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