palo/valentina
1
0
Fork 0
mirror of https://gitlab.com/smart-pattern/valentina.git synced 2024-09-28 19:31:32 +02:00
Code Issues Projects Releases Wiki Activity

Refactoring. Added move constructor.

Browse source 
--HG--
branch : develop
This commit is contained in:
Roman Telezhynskyi 2019-12-30 17:13:18 +02:00
parent 54cb9fe0fb
commit 84001dac61
70 changed files with 277 additions and 345 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

13
src/libs/qmuparser/qmuparsercallback.cpp
View file

@ -209,20 +209,19 @@ QmuParserCallback &QmuParserCallback::operator=(const QmuParserCallback &a_Fun)
}
#ifdef Q_COMPILER_RVALUE_REFS
//---------------------------------------------------------------------------------------------------------------------
QmuParserCallback::QmuParserCallback(QmuParserCallback &&a_Fun) Q_DECL_NOTHROW
: d (a_Fun.d)
{}
//---------------------------------------------------------------------------------------------------------------------
QmuParserCallback &QmuParserCallback::operator=(QmuParserCallback &&a_Fun) Q_DECL_NOTHROW
{
Swap(a_Fun);
std::swap(d, a_Fun.d);
return *this;
}
#endif
//---------------------------------------------------------------------------------------------------------------------
void QmuParserCallback::Swap(QmuParserCallback &a_Fun) Q_DECL_NOTHROW
{
std::swap(d, a_Fun.d);
}
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief Return true if the function is conservative.

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

@ -86,11 +86,10 @@ public:
QmuParserCallback &operator=(const QmuParserCallback &a_Fun);
#ifdef Q_COMPILER_RVALUE_REFS
QmuParserCallback(QmuParserCallback &&a_Fun) Q_DECL_NOTHROW;
QmuParserCallback &operator=(QmuParserCallback &&a_Fun) Q_DECL_NOTHROW;
#endif
void Swap(QmuParserCallback &a_Fun) Q_DECL_NOTHROW;
Q_REQUIRED_RESULT QmuParserCallback* Clone() const;
bool IsOptimizable() const;

15
src/libs/vgeometry/vabstractarc.cpp
View file

@ -79,21 +79,20 @@ VAbstractArc &VAbstractArc::operator=(const VAbstractArc &arc)
}
#ifdef Q_COMPILER_RVALUE_REFS
//---------------------------------------------------------------------------------------------------------------------
VAbstractArc::VAbstractArc(VAbstractArc &&arc) Q_DECL_NOTHROW
: VAbstractCurve(arc), d (arc.d)
{}
//---------------------------------------------------------------------------------------------------------------------
VAbstractArc &VAbstractArc::operator=(VAbstractArc &&arc) Q_DECL_NOTHROW
{
Swap(arc);
VAbstractCurve::operator=(arc);
std::swap(d, arc.d);
return *this;
}
#endif
//---------------------------------------------------------------------------------------------------------------------
void VAbstractArc::Swap(VAbstractArc &arc) Q_DECL_NOTHROW
{
VAbstractCurve::Swap(arc);
std::swap(d, arc.d);
}
//---------------------------------------------------------------------------------------------------------------------
VAbstractArc::~VAbstractArc()
{}

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

@ -58,11 +58,10 @@ public:
VAbstractArc& operator= (const VAbstractArc &arc);
#ifdef Q_COMPILER_RVALUE_REFS
VAbstractArc(VAbstractArc &&arc) Q_DECL_NOTHROW;
VAbstractArc &operator=(VAbstractArc &&arc) Q_DECL_NOTHROW;
#endif
void Swap(VAbstractArc &arc) Q_DECL_NOTHROW;
QString GetFormulaF1 () const;
void SetFormulaF1 (const QString &formula, qreal value);
virtual qreal GetStartAngle () const override;

15
src/libs/vgeometry/vabstractcurve.cpp
View file

@ -60,21 +60,20 @@ VAbstractCurve &VAbstractCurve::operator=(const VAbstractCurve &curve)
}
#ifdef Q_COMPILER_RVALUE_REFS
//---------------------------------------------------------------------------------------------------------------------
VAbstractCurve::VAbstractCurve(VAbstractCurve &&curve) Q_DECL_NOTHROW
:VGObject(curve), d (curve.d)
{}
//---------------------------------------------------------------------------------------------------------------------
VAbstractCurve &VAbstractCurve::operator=(VAbstractCurve &&curve) Q_DECL_NOTHROW
{
Swap(curve);
VGObject::operator=(curve);
std::swap(d, curve.d);
return *this;
}
#endif
//---------------------------------------------------------------------------------------------------------------------
void VAbstractCurve::Swap(VAbstractCurve &curve) Q_DECL_NOTHROW
{
VGObject::Swap(curve);
std::swap(d, curve.d);
}
//---------------------------------------------------------------------------------------------------------------------
VAbstractCurve::~VAbstractCurve()
{}

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

@ -57,11 +57,10 @@ public:
VAbstractCurve& operator= (const VAbstractCurve &curve);
#ifdef Q_COMPILER_RVALUE_REFS
VAbstractCurve(VAbstractCurve &&curve) Q_DECL_NOTHROW;
VAbstractCurve &operator=(VAbstractCurve &&curve) Q_DECL_NOTHROW;
#endif
void Swap(VAbstractCurve &curve) Q_DECL_NOTHROW;
virtual QVector<QPointF> GetPoints() const =0;
static QVector<QPointF> GetSegmentPoints(const QVector<QPointF> &points, const QPointF &begin, const QPointF &end,
bool reverse = false);

16
src/libs/vgeometry/varc.cpp
View file

