feat(Rust): add GraphInfo support (#883)

* update GraphInfo

* refactor(rust): align info bindings with upstream usize APIs

* update

---------

Co-authored-by: Codex <codex@localhost>

Author: Sober7135

rust/include/graphar_rs.h

@@ -32,6 +32,10 @@
 #include "rust/cxx.h"
 
 namespace graphar {
+struct MaybeIndex;
+
+using SharedVertexInfo = std::shared_ptr<VertexInfo>;
+using SharedEdgeInfo = std::shared_ptr<EdgeInfo>;
 using SharedPropertyGroup = std::shared_ptr<PropertyGroup>;
 using SharedAdjacentList = std::shared_ptr<AdjacentList>;
 using ConstInfoVersion = const InfoVersion;
@@ -89,6 +93,26 @@ std::shared_ptr<graphar::EdgeInfo> create_edge_info(
     const std::string& prefix,
     std::shared_ptr<graphar::ConstInfoVersion> version);
 
+std::shared_ptr<graphar::GraphInfo> load_graph_info(const std::string& path);
+std::shared_ptr<graphar::GraphInfo> create_graph_info(
+    const std::string& name,
+    const std::vector<graphar::SharedVertexInfo>& vertex_infos,
+    const std::vector<graphar::SharedEdgeInfo>& edge_infos,
+    const rust::Vec<rust::String>& labels, const std::string& prefix,
+    std::shared_ptr<graphar::ConstInfoVersion> version);
+graphar::MaybeIndex graph_info_vertex_info_index(
+    const graphar::GraphInfo& graph_info, const std::string& type);
+graphar::MaybeIndex graph_info_edge_info_index(
+    const graphar::GraphInfo& graph_info, const std::string& src_type,
+    const std::string& edge_type, const std::string& dst_type);
+
+void vertex_info_vec_push_vertex_info(
+    std::vector<graphar::SharedVertexInfo>& vertex_infos,
+    std::shared_ptr<graphar::VertexInfo> vertex_info);
+void edge_info_vec_push_edge_info(
+    std::vector<graphar::SharedEdgeInfo>& edge_infos,
+    std::shared_ptr<graphar::EdgeInfo> edge_info);
+
 void vertex_info_save(const graphar::VertexInfo& vertex_info,
                       const std::string& path);
 std::unique_ptr<std::string> vertex_info_dump(
@@ -101,4 +125,8 @@ void push_adjacent_list(graphar::AdjacentListVector& v,
 void edge_info_save(const graphar::EdgeInfo& edge_info,
                     const std::string& path);
 std::unique_ptr<std::string> edge_info_dump(const graphar::EdgeInfo& edge_info);
+void graph_info_save(const graphar::GraphInfo& graph_info,
+                     const std::string& path);
+std::unique_ptr<std::string> graph_info_dump(
+    const graphar::GraphInfo& graph_info);
 }  // namespace graphar_rs

rust/src/ffi.rs

@@ -17,6 +17,26 @@
 
 use cxx::{ExternType, SharedPtr};
 
+use crate::ffi::graphar::MaybeIndex;
+
+#[repr(transparent)]
+#[derive(Clone)]
+pub struct SharedVertexInfo(pub(crate) SharedPtr<graphar::VertexInfo>);
+
+unsafe impl ExternType for SharedVertexInfo {
+    type Id = cxx::type_id!("graphar::SharedVertexInfo");
+    type Kind = cxx::kind::Opaque;
+}
+
+#[repr(transparent)]
+#[derive(Clone)]
+pub struct SharedEdgeInfo(pub(crate) SharedPtr<graphar::EdgeInfo>);
+
+unsafe impl ExternType for SharedEdgeInfo {
+    type Id = cxx::type_id!("graphar::SharedEdgeInfo");
+    type Kind = cxx::kind::Opaque;
+}
+
 #[repr(transparent)]
 #[derive(Clone)]
 pub struct SharedPropertyGroup(pub(crate) SharedPtr<graphar::PropertyGroup>);
@@ -348,6 +368,81 @@ pub(crate) mod graphar {
         fn edge_info_dump(edge_info: &EdgeInfo) -> Result<UniquePtr<CxxString>>;
     }
 
+    struct MaybeIndex {
+        has_value: bool,
+        index: usize,
+    }
+
+    // `GraphInfo`
+    unsafe extern "C++" {
+        type GraphInfo;
+
+        fn GetName(&self) -> &CxxString;
+        fn GetLabels(&self) -> &CxxVector<CxxString>;
+        fn GetPrefix(&self) -> &CxxString;
+        fn version(&self) -> &SharedPtr<ConstInfoVersion>;
+        fn GetVertexInfo(&self, type_: &CxxString) -> SharedPtr<VertexInfo>;
+        fn GetEdgeInfo(
+            &self,
+            src_type: &CxxString,
+            edge_type: &CxxString,
+            dst_type: &CxxString,
+        ) -> SharedPtr<EdgeInfo>;
+        fn VertexInfoNum(&self) -> usize;
+        fn EdgeInfoNum(&self) -> usize;
+        fn GetVertexInfos(&self) -> &CxxVector<SharedVertexInfo>;
+        fn GetEdgeInfos(&self) -> &CxxVector<SharedEdgeInfo>;
+
+        #[namespace = "graphar_rs"]
+        fn load_graph_info(path: &CxxString) -> Result<SharedPtr<GraphInfo>>;
+        #[namespace = "graphar_rs"]
+        fn create_graph_info(
+            name: &CxxString,
+            vertex_infos: &CxxVector<SharedVertexInfo>,
+            edge_infos: &CxxVector<SharedEdgeInfo>,
+            labels: &Vec<String>,
+            prefix: &CxxString,
+            version: SharedPtr<ConstInfoVersion>,
+        ) -> Result<SharedPtr<GraphInfo>>;
+        #[namespace = "graphar_rs"]
+        fn graph_info_save(graph_info: &GraphInfo, path: &CxxString) -> Result<()>;
+        #[namespace = "graphar_rs"]
+        fn graph_info_dump(graph_info: &GraphInfo) -> Result<UniquePtr<CxxString>>;
+        #[namespace = "graphar_rs"]
+        fn graph_info_vertex_info_index(graph_info: &GraphInfo, type_: &CxxString) -> MaybeIndex;
+        #[namespace = "graphar_rs"]
+        fn graph_info_edge_info_index(
+            graph_info: &GraphInfo,
+            src_type: &CxxString,
+            edge_type: &CxxString,
+            dst_type: &CxxString,
+        ) -> MaybeIndex;
+    }
+
+    unsafe extern "C++" {
+        #[namespace = "graphar_rs"]
+        fn vertex_info_vec_push_vertex_info(
+            vertex_infos: Pin<&mut CxxVector<SharedVertexInfo>>,
+            vertex_info: SharedPtr<VertexInfo>,
+        );
+
+        #[namespace = "graphar_rs"]
+        fn edge_info_vec_push_edge_info(
+            edge_infos: Pin<&mut CxxVector<SharedEdgeInfo>>,
+            edge_info: SharedPtr<EdgeInfo>,
+        );
+    }
+
+    unsafe extern "C++" {
+        type SharedVertexInfo = crate::ffi::SharedVertexInfo;
+    }
+    impl CxxVector<SharedVertexInfo> {}
+
+    unsafe extern "C++" {
+        type SharedEdgeInfo = crate::ffi::SharedEdgeInfo;
+    }
+    impl CxxVector<SharedEdgeInfo> {}
+
     unsafe extern "C++" {
         type SharedPropertyGroup = crate::ffi::SharedPropertyGroup;
     }
@@ -358,3 +453,13 @@ pub(crate) mod graphar {
     }
     impl CxxVector<SharedAdjacentList> {}
 }
+
+impl From<MaybeIndex> for Option<usize> {
+    fn from(value: MaybeIndex) -> Self {
+        if value.has_value {
+            Some(value.index)
+        } else {
+            None
+        }
+    }
+}

rust/src/graphar_rs.cc

@@ -17,8 +17,10 @@
  * under the License.
  */
 
-#include "graphar_rs.h"
+#include "graphar-rs/src/ffi.rs.h"
 
+#include <cstddef>
+#include <optional>
 #include <stdexcept>
 #include <utility>
 
@@ -157,6 +159,73 @@ std::shared_ptr<graphar::EdgeInfo> create_edge_info(
   return edge_info;
 }
 
+std::shared_ptr<graphar::GraphInfo> load_graph_info(const std::string& path) {
+  auto loaded = graphar::GraphInfo::Load(path);
+  if (!loaded) {
+    throw std::runtime_error(loaded.error().message());
+  }
+  return std::move(loaded).value();
+}
+
+std::shared_ptr<graphar::GraphInfo> create_graph_info(
+    const std::string& name,
+    const std::vector<graphar::SharedVertexInfo>& vertex_infos,
+    const std::vector<graphar::SharedEdgeInfo>& edge_infos,
+    const rust::Vec<rust::String>& labels, const std::string& prefix,
+    std::shared_ptr<graphar::ConstInfoVersion> version) {
+  if (name.empty()) {
+    throw std::runtime_error("CreateGraphInfo: name must not be empty");
+  }
+
+  std::vector<std::string> label_vec;
+  label_vec.reserve(labels.size());
+  for (size_t i = 0; i < labels.size(); ++i) {
+    label_vec.emplace_back(std::string(labels[i]));
+  }
+
+  auto graph_info = graphar::CreateGraphInfo(name, vertex_infos, edge_infos,
+                                             label_vec, prefix, version);
+  if (graph_info == nullptr) {
+    throw std::runtime_error("CreateGraphInfo: returned nullptr");
+  }
+  // if (!graph_info->IsValidated()) {
+  //   throw std::runtime_error("CreateGraphInfo: graph info is not validated");
+  // }
+  return graph_info;
+}
+
+static graphar::MaybeIndex optional_to_maybe_index(std::optional<size_t> opt) {
+  if (opt) {
+    return graphar::MaybeIndex{true, *opt};
+  } else {
+    return graphar::MaybeIndex{false, 0};
+  }
+}
+
+graphar::MaybeIndex graph_info_vertex_info_index(
+    const graphar::GraphInfo& graph_info, const std::string& type) {
+  return optional_to_maybe_index(graph_info.GetVertexInfoIndex(type));
+}
+
+graphar::MaybeIndex graph_info_edge_info_index(
+    const graphar::GraphInfo& graph_info, const std::string& src_type,
+    const std::string& edge_type, const std::string& dst_type) {
+  return optional_to_maybe_index(
+      graph_info.GetEdgeInfoIndex(src_type, edge_type, dst_type));
+}
+
+void vertex_info_vec_push_vertex_info(
+    std::vector<graphar::SharedVertexInfo>& vertex_infos,
+    std::shared_ptr<graphar::VertexInfo> vertex_info) {
+  vertex_infos.emplace_back(std::move(vertex_info));
+}
+
+void edge_info_vec_push_edge_info(
+    std::vector<graphar::SharedEdgeInfo>& edge_infos,
+    std::shared_ptr<graphar::EdgeInfo> edge_info) {
+  edge_infos.emplace_back(std::move(edge_info));
+}
+
 void vertex_info_save(const graphar::VertexInfo& vertex_info,
                       const std::string& path) {
   auto status = vertex_info.Save(path);
@@ -199,4 +268,21 @@ std::unique_ptr<std::string> edge_info_dump(
   }
   return std::make_unique<std::string>(std::move(r).value());
 }
+
+void graph_info_save(const graphar::GraphInfo& graph_info,
+                     const std::string& path) {
+  auto status = graph_info.Save(path);
+  if (!status.ok()) {
+    throw std::runtime_error(status.message());
+  }
+}
+
+std::unique_ptr<std::string> graph_info_dump(
+    const graphar::GraphInfo& graph_info) {
+  auto dumped = graph_info.Dump();
+  if (!dumped) {
+    throw std::runtime_error(dumped.error().message());
+  }
+  return std::make_unique<std::string>(std::move(dumped).value());
+}
 }  // namespace graphar_rs

rust/src/info/edge_info.rs

@@ -201,6 +201,8 @@ impl EdgeInfo {
 
     /// Return the number of property groups.
     ///
+    /// The upstream C++ API uses `int`; this binding returns `usize` for a
+    /// Rust-idiomatic count type.
     pub fn property_group_num(&self) -> usize {
         self.0.PropertyGroupNum()
     }