Use proper Julia enums for enum wrapping

Author: barche

Project.toml

@@ -1,7 +1,7 @@
 name = "CxxWrap"
 uuid = "1f15a43c-97ca-5a2a-ae31-89f07a497df4"
 authors = ["Bart Janssens <[email protected]>"]
-version = "0.17.2"
+version = "0.17.3"
 
 [deps]
 Libdl = "8f399da3-3557-5675-b5ff-fb832c97cbdb"
@@ -11,7 +11,7 @@ libcxxwrap_julia_jll = "3eaa8342-bff7-56a5-9981-c04077f7cee7"
 [compat]
 MacroTools = "0.5.9"
 julia = "1.6"
-libcxxwrap_julia_jll = "0.14.0"
+libcxxwrap_julia_jll = "0.14.4"
 
 [extras]
 BenchmarkTools = "6e4b80f9-dd63-53aa-95a3-0cdb28fa8baf"

README.md

@@ -321,7 +321,7 @@ See the test at [`examples/inheritance.cpp`](https://github.com/JuliaInterop/lib
 
 ## Enum types
 
-Enum types are converted to strongly-typed bits types on the Julia side.
+Enum types are converted to standard Julia enums by calling the `@enum` macro in the backend.
 Consider the C++ enum:
 
 ```c++
@@ -337,15 +337,17 @@ This is registered as follows:
 ```c++
 JLCXX_MODULE define_types_module(jlcxx::Module& types)
 {
-  types.add_bits<MyEnum>("MyEnum", jlcxx::julia_type("CppEnum"));
-  types.set_const("EnumValA", EnumValA);
-  types.set_const("EnumValB", EnumValB);
+  types.add_enum<MyEnum>("MyEnum",
+    std::vector<const char*>({"EnumValA", "EnumValB"}),
+    std::vector<int>({EnumValA, EnumValB}));
 }
 ```
 
 The enum constants will be available on the Julia side as `CppTypes.EnumValA` and `CppTypes.EnumValB`, both of type `CppTypes.MyEnum`.
 Wrapped C++ functions taking a `MyEnum` will only accept a value of type `CppTypes.MyEnum` in Julia.
 
+Note that the old method (CxxWrap 0.17.2 and earlier) of adding enums using `add_bits` and `set_const` should be considered as deprecated.
+
 ## Template (parametric) types
 
 The natural Julia equivalent of a C++ template class is the parametric type.

src/CxxWrap.jl

@@ -143,7 +143,7 @@ end
 
 @inline cpp_trait_type(::Type) = IsNormalType
 
-# Enum type interface
+# Legacy enum type interface
 abstract type CppEnum <: Integer end
 (::Type{T})(x::CppEnum) where {T <: Integer} = T(reinterpret(Int32, x))::T
 (::Type{T})(x::Integer) where {T <: CppEnum} = reinterpret(T, Int32(x))
@@ -153,6 +153,41 @@ import Base: +, |
 |(a::T, b::T) where {T <: CppEnum} = reinterpret(T, convert(Int32,a) | convert(Int32,b))
 Base.promote_rule(::Type{E}, ::Type{T}) where {E <: CppEnum, T <: Integer} = Int32
 
+Base.unsafe_string(s::Ptr{CxxChar}) = unsafe_string(reinterpret(Ptr{Cchar}, s))
+
+function has_enum(wrapped_module, typesym, labels, values::Vector{BaseT}) where BaseT
+  if !Base.invokelatest(isdefined, wrapped_module, typesym)
+    return false
+  end
+  existing_type = Base.invokelatest(getproperty, wrapped_module, typesym)
+  if (existing_type isa DataType) && (supertype(existing_type) <: Enum{BaseT})
+    istces = instances(existing_type)
+    return all(BaseT.(istces) .== values) && all(Symbol.(istces) .== labels)
+  end
+  return false
+end
+
+# New enum wrapping
+function add_enum(wrapped_module, type_name, labels, values::Vector{BaseT}) where BaseT
+  typesym = Symbol(type_name)
+  labelsyms = Symbol.(unsafe_string.(labels))
+  if has_enum(wrapped_module, typesym, labelsyms, values)
+    return Base.invokelatest(getproperty, wrapped_module, typesym)
+  end
+  enum_block = Expr(:block)
+  try
+    for (label, value) in zip(labelsyms, values)
+      push!(enum_block.args, :($label = $value))
+    end
+    @eval wrapped_module @enum $(typesym)::$BaseT $enum_block
+    return Base.invokelatest(getproperty, wrapped_module, typesym)
+  catch e
+    @error "Error adding enum $type_name: " e
+    display(stacktrace())
+    return nothing
+  end
+end
+
 """
 Base class for smart pointers
 """

test/types.jl

@@ -197,6 +197,19 @@ end
 @show CppTypes.EnumClassBlue
 @test CppTypes.check_red(CppTypes.EnumClassRed)
 
+@test CppTypes.newenum_to_int(CppTypes.EnumVal1) == 0
+@test CppTypes.newenum_to_int(CppTypes.EnumVal2) == 1
+@test CppTypes.MyEnumNew(1) == CppTypes.EnumVal2
+@test CppTypes.newenum_to_int(CppTypes.MyEnumNew(1)) == 1
+@test CppTypes.newenum_from_int(0) == CppTypes.EnumVal1
+@test CppTypes.newenum_from_int(1) == CppTypes.EnumVal2
+@test CppTypes.newenum_byref(CppTypes.EnumVal1) == 0
+@test CppTypes.newenum_byref(CppTypes.EnumVal2) == 1
+
+@test typeof(Integer(CppTypes.zero)) == UInt64
+@test UInt64(CppTypes.zero) == 0
+@test UInt64(CppTypes.verybig) == typemax(UInt64)
+
 foovec = Any[CppTypes.Foo(StdWString("a"), [1.0, 2.0, 3.0]), CppTypes.Foo(StdWString("b"), [11.0, 12.0, 13.0])] # Must be Any because of the boxing
 @test CppTypes.name(foovec[1]) == "a"
 @test CppTypes.data(foovec[1]) == [1.0, 2.0, 3.0]