Enum Schema

pub enum Schema {
    Null(NullContext),
    Boolean(BooleanContext),
    Integer(NumberContext<i128>),
    Float(NumberContext<f64>),
    String(StringContext),
    Bytes(BytesContext),
    Sequence {
        field: Box<Field>,
        context: SequenceContext,
    },
    Struct {
        fields: BTreeMap<String, Field>,
        context: MapStructContext,
    },
    Union {
        variants: Vec<Schema>,
    },
}

This enum is the core output of the analysis, it describes the structure of a document.

Each variant also contains context data that allows it to store information about the values it has encountered.

Variants

Null(NullContext)

The Null variant is a special one that is only ever found when a document has a single null value at the root of the document. Null values in Structs or Sequences are instead handled at the Field level, where it is more ergonomic.

Boolean(BooleanContext)

Represents a boolean value.

Integer(NumberContext<i128>)

Represents an integer value.

Float(NumberContext<f64>)

Represents a floating point value.

String(StringContext)

Represents a textual value.

Bytes(BytesContext)

Represents a value of raw bytes.

Sequence

Represents a sequence of values described by a Field. It assumes all values share the same schema.

Fields

field: Box<Field>

The field is the structure shared by all the elements of the sequence.

context: SequenceContext

The context aggregates information about the sequence. It is passed the length of the sequence.

Struct

Represents a String->Field mapping.

Note: currently there is not a true map and only strings may be used as keys.

Fields

fields: BTreeMap<String, Field>

Each String key gets assigned a Field. Currently we are using a BTreeMap, but that might change in the future.

context: MapStructContext

The context aggregates information about the struct. It is passed a vector of the key names.

Union

Simply a vector of Schemas, it should never contain an Union or multiple instances of the same variant inside.

Note: content needs to be a struct variant to work with #[serde(tag = "type")].

Fields

variants: Vec<Schema>

A list of the possible schemas that were found.

Implementations

impl Schema

pub fn to_json_typegen_shape(&self) -> Shape

Convert a Schema to a json_typegen Shape.

pub fn process_with_json_typegen( &self, mode: OutputMode, ) -> Result<String, JTError>

Convert a Schema to a supported json_typegen output

pub fn process_with_json_typegen_options( &self, name: &str, options: &Options, ) -> Result<String, JTError>

Convert a Schema to a supported json_typegen output using custom settings.

impl Schema

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

Convert into a json_schema using the default settings.

pub fn to_json_schema_with_schemars_version( &self, version: &JsonSchemaVersion, ) -> Result<String, impl Error>

Convert into a specific version of json_schema.

pub fn to_schemars_schema(&self, generator: &mut SchemaGenerator) -> RootSchema

Convert using a provided generator (which also holds the settings) to a json schema.

Trait Implementations

impl Clone for Schema

fn clone(&self) -> Schema

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Coalesce for Schema

fn coalesce(&mut self, other: Self)

Merge other into self.

impl Debug for Schema

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Schema

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<Schema> for Shape

fn from(schema: Schema) -> Self

Converts to this type from the input type.

impl PartialEq for Schema

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Schema

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralEq for Schema

fn structural_eq(&self, other: &Self) -> bool

Returns true if self and other share the same structure.

fn structural_ne(&self, other: &Rhs) -> bool

Returns true if self and other DO NOT share the same structure.