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