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;
}
#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
//---------------------------------------------------------------------------------------------------------------------
/**

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

@ -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 *;

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

@ -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

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

@ -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>;

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

@ -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;

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

@ -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);

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

@ -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;
auto operator= (const VAbstractBezier &curve) -> VAbstractBezier&;
~VAbstractBezier() override =default;
VAbstractBezier(const VAbstractBezier &curve) = default;
auto operator=(const VAbstractBezier &curve) -> VAbstractBezier &;
~VAbstractBezier() override = default;
#ifdef Q_COMPILER_RVALUE_REFS
VAbstractBezier(VAbstractBezier &&curve) noexcept =default;
auto operator=(VAbstractBezier &&curve) noexcept -> VAbstractBezier & =default;
#endif
VAbstractBezier(VAbstractBezier &&curve) noexcept = default;
auto operator=(VAbstractBezier &&curve) noexcept -> VAbstractBezier & = default;
virtual auto GetC1Length() const -> qreal =0;
virtual auto GetC2Length() const -> qreal =0;
virtual auto GetC1Length() const -> qreal = 0;
virtual auto GetC2Length() const -> qreal = 0;
};
#endif // VABSTRACTBEZIER_H

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

@ -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;

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

@ -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;

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

@ -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;

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

@ -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,

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

@ -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

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

@ -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);

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

@ -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

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

@ -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);

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

@ -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

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

@ -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 &;

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

@ -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

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

@ -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);

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

@ -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;

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

@ -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);

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

@ -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

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

@ -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 &;

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

@ -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

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

@ -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;

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

@ -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
//---------------------------------------------------------------------------------------------------------------------
/**

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

@ -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);

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

@ -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
//---------------------------------------------------------------------------------------------------------------------
/**

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

@ -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);

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

@ -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;

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

@ -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);

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

@ -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;

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

@ -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);

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

@ -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)

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

@ -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);

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

@ -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;

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

@ -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();

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

@ -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;

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

@ -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);

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

@ -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;

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

@ -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>;

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

@ -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;

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

@ -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;

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

@ -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;
auto operator=(const VPosition&) -> VPosition& = default;
#ifdef Q_COMPILER_RVALUE_REFS
VPosition(VPosition&&) = default;
auto operator=(VPosition&&) -> VPosition& = default;
#endif
~VPosition()= default;
VPosition(const VPosition &) = default;
auto operator=(const VPosition &) -> VPosition & = default;
VPosition(VPosition &&) = default;
auto operator=(VPosition &&) -> VPosition & = default;
~VPosition() = default;
void run();

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

@ -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;

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

@ -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)

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

@ -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;

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;
}
#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)

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

@ -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);

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

@ -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)

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

@ -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;

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

@ -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;

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

@ -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;

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

@ -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;

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

@ -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;

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

@ -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;

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

@ -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 &;
#endif
auto operator=(VAbstractFloatItemData &&data) noexcept -> VAbstractFloatItemData &;
// 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);

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

@ -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;

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

@ -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;

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

@ -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;

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

@ -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;

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

@ -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;

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

@ -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 &;
#endif
auto operator=(VPieceLabelData &&data) noexcept -> VPieceLabelData &;
void Clear();
@ -80,7 +79,7 @@ public:
auto IsOnFold() const -> bool;
void SetOnFold(bool onFold);
auto GetAreaShortName() const -> QString;
void SetAreaShortName(const QString &val);

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

@ -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

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

@ -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;

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

@ -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;

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

@ -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;

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

@ -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;

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 &
{
std::swap(d, var.d);
return *this;
}
#endif
//---------------------------------------------------------------------------------------------------------------------
VInternalVariable::~VInternalVariable() = default;

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

@ -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 *;

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

@ -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;

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

@ -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;

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

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

@ -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;

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

@ -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;

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

@ -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);

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

@ -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)

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

@ -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;
};

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

@ -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;

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

@ -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);

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

@ -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
//---------------------------------------------------------------------------------------------------------------------
/**

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

@ -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;

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

@ -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;

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

@ -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.

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

@ -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;

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

@ -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 &;

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

@ -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;

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

@ -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 &;

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

@ -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;

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

@ -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();

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

@ -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

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

@ -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;

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

@ -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

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

@ -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);