0024512: clang++ compiler complains about extra semicolon
[occt.git] / src / NCollection / NCollection_Vec2.hxx
1 // Created by: Kirill GAVRILOV
2 // Copyright (c) 2014 OPEN CASCADE SAS
3 //
4 // This file is part of Open CASCADE Technology software library.
5 //
6 // This library is free software; you can redistribute it and / or modify it
7 // under the terms of the GNU Lesser General Public version 2.1 as published
8 // by the Free Software Foundation, with special exception defined in the file
9 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
10 // distribution for complete text of the license and disclaimer of any warranty.
11 //
12 // Alternatively, this file may be used under the terms of Open CASCADE
13 // commercial license or contractual agreement.
14
15 #ifndef _NCollection_Vec2_H__
16 #define _NCollection_Vec2_H__
17
18 #include <cmath> // std::sqrt()
19
20 //! Auxiliary macros to define couple of similar access components as vector methods.
21 //! @return 2 components by their names in specified order
22 #define NCOLLECTION_VEC_COMPONENTS_2D(theX, theY) \
23   const NCollection_Vec2<Element_t> theX##theY() const { return NCollection_Vec2<Element_t>(theX(), theY()); } \
24   const NCollection_Vec2<Element_t> theY##theX() const { return NCollection_Vec2<Element_t>(theY(), theX()); }
25
26 //! Defines the 2D-vector template.
27 //! The main target for this class - to handle raw low-level arrays (from/to graphic driver etc.).
28 template<typename Element_t>
29 class NCollection_Vec2
30 {
31
32 public:
33
34   //! Returns the number of components.
35   static int Length()
36   {
37     return 2;
38   }
39
40   //! Empty constructor. Construct the zero vector.
41   NCollection_Vec2()
42   {
43     v[0] = v[1] = Element_t(0);
44   }
45
46   //! Initialize ALL components of vector within specified value.
47   explicit NCollection_Vec2 (const Element_t theXY)
48   {
49     v[0] = v[1] = theXY;
50   }
51
52   //! Per-component constructor.
53   explicit NCollection_Vec2 (const Element_t theX,
54                              const Element_t theY)
55   {
56     v[0] = theX;
57     v[1] = theY;
58   }
59
60   //! Copy constructor.
61   NCollection_Vec2 (const NCollection_Vec2& theVec2)
62   {
63     v[0] = theVec2[0];
64     v[1] = theVec2[1];
65   }
66
67   //! Assignment operator.
68   const NCollection_Vec2& operator= (const NCollection_Vec2& theVec2)
69   {
70     v[0] = theVec2[0];
71     v[1] = theVec2[1];
72     return *this;
73   }
74
75   //! Alias to 1st component as X coordinate in XY.
76   Element_t x() const { return v[0]; }
77
78   //! Alias to 2nd component as Y coordinate in XY.
79   Element_t y() const { return v[1]; }
80
81   //! @return 2 components by their names in specified order (in GLSL-style)
82   NCOLLECTION_VEC_COMPONENTS_2D(x, y)
83
84   //! Alias to 1st component as X coordinate in XY.
85   Element_t& x() { return v[0]; }
86
87   //! Alias to 2nd component as Y coordinate in XY.
88   Element_t& y() { return v[1]; }
89
90   //! Raw access to the data (for OpenGL exchange).
91   const Element_t* GetData()    const { return v; }
92         Element_t* ChangeData()       { return v; }
93   operator const   Element_t*() const { return v; }
94   operator         Element_t*()       { return v; }
95
96   //! Compute per-component summary.
97   NCollection_Vec2& operator+= (const NCollection_Vec2& theAdd)
98   {
99     v[0] += theAdd.v[0];
100     v[1] += theAdd.v[1];
101     return *this;
102   }
103
104   //! Compute per-component summary.
105   friend NCollection_Vec2 operator+ (const NCollection_Vec2& theLeft,
106                                      const NCollection_Vec2& theRight)
107   {
108     return NCollection_Vec2 (theLeft.v[0] + theRight.v[0],
109                              theLeft.v[1] + theRight.v[1]);
110   }
111
112   //! Compute per-component subtraction.
113   NCollection_Vec2& operator-= (const NCollection_Vec2& theDec)
114   {
115     v[0] -= theDec.v[0];
116     v[1] -= theDec.v[1];
117     return *this;
118   }
119
120   //! Compute per-component subtraction.
121   friend NCollection_Vec2 operator- (const NCollection_Vec2& theLeft,
122                                      const NCollection_Vec2& theRight)
123   {
124     return NCollection_Vec2 (theLeft.v[0] - theRight.v[0],
125                              theLeft.v[1] - theRight.v[1]);
126   }
127
128   //! Unary -.
129   NCollection_Vec2 operator-() const
130   {
131     return NCollection_Vec2 (-x(), -y());
132   }
133
134   //! Compute per-component multiplication.
135   NCollection_Vec2& operator*= (const NCollection_Vec2& theRight)
136   {
137     v[0] *= theRight.v[0];
138     v[1] *= theRight.v[1];
139     return *this;
140   }
141
142   //! Compute per-component multiplication.
143   friend NCollection_Vec2 operator* (const NCollection_Vec2& theLeft,
144                                      const NCollection_Vec2& theRight)
145   {
146     return NCollection_Vec2 (theLeft.v[0] * theRight.v[0],
147                              theLeft.v[1] * theRight.v[1]);
148   }
149
150   //! Compute per-component multiplication by scale factor.
151   void Multiply (const Element_t theFactor)
152   {
153     v[0] *= theFactor;
154     v[1] *= theFactor;
155   }
156
157   //! Compute per-component multiplication by scale factor.
158   NCollection_Vec2 Multiplied (const Element_t theFactor) const
159   {
160     return NCollection_Vec2 (v[0] * theFactor,
161                              v[1] * theFactor);
162   }
163
164   //! Compute per-component multiplication by scale factor.
165   NCollection_Vec2& operator*= (const Element_t theFactor)
166   {
167     Multiply (theFactor);
168     return *this;
169   }
170
171   //! Compute per-component division by scale factor.
172   NCollection_Vec2& operator/= (const Element_t theInvFactor)
173   {
174     v[0] /= theInvFactor;
175     v[1] /= theInvFactor;
176     return *this;
177   }
178
179   //! Compute per-component multiplication by scale factor.
180   NCollection_Vec2 operator* (const Element_t theFactor) const
181   {
182     return Multiplied (theFactor);
183   }
184
185   //! Compute per-component division by scale factor.
186   NCollection_Vec2 operator/ (const Element_t theInvFactor) const
187   {
188     return NCollection_Vec2(v[0] / theInvFactor,
189             v[1] / theInvFactor);
190   }
191
192   //! Computes the dot product.
193   Element_t Dot (const NCollection_Vec2& theOther) const
194   {
195     return x() * theOther.x() + y() * theOther.y();
196   }
197
198   //! Computes the vector modulus (magnitude, length).
199   Element_t Modulus() const
200   {
201     return std::sqrt (x() * x() + y() * y());
202   }
203
204   //! Computes the square of vector modulus (magnitude, length).
205   //! This method may be used for performance tricks.
206   Element_t SquareModulus() const
207   {
208     return x() * x() + y() * y();
209   }
210
211   //! Constuct DX unit vector.
212   static NCollection_Vec2 DX()
213   {
214     return NCollection_Vec2 (Element_t(1), Element_t(0));
215   }
216
217   //! Constuct DY unit vector.
218   static NCollection_Vec2 DY()
219   {
220     return NCollection_Vec2 (Element_t(0), Element_t(1));
221   }
222
223 private:
224
225   Element_t v[2];
226
227 };
228
229 #endif // _NCollection_Vec2_H__