Julia bindings

CMakeLists.txt

@@ -62,6 +62,7 @@ openpmd_option(MPI            "Parallel, Multi-Node I/O for clusters"     AUTO)
 openpmd_option(HDF5           "HDF5 backend (.h5 files)"                  AUTO)
 openpmd_option(ADIOS1         "ADIOS1 backend (.bp files)"                AUTO)
 openpmd_option(ADIOS2         "ADIOS2 backend (.bp files)"                AUTO)
+openpmd_option(JULIA          "Enable Julia bindings"                     AUTO)
 openpmd_option(PYTHON         "Enable Python bindings"                    AUTO)
 
 option(openPMD_INSTALL               "Add installation targets"             ON)
@@ -283,6 +284,34 @@ endif()
 
 # TODO: Check if ADIOS2 is parallel when openPMD_HAVE_MPI is ON
 
+# External library: libcxxwrap-julia
+if(openPMD_USE_JULIA STREQUAL AUTO)
+    find_package(JlCxx 0.8.3)
+    if(JlCxx_FOUND)
+        set(openPMD_HAVE_JlCxx TRUE)
+    else()
+        set(openPMD_HAVE_JlCxx FALSE)
+    endif()
+    if(JULIA_FOUND)
+        set(openPMD_HAVE_JULIA TRUE)
+    else()
+        set(openPMD_HAVE_JULIA FALSE)
+    endif()
+elseif(openPMD_USE_JULIA)
+    find_package(JlCxx 0.8.3 REQUIRED)
+    set(openPMD_HAVE_JULIA TRUE)
+    set(openPMD_HAVE_JlCxx TRUE)
+else()
+    set(openPMD_HAVE_JULIA FALSE)
+    set(openPMD_HAVE_JlCxx FALSE)
+endif()
+if(openPMD_HAVE_JlCxx)
+    get_target_property(JlCxx_location JlCxx::cxxwrap_julia LOCATION)
+    get_filename_component(JlCxx_location ${JlCxx_location} DIRECTORY)
+    set(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/lib;${JlCxx_location}")
+    message(STATUS "Found JlCxx version ${JlCxx_VERSION} at ${JlCxx_location}")
+endif()
+
 # external library: pybind11 (optional)
 set(_PY_DEV_MODULE Development.Module)
 if(CMAKE_VERSION VERSION_LESS 3.18.0)
@@ -574,6 +603,33 @@ else()
     target_compile_definitions(openPMD PRIVATE openPMD_USE_VERIFY=0)
 endif()
 
+# Julia bindings
+if(openPMD_HAVE_JlCxx)
+    add_library(openPMD_jl SHARED
+        src/binding/julia/Access.cpp
+        src/binding/julia/Attributable.cpp
+        src/binding/julia/Attribute.cpp
+        src/binding/julia/BaseRecordComponent.cpp
+        src/binding/julia/Container.cpp
+        src/binding/julia/Dataset.cpp
+        src/binding/julia/Datatype.cpp
+        src/binding/julia/Format.cpp
+        src/binding/julia/Iteration.cpp
+        src/binding/julia/Mesh.cpp
+        src/binding/julia/MeshRecordComponent.cpp
+        src/binding/julia/RecordComponent.cpp
+        src/binding/julia/RecordComponent_load_chunk.cpp
+        src/binding/julia/RecordComponent_make_constant.cpp
+        src/binding/julia/RecordComponent_store_chunk.cpp
+        src/binding/julia/Series.cpp
+        src/binding/julia/UnitDimension.cpp
+        src/binding/julia/WriteIterations.cpp
+        src/binding/julia/openPMD.cpp
+        src/binding/julia/version.cpp
+    )
+    target_link_libraries(openPMD_jl PRIVATE openPMD JlCxx::cxxwrap_julia JlCxx::cxxwrap_julia_stl)
+endif()
+
 # python bindings
 if(openPMD_HAVE_PYTHON)
     add_library(openPMD.py MODULE

src/binding/julia/Access.cpp

@@ -0,0 +1,12 @@
+// IO/Access
+
+#include "defs.hpp"
+
+void define_julia_Access(jlcxx::Module &mod) {
+  mod.add_bits<Access>("Access", jlcxx::julia_type("CppEnum"));
+  jlcxx::stl::apply_stl<Access>(mod);
+
+  mod.set_const("READ_ONLY", Access::READ_ONLY);
+  mod.set_const("READ_WRITE", Access::READ_WRITE);
+  mod.set_const("CREATE", Access::CREATE);
+}

src/binding/julia/Attributable.cpp

@@ -0,0 +1,22 @@
+// Attributable
+
+#include "defs.hpp"
+
+void define_julia_Attributable(jlcxx::Module &mod) {
+  auto type = mod.add_type<Attributable>("Attributable");
+
+#define USE_TYPE(NAME, ENUM, TYPE)                                             \
+  type.method("set_attribute1_" NAME "!", &Attributable::setAttribute<TYPE>);
+  { FORALL_OPENPMD_TYPES }
+#undef USE_TYPE
+
+  type.method("get_attribute1", &Attributable::getAttribute);
+  type.method("delete_attribute!", &Attributable::deleteAttribute);
+  type.method("attributes", &Attributable::attributes);
+  type.method("num_attributes1", &Attributable::numAttributes);
+  type.method("contains_attribute", &Attributable::containsAttribute);
+  type.method("comment", &Attributable::comment);
+  type.method("set_comment!", &Attributable::setComment);
+  type.method("series_flush", static_cast<void (Attributable::*)()>(
+                                  &Attributable::seriesFlush));
+}

src/binding/julia/Attribute.cpp

@@ -0,0 +1,14 @@
+// Attribute
+
+#include "defs.hpp"
+
+void define_julia_Attribute(jlcxx::Module &mod) {
+  auto type = mod.add_type<Attribute>("Attribute");
+
+  type.method("dtype1", [](const Attribute &attr) { return attr.dtype; });
+
+#define USE_TYPE(NAME, ENUM, TYPE)                                             \
+  type.method("get1_" NAME, &Attribute::get<TYPE>);
+  { FORALL_OPENPMD_TYPES }
+#undef USE_TYPE
+}

src/binding/julia/BaseRecordComponent.cpp

@@ -0,0 +1,22 @@
+// BaseRecordComponent
+
+#include "defs.hpp"
+
+// Define supertype relationships
+namespace jlcxx {
+template <> struct SuperType<BaseRecordComponent> {
+  typedef Attributable type;
+};
+} // namespace jlcxx
+
+void define_julia_BaseRecordComponent(jlcxx::Module &mod) {
+
+  auto type = mod.add_type<BaseRecordComponent>(
+      "BaseRecordComponent", jlcxx::julia_base_type<Attributable>());
+
+  type.method("unit_SI", &BaseRecordComponent::unitSI);
+  type.method("reset_datatype1!", &BaseRecordComponent::resetDatatype);
+  type.method("get_datatype1", &BaseRecordComponent::getDatatype);
+  type.method("is_constant", &BaseRecordComponent::constant);
+  // TODO: availableChunks
+}

src/binding/julia/Container.cpp

@@ -0,0 +1,3 @@
+#include "Container.hpp"
+
+std::unique_ptr<julia_Container_type_t> julia_Container_type;

src/binding/julia/Container.hpp

@@ -0,0 +1,83 @@
+#ifndef CONTAINER_HPP
+#define CONTAINER_HPP
+
+// Container
+
+#include "defs.hpp"
+
+#include <memory>
+#include <type_traits>
+
+// Define supertype relationships
+namespace jlcxx {
+template <typename T, typename K> struct SuperType<Container<T, K>> {
+  typedef Attributable type;
+};
+} // namespace jlcxx
+
+// TODO: use std::optional instead of std::unique_ptr
+typedef jlcxx::TypeWrapper<
+    jlcxx::Parametric<jlcxx::TypeVar<1>, jlcxx::TypeVar<2>>>
+    julia_Container_type_t;
+extern std::unique_ptr<julia_Container_type_t> julia_Container_type;
+
+template <typename Eltype, typename Keytype>
+void define_julia_Container(jlcxx::Module &mod) {
+  if (!julia_Container_type)
+    julia_Container_type = std::make_unique<julia_Container_type_t>(
+        mod.add_type<jlcxx::Parametric<jlcxx::TypeVar<1>, jlcxx::TypeVar<2>>>(
+            "Container", jlcxx::julia_base_type<Attributable>()));
+
+  julia_Container_type->apply<Container<Eltype, Keytype>>([](auto type) {
+    using ContainerT = typename decltype(type)::type;
+    using key_type = typename ContainerT::key_type;
+    using mapped_type = typename ContainerT::mapped_type;
+    using size_type = typename ContainerT::size_type;
+    static_assert(std::is_same_v<Eltype, mapped_type>);
+    static_assert(std::is_same_v<Keytype, key_type>);
+
+    type.template constructor<const ContainerT &>();
+
+    type.method("empty1", &ContainerT::empty);
+    type.method("length1", &ContainerT::size);
+    type.method("empty1!", &ContainerT::clear);
+    type.method("getindex1",
+                static_cast<mapped_type &(ContainerT::*)(const key_type &)>(
+                    &ContainerT::at));
+    type.method("get1!",
+                [](ContainerT &cont, const key_type &key) -> mapped_type & {
+                  return cont[key];
+                });
+    type.method("setindex1!",
+                [](ContainerT &cont, const mapped_type &value,
+                   const key_type &key) { return cont[key] = value; });
+    type.method("count1", &ContainerT::count);
+    type.method("contains1", &ContainerT::contains);
+    type.method("delete1!",
+                static_cast<size_type (ContainerT::*)(const key_type &)>(
+                    &ContainerT::erase));
+    type.method("keys1", [](const ContainerT &cont) {
+      std::vector<key_type> res;
+      res.reserve(cont.size());
+      for (auto iter = cont.begin(); iter != cont.end(); ++iter)
+        res.push_back(iter->first);
+      return res;
+    });
+    // type.method("values1", [](const ContainerT &cont) {
+    //   std::vector<mapped_type *> res;
+    //   res.reserve(cont.size());
+    //   for (auto iter = cont.begin(); iter != cont.end(); ++iter)
+    //     res.push_back(&iter->second);
+    //   return res;
+    // });
+    // type.method("collect1", [](const ContainerT &cont) {
+    //   std::vector<std::pair<key_type, mapped_type *>> res;
+    //   res.reserve(cont.size());
+    //   for (auto iter = cont.begin(); iter != cont.end(); ++iter)
+    //     res.emplace_back(iter->first, &iter->second);
+    //   return res;
+    // });
+  });
+}
+
+#endif // #ifndef CONTAINER_HPP

src/binding/julia/Dataset.cpp

@@ -0,0 +1,23 @@
+// Dataset
+
+#include "defs.hpp"
+
+void define_julia_Dataset(jlcxx::Module &mod) {
+  auto type = mod.add_type<Dataset>("Dataset");
+
+  type.constructor<Datatype, Extent>();
+  type.constructor<Datatype, Extent, const std::string &>();
+  type.constructor<Extent>();
+
+  type.method("extend1!", &Dataset::extend);
+  type.method("set_chunk_size1!", &Dataset::setChunkSize);
+  type.method("set_compression!", &Dataset::setCompression);
+  type.method("set_custom_transform!", &Dataset::setCustomTransform);
+  type.method("extent1", [](const Dataset &d) { return d.extent; });
+  type.method("dtype1", [](const Dataset &d) { return d.dtype; });
+  type.method("rank1", [](const Dataset &d) { return d.rank; });
+  type.method("chunk_size1", [](const Dataset &d) { return d.chunkSize; });
+  type.method("compression", [](const Dataset &d) { return d.compression; });
+  type.method("transform", [](const Dataset &d) { return d.transform; });
+  type.method("options", [](const Dataset &d) { return d.options; });
+}

src/binding/julia/Datatype.cpp

@@ -0,0 +1,35 @@
+// Datatype
+
+#include "defs.hpp"
+
+void define_julia_Datatype(jlcxx::Module &mod) {
+  mod.add_bits<Datatype>("Datatype", jlcxx::julia_type("CppEnum"));
+  jlcxx::stl::apply_stl<Datatype>(mod);
+
+#define USE_TYPE(NAME, ENUM, TYPE) mod.set_const(NAME, ENUM);
+  { FORALL_OPENPMD_TYPES }
+#undef USE_TYPE
+  mod.set_const("DATATYPE", Datatype::DATATYPE);
+  mod.set_const("UNDEFINED", Datatype::UNDEFINED);
+
+  mod.set_const("openPMD_datatypes", openPMD_Datatypes);
+  // mod.method("determine_datatype", determineDatatype);
+  mod.method("to_bytes1", toBytes);
+  mod.method("to_bits1", toBits);
+  mod.method("is_vector1", isVector);
+  mod.method("is_floating_point1", (bool (*)(Datatype))isFloatingPoint);
+  mod.method("is_complex_floating_point1",
+             static_cast<bool (*)(Datatype)>(isComplexFloatingPoint));
+  mod.method("is_integer1", (std::tuple<bool, bool>(*)(Datatype))isInteger);
+  // isSameFloatingPoint
+  // isSameComplexFloatingPoint
+  // isSameInteger
+  mod.method("is_same1", isSame);
+  mod.method("basic_datatype1", basicDatatype);
+  mod.method("to_vector_type1", toVectorType);
+  mod.method("datatype_to_string1", datatypeToString);
+  mod.method("string_to_datatype1", stringToDatatype);
+  mod.method("warn_wrong_datatype1", warnWrongDtype);
+  // mod.method("==", operator==);
+  // mod.method("!=", operator!=);
+}

src/binding/julia/Format.cpp

@@ -0,0 +1,18 @@
+// IO/Format
+
+#include "defs.hpp"
+
+void define_julia_Format(jlcxx::Module &mod) {
+  mod.add_bits<Format>("Format", jlcxx::julia_type("CppEnum"));
+  jlcxx::stl::apply_stl<Format>(mod);
+
+  mod.set_const("HDF5", Format::HDF5);
+  mod.set_const("ADIOS1", Format::ADIOS1);
+  mod.set_const("ADIOS2", Format::ADIOS2);
+  mod.set_const("ADIOS2_SST", Format::ADIOS2_SST);
+  mod.set_const("ADIOS2_SSC", Format::ADIOS2_SSC);
+  mod.set_const("JSON", Format::JSON);
+  mod.set_const("DUMMY", Format::DUMMY);
+  mod.method("determine_format", determineFormat);
+  mod.method("suffix", suffix);
+}

src/binding/julia/Iteration.cpp

@@ -0,0 +1,30 @@
+// Iteration
+
+#include "defs.hpp"
+
+#include <string>
+
+// Define supertype relationships
+namespace jlcxx {
+template <> struct SuperType<Iteration> { typedef Attributable type; };
+} // namespace jlcxx
+
+void define_julia_Iteration(jlcxx::Module &mod) {
+  auto type = mod.add_type<Iteration>("Iteration",
+                                      jlcxx::julia_base_type<Attributable>());
+
+  type.method("time1", &Iteration::time<double>);
+  type.method("set_time!", &Iteration::setTime<double>);
+  type.method("dt", &Iteration::dt<double>);
+  type.method("set_dt!", &Iteration::setDt<double>);
+  type.method("time_unit_SI", &Iteration::timeUnitSI);
+  type.method("set_time_unit_SI!", &Iteration::setTimeUnitSI);
+  type.method("close1",
+              static_cast<Iteration &(Iteration::*)(bool)>(&Iteration::close));
+  type.method("open", &Iteration::open);
+  type.method("closed", &Iteration::closed);
+  type.method("closed_by_writer", &Iteration::closedByWriter);
+  type.method("meshes",
+              [](Iteration &iter) -> Container<Mesh> & { return iter.meshes; });
+  // TODO: particles
+}