Struct Inline 

#[repr(transparent)]
pub struct Inline<T: InlineEncoding> {
    pub raw: RawInline,
    /* 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 inlineencodings::R256;
use num_rational::Ratio;

let ratio = Ratio::new(1, 2);
let value: Inline<R256> = R256::inline_from(ratio);
let ratio2: Ratio<i128> = value.try_from_inline().unwrap();
assert_eq!(ratio, ratio2);

Fields

raw: RawInline

The 32-byte representation of this value.

Implementations

impl<S: InlineEncoding> Inline<S>

pub fn new(value: RawInline) -> Self

Create a new value from a 32-byte array.

Example

use triblespace_core::inline::{Inline, InlineEncoding};
use triblespace_core::inline::encodings::UnknownInline;

let bytes = [0; 32];
let value = Inline::<UnknownInline>::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) -> Inline<O>

where O: InlineEncoding,

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) -> &Inline<O>

where O: InlineEncoding,

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: &RawInline) -> &Self

Transmute a raw value reference to a value reference.

Example

use triblespace_core::inline::{Inline, InlineEncoding};
use triblespace_core::inline::encodings::UnknownInline;
use std::borrow::Borrow;

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

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

where T: TryFromInline<'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 Inline::try_from_inline method.

Example

use triblespace_core::prelude::*;
use inlineencodings::F64;

let value: Inline<F64> = (3.14f64).to_inline();
let concrete: f64 = value.from_inline();

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

where T: TryFromInline<'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 Inline::from_inline method.

Example

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

let value: Inline<R256> = R256::inline_from(Ratio::new(1, 2));
let concrete: Result<Ratio<i128>, _> = value.try_from_inline();

Trait Implementations

impl<S> AsRef<Inline<Handle<S>>> for Blob<S>

where S: BlobEncoding, Handle<S>: InlineEncoding,

Blob<S> borrows as the Inline<Handle<S>> that references it.

Models the heavy/lightweight duality at the type system level: a Blob<S> IS a content-addressed value, and its Handle<S> is the 32-byte reference form. Coercing a &Blob<S> to a &Inline<Handle<S>> is free — the handle is stored as a field — so code that wants to pass the lightweight reference around (e.g. inserting into a trible, sending over the network) can just blob.as_ref() instead of &blob.get_handle().

fn as_ref(&self) -> &Inline<Handle<S>>

Converts this type into a shared reference of the (usually inferred) input type.

impl<S: InlineEncoding> Borrow<[u8; 32]> for Inline<S>

fn borrow(&self) -> &RawInline

Immutably borrows from an owned value.

impl<T: InlineEncoding> Clone for Inline<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: InlineEncoding> Debug for Inline<T>

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

Formats the value using the given formatter.

impl<T: BlobEncoding> From<Inline<Handle<T>>> for Inline<Hash<Blake3>>

fn from(value: Inline<Handle<T>>) -> Self

Converts to this type from the input type.

impl<T: BlobEncoding> From<Inline<Hash<Blake3>>> for Inline<Handle<T>>

fn from(value: Inline<Hash<Blake3>>) -> Self

Converts to this type from the input type.

impl<T: InlineEncoding> Hash for Inline<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: InlineEncoding> IntoBytes for Inline<T>

where RawInline: 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: InlineEncoding> KnownLayout for Inline<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: InlineEncoding> Ord for Inline<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: InlineEncoding> PartialEq for Inline<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: InlineEncoding> PartialOrd for Inline<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<V: InlineEncoding> ToEncoded<V> for Inline<V>

fn to_encoded(self) -> Encoded<V>

Produce the Encoded the macro absorbs.

impl<T: InlineEncoding> TryFromBytes for Inline<T>

where RawInline: 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: InlineEncoding> TryFromInline<'a, S> for Inline<S>

type Error = Infallible

The error type returned when the conversion fails.

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

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

impl<T: InlineEncoding> Copy for Inline<T>

impl<T: InlineEncoding> Eq for Inline<T>

impl<T: InlineEncoding> Immutable for Inline<T>

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

impl<T: InlineEncoding> Unaligned for Inline<T>

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