Struct Param

pub struct Param {
    pub name: String,
    pub coercer: Option<Box<dyn Coercer + Send + Sync>>,
    pub nest: Option<Builder>,
    pub description: Option<String>,
    pub allow_null: bool,
    pub validators: Validators,
    pub default: Option<Value>,
    pub schema_builder: Option<Box<dyn Fn(&mut Builder) + Send + Sync>>,
    pub schema_id: Option<Url>,
}

Fields

name: String

coercer: Option<Box<dyn Coercer + Send + Sync>>

nest: Option<Builder>

description: Option<String>

allow_null: bool

validators: Validators

default: Option<Value>

schema_builder: Option<Box<dyn Fn(&mut Builder) + Send + Sync>>

schema_id: Option<Url>

Implementations

impl Param

pub fn new(name: &str) -> Param

pub fn new_with_coercer( name: &str, coercer: Box<dyn Coercer + Send + Sync>, ) -> Param

pub fn new_with_nest( name: &str, coercer: Box<dyn Coercer + Send + Sync>, nest: Builder, ) -> Param

pub fn build<F>(name: &str, build_def: F) -> Param

where F: FnOnce(&mut Param),

pub fn desc(&mut self, description: &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 coerce(&mut self, coercer: Box<dyn Coercer + Send + Sync>)

pub fn nest<F>(&mut self, nest_def: F)

where F: FnOnce(&mut Builder),

pub fn allow_null(&mut self)

pub fn regex(&mut self, regex: Regex)

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 process( &self, val: &mut Value, path: &str, scope: &Option<&Scope>, ) -> ExtendedResult<Option<Value>>

impl Param

pub fn allow_values<T: Serialize>(&mut self, values: &[T])

pub fn reject_values<T: Serialize>(&mut self, values: &[T])

pub fn default<T: Serialize>(&mut self, default: T)

Trait Implementations

impl Send for Param