Struct Schema 

pub struct Schema {
    pub schema: Option<Draft>,
    pub id: Option<String>,
    pub title: String,
    pub description: Option<String>,
    /* private fields */
}

This is a structure representing the JSON schema itself.

Create Schema

See the documentation top for usage.

To JSON schema string

#[derive(Debug, Schematic)]
struct Example {
    #[rschema(field(
        title = "Dummy",
        description = "Dummy field",
    ))]
    dummy: String,
}
 
fn main() -> rschema::Result<()> {
    let schema_str = Schema::new::<Example>("Example")
        .to_string()?;
 
    assert_eq!(
        schema_str,
        r#"{"title":"Example","type":"object","properties":{"dummy":{"title":"Dummy","description":"Dummy field","type":"string"}},"additionalProperties":false}"#
    );
 
    Ok(())
}

Use to_string_pretty to generate as a pretty-prited string.

Fields

schema: Option<Draft>

id: Option<String>

title: String

description: Option<String>

Implementations

impl Schema

pub fn new<T>(title: &str) -> Schema

where T: Schematic,

Create a schema object from the given type T.

pub fn description(&mut self, description: impl Into<String>) -> &mut Schema

Add a description about this schema.

pub fn schema(&mut self, schema: Draft) -> &mut Schema

Specify $schema.

pub fn id(&mut self, id: impl Into<String>) -> &mut Schema

Specify $id.

pub fn to_string(&self) -> Result<String, Error>

Generate a JSON schema string.

Errors

Internally calls serde_json::to_string, so this can fail if it fails.

pub fn to_string_pretty(&self) -> Result<String, Error>

Generate a pretty-printed JSON schema string.

Errors

Internally calls serde_json::to_string_pretty, so this can fail if it fails.

pub fn write(&self, path: impl AsRef<Path>) -> Result<(), Error>

Write a JSON schema string to a file.

Errors

This call can fail if its own to_string call or writing to a file fails.

pub fn write_pretty(&self, path: impl AsRef<Path>) -> Result<(), Error>

Write a pretty-printed JSON schema string to a file.

Errors

This call can fail if its own to_string_pretty call or writing to a file fails.

Trait Implementations

impl Debug for Schema

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Serialize for Schema

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.