Struct Value 

pub struct Value<'val, 'ty>(/* private fields */)
where
    'ty: 'val;

A container for a type-erased value.

Value is, in essence, a smart-pointer that can hold any reflected type. It is slightly larger than a standard fat-pointer, since it contains metadata about the type it contains.

Implementations

impl<'val, 'ty> Value<'val, 'ty>

pub fn from_vec(s: &'val (dyn VecInstance<'ty> + 'ty)) -> Value<'val, 'ty>

Creates a Value from a reflected Vec

pub fn from_struct(s: &'val (dyn StructInstance<'ty> + 'ty)) -> Value<'val, 'ty>

Creates a Value from a reflected struct

pub fn from_enum(s: &'val (dyn EnumInstance<'ty> + 'ty)) -> Value<'val, 'ty>

Creates a Value from a reflected enum

pub fn from_option(s: &'val (dyn OptionInstance<'ty> + 'ty)) -> Value<'val, 'ty>

Creates a Value from a reflected option

pub fn borrow<'b, T: FromValue<'val, 'ty>>(&'b self) -> Option<T>

where 'val: 'b, 'ty: 'b,

Borrows the value as an underlying type. This will return None, when the runtime type-check fails

pub fn into<T: FromValue<'val, 'ty> + 'ty>(self) -> Option<T>

Consumes the Value and returns the internal T.

This only works for types that implement FromValue, which are generally primitives that implement Copy.

pub fn as_reflected_vec(&self) -> Option<&'val (dyn VecInstance<'ty> + 'ty)>

Attempts to cast Value to a VecInstance

pub fn as_reflected_struct( &self, ) -> Option<&'val (dyn StructInstance<'ty> + 'ty)>

Attempts to cast Value to a StructInstance

pub fn as_reflected_enum(&'val self) -> Option<&(dyn EnumInstance<'ty> + 'ty)>

Attempts to cast Value to a EnumInstance

pub fn as_reflected_option( &'val self, ) -> Option<&(dyn OptionInstance<'ty> + 'ty)>

Attempts to cast Value to a OptionInstance

pub fn to_owned(&self) -> OwnedValue<'ty>

Clones the underlying value, and returns a OwnedValue

pub fn try_hash<H: Hasher>(&self, hasher: H) -> Option<u64>

Attempts to has the Value, only returning a value if the underlying type is hashable

pub fn slow_eq<'c, 'd>(&self, r: &Value<'c, 'd>) -> bool

Checks if two Values are equal.

This is slower than the implementations in PartialEq, but it works with Values of different lifetimes. It is slower, because it is implemented using reflection calls, rather than downcasting.

Trait Implementations

impl<'val, 'ty> Clone for Value<'val, 'ty>

where 'ty: 'val,

fn clone(&self) -> Value<'val, 'ty>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Value<'_, '_>

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

Formats the value using the given formatter.

impl<'val, 'ty> From<&'val Bytes> for Value<'val, 'ty>

fn from(bytes: &'val Bytes) -> Self

Converts to this type from the input type.

impl<'val, 'ty> From<Value<'val, 'ty>> for CowValue<'val, 'ty>

fn from(v: Value<'val, 'ty>) -> Self

Converts to this type from the input type.

impl PartialEq for Value<'_, '_>

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.