@ -117,22 +117,20 @@ VArc &VArc::operator =(const VArc &arc)
}
#ifdef Q_COMPILER_RVALUE_REFS
//---------------------------------------------------------------------------------------------------------------------
VArc::VArc(VArc &&arc) Q_DECL_NOTHROW
: VAbstractArc(arc), d (arc.d)
{}
//---------------------------------------------------------------------------------------------------------------------
VArc &VArc::operator=(VArc &&arc) Q_DECL_NOTHROW
{
Swap(arc);
VAbstractArc::operator=(arc);
std::swap(d, arc.d);
return *this;
}
#endif
//---------------------------------------------------------------------------------------------------------------------
inline void VArc::Swap(VArc &arc) Q_DECL_NOTHROW
{
VAbstractArc::Swap(arc);
std::swap(d, arc.d);
}
//---------------------------------------------------------------------------------------------------------------------
VArc VArc::Rotate(const QPointF &originPoint, qreal degrees, const QString &prefix) const
{

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

@ -66,11 +66,10 @@ public:
VArc& operator= (const VArc &arc);
#ifdef Q_COMPILER_RVALUE_REFS
VArc(VArc &&arc) Q_DECL_NOTHROW;
VArc &operator=(VArc &&arc) Q_DECL_NOTHROW;
#endif
void Swap(VArc &arc) Q_DECL_NOTHROW;
QString GetFormulaRadius () const;
void SetFormulaRadius (const QString &formula, qreal value);
qreal GetRadius () const;

15
src/libs/vgeometry/vcubicbezier.cpp
View file

@ -65,21 +65,20 @@ VCubicBezier &VCubicBezier::operator=(const VCubicBezier &curve)
}
#ifdef Q_COMPILER_RVALUE_REFS
//---------------------------------------------------------------------------------------------------------------------
VCubicBezier::VCubicBezier(const VCubicBezier &&curve) Q_DECL_NOTHROW
: VAbstractCubicBezier(curve), d(curve.d)
{}
//---------------------------------------------------------------------------------------------------------------------
VCubicBezier &VCubicBezier::operator=(VCubicBezier &&curve) Q_DECL_NOTHROW
{
Swap(curve);
VAbstractCubicBezier::operator=(curve);
std::swap(d, curve.d);
return *this;
}
#endif
//---------------------------------------------------------------------------------------------------------------------
void VCubicBezier::Swap(VCubicBezier &curve) Q_DECL_NOTHROW
{
VAbstractCubicBezier::Swap(curve);
std::swap(d, curve.d);
}
//---------------------------------------------------------------------------------------------------------------------
VCubicBezier VCubicBezier::Rotate(const QPointF &originPoint, qreal degrees, const QString &prefix) const
{

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

@ -57,11 +57,10 @@ public:
VCubicBezier &operator=(const VCubicBezier &curve);
#ifdef Q_COMPILER_RVALUE_REFS
VCubicBezier(const VCubicBezier &&curve) Q_DECL_NOTHROW;
VCubicBezier &operator=(VCubicBezier &&curve) Q_DECL_NOTHROW;
#endif
void Swap(VCubicBezier &curve) Q_DECL_NOTHROW;
virtual VPointF GetP1() const override;
void SetP1(const VPointF &p);

16
src/libs/vgeometry/vcubicbezierpath.cpp
View file

@ -79,21 +79,21 @@ VCubicBezierPath &VCubicBezierPath::operator=(const VCubicBezierPath &curve)
}
#ifdef Q_COMPILER_RVALUE_REFS
//---------------------------------------------------------------------------------------------------------------------
VCubicBezierPath::VCubicBezierPath(const VCubicBezierPath &&curve) Q_DECL_NOTHROW
: VAbstractCubicBezierPath(curve),
d(curve.d)
{}
//---------------------------------------------------------------------------------------------------------------------
VCubicBezierPath &VCubicBezierPath::operator=(VCubicBezierPath &&curve) Q_DECL_NOTHROW
{
Swap(curve);
VAbstractCubicBezierPath::operator=(curve);
std::swap(d, curve.d);
return *this;
}
#endif
//---------------------------------------------------------------------------------------------------------------------
void VCubicBezierPath::Swap(VCubicBezierPath &curve) Q_DECL_NOTHROW
{
VAbstractCubicBezierPath::Swap(curve);
std::swap(d, curve.d);
}
//---------------------------------------------------------------------------------------------------------------------
VCubicBezierPath VCubicBezierPath::Rotate(const QPointF &originPoint, qreal degrees, const QString &prefix) const
{

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

@ -58,11 +58,10 @@ public:
VCubicBezierPath &operator=(const VCubicBezierPath &curve);
#ifdef Q_COMPILER_RVALUE_REFS
VCubicBezierPath(const VCubicBezierPath &&curve) Q_DECL_NOTHROW;
VCubicBezierPath &operator=(VCubicBezierPath &&curve) Q_DECL_NOTHROW;
#endif
void Swap(VCubicBezierPath &curve) Q_DECL_NOTHROW;
VPointF &operator[](int indx);
const VPointF &at(int indx) const;

15
src/libs/vgeometry/vellipticalarc.cpp
View file

@ -124,21 +124,20 @@ VEllipticalArc &VEllipticalArc::operator =(const VEllipticalArc &arc)
}
#ifdef Q_COMPILER_RVALUE_REFS
//---------------------------------------------------------------------------------------------------------------------
VEllipticalArc::VEllipticalArc(const VEllipticalArc &&arc) Q_DECL_NOTHROW
: VAbstractArc(arc), d (arc.d)
{}
//---------------------------------------------------------------------------------------------------------------------
VEllipticalArc &VEllipticalArc::operator=(VEllipticalArc &&arc) Q_DECL_NOTHROW
{
Swap(arc);
VAbstractArc::operator=(arc);
std::swap(d, arc.d);
return *this;
}
#endif
//---------------------------------------------------------------------------------------------------------------------
void VEllipticalArc::Swap(VEllipticalArc &arc) Q_DECL_NOTHROW
{
VAbstractArc::Swap(arc);
std::swap(d, arc.d);
}
//---------------------------------------------------------------------------------------------------------------------
VEllipticalArc VEllipticalArc::Rotate(QPointF originPoint, qreal degrees, const QString &prefix) const
{

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

@ -69,11 +69,10 @@ public:
VEllipticalArc& operator= (const VEllipticalArc &arc);
#ifdef Q_COMPILER_RVALUE_REFS
VEllipticalArc(const VEllipticalArc &&arc) Q_DECL_NOTHROW;
VEllipticalArc &operator=(VEllipticalArc &&arc) Q_DECL_NOTHROW;
#endif
void Swap(VEllipticalArc &arc) Q_DECL_NOTHROW;
QString GetFormulaRotationAngle () const;
void SetFormulaRotationAngle (const QString &formula, qreal value);
qreal GetRotationAngle() const;

12
src/libs/vgeometry/vgobject.cpp
View file

@ -128,21 +128,19 @@ VGObject &VGObject::operator=(const VGObject &obj)
}
#ifdef Q_COMPILER_RVALUE_REFS
//---------------------------------------------------------------------------------------------------------------------
VGObject::VGObject(const VGObject &&obj) Q_DECL_NOTHROW
:d (obj.d)
{}
//---------------------------------------------------------------------------------------------------------------------
VGObject &VGObject::operator=(VGObject &&obj) Q_DECL_NOTHROW
{
Swap(obj);
std::swap(d, obj.d);
return *this;
}
#endif
//---------------------------------------------------------------------------------------------------------------------
void VGObject::Swap(VGObject &obj) Q_DECL_NOTHROW
{
std::swap(d, obj.d);
}
//---------------------------------------------------------------------------------------------------------------------
VGObject::~VGObject()
{}

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

@ -59,11 +59,10 @@ public:
VGObject& operator= (const VGObject &obj);
#ifdef Q_COMPILER_RVALUE_REFS
VGObject(const VGObject &&obj) Q_DECL_NOTHROW;
VGObject &operator=(VGObject &&obj) Q_DECL_NOTHROW;
#endif
void Swap(VGObject &obj) Q_DECL_NOTHROW;
quint32 getIdObject() const;
void setIdObject(const quint32 &value);

15
src/libs/vgeometry/vplacelabelitem.cpp
View file

