Struct Value 

#[repr(transparent)]
pub struct Value<T: ValueSchema> {
    pub raw: RawValue,
    /* private fields */
}

A value is a 32-byte array that can be (de)serialized as a Rust type. The schema type parameter is an abstract type that represents the meaning and valid bit patterns of the bytes.

Example

use triblespace_core::prelude::*;
use valueschemas::R256;
use num_rational::Ratio;

let ratio = Ratio::new(1, 2);
let value: Value<R256> = R256::value_from(ratio);
let ratio2: Ratio<i128> = value.try_from_value().unwrap();
assert_eq!(ratio, ratio2);

Fields

raw: RawValue

The 32-byte representation of this value.

Implementations

impl<S: ValueSchema> Value<S>

pub fn new(value: RawValue) -> Self

Create a new value from a 32-byte array.

Example

use triblespace_core::value::{Value, ValueSchema};
use triblespace_core::value::schemas::UnknownValue;

let bytes = [0; 32];
let value = Value::<UnknownValue>::new(bytes);

pub fn validate(self) -> Result<Self, S::ValidationError>

Validate this value using its schema.

pub fn is_valid(&self) -> bool

Check if this value conforms to its schema.

pub fn transmute<O>(self) -> Value<O>

where O: ValueSchema,

Transmute a value from one schema type to another. This is a safe operation, as the bytes are not changed. The schema type is only changed in the type system. This is a zero-cost operation. This is useful when you have a value with an abstract schema type, but you know the concrete schema type.

pub fn as_transmute<O>(&self) -> &Value<O>

where O: ValueSchema,

Transmute a value reference from one schema type to another. This is a safe operation, as the bytes are not changed. The schema type is only changed in the type system. This is a zero-cost operation. This is useful when you have a value reference with an abstract schema type, but you know the concrete schema type.

pub fn as_transmute_raw(value: &RawValue) -> &Self

Transmute a raw value reference to a value reference.

Example

use triblespace_core::value::{Value, ValueSchema};
use triblespace_core::value::schemas::UnknownValue;
use std::borrow::Borrow;

let bytes = [0; 32];
let value: Value<UnknownValue> = Value::new(bytes);
let value_ref: &Value<UnknownValue> = &value;
let raw_value_ref: &[u8; 32] = value_ref.borrow();
let value_ref2: &Value<UnknownValue> = Value::as_transmute_raw(raw_value_ref);
assert_eq!(&value, value_ref2);

pub fn from_value<'a, T>(&'a self) -> T

where T: TryFromValue<'a, S, Error = Infallible>,

Deserialize a value with an abstract schema type to a concrete Rust type.

This method only works for infallible conversions (where Error = Infallible). For fallible conversions, use the Value::try_from_value method.

Example

use triblespace_core::prelude::*;
use valueschemas::F64;

let value: Value<F64> = (3.14f64).to_value();
let concrete: f64 = value.from_value();

pub fn try_from_value<'a, T>( &'a self, ) -> Result<T, <T as TryFromValue<'a, S>>::Error>

where T: TryFromValue<'a, S>,

Deserialize a value with an abstract schema type to a concrete Rust type.

This method returns an error if the conversion is not possible. This might happen if the bytes are not valid for the schema type or if the rust type can’t represent the specific value of the schema type, e.g. if the schema type is a fractional number and the rust type is an integer.

For infallible conversions, use the Value::from_value method.

Example

use triblespace_core::prelude::*;
use valueschemas::R256;
use num_rational::Ratio;

let value: Value<R256> = R256::value_from(Ratio::new(1, 2));
let concrete: Result<Ratio<i128>, _> = value.try_from_value();

Trait Implementations

impl<S: ValueSchema> Borrow<[u8; 32]> for Value<S>

fn borrow(&self) -> &RawValue

Immutably borrows from an owned value.

impl<T: ValueSchema> Clone for Value<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: ValueSchema> Debug for Value<T>

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

Formats the value using the given formatter.

impl<H: HashProtocol, T: BlobSchema> From<Value<Handle<H, T>>> for Value<Hash<H>>

fn from(value: Value<Handle<H, T>>) -> Self

Converts to this type from the input type.

impl<H: HashProtocol, T: BlobSchema> From<Value<Hash<H>>> for Value<Handle<H, T>>

fn from(value: Value<Hash<H>>) -> Self

Converts to this type from the input type.

impl<T: ValueSchema> Hash for Value<T>

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<T: ValueSchema> IntoBytes for Value<T>

where RawValue: IntoBytes, PhantomData<T>: IntoBytes,

fn as_bytes(&self) -> &[u8]

where Self: Immutable,

Gets the bytes of this value.

fn write_to(&self, dst: &mut [u8]) -> Result<(), SizeError<&Self, &mut [u8]>>

where Self: Immutable,

Writes a copy of self to dst.

