ZFEnumDeclare.h File Reference

ZFEnum declare impl. More...

#include "ZFObjectClassTypeFwd.h"

Go to the source code of this file.

Macros
#define	ZFENUM_BEGIN(ZFLIB_, EnumName)
	macros to define reflectable enum type
#define	ZFENUM_VALUE(Value)
	see ZFENUM_BEGIN
#define	ZFENUM_VALUE_WITH_INIT(Value, initValue)
	see ZFENUM_BEGIN
#define	ZFENUM_SEPARATOR()
	see ZFENUM_BEGIN
#define	ZFENUM_SEPARATOR_ALLOW_DUPLICATE_VALUE()
	see ZFENUM_BEGIN
#define	ZFENUM_VALUE_REGISTER_WITH_NAME(Value, Name)
	see ZFENUM_BEGIN
#define	ZFENUM_VALUE_REGISTER(Value)
	see ZFENUM_BEGIN
#define	ZFENUM_END(ZFLIB_, EnumName)
	see ZFENUM_BEGIN
#define	ZFENUM_END_WITH_DEFAULT(ZFLIB_, EnumName, defaultEnum)
	see ZFENUM_BEGIN
#define	ZFENUM_END_FLAGS(ZFLIB_, EnumName, EnumFlagsName)
	see ZFENUM_BEGIN
#define	ZFENUM_END_FLAGS_WITH_DEFAULT(ZFLIB_, EnumName, EnumFlagsName, defaultEnum, defaultEnumFlags)
	see ZFENUM_BEGIN
#define	ZFENUM_REG(ZFLIB_, EnumName, ...)
	see ZFENUM_BEGIN
#define	ZFENUM_REG_FLAGS(ZFLIB_, EnumName, EnumFlagsName, ...)
	see ZFENUM_BEGIN
#define	ZFENUM_DEFINE(EnumName)
	see ZFENUM_BEGIN
#define	ZFENUM_DEFINE_FLAGS(EnumName, EnumFlagsName)
	see ZFENUM_BEGIN

Detailed Description

ZFEnum declare impl.

Macro Definition Documentation

ZFENUM_BEGIN

#define ZFENUM_BEGIN	(		ZFLIB_,
			EnumName )

macros to define reflectable enum type

usage:

 // ============================================================
 // in h file
 // declare your enum
 // * must be declared inside global namespace (#ZF_NAMESPACE_GLOBAL_BEGIN)
 // * enum name must be unique, you may use custom prefix to prevent name conflict
/ **
  * you can add Doxygen docs for EnumName (as a ZFObject) here
  * /
 ZFENUM_BEGIN(ZFLIB_APP, EnumName)
    / **
      * you can add Doxygen docs for Value1 here
      * /
     ZFENUM_VALUE(Value1)
     ZFENUM_VALUE(Value2) // /< you can add Doxygen docs for Value2 here
     ZFENUM_VALUE_WITH_INIT(Value3, 33) // you can assign the value for enum item
     ZFENUM_VALUE_WITH_INIT(Value4, e_Value2) // you can assign a same value with old value
 ZFENUM_SEPARATOR()
     // you must use ZFENUM_VALUE_REGISTER to map the value and name
     ZFENUM_VALUE_REGISTER(Value1)
     ZFENUM_VALUE_REGISTER(Value2)
     // you can set a custom name by ZFENUM_VALUE_REGISTER_WITH_NAME
     ZFENUM_VALUE_REGISTER_WITH_NAME(Value3, "CustomNameValue3")
     // (here Value4 is equal to Value2)
     // when register a new name for a existing value,
     // old name would be overrided,
     // as well as the value-name map
     ZFENUM_VALUE_REGISTER_WITH_NAME(Value4, "Value4 override Value2")
 ZFENUM_END(ZFLIB_APP, EnumName)
 ZFENUM_REG(ZFLIB_APP, EnumName)
 
 // ============================================================
 // in cpp file
 // add this macro for necessary code expansion
 ZFENUM_DEFINE(EnumName)

Note

if there are more than one enum with same value, only the last registered one would be mapped once defined, you can:

• use EnumName to access the enum value and name

  zfuint value;
  const zfchar *name;
  value = v_EnumName::e_Value1;
  value = v_EnumName::EnumValueForName("Value1");
  name = v_EnumName::EnumNameForValue(value);

• use v_EnumName to store the enum value as a ZFObject

  v_EnumName *e = zfAlloc(v_EnumName());
  e->enumValue(v_EnumName::e_Value1);
  zfuint value = e->enumValue();
  const zfchar *name = e->enumName();
  zfRelease(e);

• use base class ZFEnum to achieve dynamic binding

  zfuint value;
  const zfchar *name;
   
  ZFEnum *e = zfAlloc(EnumName, v_EnumName::e_Value1);
  value = e->enumValue(); // return the value stored as EnumName
  zfRelease(e);
   
  zfauto tmp = ZFClass::classForName("EnumName")->newInstance(); // see #ZFOBJECT_REGISTER for more info
  e = tmp;
  for(zfindex i = 0; i < e->enumCount(); ++i) { // OK, list all the value and name for e, which is EnumName type
      value = e->enumValueAt(i);
      name = e->enumNameAt(i);
  }
  value = e->enumValueForName("Value1"); // OK, value from EnumName
  name = e->enumNameForValue(value); // OK, name from EnumName
  zfRelease(e);

• you can access the internal enum type by EnumName
• usually, it's highly recommended to use the internal enum type for performance:

  // pass by EnumName value, which is actually a int value
  void func1(MyEnumEnum e) {...}

ADVANCED:
ZFEnum can also be declared in different namespace, or even declared as inner class, with some limitations

declare in different namespace:

// ============================================================
// in h file
ZF_NAMESPACE_BEGIN(YourNamespace)
// declare enum as usual, inside namespace
ZFENUM_BEGIN(ZFLIB_APP, EnumName)
    ZFENUM_VALUE(Value1)
ZFENUM_SEPARATOR()
    ZFENUM_VALUE_REGISTER(Value1)
ZFENUM_END(ZFLIB_APP, EnumName)
ZF_NAMESPACE_END(YourNamespace)
 
// ZFENUM_REG must be declared in global scope, with owner namespace declared
ZFENUM_REG(ZFLIB_APP, EnumName, YourNamespace)
 
// ============================================================
// in cpp file
ZFENUM_DEFINE(EnumName)

declare as inner class:

// ============================================================
// in h file
zfclass ZFLIB_APP YourOuterClass : zfextend ZFObject {
    ZFOBJECT_DECLARE(YourOuterClass, ZFObject)
 
    // declare enum as inner class
    ZFENUM_INNER_BEGIN(YourOuterClass, EnumName)
        ZFENUM_INNER_VALUE(Value1)
    ZFENUM_INNER_SEPARATOR()
        ZFENUM_INNER_VALUE_REGISTER(Value1)
    ZFENUM_INNER_END(YourOuterClass, EnumName)
};
 
// ZFENUM_INNER_REG must be declared in global scope
ZFENUM_INNER_REG(YourOuterClass, EnumName)
 
// ============================================================
// in cpp file
ZFENUM_INNER_DEFINE(YourOuterClass, EnumName)