Struct valico::json_dsl::Builder

pub struct Builder { /* private fields */ }

Implementations

impl Builder

pub fn new() -> Builder

pub fn build<F>(rules: F) -> Builderwhere F: FnOnce(&mut Builder),

Examples found in repository

examples/example01.rs (lines 5-10)

fn main() {
    let params = json_dsl::Builder::build(|params| {
        params.req_nested("user", json_dsl::array(), |params| {
            params.req_typed("name", json_dsl::string());
            params.req_typed("friend_ids", json_dsl::array_of(json_dsl::u64()))
        });
    });

    let mut obj = from_str(r#"{"user": {"name": "Frodo", "friend_ids": ["1223"]}}"#).unwrap();

    let state = params.process(&mut obj, None);
    if state.is_valid() {
        println!("Result object is {}", to_string_pretty(&obj).unwrap());
    } else {
        panic!("Errors during process: {:?}", state);
    }
}

pub fn get_required(&self) -> &Vec<Param>

pub fn get_optional(&self) -> &Vec<Param>

pub fn get_validators(&self) -> &Validators

pub fn req_defined(&mut self, name: &str)

pub fn req_typed(&mut self, name: &str, coercer: Box<dyn Coercer + Send + Sync>)

Examples found in repository

examples/example01.rs (line 7)

fn main() {
    let params = json_dsl::Builder::build(|params| {
        params.req_nested("user", json_dsl::array(), |params| {
            params.req_typed("name", json_dsl::string());
            params.req_typed("friend_ids", json_dsl::array_of(json_dsl::u64()))
        });
    });

    let mut obj = from_str(r#"{"user": {"name": "Frodo", "friend_ids": ["1223"]}}"#).unwrap();

    let state = params.process(&mut obj, None);
    if state.is_valid() {
        println!("Result object is {}", to_string_pretty(&obj).unwrap());
    } else {
        panic!("Errors during process: {:?}", state);
    }
}

pub fn req_nested<F>( &mut self, name: &str, coercer: Box<dyn Coercer + Send + Sync>, nest_def: F )where F: FnOnce(&mut Builder),

Examples found in repository

examples/example01.rs (lines 6-9)

fn main() {
    let params = json_dsl::Builder::build(|params| {
        params.req_nested("user", json_dsl::array(), |params| {
            params.req_typed("name", json_dsl::string());
            params.req_typed("friend_ids", json_dsl::array_of(json_dsl::u64()))
        });
    });

    let mut obj = from_str(r#"{"user": {"name": "Frodo", "friend_ids": ["1223"]}}"#).unwrap();

    let state = params.process(&mut obj, None);
    if state.is_valid() {
        println!("Result object is {}", to_string_pretty(&obj).unwrap());
    } else {
        panic!("Errors during process: {:?}", state);
    }
}

pub fn req<F>(&mut self, name: &str, param_builder: F)where F: FnOnce(&mut Param),

pub fn opt_defined(&mut self, name: &str)

pub fn opt_typed(&mut self, name: &str, coercer: Box<dyn Coercer + Send + Sync>)

pub fn opt_nested<F>( &mut self, name: &str, coercer: Box<dyn Coercer + Send + Sync>, nest_def: F )where F: FnOnce(&mut Builder),

pub fn opt<F>(&mut self, name: &str, param_builder: F)where F: FnOnce(&mut Param),

pub fn validate( &mut self, validator: Box<dyn Validator + Send + Sync + 'static> )

pub fn validate_with<F>(&mut self, validator: F)where F: Fn(&Value, &str) -> ValidatorResult + 'static + Send + Sync,

pub fn mutually_exclusive(&mut self, params: &[&str])

pub fn exactly_one_of(&mut self, params: &[&str])

pub fn at_least_one_of(&mut self, params: &[&str])

pub fn schema_id(&mut self, id: Url)

pub fn schema<F>(&mut self, build: F)where F: Fn(&mut Builder) + 'static + Send + Sync,

pub fn build_schemes(&mut self, scope: &mut Scope) -> Result<(), SchemaError>

pub fn process(&self, val: &mut Value, scope: Option<&Scope>) -> ValidationState

Examples found in repository

examples/example01.rs (line 14)

fn main() {
    let params = json_dsl::Builder::build(|params| {
        params.req_nested("user", json_dsl::array(), |params| {
            params.req_typed("name", json_dsl::string());
            params.req_typed("friend_ids", json_dsl::array_of(json_dsl::u64()))
        });
    });

    let mut obj = from_str(r#"{"user": {"name": "Frodo", "friend_ids": ["1223"]}}"#).unwrap();

    let state = params.process(&mut obj, None);
    if state.is_valid() {
        println!("Result object is {}", to_string_pretty(&obj).unwrap());
    } else {
        panic!("Errors during process: {:?}", state);
    }
}

pub fn process_nest( &self, val: &mut Value, path: &str, scope: Option<&Scope> ) -> ValidationState

Trait Implementations

impl Send for Builder