Struct Keys

pub struct Keys(/* private fields */);

A span consisting of consecutive string keys.

Implementations

impl Keys

pub fn new() -> Self

Create a new instance with no keys.

pub fn with_capacity(cap: usize) -> Self

Create a new empty instance with a capacity.

pub fn iter(&self) -> impl Iterator<Item = &String>

Iterator over the keys.

pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut String>

Mutable Iterator over the keys.

pub fn dotted(&self) -> String

Returns the keys joined by dots.

Examples found in repository

examples/schemars_json.rs (line 67)

fn main() {
    let schema_value = json! {
        {
            "$schema": "http://json-schema.org/draft-07/schema#",
            "title": "SomeStruct",
            "type": "object",
            "required": [
              "some_inner",
              "some_int"
            ],
            "additionalProperties": false,
            "properties": {
              "some_inner": {
                "type": "object",
                "required": [
                  "inner_values",
                  "inner_value"
                ],
                "properties": {
                  "inner_values": {
                    "type": "array",
                    "maxItems": 2,
                    "items": {
                        "type": "string"
                    }
                  },
                  "inner_value": {
                    "type": "integer",
                    "enum": [1, 3]
                  }
                }
              },
              "some_int": {
                "type": "integer",
                "format": "int32"
              }
            }
          }
    };

    let value = json! {
        {
            "some_inner": {
              "inner_value": 2,
              "inner_values": ["value", 2]
            },
            "unexpected_property": 2
        }
    };

    let schema = serde_json::from_value::<RootSchema>(schema_value).unwrap();
    let valid = schema.verify_value(&Spanned::new(&value, KeySpans::default()));

    if let Err(errors) = valid {
        for error in errors {
            println!(
                "({span}) {err}",
                span = error.span.map(|s| s.dotted()).unwrap_or_default(),
                err = error.value
            )
        }
    }
    // (some_inner.inner_value) invalid enum value, expected to be one of {1, 3}
    // (some_inner.inner_values.1) invalid type, expected "String"
    // (unexpected_property) value is not allowed here
    // () the required property "some_int" is missing
}

pub fn push(&mut self, value: String)

Add a new key.

pub fn into_inner(self) -> SmallVec<[String; 10]>

Return the inner container.

Trait Implementations

impl<S: ToString> Add<S> for Keys

type Output = Keys

The resulting type after applying the + operator.

fn add(self, rhs: S) -> Self::Output

Performs the + operation.

impl AddAssign for Keys

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl Clone for Keys

fn clone(&self) -> Keys

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Keys

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

Formats the value using the given formatter.

impl Default for Keys

fn default() -> Keys

Returns the “default value” for a type.

impl From<String> for Keys

fn from(s: String) -> Self

Converts to this type from the input type.

impl IntoIterator for Keys

type Item = <SmallVec<[String; 10]> as IntoIterator>::Item

The type of the elements being iterated over.

type IntoIter = IntoIter<[String; 10]>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl PartialEq for Keys

fn eq(&self, other: &Keys) -> 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 Eq for Keys

impl Span for Keys

impl StructuralPartialEq for Keys