Enum schema_analysis::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

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.

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

Struct

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.

Represents a String->Field mapping.

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

Union

Fields

variants: Vec<Schema>

A list of the possible schemas that were found.

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")].

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<Schema> for Schema

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

This method tests for self and other values to be equal, and is used by ==.

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

This method 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<Schema> 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.