@ -226,21 +226,20 @@ VPlaceLabelItem &VPlaceLabelItem::operator=(const VPlaceLabelItem &item)
}
#ifdef Q_COMPILER_RVALUE_REFS
//---------------------------------------------------------------------------------------------------------------------
VPlaceLabelItem::VPlaceLabelItem(const VPlaceLabelItem &&item) Q_DECL_NOTHROW
: VPointF(item), d(item.d)
{}
//---------------------------------------------------------------------------------------------------------------------
VPlaceLabelItem &VPlaceLabelItem::operator=(VPlaceLabelItem &&item) Q_DECL_NOTHROW
{
Swap(item);
VPointF::operator=(item);
std::swap(d, item.d);
return *this;
}
#endif
//---------------------------------------------------------------------------------------------------------------------
void VPlaceLabelItem::Swap(VPlaceLabelItem &item) Q_DECL_NOTHROW
{
VPointF::Swap(item);
std::swap(d, item.d);
}
//---------------------------------------------------------------------------------------------------------------------
PlaceLabelImg VPlaceLabelItem::LabelShape() const
{

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

@ -48,11 +48,10 @@ public:
VPlaceLabelItem &operator=(const VPlaceLabelItem &item);
#ifdef Q_COMPILER_RVALUE_REFS
VPlaceLabelItem(const VPlaceLabelItem &&item) Q_DECL_NOTHROW;
VPlaceLabelItem &operator=(VPlaceLabelItem &&item) Q_DECL_NOTHROW;
#endif
void Swap(VPlaceLabelItem &item) Q_DECL_NOTHROW;
QString GetWidthFormula() const;
QString& GetWidthFormula();
qreal GetWidth() const;

15
src/libs/vgeometry/vpointf.cpp
View file

@ -103,21 +103,20 @@ VPointF &VPointF::operator =(const VPointF &point)
}
#ifdef Q_COMPILER_RVALUE_REFS
//---------------------------------------------------------------------------------------------------------------------
VPointF::VPointF(const VPointF &&point) Q_DECL_NOTHROW
:VGObject(point), d(point.d)
{}
//---------------------------------------------------------------------------------------------------------------------
VPointF &VPointF::operator=(VPointF &&point) Q_DECL_NOTHROW
{
Swap(point);
VGObject::operator=(point);
std::swap(d, point.d);
return *this;
}
#endif
//---------------------------------------------------------------------------------------------------------------------
void VPointF::Swap(VPointF &point) Q_DECL_NOTHROW
{
VGObject::Swap(point);
std::swap(d, point.d);
}
//---------------------------------------------------------------------------------------------------------------------
VPointF::operator QPointF() const
{

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

@ -62,11 +62,10 @@ public:
VPointF &operator=(const VPointF &point);
#ifdef Q_COMPILER_RVALUE_REFS
VPointF(const VPointF &&point) Q_DECL_NOTHROW;
VPointF &operator=(VPointF &&point) Q_DECL_NOTHROW;
#endif
void Swap(VPointF &point) Q_DECL_NOTHROW;
explicit operator QPointF() const;
VPointF Rotate(const QPointF &originPoint, qreal degrees, const QString &prefix = QString()) const;
VPointF Flip(const QLineF &axis, const QString &prefix = QString()) const;

15
src/libs/vgeometry/vspline.cpp
View file

@ -248,21 +248,20 @@ VSpline &VSpline::operator =(const VSpline &spline)
}
#ifdef Q_COMPILER_RVALUE_REFS
//---------------------------------------------------------------------------------------------------------------------
VSpline::VSpline(const VSpline &&spline) Q_DECL_NOTHROW
:VAbstractCubicBezier(spline), d(spline.d)
{}
//---------------------------------------------------------------------------------------------------------------------
VSpline &VSpline::operator=(VSpline &&spline) Q_DECL_NOTHROW
{
Swap(spline);
VAbstractCubicBezier::operator=(spline);
std::swap(d, spline.d);
return *this;
}
#endif
//---------------------------------------------------------------------------------------------------------------------
void VSpline::Swap(VSpline &spline) Q_DECL_NOTHROW
{
VAbstractCubicBezier::Swap(spline);
std::swap(d, spline.d);
}
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief GetP1 return first spline point.

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

@ -67,11 +67,10 @@ public:
VSpline &operator=(const VSpline &spline);
#ifdef Q_COMPILER_RVALUE_REFS
VSpline(const VSpline &&spline) Q_DECL_NOTHROW;
VSpline &operator=(VSpline &&spline) Q_DECL_NOTHROW;
#endif
void Swap(VSpline &spline) Q_DECL_NOTHROW;
virtual VPointF GetP1 () const override;
void SetP1 (const VPointF &p);

16
src/libs/vgeometry/vsplinepath.cpp
View file

@ -304,21 +304,21 @@ VSplinePath &VSplinePath::operator =(const VSplinePath &path)
}
#ifdef Q_COMPILER_RVALUE_REFS
//---------------------------------------------------------------------------------------------------------------------
VSplinePath::VSplinePath(const VSplinePath &&splPath) Q_DECL_NOTHROW
: VAbstractCubicBezierPath(splPath),
d(splPath.d)
{}
//---------------------------------------------------------------------------------------------------------------------
VSplinePath &VSplinePath::operator=(VSplinePath &&path) Q_DECL_NOTHROW
{
Swap(path);
VAbstractCubicBezierPath::operator=(path);
std::swap(d, path.d);
return *this;
}
#endif
//---------------------------------------------------------------------------------------------------------------------
void VSplinePath::Swap(VSplinePath &path) Q_DECL_NOTHROW
{
VAbstractCubicBezierPath::Swap(path);
std::swap(d, path.d);
}
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief operator [] return spline point by index.

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

@ -67,11 +67,10 @@ public:
VSplinePoint &operator[](int indx);
VSplinePath &operator=(const VSplinePath &path);
#ifdef Q_COMPILER_RVALUE_REFS
VSplinePath(const VSplinePath&& splPath) Q_DECL_NOTHROW;
VSplinePath &operator=(VSplinePath &&path) Q_DECL_NOTHROW;
#endif
void Swap(VSplinePath &path) Q_DECL_NOTHROW;
void append(const VSplinePoint &point);
virtual qint32 CountSubSpl() const override;

25
src/libs/vgeometry/vsplinepoint.cpp
View file

