Enum TypeSpecificInfo

pub enum TypeSpecificInfo {
    Enum {
        default: u32,
        values: Vec<String>,
    },
    Numeric {
        default: f32,
        valid_range: RangeInclusive<f32>,
        units: Option<String>,
    },
    Switch {
        default: bool,
    },
}

Contains information specific to a certain type of parameter.

This is an owning version of TypeSpecificInfoRef.

Examples

let enum_info = TypeSpecificInfo::Enum {
  default: 0,
  values: vec!["A".to_string(), "B".to_string(), "C".to_string()],
};
let numeric_info = TypeSpecificInfo::Numeric {
  default: 0.0,
  valid_range: 0.0..=1.0,
  units: None,
};
let switch_info = TypeSpecificInfo::Switch {
  default: false,
};

Variants

Enum

Information specific to an enum parameter.

Fields

default: u32

Index of the default value.

Note that this must be less than the length of values.

values: Vec<String>

A list of possible values for the parameter.

Note that values must contain at least 2 elements.

Numeric

Information specific to a numeric parameter.

Fields

default: f32

The default value of the parameter.

This value must be within the valid_range.

valid_range: RangeInclusive<f32>

The valid range of the parameter.

units: Option<String>

The units of the parameter.

Here an empty string indicates unitless values, while a non-empty string indicates the logical units of a parmater, e.g., “hz”

Switch

Information specific to a switch parameter.

Fields

default: bool

The default value of the parameter.

Trait Implementations

impl Clone for TypeSpecificInfo

fn clone(&self) -> TypeSpecificInfo

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for TypeSpecificInfo

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

Formats the value using the given formatter.

impl<'a> From<&'a TypeSpecificInfo> for TypeSpecificInfoRef<'a, String>

fn from(v: &'a TypeSpecificInfo) -> Self

Converts to this type from the input type.

impl<'a, S: AsRef<str>> From<&'a TypeSpecificInfoRef<'a, S>> for TypeSpecificInfo

fn from(v: &'a TypeSpecificInfoRef<'a, S>) -> Self

Converts to this type from the input type.

impl PartialEq for TypeSpecificInfo

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl StructuralPartialEq for TypeSpecificInfo