aw/valentina
1
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Remove Q_COMPILER_RVALUE_REFS.

Browse Source
This commit is contained in:
Roman Telezhynskyi 2024-02-19 11:14:02 +02:00
parent 47a159c6aa
commit 827b82e3f6
94 changed files with 68 additions and 213 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/libs/qmuparser/qmuparsercallback.cpp
View File

@ -237,7 +237,6 @@ auto QmuParserCallback::operator=(const QmuParserCallback &a_Fun) -> QmuParserCa
return *this; return *this;
} }
#ifdef Q_COMPILER_RVALUE_REFS
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
QmuParserCallback::QmuParserCallback(QmuParserCallback &&a_Fun) noexcept QmuParserCallback::QmuParserCallback(QmuParserCallback &&a_Fun) noexcept
: d(std::move(a_Fun.d)) : d(std::move(a_Fun.d))
@ -250,7 +249,6 @@ auto QmuParserCallback::operator=(QmuParserCallback &&a_Fun) noexcept -> QmuPars
std::swap(d, a_Fun.d); std::swap(d, a_Fun.d);
return *this; return *this;
} }
#endif
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
/** /**

3
src/libs/qmuparser/qmuparsercallback.h
View File

@ -84,11 +84,8 @@ public:
QmuParserCallback(); QmuParserCallback();
QmuParserCallback(const QmuParserCallback &a_Fun); QmuParserCallback(const QmuParserCallback &a_Fun);
auto operator=(const QmuParserCallback &a_Fun) -> QmuParserCallback &; auto operator=(const QmuParserCallback &a_Fun) -> QmuParserCallback &;
#ifdef Q_COMPILER_RVALUE_REFS
QmuParserCallback(QmuParserCallback &&a_Fun) noexcept; QmuParserCallback(QmuParserCallback &&a_Fun) noexcept;
auto operator=(QmuParserCallback &&a_Fun) noexcept -> QmuParserCallback &; auto operator=(QmuParserCallback &&a_Fun) noexcept -> QmuParserCallback &;
#endif
Q_REQUIRED_RESULT auto Clone() const -> QmuParserCallback *; Q_REQUIRED_RESULT auto Clone() const -> QmuParserCallback *;

2
src/libs/vformat/knownmeasurements/vknownmeasurements.cpp
View File

@ -58,7 +58,6 @@ auto VKnownMeasurements::operator=(const VKnownMeasurements &measurements) -> VK
return *this; return *this;
} }
#ifdef Q_COMPILER_RVALUE_REFS
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
VKnownMeasurements::VKnownMeasurements(VKnownMeasurements &&paper) noexcept VKnownMeasurements::VKnownMeasurements(VKnownMeasurements &&paper) noexcept
: d(std::move(paper.d)) : d(std::move(paper.d))
@ -71,7 +70,6 @@ auto VKnownMeasurements::operator=(VKnownMeasurements &&paper) noexcept -> VKnow
std::swap(d, paper.d); std::swap(d, paper.d);
return *this; return *this;
} }
#endif
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
auto VKnownMeasurements::IsValid() const -> bool auto VKnownMeasurements::IsValid() const -> bool

3
src/libs/vformat/knownmeasurements/vknownmeasurements.h
View File

@ -45,10 +45,9 @@ public:
VKnownMeasurements(const VKnownMeasurements &measurements); VKnownMeasurements(const VKnownMeasurements &measurements);
auto operator=(const VKnownMeasurements &paper) -> VKnownMeasurements &; auto operator=(const VKnownMeasurements &paper) -> VKnownMeasurements &;
#ifdef Q_COMPILER_RVALUE_REFS
VKnownMeasurements(VKnownMeasurements &&paper) noexcept; VKnownMeasurements(VKnownMeasurements &&paper) noexcept;
auto operator=(VKnownMeasurements &&paper) noexcept -> VKnownMeasurements &; auto operator=(VKnownMeasurements &&paper) noexcept -> VKnownMeasurements &;
#endif
auto IsValid() const -> bool; auto IsValid() const -> bool;

2
src/libs/vgeometry/vabstractarc.cpp
View File

@ -86,7 +86,6 @@ auto VAbstractArc::operator=(const VAbstractArc &arc) -> VAbstractArc &
return *this; return *this;
} }
#ifdef Q_COMPILER_RVALUE_REFS
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
VAbstractArc::VAbstractArc(VAbstractArc &&arc) noexcept VAbstractArc::VAbstractArc(VAbstractArc &&arc) noexcept
: VAbstractCurve(std::move(arc)), : VAbstractCurve(std::move(arc)),
@ -101,7 +100,6 @@ auto VAbstractArc::operator=(VAbstractArc &&arc) noexcept -> VAbstractArc &
std::swap(d, arc.d); std::swap(d, arc.d);
return *this; return *this;
} }
#endif
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
VAbstractArc::~VAbstractArc() = default; VAbstractArc::~VAbstractArc() = default;

3
src/libs/vgeometry/vabstractarc.h
View File

@ -58,10 +58,9 @@ public:
~VAbstractArc() override; ~VAbstractArc() override;
auto operator=(const VAbstractArc &arc) -> VAbstractArc &; auto operator=(const VAbstractArc &arc) -> VAbstractArc &;
#ifdef Q_COMPILER_RVALUE_REFS
VAbstractArc(VAbstractArc &&arc) noexcept; VAbstractArc(VAbstractArc &&arc) noexcept;
auto operator=(VAbstractArc &&arc) noexcept -> VAbstractArc &; auto operator=(VAbstractArc &&arc) noexcept -> VAbstractArc &;
#endif
auto GetFormulaF1() const -> QString; auto GetFormulaF1() const -> QString;
void SetFormulaF1(const QString &formula, qreal value); void SetFormulaF1(const QString &formula, qreal value);

16
src/libs/vgeometry/vabstractbezier.h
View File

@ -38,17 +38,15 @@ class VAbstractBezier : public VAbstractCurve
public: public:
explicit VAbstractBezier(const GOType &type, const quint32 &idObject = NULL_ID, explicit VAbstractBezier(const GOType &type, const quint32 &idObject = NULL_ID,
const Draw &mode = Draw::Calculation); const Draw &mode = Draw::Calculation);
VAbstractBezier(const VAbstractBezier &curve) =default; VAbstractBezier(const VAbstractBezier &curve) = default;
auto operator= (const VAbstractBezier &curve) -> VAbstractBezier&; auto operator=(const VAbstractBezier &curve) -> VAbstractBezier &;
~VAbstractBezier() override =default; ~VAbstractBezier() override = default;
#ifdef Q_COMPILER_RVALUE_REFS VAbstractBezier(VAbstractBezier &&curve) noexcept = default;
VAbstractBezier(VAbstractBezier &&curve) noexcept =default; auto operator=(VAbstractBezier &&curve) noexcept -> VAbstractBezier & = default;
auto operator=(VAbstractBezier &&curve) noexcept -> VAbstractBezier & =default;
#endif
virtual auto GetC1Length() const -> qreal =0; virtual auto GetC1Length() const -> qreal = 0;
virtual auto GetC2Length() const -> qreal =0; virtual auto GetC2Length() const -> qreal = 0;
}; };
#endif // VABSTRACTBEZIER_H #endif // VABSTRACTBEZIER_H

2
src/libs/vgeometry/vabstractcubicbezier.h
View File

@ -51,10 +51,8 @@ public:
auto operator=(const VAbstractCubicBezier &curve) -> VAbstractCubicBezier &; auto operator=(const VAbstractCubicBezier &curve) -> VAbstractCubicBezier &;
~VAbstractCubicBezier() override = default; ~VAbstractCubicBezier() override = default;
#ifdef Q_COMPILER_RVALUE_REFS
VAbstractCubicBezier(VAbstractCubicBezier &&curve) noexcept = default; VAbstractCubicBezier(VAbstractCubicBezier &&curve) noexcept = default;
auto operator=(VAbstractCubicBezier &&curve) noexcept -> VAbstractCubicBezier & = default; auto operator=(VAbstractCubicBezier &&curve) noexcept -> VAbstractCubicBezier & = default;
#endif
virtual auto GetP1() const -> VPointF = 0; virtual auto GetP1() const -> VPointF = 0;
virtual auto GetP2() const -> VPointF = 0; virtual auto GetP2() const -> VPointF = 0;

2
src/libs/vgeometry/vabstractcubicbezierpath.h
View File

@ -57,10 +57,8 @@ public:
auto operator=(const VAbstractCubicBezierPath &curve) -> VAbstractCubicBezierPath &; auto operator=(const VAbstractCubicBezierPath &curve) -> VAbstractCubicBezierPath &;
~VAbstractCubicBezierPath() override; ~VAbstractCubicBezierPath() override;
#ifdef Q_COMPILER_RVALUE_REFS
VAbstractCubicBezierPath(VAbstractCubicBezierPath &&curve) noexcept = default; VAbstractCubicBezierPath(VAbstractCubicBezierPath &&curve) noexcept = default;
auto operator=(VAbstractCubicBezierPath &&curve) noexcept -> VAbstractCubicBezierPath & = default; auto operator=(VAbstractCubicBezierPath &&curve) noexcept -> VAbstractCubicBezierPath & = default;
#endif
virtual auto CountSubSpl() const -> vsizetype = 0; virtual auto CountSubSpl() const -> vsizetype = 0;
virtual auto CountPoints() const -> vsizetype = 0; virtual auto CountPoints() const -> vsizetype = 0;

2
src/libs/vgeometry/vabstractcurve.cpp
View File

@ -96,7 +96,6 @@ auto VAbstractCurve::operator=(const VAbstractCurve &curve) -> VAbstractCurve &
return *this; return *this;
} }
#ifdef Q_COMPILER_RVALUE_REFS
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
VAbstractCurve::VAbstractCurve(VAbstractCurve &&curve) noexcept VAbstractCurve::VAbstractCurve(VAbstractCurve &&curve) noexcept
: VGObject(std::move(curve)), : VGObject(std::move(curve)),
@ -111,7 +110,6 @@ auto VAbstractCurve::operator=(VAbstractCurve &&curve) noexcept -> VAbstractCurv
std::swap(d, curve.d); std::swap(d, curve.d);
return *this; return *this;
} }
#endif
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
VAbstractCurve::~VAbstractCurve() = default; VAbstractCurve::~VAbstractCurve() = default;

3
src/libs/vgeometry/vabstractcurve.h
View File

@ -58,10 +58,9 @@ public:
~VAbstractCurve() override; ~VAbstractCurve() override;
auto operator=(const VAbstractCurve &curve) -> VAbstractCurve &; auto operator=(const VAbstractCurve &curve) -> VAbstractCurve &;
#ifdef Q_COMPILER_RVALUE_REFS
VAbstractCurve(VAbstractCurve &&curve) noexcept; VAbstractCurve(VAbstractCurve &&curve) noexcept;
auto operator=(VAbstractCurve &&curve) noexcept -> VAbstractCurve &; auto operator=(VAbstractCurve &&curve) noexcept -> VAbstractCurve &;
#endif
virtual auto GetPoints() const -> QVector<QPointF> = 0; virtual auto GetPoints() const -> QVector<QPointF> = 0;
static auto GetSegmentPoints(const QVector<QPointF> &points, const QPointF &begin, const QPointF &end, bool reverse, static auto GetSegmentPoints(const QVector<QPointF> &points, const QPointF &begin, const QPointF &end, bool reverse,

2
src/libs/vgeometry/varc.cpp
View File

@ -118,7 +118,6 @@ auto VArc::operator=(const VArc &arc) -> VArc &
return *this; return *this;
} }
#ifdef Q_COMPILER_RVALUE_REFS
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
VArc::VArc(VArc &&arc) noexcept VArc::VArc(VArc &&arc) noexcept
: VAbstractArc(std::move(arc)), : VAbstractArc(std::move(arc)),
@ -133,7 +132,6 @@ auto VArc::operator=(VArc &&arc) noexcept -> VArc &
std::swap(d, arc.d); std::swap(d, arc.d);
return *this; return *this;
} }
#endif
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
auto VArc::Rotate(const QPointF &originPoint, qreal degrees, const QString &prefix) const -> VArc auto VArc::Rotate(const QPointF &originPoint, qreal degrees, const QString &prefix) const -> VArc

3
src/libs/vgeometry/varc.h
View File

@ -64,10 +64,9 @@ public:
~VArc() override; ~VArc() override;
auto operator=(const VArc &arc) -> VArc &; auto operator=(const VArc &arc) -> VArc &;
#ifdef Q_COMPILER_RVALUE_REFS
VArc(VArc &&arc) noexcept; VArc(VArc &&arc) noexcept;
auto operator=(VArc &&arc) noexcept -> VArc &; auto operator=(VArc &&arc) noexcept -> VArc &;
#endif
auto GetFormulaRadius() const -> QString; auto GetFormulaRadius() const -> QString;
void SetFormulaRadius(const QString &formula, qreal value); void SetFormulaRadius(const QString &formula, qreal value);

2
src/libs/vgeometry/vcubicbezier.cpp
View File

@ -63,7 +63,6 @@ auto VCubicBezier::operator=(const VCubicBezier &curve) -> VCubicBezier &
return *this; return *this;
} }
#ifdef Q_COMPILER_RVALUE_REFS
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
VCubicBezier::VCubicBezier(VCubicBezier &&curve) noexcept VCubicBezier::VCubicBezier(VCubicBezier &&curve) noexcept
: VAbstractCubicBezier(std::move(curve)), : VAbstractCubicBezier(std::move(curve)),
@ -78,7 +77,6 @@ auto VCubicBezier::operator=(VCubicBezier &&curve) noexcept -> VCubicBezier &
std::swap(d, curve.d); std::swap(d, curve.d);
return *this; return *this;
} }
#endif
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
auto VCubicBezier::Rotate(const QPointF &originPoint, qreal degrees, const QString &prefix) const -> VCubicBezier auto VCubicBezier::Rotate(const QPointF &originPoint, qreal degrees, const QString &prefix) const -> VCubicBezier

3
src/libs/vgeometry/vcubicbezier.h
View File

@ -54,10 +54,9 @@ public:
~VCubicBezier() override; ~VCubicBezier() override;
auto operator=(const VCubicBezier &curve) -> VCubicBezier &; auto operator=(const VCubicBezier &curve) -> VCubicBezier &;
#ifdef Q_COMPILER_RVALUE_REFS
VCubicBezier(VCubicBezier &&curve) noexcept; VCubicBezier(VCubicBezier &&curve) noexcept;
auto operator=(VCubicBezier &&curve) noexcept -> VCubicBezier &; auto operator=(VCubicBezier &&curve) noexcept -> VCubicBezier &;
#endif
auto GetP1() const -> VPointF override; auto GetP1() const -> VPointF override;
void SetP1(const VPointF &p); void SetP1(const VPointF &p);

2
src/libs/vgeometry/vcubicbezierpath.cpp
View File

@ -74,7 +74,6 @@ auto VCubicBezierPath::operator=(const VCubicBezierPath &curve) -> VCubicBezierP
return *this; return *this;
} }
#ifdef Q_COMPILER_RVALUE_REFS
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
VCubicBezierPath::VCubicBezierPath(VCubicBezierPath &&curve) noexcept VCubicBezierPath::VCubicBezierPath(VCubicBezierPath &&curve) noexcept
: VAbstractCubicBezierPath(std::move(curve)), : VAbstractCubicBezierPath(std::move(curve)),
@ -89,7 +88,6 @@ auto VCubicBezierPath::operator=(VCubicBezierPath &&curve) noexcept -> VCubicBez
std::swap(d, curve.d); std::swap(d, curve.d);
return *this; return *this;
} }
#endif
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
auto VCubicBezierPath::Rotate(const QPointF &originPoint, qreal degrees, const QString &prefix) const auto VCubicBezierPath::Rotate(const QPointF &originPoint, qreal degrees, const QString &prefix) const

3
src/libs/vgeometry/vcubicbezierpath.h
View File

@ -56,10 +56,9 @@ public:
~VCubicBezierPath() override; ~VCubicBezierPath() override;
auto operator=(const VCubicBezierPath &curve) -> VCubicBezierPath &; auto operator=(const VCubicBezierPath &curve) -> VCubicBezierPath &;
#ifdef Q_COMPILER_RVALUE_REFS
VCubicBezierPath(VCubicBezierPath &&curve) noexcept; VCubicBezierPath(VCubicBezierPath &&curve) noexcept;
auto operator=(VCubicBezierPath &&curve) noexcept -> VCubicBezierPath &; auto operator=(VCubicBezierPath &&curve) noexcept -> VCubicBezierPath &;
#endif
auto operator[](vsizetype indx) -> VPointF &; auto operator[](vsizetype indx) -> VPointF &;

2
src/libs/vgeometry/vellipticalarc.cpp
View File

@ -320,7 +320,6 @@ auto VEllipticalArc::operator=(const VEllipticalArc &arc) -> VEllipticalArc &
return *this; return *this;
} }
#ifdef Q_COMPILER_RVALUE_REFS
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
VEllipticalArc::VEllipticalArc(VEllipticalArc &&arc) noexcept VEllipticalArc::VEllipticalArc(VEllipticalArc &&arc) noexcept
: VAbstractArc(std::move(arc)), : VAbstractArc(std::move(arc)),
@ -335,7 +334,6 @@ auto VEllipticalArc::operator=(VEllipticalArc &&arc) noexcept -> VEllipticalArc
std::swap(d, arc.d); std::swap(d, arc.d);
return *this; return *this;
} }
#endif
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
auto VEllipticalArc::Rotate(QPointF originPoint, qreal degrees, const QString &prefix) const -> VEllipticalArc auto VEllipticalArc::Rotate(QPointF originPoint, qreal degrees, const QString &prefix) const -> VEllipticalArc

3
src/libs/vgeometry/vellipticalarc.h
View File

@ -68,10 +68,9 @@ public:
~VEllipticalArc() override; ~VEllipticalArc() override;
auto operator=(const VEllipticalArc &arc) -> VEllipticalArc &; auto operator=(const VEllipticalArc &arc) -> VEllipticalArc &;
#ifdef Q_COMPILER_RVALUE_REFS
VEllipticalArc(VEllipticalArc &&arc) noexcept; VEllipticalArc(VEllipticalArc &&arc) noexcept;
auto operator=(VEllipticalArc &&arc) noexcept -> VEllipticalArc &; auto operator=(VEllipticalArc &&arc) noexcept -> VEllipticalArc &;
#endif
auto GetFormulaRotationAngle() const -> QString; auto GetFormulaRotationAngle() const -> QString;
void SetFormulaRotationAngle(const QString &formula, qreal value); void SetFormulaRotationAngle(const QString &formula, qreal value);

2
src/libs/vgeometry/vgobject.cpp
View File

@ -125,7 +125,6 @@ auto VGObject::operator=(const VGObject &obj) -> VGObject &
return *this; return *this;
} }
#ifdef Q_COMPILER_RVALUE_REFS
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
VGObject::VGObject(VGObject &&obj) noexcept VGObject::VGObject(VGObject &&obj) noexcept
: d(std::move(obj.d)) : d(std::move(obj.d))
@ -138,7 +137,6 @@ auto VGObject::operator=(VGObject &&obj) noexcept -> VGObject &
std::swap(d, obj.d); std::swap(d, obj.d);
return *this; return *this;
} }
#endif
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
VGObject::~VGObject() = default; VGObject::~VGObject() = default;

3
src/libs/vgeometry/vgobject.h
View File

@ -63,10 +63,9 @@ public:
virtual ~VGObject(); virtual ~VGObject();
auto operator=(const VGObject &obj) -> VGObject &; auto operator=(const VGObject &obj) -> VGObject &;
#ifdef Q_COMPILER_RVALUE_REFS
VGObject(VGObject &&obj) noexcept; VGObject(VGObject &&obj) noexcept;
auto operator=(VGObject &&obj) noexcept -> VGObject &; auto operator=(VGObject &&obj) noexcept -> VGObject &;
#endif
auto getIdObject() const -> quint32; auto getIdObject() const -> quint32;
void setIdObject(const quint32 &value); void setIdObject(const quint32 &value);

2
src/libs/vgeometry/vplacelabelitem.cpp
View File

@ -235,7 +235,6 @@ auto VPlaceLabelItem::operator=(const VPlaceLabelItem &item) -> VPlaceLabelItem
return *this; return *this;
} }
#ifdef Q_COMPILER_RVALUE_REFS
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
VPlaceLabelItem::VPlaceLabelItem(VPlaceLabelItem &&item) noexcept VPlaceLabelItem::VPlaceLabelItem(VPlaceLabelItem &&item) noexcept
: VPointF(std::move(item)), : VPointF(std::move(item)),
@ -250,4 +249,3 @@ auto VPlaceLabelItem::operator=(VPlaceLabelItem &&item) noexcept -> VPlaceLabelI
std::swap(d, item.d); std::swap(d, item.d);
return *this; return *this;
} }
#endif

3
src/libs/vgeometry/vplacelabelitem.h
View File

@ -47,10 +47,9 @@ public:
~VPlaceLabelItem() override; ~VPlaceLabelItem() override;
auto operator=(const VPlaceLabelItem &item) -> VPlaceLabelItem &; auto operator=(const VPlaceLabelItem &item) -> VPlaceLabelItem &;
#ifdef Q_COMPILER_RVALUE_REFS
VPlaceLabelItem(VPlaceLabelItem &&item) noexcept; VPlaceLabelItem(VPlaceLabelItem &&item) noexcept;
auto operator=(VPlaceLabelItem &&item) noexcept -> VPlaceLabelItem &; auto operator=(VPlaceLabelItem &&item) noexcept -> VPlaceLabelItem &;
#endif
auto GetWidthFormula() const -> QString; auto GetWidthFormula() const -> QString;
auto GetWidthFormula() -> QString &; auto GetWidthFormula() -> QString &;

2
src/libs/vgeometry/vpointf.cpp
View File

@ -111,7 +111,6 @@ auto VPointF::operator=(const VPointF &point) -> VPointF &
return *this; return *this;
} }
#ifdef Q_COMPILER_RVALUE_REFS
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
VPointF::VPointF(VPointF &&point) noexcept VPointF::VPointF(VPointF &&point) noexcept
: VGObject(std::move(point)), : VGObject(std::move(point)),
@ -126,7 +125,6 @@ auto VPointF::operator=(VPointF &&point) noexcept -> VPointF &
std::swap(d, point.d); std::swap(d, point.d);
return *this; return *this;
} }
#endif
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
VPointF::operator QPointF() const VPointF::operator QPointF() const

3
src/libs/vgeometry/vpointf.h
View File

@ -59,10 +59,9 @@ public:
~VPointF() override; ~VPointF() override;
auto operator=(const VPointF &point) -> VPointF &; auto operator=(const VPointF &point) -> VPointF &;
#ifdef Q_COMPILER_RVALUE_REFS
VPointF(VPointF &&point) noexcept; VPointF(VPointF &&point) noexcept;
auto operator=(VPointF &&point) noexcept -> VPointF &; auto operator=(VPointF &&point) noexcept -> VPointF &;
#endif
explicit operator QPointF() const; explicit operator QPointF() const;
auto Rotate(const QPointF &originPoint, qreal degrees, const QString &prefix = QString()) const -> VPointF; auto Rotate(const QPointF &originPoint, qreal degrees, const QString &prefix = QString()) const -> VPointF;

2
src/libs/vgeometry/vspline.cpp
View File

@ -266,7 +266,6 @@ auto VSpline::operator=(const VSpline &spline) -> VSpline &
return *this; return *this;
} }
#ifdef Q_COMPILER_RVALUE_REFS
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
VSpline::VSpline(VSpline &&spline) noexcept VSpline::VSpline(VSpline &&spline) noexcept
: VAbstractCubicBezier(std::move(spline)), : VAbstractCubicBezier(std::move(spline)),
@ -281,7 +280,6 @@ auto VSpline::operator=(VSpline &&spline) noexcept -> VSpline &
std::swap(d, spline.d); std::swap(d, spline.d);
return *this; return *this;
} }
#endif
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
/** /**

3
src/libs/vgeometry/vspline.h
View File

@ -64,10 +64,9 @@ public:
~VSpline() override; ~VSpline() override;
auto operator=(const VSpline &spline) -> VSpline &; auto operator=(const VSpline &spline) -> VSpline &;
#ifdef Q_COMPILER_RVALUE_REFS
VSpline(VSpline &&spline) noexcept; VSpline(VSpline &&spline) noexcept;
auto operator=(VSpline &&spline) noexcept -> VSpline &; auto operator=(VSpline &&spline) noexcept -> VSpline &;
#endif
auto GetP1() const -> VPointF override; auto GetP1() const -> VPointF override;
void SetP1(const VPointF &p); void SetP1(const VPointF &p);

2
src/libs/vgeometry/vsplinepath.cpp
View File

@ -312,7 +312,6 @@ auto VSplinePath::operator=(const VSplinePath &path) -> VSplinePath &
return *this; return *this;
} }
#ifdef Q_COMPILER_RVALUE_REFS
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
VSplinePath::VSplinePath(VSplinePath &&splPath) noexcept VSplinePath::VSplinePath(VSplinePath &&splPath) noexcept
: VAbstractCubicBezierPath(std::move(splPath)), : VAbstractCubicBezierPath(std::move(splPath)),
@ -327,7 +326,6 @@ auto VSplinePath::operator=(VSplinePath &&path) noexcept -> VSplinePath &
std::swap(d, path.d); std::swap(d, path.d);
return *this; return *this;
} }
#endif
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
/** /**

3
src/libs/vgeometry/vsplinepath.h
View File

@ -66,10 +66,9 @@ public:
auto operator[](vsizetype indx) -> VSplinePoint &; auto operator[](vsizetype indx) -> VSplinePoint &;
auto operator=(const VSplinePath &path) -> VSplinePath &; auto operator=(const VSplinePath &path) -> VSplinePath &;
#ifdef Q_COMPILER_RVALUE_REFS
VSplinePath(VSplinePath &&splPath) noexcept; VSplinePath(VSplinePath &&splPath) noexcept;
auto operator=(VSplinePath &&path) noexcept -> VSplinePath &; auto operator=(VSplinePath &&path) noexcept -> VSplinePath &;
#endif
void append(const VSplinePoint &point); void append(const VSplinePoint &point);

4
src/libs/vgeometry/vsplinepoint.cpp
View File

@ -71,7 +71,6 @@ auto VFSplinePoint::operator=(const VFSplinePoint &point) -> VFSplinePoint &
return *this; return *this;
} }
#ifdef Q_COMPILER_RVALUE_REFS
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
VFSplinePoint::VFSplinePoint(VFSplinePoint &&point) noexcept VFSplinePoint::VFSplinePoint(VFSplinePoint &&point) noexcept
: d(std::move(point.d)) : d(std::move(point.d))
@ -84,7 +83,6 @@ auto VFSplinePoint::operator=(VFSplinePoint &&point) noexcept -> VFSplinePoint &
std::swap(d, point.d); std::swap(d, point.d);
return *this; return *this;
} }
#endif
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
VFSplinePoint::~VFSplinePoint() = default; VFSplinePoint::~VFSplinePoint() = default;
@ -227,7 +225,6 @@ auto VSplinePoint::operator=(const VSplinePoint &point) -> VSplinePoint &
return *this; return *this;
} }
#ifdef Q_COMPILER_RVALUE_REFS
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
VSplinePoint::VSplinePoint(VSplinePoint &&point) noexcept VSplinePoint::VSplinePoint(VSplinePoint &&point) noexcept
: d(std::move(point.d)) : d(std::move(point.d))
@ -240,7 +237,6 @@ auto VSplinePoint::operator=(VSplinePoint &&point) noexcept -> VSplinePoint &
std::swap(d, point.d); std::swap(d, point.d);
return *this; return *this;
} }
#endif
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
VSplinePoint::~VSplinePoint() = default; VSplinePoint::~VSplinePoint() = default;

6
src/libs/vgeometry/vsplinepoint.h
View File

@ -52,10 +52,9 @@ public:
~VFSplinePoint(); ~VFSplinePoint();
auto operator=(const VFSplinePoint &point) -> VFSplinePoint &; auto operator=(const VFSplinePoint &point) -> VFSplinePoint &;
#ifdef Q_COMPILER_RVALUE_REFS
VFSplinePoint(VFSplinePoint &&point) noexcept; VFSplinePoint(VFSplinePoint &&point) noexcept;
auto operator=(VFSplinePoint &&point) noexcept -> VFSplinePoint &; auto operator=(VFSplinePoint &&point) noexcept -> VFSplinePoint &;
#endif
auto P() const -> VPointF; auto P() const -> VPointF;
void SetP(const VPointF &value); void SetP(const VPointF &value);
@ -91,10 +90,9 @@ public:
~VSplinePoint(); ~VSplinePoint();
auto operator=(const VSplinePoint &point) -> VSplinePoint &; auto operator=(const VSplinePoint &point) -> VSplinePoint &;
#ifdef Q_COMPILER_RVALUE_REFS
VSplinePoint(VSplinePoint &&point) noexcept; VSplinePoint(VSplinePoint &&point) noexcept;
auto operator=(VSplinePoint &&point) noexcept -> VSplinePoint &; auto operator=(VSplinePoint &&point) noexcept -> VSplinePoint &;
#endif
auto P() const -> VPointF; auto P() const -> VPointF;
void SetP(const VPointF &value); void SetP(const VPointF &value);

2
src/libs/vlayout/vabstractpiece.cpp
View File

@ -912,7 +912,6 @@ auto VAbstractPiece::operator=(const VAbstractPiece &piece) -> VAbstractPiece &
return *this; return *this;
} }
#ifdef Q_COMPILER_RVALUE_REFS
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
VAbstractPiece::VAbstractPiece(VAbstractPiece &&piece) noexcept VAbstractPiece::VAbstractPiece(VAbstractPiece &&piece) noexcept
: d(std::move(piece.d)) : d(std::move(piece.d))
@ -925,7 +924,6 @@ auto VAbstractPiece::operator=(VAbstractPiece &&piece) noexcept -> VAbstractPiec
std::swap(d, piece.d); std::swap(d, piece.d);
return *this; return *this;
} }
#endif
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
VAbstractPiece::~VAbstractPiece() = default; VAbstractPiece::~VAbstractPiece() = default;

3
src/libs/vlayout/vabstractpiece.h
View File

@ -74,10 +74,9 @@ public:
virtual ~VAbstractPiece(); virtual ~VAbstractPiece();
auto operator=(const VAbstractPiece &piece) -> VAbstractPiece &; auto operator=(const VAbstractPiece &piece) -> VAbstractPiece &;
#ifdef Q_COMPILER_RVALUE_REFS
VAbstractPiece(VAbstractPiece &&piece) noexcept; VAbstractPiece(VAbstractPiece &&piece) noexcept;
auto operator=(VAbstractPiece &&piece) noexcept -> VAbstractPiece &; auto operator=(VAbstractPiece &&piece) noexcept -> VAbstractPiece &;
#endif
auto GetName() const -> QString; auto GetName() const -> QString;
void SetName(const QString &value); void SetName(const QString &value);

2
src/libs/vlayout/vbestsquare.cpp
View File

@ -68,7 +68,6 @@ auto VBestSquare::operator=(const VBestSquare &res) -> VBestSquare &
return *this; return *this;
} }
#ifdef Q_COMPILER_RVALUE_REFS
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
VBestSquare::VBestSquare(VBestSquare &&res) noexcept VBestSquare::VBestSquare(VBestSquare &&res) noexcept
: d(std::move(res.d)) : d(std::move(res.d))
@ -81,7 +80,6 @@ auto VBestSquare::operator=(VBestSquare &&res) noexcept -> VBestSquare &
std::swap(d, res.d); std::swap(d, res.d);
return *this; return *this;
} }
#endif
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
void VBestSquare::NewResult(const VBestSquareResData &data) void VBestSquare::NewResult(const VBestSquareResData &data)

3
src/libs/vlayout/vbestsquare.h
View File

@ -48,10 +48,9 @@ public:
~VBestSquare(); ~VBestSquare();
auto operator=(const VBestSquare &res) -> VBestSquare &; auto operator=(const VBestSquare &res) -> VBestSquare &;
#ifdef Q_COMPILER_RVALUE_REFS
VBestSquare(VBestSquare &&res) noexcept; VBestSquare(VBestSquare &&res) noexcept;
auto operator=(VBestSquare &&res) noexcept -> VBestSquare &; auto operator=(VBestSquare &&res) noexcept -> VBestSquare &;
#endif
void NewResult(const VBestSquareResData &data); void NewResult(const VBestSquareResData &data);
void NewResult(const VBestSquare &best); void NewResult(const VBestSquare &best);

2
src/libs/vlayout/vcontour.cpp
View File

@ -119,7 +119,6 @@ auto VContour::operator=(const VContour &contour) -> VContour &
return *this; return *this;
} }
#ifdef Q_COMPILER_RVALUE_REFS
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
VContour::VContour(VContour &&contour) noexcept VContour::VContour(VContour &&contour) noexcept
: d(std::move(contour.d)) : d(std::move(contour.d))
@ -132,7 +131,6 @@ auto VContour::operator=(VContour &&contour) noexcept -> VContour &
std::swap(d, contour.d); std::swap(d, contour.d);
return *this; return *this;
} }
#endif
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
VContour::~VContour() = default; VContour::~VContour() = default;

3
src/libs/vlayout/vcontour.h
View File

@ -55,10 +55,9 @@ public:
~VContour(); ~VContour();
auto operator=(const VContour &contour) -> VContour &; auto operator=(const VContour &contour) -> VContour &;
#ifdef Q_COMPILER_RVALUE_REFS
VContour(VContour &&contour) noexcept; VContour(VContour &&contour) noexcept;
auto operator=(VContour &&contour) noexcept -> VContour &; auto operator=(VContour &&contour) noexcept -> VContour &;
#endif
void CeateEmptySheetContour(); void CeateEmptySheetContour();

2
src/libs/vlayout/vlayoutpaper.cpp
View File

@ -79,7 +79,6 @@ auto VLayoutPaper::operator=(const VLayoutPaper &paper) -> VLayoutPaper &
return *this; return *this;
} }
#ifdef Q_COMPILER_RVALUE_REFS
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
VLayoutPaper::VLayoutPaper(VLayoutPaper &&paper) noexcept VLayoutPaper::VLayoutPaper(VLayoutPaper &&paper) noexcept
: d(std::move(paper.d)) : d(std::move(paper.d))
@ -92,7 +91,6 @@ auto VLayoutPaper::operator=(VLayoutPaper &&paper) noexcept -> VLayoutPaper &
std::swap(d, paper.d); std::swap(d, paper.d);
return *this; return *this;
} }
#endif
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
VLayoutPaper::~VLayoutPaper() = default; VLayoutPaper::~VLayoutPaper() = default;

3
src/libs/vlayout/vlayoutpaper.h
View File

@ -56,10 +56,9 @@ public:
~VLayoutPaper(); ~VLayoutPaper();
auto operator=(const VLayoutPaper &paper) -> VLayoutPaper &; auto operator=(const VLayoutPaper &paper) -> VLayoutPaper &;
#ifdef Q_COMPILER_RVALUE_REFS
VLayoutPaper(VLayoutPaper &&paper) noexcept; VLayoutPaper(VLayoutPaper &&paper) noexcept;
auto operator=(VLayoutPaper &&paper) noexcept -> VLayoutPaper &; auto operator=(VLayoutPaper &&paper) noexcept -> VLayoutPaper &;
#endif
auto GetHeight() const -> int; auto GetHeight() const -> int;
void SetHeight(int height); void SetHeight(int height);

2
src/libs/vlayout/vlayoutpiece.cpp
View File

@ -610,7 +610,6 @@ auto VLayoutPiece::operator=(const VLayoutPiece &detail) -> VLayoutPiece &
return *this; return *this;
} }
#ifdef Q_COMPILER_RVALUE_REFS
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
VLayoutPiece::VLayoutPiece(VLayoutPiece &&detail) noexcept VLayoutPiece::VLayoutPiece(VLayoutPiece &&detail) noexcept
: VAbstractPiece(std::move(detail)), : VAbstractPiece(std::move(detail)),
@ -625,7 +624,6 @@ auto VLayoutPiece::operator=(VLayoutPiece &&detail) noexcept -> VLayoutPiece &
std::swap(d, detail.d); std::swap(d, detail.d);
return *this; return *this;
} }
#endif
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
VLayoutPiece::~VLayoutPiece() = default; VLayoutPiece::~VLayoutPiece() = default;

3
src/libs/vlayout/vlayoutpiece.h
View File

@ -75,10 +75,9 @@ public:
~VLayoutPiece() override; ~VLayoutPiece() override;
auto operator=(const VLayoutPiece &detail) -> VLayoutPiece &; auto operator=(const VLayoutPiece &detail) -> VLayoutPiece &;
#ifdef Q_COMPILER_RVALUE_REFS
VLayoutPiece(VLayoutPiece &&detail) noexcept; VLayoutPiece(VLayoutPiece &&detail) noexcept;
auto operator=(VLayoutPiece &&detail) noexcept -> VLayoutPiece &; auto operator=(VLayoutPiece &&detail) noexcept -> VLayoutPiece &;
#endif
static auto Create(const VPiece &piece, vidtype id, const VContainer *pattern) -> VLayoutPiece; static auto Create(const VPiece &piece, vidtype id, const VContainer *pattern) -> VLayoutPiece;
static auto ConvertPassmarks(const VPiece &piece, const VContainer *pattern) -> QVector<VLayoutPassmark>; static auto ConvertPassmarks(const VPiece &piece, const VContainer *pattern) -> QVector<VLayoutPassmark>;

2
src/libs/vlayout/vlayoutpiecepath.cpp
View File

@ -72,7 +72,6 @@ auto VLayoutPiecePath::operator=(const VLayoutPiecePath &path) -> VLayoutPiecePa
return *this; return *this;
} }
#ifdef Q_COMPILER_RVALUE_REFS
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
VLayoutPiecePath::VLayoutPiecePath(VLayoutPiecePath &&path) noexcept VLayoutPiecePath::VLayoutPiecePath(VLayoutPiecePath &&path) noexcept
: d(std::move(path.d)) : d(std::move(path.d))
@ -85,7 +84,6 @@ auto VLayoutPiecePath::operator=(VLayoutPiecePath &&path) noexcept -> VLayoutPie
std::swap(d, path.d); std::swap(d, path.d);
return *this; return *this;
} }
#endif
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
VLayoutPiecePath::~VLayoutPiecePath() = default; VLayoutPiecePath::~VLayoutPiecePath() = default;

3
src/libs/vlayout/vlayoutpiecepath.h
View File

@ -47,10 +47,9 @@ public:
virtual ~VLayoutPiecePath(); virtual ~VLayoutPiecePath();
auto operator=(const VLayoutPiecePath &path) -> VLayoutPiecePath &; auto operator=(const VLayoutPiecePath &path) -> VLayoutPiecePath &;
#ifdef Q_COMPILER_RVALUE_REFS
VLayoutPiecePath(VLayoutPiecePath &&path) noexcept; VLayoutPiecePath(VLayoutPiecePath &&path) noexcept;
auto operator=(VLayoutPiecePath &&path) noexcept -> VLayoutPiecePath &; auto operator=(VLayoutPiecePath &&path) noexcept -> VLayoutPiecePath &;
#endif
auto GetPainterPath() const -> QPainterPath; auto GetPainterPath() const -> QPainterPath;

15
src/libs/vlayout/vposition.h
View File

@ -29,7 +29,6 @@
#ifndef VPOSITION_H #ifndef VPOSITION_H
#define VPOSITION_H #define VPOSITION_H
#include <QRunnable> #include <QRunnable>
#include <QVector> #include <QVector>
#include <QtGlobal> #include <QtGlobal>
@ -69,13 +68,13 @@ class VPosition
public: public:
VPosition() = default; VPosition() = default;
VPosition(const VPositionData &data, std::atomic_bool *stop, bool saveLength); VPosition(const VPositionData &data, std::atomic_bool *stop, bool saveLength);
VPosition(const VPosition&) = default; VPosition(const VPosition &) = default;
auto operator=(const VPosition&) -> VPosition& = default; auto operator=(const VPosition &) -> VPosition & = default;
#ifdef Q_COMPILER_RVALUE_REFS
VPosition(VPosition&&) = default; VPosition(VPosition &&) = default;
auto operator=(VPosition&&) -> VPosition& = default; auto operator=(VPosition &&) -> VPosition & = default;
#endif
~VPosition()= default; ~VPosition() = default;
void run(); void run();

2
src/libs/vlayout/vtextmanager.h
View File

@ -80,10 +80,8 @@ public:
VTextManager(const VTextManager &text) = default; VTextManager(const VTextManager &text) = default;
auto operator=(const VTextManager &text) -> VTextManager & = default; auto operator=(const VTextManager &text) -> VTextManager & = default;
#ifdef Q_COMPILER_RVALUE_REFS
VTextManager(VTextManager &&text) = default; VTextManager(VTextManager &&text) = default;
auto operator=(VTextManager &&text) -> VTextManager & = default; auto operator=(VTextManager &&text) -> VTextManager & = default;
#endif
virtual auto GetSpacing() const -> int; virtual auto GetSpacing() const -> int;

2
src/libs/vmisc/svgfont/vsvgfont.cpp
View File

@ -64,7 +64,6 @@ auto VSvgFont::operator=(const VSvgFont &font) -> VSvgFont &
return *this; return *this;
} }
#ifdef Q_COMPILER_RVALUE_REFS
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
VSvgFont::VSvgFont(VSvgFont &&font) noexcept VSvgFont::VSvgFont(VSvgFont &&font) noexcept
: d(std::move(font.d)) : d(std::move(font.d))
@ -77,7 +76,6 @@ auto VSvgFont::operator=(VSvgFont &&font) noexcept -> VSvgFont &
std::swap(d, font.d); std::swap(d, font.d);
return *this; return *this;
} }
#endif
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
void VSvgFont::SetId(const QString &id) void VSvgFont::SetId(const QString &id)

3
src/libs/vmisc/svgfont/vsvgfont.h
View File

@ -44,10 +44,9 @@ public:
~VSvgFont(); ~VSvgFont();
auto operator=(const VSvgFont &font) -> VSvgFont &; auto operator=(const VSvgFont &font) -> VSvgFont &;
#ifdef Q_COMPILER_RVALUE_REFS
VSvgFont(VSvgFont &&font) noexcept; VSvgFont(VSvgFont &&font) noexcept;
auto operator=(VSvgFont &&font) noexcept -> VSvgFont &; auto operator=(VSvgFont &&font) noexcept -> VSvgFont &;
#endif
void SetId(const QString &id); void SetId(const QString &id);
auto Id() const -> QString; auto Id() const -> QString;

2
src/libs/vmisc/svgfont/vsvgfontengine.cpp
View File

@ -139,7 +139,6 @@ auto VSvgFontEngine::ToFontUnits(qreal val, int pixelSize) const -> qreal
return val * d->m_font.UnitsPerEm() / pxSize; return val * d->m_font.UnitsPerEm() / pxSize;
} }
#ifdef Q_COMPILER_RVALUE_REFS
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
VSvgFontEngine::VSvgFontEngine(VSvgFontEngine &&engine) noexcept VSvgFontEngine::VSvgFontEngine(VSvgFontEngine &&engine) noexcept
: d(std::move(engine.d)) : d(std::move(engine.d))
@ -152,7 +151,6 @@ auto VSvgFontEngine::operator=(VSvgFontEngine &&engine) noexcept -> VSvgFontEngi
std::swap(d, engine.d); std::swap(d, engine.d);
return *this; return *this;
} }
#endif
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
void VSvgFontEngine::AddGlyph(QChar unicode, const QPainterPath &path, qreal horizAdvX) void VSvgFontEngine::AddGlyph(QChar unicode, const QPainterPath &path, qreal horizAdvX)

3
src/libs/vmisc/svgfont/vsvgfontengine.h
View File

@ -45,10 +45,9 @@ public:
~VSvgFontEngine(); ~VSvgFontEngine();
auto operator=(const VSvgFontEngine &engine) -> VSvgFontEngine &; auto operator=(const VSvgFontEngine &engine) -> VSvgFontEngine &;
#ifdef Q_COMPILER_RVALUE_REFS
VSvgFontEngine(VSvgFontEngine &&engine) noexcept; VSvgFontEngine(VSvgFontEngine &&engine) noexcept;
auto operator=(VSvgFontEngine &&engine) noexcept -> VSvgFontEngine &; auto operator=(VSvgFontEngine &&engine) noexcept -> VSvgFontEngine &;
#endif
auto Font() const -> VSvgFont; auto Font() const -> VSvgFont;
void SetFont(const VSvgFont &fnt); void SetFont(const VSvgFont &fnt);

2
src/libs/vmisc/svgfont/vsvgglyph.cpp
View File

@ -61,7 +61,6 @@ auto VSvgGlyph::operator=(const VSvgGlyph &glyph) -> VSvgGlyph &
return *this; return *this;
} }
#ifdef Q_COMPILER_RVALUE_REFS
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
VSvgGlyph::VSvgGlyph(VSvgGlyph &&glyph) noexcept VSvgGlyph::VSvgGlyph(VSvgGlyph &&glyph) noexcept
: d(std::move(glyph.d)) : d(std::move(glyph.d))
@ -74,7 +73,6 @@ auto VSvgGlyph::operator=(VSvgGlyph &&glyph) noexcept -> VSvgGlyph &
std::swap(d, glyph.d); std::swap(d, glyph.d);
return *this; return *this;
} }
#endif
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
void VSvgGlyph::SetUnicode(const QChar &unicode) void VSvgGlyph::SetUnicode(const QChar &unicode)

3
src/libs/vmisc/svgfont/vsvgglyph.h
View File

@ -42,10 +42,9 @@ public:
~VSvgGlyph(); ~VSvgGlyph();
auto operator=(const VSvgGlyph &glyph) -> VSvgGlyph &; auto operator=(const VSvgGlyph &glyph) -> VSvgGlyph &;
#ifdef Q_COMPILER_RVALUE_REFS
VSvgGlyph(VSvgGlyph &&glyph) noexcept; VSvgGlyph(VSvgGlyph &&glyph) noexcept;
auto operator=(VSvgGlyph &&glyph) noexcept -> VSvgGlyph &; auto operator=(VSvgGlyph &&glyph) noexcept -> VSvgGlyph &;
#endif
void SetUnicode(const QChar &unicode); void SetUnicode(const QChar &unicode);
auto Unicode() const -> QChar; auto Unicode() const -> QChar;

2
src/libs/vmisc/theme/vmanuallayoutstyle.h
View File

@ -42,10 +42,8 @@ public:
VManualLayoutStyle(const VManualLayoutStyle &) = default; VManualLayoutStyle(const VManualLayoutStyle &) = default;
auto operator=(const VManualLayoutStyle &) -> VManualLayoutStyle & = default; auto operator=(const VManualLayoutStyle &) -> VManualLayoutStyle & = default;
#ifdef Q_COMPILER_RVALUE_REFS
VManualLayoutStyle(VManualLayoutStyle &&) = default; VManualLayoutStyle(VManualLayoutStyle &&) = default;
auto operator=(VManualLayoutStyle &&) -> VManualLayoutStyle & = default; auto operator=(VManualLayoutStyle &&) -> VManualLayoutStyle & = default;
#endif
void LoadJson(QJsonObject const &json) override; void LoadJson(QJsonObject const &json) override;

2
src/libs/vmisc/theme/vpatternpiecestyle.h
View File

@ -42,10 +42,8 @@ public:
VPatternPieceStyle(const VPatternPieceStyle &) = default; VPatternPieceStyle(const VPatternPieceStyle &) = default;
auto operator=(const VPatternPieceStyle &) -> VPatternPieceStyle & = default; auto operator=(const VPatternPieceStyle &) -> VPatternPieceStyle & = default;
#ifdef Q_COMPILER_RVALUE_REFS
VPatternPieceStyle(VPatternPieceStyle &&) = default; VPatternPieceStyle(VPatternPieceStyle &&) = default;
auto operator=(VPatternPieceStyle &&) -> VPatternPieceStyle & = default; auto operator=(VPatternPieceStyle &&) -> VPatternPieceStyle & = default;
#endif
void LoadJson(QJsonObject const &json) override; void LoadJson(QJsonObject const &json) override;

2
src/libs/vmisc/theme/vstylesheetstyle.h
View File

@ -51,10 +51,8 @@ public:
VStylesheetStyle(const VStylesheetStyle &) = default; VStylesheetStyle(const VStylesheetStyle &) = default;
auto operator=(const VStylesheetStyle &) -> VStylesheetStyle & = default; auto operator=(const VStylesheetStyle &) -> VStylesheetStyle & = default;
#ifdef Q_COMPILER_RVALUE_REFS
VStylesheetStyle(VStylesheetStyle &&) = default; VStylesheetStyle(VStylesheetStyle &&) = default;
auto operator=(VStylesheetStyle &&) -> VStylesheetStyle & = default; auto operator=(VStylesheetStyle &&) -> VStylesheetStyle & = default;
#endif
virtual void LoadJson(QJsonObject const &json) = 0; virtual void LoadJson(QJsonObject const &json) = 0;
virtual auto ToJson() const -> QJsonObject = 0; virtual auto ToJson() const -> QJsonObject = 0;

2
src/libs/vmisc/theme/vtoolstyle.h
View File

@ -43,10 +43,8 @@ public:
VToolStyle(const VToolStyle &) = default; VToolStyle(const VToolStyle &) = default;
auto operator=(const VToolStyle &) -> VToolStyle & = default; auto operator=(const VToolStyle &) -> VToolStyle & = default;
#ifdef Q_COMPILER_RVALUE_REFS
VToolStyle(VToolStyle &&) = default; VToolStyle(VToolStyle &&) = default;
auto operator=(VToolStyle &&) -> VToolStyle & = default; auto operator=(VToolStyle &&) -> VToolStyle & = default;
#endif
void LoadJson(QJsonObject const &json) override; void LoadJson(QJsonObject const &json) override;

2
src/libs/vpatterndb/floatItemData/vabstractfloatitemdata.cpp
View File

@ -55,7 +55,6 @@ auto VAbstractFloatItemData::operator=(const VAbstractFloatItemData &data) -> VA
return *this; return *this;
} }
#ifdef Q_COMPILER_RVALUE_REFS
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
VAbstractFloatItemData::VAbstractFloatItemData(VAbstractFloatItemData &&data) noexcept VAbstractFloatItemData::VAbstractFloatItemData(VAbstractFloatItemData &&data) noexcept
: d(std::move(data.d)) : d(std::move(data.d))
@ -68,7 +67,6 @@ auto VAbstractFloatItemData::operator=(VAbstractFloatItemData &&data) noexcept -
std::swap(d, data.d); std::swap(d, data.d);
return *this; return *this;
} }
#endif
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
VAbstractFloatItemData::~VAbstractFloatItemData() = default; VAbstractFloatItemData::~VAbstractFloatItemData() = default;

7
src/libs/vpatterndb/floatItemData/vabstractfloatitemdata.h
View File

@ -43,14 +43,13 @@ public:
virtual ~VAbstractFloatItemData(); virtual ~VAbstractFloatItemData();
auto operator=(const VAbstractFloatItemData &data) -> VAbstractFloatItemData &; auto operator=(const VAbstractFloatItemData &data) -> VAbstractFloatItemData &;
#ifdef Q_COMPILER_RVALUE_REFS
VAbstractFloatItemData(VAbstractFloatItemData &&data) noexcept; VAbstractFloatItemData(VAbstractFloatItemData &&data) noexcept;
auto operator=(VAbstractFloatItemData &&data) noexcept->VAbstractFloatItemData &; auto operator=(VAbstractFloatItemData &&data) noexcept -> VAbstractFloatItemData &;
#endif
// methods, which set and return values of different parameters // methods, which set and return values of different parameters
auto GetPos() const -> QPointF; auto GetPos() const -> QPointF;
void SetPos(const QPointF& ptPos); void SetPos(const QPointF &ptPos);
auto IsVisible() const -> bool; auto IsVisible() const -> bool;
void SetVisible(bool bVisible); void SetVisible(bool bVisible);

2
src/libs/vpatterndb/floatItemData/vgrainlinedata.cpp
View File

@ -54,7 +54,6 @@ auto VGrainlineData::operator=(const VGrainlineData &data) -> VGrainlineData &
return *this; return *this;
} }
#ifdef Q_COMPILER_RVALUE_REFS
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
VGrainlineData::VGrainlineData(VGrainlineData &&data) noexcept VGrainlineData::VGrainlineData(VGrainlineData &&data) noexcept
: VAbstractFloatItemData(std::move(data)), : VAbstractFloatItemData(std::move(data)),
@ -69,7 +68,6 @@ auto VGrainlineData::operator=(VGrainlineData &&data) noexcept -> VGrainlineData
std::swap(d, data.d); std::swap(d, data.d);
return *this; return *this;
} }
#endif
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
VGrainlineData::~VGrainlineData() = default; VGrainlineData::~VGrainlineData() = default;

3
src/libs/vpatterndb/floatItemData/vgrainlinedata.h
View File

@ -50,10 +50,9 @@ public:
~VGrainlineData() override; ~VGrainlineData() override;
auto operator=(const VGrainlineData &data) -> VGrainlineData &; auto operator=(const VGrainlineData &data) -> VGrainlineData &;
#ifdef Q_COMPILER_RVALUE_REFS
VGrainlineData(VGrainlineData &&data) noexcept; VGrainlineData(VGrainlineData &&data) noexcept;
auto operator=(VGrainlineData &&data) noexcept -> VGrainlineData &; auto operator=(VGrainlineData &&data) noexcept -> VGrainlineData &;
#endif
// methods, which set and return values of different parameters // methods, which set and return values of different parameters
auto GetLength() const -> QString; auto GetLength() const -> QString;

2
src/libs/vpatterndb/floatItemData/vpatternlabeldata.cpp
View File

@ -52,7 +52,6 @@ auto VPatternLabelData::operator=(const VPatternLabelData &data) -> VPatternLabe
return *this; return *this;
} }
#ifdef Q_COMPILER_RVALUE_REFS
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
VPatternLabelData::VPatternLabelData(VPatternLabelData &&data) noexcept VPatternLabelData::VPatternLabelData(VPatternLabelData &&data) noexcept
: VAbstractFloatItemData(std::move(data)), : VAbstractFloatItemData(std::move(data)),
@ -67,7 +66,6 @@ auto VPatternLabelData::operator=(VPatternLabelData &&data) noexcept -> VPattern
std::swap(d, data.d); std::swap(d, data.d);
return *this; return *this;
} }
#endif
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
VPatternLabelData::~VPatternLabelData() = default; VPatternLabelData::~VPatternLabelData() = default;

3
src/libs/vpatterndb/floatItemData/vpatternlabeldata.h
View File

@ -47,10 +47,9 @@ public:
~VPatternLabelData() override; ~VPatternLabelData() override;
auto operator=(const VPatternLabelData &data) -> VPatternLabelData &; auto operator=(const VPatternLabelData &data) -> VPatternLabelData &;
#ifdef Q_COMPILER_RVALUE_REFS
VPatternLabelData(VPatternLabelData &&data) noexcept; VPatternLabelData(VPatternLabelData &&data) noexcept;
auto operator=(VPatternLabelData &&data) noexcept -> VPatternLabelData &; auto operator=(VPatternLabelData &&data) noexcept -> VPatternLabelData &;
#endif
// methods, which set up label parameters // methods, which set up label parameters
auto GetLabelWidth() const -> QString; auto GetLabelWidth() const -> QString;

2
src/libs/vpatterndb/floatItemData/vpiecelabeldata.cpp
View File

@ -53,7 +53,6 @@ auto VPieceLabelData::operator=(const VPieceLabelData &data) -> VPieceLabelData
return *this; return *this;
} }
#ifdef Q_COMPILER_RVALUE_REFS
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
VPieceLabelData::VPieceLabelData(VPieceLabelData &&data) noexcept VPieceLabelData::VPieceLabelData(VPieceLabelData &&data) noexcept
: VPatternLabelData(std::move(data)), : VPatternLabelData(std::move(data)),
@ -68,7 +67,6 @@ auto VPieceLabelData::operator=(VPieceLabelData &&data) noexcept -> VPieceLabelD
std::swap(d, data.d); std::swap(d, data.d);
return *this; return *this;
} }
#endif
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
VPieceLabelData::~VPieceLabelData() = default; VPieceLabelData::~VPieceLabelData() = default;

5
src/libs/vpatterndb/floatItemData/vpiecelabeldata.h
View File

@ -49,10 +49,9 @@ public:
~VPieceLabelData() override; ~VPieceLabelData() override;
auto operator=(const VPieceLabelData &data) -> VPieceLabelData &; auto operator=(const VPieceLabelData &data) -> VPieceLabelData &;
#ifdef Q_COMPILER_RVALUE_REFS
VPieceLabelData(VPieceLabelData &&data) noexcept; VPieceLabelData(VPieceLabelData &&data) noexcept;
auto operator=(VPieceLabelData &&data) noexcept->VPieceLabelData &; auto operator=(VPieceLabelData &&data) noexcept -> VPieceLabelData &;
#endif
void Clear(); void Clear();

3
src/libs/vpatterndb/variables/varcradius.h
View File

@ -47,10 +47,9 @@ public:
VArcRadius(const VArcRadius &var) = default; VArcRadius(const VArcRadius &var) = default;
auto operator=(const VArcRadius &var) -> VArcRadius &; auto operator=(const VArcRadius &var) -> VArcRadius &;
~VArcRadius() override = default; ~VArcRadius() override = default;
#ifdef Q_COMPILER_RVALUE_REFS
VArcRadius(VArcRadius &&var) noexcept = default; VArcRadius(VArcRadius &&var) noexcept = default;
auto operator=(VArcRadius &&var) noexcept -> VArcRadius & = default; auto operator=(VArcRadius &&var) noexcept -> VArcRadius & = default;
#endif
}; };
#endif // VARCRADIUS_H #endif // VARCRADIUS_H

2
src/libs/vpatterndb/variables/vcurvevariable.cpp
View File

@ -61,7 +61,6 @@ auto VCurveVariable::operator=(const VCurveVariable &var) -> VCurveVariable &
return *this; return *this;
} }
#ifdef Q_COMPILER_RVALUE_REFS
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
VCurveVariable::VCurveVariable(VCurveVariable &&var) noexcept VCurveVariable::VCurveVariable(VCurveVariable &&var) noexcept
: VInternalVariable(std::move(var)), : VInternalVariable(std::move(var)),
@ -76,7 +75,6 @@ auto VCurveVariable::operator=(VCurveVariable &&var) noexcept -> VCurveVariable
std::swap(d, var.d); std::swap(d, var.d);
return *this; return *this;
} }
#endif
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
VCurveVariable::~VCurveVariable() = default; VCurveVariable::~VCurveVariable() = default;

3
src/libs/vpatterndb/variables/vcurvevariable.h
View File

@ -46,10 +46,9 @@ public:
~VCurveVariable() override; ~VCurveVariable() override;
auto operator=(const VCurveVariable &var) -> VCurveVariable &; auto operator=(const VCurveVariable &var) -> VCurveVariable &;
#ifdef Q_COMPILER_RVALUE_REFS
VCurveVariable(VCurveVariable &&var) noexcept; VCurveVariable(VCurveVariable &&var) noexcept;
auto operator=(VCurveVariable &&var) noexcept -> VCurveVariable &; auto operator=(VCurveVariable &&var) noexcept -> VCurveVariable &;
#endif
auto Filter(quint32 id) -> bool override; auto Filter(quint32 id) -> bool override;

2
src/libs/vpatterndb/variables/vincrement.cpp
View File

@ -70,7 +70,6 @@ auto VIncrement::operator=(const VIncrement &incr) -> VIncrement &
return *this; return *this;
} }
#ifdef Q_COMPILER_RVALUE_REFS
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
VIncrement::VIncrement(VIncrement &&incr) noexcept VIncrement::VIncrement(VIncrement &&incr) noexcept
: VVariable(std::move(incr)), : VVariable(std::move(incr)),
@ -85,7 +84,6 @@ auto VIncrement::operator=(VIncrement &&incr) noexcept -> VIncrement &
std::swap(d, incr.d); std::swap(d, incr.d);
return *this; return *this;
} }
#endif
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
VIncrement::~VIncrement() = default; VIncrement::~VIncrement() = default;

3
src/libs/vpatterndb/variables/vincrement.h
View File

@ -52,10 +52,9 @@ public:
~VIncrement() override; ~VIncrement() override;
auto operator=(const VIncrement &incr) -> VIncrement &; auto operator=(const VIncrement &incr) -> VIncrement &;
#ifdef Q_COMPILER_RVALUE_REFS
VIncrement(VIncrement &&incr) noexcept; VIncrement(VIncrement &&incr) noexcept;
auto operator=(VIncrement &&incr) noexcept -> VIncrement &; auto operator=(VIncrement &&incr) noexcept -> VIncrement &;
#endif
void SetFormula(qreal base, const QString &formula, bool ok); void SetFormula(qreal base, const QString &formula, bool ok);
auto GetFormula() const -> QString; auto GetFormula() const -> QString;

2
src/libs/vpatterndb/variables/vinternalvariable.cpp
View File

@ -55,14 +55,12 @@ VInternalVariable::VInternalVariable(VInternalVariable &&var) noexcept
{ {
} }
#ifdef Q_COMPILER_RVALUE_REFS
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
auto VInternalVariable::operator=(VInternalVariable &&var) noexcept -> VInternalVariable & auto VInternalVariable::operator=(VInternalVariable &&var) noexcept -> VInternalVariable &
{ {
std::swap(d, var.d); std::swap(d, var.d);
return *this; return *this;
} }
#endif
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
VInternalVariable::~VInternalVariable() = default; VInternalVariable::~VInternalVariable() = default;

3
src/libs/vpatterndb/variables/vinternalvariable.h
View File

@ -50,10 +50,9 @@ public:
virtual ~VInternalVariable(); virtual ~VInternalVariable();
auto operator=(const VInternalVariable &var) -> VInternalVariable &; auto operator=(const VInternalVariable &var) -> VInternalVariable &;
#ifdef Q_COMPILER_RVALUE_REFS
VInternalVariable(VInternalVariable &&var) noexcept; VInternalVariable(VInternalVariable &&var) noexcept;
auto operator=(VInternalVariable &&var) noexcept -> VInternalVariable &; auto operator=(VInternalVariable &&var) noexcept -> VInternalVariable &;
#endif
virtual auto GetValue() const -> qreal; virtual auto GetValue() const -> qreal;
virtual auto GetValue() -> qreal *; virtual auto GetValue() -> qreal *;

2
src/libs/vpatterndb/variables/vlineangle.cpp
View File

@ -78,7 +78,6 @@ auto VLineAngle::operator=(const VLineAngle &var) -> VLineAngle &
return *this; return *this;
} }
#ifdef Q_COMPILER_RVALUE_REFS
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
VLineAngle::VLineAngle(VLineAngle &&var) noexcept VLineAngle::VLineAngle(VLineAngle &&var) noexcept
: VInternalVariable(std::move(var)), : VInternalVariable(std::move(var)),
@ -93,7 +92,6 @@ auto VLineAngle::operator=(VLineAngle &&var) noexcept -> VLineAngle &
std::swap(d, var.d); std::swap(d, var.d);
return *this; return *this;
} }
#endif
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
VLineAngle::~VLineAngle() = default; VLineAngle::~VLineAngle() = default;

3
src/libs/vpatterndb/variables/vlineangle.h
View File

@ -47,10 +47,9 @@ public:
~VLineAngle() override; ~VLineAngle() override;
auto operator=(const VLineAngle &var) -> VLineAngle &; auto operator=(const VLineAngle &var) -> VLineAngle &;
#ifdef Q_COMPILER_RVALUE_REFS
VLineAngle(VLineAngle &&var) noexcept; VLineAngle(VLineAngle &&var) noexcept;
auto operator=(VLineAngle &&var) noexcept -> VLineAngle &; auto operator=(VLineAngle &&var) noexcept -> VLineAngle &;
#endif
auto Filter(quint32 id) -> bool override; auto Filter(quint32 id) -> bool override;

2
src/libs/vpatterndb/variables/vlinelength.cpp
View File

@ -83,7 +83,6 @@ VLengthLine::VLengthLine(VLengthLine &&var) noexcept
{ {
} }
#ifdef Q_COMPILER_RVALUE_REFS
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
auto VLengthLine::operator=(VLengthLine &&var) noexcept -> VLengthLine & auto VLengthLine::operator=(VLengthLine &&var) noexcept -> VLengthLine &
{ {
@ -91,7 +90,6 @@ auto VLengthLine::operator=(VLengthLine &&var) noexcept -> VLengthLine &
std::swap(d, var.d); std::swap(d, var.d);
return *this; return *this;
} }
#endif
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
VLengthLine::~VLengthLine() = default; VLengthLine::~VLengthLine() = default;

3
src/libs/vpatterndb/variables/vlinelength.h
View File

@ -48,10 +48,9 @@ public:
~VLengthLine() override; ~VLengthLine() override;
auto operator=(const VLengthLine &var) -> VLengthLine &; auto operator=(const VLengthLine &var) -> VLengthLine &;
#ifdef Q_COMPILER_RVALUE_REFS
VLengthLine(VLengthLine &&var) noexcept; VLengthLine(VLengthLine &&var) noexcept;
auto operator=(VLengthLine &&var) noexcept -> VLengthLine &; auto operator=(VLengthLine &&var) noexcept -> VLengthLine &;
#endif
auto Filter(quint32 id) -> bool override; auto Filter(quint32 id) -> bool override;

2
src/libs/vpatterndb/variables/vmeasurement.cpp
View File

@ -96,7 +96,6 @@ auto VMeasurement::operator=(const VMeasurement &m) -> VMeasurement &
return *this; return *this;
} }
#ifdef Q_COMPILER_RVALUE_REFS
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
VMeasurement::VMeasurement(VMeasurement &&m) noexcept VMeasurement::VMeasurement(VMeasurement &&m) noexcept
: VVariable(std::move(m)), : VVariable(std::move(m)),
@ -111,7 +110,6 @@ auto VMeasurement::operator=(VMeasurement &&m) noexcept -> VMeasurement &
std::swap(d, m.d); std::swap(d, m.d);
return *this; return *this;
} }
#endif
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
VMeasurement::~VMeasurement() = default; VMeasurement::~VMeasurement() = default;

3
src/libs/vpatterndb/variables/vmeasurement.h
View File

@ -59,10 +59,9 @@ public:
~VMeasurement() override; ~VMeasurement() override;
auto operator=(const VMeasurement &m) -> VMeasurement &; auto operator=(const VMeasurement &m) -> VMeasurement &;
#ifdef Q_COMPILER_RVALUE_REFS
VMeasurement(VMeasurement &&m) noexcept; VMeasurement(VMeasurement &&m) noexcept;
auto operator=(VMeasurement &&m) noexcept -> VMeasurement &; auto operator=(VMeasurement &&m) noexcept -> VMeasurement &;
#endif
auto GetKnownMeasurementsId() const -> QUuid; auto GetKnownMeasurementsId() const -> QUuid;
void SetKnownMeasurementsId(const QUuid &id); void SetKnownMeasurementsId(const QUuid &id);

2
src/libs/vpatterndb/variables/vpiecearea.cpp
View File

@ -90,7 +90,6 @@ auto VPieceArea::operator=(const VPieceArea &var) -> VPieceArea &
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
VPieceArea::~VPieceArea() = default; VPieceArea::~VPieceArea() = default;
#ifdef Q_COMPILER_RVALUE_REFS
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
VPieceArea::VPieceArea(VPieceArea &&var) noexcept VPieceArea::VPieceArea(VPieceArea &&var) noexcept
: VInternalVariable(std::move(var)), : VInternalVariable(std::move(var)),
@ -105,7 +104,6 @@ auto VPieceArea::operator=(VPieceArea &&var) noexcept -> VPieceArea &
std::swap(d, var.d); std::swap(d, var.d);
return *this; return *this;
} }
#endif
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
void VPieceArea::SetValue(quint32 pieceId, const VPiece &piece, const VContainer *data, Unit unit) void VPieceArea::SetValue(quint32 pieceId, const VPiece &piece, const VContainer *data, Unit unit)

12
src/libs/vpatterndb/variables/vpiecearea.h
View File

@ -34,9 +34,13 @@ class VPiece;
class VContainer; class VContainer;
class VPieceAreaData; class VPieceAreaData;
enum class PieceAreaType : qint8 { External, SeamLine }; enum class PieceAreaType : qint8
{
External,
SeamLine
};
class VPieceArea final :public VInternalVariable class VPieceArea final : public VInternalVariable
{ {
public: public:
VPieceArea(); VPieceArea();
@ -45,16 +49,16 @@ public:
~VPieceArea() override; ~VPieceArea() override;
auto operator=(const VPieceArea &var) -> VPieceArea &; auto operator=(const VPieceArea &var) -> VPieceArea &;
#ifdef Q_COMPILER_RVALUE_REFS
VPieceArea(VPieceArea &&var) noexcept; VPieceArea(VPieceArea &&var) noexcept;
auto operator=(VPieceArea &&var) noexcept -> VPieceArea &; auto operator=(VPieceArea &&var) noexcept -> VPieceArea &;
#endif
void SetValue(quint32 pieceId, const VPiece &piece, const VContainer *data, Unit unit); void SetValue(quint32 pieceId, const VPiece &piece, const VContainer *data, Unit unit);
auto GetPieceId() const -> quint32; auto GetPieceId() const -> quint32;
static auto PieceShortName(const VPiece &piece) -> QString; static auto PieceShortName(const VPiece &piece) -> QString;
private: private:
QSharedDataPointer<VPieceAreaData> d; QSharedDataPointer<VPieceAreaData> d;
}; };

2
src/libs/vpatterndb/variables/vvariable.cpp
View File

@ -62,7 +62,6 @@ auto VVariable::operator=(const VVariable &var) -> VVariable &
return *this; return *this;
} }
#ifdef Q_COMPILER_RVALUE_REFS
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
VVariable::VVariable(VVariable &&var) noexcept VVariable::VVariable(VVariable &&var) noexcept
: VInternalVariable(std::move(var)), : VInternalVariable(std::move(var)),
@ -77,7 +76,6 @@ auto VVariable::operator=(VVariable &&var) noexcept -> VVariable &
std::swap(d, var.d); std::swap(d, var.d);
return *this; return *this;
} }
#endif
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
VVariable::~VVariable() = default; VVariable::~VVariable() = default;

3
src/libs/vpatterndb/variables/vvariable.h
View File

@ -48,10 +48,9 @@ public:
~VVariable() override; ~VVariable() override;
auto operator=(const VVariable &var) -> VVariable &; auto operator=(const VVariable &var) -> VVariable &;
#ifdef Q_COMPILER_RVALUE_REFS
VVariable(VVariable &&var) noexcept; VVariable(VVariable &&var) noexcept;
auto operator=(VVariable &&var) noexcept -> VVariable &; auto operator=(VVariable &&var) noexcept -> VVariable &;
#endif
auto GetDescription() const -> QString; auto GetDescription() const -> QString;
void SetDescription(const QString &desc); void SetDescription(const QString &desc);

2
src/libs/vpatterndb/vcontainer.cpp
View File

@ -117,7 +117,6 @@ auto VContainer::operator=(const VContainer &data) -> VContainer &
return *this; return *this;
} }
#ifdef Q_COMPILER_RVALUE_REFS
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
VContainer::VContainer(VContainer &&data) noexcept VContainer::VContainer(VContainer &&data) noexcept
: d(std::move(data.d)) : d(std::move(data.d))
@ -130,7 +129,6 @@ auto VContainer::operator=(VContainer &&data) noexcept -> VContainer &
std::swap(d, data.d); std::swap(d, data.d);
return *this; return *this;
} }
#endif
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
/** /**

3
src/libs/vpatterndb/vcontainer.h
View File

@ -120,10 +120,9 @@ public:
friend class VContainerData; friend class VContainerData;
auto operator=(const VContainer &data) -> VContainer &; auto operator=(const VContainer &data) -> VContainer &;
#ifdef Q_COMPILER_RVALUE_REFS
VContainer(VContainer &&data) noexcept; VContainer(VContainer &&data) noexcept;
auto operator=(VContainer &&data) noexcept -> VContainer &; auto operator=(VContainer &&data) noexcept -> VContainer &;
#endif
static auto UniqueNamespace() -> QString; static auto UniqueNamespace() -> QString;

2
src/libs/vpatterndb/vnodedetail.cpp
View File

@ -119,7 +119,6 @@ auto VNodeDetail::operator=(const VNodeDetail &node) -> VNodeDetail &
return *this; return *this;
} }
#ifdef Q_COMPILER_RVALUE_REFS
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
VNodeDetail::VNodeDetail(VNodeDetail &&node) noexcept VNodeDetail::VNodeDetail(VNodeDetail &&node) noexcept
: d(std::move(node.d)) : d(std::move(node.d))
@ -132,7 +131,6 @@ auto VNodeDetail::operator=(VNodeDetail &&node) noexcept -> VNodeDetail &
std::swap(d, node.d); std::swap(d, node.d);
return *this; return *this;
} }
#endif
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
VNodeDetail::~VNodeDetail() = default; VNodeDetail::~VNodeDetail() = default;

3
src/libs/vpatterndb/vnodedetail.h
View File

@ -73,10 +73,9 @@ public:
* @return node * @return node
*/ */
auto operator=(const VNodeDetail &node) -> VNodeDetail &; auto operator=(const VNodeDetail &node) -> VNodeDetail &;
#ifdef Q_COMPILER_RVALUE_REFS
VNodeDetail(VNodeDetail &&node) noexcept; VNodeDetail(VNodeDetail &&node) noexcept;
auto operator=(VNodeDetail &&node) noexcept -> VNodeDetail &; auto operator=(VNodeDetail &&node) noexcept -> VNodeDetail &;
#endif
/** /**
* @brief getId return object id. * @brief getId return object id.

2
src/libs/vpatterndb/vpiece.cpp
View File

@ -139,7 +139,6 @@ auto VPiece::operator=(const VPiece &piece) -> VPiece &
return *this; return *this;
} }
#ifdef Q_COMPILER_RVALUE_REFS
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
VPiece::VPiece(VPiece &&piece) noexcept VPiece::VPiece(VPiece &&piece) noexcept
: VAbstractPiece(std::move(piece)), : VAbstractPiece(std::move(piece)),
@ -154,7 +153,6 @@ auto VPiece::operator=(VPiece &&piece) noexcept -> VPiece &
std::swap(d, piece.d); std::swap(d, piece.d);
return *this; return *this;
} }
#endif
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
VPiece::~VPiece() = default; VPiece::~VPiece() = default;

3
src/libs/vpatterndb/vpiece.h
View File

@ -56,10 +56,9 @@ public:
~VPiece() override; ~VPiece() override;
auto operator=(const VPiece &piece) -> VPiece &; auto operator=(const VPiece &piece) -> VPiece &;
#ifdef Q_COMPILER_RVALUE_REFS
VPiece(VPiece &&piece) noexcept; VPiece(VPiece &&piece) noexcept;
auto operator=(VPiece &&piece) noexcept -> VPiece &; auto operator=(VPiece &&piece) noexcept -> VPiece &;
#endif
auto GetPath() const -> VPiecePath; auto GetPath() const -> VPiecePath;
auto GetPath() -> VPiecePath &; auto GetPath() -> VPiecePath &;

2
src/libs/vpatterndb/vpiecenode.cpp
View File

@ -61,7 +61,6 @@ auto VPieceNode::operator=(const VPieceNode &node) -> VPieceNode &
return *this; return *this;
} }
#ifdef Q_COMPILER_RVALUE_REFS
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
VPieceNode::VPieceNode(VPieceNode &&node) noexcept VPieceNode::VPieceNode(VPieceNode &&node) noexcept
: d(std::move(node.d)) : d(std::move(node.d))
@ -74,7 +73,6 @@ auto VPieceNode::operator=(VPieceNode &&node) noexcept -> VPieceNode &
std::swap(d, node.d); std::swap(d, node.d);
return *this; return *this;
} }
#endif
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
VPieceNode::~VPieceNode() = default; VPieceNode::~VPieceNode() = default;

3
src/libs/vpatterndb/vpiecenode.h
View File

@ -48,10 +48,9 @@ public:
~VPieceNode(); ~VPieceNode();
auto operator=(const VPieceNode &node) -> VPieceNode &; auto operator=(const VPieceNode &node) -> VPieceNode &;
#ifdef Q_COMPILER_RVALUE_REFS
VPieceNode(VPieceNode &&node) noexcept; VPieceNode(VPieceNode &&node) noexcept;
auto operator=(VPieceNode &&node) noexcept -> VPieceNode &; auto operator=(VPieceNode &&node) noexcept -> VPieceNode &;
#endif
friend auto operator<<(QDataStream &out, const VPieceNode &p) -> QDataStream &; friend auto operator<<(QDataStream &out, const VPieceNode &p) -> QDataStream &;
friend auto operator>>(QDataStream &in, VPieceNode &p) -> QDataStream &; friend auto operator>>(QDataStream &in, VPieceNode &p) -> QDataStream &;

2
src/libs/vpatterndb/vpiecepath.cpp
View File

@ -252,7 +252,6 @@ auto VPiecePath::operator=(const VPiecePath &path) -> VPiecePath &
return *this; return *this;
} }
#ifdef Q_COMPILER_RVALUE_REFS
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
VPiecePath::VPiecePath(VPiecePath &&path) noexcept VPiecePath::VPiecePath(VPiecePath &&path) noexcept
: d(std::move(path.d)) : d(std::move(path.d))
@ -265,7 +264,6 @@ auto VPiecePath::operator=(VPiecePath &&path) noexcept -> VPiecePath &
std::swap(d, path.d); std::swap(d, path.d);
return *this; return *this;
} }
#endif
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
VPiecePath::~VPiecePath() = default; VPiecePath::~VPiecePath() = default;

3
src/libs/vpatterndb/vpiecepath.h
View File

@ -54,10 +54,9 @@ public:
~VPiecePath(); ~VPiecePath();
auto operator=(const VPiecePath &path) -> VPiecePath &; auto operator=(const VPiecePath &path) -> VPiecePath &;
#ifdef Q_COMPILER_RVALUE_REFS
VPiecePath(VPiecePath &&path) noexcept; VPiecePath(VPiecePath &&path) noexcept;
auto operator=(VPiecePath &&path) noexcept -> VPiecePath &; auto operator=(VPiecePath &&path) noexcept -> VPiecePath &;
#endif
void Append(const VPieceNode &node); void Append(const VPieceNode &node);
void Clear(); void Clear();

2
src/libs/vpropertyexplorer/vabstractpropertyfactory.h
View File

@ -43,10 +43,8 @@ public:
VAbstractPropertyFactory(const VAbstractPropertyFactory &) = default; VAbstractPropertyFactory(const VAbstractPropertyFactory &) = default;
auto operator=(const VAbstractPropertyFactory &) -> VAbstractPropertyFactory & = default; auto operator=(const VAbstractPropertyFactory &) -> VAbstractPropertyFactory & = default;
#ifdef Q_COMPILER_RVALUE_REFS
VAbstractPropertyFactory(VAbstractPropertyFactory &&) = default; VAbstractPropertyFactory(VAbstractPropertyFactory &&) = default;
auto operator=(VAbstractPropertyFactory &&) -> VAbstractPropertyFactory & = default; auto operator=(VAbstractPropertyFactory &&) -> VAbstractPropertyFactory & = default;
#endif
//! Creates a new property of a certain type and assigns a name and description (otionally) //! Creates a new property of a certain type and assigns a name and description (otionally)
//! \param type The type of the property as string //! \param type The type of the property as string

2
src/libs/vtools/tools/vabstracttool.h
View File

@ -66,10 +66,8 @@ struct VAbstractToolInitData
VAbstractToolInitData(const VAbstractToolInitData &) = default; VAbstractToolInitData(const VAbstractToolInitData &) = default;
auto operator=(const VAbstractToolInitData &) -> VAbstractToolInitData & = default; auto operator=(const VAbstractToolInitData &) -> VAbstractToolInitData & = default;
#ifdef Q_COMPILER_RVALUE_REFS
VAbstractToolInitData(VAbstractToolInitData &&) = default; VAbstractToolInitData(VAbstractToolInitData &&) = default;
auto operator=(VAbstractToolInitData &&) -> VAbstractToolInitData & = default; auto operator=(VAbstractToolInitData &&) -> VAbstractToolInitData & = default;
#endif
/** @brief id tool id, 0 if tool doesn't exist yet.*/ /** @brief id tool id, 0 if tool doesn't exist yet.*/
quint32 id; quint32 id;

