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 const zfauto &obj) { \
550 return (zfcast(_ZFP_WrapType *, obj) != zfnull); \
551 } \
552 static T_Access zfvAccess(ZF_IN const zfauto &obj) { \
553 /* ZFTAG_TRICKS: EnumReinterpretCast */ \
554 return *(typename zftTraits<T_Access>::TrNoRef *)(&(zfcast(_ZFP_WrapType *, obj)->_ZFP_ZFEnum_value)); \
555 } \
556 static zfauto zfvAccessFinish(ZF_IN const zfauto &obj) { \
557 return zfnull; \
558 } \
559 }; \
560 template<typename T_Access> \
561 zfclassNotPOD Value<T_Access, 1> { \
562 public: \
563 static zfbool zfvAccessAvailable(ZF_IN const zfauto &obj) { \
564 return obj == zfnull || (zfcast(_ZFP_WrapType *, obj) != zfnull); \
565 } \
566 static typename zftTraits<T_Access>::TrNoRef zfvAccess(ZF_IN const zfauto &obj) { \
567 if(obj == zfnull) { \
568 return zfnull; \
569 } \
570 else { \
571 _ZFP_WrapType *t = zfcast(_ZFP_WrapType *, obj); \
572 /* ZFTAG_TRICKS: EnumReinterpretCast */ \
573 return (typename zftTraits<T_Access>::TrNoRef)(&(t->_ZFP_ZFEnum_value)); \
574 } \
575 } \
576 static zfauto zfvAccessFinish(ZF_IN const zfauto &obj) { \
577 return zfnull; \
578 } \
579 }; \
580 zfoverride \
581 virtual zfbool genericValueStore(ZF_OUT zfauto &obj, ZF_IN const void *v) const { \
582 return ValueStore(obj, *(const _ZFP_PropType *)v); \
583 } \
584 zfoverride \
585 virtual void *genericAccess(ZF_IN const zfauto &obj) const { \
586 if(!Value<_ZFP_PropType>::zfvAccessAvailable(obj)) { \
587 return zfnull; \
588 } \
589 else { \
590 return _ZFP_genericAccessWrap<_ZFP_PropType>(Value<_ZFP_PropType>::zfvAccess(obj)); \
591 } \
592 } \
593 zfoverride \
594 virtual zfauto genericAccessFinish(ZF_IN const zfauto &obj, ZF_IN void *v) const { \
595 return _ZFP_genericAccessFinishWrap(Value<_ZFP_PropType>::zfvAccessFinish(obj), v, _ZFP_genericAccessFinish<_ZFP_PropType>); \
596 } \
597 zfoverride \
598 virtual ZFCoreArrayBase *genericArrayNew(void) const { \
599 return ZFCoreArray<_ZFP_PropType>().refNew(); \
600 } \
601 }; \
602 \
603 ZFOUTPUT_TYPE(Scope EnumName, {s += Scope v_##EnumName::EnumNameForValue(v);})
604
605#define _ZFP_ZFENUM_TYPEID_DEFINE(EnumName) \
606 ZFTYPEID_DEFINE_BY_STRING_CONVERTER_WITH_CUSTOM_WRAPPER(EnumName, EnumName, { \
607 if(zfstringIsEqual(src, srcLen, ZFEnumNameInvalid(), zfindexMax())) { \
608 v = (EnumName)ZFEnumInvalid(); \
609 return zftrue; \
610 } \
611 v = (EnumName)v_##EnumName::EnumValueForName( \
612 (srcLen == zfindexMax()) ? src : zfstring(src, srcLen).cString() \
613 ); \
614 if(v == ZFEnumInvalid()) { \
615 if(errorHint) { \
616 zfstringAppend(errorHint, "invalid value: \"%s\"", zfstring(src, srcLen)); \
617 } \
618 return zffalse; \
619 } \
620 return zftrue; \
621 }, { \
622 s += v_##EnumName::EnumNameForValue(v); \
623 return zftrue; \
624 }) \
625 const zfstring &v_##EnumName::zfvTypeId(void) { \
626 return ZFTypeId_##EnumName(); \
627 }
628
629
630// ============================================================
631// enum flags
632#define _ZFP_ZFENUM_FLAGS_TYPEID_DECLARE(ZFLIB_, EnumName, EnumFlagsName) \
633 ZFTYPEID_DECLARE_WITH_CUSTOM_WRAPPER(ZFLIB_, EnumFlagsName, EnumFlagsName) \
634 \
635 typedef v_##EnumName v_##EnumFlagsName;
636#define _ZFP_ZFENUM_FLAGS_TYPEID_REG(ZFLIB_, EnumName, EnumFlagsName, Scope) \
637 \
638 template<> \
639 zfclassNotPOD ZFTypeId<Scope EnumFlagsName> : zfextend ZFTypeInfo { \
640 public: \
641 typedef Scope EnumName _ZFP_PropTypeOrig; \
642 typedef Scope EnumFlagsName _ZFP_PropType; \
643 typedef Scope v_##EnumFlagsName _ZFP_WrapType; \
644 public: \
645 enum { \
646 TypeIdRegistered = 1, \
647 TypeIdSerializable = 1, \
648 }; \
649 static inline const zfstring &TypeId(void) { \
650 return Scope ZFTypeId_##EnumFlagsName(); \
651 } \
652 static inline const ZFClass *TypeIdClass(void) { \
653 return _ZFP_WrapType::ClassData(); \
654 } \
655 zfoverride \
656 virtual zfbool typeIdSerializable(void) const { \
657 return TypeIdSerializable; \
658 } \
659 zfoverride \
660 virtual const zfstring &typeId(void) const { \
661 return TypeId(); \
662 } \
663 zfoverride \
664 virtual const ZFClass *typeIdClass(void) const { \
665 return TypeIdClass(); \
666 } \
667 static zfbool ValueStore( \
668 ZF_OUT zfauto &obj \
669 , ZF_IN zfuint const &v \
670 ) { \
671 ZFCoreMutexLock(); \
672 _ZFP_WrapType *t = zfunsafe_zfAlloc(_ZFP_WrapType, v); \
673 obj.zfunsafe_assign(t); \
674 zfunsafe_zfRelease(t); \
675 ZFCoreMutexUnlock(); \
676 return zftrue; \
677 } \
678 static zfbool ValueStore( \
679 ZF_OUT zfauto &obj \
680 , ZF_IN _ZFP_PropTypeOrig const &v \
681 ) { \
682 ZFCoreMutexLock(); \
683 _ZFP_WrapType *t = zfunsafe_zfAlloc(_ZFP_WrapType, (zfuint)v); \
684 obj.zfunsafe_assign(t); \
685 zfunsafe_zfRelease(t); \
686 ZFCoreMutexUnlock(); \
687 return zftrue; \
688 } \
689 static zfbool ValueStore( \
690 ZF_OUT zfauto &obj \
691 , ZF_IN _ZFP_PropType const &v \
692 ) { \
693 ZFCoreMutexLock(); \
694 _ZFP_WrapType *t = zfunsafe_zfAlloc(_ZFP_WrapType, (zfuint)v); \
695 obj.zfunsafe_assign(t); \
696 zfunsafe_zfRelease(t); \
697 ZFCoreMutexUnlock(); \
698 return zftrue; \
699 } \
700 template<typename T_Access = _ZFP_PropType \
701 , int T_Mode = ((zftTraits<typename zftTraits<T_Access>::TrNoRef>::TrIsPtr \
702 && !zftIsSame<typename zftTraits<T_Access>::TrNoRef, _ZFP_PropType>::Value) ? 1 \
703 : ((zftTraits<typename zftTraits<T_Access>::TrNoRef>::TrIsPtr \
704 && zftIsSame<typename zftTraits<T_Access>::TrNoRef, _ZFP_PropType>::Value \
705 && !zftTraits<T_Access>::TrIsRef) ? 2 : 0)) \
706 , typename T_Fix = void \
707 > \
708 zfclassNotPOD Value { \
709 public: \
710 static zfbool zfvAccessAvailable(ZF_IN const zfauto &obj) { \
711 return (zfcast(_ZFP_WrapType *, obj) != zfnull); \
712 } \
713 static T_Access zfvAccess(ZF_IN const zfauto &obj) { \
714 /* ZFTAG_TRICKS: EnumReinterpretCast */ \
715 return *(typename zftTraits<T_Access>::TrNoRef *)(&(zfcast(_ZFP_WrapType *, obj)->_ZFP_ZFEnum_value)); \
716 } \
717 static zfauto zfvAccessFinish(ZF_IN const zfauto &obj) { \
718 return zfnull; \
719 } \
720 }; \
721 template<typename T_Access> \
722 zfclassNotPOD Value<T_Access, 1> { \
723 public: \
724 static zfbool zfvAccessAvailable(ZF_IN const zfauto &obj) { \
725 return obj == zfnull || (zfcast(_ZFP_WrapType *, obj) != zfnull); \
726 } \
727 static typename zftTraits<T_Access>::TrNoRef zfvAccess(ZF_IN const zfauto &obj) { \
728 if(obj == zfnull) { \
729 return zfnull; \
730 } \
731 else { \
732 _ZFP_WrapType *t = zfcast(_ZFP_WrapType *, obj); \
733 /* ZFTAG_TRICKS: EnumReinterpretCast */ \
734 return (typename zftTraits<T_Access>::TrNoRef)(&(t->_ZFP_ZFEnum_value)); \
735 } \
736 } \
737 static zfauto zfvAccessFinish(ZF_IN const zfauto &obj) { \
738 return zfnull; \
739 } \
740 }; \
741 zfoverride \
742 virtual zfbool genericValueStore(ZF_OUT zfauto &obj, ZF_IN const void *v) const { \
743 return ValueStore(obj, *(const _ZFP_PropType *)v); \
744 } \
745 zfoverride \
746 virtual void *genericAccess(ZF_IN const zfauto &obj) const { \
747 if(!Value<_ZFP_PropType>::zfvAccessAvailable(obj)) { \
748 return zfnull; \
749 } \
750 else { \
751 return _ZFP_genericAccessWrap<_ZFP_PropType>(Value<_ZFP_PropType>::zfvAccess(obj)); \
752 } \
753 } \
754 zfoverride \
755 virtual zfauto genericAccessFinish(ZF_IN const zfauto &obj, ZF_IN void *v) const { \
756 return _ZFP_genericAccessFinishWrap(Value<_ZFP_PropType>::zfvAccessFinish(obj), v, _ZFP_genericAccessFinish<_ZFP_PropType>); \
757 } \
758 zfoverride \
759 virtual ZFCoreArrayBase *genericArrayNew(void) const { \
760 return ZFCoreArray<_ZFP_PropType>().refNew(); \
761 } \
762 }; \
763 \
764 ZFOUTPUT_TYPE(Scope EnumFlagsName, {v.objectInfoT(s);})
765
766#define _ZFP_ZFENUM_FLAGS_TYPEID_DEFINE(EnumName, EnumFlagsName) \
767 ZFTYPEID_DEFINE_BY_STRING_CONVERTER_WITH_CUSTOM_WRAPPER(EnumFlagsName, EnumFlagsName, { \
768 zfflags flags = 0; \
769 if(!zfflagsFromStringT(flags, \
770 v_##EnumName::ClassData(), \
771 src, srcLen)) { \
772 if(errorHint) { \
773 zfstringAppend(errorHint, "invalid value: \"%s\"", zfstring(src, srcLen)); \
774 } \
775 return zffalse; \
776 } \
777 v.enumValue((zfuint)flags); \
778 return zftrue; \
779 }, { \
780 return zfflagsToStringT(s, v_##EnumName::ClassData(), (zfflags)v.enumValue()); \
781 }) \
782 ZF_STATIC_REGISTER_INIT(EnumReg_##EnumFlagsName) { \
783 ZFClassAlias(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_DESTROY(EnumReg_##EnumFlagsName) { \
789 ZFClassAliasRemove(v_##EnumName::ClassData(), v_##EnumName::ClassData()->classNamespace() \
790 ? zfstr("%s.%s", v_##EnumName::ClassData()->classNamespace(), #EnumFlagsName).cString() \
791 : #EnumFlagsName \
792 ); \
793 } \
794 ZF_STATIC_REGISTER_END(EnumReg_##EnumFlagsName)
795
796ZF_NAMESPACE_GLOBAL_END
797#endif // #ifndef _ZFI_ZFEnumDeclare_h_
798
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