@ -76,19 +76,19 @@ VFSplinePoint &VFSplinePoint::operator=(const VFSplinePoint &point)
}
#ifdef Q_COMPILER_RVALUE_REFS
//---------------------------------------------------------------------------------------------------------------------
VFSplinePoint::VFSplinePoint(const VFSplinePoint &&point) Q_DECL_NOTHROW
:d(point.d)
{}
//---------------------------------------------------------------------------------------------------------------------
VFSplinePoint &VFSplinePoint::operator=(VFSplinePoint &&point) Q_DECL_NOTHROW
{
Swap(point);
std::swap(d, point.d);
return *this;
}
#endif
void VFSplinePoint::Swap(VFSplinePoint &point) Q_DECL_NOTHROW
{
std::swap(d, point.d);
}
//---------------------------------------------------------------------------------------------------------------------
VFSplinePoint::~VFSplinePoint()
{}
@ -235,20 +235,19 @@ VSplinePoint &VSplinePoint::operator=(const VSplinePoint &point)
}
#ifdef Q_COMPILER_RVALUE_REFS
//---------------------------------------------------------------------------------------------------------------------
VSplinePoint::VSplinePoint(const VSplinePoint &&point) Q_DECL_NOTHROW
: d(point.d)
{}
//---------------------------------------------------------------------------------------------------------------------
VSplinePoint &VSplinePoint::operator=(VSplinePoint &&point) Q_DECL_NOTHROW
{
Swap(point);
std::swap(d, point.d);
return *this;
}
#endif
//---------------------------------------------------------------------------------------------------------------------
void VSplinePoint::Swap(VSplinePoint &point) Q_DECL_NOTHROW
{
std::swap(d, point.d);
}
//---------------------------------------------------------------------------------------------------------------------
VSplinePoint::~VSplinePoint()
{

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

@ -53,11 +53,10 @@ public:
VFSplinePoint &operator=(const VFSplinePoint &point);
#ifdef Q_COMPILER_RVALUE_REFS
VFSplinePoint(const VFSplinePoint &&point) Q_DECL_NOTHROW;
VFSplinePoint &operator=(VFSplinePoint &&point) Q_DECL_NOTHROW;
#endif
void Swap(VFSplinePoint &point) Q_DECL_NOTHROW;
VPointF P() const;
void SetP(const VPointF &value);
qreal Angle1() const;
@ -92,11 +91,10 @@ public:
VSplinePoint &operator=(const VSplinePoint &point);
#ifdef Q_COMPILER_RVALUE_REFS
VSplinePoint(const VSplinePoint &&point) Q_DECL_NOTHROW;
VSplinePoint &operator=(VSplinePoint &&point) Q_DECL_NOTHROW;
#endif
void Swap(VSplinePoint &point) Q_DECL_NOTHROW;
VPointF P() const;
void SetP(const VPointF &value);

13
src/libs/vlayout/vabstractpiece.cpp
View file

@ -919,20 +919,19 @@ VAbstractPiece &VAbstractPiece::operator=(const VAbstractPiece &piece)
}
#ifdef Q_COMPILER_RVALUE_REFS
//---------------------------------------------------------------------------------------------------------------------
VAbstractPiece::VAbstractPiece(const VAbstractPiece &&piece) Q_DECL_NOTHROW
:d (piece.d)
{}
//---------------------------------------------------------------------------------------------------------------------
VAbstractPiece &VAbstractPiece::operator=(VAbstractPiece &&piece) Q_DECL_NOTHROW
{
Swap(piece);
std::swap(d, piece.d);
return *this;
}
#endif
//---------------------------------------------------------------------------------------------------------------------
void VAbstractPiece::Swap(VAbstractPiece &piece) Q_DECL_NOTHROW
{
std::swap(d, piece.d);
}
//---------------------------------------------------------------------------------------------------------------------
VAbstractPiece::~VAbstractPiece()
{}

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

@ -57,11 +57,10 @@ public:
VAbstractPiece &operator=(const VAbstractPiece &piece);
#ifdef Q_COMPILER_RVALUE_REFS
VAbstractPiece(const VAbstractPiece &&piece) Q_DECL_NOTHROW;
VAbstractPiece &operator=(VAbstractPiece &&piece) Q_DECL_NOTHROW;
#endif
void Swap(VAbstractPiece &piece) Q_DECL_NOTHROW;
QString GetName() const;
void SetName(const QString &value);

13
src/libs/vlayout/vbestsquare.cpp
View file

@ -72,20 +72,19 @@ VBestSquare &VBestSquare::operator=(const VBestSquare &res)
}
#ifdef Q_COMPILER_RVALUE_REFS
//---------------------------------------------------------------------------------------------------------------------
VBestSquare::VBestSquare(const VBestSquare &&res) Q_DECL_NOTHROW
: d(res.d)
{}
//---------------------------------------------------------------------------------------------------------------------
VBestSquare &VBestSquare::operator=(VBestSquare &&res) Q_DECL_NOTHROW
{
Swap(res);
std::swap(d, res.d);
return *this;
}
#endif
//---------------------------------------------------------------------------------------------------------------------
void VBestSquare::Swap(VBestSquare &res) Q_DECL_NOTHROW
{
std::swap(d, res.d);
}
//---------------------------------------------------------------------------------------------------------------------
void VBestSquare::NewResult(const VBestSquareResData &data)
{

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

@ -49,11 +49,10 @@ public:
VBestSquare &operator=(const VBestSquare &res);
#ifdef Q_COMPILER_RVALUE_REFS
VBestSquare(const VBestSquare &&res) Q_DECL_NOTHROW;
VBestSquare &operator=(VBestSquare &&res) Q_DECL_NOTHROW;
#endif
void Swap(VBestSquare &res) Q_DECL_NOTHROW;
void NewResult(const VBestSquareResData &data);
void NewResult(const VBestSquare &best);

13
src/libs/vlayout/vcontour.cpp
View file

@ -125,20 +125,19 @@ VContour &VContour::operator=(const VContour &contour)
}
#ifdef Q_COMPILER_RVALUE_REFS
//---------------------------------------------------------------------------------------------------------------------
VContour::VContour(const VContour &&contour) Q_DECL_NOTHROW
:d (contour.d)
{}
//---------------------------------------------------------------------------------------------------------------------
VContour &VContour::operator=(VContour &&contour) Q_DECL_NOTHROW
{
Swap(contour);
std::swap(d, contour.d);
return *this;
}
#endif
//---------------------------------------------------------------------------------------------------------------------
void VContour::Swap(VContour &contour) Q_DECL_NOTHROW
{
std::swap(d, contour.d);
}
//---------------------------------------------------------------------------------------------------------------------
VContour::~VContour()
{}

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

@ -55,11 +55,10 @@ public:
VContour &operator=(const VContour &contour);
#ifdef Q_COMPILER_RVALUE_REFS
VContour(const VContour &&contour) Q_DECL_NOTHROW;
VContour &operator=(VContour &&contour) Q_DECL_NOTHROW;
#endif
void Swap(VContour &contour) Q_DECL_NOTHROW;
void CeateEmptySheetContour();
void SetContour(const QVector<QPointF> &contour);

13
src/libs/vlayout/vlayoutpaper.cpp
View file

@ -77,20 +77,19 @@ VLayoutPaper &VLayoutPaper::operator=(const VLayoutPaper &paper)
}
#ifdef Q_COMPILER_RVALUE_REFS
//---------------------------------------------------------------------------------------------------------------------
VLayoutPaper::VLayoutPaper(const VLayoutPaper &&paper) Q_DECL_NOTHROW
:d (paper.d)
{}
//---------------------------------------------------------------------------------------------------------------------
VLayoutPaper &VLayoutPaper::operator=(VLayoutPaper &&paper) Q_DECL_NOTHROW
{
Swap(paper);
std::swap(d, paper.d);
return *this;
}
#endif
//---------------------------------------------------------------------------------------------------------------------
void VLayoutPaper::Swap(VLayoutPaper &paper) Q_DECL_NOTHROW
{
std::swap(d, paper.d);
}
//---------------------------------------------------------------------------------------------------------------------
VLayoutPaper::~VLayoutPaper()
{}

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

@ -58,11 +58,10 @@ public:
VLayoutPaper &operator=(const VLayoutPaper &paper);
#ifdef Q_COMPILER_RVALUE_REFS
VLayoutPaper(const VLayoutPaper &&paper) Q_DECL_NOTHROW;
VLayoutPaper &operator=(VLayoutPaper &&paper) Q_DECL_NOTHROW;
#endif
void Swap(VLayoutPaper &paper) Q_DECL_NOTHROW;
int GetHeight() const;
void SetHeight(int height);