fn write_to_prefix( &self, dst: &mut [u8], ) -> Result<(), SizeError<&Self, &mut [u8]>>

where Self: Immutable,

Writes a copy of self to the prefix of dst.

fn write_to_suffix( &self, dst: &mut [u8], ) -> Result<(), SizeError<&Self, &mut [u8]>>

where Self: Immutable,

Writes a copy of self to the suffix of dst.

impl<T: ValueSchema> KnownLayout for Value<T>

where Self: Sized,

type PointerMetadata = ()

The type of metadata stored in a pointer to Self.

fn size_for_metadata(meta: Self::PointerMetadata) -> Option<usize>

Computes the size of an object of type Self with the given pointer metadata.

impl<T: ValueSchema> Ord for Value<T>

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<T: ValueSchema> PartialEq for Value<T>

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.

impl<T: ValueSchema> PartialOrd for Value<T>

fn partial_cmp(&self, other: &Self) -> 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<S: ValueSchema> ToValue<S> for &Value<S>

fn to_value(self) -> Value<S>

Convert the Rust type to a Value with a specific schema type. This might cause a panic if the conversion is not possible.

impl<S: ValueSchema> ToValue<S> for Value<S>

fn to_value(self) -> Value<S>

Convert the Rust type to a Value with a specific schema type. This might cause a panic if the conversion is not possible.

impl<T: ValueSchema> TryFromBytes for Value<T>

where RawValue: TryFromBytes, PhantomData<T>: TryFromBytes,

fn try_ref_from_bytes( source: &[u8], ) -> Result<&Self, ConvertError<AlignmentError<&[u8], Self>, SizeError<&[u8], Self>, ValidityError<&[u8], Self>>>

where Self: KnownLayout + Immutable,

Attempts to interpret the given source as a &Self.

fn try_ref_from_prefix( source: &[u8], ) -> Result<(&Self, &[u8]), ConvertError<AlignmentError<&[u8], Self>, SizeError<&[u8], Self>, ValidityError<&[u8], Self>>>

where Self: KnownLayout + Immutable,

Attempts to interpret the prefix of the given source as a &Self.

fn try_ref_from_suffix( source: &[u8], ) -> Result<(&[u8], &Self), ConvertError<AlignmentError<&[u8], Self>, SizeError<&[u8], Self>, ValidityError<&[u8], Self>>>

where Self: KnownLayout + Immutable,

Attempts to interpret the suffix of the given source as a &Self.

fn try_mut_from_bytes( bytes: &mut [u8], ) -> Result<&mut Self, ConvertError<AlignmentError<&mut [u8], Self>, SizeError<&mut [u8], Self>, ValidityError<&mut [u8], Self>>>

where Self: KnownLayout + IntoBytes,

Attempts to interpret the given source as a &mut Self without copying.

fn try_mut_from_prefix( source: &mut [u8], ) -> Result<(&mut Self, &mut [u8]), ConvertError<AlignmentError<&mut [u8], Self>, SizeError<&mut [u8], Self>, ValidityError<&mut [u8], Self>>>

where Self: KnownLayout + IntoBytes,

Attempts to interpret the prefix of the given source as a &mut Self.

fn try_mut_from_suffix( source: &mut [u8], ) -> Result<(&mut [u8], &mut Self), ConvertError<AlignmentError<&mut [u8], Self>, SizeError<&mut [u8], Self>, ValidityError<&mut [u8], Self>>>

where Self: KnownLayout + IntoBytes,

Attempts to interpret the suffix of the given source as a &mut Self.

fn try_read_from_bytes( source: &[u8], ) -> Result<Self, ConvertError<Infallible, SizeError<&[u8], Self>, ValidityError<&[u8], Self>>>

where Self: Sized,

Attempts to read the given source as a Self.

fn try_read_from_prefix( source: &[u8], ) -> Result<(Self, &[u8]), ConvertError<Infallible, SizeError<&[u8], Self>, ValidityError<&[u8], Self>>>

where Self: Sized,

Attempts to read a Self from the prefix of the given source.

fn try_read_from_suffix( source: &[u8], ) -> Result<(&[u8], Self), ConvertError<Infallible, SizeError<&[u8], Self>, ValidityError<&[u8], Self>>>

where Self: Sized,

Attempts to read a Self from the suffix of the given source.

impl<'a, S: ValueSchema> TryFromValue<'a, S> for Value<S>

type Error = Infallible

The error type returned when the conversion fails.

fn try_from_value(v: &'a Value<S>) -> Result<Self, Infallible>

Convert the Value with a specific schema type to the Rust type.

impl<T: ValueSchema> Copy for Value<T>

impl<T: ValueSchema> Eq for Value<T>

impl<T: ValueSchema> Immutable for Value<T>

where RawValue: Immutable, PhantomData<T>: Immutable,

impl<T: ValueSchema> Unaligned for Value<T>

where RawValue: Unaligned, PhantomData<T>: Unaligned,