Creating an enum type is simple enough in C++, simply declare one and put your values in it, for example:
However, this can get troublesome when name and scope resolution start to play a part in your program. Declaring the above enum type in the global scope of a program, then allows you to call the values in the enum directly. Example:
This fine and well, but what if we want 2 separate enum types with similar named values, but different underlying integral value, like so:
The above code won't compile as there's a redefinition of A and the other enum values. Additionally, a basic enum doesn't allow you to have a well-defined default type, nor can you easily know the number of values in the enum itself (something other languages, like C# or Java, have capabilities for).

Enter the enum class wrapper.

The Enumeration Class Objects In Omni
Throughout the library there are various enum types that are used to specify various running aspects of your code; for example, if you create an omni::sync::basic_thread you can specify to have it start later (i.e. you specifically call the omni::sync::basic_thread::start method yourself). To do this, you specify the omni::sync::thread_start_type::USER value when creating the thread.

The thread_start_type class has an underlying enum definition and various operators that allows the class to act like a wrapper type for the enum.

The enum wrapper classes that exists throughout the library allow you to define enum types that can be treated much like you treat any other basic integral data type, but with additional benefits of parsing and other type-safety checks. As well, since the wrapper classes only storage member is an enum type that is within the class, the sizeof the classes are equal to the sizeof the enum type itself, making the classes extremely lightweight.

Other functionality of the enum wrapper classes include printing of the value as a string-ized version of the enum value (e.g. omni::sync::thread_start_type::USER will print out simply USER instead of the numeric value). Additionally, each wrapper class has a COUNT and count function that both return the number of values in the enum type, as well as a DEFAULT_VALUE function that returns the default enumeration value for an enum created without being assigned to, and string parsing and printing functionality along with assignment and equality operators that allow you to use the class like a basic integer type.

Here's an example using the omni::net::protocol_type wrapper class to do various processing of the enum value:
The OMNI_ENUM macro's
It's possible to use a template and other functions of the C++ language to create a basic enum class wrapper that one could inherit from, but creating your own derived class from that has it's own problems in both memory and object complexity as well as code readability.

To over come this, the OMNI_ENUM family of macro's can be used to create an enum type of your own in an easy and efficient way. You have a few options for creating an enum type depending on what you would like your code to do.

To define a simple enum with default-incremented values, you can use the OMNI_ENUM_DEFINE macro. To define an enum with values that are assigned (e.g. enum { VALUE = 100 };), you can use the OMNI_ENUM_ASSIGNED macro. Both of these macro's must be followed by the OMNI_ENUM_END macro to signify the definition is done. If you use either of these macros, you must use the OMNI_ENUM_DEFAULT macro to define a default value for the wrapper. It can come can after the OMNI_ENUM macro but before the OMNI_ENUM_END macro. If you have elected to use the OMNI_ENUM_ASSIGNED macro to create an enum and you would like access to the parser functions, you must use the OMNI_ENUM_ASSIGNED_PARSERS macro after the OMNI_ENUM_ASSIGNED definition.

The OMNI_ENUM_DEFINE and OMNI_ENUM_ASSIGNED macro's take the same parameters. The first parameter is the name of the enum class, and the second parameter is a variadic macro parameter that can take up to 200 parameters; those parameters are the values you wish to define within your enum wrapper.

For a simple example, take the following code to create a couple of enum wrapper types with default values.
Note that if you are using the OMNI_ENUM_DEFINE macro, you do not need to include the OMNI_ENUM_ASSIGNED_PARSERS for the parsing functionality as it is included by default in the macro definition.

A few additional notes about these macros; if you are using the OMNI_ENUM_ASSIGNED macro, you do not need to actually define the values, so you could do something like this: OMNI_ENUM_ASSIGNED(my_enum, VALUE_1, VALUE_2, NONE) and they will be default incremented. As well, any values you have defined in the OMNI_ENUM_ASSIGNED macro should be additionally named in the OMNI_ENUM_ASSIGNED_PARSERS macro (like above), however, if there are values you do not wish to have the enum wrapper include as valid parsable values, simply do not include that value in the macro, for example:
This code will create an enum wrapper named my_enum and will have 3 values in it that will be default incremented and a default value of VALUE_2 however, since the NONE value was not included in the OMNI_ENUM_ASSIGNED_PARSERS if you were to try and call my_enum::parse("NONE") it would error as that was not included in the list of parsable values.

The last macro that can be utilized to create an enum wrapper class is the more simplistic OMNI_ENUM macro which can only be used to create default incremented wrappers. It takes 3 parameters, the first is the enum wrapper name, the second parameter is the default value of the wrapper, and the last parameter is like the OMNI_ENUM_DEFINE and OMNI_ENUM_ASSIGNED macros, that is, it is a variadic macro parameter that can take up to 200 parameters that will be the values of the enum wrapper.

Here is a simple example to create an enum wrapper class using the OMNI_ENUM macro:
The OMNI_ENUM macro is a simplistic macro that can be used to create simple enum wrappers in 1 line of code.

For more information on each of the macro's and how to utilize them, you can click on any of them throughout this example.

Example