15
src/libs/vlayout/vlayoutpiece.cpp
View file

@ -405,21 +405,20 @@ VLayoutPiece &VLayoutPiece::operator=(const VLayoutPiece &detail)
}
#ifdef Q_COMPILER_RVALUE_REFS
//---------------------------------------------------------------------------------------------------------------------
VLayoutPiece::VLayoutPiece(const VLayoutPiece &&detail) Q_DECL_NOTHROW
:VAbstractPiece(detail), d(detail.d)
{}
//---------------------------------------------------------------------------------------------------------------------
VLayoutPiece &VLayoutPiece::operator=(VLayoutPiece &&detail) Q_DECL_NOTHROW
{
Swap(detail);
VAbstractPiece::operator=(detail);
std::swap(d, detail.d);
return *this;
}
#endif
//---------------------------------------------------------------------------------------------------------------------
void VLayoutPiece::Swap(VLayoutPiece &detail) Q_DECL_NOTHROW
{
VAbstractPiece::Swap(detail);
std::swap(d, detail.d);
}
//---------------------------------------------------------------------------------------------------------------------
VLayoutPiece::~VLayoutPiece()
{}

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

@ -67,11 +67,10 @@ public:
VLayoutPiece &operator=(const VLayoutPiece &detail);
#ifdef Q_COMPILER_RVALUE_REFS
VLayoutPiece(const VLayoutPiece &&detail) Q_DECL_NOTHROW;
VLayoutPiece &operator=(VLayoutPiece &&detail) Q_DECL_NOTHROW;
#endif
void Swap(VLayoutPiece &detail) Q_DECL_NOTHROW;
static VLayoutPiece Create(const VPiece &piece, vidtype id, const VContainer *pattern);
QVector<QPointF> GetMappedContourPoints() const;

13
src/libs/vlayout/vlayoutpiecepath.cpp
View file

@ -80,20 +80,19 @@ VLayoutPiecePath &VLayoutPiecePath::operator=(const VLayoutPiecePath &path)
}
#ifdef Q_COMPILER_RVALUE_REFS
//---------------------------------------------------------------------------------------------------------------------
VLayoutPiecePath::VLayoutPiecePath(const VLayoutPiecePath &&path) Q_DECL_NOTHROW
: d(path.d)
{}
//---------------------------------------------------------------------------------------------------------------------
VLayoutPiecePath &VLayoutPiecePath::operator=(VLayoutPiecePath &&path) Q_DECL_NOTHROW
{
Swap(path);
std::swap(d, path.d);
return *this;
}
#endif
//---------------------------------------------------------------------------------------------------------------------
void VLayoutPiecePath::Swap(VLayoutPiecePath &path) Q_DECL_NOTHROW
{
std::swap(d, path.d);
}
//---------------------------------------------------------------------------------------------------------------------
VLayoutPiecePath::~VLayoutPiecePath()
{

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

@ -47,11 +47,10 @@ public:
VLayoutPiecePath &operator=(const VLayoutPiecePath &path);
#ifdef Q_COMPILER_RVALUE_REFS
VLayoutPiecePath(const VLayoutPiecePath &&path) Q_DECL_NOTHROW;
VLayoutPiecePath &operator=(VLayoutPiecePath &&path) Q_DECL_NOTHROW;
#endif
void Swap(VLayoutPiecePath &path) Q_DECL_NOTHROW;
QPainterPath GetPainterPath() const;
QVector<QPointF> Points() const;

13
src/libs/vpatterndb/floatItemData/vabstractfloatitemdata.cpp
View file

@ -51,20 +51,19 @@ VAbstractFloatItemData &VAbstractFloatItemData::operator=(const VAbstractFloatIt
}
#ifdef Q_COMPILER_RVALUE_REFS
//---------------------------------------------------------------------------------------------------------------------
VAbstractFloatItemData::VAbstractFloatItemData(const VAbstractFloatItemData &&data) Q_DECL_NOTHROW
: d (data.d)
{}
//---------------------------------------------------------------------------------------------------------------------
VAbstractFloatItemData &VAbstractFloatItemData::operator=(VAbstractFloatItemData &&data) Q_DECL_NOTHROW
{
Swap(data);
std::swap(d, data.d);
return *this;
}
#endif
//---------------------------------------------------------------------------------------------------------------------
void VAbstractFloatItemData::Swap(VAbstractFloatItemData &data) Q_DECL_NOTHROW
{
std::swap(d, data.d);
}
//---------------------------------------------------------------------------------------------------------------------
VAbstractFloatItemData::~VAbstractFloatItemData()
{}

3
src/libs/vpatterndb/floatItemData/vabstractfloatitemdata.h
View file

@ -44,11 +44,10 @@ public:
VAbstractFloatItemData &operator=(const VAbstractFloatItemData &data);
#ifdef Q_COMPILER_RVALUE_REFS
VAbstractFloatItemData(const VAbstractFloatItemData &&data) Q_DECL_NOTHROW;
VAbstractFloatItemData &operator=(VAbstractFloatItemData &&data) Q_DECL_NOTHROW;
#endif
void Swap(VAbstractFloatItemData &data) Q_DECL_NOTHROW;
// methods, which set and return values of different parameters
QPointF GetPos() const;
void SetPos(const QPointF& ptPos);

16
src/libs/vpatterndb/floatItemData/vgrainlinedata.cpp
View file

@ -56,21 +56,21 @@ VGrainlineData &VGrainlineData::operator=(const VGrainlineData &data)
}
#ifdef Q_COMPILER_RVALUE_REFS
//---------------------------------------------------------------------------------------------------------------------
VGrainlineData::VGrainlineData(const VGrainlineData &&data) Q_DECL_NOTHROW
: VAbstractFloatItemData(data),
d (data.d)
{}
//---------------------------------------------------------------------------------------------------------------------
VGrainlineData &VGrainlineData::operator=(VGrainlineData &&data) Q_DECL_NOTHROW
{
Swap(data);
VAbstractFloatItemData::operator=(data);
std::swap(d, data.d);
return *this;
}
#endif
//---------------------------------------------------------------------------------------------------------------------
void VGrainlineData::Swap(VGrainlineData &data) Q_DECL_NOTHROW
{
VAbstractFloatItemData::Swap(data);
std::swap(d, data.d);
}
//---------------------------------------------------------------------------------------------------------------------
VGrainlineData::~VGrainlineData()
{}

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

@ -51,11 +51,10 @@ public:
VGrainlineData &operator=(const VGrainlineData &data);
#ifdef Q_COMPILER_RVALUE_REFS
VGrainlineData(const VGrainlineData &&data) Q_DECL_NOTHROW;
VGrainlineData &operator=(VGrainlineData &&data) Q_DECL_NOTHROW;
#endif
void Swap(VGrainlineData &data) Q_DECL_NOTHROW;
// methods, which set and return values of different parameters
QString GetLength() const;
void SetLength(const QString& qsLen);

