Remove Q_COMPILER_RVALUE_REFS.

src/libs/qmuparser/qmuparsercallback.cpp

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

src/libs/qmuparser/qmuparsercallback.h

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

src/libs/vformat/knownmeasurements/vknownmeasurements.cpp

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

src/libs/vformat/knownmeasurements/vknownmeasurements.h

@@ -45,10 +45,9 @@ public:
     VKnownMeasurements(const VKnownMeasurements &measurements);
 
     auto operator=(const VKnownMeasurements &paper) -> VKnownMeasurements &;
-#ifdef Q_COMPILER_RVALUE_REFS
+
     VKnownMeasurements(VKnownMeasurements &&paper) noexcept;
     auto operator=(VKnownMeasurements &&paper) noexcept -> VKnownMeasurements &;
-#endif
 
     auto IsValid() const -> bool;
 
@@ -63,7 +62,7 @@ public:
 
     auto IsReadOnly() const -> bool;
     void SetReadOnly(bool ro);
-    
+
     auto Measurements() const -> QHash<QString, VKnownMeasurement>;
     auto OrderedMeasurements() const -> QMap<int, VKnownMeasurement>;
     auto OrderedGroupMeasurements(const QString &group) const -> QMap<int, VKnownMeasurement>;

src/libs/vgeometry/vabstractarc.cpp

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

src/libs/vgeometry/vabstractarc.h

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

src/libs/vgeometry/vabstractbezier.h

