add schemars to ZeroVec

utils/zerovec/Cargo.toml

@@ -24,6 +24,7 @@ all-features = true
 
 [dependencies]
 zerofrom = { workspace = true }
+serde_json = "1.0"
 
 zerovec-derive = { workspace = true, optional = true}
 
@@ -37,6 +38,7 @@ serde = { version = "1.0", default-features = false, features = ["alloc"], optio
 # and all 0.7 versions, but not further.
 yoke = { version = ">=0.6.0, <0.8.0", path = "../yoke", optional = true }
 twox-hash = { version = "1.6", default-features = false, optional = true }
+schemars = "0.8.16"
 
 [dev-dependencies]
 bincode = "1.3"
@@ -48,7 +50,6 @@ rand = "0.8"
 rand_distr = "0.4"
 rand_pcg = "0.3"
 serde = { version = "1.0", features = ["derive"] }
-serde_json = "1.0"
 yoke = { path = "../../utils/yoke", features = ["derive"] }
 zerofrom = { path = "../../utils/zerofrom", features = ["derive"] }
 

utils/zerovec/src/error.rs

@@ -5,6 +5,19 @@
 use core::any;
 use core::fmt;
 
+use crate::__zerovec_internal_reexport::boxed::Box;
+use alloc::borrow::ToOwned;
+use alloc::format;
+use alloc::string::String;
+use alloc::vec;
+use schemars::gen::SchemaGenerator;
+use schemars::schema::InstanceType;
+use schemars::schema::Schema;
+use schemars::schema::SchemaObject;
+use schemars::JsonSchema;
+
+use serde_json::Value;
+
 /// A generic error type to be used for decoding slices of ULE types
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
 #[non_exhaustive]
@@ -33,6 +46,27 @@ impl fmt::Display for ZeroVecError {
         }
     }
 }
+impl JsonSchema for ZeroVecError {
+    fn schema_name() -> String {
+        format!("ZeroVecError")
+    }
+
+    fn json_schema(_gen: &mut SchemaGenerator) -> Schema {
+        Schema::Object(SchemaObject {
+            instance_type: Some(InstanceType::String.into()),
+            enum_values: Some(vec![
+                Value::String("InvalidLength".to_owned()),
+                Value::String("ParseError".to_owned()),
+                Value::String("VarZeroVecFormatError".to_owned()),
+            ]),
+            metadata: Some(Box::new(schemars::schema::Metadata {
+                description: Some("ZeroVecError is an enum representing errors that can occur during the decoding of slices of ULE".into()),
+                ..Default::default()
+            })),
+            ..Default::default()
+        })
+    }
+}
 
 impl ZeroVecError {
     /// Construct a parse error for the given type

utils/zerovec/src/lib.rs

@@ -523,6 +523,53 @@ pub use zerovec_derive::make_varule;
 mod tests {
     use super::*;
     use core::mem::size_of;
+    use schemars::{gen::SchemaGenerator, JsonSchema};
+    use serde::{Deserialize, Serialize};
+    use serde_json::Value;
+
+    #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+    #[derive(JsonSchema)]
+    pub struct DataStruct<'data> {
+        #[cfg_attr(feature = "serde", serde(borrow))]
+        nums: ZeroVec<'data, u32>,
+
+        #[cfg_attr(feature = "serde", serde(borrow))]
+        chars: ZeroVec<'data, char>,
+
+        #[cfg_attr(feature = "serde", serde(borrow))]
+        strs: VarZeroVec<'data, str>,
+
+        #[cfg_attr(feature = "serde", serde(borrow))]
+        nested_numbers: VarZeroVec<'data, ZeroSlice<u32>>,
+    }
+
+    #[test]
+    fn check_schema() {
+        let gen = SchemaGenerator::default();
+        let schema = gen.into_root_schema_for::<DataStruct>();
+        let schema_json =
+            serde_json::to_string_pretty(&schema).expect("Failed to serialize schema");
+        println!("{}", schema_json);
+        let parsed_schema: Value =
+            serde_json::from_str(&schema_json).expect("Failed to parse schema JSON");
+
+        // Check for the existence of "ZeroVec<Character>" and "ZeroVec<uint32>" in `definitions`
+        let definitions = parsed_schema
+            .get("definitions")
+            .expect("No definitions found in schema");
+        assert!(
+            definitions.get("ZeroVec<Character>").is_some(),
+            "Definition for ZeroVec<Character> not found"
+        );
+        assert!(
+            definitions.get("ZeroVec<uint32>").is_some(),
+            "Definition for ZeroVec<uint32> not found"
+        );
+        assert!(
+            definitions.get("VarZeroVec<String>").is_some(),
+            "Definition for VarZeroVec<String> not found"
+        );
+    }
 
     /// Checks that the size of the type is one of the given sizes.
     /// The size might differ across Rust versions or channels.

utils/zerovec/src/varzerovec/vec.rs

@@ -4,10 +4,17 @@
 
 use crate::ule::*;
 
+use alloc::borrow::Cow;
+use alloc::boxed::Box;
+use alloc::format;
+use alloc::string::String;
 use alloc::vec::Vec;
 use core::cmp::{Ord, Ordering, PartialOrd};
 use core::fmt;
 use core::ops::Deref;
+use schemars::gen::SchemaGenerator;
+use schemars::schema::{ArrayValidation, InstanceType, Schema, SchemaObject};
+use schemars::JsonSchema;
 
 use super::*;
 
@@ -232,6 +239,34 @@ impl<T: VarULE + ?Sized, F: VarZeroVecFormat> Deref for VarZeroVec<'_, T, F> {
     }
 }
 
