polyxml 0.15.0__tar.gz → 0.16.0__tar.gz

{polyxml-0.15.0 → polyxml-0.16.0}/Cargo.lock

@@ -549,7 +549,7 @@ dependencies = [
 
 [[package]]
 name = "polyxml"
-version = "0.15.0"
+version = "0.16.0"
 dependencies = [
  "criterion",
  "heck",
@@ -567,14 +567,14 @@ dependencies = [
 
 [[package]]
 name = "polyxml-c"
-version = "0.15.0"
+version = "0.16.0"
 dependencies = [
  "polyxml",
 ]
 
 [[package]]
 name = "polyxml-cli"
-version = "0.15.0"
+version = "0.16.0"
 dependencies = [
  "clap",
  "glob",
@@ -588,7 +588,7 @@ dependencies = [
 
 [[package]]
 name = "polyxml-js"
-version = "0.15.0"
+version = "0.16.0"
 dependencies = [
  "napi",
  "napi-build",
@@ -598,7 +598,7 @@ dependencies = [
 
 [[package]]
 name = "polyxml-python"
-version = "0.15.0"
+version = "0.16.0"
 dependencies = [
  "lexical-core",
  "polyxml",

{polyxml-0.15.0 → polyxml-0.16.0}/Cargo.toml

@@ -3,7 +3,7 @@ resolver = "2"
 members = ["crates/polyxml-core", "crates/polyxml-python"]
 
 [workspace.package]
-version = "0.15.0"
+version = "0.16.0"
 edition = "2021"
 rust-version = "1.80"
 license = "MIT"

{polyxml-0.15.0 → polyxml-0.16.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polyxml
-Version: 0.15.0
+Version: 0.16.0
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License

{polyxml-0.15.0 → polyxml-0.16.0}/crates/polyxml-core/src/codegen/cpp/mod.rs

@@ -20,6 +20,40 @@ pub enum CppMode {
     Module,
 }
 
+impl CppMode {
+    pub fn from_str_loose(s: &str) -> Option<Self> {
+        match s.to_lowercase().trim() {
+            "header" | "headeronly" | "header-only" | "headers" | "hpp" => Some(Self::HeaderOnly),
+            "module" | "modules" | "cppm" | "c++20-modules" => Some(Self::Module),
+            _ => None,
+        }
+    }
+}
+
+/// Target backend for C++ serialization/reflection metadata.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Serialize, Deserialize)]
+pub enum CppBackend {
+    /// Zero-dependency standard C++20 (default)
+    #[default]
+    Standard,
+    /// Glaze compile-time reflectionless serde (`glz::meta`)
+    Glaze,
+}
+
+impl CppBackend {
+    pub fn from_str_loose(s: &str) -> Option<Self> {
+        match s.to_lowercase().trim() {
+            "standard" | "std" | "default" | "none" => Some(Self::Standard),
+            "glaze" | "glz" => Some(Self::Glaze),
+            _ => None,
+        }
+    }
+
+    pub fn is_glaze(self) -> bool {
+        matches!(self, Self::Glaze)
+    }
+}
+
 /// Options configuring modern C++20/C++23 code generation.
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub struct CppOptions {
@@ -27,6 +61,8 @@ pub struct CppOptions {
     pub namespace: String,
     /// Header-only (.hpp) or C++20 Module (.cppm) mode (default: HeaderOnly)
     pub mode: CppMode,
+    /// Target serialization and metadata backend (default: Standard)
+    pub backend: CppBackend,
     /// Standard language dialect (default: "c++20")
     pub standard: String,
     /// Emit C++20 defaulted equality operators `bool operator==(const T&) const = default;` (default: true)
@@ -48,6 +84,7 @@ impl Default for CppOptions {
         Self {
             namespace: "polyxml::generated".to_string(),
             mode: CppMode::HeaderOnly,
+            backend: CppBackend::Standard,
             standard: "c++20".to_string(),
             emit_equality_operators: true,
             emit_enum_converters: true,
@@ -229,6 +266,11 @@ impl CppCodegen {
         self.emit_root_aliases(&mut out, ir);
 
         writeln!(out, "\n}} // namespace {}", ns).unwrap();
+
+        if self.options.backend.is_glaze() {
+            self.emit_glaze_meta(&mut out, ir);
+        }
+
         out
     }
 
@@ -261,6 +303,11 @@ impl CppCodegen {
         self.emit_root_aliases(&mut out, ir);
 
         writeln!(out, "\n}} // namespace {}", ns).unwrap();
+
+        if self.options.backend.is_glaze() {
+            self.emit_glaze_meta(&mut out, ir);
+        }
+
         out
     }
 
@@ -314,8 +361,26 @@ impl CppCodegen {
     /// Generate CMakeLists.txt definition for integration via add_subdirectory or FetchContent.
     pub fn generate_cmake(&self, project_name: &str) -> String {
         let safe_name = AsSnakeCase(project_name).to_string();
-        format!(
-            r#"cmake_minimum_required(VERSION 3.20)
+        if self.options.mode == CppMode::Module {
+            format!(
+                r#"cmake_minimum_required(VERSION 3.28)
+project({safe_name}_models LANGUAGES CXX)
+
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+add_library({safe_name})
+target_sources({safe_name}
+    PUBLIC
+        FILE_SET CXX_MODULES FILES
+            {safe_name}.cppm
+)
+target_compile_features({safe_name} PUBLIC cxx_std_20)
+"#
+            )
+        } else {
+            format!(
+                r#"cmake_minimum_required(VERSION 3.20)
 project({safe_name}_models LANGUAGES CXX)
 
 set(CMAKE_CXX_STANDARD 20)
@@ -328,7 +393,8 @@ target_include_directories({safe_name} INTERFACE
 )
 target_compile_features({safe_name} INTERFACE cxx_std_20)
 "#
-        )
+            )
+        }
     }
 
     /// Generate standalone PolyXMLConfig.cmake for `find_package(PolyXML)`.
@@ -372,7 +438,93 @@ endif()
         writeln!(out, "#include <string>").unwrap();
         writeln!(out, "#include <string_view>").unwrap();
         writeln!(out, "#include <variant>").unwrap();
-        writeln!(out, "#include <vector>\n").unwrap();
+        writeln!(out, "#include <vector>").unwrap();
+
+        if self.options.backend.is_glaze() {
+            writeln!(out, "#include <glaze/glaze.hpp>").unwrap();
+        }
+        writeln!(out).unwrap();
+    }
+
+    fn emit_glaze_meta(&self, out: &mut String, ir: &SchemaIR) {
+        let ns = to_cpp_namespace(&self.options.namespace);
+        writeln!(out, "\n// Glaze compile-time reflection metadata\n").unwrap();
+
+        // 1. Enums
+        for type_def in ir.types.values() {
+            if let TypeDef::Enum(enum_def) = type_def {
+                let enum_name = to_cpp_type_name(&enum_def.qname.local);
+                let full_type = format!("{}::{}", ns, enum_name);
+                writeln!(out, "template <>").unwrap();
+                writeln!(out, "struct glz::meta<{}> {{", full_type).unwrap();
+                writeln!(out, "    using T = {};", full_type).unwrap();
+                if enum_def.variants.is_empty() {
+                    writeln!(out, "    static constexpr auto value = enumerate();").unwrap();
+                } else {
+                    writeln!(out, "    static constexpr auto value = enumerate(").unwrap();
+                    for (i, v) in enum_def.variants.iter().enumerate() {
+                        let var_name = to_cpp_enum_variant(&v.name);
+                        let comma = if i + 1 < enum_def.variants.len() {
+                            ","
+                        } else {
+                            ""
+                        };
+                        writeln!(out, "        {:?}, T::{}{}", v.value, var_name, comma).unwrap();
+                    }
+                    writeln!(out, "    );").unwrap();
+                }
+                writeln!(out, "}};\n").unwrap();
+            }
+        }
+
+        // 2. Structs
+        let sorted_qnames = self.topological_sort_types(ir);
+        for qname in sorted_qnames {
+            if let Some(TypeDef::Struct(s)) = ir.types.get(&qname) {
+                let struct_name = to_cpp_type_name(&s.qname.local);
+                let full_type = format!("{}::{}", ns, struct_name);
+                writeln!(out, "template <>").unwrap();
+                writeln!(out, "struct glz::meta<{}> {{", full_type).unwrap();
+                writeln!(out, "    using T = {};", full_type).unwrap();
+
+                let mut field_bindings = Vec::new();
+
+                // Check for simple_content_base "value"
+                if let Some(ref base_qname) = s.base_type {
+                    let has_value_field = s
+                        .fields
+                        .iter()
+                        .any(|f| f.name == "value" || f.kind == crate::ir::FieldKind::Text);
+                    if !has_value_field
+                        && (PrimitiveType::from_xsd_name(&base_qname.local).is_some()
+                            || matches!(ir.types.get(base_qname), Some(TypeDef::Simple(_))))
+                    {
+                        field_bindings.push(r#""value", &T::value"#.to_string());
+                    }
+                }
+
+                for f in &s.fields {
+                    let field_name = to_cpp_field_name(&f.name);
+                    field_bindings.push(format!("{:?}, &T::{}", f.xml_name, field_name));
+                }
+
+                if field_bindings.is_empty() {
+                    writeln!(out, "    static constexpr auto value = object();").unwrap();
+                } else {
+                    writeln!(out, "    static constexpr auto value = object(").unwrap();
+                    for (i, fb) in field_bindings.iter().enumerate() {
+                        let comma = if i + 1 < field_bindings.len() {
+                            ","
+                        } else {
+                            ""
+                        };
+                        writeln!(out, "        {}{}", fb, comma).unwrap();
+                    }
+                    writeln!(out, "    );").unwrap();
+                }
+                writeln!(out, "}};\n").unwrap();
+            }
+        }
     }
 
     fn emit_utilities(&self, out: &mut String) {

{polyxml-0.15.0 → polyxml-0.16.0}/crates/polyxml-core/src/codegen/mod.rs

@@ -13,7 +13,7 @@ pub mod python;
 pub mod rust;
 pub mod typescript;
 
-pub use cpp::{CppCodegen, CppMode, CppOptions};
+pub use cpp::{CppBackend, CppCodegen, CppMode, CppOptions};
 pub use csharp::{CSharpCodegen, CSharpOptions, CSharpRecordKind};
 pub use go::{GoCodegen, GoOptions};
 pub use java::{JavaBackend, JavaCodegen, JavaOptions};

{polyxml-0.15.0 → polyxml-0.16.0}/crates/polyxml-core/tests/test_cpp_codegen.rs

@@ -3,8 +3,8 @@ use std::process::Command;
 use tempfile::tempdir;
 
 use polyxml::codegen::cpp::{
-    to_cpp_enum_variant, to_cpp_field_name, to_cpp_namespace, to_cpp_type_name, CppCodegen,
-    CppMode, CppOptions,
+    to_cpp_enum_variant, to_cpp_field_name, to_cpp_namespace, to_cpp_type_name, CppBackend,
+    CppCodegen, CppMode, CppOptions,
 };
 use polyxml::ir::{
     Cardinality, EnumDef, EnumValue, FieldDef, FieldKind, PrimitiveType, QName, RestrictionFacets,
@@ -154,6 +154,7 @@ fn test_cpp_struct_and_enum_codegen_compilation() {
     let options = CppOptions {
         namespace: "crm::models".to_string(),
         mode: CppMode::HeaderOnly,
+        backend: CppBackend::Standard,
         standard: "c++20".to_string(),
         emit_equality_operators: true,
         emit_enum_converters: true,
@@ -862,3 +863,140 @@ int main() {
         "ISO 20022 test binary execution failed"
     );
 }
+
+#[test]
+fn test_cpp_mode_and_backend_from_str_loose() {
+    assert_eq!(CppMode::from_str_loose("header"), Some(CppMode::HeaderOnly));
+    assert_eq!(
+        CppMode::from_str_loose("header-only"),
+        Some(CppMode::HeaderOnly)
+    );
+    assert_eq!(CppMode::from_str_loose("hpp"), Some(CppMode::HeaderOnly));
+    assert_eq!(CppMode::from_str_loose("modules"), Some(CppMode::Module));
+    assert_eq!(CppMode::from_str_loose("module"), Some(CppMode::Module));
+    assert_eq!(CppMode::from_str_loose("cppm"), Some(CppMode::Module));
+    assert_eq!(CppMode::from_str_loose("unknown"), None);
+
+    assert_eq!(
+        CppBackend::from_str_loose("standard"),
+        Some(CppBackend::Standard)
+    );
+    assert_eq!(
+        CppBackend::from_str_loose("default"),
+        Some(CppBackend::Standard)
+    );
+    assert_eq!(CppBackend::from_str_loose("glaze"), Some(CppBackend::Glaze));
+    assert_eq!(CppBackend::from_str_loose("glz"), Some(CppBackend::Glaze));
+    assert_eq!(CppBackend::from_str_loose("unknown"), None);
+}
+
+#[test]
+fn test_cpp_glaze_backend_meta_generation() {
+    let mut ir = SchemaIR::new().with_target_namespace("https://example.com/shop");
+
+    // Enum
+    ir.add_type(TypeDef::Enum(EnumDef {
+        qname: QName::new(Some("https://example.com/shop"), "OrderStatus"),
+        base_type: TypeRef::Primitive(PrimitiveType::String),
+        variants: vec![
+            EnumValue {
+                name: "pending".into(),
+                value: "pending".into(),
+                documentation: None,
+            },
+            EnumValue {
+                name: "shipped".into(),
+                value: "shipped".into(),
+                documentation: None,
+            },
+        ],
+        documentation: None,
+    }));
+
+    // Struct
+    ir.add_type(TypeDef::Struct(StructDef {
+        qname: QName::new(Some("https://example.com/shop"), "Order"),
+        base_type: None,
+        is_abstract: false,
+        fields: vec![
+            FieldDef {
+                name: "order_id".into(),
+                xml_name: "orderId".into(),
+                namespace: None,
+                kind: FieldKind::Element,
+                type_ref: TypeRef::Primitive(PrimitiveType::Int),
+                cardinality: Cardinality::required_one(),
+                nillable: false,
+                default_value: None,
+                fixed_value: None,
+                documentation: None,
+                facets: None,
+                is_cycle_cut: false,
+            },
+            FieldDef {
+                name: "status".into(),
+                xml_name: "status".into(),
+                namespace: None,
+                kind: FieldKind::Element,
+                type_ref: TypeRef::Named(QName::new(
+                    Some("https://example.com/shop"),
+                    "OrderStatus",
+                )),
+                cardinality: Cardinality::required_one(),
+                nillable: false,
+                default_value: None,
+                fixed_value: None,
+                documentation: None,
+                facets: None,
+                is_cycle_cut: false,
+            },
+        ],
+        documentation: None,
+    }));
+
+    let options = CppOptions {
+        namespace: "shop".to_string(),
+        backend: CppBackend::Glaze,
+        ..Default::default()
+    };
+
+    let codegen = CppCodegen::new(options);
+    let header_code = codegen.generate_header(&ir);
+
+    // Includes Glaze header
+    assert!(header_code.contains("#include <glaze/glaze.hpp>"));
+
+    // Glaze enum reflection
+    assert!(header_code.contains("template <>"));
+    assert!(header_code.contains("struct glz::meta<shop::OrderStatus> {"));
+    assert!(header_code.contains("using T = shop::OrderStatus;"));
+    assert!(header_code.contains("static constexpr auto value = enumerate("));
+    assert!(header_code.contains("\"pending\", T::Pending,"));
+    assert!(header_code.contains("\"shipped\", T::Shipped"));
+
+    // Glaze struct reflection
+    assert!(header_code.contains("struct glz::meta<shop::Order> {"));
+    assert!(header_code.contains("using T = shop::Order;"));
+    assert!(header_code.contains("static constexpr auto value = object("));
+    assert!(header_code.contains("\"orderId\", &T::order_id,"));
+    assert!(header_code.contains("\"status\", &T::status"));
+}
+
+#[test]
+fn test_cpp_cmake_modules_file_set() {
+    let _ir = SchemaIR::new();
+
+    let options = CppOptions {
+        namespace: "telemetry".to_string(),
+        mode: CppMode::Module,
+        emit_cmake: true,
+        ..Default::default()
+    };
+
+    let codegen = CppCodegen::new(options);
+    let cmake = codegen.generate_cmake("telemetry");
+
+    assert!(cmake.contains("cmake_minimum_required(VERSION 3.28)"));
+    assert!(cmake.contains("FILE_SET CXX_MODULES FILES"));
+    assert!(cmake.contains("telemetry.cppm"));
+}

{polyxml-0.15.0 → polyxml-0.16.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "polyxml"
-version = "0.15.0"
+version = "0.16.0"
 description = "High-performance, polyglot XML data-binding engine built in Rust"
 authors = [
     { name = "Bailey Nguyen", email = "bailey.tan.nguyen@gmail.com" }