include/basegfx/tuple/Tuple2D.hxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  */
  10
  11 #pragma once
  12
  13 #include <basegfx/utils/common.hxx>
  14 #include <basegfx/numeric/ftools.hxx>
  15
  16 namespace basegfx
  17 {
  18 template <typename TYPE> class Tuple2D
  19 {
  20 protected:
  21     union {
  22         // temporary alias mnX with mfX and mnY with mfY
  23         struct
  24         {
  25             TYPE mnX;
  26             TYPE mnY;
  27         };
  28         struct
  29         {
  30             TYPE mfX;
  31             TYPE mfY;
  32         };
  33     };
  34
  35 public:
  36     /** Create a 2D Tuple
  37
  38             @param nX
  39             This parameter is used to initialize the X-coordinate
  40             of the 2D Tuple.
  41
  42             @param nY
  43             This parameter is used to initialize the Y-coordinate
  44             of the 2D Tuple.
  45     */
  46     Tuple2D(TYPE x, TYPE y)
  47         : mnX(x)
  48         , mnY(y)
  49     {
  50     }
  51
  52     double get(Axis2D eAxis) { return eAxis == Axis2D::X ? getX() : getY(); }
  53
  54     void set(Axis2D eAxis, TYPE fValue)
  55     {
  56         if (eAxis == Axis2D::X)
  57             setX(fValue);
  58         else
  59             setY(fValue);
  60     }
  61
  62     /// Get X-Coordinate of 2D Tuple
  63     TYPE getX() const { return mnX; }
  64
  65     /// Get Y-Coordinate of 2D Tuple
  66     TYPE getY() const { return mnY; }
  67
  68     /// Set X-Coordinate of 2D Tuple
  69     void setX(TYPE fX) { mnX = fX; }
  70
  71     /// Set Y-Coordinate of 2D Tuple
  72     void setY(TYPE fY) { mnY = fY; }
  73
  74     /// Adjust X-Coordinate of 2D Tuple
  75     void adjustX(TYPE fX) { mnX += fX; }
  76
  77     /// Adjust Y-Coordinate of 2D Tuple
  78     void adjustY(TYPE fY) { mnY += fY; }
  79
  80     // comparators with tolerance
  81
  82     template <typename T = TYPE, std::enable_if_t<std::is_integral_v<T>, int> = 0>
  83     bool equal(const Tuple2D<TYPE>& rTup) const
  84     {
  85         return mfX == rTup.mfX && mfY == rTup.mfY;
  86     }
  87
  88     template <typename T = TYPE, std::enable_if_t<std::is_floating_point_v<T>, int> = 0>
  89     bool equal(const Tuple2D<TYPE>& rTup) const
  90     {
  91         return this == &rTup || (fTools::equal(mfX, rTup.mfX) && fTools::equal(mfY, rTup.mfY));
  92     }
  93
  94     template <typename T = TYPE, std::enable_if_t<std::is_integral_v<T>, int> = 0>
  95     bool equalZero() const
  96     {
  97         return mnX == 0 && mnY == 0;
  98     }
  99
 100     template <typename T = TYPE, std::enable_if_t<std::is_floating_point_v<T>, int> = 0>
 101     bool equalZero() const
 102     {
 103         return fTools::equalZero(mfX) && fTools::equalZero(mfY);
 104     }
 105
 106     // operator overrides
 107
 108     Tuple2D<TYPE>& operator+=(const Tuple2D<TYPE>& rTup)
 109     {
 110         mfX += rTup.mfX;
 111         mfY += rTup.mfY;
 112         return *this;
 113     }
 114
 115     Tuple2D<TYPE>& operator-=(const Tuple2D<TYPE>& rTup)
 116     {
 117         mfX -= rTup.mfX;
 118         mfY -= rTup.mfY;
 119         return *this;
 120     }
 121
 122     Tuple2D<TYPE>& operator/=(const Tuple2D<TYPE>& rTup)
 123     {
 124         mfX /= rTup.mfX;
 125         mfY /= rTup.mfY;
 126         return *this;
 127     }
 128
 129     Tuple2D<TYPE>& operator*=(const Tuple2D<TYPE>& rTup)
 130     {
 131         mfX *= rTup.mfX;
 132         mfY *= rTup.mfY;
 133         return *this;
 134     }
 135
 136     Tuple2D<TYPE>& operator*=(TYPE t)
 137     {
 138         mfX *= t;
 139         mfY *= t;
 140         return *this;
 141     }
 142
 143     Tuple2D<TYPE>& operator/=(TYPE t)
 144     {
 145         mfX /= t;
 146         mfY /= t;
 147         return *this;
 148     }
 149
 150     Tuple2D<TYPE> operator-(void) const { return Tuple2D<TYPE>(-mfX, -mfY); }
 151
 152     bool operator==(const Tuple2D<TYPE>& rTup) const { return mfX == rTup.mfX && mfY == rTup.mfY; }
 153
 154     bool operator!=(const Tuple2D<TYPE>& rTup) const { return !(*this == rTup); }
 155 };
 156
 157 template <typename TYPE>
 158 inline Tuple2D<TYPE> operator-(const Tuple2D<TYPE>& rTupA, const Tuple2D<TYPE>& rTupB)
 159 {
 160     Tuple2D<TYPE> aNew(rTupA);
 161     aNew -= rTupB;
 162     return aNew;
 163 }
 164
 165 template <typename TYPE>
 166 inline Tuple2D<TYPE> operator+(const Tuple2D<TYPE>& rTupA, const Tuple2D<TYPE>& rTupB)
 167 {
 168     Tuple2D<TYPE> aNew(rTupA);
 169     aNew += rTupB;
 170     return aNew;
 171 }
 172
 173 template <typename TYPE>
 174 inline Tuple2D<TYPE> operator*(const Tuple2D<TYPE>& rTupA, const Tuple2D<TYPE>& rTupB)
 175 {
 176     Tuple2D<TYPE> aNew(rTupA);
 177     aNew *= rTupB;
 178     return aNew;
 179 }
 180
 181 template <typename TYPE>
 182 inline Tuple2D<TYPE> operator/(const Tuple2D<TYPE>& rTupA, const Tuple2D<TYPE>& rTupB)
 183 {
 184     Tuple2D<TYPE> aNew(rTupA);
 185     aNew /= rTupB;
 186     return aNew;
 187 }
 188
 189 } // end of namespace basegfx
 190
 191 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */