Rewrote project in Rust

src/builder/cpp_file_builder.rs

@@ -0,0 +1,40 @@
+use std::io::{Result, Write};
+
+use super::FileBuilder;
+
+pub struct CppBuilder;
+
+impl FileBuilder for CppBuilder {
+    fn extension(&mut self) -> &str {
+        "hpp"
+    }
+
+    fn write_top_level(&mut self, output: &mut dyn Write) -> Result<()> {
+        write!(output, "#pragma once\n\n")?;
+        write!(output, "#include <cstddef>\n\n")?;
+
+        Ok(())
+    }
+
+    fn write_namespace(&mut self, output: &mut dyn Write, name: &str) -> Result<()> {
+        write!(output, "namespace {} {{\n", name)?;
+
+        Ok(())
+    }
+
+    fn write_variable(&mut self, output: &mut dyn Write, name: &str, value: usize) -> Result<()> {
+        write!(
+            output,
+            "    constexpr std::ptrdiff_t {} = {:#X};\n",
+            name, value
+        )?;
+
+        Ok(())
+    }
+
+    fn write_closure(&mut self, output: &mut dyn Write, eof: bool) -> Result<()> {
+        write!(output, "{}", if eof { "}" } else { "}\n\n" })?;
+
+        Ok(())
+    }
+}

src/builder/csharp_file_builder.rs

@@ -0,0 +1,33 @@
+use std::io::{Result, Write};
+
+use super::FileBuilder;
+
+pub struct CSharpBuilder;
+
+impl FileBuilder for CSharpBuilder {
+    fn extension(&mut self) -> &str {
+        "cs"
+    }
+
+    fn write_top_level(&mut self, _output: &mut dyn Write) -> Result<()> {
+        Ok(())
+    }
+
+    fn write_namespace(&mut self, output: &mut dyn Write, name: &str) -> Result<()> {
+        write!(output, "public static class {} {{\n", name)?;
+
+        Ok(())
+    }
+
+    fn write_variable(&mut self, output: &mut dyn Write, name: &str, value: usize) -> Result<()> {
+        write!(output, "    public const nint {} = {:#X};\n", name, value)?;
+
+        Ok(())
+    }
+
+    fn write_closure(&mut self, output: &mut dyn Write, eof: bool) -> Result<()> {
+        write!(output, "{}", if eof { "}" } else { "}\n\n" })?;
+
+        Ok(())
+    }
+}

src/builder/file_builder.rs

@@ -0,0 +1,9 @@
+use std::io::{Result, Write};
+
+pub trait FileBuilder {
+    fn extension(&mut self) -> &str;
+    fn write_top_level(&mut self, output: &mut dyn Write) -> Result<()>;
+    fn write_namespace(&mut self, output: &mut dyn Write, name: &str) -> Result<()>;
+    fn write_variable(&mut self, output: &mut dyn Write, name: &str, value: usize) -> Result<()>;
+    fn write_closure(&mut self, output: &mut dyn Write, eof: bool) -> Result<()>;
+}

src/builder/json_file_builder.rs

@@ -0,0 +1,56 @@
+use std::io::{Result, Write};
+
+use serde_json::{json, Value};
+
+use super::FileBuilder;
+
+#[derive(Default)]
+pub struct JsonFileBuilder {
+    json: Value,
+    namespace: String,
+}
+
+impl FileBuilder for JsonFileBuilder {
+    fn extension(&mut self) -> &str {
+        "json"
+    }
+
+    fn write_top_level(&mut self, _output: &mut dyn Write) -> Result<()> {
+        Ok(())
+    }
+
+    fn write_namespace(&mut self, _output: &mut dyn Write, name: &str) -> Result<()> {
+        self.namespace = name.to_string();
+
+        Ok(())
+    }
+
+    fn write_variable(&mut self, _output: &mut dyn Write, name: &str, value: usize) -> Result<()> {
+        if let Some(json_as_map) = self.json.as_object_mut() {
+            let namespace_entry = json_as_map
+                .entry(self.namespace.clone())
+                .or_insert_with(|| json!({}));
+
+            if let Some(namespace_object) = namespace_entry.as_object_mut() {
+                namespace_object.insert(name.to_string(), json!(value));
+            }
+        }
+
+        Ok(())
+    }
+
+    fn write_closure(&mut self, output: &mut dyn Write, eof: bool) -> Result<()> {
+        if eof {
+            write!(
+                output,
+                "{}",
+                serde_json::to_string_pretty(&self.json).unwrap()
+            )
+            .unwrap();
+
+            self.json = json!({});
+        }
+
+        Ok(())
+    }
+}

src/builder/mod.rs

