PxFlags.h
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2008-2015, NVIDIA CORPORATION. All rights reserved.
3  *
4  * NVIDIA CORPORATION and its licensors retain all intellectual property
5  * and proprietary rights in and to this software, related documentation
6  * and any modifications thereto. Any use, reproduction, disclosure or
7  * distribution of this software and related documentation without an express
8  * license agreement from NVIDIA CORPORATION is strictly prohibited.
9  */
10 // Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
11 // Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
12 
13 
14 #ifndef PX_FOUNDATION_PX_FLAGS_H
15 #define PX_FOUNDATION_PX_FLAGS_H
16 
21 #include "foundation/Px.h"
22 
23 #ifndef PX_DOXYGEN
24 namespace physx
25 {
26 #endif
27 
56  template<typename enumtype, typename storagetype=PxU32>
57  class PxFlags
58  {
59  public:
60  typedef storagetype InternalType;
61 
62  PX_INLINE explicit PxFlags(const PxEMPTY&) {}
63  PX_INLINE PxFlags(void);
64  PX_INLINE PxFlags(enumtype e);
66  PX_INLINE explicit PxFlags(storagetype b);
67 
68  PX_INLINE bool isSet (enumtype e) const;
69  PX_INLINE PxFlags<enumtype,storagetype> &set (enumtype e);
70  PX_INLINE bool operator==(enumtype e) const;
71  PX_INLINE bool operator==(const PxFlags<enumtype,storagetype> &f) const;
72  PX_INLINE bool operator==(bool b) const;
73  PX_INLINE bool operator!=(enumtype e) const;
74  PX_INLINE bool operator!=(const PxFlags<enumtype,storagetype> &f) const;
75 
76  PX_INLINE PxFlags<enumtype,storagetype> &operator =(enumtype e);
78 
79  PX_INLINE PxFlags<enumtype,storagetype> &operator|=(enumtype e);
81  PX_INLINE PxFlags<enumtype,storagetype> operator| (enumtype e) const;
83 
84  PX_INLINE PxFlags<enumtype,storagetype> &operator&=(enumtype e);
86  PX_INLINE PxFlags<enumtype,storagetype> operator& (enumtype e) const;
88 
89  PX_INLINE PxFlags<enumtype,storagetype> &operator^=(enumtype e);
91  PX_INLINE PxFlags<enumtype,storagetype> operator^ (enumtype e) const;
93 
94  PX_INLINE PxFlags<enumtype,storagetype> operator~ (void) const;
95 
96  PX_INLINE operator bool(void) const;
97  PX_INLINE operator PxU8(void) const;
98  PX_INLINE operator PxU16(void) const;
99  PX_INLINE operator PxU32(void) const;
100 
101  PX_INLINE void clear(enumtype e);
102 
103  public:
105  {
107  out.mBits = a & b.mBits;
108  return out;
109  }
110 
111  private:
112  storagetype mBits;
113  };
114 
115  #define PX_FLAGS_OPERATORS(enumtype, storagetype) \
116  PX_INLINE PxFlags<enumtype, storagetype> operator|(enumtype a, enumtype b) { PxFlags<enumtype, storagetype> r(a); r |= b; return r; } \
117  PX_INLINE PxFlags<enumtype, storagetype> operator&(enumtype a, enumtype b) { PxFlags<enumtype, storagetype> r(a); r &= b; return r; } \
118  PX_INLINE PxFlags<enumtype, storagetype> operator~(enumtype a) { return ~PxFlags<enumtype, storagetype>(a); }
119 
120  #define PX_FLAGS_TYPEDEF(x, y) typedef PxFlags<x::Enum, y> x##s; \
121  PX_FLAGS_OPERATORS(x::Enum, y)
122 
123  template<typename enumtype, typename storagetype>
125  {
126  mBits = 0;
127  }
128 
129  template<typename enumtype, typename storagetype>
131  {
132  mBits = static_cast<storagetype>(e);
133  }
134 
135  template<typename enumtype, typename storagetype>
137  {
138  mBits = f.mBits;
139  }
140 
141  template<typename enumtype, typename storagetype>
143  {
144  mBits = f.mBits;
145  return *this;
146  }
147 
148  template<typename enumtype, typename storagetype>
150  {
151  mBits = b;
152  }
153 
154  template<typename enumtype, typename storagetype>
156  {
157  return (mBits & static_cast<storagetype>(e)) == static_cast<storagetype>(e);
158  }
159 
160  template<typename enumtype, typename storagetype>
162  {
163  mBits = static_cast<storagetype>(e);
164  return *this;
165  }
166 
167  template<typename enumtype, typename storagetype>
169  {
170  return mBits == static_cast<storagetype>(e);
171  }
172 
173  template<typename enumtype, typename storagetype>
175  {
176  return mBits == f.mBits;
177  }
178 
179  template<typename enumtype, typename storagetype>
181  {
182  return ((bool)*this) == b;
183  }
184 
185  template<typename enumtype, typename storagetype>
187  {
188  return mBits != static_cast<storagetype>(e);
189  }
190 
191  template<typename enumtype, typename storagetype>
193  {
194  return mBits != f.mBits;
195  }
196 
197  template<typename enumtype, typename storagetype>
199  {
200  mBits = static_cast<storagetype>(e);
201  return *this;
202  }
203 
204  template<typename enumtype, typename storagetype>
206  {
207  mBits |= static_cast<storagetype>(e);
208  return *this;
209  }
210 
211  template<typename enumtype, typename storagetype>
213  {
214  mBits |= f.mBits;
215  return *this;
216  }
217 
218  template<typename enumtype, typename storagetype>
220  {
222  out |= e;
223  return out;
224  }
225 
226  template<typename enumtype, typename storagetype>
228  {
230  out |= f;
231  return out;
232  }
233 
234  template<typename enumtype, typename storagetype>
236  {
237  mBits &= static_cast<storagetype>(e);
238  return *this;
239  }
240 
241  template<typename enumtype, typename storagetype>
243  {
244  mBits &= f.mBits;
245  return *this;
246  }
247 
248  template<typename enumtype, typename storagetype>
250  {
251  PxFlags<enumtype,storagetype> out = *this;
252  out.mBits &= static_cast<storagetype>(e);
253  return out;
254  }
255 
256  template<typename enumtype, typename storagetype>
258  {
259  PxFlags<enumtype,storagetype> out = *this;
260  out.mBits &= f.mBits;
261  return out;
262  }
263 
264  template<typename enumtype, typename storagetype>
266  {
267  mBits ^= static_cast<storagetype>(e);
268  return *this;
269  }
270 
271  template<typename enumtype, typename storagetype>
273  {
274  mBits ^= f.mBits;
275  return *this;
276  }
277 
278  template<typename enumtype, typename storagetype>
280  {
281  PxFlags<enumtype,storagetype> out = *this;
282  out.mBits ^= static_cast<storagetype>(e);
283  return out;
284  }
285 
286  template<typename enumtype, typename storagetype>
288  {
289  PxFlags<enumtype,storagetype> out = *this;
290  out.mBits ^= f.mBits;
291  return out;
292  }
293 
294  template<typename enumtype, typename storagetype>
296  {
298  out.mBits = (storagetype)~mBits;
299  return out;
300  }
301 
302  template<typename enumtype, typename storagetype>
304  {
305  return mBits ? true : false;
306  }
307 
308  template<typename enumtype, typename storagetype>
310  {
311  return static_cast<PxU8>(mBits);
312  }
313 
314  template<typename enumtype, typename storagetype>
316  {
317  return static_cast<PxU16>(mBits);
318  }
319 
320  template<typename enumtype, typename storagetype>
322  {
323  return static_cast<PxU32>(mBits);
324  }
325 
326  template<typename enumtype, typename storagetype>
328  {
329  mBits &= ~static_cast<storagetype>(e);
330  }
331 
332 #ifndef PX_DOXYGEN
333 } // namespace physx
334 #endif
335 
337 #endif // #ifndef PX_FOUNDATION_PX_FLAGS_H


Copyright © 2008-2015 NVIDIA Corporation, 2701 San Tomas Expressway, Santa Clara, CA 95050 U.S.A. All rights reserved. www.nvidia.com