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_OUT zfauto &obj) { \
416 return (zfcast(_ZFP_WrapType *, obj) != zfnull); \
417 } \
418 static T_Access zfvAccess(ZF_IN_OUT zfauto &obj) { \
419 /* ZFTAG_TRICKS: EnumReinterpretCast */ \
420 return *(typename zftTraits<T_Access>::TrNoRef *)(&(zfcast(_ZFP_WrapType *, obj)->_ZFP_ZFEnum_value)); \
421 } \
422 static void zfvAccessFinish(ZF_IN_OUT zfauto &obj) { \
423 } \
424 }; \
425 template<typename T_Access> \
426 zfclassNotPOD Value<T_Access, 1> { \
427 public: \
428 static zfbool zfvAccessAvailable(ZF_IN_OUT zfauto &obj) { \
429 return obj == zfnull || (zfcast(_ZFP_WrapType *, obj) != zfnull); \
430 } \
431 static typename zftTraits<T_Access>::TrNoRef zfvAccess(ZF_IN_OUT 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 void zfvAccessFinish(ZF_IN_OUT zfauto &obj) { \
442 } \
443 }; \
444 zfoverride \
445 virtual zfbool genericValueStore(ZF_OUT zfauto &obj, ZF_IN const void *v) const { \
446 return ValueStore(obj, *(const _ZFP_PropType *)v); \
447 } \
448 zfoverride \
449 virtual void *genericAccess(ZF_IN_OUT zfauto &obj) const { \
450 if(!Value<_ZFP_PropType>::zfvAccessAvailable(obj)) { \
451 return zfnull; \
452 } \
453 return (void *)zfnew(_ZFP_PropType, Value<_ZFP_PropType>::zfvAccess(obj)); \
454 } \
455 zfoverride \
456 virtual void genericAccessFinish(ZF_IN_OUT zfauto &obj, ZF_IN void *v) const { \
457 zfdelete((_ZFP_PropType *)v); \
458 Value<_ZFP_PropType>::zfvAccessFinish(obj); \
459 } \
460 zfoverride \
461 virtual ZFCoreArrayBase *genericArrayNew(void) const { \
462 return zfnew(ZFCoreArray<_ZFP_PropType>); \
463 } \
464 }; \
465 \
466 ZFOUTPUT_TYPE(OuterClass::EnumName, {s += OuterClass::v_##EnumName::EnumNameForValue(v);})
467
468#define _ZFP_ZFENUM_INNER_TYPEID_DEFINE(OuterClass, EnumName) \
469 ZFTYPEID_INNER_DEFINE_BY_STRING_CONVERTER_WITH_CUSTOM_WRAPPER(OuterClass, EnumName, EnumName, { \
470 if(zfstringIsEqual(src, srcLen, ZFEnumNameInvalid(), zfindexMax())) { \
471 v = (EnumName)ZFEnumInvalid(); \
472 return zftrue; \
473 } \
474 v = (EnumName)v_##EnumName::EnumValueForName( \
475 (srcLen == zfindexMax()) ? src : zfstring(src, srcLen).cString() \
476 ); \
477 if(v == ZFEnumInvalid()) { \
478 if(errorHint) { \
479 zfstringAppend(errorHint, "invalid value: \"%s\"", zfstring(src, srcLen)); \
480 } \
481 return zffalse; \
482 } \
483 return zftrue; \
484 }, { \
485 s += v_##EnumName::EnumNameForValue(v); \
486 return zftrue; \
487 }) \
488 const zfstring &OuterClass::v_##EnumName::zfvTypeId(void) { \
489 return ZFTypeId_##EnumName(); \
490 }
491
492
493// ============================================================
494// enum flags
495#define _ZFP_ZFENUM_INNER_FLAGS_TYPEID_DECLARE(OuterClass, EnumName, EnumFlagsName) \
496 ZFTYPEID_INNER_DECLARE_WITH_CUSTOM_WRAPPER(OuterClass, EnumFlagsName, EnumFlagsName) \
497 \
498 typedef v_##EnumName v_##EnumFlagsName;
499#define _ZFP_ZFENUM_INNER_FLAGS_TYPEID_REG(OuterClass, EnumName, EnumFlagsName) \
500 \
501 template<> \
502 zfclassNotPOD ZFTypeId<OuterClass::EnumFlagsName> : zfextend ZFTypeInfo { \
503 public: \
504 typedef OuterClass::EnumName _ZFP_PropTypeOrig; \
505 typedef OuterClass::EnumFlagsName _ZFP_PropType; \
506 typedef OuterClass::v_##EnumFlagsName _ZFP_WrapType; \
507 public: \
508 enum { \
509 TypeIdRegistered = 1, \
510 TypeIdSerializable = 1, \
511 }; \
512 static inline const zfstring &TypeId(void) { \
513 return OuterClass::ZFTypeId_##EnumFlagsName(); \
514 } \
515 static inline const ZFClass *TypeIdClass(void) { \
516 return _ZFP_WrapType::ClassData(); \
517 } \
518 zfoverride \
519 virtual zfbool typeIdSerializable(void) const { \
520 return TypeIdSerializable; \
521 } \
522 zfoverride \
523 virtual const zfstring &typeId(void) const { \
524 return TypeId(); \
525 } \
526 zfoverride \
527 virtual const ZFClass *typeIdClass(void) const { \
528 return TypeIdClass(); \
529 } \
530 static zfbool ValueStore( \
531 ZF_OUT zfauto &obj \
532 , ZF_IN zfuint const &v \
533 ) { \
534 ZFCoreMutexLock(); \
535 _ZFP_WrapType *t = zfunsafe_zfAlloc(_ZFP_WrapType, v); \
536 obj.zfunsafe_assign(t); \
537 zfunsafe_zfRelease(t); \
538 ZFCoreMutexUnlock(); \
539 return zftrue; \
540 } \
541 static zfbool ValueStore( \
542 ZF_OUT zfauto &obj \
543 , ZF_IN _ZFP_PropTypeOrig const &v \
544 ) { \
545 ZFCoreMutexLock(); \
546 _ZFP_WrapType *t = zfunsafe_zfAlloc(_ZFP_WrapType, (zfuint)v); \
547 obj.zfunsafe_assign(t); \
548 zfunsafe_zfRelease(t); \
549 ZFCoreMutexUnlock(); \
550 return zftrue; \
551 } \
552 static zfbool ValueStore( \
553 ZF_OUT zfauto &obj \
554 , ZF_IN _ZFP_PropType const &v \
555 ) { \
556 ZFCoreMutexLock(); \
557 _ZFP_WrapType *t = zfunsafe_zfAlloc(_ZFP_WrapType, (zfuint)v); \
558 obj.zfunsafe_assign(t); \
559 zfunsafe_zfRelease(t); \
560 ZFCoreMutexUnlock(); \
561 return zftrue; \
562 } \
563 template<typename T_Access = _ZFP_PropType \
564 , int T_Mode = ((zftTraits<typename zftTraits<T_Access>::TrNoRef>::TrIsPtr \
565 && !zftIsSame<typename zftTraits<T_Access>::TrNoRef, _ZFP_PropType>::Value) ? 1 \
566 : ((zftTraits<typename zftTraits<T_Access>::TrNoRef>::TrIsPtr \
567 && zftIsSame<typename zftTraits<T_Access>::TrNoRef, _ZFP_PropType>::Value \
568 && !zftTraits<T_Access>::TrIsRef) ? 2 : 0)) \
569 , typename T_Fix = void \
570 > \
571 zfclassNotPOD Value { \
572 public: \
573 static zfbool zfvAccessAvailable(ZF_IN_OUT zfauto &obj) { \
574 return (zfcast(_ZFP_WrapType *, obj) != zfnull); \
575 } \
576 static T_Access zfvAccess(ZF_IN_OUT zfauto &obj) { \
577 /* ZFTAG_TRICKS: EnumReinterpretCast */ \
578 return *(typename zftTraits<T_Access>::TrNoRef *)(&(zfcast(_ZFP_WrapType *, obj)->_ZFP_ZFEnum_value)); \
579 } \
580 static void zfvAccessFinish(ZF_IN_OUT zfauto &obj) { \
581 } \
582 }; \
583 template<typename T_Access> \
584 zfclassNotPOD Value<T_Access, 1> { \
585 public: \
586 static zfbool zfvAccessAvailable(ZF_IN_OUT zfauto &obj) { \
587 return obj == zfnull || (zfcast(_ZFP_WrapType *, obj) != zfnull); \
588 } \
589 static typename zftTraits<T_Access>::TrNoRef zfvAccess(ZF_IN_OUT zfauto &obj) { \
590 if(obj == zfnull) { \
591 return zfnull; \
592 } \
593 else { \
594 _ZFP_WrapType *t = zfcast(_ZFP_WrapType *, obj); \
595 /* ZFTAG_TRICKS: EnumReinterpretCast */ \
596 return (typename zftTraits<T_Access>::TrNoRef)(&(t->_ZFP_ZFEnum_value)); \
597 } \
598 } \
599 static void zfvAccessFinish(ZF_IN_OUT zfauto &obj) { \
600 } \
601 }; \
602 zfoverride \
603 virtual zfbool genericValueStore(ZF_OUT zfauto &obj, ZF_IN const void *v) const { \
604 return ValueStore(obj, *(const _ZFP_PropType *)v); \
605 } \
606 zfoverride \
607 virtual void *genericAccess(ZF_IN_OUT zfauto &obj) const { \
608 if(!Value<_ZFP_PropType>::zfvAccessAvailable(obj)) { \
609 return zfnull; \
610 } \
611 return (void *)zfnew(_ZFP_PropType, Value<_ZFP_PropType>::zfvAccess(obj)); \
612 } \
613 zfoverride \
614 virtual void genericAccessFinish(ZF_IN_OUT zfauto &obj, ZF_IN void *v) const { \
615 zfdelete((_ZFP_PropType *)v); \
616 Value<_ZFP_PropType>::zfvAccessFinish(obj); \
617 } \
618 zfoverride \
619 virtual ZFCoreArrayBase *genericArrayNew(void) const { \
620 return zfnew(ZFCoreArray<_ZFP_PropType>); \
621 } \
622 }; \
623 \
624 ZFOUTPUT_TYPE(OuterClass::EnumFlagsName, {v.objectInfoT(s);})
625
626#define _ZFP_ZFENUM_INNER_FLAGS_TYPEID_DEFINE(OuterClass, EnumName, EnumFlagsName) \
627 ZFTYPEID_INNER_DEFINE_BY_STRING_CONVERTER_WITH_CUSTOM_WRAPPER(OuterClass, EnumFlagsName, EnumFlagsName, { \
628 zfflags flags = 0; \
629 if(!zfflagsFromStringT(flags, \
630 v_##EnumName::ClassData(), \
631 src, srcLen)) { \
632 if(errorHint) { \
633 zfstringAppend(errorHint, "invalid value: \"%s\"", zfstring(src, srcLen)); \
634 } \
635 return zffalse; \
636 } \
637 v.enumValue((zfuint)flags); \
638 return zftrue; \
639 }, { \
640 return zfflagsToStringT(s, v_##EnumName::ClassData(), (zfflags)v.enumValue()); \
641 }) \
642 ZF_STATIC_REGISTER_INIT(EnumReg_##OuterClass##_##EnumFlagsName) { \
643 ZFClassAlias(OuterClass::v_##EnumName::ClassData(), OuterClass::v_##EnumName::ClassData()->classNamespace() \
644 ? zfstr("%s.%s", OuterClass::v_##EnumName::ClassData()->classNamespace(), #EnumFlagsName).cString() \
645 : #EnumFlagsName \
646 ); \
647 } \
648 ZF_STATIC_REGISTER_DESTROY(EnumReg_##OuterClass##_##EnumFlagsName) { \
649 ZFClassAliasRemove(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_END(EnumReg_##OuterClass##_##EnumFlagsName)
655
656ZF_NAMESPACE_GLOBAL_END
657#endif // #ifndef _ZFI_ZFEnumDeclare_inner_h_
658
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