Struct ion_schema::types::TypeRef

pub struct TypeRef { /* private fields */ }

Implementations

impl TypeRef

pub fn new(id: TypeId, type_store: Rc<TypeStore>) -> Self

pub fn id(&self) -> TypeId

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

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

use ion_rs::value::owned::OwnedElement;
use ion_schema::IonSchemaElement;
use ion_schema::authority::{FileSystemDocumentAuthority, DocumentAuthority};
use ion_schema::system::SchemaSystem;
use ion_schema::result::IonSchemaResult;
use std::path::Path;

fn main() -> IonSchemaResult<()> {
    // create an IonSchemaElement from an OwnedElement
    use ion_schema::authority::MapDocumentAuthority;
    let owned_element: OwnedElement = 4.into();
    let document: Vec<OwnedElement> = 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(&document).is_err()); // document type is invalid for `my_int` type
    Ok(())
}

Trait Implementations

impl Clone for TypeRef

fn clone(&self) -> TypeRef

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for TypeRef

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

Formats the value using the given formatter.