Make Vertex immutable

To match the C++ implementation. I meant to do this at the same time as the other metadata structs but missed it.

cpp/src/api/convert.cpp

@@ -2,6 +2,41 @@
 
 #include "api/exception/exception.h"
 
+namespace {
+std::optional<loot::EdgeType> convert(loot::rust::EdgeType edgeType) {
+  switch (edgeType) {
+    case loot::rust::EdgeType::Hardcoded:
+      return loot::EdgeType::hardcoded;
+    case loot::rust::EdgeType::MasterFlag:
+      return loot::EdgeType::masterFlag;
+    case loot::rust::EdgeType::Master:
+      return loot::EdgeType::master;
+    case loot::rust::EdgeType::MasterlistRequirement:
+      return loot::EdgeType::masterlistRequirement;
+    case loot::rust::EdgeType::UserRequirement:
+      return loot::EdgeType::userRequirement;
+    case loot::rust::EdgeType::MasterlistLoadAfter:
+      return loot::EdgeType::masterlistLoadAfter;
+    case loot::rust::EdgeType::UserLoadAfter:
+      return loot::EdgeType::userLoadAfter;
+    case loot::rust::EdgeType::MasterlistGroup:
+      return loot::EdgeType::masterlistGroup;
+    case loot::rust::EdgeType::UserGroup:
+      return loot::EdgeType::userGroup;
+    case loot::rust::EdgeType::RecordOverlap:
+      return loot::EdgeType::recordOverlap;
+    case loot::rust::EdgeType::AssetOverlap:
+      return loot::EdgeType::assetOverlap;
+    case loot::rust::EdgeType::TieBreak:
+      return loot::EdgeType::tieBreak;
+    case loot::rust::EdgeType::BlueprintMaster:
+      return loot::EdgeType::blueprintMaster;
+    default:
+      return std::nullopt;
+  }
+}
+}
+
 namespace loot {
 // To public types
 /////////////////////
@@ -93,42 +128,9 @@ loot::PluginMetadata convert(const loot::rust::PluginMetadata& metadata) {
   return output;
 }
 
-std::optional<loot::EdgeType> convert(uint8_t edgeType) {
-  switch (edgeType) {
-    case static_cast<uint8_t>(loot::rust::EdgeType::Hardcoded):
-      return loot::EdgeType::hardcoded;
-    case static_cast<uint8_t>(loot::rust::EdgeType::MasterFlag):
-      return loot::EdgeType::masterFlag;
-    case static_cast<uint8_t>(loot::rust::EdgeType::Master):
-      return loot::EdgeType::master;
-    case static_cast<uint8_t>(loot::rust::EdgeType::MasterlistRequirement):
-      return loot::EdgeType::masterlistRequirement;
-    case static_cast<uint8_t>(loot::rust::EdgeType::UserRequirement):
-      return loot::EdgeType::userRequirement;
-    case static_cast<uint8_t>(loot::rust::EdgeType::MasterlistLoadAfter):
-      return loot::EdgeType::masterlistLoadAfter;
-    case static_cast<uint8_t>(loot::rust::EdgeType::UserLoadAfter):
-      return loot::EdgeType::userLoadAfter;
-    case static_cast<uint8_t>(loot::rust::EdgeType::MasterlistGroup):
-      return loot::EdgeType::masterlistGroup;
-    case static_cast<uint8_t>(loot::rust::EdgeType::UserGroup):
-      return loot::EdgeType::userGroup;
-    case static_cast<uint8_t>(loot::rust::EdgeType::RecordOverlap):
-      return loot::EdgeType::recordOverlap;
-    case static_cast<uint8_t>(loot::rust::EdgeType::AssetOverlap):
-      return loot::EdgeType::assetOverlap;
-    case static_cast<uint8_t>(loot::rust::EdgeType::TieBreak):
-      return loot::EdgeType::tieBreak;
-    case static_cast<uint8_t>(loot::rust::EdgeType::BlueprintMaster):
-      return loot::EdgeType::blueprintMaster;
-    default:
-      return std::nullopt;
-  }
-}
-
 loot::Vertex convert(const loot::rust::Vertex& vertex) {
   try {
-    const auto outEdgeType = convert(vertex.out_edge_type());
+    const auto outEdgeType = ::convert(vertex.out_edge_type());
     if (outEdgeType.has_value()) {
       return loot::Vertex(convert(vertex.name()), outEdgeType.value());
     } else {

cpp/src/database.rs

@@ -220,24 +220,25 @@ impl Database {
 #[repr(transparent)]
 pub struct Vertex(libloot::Vertex);
 
-pub fn new_vertex(name: String) -> Box<Vertex> {
-    Box::new(Vertex(libloot::Vertex::new(name)))
+pub fn new_vertex(name: String, out_edge_type: EdgeType) -> Result<Box<Vertex>, VerboseError> {
+    let mut vertex = libloot::Vertex::new(name);
+
+    if out_edge_type != EdgeType::None {
+        vertex = vertex.with_out_edge_type(out_edge_type.try_into()?);
+    }
+
+    Ok(Box::new(Vertex(vertex)))
 }
 
 impl Vertex {
     // A value of 255 is used to indicate that there is no out edge.
-    pub fn out_edge_type(&self) -> Result<u8, VerboseError> {
+    pub fn out_edge_type(&self) -> Result<EdgeType, VerboseError> {
         match self.0.out_edge_type() {
-            Some(e) => Ok(EdgeType::try_from(e)?.repr),
-            None => Ok(u8::MAX),
+            Some(e) => EdgeType::try_from(e).map_err(Into::into),
+            None => Ok(EdgeType::None),
         }
     }
 
-    pub fn set_out_edge_type(&mut self, out_edge_type: EdgeType) -> Result<(), VerboseError> {
-        self.0.set_out_edge_type(out_edge_type.try_into()?);
-        Ok(())
-    }
-
     pub fn boxed_clone(&self) -> Box<Self> {
         Box::new(Self(self.0.clone()))
     }

cpp/src/lib.rs

@@ -238,6 +238,7 @@ mod ffi {
     }
 
     pub enum EdgeType {
+        None,
         Hardcoded,
         MasterFlag,
         Master,
@@ -512,13 +513,11 @@ mod ffi {
     extern "Rust" {
         type Vertex;
 
-        pub fn new_vertex(name: String) -> Box<Vertex>;
+        pub fn new_vertex(name: String, out_edge_type: EdgeType) -> Result<Box<Vertex>>;
 
         pub fn name(&self) -> &str;
 
-        pub fn out_edge_type(&self) -> Result<u8>;
-
-        pub fn set_out_edge_type(&mut self, #[into] out_edge_type: EdgeType) -> Result<()>;
+        pub fn out_edge_type(&self) -> Result<EdgeType>;
 
         pub fn boxed_clone(&self) -> Box<Vertex>;
     }