ZFFramework
Loading...
Searching...
No Matches
ZFEnumDeclare_inner.h
Go to the documentation of this file.
1
5
6#ifndef _ZFI_ZFEnumDeclare_inner_h_
7#define _ZFI_ZFEnumDeclare_inner_h_
8
9#include "ZFObjectClassTypeFwd.h"
10ZF_NAMESPACE_GLOBAL_BEGIN
11
12// ============================================================
14#define ZFENUM_INNER_BEGIN(OuterClass, EnumName) \
15 _ZFP_ZFENUM_INNER_BEGIN(OuterClass, EnumName)
16
18#define ZFENUM_INNER_VALUE(Value) \
19 _ZFP_ZFENUM_INNER_VALUE(Value)
20
21#define ZFENUM_INNER_VALUE_WITH_INIT(Value, initValue) \
22 _ZFP_ZFENUM_INNER_VALUE_WITH_INIT(Value, initValue)
23
25#define ZFENUM_INNER_SEPARATOR() \
26 _ZFP_ZFENUM_INNER_SEPARATOR(zffalse)
27
28#define ZFENUM_INNER_SEPARATOR_ALLOW_DUPLICATE_VALUE() \
29 _ZFP_ZFENUM_INNER_SEPARATOR(zftrue)
30
32#define ZFENUM_INNER_VALUE_REGISTER_WITH_NAME(Value, Name) \
33 _ZFP_ZFENUM_INNER_VALUE_REGISTER_WITH_NAME(Value, Name)
34
35#define ZFENUM_INNER_VALUE_REGISTER(Value) \
36 _ZFP_ZFENUM_INNER_VALUE_REGISTER_WITH_NAME(Value, zftext(#Value))
37
39#define ZFENUM_INNER_END(OuterClass, EnumName) \
40 _ZFP_ZFENUM_INNER_END(OuterClass, EnumName)
41
42#define ZFENUM_INNER_END_WITH_DEFAULT(OuterClass, EnumName, defaultEnum) \
43 _ZFP_ZFENUM_INNER_END_WITH_DEFAULT(OuterClass, EnumName, defaultEnum)
44
46#define ZFENUM_INNER_END_FLAGS(OuterClass, EnumName, EnumFlagsName) \
47 _ZFP_ZFENUM_INNER_END_FLAGS(OuterClass, EnumName, EnumFlagsName)
48
49#define ZFENUM_INNER_END_FLAGS_WITH_DEFAULT(OuterClass, EnumName, EnumFlagsName, defaultEnum, defaultEnumFlags) \
50 _ZFP_ZFENUM_INNER_END_FLAGS_WITH_DEFAULT(OuterClass, EnumName, EnumFlagsName, defaultEnum, defaultEnumFlags)
51
53#define ZFENUM_INNER_REG(OuterClass, EnumName) \
54 _ZFP_ZFENUM_INNER_TYPEID_REG(OuterClass, EnumName)
55
56#define ZFENUM_INNER_REG_FLAGS(OuterClass, EnumName, EnumFlagsName) \
57 ZFCORE_POD_DECLARE_NO_COMPARER(OuterClass::EnumFlagsName) \
58 _ZFP_ZFENUM_INNER_TYPEID_REG(OuterClass, EnumName) \
59 _ZFP_ZFENUM_INNER_FLAGS_TYPEID_REG(OuterClass, EnumName, EnumFlagsName)
60
62#define ZFENUM_INNER_DEFINE(OuterClass, EnumName) \
63 _ZFP_ZFENUM_INNER_DEFINE(OuterClass, EnumName)
64
66#define ZFENUM_INNER_DEFINE_FLAGS(OuterClass, EnumName, EnumFlagsName) \
67 _ZFP_ZFENUM_INNER_DEFINE_FLAGS(OuterClass, EnumName, EnumFlagsName)
68
69// ============================================================
70#define _ZFP_ZFENUM_INNER_BEGIN(OuterClass, EnumName) \
71 zfclass v_##EnumName : zfextend ZFEnum { \
72 ZFOBJECT_DECLARE(v_##EnumName, ZFEnum, OuterClass) \
73 public: \
74 \
75 typedef enum {
76
77#define _ZFP_ZFENUM_INNER_VALUE(Value) e_##Value,
78#define _ZFP_ZFENUM_INNER_VALUE_WITH_INIT(Value, initValue) e_##Value = initValue,
79
80#define _ZFP_ZFENUM_INNER_SEPARATOR(isEnableDuplicateValue_) \
81 /* used to ensure sizeof(enum) == sizeof(zfuint) */ \
82 /* required for enum value reinterpret cast (ZFTAG_TRICKS: EnumReinterpretCast) */ \
83 _ZFP_ZFEnumMax = ((zfuint)-1), \
84 } ZFEnumType; \
85 public: \
86 \
87 static zfindex EnumCount(void) { \
88 return zfself::_ZFP_ZFEnumDataRef().enumCount(); \
89 } \
90 \
91 static zfindex EnumIndexForValue(ZF_IN zfuint value) { \
92 return zfself::_ZFP_ZFEnumDataRef().enumIndexForValue(value); \
93 } \
94 \
95 static zfuint EnumValueAt(ZF_IN zfindex index) { \
96 return zfself::_ZFP_ZFEnumDataRef().enumValueAt(index); \
97 } \
98 \
99 static const zfstring &EnumNameAt(ZF_IN zfindex index) { \
100 return zfself::_ZFP_ZFEnumDataRef().enumNameAt(index); \
101 } \
102 \
103 static zfbool EnumValueContain(ZF_IN zfuint value) { \
104 return zfself::_ZFP_ZFEnumDataRef().enumValueContain(value); \
105 } \
106 \
107 static zfuint EnumValueForName(ZF_IN const zfstring &name) { \
108 return zfself::_ZFP_ZFEnumDataRef().enumValueForName(name); \
109 } \
110 \
111 static const zfstring &EnumNameForValue(ZF_IN zfuint value) { \
112 return zfself::_ZFP_ZFEnumDataRef().enumNameForValue(value); \
113 } \
114 public: \
115 \
116 zfoverride \
117 virtual zfindex enumCount(void) { \
118 return zfself::EnumCount(); \
119 } \
120 zfoverride \
121 virtual zfuint enumDefault(void) { \
122 return zfself::EnumDefault(); \
123 } \
124 zfoverride \
125 virtual zfbool enumIsFlags(void) { \
126 return zfself::EnumIsFlags(); \
127 } \
128 zfoverride \
129 virtual zfindex enumIndexForValue(ZF_IN zfuint value) { \
130 return zfself::EnumIndexForValue(value); \
131 } \
132 zfoverride \
133 virtual zfuint enumValueAt(ZF_IN zfindex index) { \
134 return zfself::EnumValueAt(index); \
135 } \
136 zfoverride \
137 virtual const zfstring &enumNameAt(ZF_IN zfindex index) { \
138 return zfself::EnumNameAt(index); \
139 } \
140 zfoverride \
141 virtual zfbool enumValueContain(ZF_IN zfuint value) { \
142 return zfself::EnumValueContain(value); \
143 } \
144 zfoverride \
145 virtual zfuint enumValueForName(ZF_IN const zfstring &name) { \
146 return zfself::EnumValueForName(name); \
147 } \
148 zfoverride \
149 virtual const zfstring &enumNameForValue(ZF_IN zfuint value) { \
150 return zfself::EnumNameForValue(value); \
151 } \
152 \
153 public: \
154 static const _ZFP_ZFEnumData &_ZFP_ZFEnumDataRef(void) { \
155 static _ZFP_ZFEnumDataHolder d(_ZFP_ZFEnumDataInit()); \
156 return d.d; \
157 } \
158 static const _ZFP_ZFEnumData &_ZFP_ZFEnumDataInit(void) { \
159 ZFCoreMutexLocker(); \
160 _ZFP_ZFEnumData &d = _ZFP_ZFEnumDataAccess(zfself::ClassData()); \
161 if(d.needInitFlag) { \
162 d.needInitFlag = zffalse; \
163 zfbool isEnableDuplicateValue = isEnableDuplicateValue_;
164
165#define _ZFP_ZFENUM_INNER_VALUE_REGISTER_WITH_NAME(Value, Name) \
166 d.add(isEnableDuplicateValue, zfself::e_##Value, Name);
167
168#define _ZFP_ZFENUM_INNER_END(OuterClass, EnumName) \
169 _ZFP_ZFENUM_INNER_END_DETAIL(OuterClass, EnumName, zffalse, d.enumValueAt(0))
170#define _ZFP_ZFENUM_INNER_END_WITH_DEFAULT(OuterClass, EnumName, defaultEnum) \
171 _ZFP_ZFENUM_INNER_END_DETAIL(OuterClass, EnumName, zffalse, zfself::e_##defaultEnum)
172
173#define _ZFP_ZFENUM_INNER_END_FLAGS(OuterClass, EnumName, EnumFlagsName) \
174 _ZFP_ZFENUM_INNER_END_DETAIL(OuterClass, EnumName, zftrue, d.enumValueAt(0)) \
175 _ZFP_ZFENUM_INNER_FLAGS_DECLARE(OuterClass, EnumName, EnumFlagsName, v_##EnumName::EnumDefault())
176#define _ZFP_ZFENUM_INNER_END_FLAGS_WITH_DEFAULT(OuterClass, EnumName, EnumFlagsName, defaultEnum, defaultEnumFlags) \
177 _ZFP_ZFENUM_INNER_END_DETAIL(OuterClass, EnumName, zftrue, zfself::e_##defaultEnum) \
178 _ZFP_ZFENUM_INNER_FLAGS_DECLARE(OuterClass, EnumName, EnumFlagsName, defaultEnumFlags)
179
180#define _ZFP_ZFENUM_INNER_END_DETAIL(OuterClass, EnumName, IsFlags, defaultEnum) \
181 d.enumDefault = (zfuint)(defaultEnum); \
182 d.enumIsFlags = (IsFlags); \
183 } \
184 return d; \
185 } \
186 public: \
187 \
188 static inline zfbool EnumIsFlags(void) { \
189 return (v_##EnumName::ZFEnumType)zfself::_ZFP_ZFEnumDataRef().enumIsFlags; \
190 } \
191 \
192 static inline v_##EnumName::ZFEnumType EnumDefault(void) { \
193 return (v_##EnumName::ZFEnumType)zfself::_ZFP_ZFEnumDataRef().enumDefault; \
194 } \
195 public: \
196 \
197 zffinal zfself::ZFEnumType zfv(void) { \
198 return (zfself::ZFEnumType)this->enumValue(); \
199 } \
200 public: \
201 zfoverride \
202 virtual const zfstring &zfvTypeId(void); \
203 }; \
204 \
205 typedef v_##EnumName::ZFEnumType EnumName; \
206 _ZFP_ZFENUM_INNER_CONVERTER_DECLARE(OuterClass, EnumName) \
207 _ZFP_ZFENUM_INNER_TYPEID_DECLARE(OuterClass, EnumName)
208
209// ============================================================
210#define _ZFP_ZFENUM_INNER_DEFINE(OuterClass, EnumName) \
211 _ZFP_ZFENUM_INNER_CONVERTER_DEFINE(OuterClass, EnumName) \
212 ZFOBJECT_REGISTER(OuterClass, v_##EnumName) \
213 _ZFP_ZFENUM_INNER_TYPEID_DEFINE(OuterClass, EnumName) \
214 ZF_STATIC_REGISTER_INIT(EnumReg_##OuterClass##_##EnumName) { \
215 for(zfindex i = 0; i < OuterClass::v_##EnumName::EnumCount(); ++i) { \
216 ZFMethodUserRegisterDetail_0(resultMethod, { \
217 return (OuterClass::EnumName)OuterClass::v_##EnumName::EnumValueForName(invokerMethod->methodName() + 2); \
218 }, OuterClass::v_##EnumName::ClassData(), public, ZFMethodTypeStatic, \
219 OuterClass::EnumName, zfstr("e_%s", OuterClass::v_##EnumName::EnumNameAt(i))); \
220 _m.add(resultMethod); \
221 } \
222 _ZFP_ZFEnumMethodReg(_m, OuterClass::v_##EnumName::_ZFP_ZFEnumDataRef()); \
223 } \
224 ZF_STATIC_REGISTER_DESTROY(EnumReg_##OuterClass##_##EnumName) { \
225 for(zfindex i = 0; i < _m.count(); ++i) { \
226 ZFMethodUserUnregister(_m[i]); \
227 } \
228 } \
229 ZFCoreArray<const ZFMethod *> _m; \
230 ZF_STATIC_REGISTER_END(EnumReg_##OuterClass##_##EnumName)
231
232#define _ZFP_ZFENUM_INNER_DEFINE_FLAGS(OuterClass, EnumName, EnumFlagsName) \
233 _ZFP_ZFENUM_INNER_DEFINE(OuterClass, EnumName) \
234 _ZFP_ZFENUM_INNER_FLAGS_DEFINE(OuterClass, EnumName, EnumFlagsName)
235
236// ============================================================
237#define _ZFP_ZFENUM_INNER_CONVERTER_DECLARE(OuterClass, EnumName) \
238 \
239 static zfbool EnumName##FromStringT( \
240 ZF_OUT zfauto &ret \
241 , ZF_IN const zfchar *src \
242 , ZF_IN_OPT zfindex srcLen = zfindexMax() \
243 , ZF_OUT_OPT zfstring *errorHint = zfnull \
244 ); \
245 \
246 static zfbool EnumName##ToStringT( \
247 ZF_IN_OUT zfstring &ret \
248 , ZF_IN v_##EnumName *const &value \
249 , ZF_OUT_OPT zfstring *errorHint = zfnull \
250 ); \
251 \
252 static inline zfstring EnumName##ToString( \
253 ZF_IN v_##EnumName *const &value \
254 , ZF_OUT_OPT zfstring *errorHint = zfnull \
255 ) { \
256 zfstring ret; \
257 EnumName##ToStringT(ret, value, errorHint); \
258 return ret; \
259 }
260#define _ZFP_ZFENUM_INNER_CONVERTER_DEFINE(OuterClass, EnumName) \
261 zfbool OuterClass::EnumName##ToStringT( \
262 ZF_IN_OUT zfstring &ret \
263 , ZF_IN OuterClass::v_##EnumName *const &value \
264 , ZF_OUT_OPT zfstring *errorHint /* = zfnull */ \
265 ) { \
266 ret += ((value == zfnull) ? zfstring() : value->enumName()); \
267 return zftrue; \
268 } \
269 zfbool OuterClass::EnumName##FromStringT( \
270 ZF_OUT zfauto &ret \
271 , ZF_IN const zfchar *src \
272 , ZF_IN_OPT zfindex srcLen /* = zfindexMax() */ \
273 , ZF_OUT_OPT zfstring *errorHint /* = zfnull */ \
274 ) { \
275 if(zfstringIsEqual(src, srcLen, ZFEnumNameInvalid(), zfindexMax())) { \
276 ret = zfobj<v_##EnumName>(ZFEnumInvalid()); \
277 return zftrue; \
278 } \
279 zfuint tmpValue = v_##EnumName::EnumValueForName( \
280 (srcLen == zfindexMax()) ? src : zfstring(src, srcLen).cString()); \
281 if(tmpValue == ZFEnumInvalid()) { \
282 zfstringAppend(errorHint, "no enum named: \"%s\"", zfstring(src, srcLen)); \
283 return zffalse; \
284 } \
285 else { \
286 ret = zfobj<v_##EnumName>(tmpValue); \
287 return zftrue; \
288 } \
289 }
290
291// ============================================================
292#define _ZFP_ZFENUM_INNER_FLAGS_DECLARE(OuterClass, EnumName, EnumFlagsName, defaultValue) \
293 \
294 zffinal zfclassPOD EnumFlagsName { \
295 /* this class should be POD-like to support enum value reinterpret cast (ZFTAG_TRICKS: EnumReinterpretCast) */ \
296 public: \
297 \
298 static zfuint EnumDefault(void) { \
299 return defaultValue; \
300 } \
301 public: \
302 \
303 EnumFlagsName(void) : flags(0) {} \
304 EnumFlagsName(ZF_IN zfuint const &flags) : flags(flags) {} \
305 EnumFlagsName(ZF_IN EnumName const &flags) : flags((zfuint)flags) {} \
306 EnumFlagsName(ZF_IN EnumFlagsName const &ref) : flags(ref.flags) {} \
307 public: \
308 zfuint const &enumValue(void) const {return this->flags;} \
309 void enumValue(ZF_IN zfuint const &flags) {this->flags = flags;} \
310 void enumValue(ZF_IN EnumName const &flags) {this->flags = (zfuint)flags;} \
311 public: \
312 operator zfuint const & (void) const {return this->flags;} \
313 EnumFlagsName &operator = (ZF_IN zfuint const &flags) {this->flags = flags; return *this;} \
314 EnumFlagsName &operator = (ZF_IN EnumName const &flags) {this->flags = (zfuint)flags; return *this;} \
315 EnumFlagsName &operator = (ZF_IN EnumFlagsName const &ref) {this->flags = ref.flags; return *this;} \
316 zfbool operator == (ZF_IN zfuint const &flags) const {return (this->flags == flags);} \
317 zfbool operator == (ZF_IN EnumName const &flags) const {return (this->flags == (zfuint)flags);} \
318 zfbool operator == (ZF_IN EnumFlagsName const &ref) const {return (this->flags == ref.flags);} \
319 zfbool operator != (ZF_IN zfuint const &flags) const {return (this->flags != flags);} \
320 zfbool operator != (ZF_IN EnumName const &flags) const {return (this->flags != (zfuint)flags);} \
321 zfbool operator != (ZF_IN EnumFlagsName const &ref) const {return (this->flags != ref.flags);} \
322 EnumFlagsName &operator |= (ZF_IN zfuint const &flags) {this->flags |= flags; return *this;} \
323 EnumFlagsName &operator |= (ZF_IN EnumName const &flags) {this->flags |= (zfuint)flags; return *this;} \
324 EnumFlagsName &operator |= (ZF_IN EnumFlagsName const &ref) {this->flags |= ref.flags; return *this;} \
325 EnumFlagsName &operator &= (ZF_IN zfuint const &flags) {this->flags &= flags; return *this;} \
326 EnumFlagsName &operator &= (ZF_IN EnumName const &flags) {this->flags &= (zfuint)flags; return *this;} \
327 EnumFlagsName &operator &= (ZF_IN EnumFlagsName const &ref) {this->flags &= ref.flags; return *this;} \
328 public: \
329 void objectInfoT(ZF_IN_OUT zfstring &ret) const; \
330 inline zfstring objectInfo(void) const { \
331 zfstring ret; \
332 this->objectInfoT(ret); \
333 return ret; \
334 } \
335 \
336 private: \
337 zfuint flags; \
338 }; \
339 _ZFP_ZFENUM_INNER_FLAGS_TYPEID_DECLARE(OuterClass, EnumName, EnumFlagsName)
340
341#define _ZFP_ZFENUM_INNER_FLAGS_DEFINE(OuterClass, EnumName, EnumFlagsName) \
342 void OuterClass::EnumFlagsName::objectInfoT(ZF_IN_OUT zfstring &ret) const { \
343 zfflagsToStringT(ret, v_##EnumName::ClassData(), (zfflags)this->enumValue()); \
344 } \
345 _ZFP_ZFENUM_INNER_FLAGS_TYPEID_DEFINE(OuterClass, EnumName, EnumFlagsName)
346
347
348// ============================================================
349// normal enum
350#define _ZFP_ZFENUM_INNER_TYPEID_DECLARE(OuterClass, EnumName) \
351 ZFTYPEID_INNER_DECLARE_WITH_CUSTOM_WRAPPER(OuterClass, EnumName, EnumName)
352#define _ZFP_ZFENUM_INNER_TYPEID_REG(OuterClass, EnumName) \
353 \
354 template<> \
355 zfclassNotPOD ZFTypeId<OuterClass::EnumName> : zfextend ZFTypeInfo { \
356 public: \
357 typedef OuterClass::EnumName _ZFP_PropType; \
358 typedef OuterClass::v_##EnumName _ZFP_WrapType; \
359 public: \
360 enum { \
361 TypeIdRegistered = 1, \
362 TypeIdSerializable = 1, \
363 }; \
364 static inline const zfstring &TypeId(void) { \
365 return OuterClass::ZFTypeId_##EnumName(); \
366 } \
367 static inline const ZFClass *TypeIdClass(void) { \
368 return _ZFP_WrapType::ClassData(); \
369 } \
370 zfoverride \
371 virtual zfbool typeIdSerializable(void) const { \
372 return TypeIdSerializable; \
373 } \
374 zfoverride \
375 virtual const zfstring &typeId(void) const { \
376 return TypeId(); \
377 } \
378 zfoverride \
379 virtual const ZFClass *typeIdClass(void) const { \
380 return TypeIdClass(); \
381 } \
382 static zfbool ValueStore( \
383 ZF_OUT zfauto &obj \
384 , ZF_IN zfuint const &v \
385 ) { \
386 ZFCoreMutexLock(); \
387 _ZFP_WrapType *t = zfunsafe_zfobjAlloc(_ZFP_WrapType, v); \
388 obj.zfunsafe_assign(t); \
389 zfunsafe_zfobjRelease(t); \
390 ZFCoreMutexUnlock(); \
391 return zftrue; \
392 } \
393 static zfbool ValueStore( \
394 ZF_OUT zfauto &obj \
395 , ZF_IN _ZFP_PropType const &v \
396 ) { \
397 ZFCoreMutexLock(); \
398 _ZFP_WrapType *t = zfunsafe_zfobjAlloc(_ZFP_WrapType, (zfuint)v); \
399 obj.zfunsafe_assign(t); \
400 zfunsafe_zfobjRelease(t); \
401 ZFCoreMutexUnlock(); \
402 return zftrue; \
403 } \
404 template<typename T_Access = _ZFP_PropType \
405 , int T_Mode = ((zftTraits<typename zftTraits<T_Access>::TrNoRef>::TrIsPtr \
406 && !zftIsSame<typename zftTraits<T_Access>::TrNoRef, _ZFP_PropType>::Value) ? 1 \
407 : ((zftTraits<typename zftTraits<T_Access>::TrNoRef>::TrIsPtr \
408 && zftIsSame<typename zftTraits<T_Access>::TrNoRef, _ZFP_PropType>::Value \
409 && !zftTraits<T_Access>::TrIsRef) ? 2 : 0)) \
410 , typename T_Fix = void \
411 > \
412 zfclassNotPOD Value { \
413 public: \
414 static zfbool zfvAccessAvailable(ZF_IN const zfauto &obj) { \
415 return (zfcast(_ZFP_WrapType *, obj) != zfnull); \
416 } \
417 static T_Access zfvAccess(ZF_IN const zfauto &obj) { \
418 /* ZFTAG_TRICKS: EnumReinterpretCast */ \
419 return *(typename zftTraits<T_Access>::TrNoRef *)(&(zfcast(_ZFP_WrapType *, obj)->_ZFP_ZFEnum_value)); \
420 } \
421 static zfauto zfvAccessFinish(ZF_IN const zfauto &obj) { \
422 return zfnull; \
423 } \
424 }; \
425 template<typename T_Access> \
426 zfclassNotPOD Value<T_Access, 1> { \
427 public: \
428 static zfbool zfvAccessAvailable(ZF_IN const zfauto &obj) { \
429 return obj == zfnull || (zfcast(_ZFP_WrapType *, obj) != zfnull); \
430 } \
431 static typename zftTraits<T_Access>::TrNoRef zfvAccess(ZF_IN const zfauto &obj) { \
432 if(obj == zfnull) { \
433 return zfnull; \
434 } \
435 else { \
436 _ZFP_WrapType *t = zfcast(_ZFP_WrapType *, obj); \
437 /* ZFTAG_TRICKS: EnumReinterpretCast */ \
438 return (typename zftTraits<T_Access>::TrNoRef)(&(t->_ZFP_ZFEnum_value)); \
439 } \
440 } \
441 static zfauto zfvAccessFinish(ZF_IN const zfauto &obj) { \
442 return zfnull; \
443 } \
444 }; \
445 zfoverride \
446 virtual zfbool genericValueStore(ZF_OUT zfauto &obj, ZF_IN const void *v) const { \
447 return ValueStore(obj, *(const _ZFP_PropType *)v); \
448 } \
449 zfoverride \
450 virtual void *genericAccess(ZF_IN const zfauto &obj) const { \
451 if(!Value<_ZFP_PropType>::zfvAccessAvailable(obj)) { \
452 return zfnull; \
453 } \
454 else { \
455 return _ZFP_genericAccessWrap<_ZFP_PropType>(Value<_ZFP_PropType>::zfvAccess(obj)); \
456 } \
457 } \
458 zfoverride \
459 virtual zfauto genericAccessFinish(ZF_IN const zfauto &obj, ZF_IN void *v) const { \
460 return _ZFP_genericAccessFinishWrap(Value<_ZFP_PropType>::zfvAccessFinish(obj), v, _ZFP_genericAccessFinish<_ZFP_PropType>); \
461 } \
462 zfoverride \
463 virtual ZFCoreArrayBase *genericArrayNew(void) const { \
464 return ZFCoreArray<_ZFP_PropType>().refNew(); \
465 } \
466 }; \
467 \
468 ZFOUTPUT_TYPE(OuterClass::EnumName, {s += OuterClass::v_##EnumName::EnumNameForValue(v);})
469
470#define _ZFP_ZFENUM_INNER_TYPEID_DEFINE(OuterClass, EnumName) \
471 ZFTYPEID_INNER_DEFINE_BY_STRING_CONVERTER_WITH_CUSTOM_WRAPPER(OuterClass, EnumName, EnumName, { \
472 if(zfstringIsEqual(src, srcLen, ZFEnumNameInvalid(), zfindexMax())) { \
473 v = (EnumName)ZFEnumInvalid(); \
474 return zftrue; \
475 } \
476 v = (EnumName)v_##EnumName::EnumValueForName( \
477 (srcLen == zfindexMax()) ? src : zfstring(src, srcLen).cString() \
478 ); \
479 if(v == ZFEnumInvalid()) { \
480 if(errorHint) { \
481 zfstringAppend(errorHint, "invalid value: \"%s\"", zfstring(src, srcLen)); \
482 } \
483 return zffalse; \
484 } \
485 return zftrue; \
486 }, { \
487 s += v_##EnumName::EnumNameForValue(v); \
488 return zftrue; \
489 }) \
490 const zfstring &OuterClass::v_##EnumName::zfvTypeId(void) { \
491 return ZFTypeId_##EnumName(); \
492 }
493
494
495// ============================================================
496// enum flags
497#define _ZFP_ZFENUM_INNER_FLAGS_TYPEID_DECLARE(OuterClass, EnumName, EnumFlagsName) \
498 ZFTYPEID_INNER_DECLARE_WITH_CUSTOM_WRAPPER(OuterClass, EnumFlagsName, EnumFlagsName) \
499 \
500 typedef v_##EnumName v_##EnumFlagsName;
501#define _ZFP_ZFENUM_INNER_FLAGS_TYPEID_REG(OuterClass, EnumName, EnumFlagsName) \
502 \
503 template<> \
504 zfclassNotPOD ZFTypeId<OuterClass::EnumFlagsName> : zfextend ZFTypeInfo { \
505 public: \
506 typedef OuterClass::EnumName _ZFP_PropTypeOrig; \
507 typedef OuterClass::EnumFlagsName _ZFP_PropType; \
508 typedef OuterClass::v_##EnumFlagsName _ZFP_WrapType; \
509 public: \
510 enum { \
511 TypeIdRegistered = 1, \
512 TypeIdSerializable = 1, \
513 }; \
514 static inline const zfstring &TypeId(void) { \
515 return OuterClass::ZFTypeId_##EnumFlagsName(); \
516 } \
517 static inline const ZFClass *TypeIdClass(void) { \
518 return _ZFP_WrapType::ClassData(); \
519 } \
520 zfoverride \
521 virtual zfbool typeIdSerializable(void) const { \
522 return TypeIdSerializable; \
523 } \
524 zfoverride \
525 virtual const zfstring &typeId(void) const { \
526 return TypeId(); \
527 } \
528 zfoverride \
529 virtual const ZFClass *typeIdClass(void) const { \
530 return TypeIdClass(); \
531 } \
532 static zfbool ValueStore( \
533 ZF_OUT zfauto &obj \
534 , ZF_IN zfuint const &v \
535 ) { \
536 ZFCoreMutexLock(); \
537 _ZFP_WrapType *t = zfunsafe_zfobjAlloc(_ZFP_WrapType, v); \
538 obj.zfunsafe_assign(t); \
539 zfunsafe_zfobjRelease(t); \
540 ZFCoreMutexUnlock(); \
541 return zftrue; \
542 } \
543 static zfbool ValueStore( \
544 ZF_OUT zfauto &obj \
545 , ZF_IN _ZFP_PropTypeOrig const &v \
546 ) { \
547 ZFCoreMutexLock(); \
548 _ZFP_WrapType *t = zfunsafe_zfobjAlloc(_ZFP_WrapType, (zfuint)v); \
549 obj.zfunsafe_assign(t); \
550 zfunsafe_zfobjRelease(t); \
551 ZFCoreMutexUnlock(); \
552 return zftrue; \
553 } \
554 static zfbool ValueStore( \
555 ZF_OUT zfauto &obj \
556 , ZF_IN _ZFP_PropType const &v \
557 ) { \
558 ZFCoreMutexLock(); \
559 _ZFP_WrapType *t = zfunsafe_zfobjAlloc(_ZFP_WrapType, (zfuint)v); \
560 obj.zfunsafe_assign(t); \
561 zfunsafe_zfobjRelease(t); \
562 ZFCoreMutexUnlock(); \
563 return zftrue; \
564 } \
565 template<typename T_Access = _ZFP_PropType \
566 , int T_Mode = ((zftTraits<typename zftTraits<T_Access>::TrNoRef>::TrIsPtr \
567 && !zftIsSame<typename zftTraits<T_Access>::TrNoRef, _ZFP_PropType>::Value) ? 1 \
568 : ((zftTraits<typename zftTraits<T_Access>::TrNoRef>::TrIsPtr \
569 && zftIsSame<typename zftTraits<T_Access>::TrNoRef, _ZFP_PropType>::Value \
570 && !zftTraits<T_Access>::TrIsRef) ? 2 : 0)) \
571 , typename T_Fix = void \
572 > \
573 zfclassNotPOD Value { \
574 public: \
575 static zfbool zfvAccessAvailable(ZF_IN const zfauto &obj) { \
576 return (zfcast(_ZFP_WrapType *, obj) != zfnull); \
577 } \
578 static T_Access zfvAccess(ZF_IN const zfauto &obj) { \
579 /* ZFTAG_TRICKS: EnumReinterpretCast */ \
580 return *(typename zftTraits<T_Access>::TrNoRef *)(&(zfcast(_ZFP_WrapType *, obj)->_ZFP_ZFEnum_value)); \
581 } \
582 static zfauto zfvAccessFinish(ZF_IN const zfauto &obj) { \
583 return zfnull; \
584 } \
585 }; \
586 template<typename T_Access> \
587 zfclassNotPOD Value<T_Access, 1> { \
588 public: \
589 static zfbool zfvAccessAvailable(ZF_IN const zfauto &obj) { \
590 return obj == zfnull || (zfcast(_ZFP_WrapType *, obj) != zfnull); \
591 } \
592 static typename zftTraits<T_Access>::TrNoRef zfvAccess(ZF_IN const zfauto &obj) { \
593 if(obj == zfnull) { \
594 return zfnull; \
595 } \
596 else { \
597 _ZFP_WrapType *t = zfcast(_ZFP_WrapType *, obj); \
598 /* ZFTAG_TRICKS: EnumReinterpretCast */ \
599 return (typename zftTraits<T_Access>::TrNoRef)(&(t->_ZFP_ZFEnum_value)); \
600 } \
601 } \
602 static zfauto zfvAccessFinish(ZF_IN const zfauto &obj) { \
603 return zfnull; \
604 } \
605 }; \
606 zfoverride \
607 virtual zfbool genericValueStore(ZF_OUT zfauto &obj, ZF_IN const void *v) const { \
608 return ValueStore(obj, *(const _ZFP_PropType *)v); \
609 } \
610 zfoverride \
611 virtual void *genericAccess(ZF_IN const zfauto &obj) const { \
612 if(!Value<_ZFP_PropType>::zfvAccessAvailable(obj)) { \
613 return zfnull; \
614 } \
615 else { \
616 return _ZFP_genericAccessWrap<_ZFP_PropType>(Value<_ZFP_PropType>::zfvAccess(obj)); \
617 } \
618 } \
619 zfoverride \
620 virtual zfauto genericAccessFinish(ZF_IN const zfauto &obj, ZF_IN void *v) const { \
621 return _ZFP_genericAccessFinishWrap(Value<_ZFP_PropType>::zfvAccessFinish(obj), v, _ZFP_genericAccessFinish<_ZFP_PropType>); \
622 } \
623 zfoverride \
624 virtual ZFCoreArrayBase *genericArrayNew(void) const { \
625 return ZFCoreArray<_ZFP_PropType>().refNew(); \
626 } \
627 }; \
628 \
629 ZFOUTPUT_TYPE(OuterClass::EnumFlagsName, {v.objectInfoT(s);})
630
631#define _ZFP_ZFENUM_INNER_FLAGS_TYPEID_DEFINE(OuterClass, EnumName, EnumFlagsName) \
632 ZFTYPEID_INNER_DEFINE_BY_STRING_CONVERTER_WITH_CUSTOM_WRAPPER(OuterClass, EnumFlagsName, EnumFlagsName, { \
633 zfflags flags = 0; \
634 if(!zfflagsFromStringT(flags, \
635 v_##EnumName::ClassData(), \
636 src, srcLen)) { \
637 if(errorHint) { \
638 zfstringAppend(errorHint, "invalid value: \"%s\"", zfstring(src, srcLen)); \
639 } \
640 return zffalse; \
641 } \
642 v.enumValue((zfuint)flags); \
643 return zftrue; \
644 }, { \
645 return zfflagsToStringT(s, v_##EnumName::ClassData(), (zfflags)v.enumValue()); \
646 }) \
647 ZF_STATIC_REGISTER_INIT(EnumReg_##OuterClass##_##EnumFlagsName) { \
648 ZFClassAlias(OuterClass::v_##EnumName::ClassData(), OuterClass::v_##EnumName::ClassData()->classNamespace() \
649 ? zfstr("%s.%s", OuterClass::v_##EnumName::ClassData()->classNamespace(), #EnumFlagsName).cString() \
650 : #EnumFlagsName \
651 ); \
652 } \
653 ZF_STATIC_REGISTER_DESTROY(EnumReg_##OuterClass##_##EnumFlagsName) { \
654 ZFClassAliasRemove(OuterClass::v_##EnumName::ClassData(), OuterClass::v_##EnumName::ClassData()->classNamespace() \
655 ? zfstr("%s.%s", OuterClass::v_##EnumName::ClassData()->classNamespace(), #EnumFlagsName).cString() \
656 : #EnumFlagsName \
657 ); \
658 } \
659 ZF_STATIC_REGISTER_END(EnumReg_##OuterClass##_##EnumFlagsName)
660
661ZF_NAMESPACE_GLOBAL_END
662#endif // #ifndef _ZFI_ZFEnumDeclare_inner_h_
663
ZF_NAMESPACE_GLOBAL_BEGIN
#define ZF_NAMESPACE_GLOBAL_BEGIN
begin namespace ZFFramework
Definition ZFNamespace.h:97
ZF_NAMESPACE_GLOBAL_END
#define ZF_NAMESPACE_GLOBAL_END
end namespace ZFFramework
Definition ZFNamespace.h:98
ZFObjectClassTypeFwd.h
types for ZFFramework