What is the correct way to bind C++ enum?

[BotellaA]

Is there a prefered or recommended way to bind an enum? I did not see anything related in my readings. Maybe I missed something.

Thanks for the help.

[KevinEady]

Hi @BotellaA ,

For clarification, are you using plain enums or class enums in C++?

[BotellaA]

I mostly use class enums but other third party libraries use plain.
Should plain and class enums be handle differently?

[KevinEady]

Hi @BotellaA ,

Should plain and class enums be handle differently?

Maybe not... What if you were to use an ObjectWrap, which holds in an instance field the value of your enum?

[KevinEady]

Hi @BotellaA ,

Also you might be able to use Externals?

enum class Color { red, green, blue };

Then, somewhere in your method you would like to create a JavaScript representation of this Color (ie, Native -> JS):

Napi::Value extColor = Napi::External<Color>::New(
    env, new Color(Color::red), [](Napi::Env env, Color* data) {
      delete data;
    });

Then, in some C++ methods that take a Color, (ie, JS -> Native):

Color* color = extColor.As<External<Color>>().Data();
printf("Color is red? %d", *color == Color::red);

[m59peacemaker]

I binded all the enums from a c++ library as an object of numbers, e.g. { red: 0, green, 1, blue: 2 }.

I created an object with the same keys as the enum, with values like the following:

Napi::Number::New(env, static_cast<double>(Color::red))

Are there cases where casting the enum value to a double will make it wrong when passing back to a c++ function expecting that enum?

[KevinEady]

@m59peacemaker , there shouldn't be any issues casting between those types. Note if you use a normal enum instead of an enum class, the compiler will do automatic typecasting for you as well. Perhaps that might ease some of your code if you use regular enums instead.

edit: I just re-read that you are using another c++ library, you probably cant change the library's class enums to regular enums.

[m59peacemaker]

@KevinEady Thanks! I'm glad to have some reassurance about my approach, as I am quite new to c++.

In case it is of interest to anyone else, here is my full approach, using a macro to avoid some repetition in the usage. Note that it requires c++20 due to the use of __VA_OPT__ in the FOR_EACH macro.

#define PARENS ()

#define EXPAND(...) EXPAND4(EXPAND4(EXPAND4(EXPAND4(__VA_ARGS__))))
#define EXPAND4(...) EXPAND3(EXPAND3(EXPAND3(EXPAND3(__VA_ARGS__))))
#define EXPAND3(...) EXPAND2(EXPAND2(EXPAND2(EXPAND2(__VA_ARGS__))))
#define EXPAND2(...) EXPAND1(EXPAND1(EXPAND1(EXPAND1(__VA_ARGS__))))
#define EXPAND1(...) __VA_ARGS__

#define FOR_EACH(macro, arg, ...) \
  __VA_OPT__(EXPAND(FOR_EACH_HELPER(macro, arg, __VA_ARGS__)))
#define FOR_EACH_HELPER(macro, arg, a1, ...) \
  macro(arg, a1) \
  __VA_OPT__(FOR_EACH_AGAIN PARENS (macro, arg, __VA_ARGS__))
#define FOR_EACH_AGAIN() FOR_EACH_HELPER

#define ENUM_TO_JS_ENUM_PROPERTY(enm, name) \
	 Napi::PropertyDescriptor::Value( \
	 	 #name, \
	 	 Napi::Number::New(env, static_cast<double>(enm::name)), \
	 	 napi_enumerable \
	 ),
	
#define ENUM_TO_JS(enm, names...) \
	 [](Napi::Env env)->Napi::Object { \
	 	 Napi::Object object = Napi::Object::New(env); \
	 	 object.DefineProperties({ \
	 	 	 FOR_EACH(ENUM_TO_JS_ENUM_PROPERTY, enm, names) \
	 	 }); \
	 	 object.Seal(); \
	 	 return object; \
	 }

Usage:

enum class Color { red, green, blue };
exports.Set(
	Napi::String::New(env, "Color"),
	ENUM_TO_JS(Color, red, green, blue)(env)
);

const { Color } = require(binding)
Color.blue // => 2

The macro offers the most concise expression, but there's no other need for it. I'm generating the c++ code anyway, so I may generate the node-addon-api calls directly. Some other ideas would be regular functions like:

// build the object from key/value pairs
Object_from_entries(
  env,
  {
    { "red", static_cast<double>(Color::red) },
    { "green", static_cast<double>(Color::green) },
    { "blue", static_cast<double>(Color::blue) }
  }
);

// build the object from key/value pairs, casting the value to `double`
Object_from_enum(
  env,
  {
    { "red", Color::red },
    { "green", Color::green },
    { "blue", Color::blue }
  }
);

[mhdawson]

Sounds like the question was answered. Closing, please let us know if you don't think that was the right thing to do.