@@ -0,0 +1,71 @@
+pub use std::io::{Result, Write};
+
+pub use cpp_file_builder::CppBuilder;
+pub use csharp_file_builder::CSharpBuilder;
+pub use file_builder::FileBuilder;
+pub use json_file_builder::JsonFileBuilder;
+pub use rust_file_builder::RustFileBuilder;
+
+pub mod cpp_file_builder;
+pub mod csharp_file_builder;
+pub mod file_builder;
+pub mod json_file_builder;
+pub mod rust_file_builder;
+
+pub enum FileBuilderEnum {
+    CppBuilder(CppBuilder),
+    CSharpBuilder(CSharpBuilder),
+    JsonFileBuilder(JsonFileBuilder),
+    RustFileBuilder(RustFileBuilder),
+}
+
+impl FileBuilder for FileBuilderEnum {
+    fn extension(&mut self) -> &str {
+        match self {
+            FileBuilderEnum::CppBuilder(builder) => builder.extension(),
+            FileBuilderEnum::CSharpBuilder(builder) => builder.extension(),
+            FileBuilderEnum::JsonFileBuilder(builder) => builder.extension(),
+            FileBuilderEnum::RustFileBuilder(builder) => builder.extension(),
+        }
+    }
+
+    fn write_top_level(&mut self, output: &mut dyn Write) -> Result<()> {
+        match self {
+            FileBuilderEnum::CppBuilder(builder) => builder.write_top_level(output),
+            FileBuilderEnum::CSharpBuilder(builder) => builder.write_top_level(output),
+            FileBuilderEnum::JsonFileBuilder(builder) => builder.write_top_level(output),
+            FileBuilderEnum::RustFileBuilder(builder) => builder.write_top_level(output),
+        }
+    }
+
+    fn write_namespace(&mut self, output: &mut dyn Write, name: &str) -> Result<()> {
+        match self {
+            FileBuilderEnum::CppBuilder(builder) => builder.write_namespace(output, name),
+            FileBuilderEnum::CSharpBuilder(builder) => builder.write_namespace(output, name),
+            FileBuilderEnum::JsonFileBuilder(builder) => builder.write_namespace(output, name),
+            FileBuilderEnum::RustFileBuilder(builder) => builder.write_namespace(output, name),
+        }
+    }
+
+    fn write_variable(&mut self, output: &mut dyn Write, name: &str, value: usize) -> Result<()> {
+        match self {
+            FileBuilderEnum::CppBuilder(builder) => builder.write_variable(output, name, value),
+            FileBuilderEnum::CSharpBuilder(builder) => builder.write_variable(output, name, value),
+            FileBuilderEnum::JsonFileBuilder(builder) => {
+                builder.write_variable(output, name, value)
+            }
+            FileBuilderEnum::RustFileBuilder(builder) => {
+                builder.write_variable(output, name, value)
+            }
+        }
+    }
+
+    fn write_closure(&mut self, output: &mut dyn Write, eof: bool) -> Result<()> {
+        match self {
+            FileBuilderEnum::CppBuilder(builder) => builder.write_closure(output, eof),
+            FileBuilderEnum::CSharpBuilder(builder) => builder.write_closure(output, eof),
+            FileBuilderEnum::JsonFileBuilder(builder) => builder.write_closure(output, eof),
+            FileBuilderEnum::RustFileBuilder(builder) => builder.write_closure(output, eof),
+        }
+    }
+}

src/builder/rust_file_builder.rs

@@ -0,0 +1,38 @@
+use std::io::{Result, Write};
+
+use super::FileBuilder;
+
+pub struct RustFileBuilder;
+
+impl FileBuilder for RustFileBuilder {
+    fn extension(&mut self) -> &str {
+        "rs"
+    }
+
+    fn write_top_level(&mut self, output: &mut dyn Write) -> Result<()> {
+        write!(
+            output,
+            "#![allow(non_snake_case, non_upper_case_globals)]\n\n"
+        )?;
+
+        Ok(())
+    }
+
+    fn write_namespace(&mut self, output: &mut dyn Write, name: &str) -> Result<()> {
+        write!(output, "pub mod {} {{\n", name)?;
+
+        Ok(())
+    }
+
+    fn write_variable(&mut self, output: &mut dyn Write, name: &str, value: usize) -> Result<()> {
+        write!(output, "    pub const {}: usize = {:#X};\n", name, value)?;
+
+        Ok(())
+    }
+
+    fn write_closure(&mut self, output: &mut dyn Write, eof: bool) -> Result<()> {
+        write!(output, "{}", if eof { "}" } else { "}\n\n" })?;
+
+        Ok(())
+    }
+}