+impl<'a, T, F> JsonSchema for VarZeroVec<'a, T, F>
+where
+    T: VarULE + ?Sized + JsonSchema,
+    F: VarZeroVecFormat,
+{
+    fn schema_name() -> String {
+        format!("VarZeroVec<{}>", T::schema_name())
+    }
+
+    fn schema_id() -> Cow<'static, str> {
+        Cow::Owned(format!("zerovec::VarZeroVec<{}>", T::schema_id()))
+    }
+
+    fn json_schema(gen: &mut SchemaGenerator) -> Schema {
+        let items_schema = gen.subschema_for::<T>();
+
+        SchemaObject {
+            instance_type: Some(InstanceType::Array.into()),
+            array: Some(Box::new(ArrayValidation {
+                items: Some(items_schema.into()),
+                ..Default::default()
+            })),
+            ..Default::default()
+        }
+        .into()
+    }
+}
+
 impl<'a, T: VarULE + ?Sized, F: VarZeroVecFormat> VarZeroVec<'a, T, F> {
     /// Creates a new, empty `VarZeroVec<T>`.
     ///

utils/zerovec/src/zerovec/mod.rs

@@ -10,10 +10,15 @@ mod serde;
 
 mod slice;
 
+use schemars::gen::SchemaGenerator;
+use schemars::schema::{ArrayValidation, InstanceType, Schema};
 pub use slice::ZeroSlice;
 
 use crate::ule::*;
 use alloc::borrow::Cow;
+use alloc::boxed::Box;
+use alloc::format;
+use alloc::string::String;
 use alloc::vec::Vec;
 use core::cmp::{Ord, Ordering, PartialOrd};
 use core::fmt;
@@ -23,6 +28,7 @@ use core::mem;
 use core::num::NonZeroUsize;
 use core::ops::Deref;
 use core::ptr::{self, NonNull};
+use schemars::{schema::SchemaObject, JsonSchema};
 
 /// A zero-copy, byte-aligned vector for fixed-width types.
 ///
@@ -114,6 +120,32 @@ impl<'a, T: AsULE> Deref for ZeroVec<'a, T> {
     }
 }
 
+impl<'a, T> JsonSchema for ZeroVec<'a, T>
+where
+    T: AsULE + JsonSchema,
+{
+    fn schema_name() -> String {
+        format!("ZeroVec<{}>", T::schema_name())
+    }
+
+    fn schema_id() -> Cow<'static, str> {
+        Cow::Owned(format!("zerovec::ZeroVec<{}>", T::schema_id()))
+    }
+
+    fn json_schema(gen: &mut SchemaGenerator) -> Schema {
+        let element_schema = gen.subschema_for::<T>();
+        SchemaObject {
+            instance_type: Some(InstanceType::Array.into()),
+            array: Some(Box::new(ArrayValidation {
+                items: Some(element_schema.into()),
+                ..Default::default()
+            })),
+            ..Default::default()
+        }
+        .into()
+    }
+}
+
 // Represents an unsafe potentially-owned vector/slice type, without a lifetime
 // working around dropck limitations.
 //

utils/zerovec/src/zerovec/slice.rs

@@ -3,6 +3,8 @@
 // (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
 
 use super::*;
+use crate::alloc::string::ToString;
+use ::serde::Serialize;
 use alloc::boxed::Box;
 use core::cmp::Ordering;
 use core::ops::Range;
@@ -543,6 +545,41 @@ impl<T: AsULE + Ord> Ord for ZeroSlice<T> {
     }
 }
 
+impl<T> JsonSchema for ZeroSlice<T>
+where
+    T: AsULE + JsonSchema + Serialize, // Ensure T is serializable for accurate schema representation
+{
+    fn schema_name() -> String {
+        format!("ZeroSlice<{}>", T::schema_name())
+    }
+
+    fn schema_id() -> Cow<'static, str> {
+        Cow::Owned(format!("zerovec::ZeroSlice<{}>", T::schema_id()))
+    }
+
+    fn json_schema(gen: &mut SchemaGenerator) -> Schema {
+        // Instead of generating a subschema for T, we generate a schema representing the byte array
+        let byte_schema = gen.subschema_for::<Vec<u8>>();
+
+        SchemaObject {
+            instance_type: Some(InstanceType::Object.into()),
+            object: Some(Box::new({
+                let mut object_validation = schemars::schema::ObjectValidation::default();
+                object_validation
+                    .properties
+                    .insert("data".to_string(), byte_schema);
+                object_validation
+                    .properties
+                    .insert("error".to_string(), gen.subschema_for::<ZeroVecError>());
+                object_validation.required.insert("data".to_string());
+                object_validation
+            })),
+            ..Default::default()
+        }
+        .into()
+    }
+}
+
 impl<T: AsULE> AsRef<ZeroSlice<T>> for Vec<T::ULE> {
     fn as_ref(&self) -> &ZeroSlice<T> {
         ZeroSlice::<T>::from_ule_slice(self)