Your CONTRIBUTING.md states that you are looking for a third-party service to run your tests on. Travis is a continous integration service that builds every commit and even pull requests for you. You can log in using your github account and add your repository. Every time you push a new commit or someone submits a pull request, travis will build the commit and notify you if it failed. You can learn more about travis here.

This PR adds a .travis.yml so that travis knows how to run your tests. It currently tests clang 3.4 and g++ 4.8. For an example how this might look see https://travis-ci.org/UnrealQuester/better-enums/builds/68665505

You can do something like this:

// Make sure it's possible to compare string correctly
constexpr bool static_strequal_helper(const char * a, const char * b, unsigned len) {
   return (len == 0) ? true : ((*a == *b) ? static_strequal_helper(a + 1, b + 1, len - 1) : false);
}

// This is the base class using CRTP for capturing the enum' class type
// With the macro trick below, it allow auto registration even in classes of your enum, and 
// also O(1) runtime string lookup-to-value matching
template <typename T>
struct CatalogEnum
{
     typedef T ClassType;
     static std::map<const char *, int> enumToValue; 
     static void registerField(const char * name, int value) { enumToValue[name] = value; }
     static int fromStringImpl(const char * name) { return enumToValue[name]; }
};

/* This is the basic block. Because your enum derives from CatalogEnum, it has a registerField member, so it can be registered at run time (before any usage)
Also, I've provided a basic constexpr trick to match against an enum value, but not the code 
for complete lookup. 
It should not be difficult to iterate over all the RegisterEnum entries at compile time to perform O(N) lookup for a fromString method. 
Please notice that even if you enum as same value for 2 field, it'll generate two different instance of this
template, and will still work correctly, since the pointer to _get_field_name is different */ 
template <typename Class, int value, typename const char* (*enumName)()>
struct RegisterEnum
{
      // Compile-time version
      template<size_t N>
      constexpr bool match_string(const char (&a)[N]) const { return static_strequal_helper(a, (*enumName)(), N); }
      // Run-time version
      bool match_string(const char* a) const { return strcmp(a, (*enumName)()) == 0; }

      RegisterEnum() { CatalogEnum<Class>::registerField((*enumName)(), value); }
};

// Basic macro trick, it declares a static function, and uses its address as a templated differentiator
// Then the templated object constructor takes care of calling the Catalog::registerField method to register 
// the enum field
#define DeclMember(A) \
       static const char *__get##A() { return #A; } \
       RegisterEnum<ClassType, A, &__get##A> __##A;

// And some of your code:
#define ENUM(Name, type, A, B, C) \
    struct Name : CatalogEnum<Name> { enum Type : type { A, B, C }; \
       DeclMember(A) \
       DeclMember(B) \
       DeclMember(C) \
       static Type fromString(const char * name) { return (Type)fromStringImpl(name); } \
       template <size_t N>
       static constexpr fromString(const char (&a)[N]); // Should iterate through all RegisterEnum  and call match_string(a) on them  
   [your actual code here]
   }; 


// Usage:
struct A
{
      ENUM(Color, int, Blue, Red, Green); // OMG, it works!

     void exampleMethod() { Color::Type c = Color::fromString("RED"); }
};

Visual Studio 2015 added support for constexpr, but the implementation seems too buggy to get it working with Better Enums without a bunch of workarounds. Progress is in the branch vs2015-constexpr. Internal compiler errors can be seen here – search for "error" in the log.

Normal scoped enumerations are default constructible:

enum class Fubar { One, Two, Three };
auto myinstance = Fubar{};

However, your ENUM macro does not yield a struct that matches these semantics:

ENUM(Fubar, int, One, Two, Three);
auto myinstance = Fubar{}; // compiler error on MSVC12

The error I get is:

error C2248: 'Fubar' : cannot access private member declared in class 'Fubar'

These semantics are extremely important for template metaprogramming. Example test case:

template<typename T>
void DeserializeEnum(T& enumerator, T const& default_value = T{});

Internally, the method above will attempt to stream in a string and map it to a proper enumerator. If the string does not map to a valid enumerator, it will instead set it to the value of default_value. This template works just fine for true scoped enumerations, but not with your struct declared by the ENUM macro.

Thanks for Better Enums. It's incredibly useful.

