Enum polyvalue::InnerValue

pub enum InnerValue {
    Bool(Bool),
    I64(I64),
    Float(Float),
    U8(U8),
    I8(I8),
    U16(U16),
    I16(I16),
    U32(U32),
    I32(I32),
    U64(U64),
    Fixed(Fixed),
    Currency(Currency),
    String(Str),
    Range(Range),
    Array(Array),
    Object(Object),
}

Main value type This is an enum that can hold any of the supported value types

Variants

Bool(Bool)

A boolean value

I64(I64)

An signed 64bit integer value

Float(Float)

A floating-point value

U8(U8)

An unsigned 8bit integer value

I8(I8)

An unsigned 8bit integer value

U16(U16)

An unsigned 16bit integer value

I16(I16)

An signed 16bit integer value

U32(U32)

An unsigned 32bit integer value

I32(I32)

An signed 32bit integer value

U64(U64)

An unsigned 64bit integer value

Fixed(Fixed)

A fixed-point value

Currency(Currency)

A currency value

String(Str)

A string value

Range(Range)

A range value This type will always resolve to array in all comparisons and operations

Array(Array)

An array value

Object(Object)

An object value

Trait Implementations

impl Clone for InnerValue

fn clone(&self) -> InnerValue

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'de> Deserialize<'de> for InnerValue

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<InnerValue> for Value

fn from(inner: InnerValue) -> Value

Converts to this type from the input type.

impl From<Value> for InnerValue

fn from(value: Value) -> InnerValue

Converts to this type from the input type.

impl Hash for InnerValue

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for InnerValue

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Serialize for InnerValue

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for InnerValue

impl StructuralPartialEq for InnerValue