Pepper_42_C++_interfaces
point.h
Go to the documentation of this file.
1 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4 
5 #ifndef PPAPI_CPP_POINT_H_
6 #define PPAPI_CPP_POINT_H_
7 
8 #include "ppapi/c/pp_point.h"
9 
10 /// @file
11 /// This file defines the API to create a 2 dimensional point.
12 
13 namespace pp {
14 
15 /// A 2 dimensional point with 0,0 being the upper-left starting coordinate.
16 class Point {
17  public:
18  /// The default constructor for a point at 0,0.
19  Point() {
20  point_.x = 0;
21  point_.y = 0;
22  }
23 
24  /// A constructor accepting two int32_t values for x and y and converting
25  /// them to a Point.
26  ///
27  /// @param[in] in_x An int32_t value representing a horizontal coordinate
28  /// of a point, starting with 0 as the left-most coordinate.
29  /// @param[in] in_y An int32_t value representing a vertical coordinate
30  /// of a point, starting with 0 as the top-most coordinate.
31  Point(int32_t in_x, int32_t in_y) {
32  point_.x = in_x;
33  point_.y = in_y;
34  }
35 
36  /// A constructor accepting a pointer to a PP_Point and converting the
37  /// PP_Point to a Point. This is an implicit conversion constructor.
38  ///
39  /// @param[in] point A pointer to a PP_Point.
40  Point(const PP_Point& point) { // Implicit.
41  point_.x = point.x;
42  point_.y = point.y;
43  }
44 
45  /// Destructor.
46  ~Point() {
47  }
48 
49  /// A function allowing implicit conversion of a Point to a PP_Point.
50  /// @return A Point.
51  operator PP_Point() const {
52  return point_;
53  }
54 
55  /// Getter function for returning the internal PP_Point struct.
56  ///
57  /// @return A const reference to the internal PP_Point struct.
58  const PP_Point& pp_point() const {
59  return point_;
60  }
61 
62  /// Getter function for returning the internal PP_Point struct.
63  ///
64  /// @return A mutable reference to the PP_Point struct.
65  PP_Point& pp_point() {
66  return point_;
67  }
68 
69  /// Getter function for returning the value of x.
70  ///
71  /// @return The value of x for this Point.
72  int32_t x() const { return point_.x; }
73 
74  /// Setter function for setting the value of x.
75  ///
76  /// @param[in] in_x A new x value.
77  void set_x(int32_t in_x) {
78  point_.x = in_x;
79  }
80 
81  /// Getter function for returning the value of y.
82  ///
83  /// @return The value of y for this Point.
84  int32_t y() const { return point_.y; }
85 
86  /// Setter function for setting the value of y.
87  ///
88  /// @param[in] in_y A new y value.
89  void set_y(int32_t in_y) {
90  point_.y = in_y;
91  }
92 
93  /// Adds two Points (this and other) together by adding their x values and
94  /// y values.
95  ///
96  /// @param[in] other A Point.
97  ///
98  /// @return A new Point containing the result.
99  Point operator+(const Point& other) const {
100  return Point(x() + other.x(), y() + other.y());
101  }
102 
103  /// Subtracts one Point from another Point by subtracting their x values
104  /// and y values. Returns a new point with the result.
105  ///
106  /// @param[in] other A Point.
107  ///
108  /// @return A new Point containing the result.
109  Point operator-(const Point& other) const {
110  return Point(x() - other.x(), y() - other.y());
111  }
112 
113  /// Adds two Points (this and other) together by adding their x and y
114  /// values. Returns this point as the result.
115  ///
116  /// @param[in] other A Point.
117  ///
118  /// @return This Point containing the result.
119  Point& operator+=(const Point& other) {
120  point_.x += other.x();
121  point_.y += other.y();
122  return *this;
123  }
124 
125  /// Subtracts one Point from another Point by subtracting their x values
126  /// and y values. Returns this point as the result.
127  ///
128  /// @param[in] other A Point.
129  ///
130  /// @return This Point containing the result.
131  Point& operator-=(const Point& other) {
132  point_.x -= other.x();
133  point_.y -= other.y();
134  return *this;
135  }
136 
137  /// Swaps the coordinates of two Points.
138  ///
139  /// @param[in] other A Point.
140  void swap(Point& other) {
141  int32_t x = point_.x;
142  int32_t y = point_.y;
143  point_.x = other.point_.x;
144  point_.y = other.point_.y;
145  other.point_.x = x;
146  other.point_.y = y;
147  }
148 
149  private:
150  PP_Point point_;
151 };
152 
153 /// A 2 dimensional floating-point point with 0,0 being the upper-left starting
154 /// coordinate.
155 class FloatPoint {
156  public:
157  /// A constructor for a point at 0,0.
159  float_point_.x = 0.0f;
160  float_point_.y = 0.0f;
161  }
162 
163  /// A constructor accepting two values for x and y and converting them to a
164  /// FloatPoint.
165  ///
166  /// @param[in] in_x An value representing a horizontal coordinate of a
167  /// point, starting with 0 as the left-most coordinate.
168  ///
169  /// @param[in] in_y An value representing a vertical coordinate of a point,
170  /// starting with 0 as the top-most coordinate.
171  FloatPoint(float in_x, float in_y) {
172  float_point_.x = in_x;
173  float_point_.y = in_y;
174  }
175 
176  /// A constructor accepting a pointer to a PP_FloatPoint and converting the
177  /// PP_Point to a Point. This is an implicit conversion constructor.
178  ///
179  /// @param[in] point A PP_FloatPoint.
180  FloatPoint(const PP_FloatPoint& point) { // Implicit.
181  float_point_.x = point.x;
182  float_point_.y = point.y;
183  }
184  /// Destructor.
186  }
187 
188  /// A function allowing implicit conversion of a FloatPoint to a
189  /// PP_FloatPoint.
190  operator PP_FloatPoint() const {
191  return float_point_;
192  }
193 
194  /// Getter function for returning the internal PP_FloatPoint struct.
195  ///
196  /// @return A const reference to the internal PP_FloatPoint struct.
197  const PP_FloatPoint& pp_float_point() const {
198  return float_point_;
199  }
200 
201  /// Getter function for returning the internal PP_Point struct.
202  ///
203  /// @return A mutable reference to the PP_Point struct.
204  PP_FloatPoint& pp_float_point() {
205  return float_point_;
206  }
207 
208  /// Getter function for returning the value of x.
209  ///
210  /// @return The value of x for this Point.
211  float x() const { return float_point_.x; }
212 
213  /// Setter function for setting the value of x.
214  ///
215  /// @param[in] in_x A new x value.
216  void set_x(float in_x) {
217  float_point_.x = in_x;
218  }
219 
220  /// Getter function for returning the value of y.
221  ///
222  /// @return The value of y for this Point.
223  float y() const { return float_point_.y; }
224 
225  /// Setter function for setting the value of y.
226  ///
227  /// @param[in] in_y A new y value.
228  void set_y(float in_y) {
229  float_point_.y = in_y;
230  }
231 
232  /// Adds two Points (this and other) together by adding their x values and
233  /// y values.
234  ///
235  /// @param[in] other A Point.
236  ///
237  /// @return A new Point containing the result.
238  FloatPoint operator+(const FloatPoint& other) const {
239  return FloatPoint(x() + other.x(), y() + other.y());
240  }
241 
242  /// Subtracts one Point from another Point by subtracting their x values
243  /// and y values. Returns a new point with the result.
244  ///
245  /// @param[in] other A FloatPoint.
246  ///
247  /// @return A new Point containing the result.
248  FloatPoint operator-(const FloatPoint& other) const {
249  return FloatPoint(x() - other.x(), y() - other.y());
250  }
251 
252  /// Adds two Points (this and other) together by adding their x and y
253  /// values. Returns this point as the result.
254  ///
255  /// @param[in] other A Point.
256  ///
257  /// @return This Point containing the result.
259  float_point_.x += other.x();
260  float_point_.y += other.y();
261  return *this;
262  }
263 
264  /// Subtracts one Point from another Point by subtracting their x values
265  /// and y values. Returns this point as the result.
266  ///
267  /// @param[in] other A Point.
268  ///
269  /// @return This Point containing the result.
271  float_point_.x -= other.x();
272  float_point_.y -= other.y();
273  return *this;
274  }
275 
276  /// Swaps the coordinates of two Points.
277  ///
278  /// @param[in] other A Point.
279  void swap(FloatPoint& other) {
280  float x = float_point_.x;
281  float y = float_point_.y;
282  float_point_.x = other.float_point_.x;
283  float_point_.y = other.float_point_.y;
284  other.float_point_.x = x;
285  other.float_point_.y = y;
286  }
287 
288  private:
289  PP_FloatPoint float_point_;
290 };
291 
292 } // namespace pp
293 
294 /// Determines whether the x and y values of two Points are equal.
295 ///
296 /// @param[in] lhs The Point on the left-hand side of the equation.
297 /// @param[in] rhs The Point on the right-hand side of the equation.
298 ///
299 /// @return true if they are equal, false if unequal.
300 inline bool operator==(const pp::Point& lhs, const pp::Point& rhs) {
301  return lhs.x() == rhs.x() && lhs.y() == rhs.y();
302 }
303 
304 /// Determines whether two Points have different coordinates.
305 ///
306 /// @param[in] lhs The Point on the left-hand side of the equation.
307 /// @param[in] rhs The Point on the right-hand side of the equation.
308 ///
309 /// @return true if the coordinates of lhs are equal to the coordinates
310 /// of rhs, otherwise false.
311 inline bool operator!=(const pp::Point& lhs, const pp::Point& rhs) {
312  return !(lhs == rhs);
313 }
314 
315 /// Determines whether the x and y values of two FloatPoints are equal.
316 ///
317 /// @param[in] lhs The Point on the left-hand side of the equation.
318 /// @param[in] rhs The Point on the right-hand side of the equation.
319 ///
320 /// @return true if they are equal, false if unequal.
321 inline bool operator==(const pp::FloatPoint& lhs, const pp::FloatPoint& rhs) {
322  return lhs.x() == rhs.x() && lhs.y() == rhs.y();
323 }
324 
325 /// Determines whether two Points have different coordinates.
326 ///
327 /// @param[in] lhs The Point on the left-hand side of the equation.
328 /// @param[in] rhs The Point on the right-hand side of the equation.
329 ///
330 /// @return true if the coordinates of lhs are equal to the coordinates
331 /// of rhs, otherwise false.
332 inline bool operator!=(const pp::FloatPoint& lhs, const pp::FloatPoint& rhs) {
333  return !(lhs == rhs);
334 }
335 
336 #endif // PPAPI_CPP_POINT_H_
void swap(FloatPoint &other)
Definition: point.h:279
Point(const PP_Point &point)
Definition: point.h:40
const PP_Point & pp_point() const
Definition: point.h:58
A 2 dimensional point with 0,0 being the upper-left starting coordinate.
Definition: point.h:16
FloatPoint & operator+=(const FloatPoint &other)
Definition: point.h:258
const PP_FloatPoint & pp_float_point() const
Definition: point.h:197
int32_t y() const
Definition: point.h:84
void swap(Point &other)
Definition: point.h:140
PP_FloatPoint & pp_float_point()
Definition: point.h:204
~Point()
Destructor.
Definition: point.h:46
void set_y(int32_t in_y)
Definition: point.h:89
Point operator+(const Point &other) const
Definition: point.h:99
void set_x(int32_t in_x)
Definition: point.h:77
float y() const
Definition: point.h:223
void set_y(float in_y)
Definition: point.h:228
Point & operator-=(const Point &other)
Definition: point.h:131
FloatPoint & operator-=(const FloatPoint &other)
Definition: point.h:270
Point()
The default constructor for a point at 0,0.
Definition: point.h:19
int32_t x() const
Definition: point.h:72
float x() const
Definition: point.h:211
~FloatPoint()
Destructor.
Definition: point.h:185
void set_x(float in_x)
Definition: point.h:216
Point & operator+=(const Point &other)
Definition: point.h:119
FloatPoint()
A constructor for a point at 0,0.
Definition: point.h:158
PP_Point & pp_point()
Definition: point.h:65
Point operator-(const Point &other) const
Definition: point.h:109
FloatPoint(float in_x, float in_y)
Definition: point.h:171
FloatPoint(const PP_FloatPoint &point)
Definition: point.h:180
bool operator!=(const pp::Point &lhs, const pp::Point &rhs)
Definition: point.h:311
FloatPoint operator-(const FloatPoint &other) const
Definition: point.h:248
FloatPoint operator+(const FloatPoint &other) const
Definition: point.h:238
bool operator==(const pp::Point &lhs, const pp::Point &rhs)
Definition: point.h:300
Point(int32_t in_x, int32_t in_y)
Definition: point.h:31