NVIDIA(R) PhysX(R) SDK 3.4 API Reference: PxFlags.h Source File

00001 //
00002 // Redistribution and use in source and binary forms, with or without
00003 // modification, are permitted provided that the following conditions
00004 // are met:
00005 //  * Redistributions of source code must retain the above copyright
00006 //    notice, this list of conditions and the following disclaimer.
00007 //  * Redistributions in binary form must reproduce the above copyright
00008 //    notice, this list of conditions and the following disclaimer in the
00009 //    documentation and/or other materials provided with the distribution.
00010 //  * Neither the name of NVIDIA CORPORATION nor the names of its
00011 //    contributors may be used to endorse or promote products derived
00012 //    from this software without specific prior written permission.
00013 //
00014 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
00015 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
00016 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
00017 // PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
00018 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
00019 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
00020 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
00021 // PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
00022 // OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
00023 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
00024 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
00025 //
00026 // Copyright (c) 2008-2018 NVIDIA Corporation. All rights reserved.
00027 // Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
00028 // Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
00029 
00030 #ifndef PXFOUNDATION_PXFLAGS_H
00031 #define PXFOUNDATION_PXFLAGS_H
00032 
00037 #include "foundation/Px.h"
00038 
00039 #if !PX_DOXYGEN
00040 namespace physx
00041 {
00042 #endif
00043 
00072 template <typename enumtype, typename storagetype = uint32_t>
00073 class PxFlags
00074 {
00075   public:
00076     typedef storagetype InternalType;
00077 
00078     PX_CUDA_CALLABLE PX_INLINE explicit PxFlags(const PxEMPTY)
00079     {
00080     }
00081     PX_CUDA_CALLABLE PX_INLINE PxFlags(void);
00082     PX_CUDA_CALLABLE PX_INLINE PxFlags(enumtype e);
00083     PX_CUDA_CALLABLE PX_INLINE PxFlags(const PxFlags<enumtype, storagetype>& f);
00084     PX_CUDA_CALLABLE PX_INLINE explicit PxFlags(storagetype b);
00085 
00086     PX_CUDA_CALLABLE PX_INLINE bool isSet(enumtype e) const;
00087     PX_CUDA_CALLABLE PX_INLINE PxFlags<enumtype, storagetype>& set(enumtype e);
00088     PX_CUDA_CALLABLE PX_INLINE bool operator==(enumtype e) const;
00089     PX_CUDA_CALLABLE PX_INLINE bool operator==(const PxFlags<enumtype, storagetype>& f) const;
00090     PX_CUDA_CALLABLE PX_INLINE bool operator==(bool b) const;
00091     PX_CUDA_CALLABLE PX_INLINE bool operator!=(enumtype e) const;
00092     PX_CUDA_CALLABLE PX_INLINE bool operator!=(const PxFlags<enumtype, storagetype>& f) const;
00093 
00094     PX_CUDA_CALLABLE PX_INLINE PxFlags<enumtype, storagetype>& operator=(const PxFlags<enumtype, storagetype>& f);
00095     PX_CUDA_CALLABLE PX_INLINE PxFlags<enumtype, storagetype>& operator=(enumtype e);
00096 
00097     PX_CUDA_CALLABLE PX_INLINE PxFlags<enumtype, storagetype>& operator|=(enumtype e);
00098     PX_CUDA_CALLABLE PX_INLINE PxFlags<enumtype, storagetype>& operator|=(const PxFlags<enumtype, storagetype>& f);
00099     PX_CUDA_CALLABLE PX_INLINE PxFlags<enumtype, storagetype> operator|(enumtype e) const;
00100     PX_CUDA_CALLABLE PX_INLINE PxFlags<enumtype, storagetype> operator|(const PxFlags<enumtype, storagetype>& f) const;
00101 
00102     PX_CUDA_CALLABLE PX_INLINE PxFlags<enumtype, storagetype>& operator&=(enumtype e);
00103     PX_CUDA_CALLABLE PX_INLINE PxFlags<enumtype, storagetype>& operator&=(const PxFlags<enumtype, storagetype>& f);
00104     PX_CUDA_CALLABLE PX_INLINE PxFlags<enumtype, storagetype> operator&(enumtype e) const;
00105     PX_CUDA_CALLABLE PX_INLINE PxFlags<enumtype, storagetype> operator&(const PxFlags<enumtype, storagetype>& f) const;
00106 
00107     PX_CUDA_CALLABLE PX_INLINE PxFlags<enumtype, storagetype>& operator^=(enumtype e);
00108     PX_CUDA_CALLABLE PX_INLINE PxFlags<enumtype, storagetype>& operator^=(const PxFlags<enumtype, storagetype>& f);
00109     PX_CUDA_CALLABLE PX_INLINE PxFlags<enumtype, storagetype> operator^(enumtype e) const;
00110     PX_CUDA_CALLABLE PX_INLINE PxFlags<enumtype, storagetype> operator^(const PxFlags<enumtype, storagetype>& f) const;
00111 
00112     PX_CUDA_CALLABLE PX_INLINE PxFlags<enumtype, storagetype> operator~(void) const;
00113 
00114     PX_CUDA_CALLABLE PX_INLINE operator bool(void) const;
00115     PX_CUDA_CALLABLE PX_INLINE operator uint8_t(void) const;
00116     PX_CUDA_CALLABLE PX_INLINE operator uint16_t(void) const;
00117     PX_CUDA_CALLABLE PX_INLINE operator uint32_t(void) const;
00118 
00119     PX_CUDA_CALLABLE PX_INLINE void clear(enumtype e);
00120 
00121   public:
00122     friend PX_INLINE PxFlags<enumtype, storagetype> operator&(enumtype a, PxFlags<enumtype, storagetype>& b)
00123     {
00124         PxFlags<enumtype, storagetype> out;
00125         out.mBits = a & b.mBits;
00126         return out;
00127     }
00128 
00129   private:
00130     storagetype mBits;
00131 };
00132 
00133 #define PX_FLAGS_OPERATORS(enumtype, storagetype)                                                                      \
00134     PX_INLINE PxFlags<enumtype, storagetype> operator|(enumtype a, enumtype b)                                         \
00135     {                                                                                                                  \
00136         PxFlags<enumtype, storagetype> r(a);                                                                           \
00137         r |= b;                                                                                                        \
00138         return r;                                                                                                      \
00139     }                                                                                                                  \
00140     PX_INLINE PxFlags<enumtype, storagetype> operator&(enumtype a, enumtype b)                                         \
00141     {                                                                                                                  \
00142         PxFlags<enumtype, storagetype> r(a);                                                                           \
00143         r &= b;                                                                                                        \
00144         return r;                                                                                                      \
00145     }                                                                                                                  \
00146     PX_INLINE PxFlags<enumtype, storagetype> operator~(enumtype a)                                                     \
00147     {                                                                                                                  \
00148         return ~PxFlags<enumtype, storagetype>(a);                                                                     \
00149     }
00150 
00151 #define PX_FLAGS_TYPEDEF(x, y)                                                                                         \
00152     typedef PxFlags<x::Enum, y> x##s;                                                                                  \
00153     PX_FLAGS_OPERATORS(x::Enum, y)
00154 
00155 template <typename enumtype, typename storagetype>
00156 PX_INLINE PxFlags<enumtype, storagetype>::PxFlags(void)
00157 {
00158     mBits = 0;
00159 }
00160 
00161 template <typename enumtype, typename storagetype>
00162 PX_INLINE PxFlags<enumtype, storagetype>::PxFlags(enumtype e)
00163 {
00164     mBits = static_cast<storagetype>(e);
00165 }
00166 
00167 template <typename enumtype, typename storagetype>
00168 PX_INLINE PxFlags<enumtype, storagetype>::PxFlags(const PxFlags<enumtype, storagetype>& f)
00169 {
00170     mBits = f.mBits;
00171 }
00172 
00173 template <typename enumtype, typename storagetype>
00174 PX_INLINE PxFlags<enumtype, storagetype>::PxFlags(storagetype b)
00175 {
00176     mBits = b;
00177 }
00178 
00179 template <typename enumtype, typename storagetype>
00180 PX_INLINE bool PxFlags<enumtype, storagetype>::isSet(enumtype e) const
00181 {
00182     return (mBits & static_cast<storagetype>(e)) == static_cast<storagetype>(e);
00183 }
00184 
00185 template <typename enumtype, typename storagetype>
00186 PX_INLINE PxFlags<enumtype, storagetype>& PxFlags<enumtype, storagetype>::set(enumtype e)
00187 {
00188     mBits = static_cast<storagetype>(e);
00189     return *this;
00190 }
00191 
00192 template <typename enumtype, typename storagetype>
00193 PX_INLINE bool PxFlags<enumtype, storagetype>::operator==(enumtype e) const
00194 {
00195     return mBits == static_cast<storagetype>(e);
00196 }
00197 
00198 template <typename enumtype, typename storagetype>
00199 PX_INLINE bool PxFlags<enumtype, storagetype>::operator==(const PxFlags<enumtype, storagetype>& f) const
00200 {
00201     return mBits == f.mBits;
00202 }
00203 
00204 template <typename enumtype, typename storagetype>
00205 PX_INLINE bool PxFlags<enumtype, storagetype>::operator==(bool b) const
00206 {
00207     return bool(*this) == b;
00208 }
00209 
00210 template <typename enumtype, typename storagetype>
00211 PX_INLINE bool PxFlags<enumtype, storagetype>::operator!=(enumtype e) const
00212 {
00213     return mBits != static_cast<storagetype>(e);
00214 }
00215 
00216 template <typename enumtype, typename storagetype>
00217 PX_INLINE bool PxFlags<enumtype, storagetype>::operator!=(const PxFlags<enumtype, storagetype>& f) const
00218 {
00219     return mBits != f.mBits;
00220 }
00221 
00222 template <typename enumtype, typename storagetype>
00223 PX_INLINE PxFlags<enumtype, storagetype>& PxFlags<enumtype, storagetype>::operator=(enumtype e)
00224 {
00225     mBits = static_cast<storagetype>(e);
00226     return *this;
00227 }
00228 
00229 template <typename enumtype, typename storagetype>
00230 PX_INLINE PxFlags<enumtype, storagetype>& PxFlags<enumtype, storagetype>::operator=(const PxFlags<enumtype, storagetype>& f)
00231 {
00232     mBits = f.mBits;
00233     return *this;
00234 }
00235 
00236 template <typename enumtype, typename storagetype>
00237 PX_INLINE PxFlags<enumtype, storagetype>& PxFlags<enumtype, storagetype>::operator|=(enumtype e)
00238 {
00239     mBits |= static_cast<storagetype>(e);
00240     return *this;
00241 }
00242 
00243 template <typename enumtype, typename storagetype>
00244 PX_INLINE PxFlags<enumtype, storagetype>& PxFlags<enumtype, storagetype>::
00245 operator|=(const PxFlags<enumtype, storagetype>& f)
00246 {
00247     mBits |= f.mBits;
00248     return *this;
00249 }
00250 
00251 template <typename enumtype, typename storagetype>
00252 PX_INLINE PxFlags<enumtype, storagetype> PxFlags<enumtype, storagetype>::operator|(enumtype e) const
00253 {
00254     PxFlags<enumtype, storagetype> out(*this);
00255     out |= e;
00256     return out;
00257 }
00258 
00259 template <typename enumtype, typename storagetype>
00260 PX_INLINE PxFlags<enumtype, storagetype> PxFlags<enumtype, storagetype>::
00261 operator|(const PxFlags<enumtype, storagetype>& f) const
00262 {
00263     PxFlags<enumtype, storagetype> out(*this);
00264     out |= f;
00265     return out;
00266 }
00267 
00268 template <typename enumtype, typename storagetype>
00269 PX_INLINE PxFlags<enumtype, storagetype>& PxFlags<enumtype, storagetype>::operator&=(enumtype e)
00270 {
00271     mBits &= static_cast<storagetype>(e);
00272     return *this;
00273 }
00274 
00275 template <typename enumtype, typename storagetype>
00276 PX_INLINE PxFlags<enumtype, storagetype>& PxFlags<enumtype, storagetype>::
00277 operator&=(const PxFlags<enumtype, storagetype>& f)
00278 {
00279     mBits &= f.mBits;
00280     return *this;
00281 }
00282 
00283 template <typename enumtype, typename storagetype>
00284 PX_INLINE PxFlags<enumtype, storagetype> PxFlags<enumtype, storagetype>::operator&(enumtype e) const
00285 {
00286     PxFlags<enumtype, storagetype> out = *this;
00287     out.mBits &= static_cast<storagetype>(e);
00288     return out;
00289 }
00290 
00291 template <typename enumtype, typename storagetype>
00292 PX_INLINE PxFlags<enumtype, storagetype> PxFlags<enumtype, storagetype>::
00293 operator&(const PxFlags<enumtype, storagetype>& f) const
00294 {
00295     PxFlags<enumtype, storagetype> out = *this;
00296     out.mBits &= f.mBits;
00297     return out;
00298 }
00299 
00300 template <typename enumtype, typename storagetype>
00301 PX_INLINE PxFlags<enumtype, storagetype>& PxFlags<enumtype, storagetype>::operator^=(enumtype e)
00302 {
00303     mBits ^= static_cast<storagetype>(e);
00304     return *this;
00305 }
00306 
00307 template <typename enumtype, typename storagetype>
00308 PX_INLINE PxFlags<enumtype, storagetype>& PxFlags<enumtype, storagetype>::
00309 operator^=(const PxFlags<enumtype, storagetype>& f)
00310 {
00311     mBits ^= f.mBits;
00312     return *this;
00313 }
00314 
00315 template <typename enumtype, typename storagetype>
00316 PX_INLINE PxFlags<enumtype, storagetype> PxFlags<enumtype, storagetype>::operator^(enumtype e) const
00317 {
00318     PxFlags<enumtype, storagetype> out = *this;
00319     out.mBits ^= static_cast<storagetype>(e);
00320     return out;
00321 }
00322 
00323 template <typename enumtype, typename storagetype>
00324 PX_INLINE PxFlags<enumtype, storagetype> PxFlags<enumtype, storagetype>::
00325 operator^(const PxFlags<enumtype, storagetype>& f) const
00326 {
00327     PxFlags<enumtype, storagetype> out = *this;
00328     out.mBits ^= f.mBits;
00329     return out;
00330 }
00331 
00332 template <typename enumtype, typename storagetype>
00333 PX_INLINE PxFlags<enumtype, storagetype> PxFlags<enumtype, storagetype>::operator~(void) const
00334 {
00335     PxFlags<enumtype, storagetype> out;
00336     out.mBits = storagetype(~mBits);
00337     return out;
00338 }
00339 
00340 template <typename enumtype, typename storagetype>
00341 PX_INLINE PxFlags<enumtype, storagetype>::operator bool(void) const
00342 {
00343     return mBits ? true : false;
00344 }
00345 
00346 template <typename enumtype, typename storagetype>
00347 PX_INLINE PxFlags<enumtype, storagetype>::operator uint8_t(void) const
00348 {
00349     return static_cast<uint8_t>(mBits);
00350 }
00351 
00352 template <typename enumtype, typename storagetype>
00353 PX_INLINE PxFlags<enumtype, storagetype>::operator uint16_t(void) const
00354 {
00355     return static_cast<uint16_t>(mBits);
00356 }
00357 
00358 template <typename enumtype, typename storagetype>
00359 PX_INLINE PxFlags<enumtype, storagetype>::operator uint32_t(void) const
00360 {
00361     return static_cast<uint32_t>(mBits);
00362 }
00363 
00364 template <typename enumtype, typename storagetype>
00365 PX_INLINE void PxFlags<enumtype, storagetype>::clear(enumtype e)
00366 {
00367     mBits &= ~static_cast<storagetype>(e);
00368 }
00369 
00370 #if !PX_DOXYGEN
00371 } // namespace physx
00372 #endif
00373 
00375 #endif // #ifndef PXFOUNDATION_PXFLAGS_H