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