16
src/libs/vpatterndb/floatItemData/vpatternlabeldata.cpp
View file

@ -55,21 +55,21 @@ VPatternLabelData &VPatternLabelData::operator=(const VPatternLabelData &data)
}
#ifdef Q_COMPILER_RVALUE_REFS
//---------------------------------------------------------------------------------------------------------------------
VPatternLabelData::VPatternLabelData(const VPatternLabelData &&data) Q_DECL_NOTHROW
: VAbstractFloatItemData(data),
d (data.d)
{}
//---------------------------------------------------------------------------------------------------------------------
VPatternLabelData &VPatternLabelData::operator=(VPatternLabelData &&data) Q_DECL_NOTHROW
{
Swap(data);
VAbstractFloatItemData::operator=(data);
std::swap(d, data.d);
return *this;
}
#endif
//---------------------------------------------------------------------------------------------------------------------
void VPatternLabelData::Swap(VPatternLabelData &data) Q_DECL_NOTHROW
{
VAbstractFloatItemData::Swap(data);
std::swap(d, data.d);
}
//---------------------------------------------------------------------------------------------------------------------
VPatternLabelData::~VPatternLabelData()
{}

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

@ -48,11 +48,10 @@ public:
VPatternLabelData &operator=(const VPatternLabelData &data);
#ifdef Q_COMPILER_RVALUE_REFS
VPatternLabelData(const VPatternLabelData &&data) Q_DECL_NOTHROW;
VPatternLabelData &operator=(VPatternLabelData &&data) Q_DECL_NOTHROW;
#endif
void Swap(VPatternLabelData &data) Q_DECL_NOTHROW;
// methods, which set up label parameters
QString GetLabelWidth() const;
void SetLabelWidth(const QString &dLabelW);

16
src/libs/vpatterndb/floatItemData/vpiecelabeldata.cpp
View file

@ -56,21 +56,21 @@ VPieceLabelData &VPieceLabelData::operator=(const VPieceLabelData &data)
}
#ifdef Q_COMPILER_RVALUE_REFS
//---------------------------------------------------------------------------------------------------------------------
VPieceLabelData::VPieceLabelData(const VPieceLabelData &&data) Q_DECL_NOTHROW
: VPatternLabelData(data),
d (data.d)
{}
//---------------------------------------------------------------------------------------------------------------------
VPieceLabelData &VPieceLabelData::operator=(VPieceLabelData &&data) Q_DECL_NOTHROW
{
Swap(data);
VPatternLabelData::operator=(data);
std::swap(d, data.d);
return *this;
}
#endif
//---------------------------------------------------------------------------------------------------------------------
void VPieceLabelData::Swap(VPieceLabelData &data) Q_DECL_NOTHROW
{
VPatternLabelData::Swap(data);
std::swap(d, data.d);
}
//---------------------------------------------------------------------------------------------------------------------
VPieceLabelData::~VPieceLabelData()
{}

3
src/libs/vpatterndb/floatItemData/vpiecelabeldata.h
View file

@ -51,11 +51,10 @@ public:
VPieceLabelData &operator=(const VPieceLabelData &data);
#ifdef Q_COMPILER_RVALUE_REFS
VPieceLabelData(const VPieceLabelData &&data) Q_DECL_NOTHROW;
VPieceLabelData &operator=(VPieceLabelData &&data) Q_DECL_NOTHROW;
#endif
void Swap(VPieceLabelData &data) Q_DECL_NOTHROW;
void Clear();
// methods, which operate on other members

15
src/libs/vpatterndb/variables/vcurvevariable.cpp
View file

@ -65,21 +65,20 @@ VCurveVariable &VCurveVariable::operator=(const VCurveVariable &var)
}
#ifdef Q_COMPILER_RVALUE_REFS
//---------------------------------------------------------------------------------------------------------------------
VCurveVariable::VCurveVariable(const VCurveVariable &&var) Q_DECL_NOTHROW
:VInternalVariable(var), d(var.d)
{}
//---------------------------------------------------------------------------------------------------------------------
VCurveVariable &VCurveVariable::operator=(VCurveVariable &&var) Q_DECL_NOTHROW
{
Swap(var);
VInternalVariable::operator=(var);
std::swap(d, var.d);
return *this;
}
#endif
//---------------------------------------------------------------------------------------------------------------------
void VCurveVariable::Swap(VCurveVariable &var) Q_DECL_NOTHROW
{
VInternalVariable::Swap(var);
std::swap(d, var.d);
}
//---------------------------------------------------------------------------------------------------------------------
VCurveVariable::~VCurveVariable()
{}

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

@ -49,11 +49,10 @@ public:
VCurveVariable &operator=(const VCurveVariable &var);
#ifdef Q_COMPILER_RVALUE_REFS
VCurveVariable(const VCurveVariable &&var) Q_DECL_NOTHROW;
VCurveVariable &operator=(VCurveVariable &&var) Q_DECL_NOTHROW;
#endif
void Swap(VCurveVariable &var) Q_DECL_NOTHROW;
virtual bool Filter(quint32 id) override;
quint32 GetId() const;

15
src/libs/vpatterndb/variables/vincrement.cpp
View file

@ -71,21 +71,20 @@ VIncrement &VIncrement::operator=(const VIncrement &incr)
}
#ifdef Q_COMPILER_RVALUE_REFS
//---------------------------------------------------------------------------------------------------------------------
VIncrement::VIncrement(const VIncrement &&incr) Q_DECL_NOTHROW
:VVariable(incr), d(incr.d)
{}
//---------------------------------------------------------------------------------------------------------------------
VIncrement &VIncrement::operator=(VIncrement &&incr) Q_DECL_NOTHROW
{
Swap(incr);
VVariable::operator=(incr);
std::swap(d, incr.d);
return *this;
}
#endif
//---------------------------------------------------------------------------------------------------------------------
void VIncrement::Swap(VIncrement &incr) Q_DECL_NOTHROW
{
VVariable::Swap(incr);
std::swap(d, incr.d);
}
//---------------------------------------------------------------------------------------------------------------------
VIncrement::~VIncrement()
{}

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

@ -54,11 +54,10 @@ public:
VIncrement &operator=(const VIncrement &incr);
#ifdef Q_COMPILER_RVALUE_REFS
VIncrement(const VIncrement &&incr) Q_DECL_NOTHROW;
VIncrement &operator=(VIncrement &&incr) Q_DECL_NOTHROW;
#endif
void Swap(VIncrement &incr) Q_DECL_NOTHROW;
void SetFormula(qreal base, const QString &formula, bool ok);
QString GetFormula() const;
bool IsFormulaOk() const;

13
src/libs/vpatterndb/variables/vinternalvariable.cpp
View file

@ -50,21 +50,20 @@ VInternalVariable &VInternalVariable::operator=(const VInternalVariable &var)
return *this;
}
//---------------------------------------------------------------------------------------------------------------------
VInternalVariable::VInternalVariable(const VInternalVariable &&var) Q_DECL_NOTHROW
:d(var.d)
{}
#ifdef Q_COMPILER_RVALUE_REFS
//---------------------------------------------------------------------------------------------------------------------
VInternalVariable &VInternalVariable::operator=(VInternalVariable &&var) Q_DECL_NOTHROW
{
Swap(var);
std::swap(d, var.d);
return *this;
}
#endif
//---------------------------------------------------------------------------------------------------------------------
void VInternalVariable::Swap(VInternalVariable &var) Q_DECL_NOTHROW
{
std::swap(d, var.d);
}
//---------------------------------------------------------------------------------------------------------------------
VInternalVariable::~VInternalVariable()
{}

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