@@ -38,17 +38,15 @@ class VAbstractBezier : public VAbstractCurve
 public:
     explicit VAbstractBezier(const GOType &type, const quint32 &idObject = NULL_ID,
                              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

src/libs/vgeometry/vabstractcubicbezier.h

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

src/libs/vgeometry/vabstractcubicbezierpath.h

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

src/libs/vgeometry/vabstractcurve.cpp

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

src/libs/vgeometry/vabstractcurve.h

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

src/libs/vgeometry/varc.cpp

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

src/libs/vgeometry/varc.h

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

src/libs/vgeometry/vcubicbezier.cpp

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

src/libs/vgeometry/vcubicbezier.h

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

src/libs/vgeometry/vcubicbezierpath.cpp

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

src/libs/vgeometry/vcubicbezierpath.h

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

src/libs/vgeometry/vellipticalarc.cpp

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

src/libs/vgeometry/vellipticalarc.h

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

src/libs/vgeometry/vgobject.cpp

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

src/libs/vgeometry/vgobject.h

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

src/libs/vgeometry/vplacelabelitem.cpp

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

src/libs/vgeometry/vplacelabelitem.h

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

src/libs/vgeometry/vpointf.cpp

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

src/libs/vgeometry/vpointf.h

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

src/libs/vgeometry/vspline.cpp

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

src/libs/vgeometry/vspline.h

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

src/libs/vgeometry/vsplinepath.cpp

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

src/libs/vgeometry/vsplinepath.h

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

src/libs/vgeometry/vsplinepoint.cpp

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

src/libs/vgeometry/vsplinepoint.h

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

src/libs/vlayout/vabstractpiece.cpp

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

src/libs/vlayout/vabstractpiece.h

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

src/libs/vlayout/vbestsquare.cpp

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

src/libs/vlayout/vbestsquare.h

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

src/libs/vlayout/vcontour.cpp

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

src/libs/vlayout/vcontour.h

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

src/libs/vlayout/vlayoutpaper.cpp

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

src/libs/vlayout/vlayoutpaper.h

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

src/libs/vlayout/vlayoutpiece.cpp

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

src/libs/vlayout/vlayoutpiece.h

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

src/libs/vlayout/vlayoutpiecepath.cpp

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

src/libs/vlayout/vlayoutpiecepath.h

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

src/libs/vlayout/vposition.h

@@ -29,7 +29,6 @@
 #ifndef VPOSITION_H
 #define VPOSITION_H
 
-
 #include <QRunnable>
 #include <QVector>
 #include <QtGlobal>
@@ -69,13 +68,13 @@ class VPosition
 public:
     VPosition() = default;
     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();
 

src/libs/vlayout/vtextmanager.h

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

src/libs/vmisc/svgfont/vsvgfont.cpp

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

src/libs/vmisc/svgfont/vsvgfont.h

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

src/libs/vmisc/svgfont/vsvgfontengine.cpp

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

src/libs/vmisc/svgfont/vsvgfontengine.h

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

src/libs/vmisc/svgfont/vsvgglyph.cpp

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

src/libs/vmisc/svgfont/vsvgglyph.h

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

src/libs/vmisc/theme/vmanuallayoutstyle.h

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

src/libs/vmisc/theme/vpatternpiecestyle.h

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

src/libs/vmisc/theme/vstylesheetstyle.h

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

src/libs/vmisc/theme/vtoolstyle.h

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

src/libs/vpatterndb/floatItemData/vabstractfloatitemdata.cpp

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

src/libs/vpatterndb/floatItemData/vabstractfloatitemdata.h

@@ -43,14 +43,13 @@ public:
     virtual ~VAbstractFloatItemData();
 
     auto operator=(const VAbstractFloatItemData &data) -> VAbstractFloatItemData &;
-#ifdef Q_COMPILER_RVALUE_REFS
+
     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
     auto GetPos() const -> QPointF;
-    void    SetPos(const QPointF& ptPos);
+    void SetPos(const QPointF &ptPos);
 
     auto IsVisible() const -> bool;
     void SetVisible(bool bVisible);

src/libs/vpatterndb/floatItemData/vgrainlinedata.cpp

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

src/libs/vpatterndb/floatItemData/vgrainlinedata.h

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

src/libs/vpatterndb/floatItemData/vpatternlabeldata.cpp

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

src/libs/vpatterndb/floatItemData/vpatternlabeldata.h

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

src/libs/vpatterndb/floatItemData/vpiecelabeldata.cpp

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

src/libs/vpatterndb/floatItemData/vpiecelabeldata.h

@@ -49,10 +49,9 @@ public:
     ~VPieceLabelData() override;
 
     auto operator=(const VPieceLabelData &data) -> VPieceLabelData &;
-#ifdef Q_COMPILER_RVALUE_REFS
+
     VPieceLabelData(VPieceLabelData &&data) noexcept;
-    auto operator=(VPieceLabelData &&data) noexcept->VPieceLabelData &;
+    auto operator=(VPieceLabelData &&data) noexcept -> VPieceLabelData &;
-#endif
 
     void Clear();
 
@@ -80,7 +79,7 @@ public:
 
     auto IsOnFold() const -> bool;
     void SetOnFold(bool onFold);
-    
+
     auto GetAreaShortName() const -> QString;
     void SetAreaShortName(const QString &val);
 

src/libs/vpatterndb/variables/varcradius.h

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

src/libs/vpatterndb/variables/vcurvevariable.cpp

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

src/libs/vpatterndb/variables/vcurvevariable.h

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

src/libs/vpatterndb/variables/vincrement.cpp

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

src/libs/vpatterndb/variables/vincrement.h

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

src/libs/vpatterndb/variables/vinternalvariable.cpp

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

src/libs/vpatterndb/variables/vinternalvariable.h

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

src/libs/vpatterndb/variables/vlineangle.cpp

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

src/libs/vpatterndb/variables/vlineangle.h

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

src/libs/vpatterndb/variables/vlinelength.cpp

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

src/libs/vpatterndb/variables/vlinelength.h

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

src/libs/vpatterndb/variables/vmeasurement.cpp

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

src/libs/vpatterndb/variables/vmeasurement.h

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

src/libs/vpatterndb/variables/vpiecearea.cpp

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

src/libs/vpatterndb/variables/vpiecearea.h

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

src/libs/vpatterndb/variables/vvariable.cpp

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

src/libs/vpatterndb/variables/vvariable.h

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

src/libs/vpatterndb/vcontainer.cpp

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

src/libs/vpatterndb/vcontainer.h

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

src/libs/vpatterndb/vnodedetail.cpp

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

src/libs/vpatterndb/vnodedetail.h

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

src/libs/vpatterndb/vpiece.cpp

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

src/libs/vpatterndb/vpiece.h

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

src/libs/vpatterndb/vpiecenode.cpp

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

src/libs/vpatterndb/vpiecenode.h

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

src/libs/vpatterndb/vpiecepath.cpp

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

src/libs/vpatterndb/vpiecepath.h

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

src/libs/vpropertyexplorer/vabstractpropertyfactory.h

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

src/libs/vtools/tools/vabstracttool.h

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

src/libs/vwidgets/vpiecegrainline.cpp

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

src/libs/vwidgets/vpiecegrainline.h

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