Enum DynamicValue 

pub enum DynamicValue {
    String(String),
    Integer(i64),
    Float(f64),
    Bool(bool),
    Array(Vec<DynamicValue>),
    Object(HashMap<String, DynamicValue>),
    Null,
}

Dynamic value wrapper that supports Python-like operations

Variants

String(String)

String value

Integer(i64)

Integer value

Float(f64)

Float value

Bool(bool)

Boolean value

Array(Vec<DynamicValue>)

Array value

Object(HashMap<String, DynamicValue>)

Object value

Null

Null value

Implementations

impl DynamicValue

pub fn from_unity_value(value: &UnityValue) -> Self

Convert from UnityValue

pub fn to_unity_value(&self) -> UnityValue

Convert to UnityValue

pub fn as_string(&self) -> Option<&str>

Get as string

pub fn as_integer(&self) -> Option<i64>

Get as integer

pub fn as_float(&self) -> Option<f64>

Get as float

pub fn as_bool(&self) -> Option<bool>

Get as boolean

pub fn as_array(&self) -> Option<&Vec<DynamicValue>>

Get as array

pub fn as_array_mut(&mut self) -> Option<&mut Vec<DynamicValue>>

Get as mutable array

pub fn as_object(&self) -> Option<&HashMap<String, DynamicValue>>

Get as object

pub fn as_object_mut(&mut self) -> Option<&mut HashMap<String, DynamicValue>>

Get as mutable object

pub fn is_null(&self) -> bool

Check if value is null

pub fn get_index(&self, index: usize) -> Option<&DynamicValue>

Array indexing (similar to Python list access)

pub fn get_index_mut(&mut self, index: usize) -> Option<&mut DynamicValue>

Mutable array indexing

pub fn get_property(&self, key: &str) -> Option<&DynamicValue>

Object property access (similar to Python dict access)

pub fn get_property_mut(&mut self, key: &str) -> Option<&mut DynamicValue>

Mutable object property access

pub fn set_property(&mut self, key: String, value: DynamicValue) -> Result<()>

Set object property

pub fn push(&mut self, value: DynamicValue) -> Result<()>

Add to array

pub fn concat_string(&mut self, other: &str) -> Result<()>

String concatenation (Python-like += for strings)

pub fn add_numeric(&mut self, other: f64) -> Result<()>

Numeric addition (Python-like += for numbers)

Trait Implementations

impl Clone for DynamicValue

fn clone(&self) -> DynamicValue

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DynamicValue

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

Formats the value using the given formatter.

impl Display for DynamicValue

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

Formats the value using the given formatter.

impl PartialEq for DynamicValue

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