Use precompiled type if availableAlso remove all references to jl_current_module

Author: barche

examples/types.cpp

@@ -44,6 +44,8 @@ struct World
   ~World() { std::cout << "Destroying World with message " << msg << std::endl; }
 };
 
+struct Array {};
+
 struct NonCopyable
 {
   NonCopyable() {}
@@ -101,7 +103,7 @@ void call_testype_function()
   jlcxx::JuliaFunction("julia_test_func")(result);
 }
 
-enum CppEnum
+enum MyEnum
 {
   EnumValA,
   EnumValB
@@ -123,7 +125,7 @@ struct NullableStruct {};
 
 namespace jlcxx
 {
-  template<> struct IsBits<cpp_types::CppEnum> : std::true_type {};
+  template<> struct IsBits<cpp_types::MyEnum> : std::true_type {};
   template<typename T> struct IsSmartPointerType<cpp_types::MySmartPointer<T>> : std::true_type { };
   template<typename T> struct ConstructorPointerType<cpp_types::MySmartPointer<T>> { typedef std::shared_ptr<T> type; };
 }
@@ -143,6 +145,8 @@ JLCXX_MODULE define_julia_module(jlcxx::Module& types)
     .method("greet", &World::greet)
     .method("greet_lambda", [] (const World& w) { return w.greet(); } );
 
+  types.add_type<Array>("Array");
+
   types.method("world_factory", []()
   {
     return new World("factory hello");
@@ -230,10 +234,10 @@ JLCXX_MODULE define_julia_module(jlcxx::Module& types)
     .method("greet", &ConstPtrConstruct::greet);
 
   // Enum
-  types.add_bits<CppEnum>("CppEnum", jlcxx::julia_type("CppEnum"));
+  types.add_bits<MyEnum>("MyEnum", jlcxx::julia_type("CppEnum"));
   types.set_const("EnumValA", EnumValA);
   types.set_const("EnumValB", EnumValB);
-  types.method("enum_to_int", [] (const CppEnum e) { return static_cast<int>(e); });
+  types.method("enum_to_int", [] (const MyEnum e) { return static_cast<int>(e); });
   types.method("get_enum_b", [] () { return EnumValB; });
 
   types.add_type<Foo>("Foo")

include/jlcxx/module.hpp

@@ -17,7 +17,7 @@
 namespace jlcxx
 {
 
-/// Compatibility between 0.6 and 0.7
+/// Wrappers for creating new datatype
 JLCXX_API jl_datatype_t* new_datatype(jl_sym_t *name,
                             jl_module_t* module,
                             jl_datatype_t *super,
@@ -26,6 +26,11 @@ JLCXX_API jl_datatype_t* new_datatype(jl_sym_t *name,
                             int abstract, int mutabl,
                             int ninitialized);
 
+JLCXX_API jl_datatype_t* new_bitstype(jl_sym_t *name,
+                            jl_module_t* module,
+                            jl_datatype_t *super,
+                            jl_svec_t *parameters, const size_t nbits);
+
 /// Some helper functions
 namespace detail
 {
@@ -491,13 +496,7 @@ class JLCXX_API Module
     return module_name(m_jl_mod);
   }
 
-  void bind_constants(jl_module_t* mod)
-  {
-    for(auto& dt_pair : m_jl_constants)
-    {
-      jl_set_const(mod, jl_symbol(dt_pair.first.c_str()), dt_pair.second);
-    }
-  }
+  void bind_constants(jl_module_t* mod);
 
   jl_datatype_t* get_julia_type(const char* name)
   {
@@ -1049,13 +1048,7 @@ void Module::add_bits(const std::string& name, JLSuperT* super)
   static_assert(std::is_scalar<T>::value, "Bits types must be a scalar type");
   jl_svec_t* params = is_parametric ? parameter_list<T>()() : jl_emptysvec;
   JL_GC_PUSH1(&params);
-#if JULIA_VERSION_MAJOR == 0 && JULIA_VERSION_MINOR < 6
-  jl_datatype_t* dt = jl_new_bitstype((jl_value_t*)jl_symbol(name.c_str()), (jl_datatype_t*)super, params, 8*sizeof(T));
-#elif JULIA_VERSION_MAJOR == 0 && JULIA_VERSION_MINOR < 7
-  jl_datatype_t* dt = jl_new_primitivetype((jl_value_t*)jl_symbol(name.c_str()), (jl_datatype_t*)super, params, 8*sizeof(T));
-#else
-  jl_datatype_t* dt = jl_new_primitivetype((jl_value_t*)jl_symbol(name.c_str()), m_jl_mod, (jl_datatype_t*)super, params, 8*sizeof(T));
-#endif
+  jl_datatype_t* dt = new_bitstype(jl_symbol(name.c_str()), m_jl_mod, (jl_datatype_t*)super, params, 8*sizeof(T));
   protect_from_gc(dt);
   JL_GC_POP();
   detail::dispatch_set_julia_type<T, is_parametric>()(dt);
@@ -1085,6 +1078,7 @@ class JLCXX_API ModuleRegistry
     return m_modules.find(jmod) != m_modules.end();
   }
 
+  bool has_current_module() { return m_current_module != nullptr; }
   Module& current_module();
   void reset_current_module() { m_current_module = nullptr; }
 

include/jlcxx/smart_pointers.hpp

@@ -87,8 +87,8 @@ struct BaseMapping
 {
 };
 
-template<template<typename...> class PtrT, typename PointeeT, typename OtherPtrT>
-struct BaseMapping<PtrT<PointeeT>, OtherPtrT>
+template<template<typename...> class PtrT, typename PointeeT, typename OtherPtrT, typename... ExtraArgs>
+struct BaseMapping<PtrT<PointeeT, ExtraArgs...>, OtherPtrT>
 {
   template<bool B, typename DummyT=void>
   struct ConditionalConstructFromOther

src/functions.cpp

@@ -1,4 +1,5 @@
 #include "jlcxx/functions.hpp"
+#include "jlcxx/module.hpp"
 
 // This header provides helper functions to call Julia functions from C++
 
@@ -7,10 +8,27 @@ namespace jlcxx
 
 JuliaFunction::JuliaFunction(const std::string& name, const std::string& module_name)
 {
-  jl_module_t* mod = module_name.empty() ? jl_current_module : (jl_module_t*)jl_get_global(jl_current_module, jl_symbol(module_name.c_str()));
+  jl_module_t* mod = nullptr;
+  jl_module_t* current_mod = nullptr;
+  if(registry().has_current_module())
+  {
+    current_mod = registry().current_module().julia_module();
+  }
+  if(!module_name.empty())
+  {
+    mod = (jl_module_t*)jl_get_global(jl_main_module, jl_symbol(module_name.c_str()));
+    if(mod == nullptr && current_mod != nullptr)
+    {
+      mod = (jl_module_t *)jl_get_global(current_mod, jl_symbol(module_name.c_str()));
+    }
+    if(mod == nullptr)
+    {
+      throw std::runtime_error("Could not find module " + module_name + " when looking up function " + name);
+    }
+  }
   if(mod == nullptr)
   {
-    throw std::runtime_error("Could not find module " + module_name + " when looking up function " + module_name);
+    mod = current_mod == nullptr ? jl_main_module : current_mod;
   }
 
   m_function = jl_get_function(mod, name.c_str());

src/jlcxx.cpp

@@ -55,6 +55,14 @@ int_t Module::store_pointer(void *ptr)
   return m_pointer_array.size();
 }
 
+void Module::bind_constants(jl_module_t* mod)
+{
+  for(auto& dt_pair : m_jl_constants)
+  {
+    jl_set_const(mod, jl_symbol(dt_pair.first.c_str()), dt_pair.second);
+  }
+}
+
 Module &ModuleRegistry::create_module(jl_module_t* jmod)
 {
   if(jmod == nullptr)
@@ -91,8 +99,43 @@ JLCXX_API ModuleRegistry& registry()
 
 JLCXX_API jl_value_t* julia_type(const std::string& name, const std::string& module_name)
 {
-  const auto mods = {module_name.empty() ? nullptr : (jl_module_t*)jl_get_global(jl_current_module, jl_symbol(module_name.c_str())), jl_base_module, g_cxxwrap_module, jl_current_module, jl_current_module->parent};
-  std::string found_type;
+  std::vector<jl_module_t*> mods;
+  mods.reserve(6);
+  jl_module_t* current_mod = registry().has_current_module() ? registry().current_module().julia_module() : nullptr;
+  if(!module_name.empty())
+  {
+    jl_sym_t* modsym = jl_symbol(module_name.c_str());
+    jl_module_t* found_mod = nullptr;
+    if(current_mod != nullptr)
+    {
+      found_mod = (jl_module_t*)jl_get_global(current_mod, modsym);
+    }
+    if(found_mod == nullptr)
+    {
+      found_mod = (jl_module_t*)jl_get_global(jl_main_module, jl_symbol(module_name.c_str()));
+    }
+    if(found_mod != nullptr)
+    {
+      mods.push_back(found_mod);
+    }
+    else
+    {
+      throw std::runtime_error("Failed to find module " + module_name);
+    }
+  }
+  else
+  {
+    if (current_mod != nullptr)
+    {
+      mods.push_back(current_mod);
+    }
+    mods.push_back(jl_main_module);
+    mods.push_back(jl_base_module);
+    mods.push_back(g_cxxwrap_module);
+    mods.push_back(jl_top_module);
+  }
+
+  std::string found_type = "null";
   for(jl_module_t* mod : mods)
   {
     if(mod == nullptr)
@@ -170,6 +213,24 @@ std::wstring ConvertToCpp<std::wstring, false, false, false>::operator()(jl_valu
   return std::wstring(arr.data(), arr.size());
 }
 
+static constexpr const char* dt_prefix = "__cxxwrap_dt_";
+
+jl_datatype_t* existing_datatype(jl_module_t* mod, jl_sym_t* name)
+{
+  const std::string prefixed_name = dt_prefix + symbol_name(name);
+  jl_value_t* found_dt = jl_get_global(mod, jl_symbol(prefixed_name.c_str()));
+  if(found_dt == nullptr || !jl_is_datatype(found_dt))
+  {
+    return nullptr;
+  }
+  return (jl_datatype_t*)found_dt;
+}
+
+void set_internal_constant(jl_module_t* mod, jl_datatype_t* dt, const std::string& prefixed_name)
+{
+  jl_set_const(mod, jl_symbol(prefixed_name.c_str()), (jl_value_t*)dt);
+}
+
 JLCXX_API jl_datatype_t* new_datatype(jl_sym_t *name,
                             jl_module_t* module,
                             jl_datatype_t *super,
@@ -182,11 +243,32 @@ JLCXX_API jl_datatype_t* new_datatype(jl_sym_t *name,
   {
     throw std::runtime_error("null module when creating type");
   }
-#if JULIA_VERSION_MAJOR == 0 && JULIA_VERSION_MINOR < 7
-  return jl_new_datatype(name, super, parameters, fnames, ftypes, abstract, mutabl, ninitialized);
-#else
-  return jl_new_datatype(name, module, super, parameters, fnames, ftypes, abstract, mutabl, ninitialized);
-#endif
+  jl_datatype_t* dt = existing_datatype(module, name);
+  if(dt != nullptr)
+  {
+    return dt;
+  }
+
+  dt = jl_new_datatype(name, module, super, parameters, fnames, ftypes, abstract, mutabl, ninitialized);
+  set_internal_constant(module, dt, dt_prefix + symbol_name(name));
+  return dt;
+}
+
+JLCXX_API jl_datatype_t* new_bitstype(jl_sym_t *name,
+                            jl_module_t* module,
+                            jl_datatype_t *super,
+                            jl_svec_t *parameters, const size_t nbits)
+{
+  assert(module != nullptr);
+  jl_datatype_t* dt = existing_datatype(module, name);
+  if(dt != nullptr)
+  {
+    return dt;
+  }
+
+  dt = jl_new_primitivetype((jl_value_t*)name, module, super, parameters, nbits);
+  set_internal_constant(module, dt, dt_prefix + symbol_name(name));
+  return dt;
 }
 
 }