1 /*---------------------------------------------------------------------------* 2 Project: Horizon 3 File: util_SizedEnum.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: 46347 $ 14 *---------------------------------------------------------------------------*/ 15 16 #ifndef NN_UTIL_UTIL_SIZEDENUM_H_ 17 #define NN_UTIL_UTIL_SIZEDENUM_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 SizedEnum 40 { 41 private: 42 typedef SizedEnum<StorageT, EnumT> Self; 43 // NN_STATIC_ASSERT(sizeof(EnumT) <= sizeof(StorageT)); 44 45 private: 46 StorageT m_EnumValue; 47 48 public: 49 //--------------------------------------------------------------------------- 50 // 51 // 52 // 53 //--------------------------------------------------------------------------- SizedEnum()54 SizedEnum() {} 55 56 //--------------------------------------------------------------------------- 57 // 58 // 59 // 60 // 61 // 62 //--------------------------------------------------------------------------- SizedEnum(EnumT e)63 SizedEnum(EnumT e) { Set(e); } 64 65 66 //--------------------------------------------------------------------------- 67 // 68 // 69 // 70 //--------------------------------------------------------------------------- EnumT()71 operator EnumT() const { return Get(); } 72 73 //--------------------------------------------------------------------------- 74 // 75 // 76 // 77 // 78 // 79 // 80 // 81 //--------------------------------------------------------------------------- 82 Self& operator =(EnumT e) { Set(e); return *this; } 83 84 85 //--------------------------------------------------------------------------- 86 // 87 // 88 // 89 // 90 // 91 //--------------------------------------------------------------------------- Set(EnumT e)92 void Set(EnumT e) { m_EnumValue = static_cast<EnumT>(e); } 93 94 //--------------------------------------------------------------------------- 95 // 96 // 97 // 98 // 99 // 100 //--------------------------------------------------------------------------- Get()101 EnumT Get() const { return static_cast<EnumT>(m_EnumValue); } 102 }; 103 104 //--------------------------------------------------------------------------- 105 // 106 // 107 // 108 // 109 // 110 // 111 // 112 //--------------------------------------------------------------------------- 113 template <typename EnumT> 114 class SizedEnum1 : public SizedEnum<bit8, EnumT> 115 { 116 public: 117 //--------------------------------------------------------------------------- 118 // 119 // 120 // 121 //--------------------------------------------------------------------------- SizedEnum1()122 SizedEnum1() : SizedEnum<bit8, EnumT>() {} 123 124 //--------------------------------------------------------------------------- 125 // 126 // 127 // 128 // 129 // 130 //--------------------------------------------------------------------------- SizedEnum1(EnumT e)131 SizedEnum1(EnumT e) : SizedEnum<bit8, EnumT>(e) {} 132 }; 133 134 //--------------------------------------------------------------------------- 135 // 136 // 137 // 138 // 139 // 140 // 141 // 142 //--------------------------------------------------------------------------- 143 template <typename EnumT> 144 class SizedEnum2 : public SizedEnum<bit16, EnumT> 145 { 146 public: 147 //--------------------------------------------------------------------------- 148 // 149 // 150 // 151 //--------------------------------------------------------------------------- SizedEnum2()152 SizedEnum2() : SizedEnum<bit16, EnumT>() {} 153 154 //--------------------------------------------------------------------------- 155 // 156 // 157 // 158 // 159 // 160 //--------------------------------------------------------------------------- SizedEnum2(EnumT e)161 SizedEnum2(EnumT e) : SizedEnum<bit16, EnumT>(e) {} 162 }; 163 164 //--------------------------------------------------------------------------- 165 // 166 // 167 // 168 // 169 // 170 // 171 // 172 //--------------------------------------------------------------------------- 173 template <typename EnumT> 174 class SizedEnum4 : public SizedEnum<bit32, EnumT> 175 { 176 public: 177 //--------------------------------------------------------------------------- 178 // 179 // 180 // 181 //--------------------------------------------------------------------------- SizedEnum4()182 SizedEnum4() : SizedEnum<bit32, EnumT>() {} 183 184 //--------------------------------------------------------------------------- 185 // 186 // 187 // 188 // 189 // 190 //--------------------------------------------------------------------------- SizedEnum4(EnumT e)191 SizedEnum4(EnumT e) : SizedEnum<bit32, EnumT>(e) {} 192 }; 193 194 }} 195 196 197 #endif // __cplusplus 198 199 #endif /* NN_UTIL_UTIL_SIZEDENUM_H_ */ 200