From c703b2d22c3f45825d9c9d790c3b5a4b6f97e776 Mon Sep 17 00:00:00 2001 From: Tomaž Vajngerl Date: Wed, 12 May 2021 19:00:32 +0900 Subject: basegfx: generalise tuples with template class Tuple2D and Tuple3D MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit B2DTuple2D, B2ITuple2D and B2I64Tuple share a lot in common so we can generalise it as a template class. The same goes for the 3D variants - B3DTuple and B3ITuple. This is the initial attempt, but doesn't yet generalise all that is possible. Add some tests for the tuple variants that test the behaviour of overloaded operators and other common methods. Change-Id: Iee5ed15d58ea88e65ee7854bd05a87ceab22023d Reviewed-on: https://gerrit.libreoffice.org/c/core/+/117104 Tested-by: Jenkins Reviewed-by: Tomaž Vajngerl --- include/basegfx/tuple/Tuple2D.hxx | 157 +++++++++++++++++++++++++++++++++++ include/basegfx/tuple/Tuple3D.hxx | 139 +++++++++++++++++++++++++++++++ include/basegfx/tuple/b2dtuple.hxx | 121 +-------------------------- include/basegfx/tuple/b2i64tuple.hxx | 105 ++--------------------- include/basegfx/tuple/b2ituple.hxx | 119 ++------------------------ include/basegfx/tuple/b3dtuple.hxx | 109 ++---------------------- include/basegfx/tuple/b3ituple.hxx | 87 +------------------ 7 files changed, 325 insertions(+), 512 deletions(-) create mode 100644 include/basegfx/tuple/Tuple2D.hxx create mode 100644 include/basegfx/tuple/Tuple3D.hxx (limited to 'include/basegfx/tuple') diff --git a/include/basegfx/tuple/Tuple2D.hxx b/include/basegfx/tuple/Tuple2D.hxx new file mode 100644 index 000000000000..e38dd1542207 --- /dev/null +++ b/include/basegfx/tuple/Tuple2D.hxx @@ -0,0 +1,157 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + */ + +#pragma once + +#include +#include +#include +#include + +namespace basegfx +{ +template class Tuple2D +{ +protected: + union { + // temporary alias mnX with mfX and mnY with mfY + struct + { + TYPE mnX; + TYPE mnY; + }; + struct + { + TYPE mfX; + TYPE mfY; + }; + }; + +public: + /** Create a 2D Tuple + + @param nX + This parameter is used to initialize the X-coordinate + of the 2D Tuple. + + @param nY + This parameter is used to initialize the Y-coordinate + of the 2D Tuple. + */ + Tuple2D(TYPE x, TYPE y) + : mnX(x) + , mnY(y) + { + } + + double get(Axis2D eAxis) { return eAxis == Axis2D::X ? getX() : getY(); } + + void set(Axis2D eAxis, TYPE fValue) + { + if (eAxis == Axis2D::X) + setX(fValue); + else + setY(fValue); + } + + /// Get X-Coordinate of 2D Tuple + TYPE getX() const { return mnX; } + + /// Get Y-Coordinate of 2D Tuple + TYPE getY() const { return mnY; } + + /// Set X-Coordinate of 2D Tuple + void setX(TYPE fX) { mnX = fX; } + + /// Set Y-Coordinate of 2D Tuple + void setY(TYPE fY) { mnY = fY; } + + // comparators with tolerance + + template ::value, bool>::type = false> + bool equal(const Tuple2D& rTup) const + { + return mfX == rTup.mfX && mfY == rTup.mfY; + } + + template ::value, bool>::type = false> + bool equal(const Tuple2D& rTup) const + { + return this == &rTup || (fTools::equal(mfX, rTup.mfX) && fTools::equal(mfY, rTup.mfY)); + } + + template ::value, bool>::type = false> + bool equalZero() const + { + return mnX == 0 && mnY == 0; + } + + template ::value, bool>::type = false> + bool equalZero() const + { + return fTools::equalZero(mfX) && fTools::equalZero(mfY); + } + + // operator overrides + + Tuple2D& operator+=(const Tuple2D& rTup) + { + mfX += rTup.mfX; + mfY += rTup.mfY; + return *this; + } + + Tuple2D& operator-=(const Tuple2D& rTup) + { + mfX -= rTup.mfX; + mfY -= rTup.mfY; + return *this; + } + + Tuple2D& operator/=(const Tuple2D& rTup) + { + mfX /= rTup.mfX; + mfY /= rTup.mfY; + return *this; + } + + Tuple2D& operator*=(const Tuple2D& rTup) + { + mfX *= rTup.mfX; + mfY *= rTup.mfY; + return *this; + } + + Tuple2D& operator*=(TYPE t) + { + mfX *= t; + mfY *= t; + return *this; + } + + Tuple2D& operator/=(TYPE t) + { + mfX /= t; + mfY /= t; + return *this; + } + + bool operator==(const Tuple2D& rTup) const { return mfX == rTup.mfX && mfY == rTup.mfY; } + + bool operator!=(const Tuple2D& rTup) const { return !(*this == rTup); } +}; + +} // end of namespace basegfx + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/basegfx/tuple/Tuple3D.hxx b/include/basegfx/tuple/Tuple3D.hxx new file mode 100644 index 000000000000..8ddcec8c618b --- /dev/null +++ b/include/basegfx/tuple/Tuple3D.hxx @@ -0,0 +1,139 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + */ + +#pragma once + +#include +#include +#include +#include + +namespace basegfx +{ +template class Tuple3D +{ +protected: + union { + // temporary alias mnX with mfX, mnY with mfY and mnZ with mfZ + struct + { + TYPE mnX; + TYPE mnY; + TYPE mnZ; + }; + struct + { + TYPE mfX; + TYPE mfY; + TYPE mfZ; + }; + }; + +public: + /** Create a 3D Tuple + + @param x + This parameter is used to initialize the X-coordinate + of the 3D Tuple. + + @param y + This parameter is used to initialize the Y-coordinate + of the 3D Tuple. + + @param z + This parameter is used to initialize the Z-coordinate + of the 3D Tuple. + */ + Tuple3D(TYPE x, TYPE y, TYPE z) + : mnX(x) + , mnY(y) + , mnZ(z) + { + } + + /// Get X-Coordinate of 3D Tuple + TYPE getX() const { return mnX; } + + /// Get Y-Coordinate of 3D Tuple + TYPE getY() const { return mnY; } + + /// Get Z-Coordinate of 3D Tuple + TYPE getZ() const { return mnZ; } + + /// Set X-Coordinate of 3D Tuple + void setX(TYPE fX) { mnX = fX; } + + /// Set Y-Coordinate of 3D Tuple + void setY(TYPE fY) { mnY = fY; } + + /// Set Z-Coordinate of 3D Tuple + void setZ(TYPE fZ) { mnZ = fZ; } + + // operators + + Tuple3D& operator+=(const Tuple3D& rTup) + { + mfX += rTup.mfX; + mfY += rTup.mfY; + mfZ += rTup.mfZ; + return *this; + } + + Tuple3D& operator-=(const Tuple3D& rTup) + { + mfX -= rTup.mfX; + mfY -= rTup.mfY; + mfZ -= rTup.mfZ; + return *this; + } + + Tuple3D& operator/=(const Tuple3D& rTup) + { + mfX /= rTup.mfX; + mfY /= rTup.mfY; + mfZ /= rTup.mfZ; + return *this; + } + + Tuple3D& operator*=(const Tuple3D& rTup) + { + mfX *= rTup.mfX; + mfY *= rTup.mfY; + mfZ *= rTup.mfZ; + return *this; + } + + Tuple3D& operator*=(TYPE t) + { + mfX *= t; + mfY *= t; + mfZ *= t; + return *this; + } + + Tuple3D& operator/=(TYPE t) + { + mfX /= t; + mfY /= t; + mfZ /= t; + return *this; + } + + bool operator==(const Tuple3D& rTup) const + { + return mfX == rTup.mfX && mfY == rTup.mfY && mfZ == rTup.mfZ; + } + + bool operator!=(const Tuple3D& rTup) const { return !operator==(rTup); } +}; + +} // end of namespace basegfx + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/basegfx/tuple/b2dtuple.hxx b/include/basegfx/tuple/b2dtuple.hxx index 0c7b7f463261..c523501b9639 100644 --- a/include/basegfx/tuple/b2dtuple.hxx +++ b/include/basegfx/tuple/b2dtuple.hxx @@ -22,7 +22,7 @@ #include #include #include -#include +#include namespace basegfx { @@ -36,12 +36,8 @@ namespace basegfx @derive Use this class to implement Points or Vectors which are based on two double values */ - class SAL_WARN_UNUSED B2DTuple + class SAL_WARN_UNUSED B2DTuple : public Tuple2D { - protected: - double mfX; - double mfY; - public: /** Create a 2D Tuple @@ -49,8 +45,7 @@ namespace basegfx The tuple is initialized to (0.0, 0.0) */ B2DTuple() - : mfX(0.0), - mfY(0.0) + : Tuple2D(0.0, 0.0) {} /** Create a 2D Tuple @@ -64,8 +59,7 @@ namespace basegfx of the 2D Tuple. */ B2DTuple(double fX, double fY) - : mfX( fX ), - mfY( fY ) + : Tuple2D(fX, fY) {} /** Create a copy of a 2D integer Tuple @@ -75,120 +69,13 @@ namespace basegfx */ BASEGFX_DLLPUBLIC explicit B2DTuple(const B2ITuple& rTup); - /// Get X-Coordinate of 2D Tuple - double getX() const - { - return mfX; - } - - /// Get Y-Coordinate of 2D Tuple - double getY() const - { - return mfY; - } - - /// Set X-Coordinate of 2D Tuple - void setX(double fX) - { - mfX = fX; - } - - /// Set Y-Coordinate of 2D Tuple - void setY(double fY) - { - mfY = fY; - } - - double get(Axis2D eAxis) - { - return eAxis == Axis2D::X ? getX() : getY(); - } - - void set(Axis2D eAxis, double fValue) - { - if (eAxis == Axis2D::X) - setX(fValue); - else - setY(fValue); - } - - // comparators with tolerance - - bool equalZero() const - { - return (this == &getEmptyTuple() || - (fTools::equalZero(mfX) && fTools::equalZero(mfY))); - } - - bool equal(const B2DTuple& rTup) const - { - return ( - this == &rTup || - (fTools::equal(mfX, rTup.mfX) && - fTools::equal(mfY, rTup.mfY))); - } - // operators - - B2DTuple& operator+=( const B2DTuple& rTup ) - { - mfX += rTup.mfX; - mfY += rTup.mfY; - return *this; - } - - B2DTuple& operator-=( const B2DTuple& rTup ) - { - mfX -= rTup.mfX; - mfY -= rTup.mfY; - return *this; - } - - B2DTuple& operator/=( const B2DTuple& rTup ) - { - mfX /= rTup.mfX; - mfY /= rTup.mfY; - return *this; - } - - B2DTuple& operator*=( const B2DTuple& rTup ) - { - mfX *= rTup.mfX; - mfY *= rTup.mfY; - return *this; - } - - B2DTuple& operator*=(double t) - { - mfX *= t; - mfY *= t; - return *this; - } - - B2DTuple& operator/=(double t) - { - const double fVal(1.0 / t); - mfX *= fVal; - mfY *= fVal; - return *this; - } - B2DTuple operator-(void) const { return B2DTuple(-mfX, -mfY); } - bool operator==( const B2DTuple& rTup ) const - { - return mfX == rTup.mfX && mfY == rTup.mfY; - } - - bool operator!=( const B2DTuple& rTup ) const - { - return mfX != rTup.mfX || mfY != rTup.mfY; - } - BASEGFX_DLLPUBLIC static const B2DTuple& getEmptyTuple(); }; diff --git a/include/basegfx/tuple/b2i64tuple.hxx b/include/basegfx/tuple/b2i64tuple.hxx index 5f2350b66ac1..70838572f321 100644 --- a/include/basegfx/tuple/b2i64tuple.hxx +++ b/include/basegfx/tuple/b2i64tuple.hxx @@ -21,7 +21,7 @@ #include #include - +#include namespace basegfx { @@ -33,34 +33,29 @@ namespace basegfx @derive Use this class to implement Points or Vectors which are based on two sal_Int64 values */ - class SAL_WARN_UNUSED BASEGFX_DLLPUBLIC B2I64Tuple final + class SAL_WARN_UNUSED BASEGFX_DLLPUBLIC B2I64Tuple : public Tuple2D { - sal_Int64 mnX; - sal_Int64 mnY; - public: /** Create a 2D Tuple The tuple is initialized to (0, 0) */ B2I64Tuple() - : mnX(0), - mnY(0) + : Tuple2D(0, 0) {} /** Create a 2D Tuple - @param fX + @param nX This parameter is used to initialize the X-coordinate of the 2D Tuple. - @param fY + @param nY This parameter is used to initialize the Y-coordinate of the 2D Tuple. */ - B2I64Tuple(sal_Int64 fX, sal_Int64 fY) - : mnX( fX ), - mnY( fY ) + B2I64Tuple(sal_Int64 nX, sal_Int64 nY) + : Tuple2D(nX, nY) {} /** Create a copy of a 2D Tuple @@ -69,100 +64,16 @@ namespace basegfx The 2D Tuple which will be copied. */ B2I64Tuple(const B2I64Tuple& rTup) - : mnX( rTup.mnX ), - mnY( rTup.mnY ) + : Tuple2D(rTup.mnX, rTup.mnY) {} - /// Get X-Coordinate of 2D Tuple - sal_Int64 getX() const - { - return mnX; - } - - /// Get Y-Coordinate of 2D Tuple - sal_Int64 getY() const - { - return mnY; - } - - /// Array-access to 2D Tuple - const sal_Int64& operator[] (int nPos) const - { - // Here, normally one if(...) should be used. In the assumption that - // both sal_Int64 members can be accessed as an array a shortcut is used here. - // if(0 == nPos) return mnX; return mnY; - return *((&mnX) + nPos); - } - - /// Array-access to 2D Tuple - sal_Int64& operator[] (int nPos) - { - // Here, normally one if(...) should be used. In the assumption that - // both sal_Int64 members can be accessed as an array a shortcut is used here. - // if(0 == nPos) return mnX; return mnY; - return *((&mnX) + nPos); - } - // operators - - B2I64Tuple& operator+=( const B2I64Tuple& rTup ) - { - mnX += rTup.mnX; - mnY += rTup.mnY; - return *this; - } - - B2I64Tuple& operator-=( const B2I64Tuple& rTup ) - { - mnX -= rTup.mnX; - mnY -= rTup.mnY; - return *this; - } - - B2I64Tuple& operator/=( const B2I64Tuple& rTup ) - { - mnX /= rTup.mnX; - mnY /= rTup.mnY; - return *this; - } - - B2I64Tuple& operator*=( const B2I64Tuple& rTup ) - { - mnX *= rTup.mnX; - mnY *= rTup.mnY; - return *this; - } - - B2I64Tuple& operator*=(sal_Int64 t) - { - mnX *= t; - mnY *= t; - return *this; - } - - B2I64Tuple& operator/=(sal_Int64 t) - { - mnX /= t; - mnY /= t; - return *this; - } - B2I64Tuple operator-(void) const { return B2I64Tuple(-mnX, -mnY); } - bool operator==( const B2I64Tuple& rTup ) const - { - return this == &rTup || (rTup.mnX == mnX && rTup.mnY == mnY); - } - - bool operator!=( const B2I64Tuple& rTup ) const - { - return !(*this == rTup); - } - B2I64Tuple& operator=( const B2I64Tuple& rTup ) { mnX = rTup.mnX; diff --git a/include/basegfx/tuple/b2ituple.hxx b/include/basegfx/tuple/b2ituple.hxx index b8f6c3e96386..e3f195596a37 100644 --- a/include/basegfx/tuple/b2ituple.hxx +++ b/include/basegfx/tuple/b2ituple.hxx @@ -21,6 +21,7 @@ #include #include +#include namespace basegfx { @@ -32,143 +33,37 @@ namespace basegfx @derive Use this class to implement Points or Vectors which are based on two sal_Int32 values */ - class SAL_WARN_UNUSED BASEGFX_DLLPUBLIC B2ITuple + class SAL_WARN_UNUSED BASEGFX_DLLPUBLIC B2ITuple : public Tuple2D { - protected: - sal_Int32 mnX; - sal_Int32 mnY; - public: /** Create a 2D Tuple The tuple is initialized to (0, 0) */ B2ITuple() - : mnX(0), - mnY(0) + : Tuple2D(0, 0) {} /** Create a 2D Tuple - @param fX + @param nX This parameter is used to initialize the X-coordinate of the 2D Tuple. - @param fY + @param nY This parameter is used to initialize the Y-coordinate of the 2D Tuple. */ - B2ITuple(sal_Int32 fX, sal_Int32 fY) - : mnX( fX ), - mnY( fY ) + B2ITuple(sal_Int32 nX, sal_Int32 nY) + : Tuple2D(nX, nY) {} - /// Get X-Coordinate of 2D Tuple - sal_Int32 getX() const - { - return mnX; - } - - /// Get Y-Coordinate of 2D Tuple - sal_Int32 getY() const - { - return mnY; - } - - /// Set X-Coordinate of 2D Tuple - void setX(sal_Int32 fX) - { - mnX = fX; - } - - /// Set Y-Coordinate of 2D Tuple - void setY(sal_Int32 fY) - { - mnY = fY; - } - - /// Array-access to 2D Tuple - const sal_Int32& operator[] (int nPos) const - { - // Here, normally one if(...) should be used. In the assumption that - // both sal_Int32 members can be accessed as an array a shortcut is used here. - // if(0 == nPos) return mnX; return mnY; - return *((&mnX) + nPos); - } - - /// Array-access to 2D Tuple - sal_Int32& operator[] (int nPos) - { - // Here, normally one if(...) should be used. In the assumption that - // both sal_Int32 members can be accessed as an array a shortcut is used here. - // if(0 == nPos) return mnX; return mnY; - return *((&mnX) + nPos); - } - // operators - - B2ITuple& operator+=( const B2ITuple& rTup ) - { - mnX += rTup.mnX; - mnY += rTup.mnY; - return *this; - } - - B2ITuple& operator-=( const B2ITuple& rTup ) - { - mnX -= rTup.mnX; - mnY -= rTup.mnY; - return *this; - } - - B2ITuple& operator/=( const B2ITuple& rTup ) - { - mnX /= rTup.mnX; - mnY /= rTup.mnY; - return *this; - } - - B2ITuple& operator*=( const B2ITuple& rTup ) - { - mnX *= rTup.mnX; - mnY *= rTup.mnY; - return *this; - } - - B2ITuple& operator*=(sal_Int32 t) - { - mnX *= t; - mnY *= t; - return *this; - } - - B2ITuple& operator/=(sal_Int32 t) - { - mnX /= t; - mnY /= t; - return *this; - } - B2ITuple operator-(void) const { return B2ITuple(-mnX, -mnY); } - - bool equalZero() const - { - return mnX == 0 && mnY == 0; - } - - bool operator==( const B2ITuple& rTup ) const - { - return this == &rTup || (rTup.mnX == mnX && rTup.mnY == mnY); - } - - bool operator!=( const B2ITuple& rTup ) const - { - return !(*this == rTup); - } }; // external operators diff --git a/include/basegfx/tuple/b3dtuple.hxx b/include/basegfx/tuple/b3dtuple.hxx index 791cc5f3e667..bb8f4b4067c3 100644 --- a/include/basegfx/tuple/b3dtuple.hxx +++ b/include/basegfx/tuple/b3dtuple.hxx @@ -23,6 +23,7 @@ #include #include #include +#include namespace basegfx { @@ -36,22 +37,15 @@ namespace basegfx @derive Use this class to implement Points or Vectors which are based on three double values */ - class SAL_WARN_UNUSED UNLESS_MERGELIBS(BASEGFX_DLLPUBLIC) B3DTuple + class SAL_WARN_UNUSED UNLESS_MERGELIBS(BASEGFX_DLLPUBLIC) B3DTuple : public Tuple3D { - protected: - double mfX; - double mfY; - double mfZ; - public: /** Create a 3D Tuple The tuple is initialized to (0.0, 0.0, 0.0) */ B3DTuple() - : mfX(0.0), - mfY(0.0), - mfZ(0.0) + : Tuple3D(0.0, 0.0, 0.0) {} /** Create a 3D Tuple @@ -69,47 +63,9 @@ namespace basegfx of the 3D Tuple. */ B3DTuple(double fX, double fY, double fZ) - : mfX(fX), - mfY(fY), - mfZ(fZ) + : Tuple3D(fX, fY, fZ) {} - /// get X-Coordinate of 3D Tuple - double getX() const - { - return mfX; - } - - /// get Y-Coordinate of 3D Tuple - double getY() const - { - return mfY; - } - - /// get Z-Coordinate of 3D Tuple - double getZ() const - { - return mfZ; - } - - /// set X-Coordinate of 3D Tuple - void setX(double fX) - { - mfX = fX; - } - - /// set Y-Coordinate of 3D Tuple - void setY(double fY) - { - mfY = fY; - } - - /// set Z-Coordinate of 3D Tuple - void setZ(double fZ) - { - mfZ = fZ; - } - /// Array-access to 3D Tuple const double& operator[] (int nPos) const { @@ -150,70 +106,17 @@ namespace basegfx // operators - - B3DTuple& operator+=( const B3DTuple& rTup ) - { - mfX += rTup.mfX; - mfY += rTup.mfY; - mfZ += rTup.mfZ; - return *this; - } - - B3DTuple& operator-=( const B3DTuple& rTup ) - { - mfX -= rTup.mfX; - mfY -= rTup.mfY; - mfZ -= rTup.mfZ; - return *this; - } - - B3DTuple& operator/=( const B3DTuple& rTup ) - { - mfX /= rTup.mfX; - mfY /= rTup.mfY; - mfZ /= rTup.mfZ; - return *this; - } - - B3DTuple& operator*=( const B3DTuple& rTup ) - { - mfX *= rTup.mfX; - mfY *= rTup.mfY; - mfZ *= rTup.mfZ; - return *this; - } - - B3DTuple& operator*=(double t) - { - mfX *= t; - mfY *= t; - mfZ *= t; - return *this; - } - - B3DTuple& operator/=(double t) - { - const double fVal(1.0 / t); - mfX *= fVal; - mfY *= fVal; - mfZ *= fVal; - return *this; - } - B3DTuple operator-(void) const { return B3DTuple(-mfX, -mfY, -mfZ); } - bool operator==( const B3DTuple& rTup ) const + bool operator==(const B3DTuple& rTup) const { return mfX == rTup.mfX && mfY == rTup.mfY && mfZ == rTup.mfZ; } - bool operator!=( const B3DTuple& rTup ) const - { - return mfX != rTup.mfX || mfY != rTup.mfY || mfZ != rTup.mfZ; - } + bool operator!=(const B3DTuple& rTup) const { return !operator==(rTup); } void correctValues(const double fCompareValue = 0.0) { diff --git a/include/basegfx/tuple/b3ituple.hxx b/include/basegfx/tuple/b3ituple.hxx index 7fe49ea92e93..72c9fa81402a 100644 --- a/include/basegfx/tuple/b3ituple.hxx +++ b/include/basegfx/tuple/b3ituple.hxx @@ -21,6 +21,7 @@ #include #include +#include namespace basegfx { @@ -32,22 +33,15 @@ namespace basegfx @derive Use this class to implement Points or Vectors which are based on three sal_Int32 values */ - class SAL_WARN_UNUSED BASEGFX_DLLPUBLIC B3ITuple + class SAL_WARN_UNUSED BASEGFX_DLLPUBLIC B3ITuple : public Tuple3D { - protected: - sal_Int32 mnX; - sal_Int32 mnY; - sal_Int32 mnZ; - public: /** Create a 3D Tuple The tuple is initialized to (0, 0, 0) */ B3ITuple() - : mnX(0), - mnY(0), - mnZ(0) + : Tuple3D(0, 0, 0) {} /** Create a 3D Tuple @@ -65,23 +59,9 @@ namespace basegfx of the 3D Tuple. */ B3ITuple(sal_Int32 nX, sal_Int32 nY, sal_Int32 nZ) - : mnX(nX), - mnY(nY), - mnZ(nZ) + : Tuple3D(nX, nY, nZ) {} - /// get X-Coordinate of 3D Tuple - sal_Int32 getX() const - { - return mnX; - } - - /// get Y-Coordinate of 3D Tuple - sal_Int32 getY() const - { - return mnY; - } - /// Array-access to 3D Tuple const sal_Int32& operator[] (int nPos) const { @@ -102,69 +82,10 @@ namespace basegfx // operators - - B3ITuple& operator+=( const B3ITuple& rTup ) - { - mnX += rTup.mnX; - mnY += rTup.mnY; - mnZ += rTup.mnZ; - return *this; - } - - B3ITuple& operator-=( const B3ITuple& rTup ) - { - mnX -= rTup.mnX; - mnY -= rTup.mnY; - mnZ -= rTup.mnZ; - return *this; - } - - B3ITuple& operator/=( const B3ITuple& rTup ) - { - mnX /= rTup.mnX; - mnY /= rTup.mnY; - mnZ /= rTup.mnZ; - return *this; - } - - B3ITuple& operator*=( const B3ITuple& rTup ) - { - mnX *= rTup.mnX; - mnY *= rTup.mnY; - mnZ *= rTup.mnZ; - return *this; - } - - B3ITuple& operator*=(sal_Int32 t) - { - mnX *= t; - mnY *= t; - mnZ *= t; - return *this; - } - - B3ITuple& operator/=(sal_Int32 t) - { - mnX /= t; - mnY /= t; - mnZ /= t; - return *this; - } - B3ITuple operator-(void) const { return B3ITuple(-mnX, -mnY, -mnZ); } - - bool operator==( const B3ITuple& rTup ) const - { - return this == &rTup || (rTup.mnX == mnX && rTup.mnY == mnY && rTup.mnZ == mnZ); - } - - bool operator!=( const B3ITuple& rTup ) const - { - return !(*this == rTup); - } }; } // end of namespace basegfx -- cgit v1.2.3