Enum TypeSpecificInfoRef

pub enum TypeSpecificInfoRef<'a, S> {
    Enum {
        default: u32,
        values: &'a [S],
    },
    Numeric {
        default: f32,
        valid_range: RangeInclusive<f32>,
        units: Option<&'a str>,
    },
    Switch {
        default: bool,
    },
}

Contains information specific to a certain type of parameter.

This is a non-owning reference type, pointing to data with lifetime 'a.

Here the S represents the type of strings, this generally will be either &'a str or String.

Examples

let enum_info = TypeSpecificInfoRef::Enum {
   default: 0,
   values: &["A", "B", "C"],
};

let numeric_info: TypeSpecificInfoRef<'static, &'static str> = TypeSpecificInfoRef::Numeric {
  default: 0.0,
  valid_range: 0.0..=1.0,
  units: None,
};

let switch_info: TypeSpecificInfoRef<'static, &'static str> = TypeSpecificInfoRef::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: &'a [S]

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<&'a str>

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<'a, S: Clone> Clone for TypeSpecificInfoRef<'a, S>

fn clone(&self) -> TypeSpecificInfoRef<'a, S>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a, S: Debug> Debug for TypeSpecificInfoRef<'a, S>

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<'a, S: PartialEq> PartialEq for TypeSpecificInfoRef<'a, S>

fn eq(&self, other: &TypeSpecificInfoRef<'a, S>) -> 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<'a, S> StructuralPartialEq for TypeSpecificInfoRef<'a, S>