ZFFramework
Loading...
Searching...
No Matches
ZFEnumDeclare.h
Go to the documentation of this file.
1
5
6#ifndef _ZFI_ZFEnumDeclare_h_
7#define _ZFI_ZFEnumDeclare_h_
8
9#include "ZFObjectClassTypeFwd.h"
10ZF_NAMESPACE_GLOBAL_BEGIN
11
12// ============================================================
147#define ZFENUM_BEGIN(ZFLIB_, EnumName) \
148 _ZFP_ZFENUM_BEGIN(ZFLIB_, EnumName)
149
151#define ZFENUM_VALUE(Value) \
152 _ZFP_ZFENUM_VALUE(Value)
153
154#define ZFENUM_VALUE_WITH_INIT(Value, initValue) \
155 _ZFP_ZFENUM_VALUE_WITH_INIT(Value, initValue)
156
158#define ZFENUM_SEPARATOR() \
159 _ZFP_ZFENUM_SEPARATOR(zffalse)
160
161#define ZFENUM_SEPARATOR_ALLOW_DUPLICATE_VALUE() \
162 _ZFP_ZFENUM_SEPARATOR(zftrue)
163
165#define ZFENUM_VALUE_REGISTER_WITH_NAME(Value, Name) \
166 _ZFP_ZFENUM_VALUE_REGISTER_WITH_NAME(Value, Name)
167
168#define ZFENUM_VALUE_REGISTER(Value) \
169 _ZFP_ZFENUM_VALUE_REGISTER_WITH_NAME(Value, zftext(#Value))
170
172#define ZFENUM_END(ZFLIB_, EnumName) \
173 _ZFP_ZFENUM_END(ZFLIB_, EnumName)
174
175#define ZFENUM_END_WITH_DEFAULT(ZFLIB_, EnumName, defaultEnum) \
176 _ZFP_ZFENUM_END_WITH_DEFAULT(ZFLIB_, EnumName, defaultEnum)
177
179#define ZFENUM_END_FLAGS(ZFLIB_, EnumName, EnumFlagsName) \
180 _ZFP_ZFENUM_END_FLAGS(ZFLIB_, EnumName, EnumFlagsName)
181
182#define ZFENUM_END_FLAGS_WITH_DEFAULT(ZFLIB_, EnumName, EnumFlagsName, defaultEnum, defaultEnumFlags) \
183 _ZFP_ZFENUM_END_FLAGS_WITH_DEFAULT(ZFLIB_, EnumName, EnumFlagsName, defaultEnum, defaultEnumFlags)
184
186#define ZFENUM_REG(ZFLIB_, EnumName, ...) \
187 _ZFP_ZFENUM_TYPEID_REG(ZFLIB_, EnumName, __VA_ARGS__ ::)
188
189#define ZFENUM_REG_FLAGS(ZFLIB_, EnumName, EnumFlagsName, ...) \
190 ZFCORE_POD_DECLARE_NO_COMPARER(__VA_ARGS__ :: EnumFlagsName) \
191 _ZFP_ZFENUM_TYPEID_REG(ZFLIB_, EnumName, __VA_ARGS__ ::) \
192 _ZFP_ZFENUM_FLAGS_TYPEID_REG(ZFLIB_, EnumName, EnumFlagsName, __VA_ARGS__ ::)
193
195#define ZFENUM_DEFINE(EnumName) \
196 _ZFP_ZFENUM_DEFINE(EnumName)
197
199#define ZFENUM_DEFINE_FLAGS(EnumName, EnumFlagsName) \
200 _ZFP_ZFENUM_DEFINE_FLAGS(EnumName, EnumFlagsName)
201
202// ============================================================
203#define _ZFP_ZFENUM_BEGIN(ZFLIB_, EnumName) \
204 zfclass ZFLIB_ v_##EnumName : zfextend ZFEnum { \
205 ZFOBJECT_DECLARE(v_##EnumName, ZFEnum) \
206 public: \
207 \
208 typedef enum {
209
210#define _ZFP_ZFENUM_VALUE(Value) e_##Value,
211#define _ZFP_ZFENUM_VALUE_WITH_INIT(Value, initValue) e_##Value = initValue,
212
213#define _ZFP_ZFENUM_SEPARATOR(isEnableDuplicateValue_) \
214 /* used to ensure sizeof(enum) == sizeof(zfuint) */ \
215 /* required for enum value reinterpret cast (ZFTAG_TRICKS: EnumReinterpretCast) */ \
216 _ZFP_ZFEnumMax = ((zfuint)-1), \
217 } ZFEnumType; \
218 public: \
219 \
220 static zfindex EnumCount(void) { \
221 return zfself::_ZFP_ZFEnumDataRef().enumCount(); \
222 } \
223 \
224 static zfindex EnumIndexForValue(ZF_IN zfuint value) { \
225 return zfself::_ZFP_ZFEnumDataRef().enumIndexForValue(value); \
226 } \
227 \
228 static zfuint EnumValueAt(ZF_IN zfindex index) { \
229 return zfself::_ZFP_ZFEnumDataRef().enumValueAt(index); \
230 } \
231 \
232 static const zfstring &EnumNameAt(ZF_IN zfindex index) { \
233 return zfself::_ZFP_ZFEnumDataRef().enumNameAt(index); \
234 } \
235 \
236 static zfbool EnumValueContain(ZF_IN zfuint value) { \
237 return zfself::_ZFP_ZFEnumDataRef().enumValueContain(value); \
238 } \
239 \
240 static zfuint EnumValueForName(ZF_IN const zfstring &name) { \
241 return zfself::_ZFP_ZFEnumDataRef().enumValueForName(name); \
242 } \
243 \
244 static const zfstring &EnumNameForValue(ZF_IN zfuint value) { \
245 return zfself::_ZFP_ZFEnumDataRef().enumNameForValue(value); \
246 } \
247 public: \
248 \
249 zfoverride \
250 virtual zfindex enumCount(void) { \
251 return zfself::EnumCount(); \
252 } \
253 zfoverride \
254 virtual zfuint enumDefault(void) { \
255 return zfself::EnumDefault(); \
256 } \
257 zfoverride \
258 virtual zfbool enumIsFlags(void) { \
259 return zfself::EnumIsFlags(); \
260 } \
261 zfoverride \
262 virtual zfindex enumIndexForValue(ZF_IN zfuint value) { \
263 return zfself::EnumIndexForValue(value); \
264 } \
265 zfoverride \
266 virtual zfuint enumValueAt(ZF_IN zfindex index) { \
267 return zfself::EnumValueAt(index); \
268 } \
269 zfoverride \
270 virtual const zfstring &enumNameAt(ZF_IN zfindex index) { \
271 return zfself::EnumNameAt(index); \
272 } \
273 zfoverride \
274 virtual zfbool enumValueContain(ZF_IN zfuint value) { \
275 return zfself::EnumValueContain(value); \
276 } \
277 zfoverride \
278 virtual zfuint enumValueForName(ZF_IN const zfstring &name) { \
279 return zfself::EnumValueForName(name); \
280 } \
281 zfoverride \
282 virtual const zfstring &enumNameForValue(ZF_IN zfuint value) { \
283 return zfself::EnumNameForValue(value); \
284 } \
285 \
286 public: \
287 static const _ZFP_ZFEnumData &_ZFP_ZFEnumDataRef(void) { \
288 static _ZFP_ZFEnumDataHolder d(_ZFP_ZFEnumDataInit()); \
289 return d.d; \
290 } \
291 static const _ZFP_ZFEnumData &_ZFP_ZFEnumDataInit(void) { \
292 ZFCoreMutexLocker(); \
293 _ZFP_ZFEnumData &d = _ZFP_ZFEnumDataAccess(zfself::ClassData()); \
294 if(d.needInitFlag) { \
295 d.needInitFlag = zffalse; \
296 zfbool isEnableDuplicateValue = isEnableDuplicateValue_;
297
298#define _ZFP_ZFENUM_VALUE_REGISTER_WITH_NAME(Value, Name) \
299 d.add(isEnableDuplicateValue, zfself::e_##Value, Name);
300
301#define _ZFP_ZFENUM_END(ZFLIB_, EnumName) \
302 _ZFP_ZFENUM_END_DETAIL(ZFLIB_, EnumName, zffalse, d.enumValueAt(0))
303#define _ZFP_ZFENUM_END_WITH_DEFAULT(ZFLIB_, EnumName, defaultEnum) \
304 _ZFP_ZFENUM_END_DETAIL(ZFLIB_, EnumName, zffalse, zfself::e_##defaultEnum)
305
306#define _ZFP_ZFENUM_END_FLAGS(ZFLIB_, EnumName, EnumFlagsName) \
307 _ZFP_ZFENUM_END_DETAIL(ZFLIB_, EnumName, zftrue, d.enumValueAt(0)) \
308 _ZFP_ZFENUM_FLAGS_DECLARE(ZFLIB_, EnumName, EnumFlagsName, v_##EnumName::EnumDefault())
309#define _ZFP_ZFENUM_END_FLAGS_WITH_DEFAULT(ZFLIB_, EnumName, EnumFlagsName, defaultEnum, defaultEnumFlags) \
310 _ZFP_ZFENUM_END_DETAIL(ZFLIB_, EnumName, zftrue, zfself::e_##defaultEnum) \
311 _ZFP_ZFENUM_FLAGS_DECLARE(ZFLIB_, EnumName, EnumFlagsName, defaultEnumFlags)
312
313#define _ZFP_ZFENUM_END_DETAIL(ZFLIB_, EnumName, IsFlags, defaultEnum) \
314 d.enumDefault = (zfuint)(defaultEnum); \
315 d.enumIsFlags = (IsFlags); \
316 } \
317 return d; \
318 } \
319 public: \
320 \
321 static inline zfbool EnumIsFlags(void) { \
322 return (v_##EnumName::ZFEnumType)zfself::_ZFP_ZFEnumDataRef().enumIsFlags; \
323 } \
324 \
325 static inline v_##EnumName::ZFEnumType EnumDefault(void) { \
326 return (v_##EnumName::ZFEnumType)zfself::_ZFP_ZFEnumDataRef().enumDefault; \
327 } \
328 public: \
329 \
330 zffinal zfself::ZFEnumType zfv(void) { \
331 return (zfself::ZFEnumType)this->enumValue(); \
332 } \
333 public: \
334 zfoverride \
335 virtual const zfstring &zfvTypeId(void); \
336 }; \
337 \
338 typedef v_##EnumName::ZFEnumType EnumName; \
339 _ZFP_ZFENUM_CONVERTER_DECLARE(ZFLIB_, EnumName) \
340 _ZFP_ZFENUM_TYPEID_DECLARE(ZFLIB_, EnumName)
341
342// ============================================================
343#define _ZFP_ZFENUM_DEFINE(EnumName) \
344 _ZFP_ZFENUM_CONVERTER_DEFINE(EnumName) \
345 ZFOBJECT_REGISTER(v_##EnumName) \
346 _ZFP_ZFENUM_TYPEID_DEFINE(EnumName) \
347 ZF_STATIC_REGISTER_INIT(EnumReg_##EnumName) { \
348 for(zfindex i = 0; i < v_##EnumName::EnumCount(); ++i) { \
349 ZFMethodUserRegisterDetail_0(resultMethod, { \
350 return (EnumName)v_##EnumName::EnumValueForName(invokerMethod->methodName() + 2); \
351 }, v_##EnumName::ClassData(), public, ZFMethodTypeStatic \
352 , EnumName, zfstr("e_%s", v_##EnumName::EnumNameAt(i)) \
353 ); \
354 _m.add(resultMethod); \
355 } \
356 _ZFP_ZFEnumMethodReg(_m, v_##EnumName::_ZFP_ZFEnumDataRef()); \
357 } \
358 ZF_STATIC_REGISTER_DESTROY(EnumReg_##EnumName) { \
359 for(zfindex i = 0; i < _m.count(); ++i) { \
360 ZFMethodUserUnregister(_m[i]); \
361 } \
362 } \
363 ZFCoreArray<const ZFMethod *> _m; \
364 ZF_STATIC_REGISTER_END(EnumReg_##EnumName)
365
366#define _ZFP_ZFENUM_DEFINE_FLAGS(EnumName, EnumFlagsName) \
367 _ZFP_ZFENUM_DEFINE(EnumName) \
368 _ZFP_ZFENUM_FLAGS_DEFINE(EnumName, EnumFlagsName)
369
370// ============================================================
371#define _ZFP_ZFENUM_CONVERTER_DECLARE(ZFLIB_, EnumName) \
372 \
373 extern ZFLIB_ zfbool EnumName##FromStringT( \
374 ZF_OUT zfauto &ret \
375 , ZF_IN const zfchar *src \
376 , ZF_IN_OPT zfindex srcLen = zfindexMax() \
377 , ZF_OUT_OPT zfstring *errorHint = zfnull \
378 ); \
379 \
380 extern ZFLIB_ zfbool EnumName##ToStringT( \
381 ZF_IN_OUT zfstring &ret \
382 , ZF_IN v_##EnumName *const &value \
383 , ZF_OUT_OPT zfstring *errorHint = zfnull \
384 ); \
385 \
386 inline zfstring EnumName##ToString( \
387 ZF_IN v_##EnumName *const &value \
388 , ZF_OUT_OPT zfstring *errorHint = zfnull \
389 ) { \
390 zfstring ret; \
391 EnumName##ToStringT(ret, value, errorHint); \
392 return ret; \
393 }
394#define _ZFP_ZFENUM_CONVERTER_DEFINE(EnumName) \
395 zfbool EnumName##ToStringT( \
396 ZF_IN_OUT zfstring &ret \
397 , ZF_IN v_##EnumName *const &value \
398 , ZF_OUT_OPT zfstring *errorHint /* = zfnull */ \
399 ) { \
400 ret += ((value == zfnull) ? zfstring() : value->enumName()); \
401 return zftrue; \
402 } \
403 zfbool EnumName##FromStringT( \
404 ZF_OUT zfauto &ret \
405 , ZF_IN const zfchar *src \
406 , ZF_IN_OPT zfindex srcLen /* = zfindexMax() */ \
407 , ZF_OUT_OPT zfstring *errorHint /* = zfnull */ \
408 ) { \
409 if(zfstringIsEqual(src, srcLen, ZFEnumNameInvalid(), zfindexMax())) { \
410 ret = zfobj<v_##EnumName>(ZFEnumInvalid()); \
411 return zftrue; \
412 } \
413 zfuint tmpValue = v_##EnumName::EnumValueForName( \
414 (srcLen == zfindexMax()) ? src : zfstring(src, srcLen).cString()); \
415 if(tmpValue == ZFEnumInvalid()) { \
416 zfstringAppend(errorHint, "no enum named: \"%s\"", zfstring(src, srcLen)); \
417 return zffalse; \
418 } \
419 else { \
420 ret = zfobj<v_##EnumName>(tmpValue); \
421 return zftrue; \
422 } \
423 }
424
425// ============================================================
426#define _ZFP_ZFENUM_FLAGS_DECLARE(ZFLIB_, EnumName, EnumFlagsName, defaultValue) \
427 \
428 zffinal zfclassPOD ZFLIB_ EnumFlagsName { \
429 /* this class should be POD-like to support enum value reinterpret cast (ZFTAG_TRICKS: EnumReinterpretCast) */ \
430 public: \
431 \
432 static zfuint EnumDefault(void) { \
433 return defaultValue; \
434 } \
435 public: \
436 \
437 EnumFlagsName(void) : flags(0) {} \
438 EnumFlagsName(ZF_IN zfuint const &flags) : flags(flags) {} \
439 EnumFlagsName(ZF_IN EnumName const &flags) : flags((zfuint)flags) {} \
440 EnumFlagsName(ZF_IN EnumFlagsName const &ref) : flags(ref.flags) {} \
441 public: \
442 zfuint const &enumValue(void) const {return this->flags;} \
443 void enumValue(ZF_IN zfuint const &flags) {this->flags = flags;} \
444 void enumValue(ZF_IN EnumName const &flags) {this->flags = (zfuint)flags;} \
445 public: \
446 operator zfuint const & (void) const {return this->flags;} \
447 EnumFlagsName &operator = (ZF_IN zfuint const &flags) {this->flags = flags; return *this;} \
448 EnumFlagsName &operator = (ZF_IN EnumName const &flags) {this->flags = (zfuint)flags; return *this;} \
449 EnumFlagsName &operator = (ZF_IN EnumFlagsName const &ref) {this->flags = ref.flags; return *this;} \
450 zfbool operator == (ZF_IN zfuint const &flags) const {return (this->flags == flags);} \
451 zfbool operator == (ZF_IN EnumName const &flags) const {return (this->flags == (zfuint)flags);} \
452 zfbool operator == (ZF_IN EnumFlagsName const &ref) const {return (this->flags == ref.flags);} \
453 zfbool operator != (ZF_IN zfuint const &flags) const {return (this->flags != flags);} \
454 zfbool operator != (ZF_IN EnumName const &flags) const {return (this->flags != (zfuint)flags);} \
455 zfbool operator != (ZF_IN EnumFlagsName const &ref) const {return (this->flags != ref.flags);} \
456 EnumFlagsName &operator |= (ZF_IN zfuint const &flags) {this->flags |= flags; return *this;} \
457 EnumFlagsName &operator |= (ZF_IN EnumName const &flags) {this->flags |= (zfuint)flags; return *this;} \
458 EnumFlagsName &operator |= (ZF_IN EnumFlagsName const &ref) {this->flags |= ref.flags; return *this;} \
459 EnumFlagsName &operator &= (ZF_IN zfuint const &flags) {this->flags &= flags; return *this;} \
460 EnumFlagsName &operator &= (ZF_IN EnumName const &flags) {this->flags &= (zfuint)flags; return *this;} \
461 EnumFlagsName &operator &= (ZF_IN EnumFlagsName const &ref) {this->flags &= ref.flags; return *this;} \
462 public: \
463 void objectInfoT(ZF_IN_OUT zfstring &ret) const; \
464 inline zfstring objectInfo(void) const { \
465 zfstring ret; \
466 this->objectInfoT(ret); \
467 return ret; \
468 } \
469 \
470 private: \
471 zfuint flags; \
472 }; \
473 _ZFP_ZFENUM_FLAGS_TYPEID_DECLARE(ZFLIB_, EnumName, EnumFlagsName)
474
475#define _ZFP_ZFENUM_FLAGS_DEFINE(EnumName, EnumFlagsName) \
476 void EnumFlagsName::objectInfoT(ZF_IN_OUT zfstring &ret) const { \
477 zfflagsToStringT(ret, v_##EnumName::ClassData(), (zfflags)this->enumValue()); \
478 } \
479 _ZFP_ZFENUM_FLAGS_TYPEID_DEFINE(EnumName, EnumFlagsName)
480
481
482// ============================================================
483// normal enum
484#define _ZFP_ZFENUM_TYPEID_DECLARE(ZFLIB_, EnumName) \
485 ZFTYPEID_DECLARE_WITH_CUSTOM_WRAPPER(ZFLIB_, EnumName, EnumName)
486#define _ZFP_ZFENUM_TYPEID_REG(ZFLIB_, EnumName, Scope) \
487 \
488 template<> \
489 zfclassNotPOD ZFTypeId<Scope EnumName> : zfextend ZFTypeInfo { \
490 public: \
491 typedef Scope EnumName _ZFP_PropType; \
492 typedef Scope v_##EnumName _ZFP_WrapType; \
493 public: \
494 enum { \
495 TypeIdRegistered = 1, \
496 TypeIdSerializable = 1, \
497 }; \
498 static inline const zfstring &TypeId(void) { \
499 return Scope ZFTypeId_##EnumName(); \
500 } \
501 static inline const ZFClass *TypeIdClass(void) { \
502 return _ZFP_WrapType::ClassData(); \
503 } \
504 zfoverride \
505 virtual zfbool typeIdSerializable(void) const { \
506 return TypeIdSerializable; \
507 } \
508 zfoverride \
509 virtual const zfstring &typeId(void) const { \
510 return TypeId(); \
511 } \
512 zfoverride \
513 virtual const ZFClass *typeIdClass(void) const { \
514 return TypeIdClass(); \
515 } \
516 static zfbool ValueStore( \
517 ZF_OUT zfauto &obj \
518 , ZF_IN zfuint const &v \
519 ) { \
520 ZFCoreMutexLock(); \
521 _ZFP_WrapType *t = zfunsafe_zfobjAlloc(_ZFP_WrapType, v); \
522 obj.zfunsafe_assign(t); \
523 zfunsafe_zfobjRelease(t); \
524 ZFCoreMutexUnlock(); \
525 return zftrue; \
526 } \
527 static zfbool ValueStore( \
528 ZF_OUT zfauto &obj \
529 , ZF_IN _ZFP_PropType const &v \
530 ) { \
531 ZFCoreMutexLock(); \
532 _ZFP_WrapType *t = zfunsafe_zfobjAlloc(_ZFP_WrapType, (zfuint)v); \
533 obj.zfunsafe_assign(t); \
534 zfunsafe_zfobjRelease(t); \
535 ZFCoreMutexUnlock(); \
536 return zftrue; \
537 } \
538 template<typename T_Access = _ZFP_PropType \
539 , int T_Mode = ((zftTraits<typename zftTraits<T_Access>::TrNoRef>::TrIsPtr \
540 && !zftIsSame<typename zftTraits<T_Access>::TrNoRef, _ZFP_PropType>::Value) ? 1 \
541 : ((zftTraits<typename zftTraits<T_Access>::TrNoRef>::TrIsPtr \
542 && zftIsSame<typename zftTraits<T_Access>::TrNoRef, _ZFP_PropType>::Value \
543 && !zftTraits<T_Access>::TrIsRef) ? 2 : 0)) \
544 , typename T_Fix = void \
545 > \
546 zfclassNotPOD Value { \
547 public: \
548 static zfbool zfvAccessAvailable(ZF_IN const zfauto &obj) { \
549 return (zfcast(_ZFP_WrapType *, obj) != zfnull); \
550 } \
551 static T_Access zfvAccess(ZF_IN const zfauto &obj) { \
552 /* ZFTAG_TRICKS: EnumReinterpretCast */ \
553 return *(typename zftTraits<T_Access>::TrNoRef *)(&(zfcast(_ZFP_WrapType *, obj)->_ZFP_ZFEnum_value)); \
554 } \
555 static zfauto zfvAccessFinish(ZF_IN const zfauto &obj) { \
556 return zfnull; \
557 } \
558 }; \
559 template<typename T_Access> \
560 zfclassNotPOD Value<T_Access, 1> { \
561 public: \
562 static zfbool zfvAccessAvailable(ZF_IN const zfauto &obj) { \
563 return obj == zfnull || (zfcast(_ZFP_WrapType *, obj) != zfnull); \
564 } \
565 static typename zftTraits<T_Access>::TrNoRef zfvAccess(ZF_IN const zfauto &obj) { \
566 if(obj == zfnull) { \
567 return zfnull; \
568 } \
569 else { \
570 _ZFP_WrapType *t = zfcast(_ZFP_WrapType *, obj); \
571 /* ZFTAG_TRICKS: EnumReinterpretCast */ \
572 return (typename zftTraits<T_Access>::TrNoRef)(&(t->_ZFP_ZFEnum_value)); \
573 } \
574 } \
575 static zfauto zfvAccessFinish(ZF_IN const zfauto &obj) { \
576 return zfnull; \
577 } \
578 }; \
579 zfoverride \
580 virtual zfbool genericValueStore(ZF_OUT zfauto &obj, ZF_IN const void *v) const { \
581 return ValueStore(obj, *(const _ZFP_PropType *)v); \
582 } \
583 zfoverride \
584 virtual void *genericAccess(ZF_IN const zfauto &obj) const { \
585 if(!Value<_ZFP_PropType>::zfvAccessAvailable(obj)) { \
586 return zfnull; \
587 } \
588 else { \
589 return _ZFP_genericAccessWrap<_ZFP_PropType>(Value<_ZFP_PropType>::zfvAccess(obj)); \
590 } \
591 } \
592 zfoverride \
593 virtual zfauto genericAccessFinish(ZF_IN const zfauto &obj, ZF_IN void *v) const { \
594 return _ZFP_genericAccessFinishWrap(Value<_ZFP_PropType>::zfvAccessFinish(obj), v, _ZFP_genericAccessFinish<_ZFP_PropType>); \
595 } \
596 zfoverride \
597 virtual ZFCoreArrayBase *genericArrayNew(void) const { \
598 return ZFCoreArray<_ZFP_PropType>().refNew(); \
599 } \
600 }; \
601 \
602 ZFOUTPUT_TYPE(Scope EnumName, {s += Scope v_##EnumName::EnumNameForValue(v);})
603
604#define _ZFP_ZFENUM_TYPEID_DEFINE(EnumName) \
605 ZFTYPEID_DEFINE_BY_STRING_CONVERTER_WITH_CUSTOM_WRAPPER(EnumName, EnumName, { \
606 if(zfstringIsEqual(src, srcLen, ZFEnumNameInvalid(), zfindexMax())) { \
607 v = (EnumName)ZFEnumInvalid(); \
608 return zftrue; \
609 } \
610 v = (EnumName)v_##EnumName::EnumValueForName( \
611 (srcLen == zfindexMax()) ? src : zfstring(src, srcLen).cString() \
612 ); \
613 if(v == ZFEnumInvalid()) { \
614 if(errorHint) { \
615 zfstringAppend(errorHint, "invalid value: \"%s\"", zfstring(src, srcLen)); \
616 } \
617 return zffalse; \
618 } \
619 return zftrue; \
620 }, { \
621 s += v_##EnumName::EnumNameForValue(v); \
622 return zftrue; \
623 }) \
624 const zfstring &v_##EnumName::zfvTypeId(void) { \
625 return ZFTypeId_##EnumName(); \
626 }
627
628
629// ============================================================
630// enum flags
631#define _ZFP_ZFENUM_FLAGS_TYPEID_DECLARE(ZFLIB_, EnumName, EnumFlagsName) \
632 ZFTYPEID_DECLARE_WITH_CUSTOM_WRAPPER(ZFLIB_, EnumFlagsName, EnumFlagsName) \
633 \
634 typedef v_##EnumName v_##EnumFlagsName;
635#define _ZFP_ZFENUM_FLAGS_TYPEID_REG(ZFLIB_, EnumName, EnumFlagsName, Scope) \
636 \
637 template<> \
638 zfclassNotPOD ZFTypeId<Scope EnumFlagsName> : zfextend ZFTypeInfo { \
639 public: \
640 typedef Scope EnumName _ZFP_PropTypeOrig; \
641 typedef Scope EnumFlagsName _ZFP_PropType; \
642 typedef Scope v_##EnumFlagsName _ZFP_WrapType; \
643 public: \
644 enum { \
645 TypeIdRegistered = 1, \
646 TypeIdSerializable = 1, \
647 }; \
648 static inline const zfstring &TypeId(void) { \
649 return Scope ZFTypeId_##EnumFlagsName(); \
650 } \
651 static inline const ZFClass *TypeIdClass(void) { \
652 return _ZFP_WrapType::ClassData(); \
653 } \
654 zfoverride \
655 virtual zfbool typeIdSerializable(void) const { \
656 return TypeIdSerializable; \
657 } \
658 zfoverride \
659 virtual const zfstring &typeId(void) const { \
660 return TypeId(); \
661 } \
662 zfoverride \
663 virtual const ZFClass *typeIdClass(void) const { \
664 return TypeIdClass(); \
665 } \
666 static zfbool ValueStore( \
667 ZF_OUT zfauto &obj \
668 , ZF_IN zfuint const &v \
669 ) { \
670 ZFCoreMutexLock(); \
671 _ZFP_WrapType *t = zfunsafe_zfobjAlloc(_ZFP_WrapType, v); \
672 obj.zfunsafe_assign(t); \
673 zfunsafe_zfobjRelease(t); \
674 ZFCoreMutexUnlock(); \
675 return zftrue; \
676 } \
677 static zfbool ValueStore( \
678 ZF_OUT zfauto &obj \
679 , ZF_IN _ZFP_PropTypeOrig const &v \
680 ) { \
681 ZFCoreMutexLock(); \
682 _ZFP_WrapType *t = zfunsafe_zfobjAlloc(_ZFP_WrapType, (zfuint)v); \
683 obj.zfunsafe_assign(t); \
684 zfunsafe_zfobjRelease(t); \
685 ZFCoreMutexUnlock(); \
686 return zftrue; \
687 } \
688 static zfbool ValueStore( \
689 ZF_OUT zfauto &obj \
690 , ZF_IN _ZFP_PropType const &v \
691 ) { \
692 ZFCoreMutexLock(); \
693 _ZFP_WrapType *t = zfunsafe_zfobjAlloc(_ZFP_WrapType, (zfuint)v); \
694 obj.zfunsafe_assign(t); \
695 zfunsafe_zfobjRelease(t); \
696 ZFCoreMutexUnlock(); \
697 return zftrue; \
698 } \
699 template<typename T_Access = _ZFP_PropType \
700 , int T_Mode = ((zftTraits<typename zftTraits<T_Access>::TrNoRef>::TrIsPtr \
701 && !zftIsSame<typename zftTraits<T_Access>::TrNoRef, _ZFP_PropType>::Value) ? 1 \
702 : ((zftTraits<typename zftTraits<T_Access>::TrNoRef>::TrIsPtr \
703 && zftIsSame<typename zftTraits<T_Access>::TrNoRef, _ZFP_PropType>::Value \
704 && !zftTraits<T_Access>::TrIsRef) ? 2 : 0)) \
705 , typename T_Fix = void \
706 > \
707 zfclassNotPOD Value { \
708 public: \
709 static zfbool zfvAccessAvailable(ZF_IN const zfauto &obj) { \
710 return (zfcast(_ZFP_WrapType *, obj) != zfnull); \
711 } \
712 static T_Access zfvAccess(ZF_IN const zfauto &obj) { \
713 /* ZFTAG_TRICKS: EnumReinterpretCast */ \
714 return *(typename zftTraits<T_Access>::TrNoRef *)(&(zfcast(_ZFP_WrapType *, obj)->_ZFP_ZFEnum_value)); \
715 } \
716 static zfauto zfvAccessFinish(ZF_IN const zfauto &obj) { \
717 return zfnull; \
718 } \
719 }; \
720 template<typename T_Access> \
721 zfclassNotPOD Value<T_Access, 1> { \
722 public: \
723 static zfbool zfvAccessAvailable(ZF_IN const zfauto &obj) { \
724 return obj == zfnull || (zfcast(_ZFP_WrapType *, obj) != zfnull); \
725 } \
726 static typename zftTraits<T_Access>::TrNoRef zfvAccess(ZF_IN const zfauto &obj) { \
727 if(obj == zfnull) { \
728 return zfnull; \
729 } \
730 else { \
731 _ZFP_WrapType *t = zfcast(_ZFP_WrapType *, obj); \
732 /* ZFTAG_TRICKS: EnumReinterpretCast */ \
733 return (typename zftTraits<T_Access>::TrNoRef)(&(t->_ZFP_ZFEnum_value)); \
734 } \
735 } \
736 static zfauto zfvAccessFinish(ZF_IN const zfauto &obj) { \
737 return zfnull; \
738 } \
739 }; \
740 zfoverride \
741 virtual zfbool genericValueStore(ZF_OUT zfauto &obj, ZF_IN const void *v) const { \
742 return ValueStore(obj, *(const _ZFP_PropType *)v); \
743 } \
744 zfoverride \
745 virtual void *genericAccess(ZF_IN const zfauto &obj) const { \
746 if(!Value<_ZFP_PropType>::zfvAccessAvailable(obj)) { \
747 return zfnull; \
748 } \
749 else { \
750 return _ZFP_genericAccessWrap<_ZFP_PropType>(Value<_ZFP_PropType>::zfvAccess(obj)); \
751 } \
752 } \
753 zfoverride \
754 virtual zfauto genericAccessFinish(ZF_IN const zfauto &obj, ZF_IN void *v) const { \
755 return _ZFP_genericAccessFinishWrap(Value<_ZFP_PropType>::zfvAccessFinish(obj), v, _ZFP_genericAccessFinish<_ZFP_PropType>); \
756 } \
757 zfoverride \
758 virtual ZFCoreArrayBase *genericArrayNew(void) const { \
759 return ZFCoreArray<_ZFP_PropType>().refNew(); \
760 } \
761 }; \
762 \
763 ZFOUTPUT_TYPE(Scope EnumFlagsName, {v.objectInfoT(s);})
764
765#define _ZFP_ZFENUM_FLAGS_TYPEID_DEFINE(EnumName, EnumFlagsName) \
766 ZFTYPEID_DEFINE_BY_STRING_CONVERTER_WITH_CUSTOM_WRAPPER(EnumFlagsName, EnumFlagsName, { \
767 zfflags flags = 0; \
768 if(!zfflagsFromStringT(flags, \
769 v_##EnumName::ClassData(), \
770 src, srcLen)) { \
771 if(errorHint) { \
772 zfstringAppend(errorHint, "invalid value: \"%s\"", zfstring(src, srcLen)); \
773 } \
774 return zffalse; \
775 } \
776 v.enumValue((zfuint)flags); \
777 return zftrue; \
778 }, { \
779 return zfflagsToStringT(s, v_##EnumName::ClassData(), (zfflags)v.enumValue()); \
780 }) \
781 ZF_STATIC_REGISTER_INIT(EnumReg_##EnumFlagsName) { \
782 ZFClassAlias(v_##EnumName::ClassData(), v_##EnumName::ClassData()->classNamespace() \
783 ? zfstr("%s.%s", v_##EnumName::ClassData()->classNamespace(), #EnumFlagsName).cString() \
784 : #EnumFlagsName \
785 ); \
786 } \
787 ZF_STATIC_REGISTER_DESTROY(EnumReg_##EnumFlagsName) { \
788 ZFClassAliasRemove(v_##EnumName::ClassData(), v_##EnumName::ClassData()->classNamespace() \
789 ? zfstr("%s.%s", v_##EnumName::ClassData()->classNamespace(), #EnumFlagsName).cString() \
790 : #EnumFlagsName \
791 ); \
792 } \
793 ZF_STATIC_REGISTER_END(EnumReg_##EnumFlagsName)
794
795ZF_NAMESPACE_GLOBAL_END
796#endif // #ifndef _ZFI_ZFEnumDeclare_h_
797
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