Enum Variable 

pub enum Variable {
    Null,
    I8(i8),
    I16(i16),
    I32(i32),
    I64(i64),
    U8(u8),
    U16(u16),
    U32(u32),
    U64(u64),
    F32(f32),
    F64(f64),
    Bool(bool),
    Char(char),
    String(String),
    List(Vec<Variable>),
}

Represents a dynamically typed value that can be passed between plugins.

Variable is the core data type used for communication between plugins and the host. It supports all common data types and provides type-safe conversion methods.

Variants

• Null - Represents a null/empty value (default)
• I8, I16, I32, I64 - Signed integer types
• U8, U16, U32, U64 - Unsigned integer types
• F32, F64 - Floating point types
• Bool - Boolean values
• Char - Unicode characters
• String - UTF-8 strings
• List - Lists/arrays of variables

Examples

use plux_rs::variable::Variable;

// Create variables of different types
let num = Variable::I32(42);
let text = Variable::String("Hello".to_string());
let flag = Variable::Bool(true);
let list = Variable::List(vec![num, text, flag]);

// Convert from Rust types
let var1: Variable = 42_i32.into();
let var2: Variable = "hello".into();
let var3: Variable = vec![1, 2, 3].into();

Variants

Null

Null/empty value

I8(i8)

8-bit signed integer

I16(i16)

16-bit signed integer

I32(i32)

32-bit signed integer

I64(i64)

64-bit signed integer

U8(u8)

8-bit unsigned integer

U16(u16)

16-bit unsigned integer

U32(u32)

32-bit unsigned integer

U64(u64)

64-bit unsigned integer

F32(f32)

32-bit floating point

F64(f64)

64-bit floating point

Bool(bool)

Boolean value

Char(char)

Unicode character

String(String)

UTF-8 string

List(Vec<Variable>)

List of variables

Implementations

impl Variable

pub fn is_null(&self) -> bool

Check if the Variable represents a null value.

Returns

Returns true if the Variable is Variable::Null, false otherwise.

Example

use plux_rs::variable::Variable;

let null_var = Variable::Null;
let int_var = Variable::I32(42);

assert!(null_var.is_null());
assert!(!int_var.is_null());

impl Variable

pub fn parse<F>(self) -> F::Output

where F: FromVariable,

Parse the Variable into a specific type (panics on error).

This method converts the Variable to the specified type, panicking if the conversion fails. Use this when you’re certain about the type.

Type Parameters

• F - The target type that implements FromVariable

Returns

Returns the converted value of type F::Output.

Panics

Panics if the Variable cannot be converted to the target type.

Example

use plux_rs::variable::Variable;

let var = Variable::I32(42);
let num: i32 = var.parse::<i32>();
assert_eq!(num, 42);

pub fn parse_ref<F>(&self) -> F::RefOutput<'_>

where F: FromVariable,

Parse the Variable into a specific type by reference (panics on error).

This method converts the Variable to the specified type without consuming it, panicking if the conversion fails.

Type Parameters

• F - The target type that implements FromVariable

Returns

Returns a reference to the converted value of type F::RefOutput<'_>.

Panics

Panics if the Variable cannot be converted to the target type.

pub fn parse_mut<F>(&mut self) -> F::MutOutput<'_>

where F: FromVariable,

Parse the Variable into a specific type by mutable reference (panics on error).

This method converts the Variable to the specified type without consuming it, panicking if the conversion fails.

Type Parameters

• F - The target type that implements FromVariable

Returns

Returns a mutable reference to the converted value of type F::MutOutput<'_>.

Panics

Panics if the Variable cannot be converted to the target type.

pub fn try_parse<F>(self) -> Result<F::Output, ParseVariableError>

where F: FromVariable,

Try to parse the Variable into a specific type.

This method attempts to convert the Variable to the specified type, returning an error if the conversion fails.

Type Parameters

• F - The target type that implements FromVariable

Returns

Returns Result<F::Output, ParseVariableError> containing the converted value or an error if the conversion fails.

Example

use plux_rs::variable::Variable;

let var = Variable::I32(42);
match var.try_parse::<i32>() {
    Ok(num) => println!("Parsed: {}", num),
    Err(e) => println!("Parse error: {}", e),
}

pub fn try_parse_ref<F>(&self) -> Result<F::RefOutput<'_>, ParseVariableError>

where F: FromVariable,

Try to parse the Variable into a specific type by reference.

This method attempts to convert the Variable to the specified type without consuming it, returning an error if the conversion fails.

Type Parameters

• F - The target type that implements FromVariable

Returns

Returns Result<F::RefOutput<'_>, ParseVariableError> containing a reference to the converted value or an error if the conversion fails.

pub fn try_parse_mut<F>( &mut self, ) -> Result<F::MutOutput<'_>, ParseVariableError>

where F: FromVariable,

Try to parse the Variable into a specific type by mutable reference.

This method attempts to convert the Variable to the specified type without consuming it, returning an error if the conversion fails.

Type Parameters

• F - The target type that implements FromVariable

Returns

Returns Result<F::MutOutput<'_>, ParseVariableError> containing a mutable reference to the converted value or an error if the conversion fails.

Trait Implementations

impl Clone for Variable

fn clone(&self) -> Variable

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Variable

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

Formats the value using the given formatter.

impl Default for Variable

fn default() -> Variable

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Variable

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Variable

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

Formats the value using the given formatter.

impl<T> From<&[T]> for Variable

where T: Into<Variable> + Clone,

fn from(x: &[T]) -> Self

Converts to this type from the input type.

impl From<&str> for Variable

fn from(x: &str) -> Self

Converts to this type from the input type.

impl From<String> for Variable

fn from(x: String) -> Self

Converts to this type from the input type.

impl<T> From<Vec<T>> for Variable

where T: Into<Variable>,

fn from(x: Vec<T>) -> Self

Converts to this type from the input type.

impl From<bool> for Variable

fn from(x: bool) -> Self

Converts to this type from the input type.

impl From<char> for Variable

fn from(x: char) -> Self

Converts to this type from the input type.

impl From<f32> for Variable

fn from(x: f32) -> Self

Converts to this type from the input type.

impl From<f64> for Variable

fn from(x: f64) -> Self

Converts to this type from the input type.

impl From<i16> for Variable

fn from(x: i16) -> Self

Converts to this type from the input type.

impl From<i32> for Variable

fn from(x: i32) -> Self

Converts to this type from the input type.

impl From<i64> for Variable

fn from(x: i64) -> Self

Converts to this type from the input type.

impl From<i8> for Variable

fn from(x: i8) -> Self

Converts to this type from the input type.

impl From<u16> for Variable

fn from(x: u16) -> Self

Converts to this type from the input type.

impl From<u32> for Variable

fn from(x: u32) -> Self

Converts to this type from the input type.

impl From<u64> for Variable

fn from(x: u64) -> Self

Converts to this type from the input type.

impl From<u8> for Variable

fn from(x: u8) -> Self

Converts to this type from the input type.

impl PartialEq for Variable

fn eq(&self, other: &Variable) -> 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 PartialOrd for Variable

fn partial_cmp(&self, other: &Variable) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for Variable

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 Variable