@ -48,11 +48,10 @@ public:
VInternalVariable &operator=(const VInternalVariable &var);
#ifdef Q_COMPILER_RVALUE_REFS
VInternalVariable(const VInternalVariable &&var) Q_DECL_NOTHROW;
VInternalVariable &operator=(VInternalVariable &&var) Q_DECL_NOTHROW;
#endif
void Swap(VInternalVariable &var) Q_DECL_NOTHROW;
virtual qreal GetValue() const;
virtual qreal* GetValue();

15
src/libs/vpatterndb/variables/vlineangle.cpp
View file

@ -77,22 +77,21 @@ VLineAngle &VLineAngle::operator=(const VLineAngle &var)
return *this;
}
//---------------------------------------------------------------------------------------------------------------------
VLineAngle::VLineAngle(const VLineAngle &&var) Q_DECL_NOTHROW
:VInternalVariable(var), d(var.d)
{}
#ifdef Q_COMPILER_RVALUE_REFS
//---------------------------------------------------------------------------------------------------------------------
VLineAngle &VLineAngle::operator=(VLineAngle &&var) Q_DECL_NOTHROW
{
Swap(var);
VInternalVariable::operator=(var);
std::swap(d, var.d);
return *this;
}
#endif
//---------------------------------------------------------------------------------------------------------------------
void VLineAngle::Swap(VLineAngle &var) Q_DECL_NOTHROW
{
VInternalVariable::Swap(var);
std::swap(d, var.d);
}
//---------------------------------------------------------------------------------------------------------------------
VLineAngle::~VLineAngle()
{}

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

@ -50,11 +50,10 @@ public:
VLineAngle &operator=(const VLineAngle &var);
#ifdef Q_COMPILER_RVALUE_REFS
VLineAngle(const VLineAngle &&var) Q_DECL_NOTHROW;
VLineAngle &operator=(VLineAngle &&var) Q_DECL_NOTHROW;
#endif
void Swap(VLineAngle &var) Q_DECL_NOTHROW;
virtual bool Filter(quint32 id) override;
void SetValue(const VPointF *p1, const VPointF *p2);
quint32 GetP1Id() const;

15
src/libs/vpatterndb/variables/vlinelength.cpp
View file

@ -75,22 +75,21 @@ VLengthLine &VLengthLine::operator=(const VLengthLine &var)
return *this;
}
//---------------------------------------------------------------------------------------------------------------------
VLengthLine::VLengthLine(const VLengthLine &&var) Q_DECL_NOTHROW
:VInternalVariable(var), d(var.d)
{}
#ifdef Q_COMPILER_RVALUE_REFS
//---------------------------------------------------------------------------------------------------------------------
VLengthLine &VLengthLine::operator=(VLengthLine &&var) Q_DECL_NOTHROW
{
Swap(var);
VInternalVariable::operator=(var);
std::swap(d, var.d);
return *this;
}
#endif
//---------------------------------------------------------------------------------------------------------------------
void VLengthLine::Swap(VLengthLine &var) Q_DECL_NOTHROW
{
VInternalVariable::Swap(var);
std::swap(d, var.d);
}
//---------------------------------------------------------------------------------------------------------------------
VLengthLine::~VLengthLine()
{}

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

@ -52,11 +52,10 @@ public:
VLengthLine &operator=(const VLengthLine &var);
#ifdef Q_COMPILER_RVALUE_REFS
VLengthLine(const VLengthLine &&var) Q_DECL_NOTHROW;
VLengthLine &operator=(VLengthLine &&var) Q_DECL_NOTHROW;
#endif
void Swap(VLengthLine &var) Q_DECL_NOTHROW;
virtual bool Filter(quint32 id) override;
void SetValue(const VPointF *p1, const VPointF *p2);
quint32 GetP1Id() const;

15
src/libs/vpatterndb/variables/vmeasurement.cpp
View file

@ -93,21 +93,20 @@ VMeasurement &VMeasurement::operator=(const VMeasurement &m)
}
#ifdef Q_COMPILER_RVALUE_REFS
//---------------------------------------------------------------------------------------------------------------------
VMeasurement::VMeasurement(const VMeasurement &&m) Q_DECL_NOTHROW
:VVariable(m), d(m.d)
{}
//---------------------------------------------------------------------------------------------------------------------
VMeasurement &VMeasurement::operator=(VMeasurement &&m) Q_DECL_NOTHROW
{
Swap(m);
VVariable::operator=(m);
std::swap(d, m.d);
return *this;
}
#endif
//---------------------------------------------------------------------------------------------------------------------
void VMeasurement::Swap(VMeasurement &m) Q_DECL_NOTHROW
{
VVariable::Swap(m);
std::swap(d, m.d);
}
//---------------------------------------------------------------------------------------------------------------------
VMeasurement::~VMeasurement()
{}

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

@ -62,11 +62,10 @@ public:
VMeasurement &operator=(const VMeasurement &m);
#ifdef Q_COMPILER_RVALUE_REFS
VMeasurement(const VMeasurement &&m) Q_DECL_NOTHROW;
VMeasurement &operator=(VMeasurement &&m) Q_DECL_NOTHROW;
#endif
void Swap(VMeasurement &m) Q_DECL_NOTHROW;
QString GetGuiText() const;
QString TagName() const;

15
src/libs/vpatterndb/variables/vvariable.cpp
View file

@ -64,21 +64,20 @@ VVariable &VVariable::operator=(const VVariable &var)
}
#ifdef Q_COMPILER_RVALUE_REFS
//---------------------------------------------------------------------------------------------------------------------
VVariable::VVariable(const VVariable &&var) Q_DECL_NOTHROW
:VInternalVariable(var), d(var.d)
{}
//---------------------------------------------------------------------------------------------------------------------
VVariable &VVariable::operator=(VVariable &&var) Q_DECL_NOTHROW
{
Swap(var);
VInternalVariable::operator=(var);
std::swap(d, var.d);
return *this;
}
#endif
//---------------------------------------------------------------------------------------------------------------------
void VVariable::Swap(VVariable &var) Q_DECL_NOTHROW
{
VInternalVariable::Swap(var);
std::swap(d, var.d);
}
//---------------------------------------------------------------------------------------------------------------------
VVariable::~VVariable()
{}

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

@ -52,11 +52,10 @@ public:
VVariable &operator=(const VVariable &var);
#ifdef Q_COMPILER_RVALUE_REFS
VVariable(const VVariable &&var) Q_DECL_NOTHROW;
VVariable &operator=(VVariable &&var) Q_DECL_NOTHROW;
#endif
void Swap(VVariable &var) Q_DECL_NOTHROW;
QString GetDescription() const;
void SetDescription(const QString &desc);

13
src/libs/vpatterndb/vcontainer.cpp
View file

