Struct TypeDefinition 

pub struct TypeDefinition { /* private fields */ }

Represents a top level ISL type definition

Implementations

impl TypeDefinition

pub fn id(&self) -> TypeId

pub fn validate<'a, I: Into<IonSchemaElement<'a>>>( &self, value: I, ) -> ValidationResult

Provides the validation for the given value based on this schema type

use ion_rs::Element;
use ion_schema::IonSchemaElement;
use ion_schema::authority::{FileSystemDocumentAuthority, DocumentAuthority};
use ion_schema::system::SchemaSystem;
use ion_schema::result::IonSchemaResult;
use std::path::Path;
use ion_schema::authority::MapDocumentAuthority;
use ion_schema::AsDocumentHint;

fn main() -> IonSchemaResult<()> {
    // create an IonSchemaElement from an Element
    let owned_element: Element = 4.into();
    let elements: Vec<Element> = vec![4.into(), "hello".to_string().into(), true.into()];

    let map_authority = [
        (
           "sample.isl",
            r#"
                type::{
                    name: my_int,
                    type: int,
                }
            "#
        )   
    ];

    // create a vector of authorities and construct schema system
    // this example uses above mentioned map as the authority
    let authorities: Vec<Box<dyn DocumentAuthority>> = vec![Box::new(
            MapDocumentAuthority::new(map_authority),
        )];
    let mut schema_system = SchemaSystem::new(authorities);

    // use this schema_system to load a schema as following
    let schema = schema_system.load_schema("sample.isl")?;

    // unwrap() here because we know that the `my_int` type exists in sample.isl
    let type_ref = schema.get_type("my_int").unwrap();

    assert!(type_ref.validate(&owned_element).is_ok()); // 4 is valid for `my_int`
    assert!(type_ref.validate(elements.as_document()).is_err()); // document type is invalid for `my_int` type
    Ok(())
}

Trait Implementations

impl Clone for TypeDefinition

fn clone(&self) -> TypeDefinition

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TypeDefinition

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

Formats the value using the given formatter.