Some projects wishing to include enum.h might be following the advice of enabling all available compiler warning flags (eg C++ Coding Standards by Herb Sutter and Andrei Alexandrescu, Item #1, "Compile cleanly at high warning levels"). Such projects currently need to either modify enum.h or use #pragm directives to disable warnings for that file.

This PR modifies the example and test Makefile to enable all available warning flags, along with associated code changes to comply with the resulting compiler warnings. This allows enum.h to be directly used in projects without editing or #pragma directives. The test cases pass and the examples execute without error.

See https://github.com/Neargye/magic_enum#readme.

If someone tries both Better Enums and magic_enum, and there is a reason to prefer Better Enums, please leave a comment here.

Otherwise, I think we should recommend magic_enum and move Better Enums toward deprecation.

cc @Neargye

I'm in a weird situation where, because of std::vector<bool> bit packing and a need to interface with a C API I need to make my own boolean type (the other alternative being using a non-standard container, like boost::container::vector).

Because of that C API I need a guarantee that sizeof(BETTER_ENUM(foo, char)) == sizeof(char), does Better Enums provide such a guarantee?

Using a simple test code (below) this seems to be true, but the actual implementation is somewhere so deep among the macros it's difficult to analyze.

Test code:

#include <iostream>

#include <better-enums/enum.h>

BETTER_ENUM(mbool, char, mfalse = 0, mtrue = 1)

int main() {
    std::cout << sizeof(mbool) << ' ' << sizeof(char) << std::endl;
    std::cout << std::boolalpha << (sizeof(mbool) == sizeof(char)) << std::endl;

    return 0;
}

Edit: I'm aware that enum class mbool : char would work for this use case, but Better Enums are, well, better.

Hello @aantron & co.,

Trying to compile with BETTER_ENUM in Visual Studio 2017 produces the following error:

E0028 expression must have a constant value attempt to access run-time storage

The error occurs at the assignment of _value_array.

Here are a few test cases of the compiler behavior:

    //These compile
    constexpr const int example0[] = {
      123
    };
    constexpr const MyEnum example1[] = {
      MyEnum::MyEnumValue
    };
    constexpr const int myEnumValue = MyEnum::MyEnumValue;
    constexpr const int example2[] = {
      myEnumValue
    };    

    //These array assignments all produce error E0028
    constexpr const MyEnum example3[] = {
      ((::better_enums::_eat_assign<MyEnum>)MyEnum::MyEnumValue = 0)
    };
    constexpr const MyEnum example4[] = {
      ::better_enums::_eat_assign<MyEnum>(MyEnum::MyEnumValue)
    };
    constexpr ::better_enums::_eat_assign<MyEnum> myEat(MyEnum::MyEnumValue);
    constexpr const MyEnum example5[] = {
      myEat
    };

This is in Visual Studio 2017 (v15.4.5), and happens using any of the ISO C++14, ISO C++17, and Latest Draft compilers.

I know this is intended to work (apropos the recent commit to support constexpr in VS2017). What's likely to be the issue?

❤️ , dan

Thanks for better-enum. It is awesome. However I was missing a feature to use the enum values in unordered_map. I have extended it for this use case. Please review and accept my PR.

int main()
{
	Channel channel = Channel::Red;
	
	std::unordered_map<Channel, int> u = {
		{Channel::Red, 1},
		{Channel::Blue, 3},
	};

	printf("Red %d\n", u[Channel::Red]);
	printf("Blue %d\n", u[Channel::Blue]);

	return 0;
}

1. Global stream I/O operators were sometimes not found in my code. I didn't have enough patience to detect the exact cause of this and to reproduce the error using a small example, but this is apparently due to some complex ADL rules. I moved the operators to the enum namespace scope as I think it's more appropriate, the lookup is more reliable now. It also allowed to get rid of the hacky "traits" class.
2. Using better_enums as a name for both global and nested namespaces is pretty error-prone as the nested one will be chosen by default, unless ::better_enums is specified explicitly. I concatenated the nested namespace names to produce a unique one and prevent the name clash.

Now that we have ci, you might want to add the travis status image and the appveyor status badge. This way users can immediately see that you project has automated tests and feel a little more comfortable in using it. And potential contributors can be confident that their contributions are automatically tested.

The aim of this PR is to add the possibility to compare enums with values without the need to add + to explicitly promote them to types.

For example the following code is possible:

Channel red = Channel::Red;

if (red != Channel::Blue) {
}
if (red == Channel::Red) {
}
if (Channel::_from_string("Red) != Channel::Red) {
}

See unit tests for examples.

I would like to declare a better_enum from inside a class. For example,

#include <enum.h>
class A
{
  public:
    BETTER_ENUM(Word, int, Hello, World)
    A(Word x){}
};

int main()
{
  A x(Word::Hello);
  return 0;
}

Unfortunately, this fails to compile. However, if I move the BETTER_ENUM declaration outside of the class, this works just fine. Is there another way to declare a better_enum inside a C++ class?

This git repo is very useful. However, it currently does not have a means to create a Debian package. I've created a new PullRequest to provide that capability.

PROBLEM STATEMENT: Better-enums currently does not provide a way to deliver its contents as a Debian package

SOLUTION: Added Debian packaging files

DETAILS: Follows the standard Debian Packaging rules. See https://www.debian.org/doc/manuals/debmake-doc/index.en.html

IMPACT ANALYSIS: When making future releases, debian/changelog needs to be updated

TESTING:

• Ran dpkg-buildpackage -us -uc -b
• Ran dpkc -c on resulting DEB file
• Ran lintian on resulting DEB file
• Installed resulting DEB file and compiled against it using pkg-config --cflags better-enums

Hi, this is a great work you’v made. But how to reflect from strings of enum value and name?

I have,

enum Type
{
   A = 1,
   B = 2
};

and text content

enum name : Type ; value: A

How to reflect the strings into Type with A?

I know there is no reflection in c++, but can we build that system just with help of this better-enum project?

I've added better-enums to an embedded project with limited binary size. After converting a single existing enum to BETTER_ENUM the binary size increased by ~5 kB which is not acceptable for such a project. I was able to trim this to less than 1 kB by enabling the compile-time name trimming feature so it seems that the runtime code is pulling in many dependencies or generating much code.

In such a case using the compile-time name trimming feature is definitely preferred, so I suggest to add a small note about that to the documentation for other users.