Enum plugx_input::definition::InputDefinitionType

pub enum InputDefinitionType {
    Any,
    Boolean,
    Integer {
        maybe_range: Option<InputDefinitionRangeInteger>,
    },
    Float {
        maybe_range: Option<InputDefinitionRangeFloat>,
    },
    String {
        maybe_size: Option<InputDefinitionSize>,
    },
    List {
        maybe_size: Option<InputDefinitionSize>,
        item_definition: Box<InputDefinitionType>,
    },
    StaticMap {
        item_definitions: HashMap<String, InputDefinition>,
    },
    DynamicMap {
        maybe_size: Option<InputDefinitionSize>,
        item_definition: Box<InputDefinitionType>,
    },
    Enum {
        item_list: Vec<Input>,
    },
    Either {
        item_definition_list: Vec<InputDefinitionType>,
    },
}

Variants

Any

Boolean

Integer

Fields

maybe_range: Option<InputDefinitionRangeInteger>

Float

Fields

maybe_range: Option<InputDefinitionRangeFloat>

String

Fields

maybe_size: Option<InputDefinitionSize>

List

Fields

maybe_size: Option<InputDefinitionSize>

item_definition: Box<InputDefinitionType>

StaticMap

Fields

item_definitions: HashMap<String, InputDefinition>

DynamicMap

Fields

maybe_size: Option<InputDefinitionSize>

item_definition: Box<InputDefinitionType>

Enum

Fields

item_list: Vec<Input>

Either

Fields

item_definition_list: Vec<InputDefinitionType>

Implementations

impl InputDefinitionType

pub fn any() -> Self

pub fn is_any(&self) -> bool

impl InputDefinitionType

pub fn boolean() -> Self

pub fn is_boolean(&self) -> bool

impl InputDefinitionType

pub fn integer() -> Self

pub fn is_integer(&self) -> bool

pub fn maybe_integer_range(&self) -> Option<&InputDefinitionRangeInteger>

pub fn maybe_integer_range_mut( &mut self ) -> &mut Option<InputDefinitionRangeInteger>

pub fn set_integer_range<T: Into<InputDefinitionRangeInteger>>( &mut self, range: T )

pub fn with_integer_range<T: Into<InputDefinitionRangeInteger>>( self, range: T ) -> Self

impl InputDefinitionType

pub fn float() -> Self

pub fn is_float(&self) -> bool

pub fn maybe_float_range(&self) -> Option<&InputDefinitionRangeFloat>

pub fn maybe_float_range_mut( &mut self ) -> &mut Option<InputDefinitionRangeFloat>

pub fn set_float_range<T: Into<InputDefinitionRangeFloat>>(&mut self, range: T)

pub fn with_float_range<T: Into<InputDefinitionRangeFloat>>( self, range: T ) -> Self

impl InputDefinitionType

pub fn string() -> Self

pub fn is_string(&self) -> bool

pub fn maybe_string_size(&self) -> Option<&InputDefinitionSize>

pub fn maybe_string_size_mut(&mut self) -> &mut Option<InputDefinitionSize>

pub fn set_string_size<T: Into<InputDefinitionSize>>(&mut self, size: T)

pub fn with_string_size<T: Into<InputDefinitionSize>>(self, size: T) -> Self

impl InputDefinitionType

pub fn list() -> Self

pub fn is_list(&self) -> bool

pub fn list_item_definition(&self) -> &InputDefinitionType

pub fn list_item_definition_mut(&mut self) -> &mut InputDefinitionType

pub fn set_list_item_definition<T: Into<InputDefinitionType>>( &mut self, definition: T )

pub fn with_list_item_definition<T: Into<InputDefinitionType>>( self, definition: T ) -> Self

pub fn maybe_list_size(&self) -> Option<&InputDefinitionSize>

pub fn maybe_list_size_mut(&mut self) -> &mut Option<InputDefinitionSize>

pub fn set_list_size<T: Into<InputDefinitionSize>>(&mut self, size: T)

pub fn with_list_size<T: Into<InputDefinitionSize>>(self, size: T) -> Self

impl InputDefinitionType

pub fn static_map() -> Self

pub fn is_static_map(&self) -> bool

pub fn static_map_definitions(&self) -> &HashMap<String, InputDefinition>

pub fn static_map_definitions_mut( &mut self ) -> &mut HashMap<String, InputDefinition>

pub fn set_static_map_definition<K: Into<String>, V: Into<InputDefinition>>( &mut self, key: K, definition: V )

pub fn with_static_map_definition<K: Into<String>, V: Into<InputDefinition>>( self, key: K, definition: V ) -> Self

impl InputDefinitionType

pub fn dynamic_map() -> Self

pub fn is_dynamic_map(&self) -> bool

pub fn dynamic_map_item_definition(&self) -> &InputDefinitionType

pub fn dynamic_map_item_definition_mut(&mut self) -> &mut InputDefinitionType

pub fn set_dynamic_map_item_definition<T: Into<InputDefinitionType>>( &mut self, definition: T )

pub fn with_dynamic_map_item_definition<T: Into<InputDefinitionType>>( self, definition: T ) -> Self

pub fn maybe_dynamic_map_size(&self) -> Option<&InputDefinitionSize>

pub fn maybe_dynamic_map_size_mut(&mut self) -> Option<&mut InputDefinitionSize>

pub fn set_dynamic_map_size<T: Into<InputDefinitionSize>>(&mut self, size: T)

pub fn with_dynamic_map_size<T: Into<InputDefinitionSize>>( self, size: T ) -> Self

impl InputDefinitionType

pub fn enum_() -> Self

pub fn is_enum(&self) -> bool

pub fn enum_item_list(&self) -> &Vec<Input>

pub fn enum_item_list_mut(&mut self) -> &mut Vec<Input>

pub fn set_enum_item_list<T: Into<Input>>(&mut self, item_list: Vec<T>)

pub fn with_enum_item_list<T: Into<Input>>(self, item_list: Vec<T>) -> Self

pub fn set_enum_item<T: Into<Input>>(&mut self, item: T)

pub fn with_enum_item<T: Into<Input>>(self, item: T) -> Self

impl InputDefinitionType

pub fn either() -> Self

pub fn is_either(&self) -> bool

pub fn either_definition_list(&self) -> &Vec<InputDefinitionType>

pub fn either_definition_list_mut(&mut self) -> &mut Vec<InputDefinitionType>

pub fn set_either_definition_list<T: Into<InputDefinitionType>>( &mut self, definition_list: Vec<T> )

pub fn with_either_definition_list<T: Into<InputDefinitionType>>( self, definition_list: Vec<T> ) -> Self

pub fn set_either_definition<T: Into<InputDefinitionType>>(&mut self, item: T)

pub fn with_either_definition<T: Into<InputDefinitionType>>( self, item: T ) -> Self

Trait Implementations

impl Clone for InputDefinitionType

fn clone(&self) -> InputDefinitionType

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for InputDefinitionType

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

Formats the value using the given formatter.

impl Default for InputDefinitionType

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for InputDefinitionType

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for InputDefinitionType

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

Formats the value using the given formatter.

impl PartialEq<InputDefinitionType> for InputDefinitionType

fn eq(&self, other: &InputDefinitionType) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for InputDefinitionType

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for InputDefinitionType