2
src/libs/vwidgets/vpiecegrainline.cpp
View File

@ -90,7 +90,6 @@ auto VPieceGrainline::operator=(const VPieceGrainline &grainline) -> VPieceGrain
return *this; return *this;
} }
#ifdef Q_COMPILER_RVALUE_REFS
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
VPieceGrainline::VPieceGrainline(VPieceGrainline &&grainline) noexcept VPieceGrainline::VPieceGrainline(VPieceGrainline &&grainline) noexcept
: d(std::move(grainline.d)) : d(std::move(grainline.d))
@ -103,7 +102,6 @@ auto VPieceGrainline::operator=(VPieceGrainline &&grainline) noexcept -> VPieceG
std::swap(d, grainline.d); std::swap(d, grainline.d);
return *this; return *this;
} }
#endif
//--------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------
auto VPieceGrainline::GetMainLine() const -> QLineF auto VPieceGrainline::GetMainLine() const -> QLineF

3
src/libs/vwidgets/vpiecegrainline.h
View File

@ -51,10 +51,9 @@ public:
~VPieceGrainline(); ~VPieceGrainline();
auto operator=(const VPieceGrainline &grainline) -> VPieceGrainline &; auto operator=(const VPieceGrainline &grainline) -> VPieceGrainline &;
#ifdef Q_COMPILER_RVALUE_REFS
VPieceGrainline(VPieceGrainline &&grainline) noexcept; VPieceGrainline(VPieceGrainline &&grainline) noexcept;
auto operator=(VPieceGrainline &&grainline) noexcept -> VPieceGrainline &; auto operator=(VPieceGrainline &&grainline) noexcept -> VPieceGrainline &;
#endif
auto GetMainLine() const -> QLineF; auto GetMainLine() const -> QLineF;
void SetMainLine(const QLineF &mainLine); void SetMainLine(const QLineF &mainLine);