@ -131,20 +131,19 @@ VContainer &VContainer::operator =(const VContainer &data)
}
#ifdef Q_COMPILER_RVALUE_REFS
//---------------------------------------------------------------------------------------------------------------------
VContainer::VContainer(const VContainer &&data) Q_DECL_NOTHROW
:d(data.d)
{}
//---------------------------------------------------------------------------------------------------------------------
VContainer &VContainer::operator=(VContainer &&data) Q_DECL_NOTHROW
{
Swap(data);
std::swap(d, data.d);
return *this;
}
#endif
//---------------------------------------------------------------------------------------------------------------------
void VContainer::Swap(VContainer &data) Q_DECL_NOTHROW
{
std::swap(d, data.d);
}
//---------------------------------------------------------------------------------------------------------------------
/**
* @brief VContainer create container from another container

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

@ -131,11 +131,10 @@ public:
VContainer &operator=(const VContainer &data);
#ifdef Q_COMPILER_RVALUE_REFS
VContainer(const VContainer &&data) Q_DECL_NOTHROW;
VContainer &operator=(VContainer &&data) Q_DECL_NOTHROW;
#endif
void Swap(VContainer &data) Q_DECL_NOTHROW;
static QString UniqueNamespace();
template <typename T>

13
src/libs/vpatterndb/vnodedetail.cpp
View file

@ -123,20 +123,19 @@ VNodeDetail &VNodeDetail::operator =(const VNodeDetail &node)
}
#ifdef Q_COMPILER_RVALUE_REFS
//---------------------------------------------------------------------------------------------------------------------
VNodeDetail::VNodeDetail(const VNodeDetail &&node) Q_DECL_NOTHROW
:d (node.d)
{}
//---------------------------------------------------------------------------------------------------------------------
VNodeDetail &VNodeDetail::operator=(VNodeDetail &&node) Q_DECL_NOTHROW
{
Swap(node);
std::swap(d, node.d);
return *this;
}
#endif
//---------------------------------------------------------------------------------------------------------------------
void VNodeDetail::Swap(VNodeDetail &node) Q_DECL_NOTHROW
{
std::swap(d, node.d);
}
//---------------------------------------------------------------------------------------------------------------------
VNodeDetail::~VNodeDetail()
{}

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

@ -74,11 +74,10 @@ public:
*/
VNodeDetail &operator=(const VNodeDetail &node);
#ifdef Q_COMPILER_RVALUE_REFS
VNodeDetail(const VNodeDetail &&node) Q_DECL_NOTHROW;
VNodeDetail &operator=(VNodeDetail &&node) Q_DECL_NOTHROW;
#endif
void Swap(VNodeDetail &node) Q_DECL_NOTHROW;
/**
* @brief getId return object id.
* @return id.

15
src/libs/vpatterndb/vpiece.cpp
View file

@ -132,21 +132,20 @@ VPiece &VPiece::operator=(const VPiece &piece)
}
#ifdef Q_COMPILER_RVALUE_REFS
//---------------------------------------------------------------------------------------------------------------------
VPiece::VPiece(const VPiece &&piece) Q_DECL_NOTHROW
: VAbstractPiece(piece), d (piece.d)
{}
//---------------------------------------------------------------------------------------------------------------------
VPiece &VPiece::operator=(VPiece &&piece) Q_DECL_NOTHROW
{
Swap(piece);
VAbstractPiece::operator=(piece);
std::swap(d, piece.d);
return *this;
}
#endif
//---------------------------------------------------------------------------------------------------------------------
void VPiece::Swap(VPiece &piece) Q_DECL_NOTHROW
{
VAbstractPiece::Swap(piece);
std::swap(d, piece.d);
}
//---------------------------------------------------------------------------------------------------------------------
VPiece::~VPiece()
{}

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

@ -57,11 +57,10 @@ public:
VPiece &operator=(const VPiece &piece);
#ifdef Q_COMPILER_RVALUE_REFS
VPiece(const VPiece &&piece) Q_DECL_NOTHROW;
VPiece &operator=(VPiece &&piece) Q_DECL_NOTHROW;
#endif
void Swap(VPiece &piece) Q_DECL_NOTHROW;
VPiecePath GetPath() const;
VPiecePath &GetPath();
void SetPath(const VPiecePath &path);

13
src/libs/vpatterndb/vpiecenode.cpp
View file

@ -66,20 +66,19 @@ VPieceNode &VPieceNode::operator=(const VPieceNode &node)
}
#ifdef Q_COMPILER_RVALUE_REFS
//---------------------------------------------------------------------------------------------------------------------
VPieceNode::VPieceNode(const VPieceNode &&node) Q_DECL_NOTHROW
: d (node.d)
{}
//---------------------------------------------------------------------------------------------------------------------
VPieceNode &VPieceNode::operator=(VPieceNode &&node) Q_DECL_NOTHROW
{
Swap(node);
std::swap(d, node.d);
return *this;
}
#endif
//---------------------------------------------------------------------------------------------------------------------
void VPieceNode::Swap(VPieceNode &node) Q_DECL_NOTHROW
{
std::swap(d, node.d);
}
//---------------------------------------------------------------------------------------------------------------------
VPieceNode::~VPieceNode()
{}

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

@ -49,11 +49,10 @@ public:
VPieceNode &operator=(const VPieceNode &node);
#ifdef Q_COMPILER_RVALUE_REFS
VPieceNode(const VPieceNode &&node) Q_DECL_NOTHROW;
VPieceNode &operator=(VPieceNode &&node) Q_DECL_NOTHROW;
#endif
void Swap(VPieceNode &node) Q_DECL_NOTHROW;
friend QDataStream& operator<<(QDataStream& out, const VPieceNode& p);
friend QDataStream& operator>>(QDataStream& in, VPieceNode& p);

13
src/libs/vpatterndb/vpiecepath.cpp
View file

@ -219,20 +219,19 @@ VPiecePath &VPiecePath::operator=(const VPiecePath &path)
}
#ifdef Q_COMPILER_RVALUE_REFS
//---------------------------------------------------------------------------------------------------------------------
VPiecePath::VPiecePath(const VPiecePath &&path) Q_DECL_NOTHROW
: d (path.d)
{}
//---------------------------------------------------------------------------------------------------------------------
VPiecePath &VPiecePath::operator=(VPiecePath &&path) Q_DECL_NOTHROW
{
Swap(path);
std::swap(d, path.d);
return *this;
}
#endif
//---------------------------------------------------------------------------------------------------------------------
void VPiecePath::Swap(VPiecePath &path) Q_DECL_NOTHROW
{
std::swap(d, path.d);
}
//---------------------------------------------------------------------------------------------------------------------
VPiecePath::~VPiecePath()
{}

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

@ -54,11 +54,10 @@ public:
VPiecePath &operator=(const VPiecePath &path);
#ifdef Q_COMPILER_RVALUE_REFS
VPiecePath(const VPiecePath &&path) Q_DECL_NOTHROW;
VPiecePath &operator=(VPiecePath &&path) Q_DECL_NOTHROW;
#endif
void Swap(VPiecePath &path) Q_DECL_NOTHROW;
void Append(const VPieceNode &node);
void Clear();
qint32 CountNodes() const;