1 /*---------------------------------------------------------------------------* 2 Project: Horizon 3 File: util_FlagsEnum.h 4 5 Copyright (C)2009-2012 Nintendo Co., Ltd. All rights reserved. 6 7 These coded instructions, statements, and computer programs contain 8 proprietary information of Nintendo of America Inc. and/or Nintendo 9 Company Ltd., and are protected by Federal copyright law. They may 10 not be disclosed to third parties or copied or duplicated in any form, 11 in whole or in part, without the prior written consent of Nintendo. 12 13 $Rev: 47346 $ 14 *---------------------------------------------------------------------------*/ 15 16 #ifndef NN_UTIL_UTIL_FLAGSENUM_H_ 17 #define NN_UTIL_UTIL_FLAGSENUM_H_ 18 19 #include <nn/types.h> 20 #include <nn/util/util_StaticAssert.h> 21 22 #ifdef __cplusplus 23 24 namespace nn { namespace util { 25 26 //--------------------------------------------------------------------------- 27 // 28 // 29 // 30 // 31 // 32 // 33 // 34 // 35 // 36 // 37 //--------------------------------------------------------------------------- 38 template <typename StorageT, typename EnumT> 39 class FlagsEnum 40 { 41 private: 42 typedef FlagsEnum<StorageT, EnumT> Self; 43 NN_STATIC_ASSERT(sizeof(EnumT) <= sizeof(StorageT)); 44 45 private: 46 StorageT m_FlagsValue; 47 48 public: 49 //--------------------------------------------------------------------------- 50 // 51 // 52 // 53 //--------------------------------------------------------------------------- FlagsEnum()54 FlagsEnum() : m_FlagsValue(0) {} 55 56 //--------------------------------------------------------------------------- 57 // 58 // 59 // 60 //--------------------------------------------------------------------------- FlagsEnum(EnumT e)61 FlagsEnum(EnumT e) : m_FlagsValue(e) {} 62 63 //--------------------------------------------------------------------------- 64 // 65 // 66 // 67 //--------------------------------------------------------------------------- FlagsEnum(StorageT e)68 FlagsEnum(StorageT e) : m_FlagsValue(e) {} 69 70 //--------------------------------------------------------------------------- 71 // 72 // 73 // 74 //--------------------------------------------------------------------------- EnumT()75 operator EnumT() const { return Get(); } 76 77 //--------------------------------------------------------------------------- 78 // 79 // 80 // 81 // 82 // 83 // 84 // 85 //--------------------------------------------------------------------------- 86 Self& operator =(bit32 v) { Replace(v); return *this; } 87 88 //--------------------------------------------------------------------------- 89 // 90 // 91 // 92 // 93 // 94 // 95 // 96 //--------------------------------------------------------------------------- 97 Self& operator =(int v) { Replace(v); return *this; } 98 99 //--------------------------------------------------------------------------- 100 // 101 // 102 // 103 // 104 // 105 // 106 //--------------------------------------------------------------------------- Replace(bit32 v)107 void Replace(bit32 v) { m_FlagsValue = static_cast<StorageT>(v); } 108 109 //--------------------------------------------------------------------------- 110 // 111 // 112 // 113 // 114 // 115 // 116 //--------------------------------------------------------------------------- Replace(int v)117 void Replace(int v) { m_FlagsValue = static_cast<StorageT>(v); } 118 119 //--------------------------------------------------------------------------- 120 // 121 // 122 // 123 // 124 // 125 //--------------------------------------------------------------------------- Get()126 bit32 Get() const { return m_FlagsValue; } 127 128 129 //--------------------------------------------------------------------------- 130 // 131 // 132 // 133 // 134 // 135 // 136 //--------------------------------------------------------------------------- Set(EnumT e)137 void Set(EnumT e) { m_FlagsValue |= e; } 138 139 //--------------------------------------------------------------------------- 140 // 141 // 142 // 143 // 144 // 145 // 146 //--------------------------------------------------------------------------- Clear(EnumT e)147 void Clear(EnumT e) { m_FlagsValue &= ~e; } 148 149 //--------------------------------------------------------------------------- 150 // 151 // 152 // 153 // 154 // 155 // 156 // 157 //--------------------------------------------------------------------------- IsSet(EnumT e)158 bool IsSet(EnumT e) const { return (m_FlagsValue & e) != 0; } 159 160 //--------------------------------------------------------------------------- 161 // 162 // 163 // 164 // 165 // 166 // 167 // 168 // 169 //--------------------------------------------------------------------------- IsSetAny(EnumT e)170 bool IsSetAny(EnumT e) const { return (m_FlagsValue & e) != 0; } 171 172 //--------------------------------------------------------------------------- 173 // 174 // 175 // 176 // 177 // 178 // 179 // 180 // 181 //--------------------------------------------------------------------------- IsSetAll(EnumT e)182 bool IsSetAll(EnumT e) const { return (m_FlagsValue & e) == e; } 183 }; 184 185 //--------------------------------------------------------------------------- 186 // 187 // 188 // 189 // 190 // 191 // 192 // 193 // 194 //--------------------------------------------------------------------------- 195 template <typename EnumT> 196 class FlagsEnum1 : public FlagsEnum<bit8, EnumT> 197 { 198 public: 199 //--------------------------------------------------------------------------- 200 // 201 //--------------------------------------------------------------------------- FlagsEnum1()202 FlagsEnum1() : FlagsEnum<bit8, EnumT>() {} 203 204 //--------------------------------------------------------------------------- 205 // 206 // 207 // 208 //--------------------------------------------------------------------------- FlagsEnum1(EnumT e)209 explicit FlagsEnum1(EnumT e) : FlagsEnum<bit8, EnumT>(e) {} 210 211 //--------------------------------------------------------------------------- 212 // 213 // 214 // 215 //--------------------------------------------------------------------------- FlagsEnum1(bit8 e)216 explicit FlagsEnum1(bit8 e) : FlagsEnum<bit8, EnumT>(e) {} 217 218 FlagsEnum1<EnumT>& operator =(bit32 v) { this->Replace(v); return *this; } 219 FlagsEnum1<EnumT>& operator =(int v) { this->Replace(v); return *this; } 220 }; 221 222 //--------------------------------------------------------------------------- 223 // 224 // 225 // 226 // 227 // 228 // 229 // 230 // 231 //--------------------------------------------------------------------------- 232 template <typename EnumT> 233 class FlagsEnum2 : public FlagsEnum<bit16, EnumT> 234 { 235 public: 236 //--------------------------------------------------------------------------- 237 // 238 //--------------------------------------------------------------------------- FlagsEnum2()239 FlagsEnum2() : FlagsEnum<bit16, EnumT>() {} 240 241 //--------------------------------------------------------------------------- 242 // 243 // 244 // 245 //--------------------------------------------------------------------------- FlagsEnum2(EnumT e)246 explicit FlagsEnum2(EnumT e) : FlagsEnum<bit16, EnumT>(e) {} 247 248 //--------------------------------------------------------------------------- 249 // 250 // 251 // 252 //--------------------------------------------------------------------------- FlagsEnum2(bit16 e)253 explicit FlagsEnum2(bit16 e) : FlagsEnum<bit16, EnumT>(e) {} 254 255 FlagsEnum2<EnumT>& operator =(bit32 v) { this->Replace(v); return *this; } 256 FlagsEnum2<EnumT>& operator =(int v) { this->Replace(v); return *this; } 257 }; 258 259 //--------------------------------------------------------------------------- 260 // 261 // 262 // 263 // 264 // 265 // 266 // 267 // 268 //--------------------------------------------------------------------------- 269 template <typename EnumT> 270 class FlagsEnum4 : public FlagsEnum<bit32, EnumT> 271 { 272 public: 273 //--------------------------------------------------------------------------- 274 // 275 //--------------------------------------------------------------------------- FlagsEnum4()276 FlagsEnum4() : FlagsEnum<bit32, EnumT>() {} 277 278 //--------------------------------------------------------------------------- 279 // 280 // 281 // 282 //--------------------------------------------------------------------------- FlagsEnum4(EnumT e)283 explicit FlagsEnum4(EnumT e) : FlagsEnum<bit32, EnumT>(e) {} 284 285 //--------------------------------------------------------------------------- 286 // 287 // 288 // 289 //--------------------------------------------------------------------------- FlagsEnum4(bit32 e)290 explicit FlagsEnum4(bit32 e) : FlagsEnum<bit32, EnumT>(e) {} 291 292 FlagsEnum4<EnumT>& operator =(bit32 v) { this->Replace(v); return *this; } 293 FlagsEnum4<EnumT>& operator =(int v) { this->Replace(v); return *this; } 294 }; 295 296 }} 297 298 299 #endif // __cplusplus 300 301 #endif /* NN_UTIL_UTIL_FLAGSENUM_H_ */ 302