I am trying to wrap an enum class in a c++ header file for use in a cython project.
For example, how can this
enum class Color {red, green = 20, blue};
be wrapped with Cython.
4 Answers
CPP class
enum class Color {red, green = 20, blue};
Definition of type
cdef extern from "colors.h":
cdef cppclass Color:
pass
Definition of color types
cdef extern from "colors.h" namespace "Color":
cdef Color red
cdef Color green
cdef Color blue
Python implementation
cdef class PyColor:
cdef Color thisobj
def __cinit__(self, int val):
self.thisobj = <Color> val
def get_color_type(self):
cdef c = {<int>red : "red", <int> green : "green", <int> blue : "blue"}
return c[<int>self.thisobj]
1 Comment
ead
With Cython version >= 3.0 consider this answer: stackoverflow.com/a/67138945/5769463
The latest cython (3.x) has a direct support for c++ enum class, it's documented here:
https://cython.readthedocs.io/en/latest/src/userguide/wrapping_CPlusPlus.html#scoped-enumerations
Here is an example:
// cpp header
enum class State: int
{
Good,
Bad,
Unknown,
};
const char* foo(State s){
switch (s){
case State::Good:
return "Good";
case State::Bad:
return "Bad";
case State::Unknown:
return "Unknown";
}
}
Cython's side
cdef extern from "test.h":
cpdef enum class State(int):
Good,
Bad,
Unknown,
const char* foo(State s)
def py_foo(State s):
return foo(s)
call py_foo(State.Good) returns b'Good'
1 Comment
user3684792
Pretty cool. I asked this question 6 years ago, and it is nice to finally be able to accept a real native answer, though thank you to all of the other answers that provided decent workarounds
Another alternative that allows using PEP-435 Enums as mentioned in Cython docs is as follows:
foo.h
namespace foo {
enum class Bar : uint32_t {
Zero = 0,
One = 1
};
}
foo.pxd
from libc.stdint cimport uint32_t
cdef extern from "foo.h" namespace 'foo':
cdef enum _Bar 'foo::Bar':
_Zero 'foo::Bar::Zero'
_One 'foo::Bar::One'
cpdef enum Bar:
Zero = <uint32_t> _Zero
One = <uint32_t> _One
main.pyx
from foo cimport Bar
print(Bar.Zero)
print(Bar.One)
# or iterate over elements
for value in Bar:
print(value)
Comments
Here's an alternative solution that uses the ability to change the name of cython and C++ identifiers.
header.hpp
namespace foo {
enum class Bar : uint32_t {
BAZ,
QUUX
};
}
header.pxd
cdef extern from "header.hpp" namespace "foo::Bar":
cdef enum Bar "foo::Bar":
BAZ,
QUUX
main.pyx
from header cimport *
cdef void doit(Bar b):
pass
doit(BAZ) # Not Bar.BAZ, which would have been nicer.
It's effectively telling cython that there exists a namespace called "foo::Bar", and puts a C-style enum in it. To counteract the fact that Bar would otherwise become "foo::Bar::Bar" that is also given an overridden name. It does mean that Bar::BAZ is referred to as BAZ in cython, rather than Bar.BAZ which would be a more idiomatic representation of enum classes, but it seems close enough.
cdef enum Foo: [...]does not answer your needs ?ctypedefand the contents of the enum in a namespace? (I haven't tested this, but it seems it might work)ctypedef int enum_typeor possiblecdef cppclass enum_type: passto define the type. Then to define the members doingcdef extern from "somefile.hpp" namespace "enum_type": cdef enum_type BLUE(etc). I think something like that should generate the right c++ code (i.e.BLUEwill be replaced withenum_type::BLUE)