Enum DynamicValue 

pub enum DynamicValue {
    Bool(bool),
    Byte(u8),
    Int8(i8),
    UInt8(u8),
    Int16(i16),
    UInt16(u16),
    Int32(i32),
    UInt32(u32),
    Int64(i64),
    UInt64(u64),
    Float32(f32),
    Float64(f64),
    Char8(u8),
    Char16(u16),
    String(String),
    WString(Vec<u16>),
    Complex(Box<DynamicData>),
    Sequence(Vec<DynamicData>),
    Map(Vec<(DynamicData, DynamicData)>),
    None,
}

Sum type for all values storable in DynamicData. Spec §7.5.6 speaks of 12 primitive types + composite + sequence — this enum encapsulates the storage.

Variants

Bool(bool)

bool.

Byte(u8)

8-bit unsigned (octet).

Int8(i8)

int8.

UInt8(u8)

uint8.

Int16(i16)

int16.

UInt16(u16)

uint16.

Int32(i32)

int32.

UInt32(u32)

uint32.

Int64(i64)

int64.

UInt64(u64)

uint64.

Float32(f32)

float.

Float64(f64)

double.

Char8(u8)

char.

Char16(u16)

wchar.

String(String)

string.

WString(Vec<u16>)

wstring (UTF-16 as Vec).

Complex(Box<DynamicData>)

Composite or sequence — embedded DynamicData.

Sequence(Vec<DynamicData>)

Sequence of DynamicData (spec: the element type is known from the containerizing TypeDescriptor).

Map(Vec<(DynamicData, DynamicData)>)

map<K,V> — ordered key→value entries. Each key/value is a DynamicData (a scalar wrapped under member id 0, or a composite aggregate), matching how sequence elements are stored. Entry order mirrors the wire order.

None

Discard / not set (the default value is returned).

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 PartialEq for DynamicValue

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