New Defects reported by Coverity Scan for LibreOffice
scan-admin at coverity.com
scan-admin at coverity.com
Sun Jan 7 14:19:51 UTC 2024
Hi,
Please find the latest report on new defect(s) introduced to LibreOffice found with Coverity Scan.
11 new defect(s) introduced to LibreOffice found with Coverity Scan.
46 defect(s), reported by Coverity Scan earlier, were marked fixed in the recent build analyzed by Coverity Scan.
New defect(s) Reported-by: Coverity Scan
Showing 11 of 11 defect(s)
** CID 1583700: Uninitialized variables (UNINIT)
/sc/source/core/tool/token.cxx: 3357 in ScTokenArray::AdjustReferenceOnShift(const sc::RefUpdateContext &, const ScAddress &)()
________________________________________________________________________________________________________
*** CID 1583700: Uninitialized variables (UNINIT)
/sc/source/core/tool/token.cxx: 3357 in ScTokenArray::AdjustReferenceOnShift(const sc::RefUpdateContext &, const ScAddress &)()
3351 ; // nothing
3352 }
3353 }
3354 }
3355 }
3356
>>> CID 1583700: Uninitialized variables (UNINIT)
>>> Using uninitialized value "aRes". Field "aRes.nTab" is uninitialized.
3357 return aRes;
3358 }
3359
3360 sc::RefUpdateResult ScTokenArray::AdjustReferenceOnMove(
3361 const sc::RefUpdateContext& rCxt, const ScAddress& rOldPos, const ScAddress& rNewPos )
3362 {
** CID 1583699: Uninitialized variables (UNINIT)
/sc/source/core/tool/token.cxx: 4395 in ScTokenArray::AdjustReferenceOnInsertedTab(const sc::RefUpdateInsertTabContext &, const ScAddress &)()
________________________________________________________________________________________________________
*** CID 1583699: Uninitialized variables (UNINIT)
/sc/source/core/tool/token.cxx: 4395 in ScTokenArray::AdjustReferenceOnInsertedTab(const sc::RefUpdateInsertTabContext &, const ScAddress &)()
4389 default:
4390 ; // nothing
4391 }
4392 }
4393 }
4394 }
>>> CID 1583699: Uninitialized variables (UNINIT)
>>> Using uninitialized value "aRes". Field "aRes.nTab" is uninitialized.
4395 return aRes;
4396 }
4397
4398 namespace {
4399
4400 bool adjustTabOnMove( ScAddress& rPos, const sc::RefUpdateMoveTabContext& rCxt )
** CID 1583698: (MISSING_MOVE_ASSIGNMENT)
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
/include/rtl/ref.hxx: 45 in ()
________________________________________________________________________________________________________
*** CID 1583698: (MISSING_MOVE_ASSIGNMENT)
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<XFContentContainer>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<XclExpRecordBase>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<XPropertyList>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<SvxShapeGroupAnyD>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<sdext::presenter::PresenterButton>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<configmgr::Node>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<sd::Annotation>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<SfxItemPool>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<sd::TextApiObject>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<sdr::overlay::OverlayManager>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<SwXDocumentIndexMark>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<ScAccessibleCell>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<SdrCaptionObj>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<unoidl::Entity>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<ScAccessibleCsvControl>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<connectivity::ORefVector<com::sun::star::uno::Reference<com::sun::star::beans::XPropertySet> > >" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<dbaccess::OContentHelper>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<XFFont>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<SdrMediaObj>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<oox::shape::ShapeContextHandler>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<utl::AccessibleRelationSetHelper>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<BibDataManager>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<SvxShapePolyPolygon>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<SvxShapeText>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<chart::RegressionCurveModel>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<OpenGLContext>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<chart::ChartView>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<chart::FormattedString>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<chart::BaseCoordinateSystem>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<accessibility::AccessibleGridControlTable>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<SwXTextPortion>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<oox::core::ContextHandler>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<SdrObject>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<unoidl::Provider>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<XColorList>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<chart::Axis>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<unoidl::MapCursor>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<chart::ChartController>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<sdext::presenter::<unnamed>::Element>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<SwXFieldMaster>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<sdr::SelectionController>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<MetaAction>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<<unnamed>::XclExpExternSheet>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<SwXTextSection>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<SwXTextRange>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<SwAccessibleContext>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<jfw_plugin::VendorBase>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<XclExpChLineFormat>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<SvXMLEmbeddedObjectHelper>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<XHatchList>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<chart::InternalDataProvider>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<dbaccess::OCacheSet>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<SvxTableShape>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<sdext::presenter::PresenterAccessible::AccessibleObject>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<SvXMLImportPropertyMapper>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<VCLXAccessibleListItem>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<SdrEdgeObj>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<svt::<unnamed>::EmbedEventListener_Impl>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<OutputDevice>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<configmgr::ChildAccess>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<SwXBookmark>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<chart::ChartModel>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<dbaccess::SettingsImport>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<writerperfect::exp::XMLImportContext>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<connectivity::OKeySet>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<chart::DataSeries>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<svx::SvxShowCharSetItemAcc>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<avmedia::gstreamer::FrameGrabber>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<chart::AccessibleTextHelper>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<SvXMLGraphicHelper>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<SwXReferenceMark>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<accessibility::AccessibleListBoxEntry>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<dbaui::OTableFieldDesc>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<SfxStyleSheetBase>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<frm::ORichTextFeatureDispatcher>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<SvxShapeRect>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<LwpObject>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<SwXTextField>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<XclExpChFrame>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<chart::Title>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<SdrGrafObj>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<chart::ChartTypeTemplate>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<chart::GridProperties>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<sdext::presenter::PresenterController>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<LwpVirtualLayout>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<XFFrame>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<XFCell>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<SdrPathObj>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<ScHeaderFooterTextObj>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<SwXFootnote>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<LogicalFontInstance>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<XclExpRangeFmlaBase>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<chart::ChartType>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<sd::SlideShow>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<connectivity::odbc::OResultSet>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<drawinglayer::primitive2d::BasePrimitive2D>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<sfx2::sidebar::SidebarController>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<dbaccess::ORowSetOldRowHelper>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<comphelper::OPropertyChangeMultiplexer>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<SdrPage>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<TransferDataContainer>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<SwXTextCellStyle>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<sax_fastparser::FastAttributeList>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<SdPage>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<chart::Legend>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<XMLTransformerContext>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<StgPage>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<X509Certificate_NssImpl>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<SwXTextCursor>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<vcl::table::IAccessibleTableControl>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<sdr::table::SdrTableObj>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<XFContent>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<SvXMLImportContext>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<SvxShape>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<SwXParagraph>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<SwXLineBreak>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<XclExpTableop>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<vcl::IAccessibleBrowseBox>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<<unnamed>::IntrospectionAccessStatic_Impl>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<accessibility::AccessibleShape>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<accessibility::AccessibleBrowseBoxTable>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
/include/rtl/ref.hxx: 45 in ()
39 namespace rtl
40 {
41
42 /** Template reference class for reference type.
43 */
44 template <class reference_type>
>>> CID 1583698: (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<XclExpChText>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
45 class Reference
46 {
47 /** The <b>reference_type</b> body pointer.
48 */
49 reference_type * m_pBody;
50
** CID 1583697: Low impact quality (MISSING_MOVE_ASSIGNMENT)
/include/xmloff/xmlaustp.hxx: 47 in ()
________________________________________________________________________________________________________
*** CID 1583697: Low impact quality (MISSING_MOVE_ASSIGNMENT)
/include/xmloff/xmlaustp.hxx: 47 in ()
41 }
42
43 namespace com::sun::star::uno { template <typename > class Reference; }
44
45 namespace com::sun::star::xml::sax { class XDocumentHandler; }
46 namespace xmloff { struct AutoStyleEntry; }
>>> CID 1583697: Low impact quality (MISSING_MOVE_ASSIGNMENT)
>>> Class "rtl::Reference<XMLPropertySetMapper>" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
47 namespace rtl { template <class reference_type> class Reference; }
48
49 class XMLOFF_DLLPUBLIC SvXMLAutoStylePoolP : public salhelper::SimpleReferenceObject
50 {
51 friend class Test;
52 friend class SvXMLAutoStylePoolP_Impl;
** CID 1583696: (TAINTED_SCALAR)
________________________________________________________________________________________________________
*** CID 1583696: (TAINTED_SCALAR)
/dbaccess/source/filter/hsqldb/rowinputbinary.cxx: 247 in dbahsql::HsqlRowInputStream::readOneRow(const std::vector<dbahsql::ColumnDefinition, std::allocator<dbahsql::ColumnDefinition>> &)()
241 std::vector<Any> aData;
242
243 for (size_t i = 0; i < nLen; ++i)
244 {
245 if (checkNull())
246 {
>>> CID 1583696: (TAINTED_SCALAR)
>>> Passing tainted expression "aData->_M_impl" to "emplace_back", which uses it as a loop boundary.
247 aData.emplace_back();
248 continue;
249 }
250
251 sal_Int32 nType = nColTypes[i].getDataType();
252
/dbaccess/source/filter/hsqldb/rowinputbinary.cxx: 375 in dbahsql::HsqlRowInputStream::readOneRow(const std::vector<dbahsql::ColumnDefinition, std::allocator<dbahsql::ColumnDefinition>> &)()
369 sal_uInt8 nBool = 0;
370 m_pStream->ReadUChar(nBool);
371 aData.emplace_back(static_cast<bool>(nBool));
372 }
373 break;
374 case DataType::OTHER:
>>> CID 1583696: (TAINTED_SCALAR)
>>> Passing tainted expression "aData->_M_impl" to "emplace_back", which uses it as a loop boundary.
375 aData.emplace_back(); // TODO
376 break;
377 case DataType::BINARY:
378 case DataType::VARBINARY:
379 case DataType::LONGVARBINARY:
380 {
** CID 1583695: Uninitialized variables (UNINIT)
/sc/source/core/tool/token.cxx: 4323 in ScTokenArray::AdjustReferenceOnDeletedTab(const sc::RefUpdateDeleteTabContext &, const ScAddress &)()
________________________________________________________________________________________________________
*** CID 1583695: Uninitialized variables (UNINIT)
/sc/source/core/tool/token.cxx: 4323 in ScTokenArray::AdjustReferenceOnDeletedTab(const sc::RefUpdateDeleteTabContext &, const ScAddress &)()
4317 default:
4318 ; // nothing
4319 }
4320 }
4321 }
4322 }
>>> CID 1583695: Uninitialized variables (UNINIT)
>>> Using uninitialized value "aRes". Field "aRes.nTab" is uninitialized.
4323 return aRes;
4324 }
4325
4326 sc::RefUpdateResult ScTokenArray::AdjustReferenceOnInsertedTab( const sc::RefUpdateInsertTabContext& rCxt, const ScAddress& rOldPos )
4327 {
4328 sc::RefUpdateResult aRes;
** CID 1583694: Uninitialized variables (UNINIT)
/sc/source/core/tool/token.cxx: 3367 in ScTokenArray::AdjustReferenceOnMove(const sc::RefUpdateContext &, const ScAddress &, const ScAddress &)()
________________________________________________________________________________________________________
*** CID 1583694: Uninitialized variables (UNINIT)
/sc/source/core/tool/token.cxx: 3367 in ScTokenArray::AdjustReferenceOnMove(const sc::RefUpdateContext &, const ScAddress &, const ScAddress &)()
3361 const sc::RefUpdateContext& rCxt, const ScAddress& rOldPos, const ScAddress& rNewPos )
3362 {
3363 sc::RefUpdateResult aRes;
3364
3365 if (!rCxt.mnColDelta && !rCxt.mnRowDelta && !rCxt.mnTabDelta)
3366 // The cell hasn't moved at all.
>>> CID 1583694: Uninitialized variables (UNINIT)
>>> Using uninitialized value "aRes". Field "aRes.nTab" is uninitialized.
3367 return aRes;
3368
3369 // When moving, the range in the context is the destination range. We need
3370 // to use the old range prior to the move for hit analysis.
3371 ScRange aOldRange = rCxt.maRange;
3372 ScRange aErrorMoveRange( ScAddress::UNINITIALIZED );
** CID 1583693: Uninitialized members (UNINIT_CTOR)
/sc/source/core/data/refupdatecontext.cxx: 99 in sc::RefUpdateResult::RefUpdateResult()()
________________________________________________________________________________________________________
*** CID 1583693: Uninitialized members (UNINIT_CTOR)
/sc/source/core/data/refupdatecontext.cxx: 99 in sc::RefUpdateResult::RefUpdateResult()()
93
94 ColumnBlockPosition* RefUpdateContext::getBlockPosition(SCTAB nTab, SCCOL nCol)
95 {
96 return mpBlockPos ? mpBlockPos->getBlockPosition(nTab, nCol) : nullptr;
97 }
98
>>> CID 1583693: Uninitialized members (UNINIT_CTOR)
>>> Non-static class member "nTab" is not initialized in this constructor nor in any functions that it calls.
99 RefUpdateResult::RefUpdateResult() : mbValueChanged(false), mbReferenceModified(false), mbNameModified(false) {}
100
101 RefUpdateInsertTabContext::RefUpdateInsertTabContext(ScDocument& rDoc, SCTAB nInsertPos, SCTAB nSheets) :
102 mrDoc(rDoc), mnInsertPos(nInsertPos), mnSheets(nSheets) {}
103
104 RefUpdateDeleteTabContext::RefUpdateDeleteTabContext(ScDocument& rDoc, SCTAB nDeletePos, SCTAB nSheets) :
** CID 1583692: (UNINIT)
/sc/source/core/tool/token.cxx: 3820 in ScTokenArray::AdjustReferenceInName(const sc::RefUpdateContext &, const ScAddress &)()
/sc/source/core/tool/token.cxx: 4079 in ScTokenArray::AdjustReferenceInName(const sc::RefUpdateContext &, const ScAddress &)()
________________________________________________________________________________________________________
*** CID 1583692: (UNINIT)
/sc/source/core/tool/token.cxx: 3820 in ScTokenArray::AdjustReferenceInName(const sc::RefUpdateContext &, const ScAddress &)()
3814 return AdjustReferenceInMovedName(rCxt, rPos);
3815
3816 sc::RefUpdateResult aRes;
3817
3818 if (rCxt.meMode == URM_COPY)
3819 // Copying cells does not modify named expressions.
>>> CID 1583692: (UNINIT)
>>> Using uninitialized value "aRes". Field "aRes.nTab" is uninitialized.
3820 return aRes;
3821
3822 TokenPointers aPtrs( pCode.get(), nLen, pRPN, nRPN);
3823 for (size_t j=0; j<2; ++j)
3824 {
3825 FormulaToken** pp = aPtrs.maPointerRange[j].mpStart;
/sc/source/core/tool/token.cxx: 4079 in ScTokenArray::AdjustReferenceInName(const sc::RefUpdateContext &, const ScAddress &)()
4073 default:
4074 ;
4075 }
4076 }
4077 }
4078
>>> CID 1583692: (UNINIT)
>>> Using uninitialized value "aRes". Field "aRes.nTab" is uninitialized.
4079 return aRes;
4080 }
4081
4082 sc::RefUpdateResult ScTokenArray::AdjustReferenceInMovedName( const sc::RefUpdateContext& rCxt, const ScAddress& rPos )
4083 {
4084 // When moving, the range is the destination range.
** CID 1583691: Uninitialized variables (UNINIT)
/sc/source/core/tool/token.cxx: 4416 in ScTokenArray::AdjustReferenceOnMovedTab(const sc::RefUpdateMoveTabContext &, const ScAddress &)()
________________________________________________________________________________________________________
*** CID 1583691: Uninitialized variables (UNINIT)
/sc/source/core/tool/token.cxx: 4416 in ScTokenArray::AdjustReferenceOnMovedTab(const sc::RefUpdateMoveTabContext &, const ScAddress &)()
4410 }
4411
4412 sc::RefUpdateResult ScTokenArray::AdjustReferenceOnMovedTab( const sc::RefUpdateMoveTabContext& rCxt, const ScAddress& rOldPos )
4413 {
4414 sc::RefUpdateResult aRes;
4415 if (rCxt.mnOldPos == rCxt.mnNewPos)
>>> CID 1583691: Uninitialized variables (UNINIT)
>>> Using uninitialized value "aRes". Field "aRes.nTab" is uninitialized.
4416 return aRes;
4417
4418 ScAddress aNewPos = rOldPos;
4419 if (adjustTabOnMove(aNewPos, rCxt))
4420 {
4421 aRes.mbReferenceModified = true;
** CID 1364016: Low impact quality (MISSING_MOVE_ASSIGNMENT)
/include/com/sun/star/uno/Any.h: 57 in ()
________________________________________________________________________________________________________
*** CID 1364016: Low impact quality (MISSING_MOVE_ASSIGNMENT)
/include/com/sun/star/uno/Any.h: 57 in ()
51 binary C representation of uno_Any.
52 You can insert a value by using the <<= operators.
53 No any can hold an any. You can extract values from an any by using the >>= operators which
54 return true if the any contains an assignable value (no data loss), e.g. the any contains a
55 short and you >>= it into a long variable.
56 */
>>> CID 1364016: Low impact quality (MISSING_MOVE_ASSIGNMENT)
>>> Class "com::sun::star::uno::Any" may benefit from adding a move assignment operator. See other events which show the copy assignment operator being applied to rvalues, where a move assignment may be faster.
57 class SAL_WARN_UNUSED SAL_DLLPUBLIC_RTTI Any : public uno_Any
58 {
59 public:
60 /// @cond INTERNAL
61 // these are here to force memory de/allocation to sal lib.
62 static void * SAL_CALL operator new ( size_t nSize )
________________________________________________________________________________________________________
To view the defects in Coverity Scan visit, https://u15810271.ct.sendgrid.net/ls/click?upn=HRESupC-2F2Czv4BOaCWWCy7my0P0qcxCbhZ31OYv50ypSs1kiFPuCn2xFdlMIFBirii0zZ9j2-2F9F2XPBcBm2BNnPiSHxWPOELPnIxzXoBNaw-3DOPQ8_OTq2XUZbbipYjyLSo6GRo-2FpVxQ9OzkDINu9UTS-2FQhSdO0F0jQniitrGlNxDIzPJiEbA3AZksirPwIvs32K16ISog-2FE4rslR-2BWXYEQR6eZOr9QV5xrMJceDUSfI37FZ1Ycy3NZOQCwxmycVGlDs8MTDYS7cmicxuh27sIHtVMj3ZZodJa-2FkkZlcWQG1xE87hli4nZQWSq4uSMu5xHj4JsEmhA8kEUOpby8Gc4M-2FMMGzg-3D
More information about the LibreOffice
mailing list