Enum Distributed 

pub enum Distributed {
    Null,
    Bool(bool),
    I64(Le<i64>),
    U64(Le<u64>),
    F64(Le<f64>),
    String(Point<String>),
    Array(Point<Vec<Self>>),
    Object(Point<BTreeMap<LpString, Self>>),
}

Available on crate feature distributed only.

Variants

Null

Bool(bool)

I64(Le<i64>)

U64(Le<u64>)

F64(Le<f64>)

String(Point<String>)

Array(Point<Vec<Self>>)

Object(Point<BTreeMap<LpString, Self>>)

Implementations

impl Distributed

pub async fn to_value(&self) -> Result<Value>

Trait Implementations

impl Clone for Distributed

fn clone(&self) -> Distributed

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Default for Distributed

fn default() -> Distributed

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Distributed

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Enum for Distributed

type Kind = __Kind

Discriminant uniquely identifying this enum’s variants.

fn kind(&self) -> Self::Kind

Get the EnumKind of this variant.

impl<__I: PointInput<Extra: Send + Sync + Clone>> EnumParse<__I> for Distributed

where bool: Parse<__I> + Object<__I::Extra>, Le<i64>: Parse<__I> + Object<__I::Extra>, Le<u64>: Parse<__I> + Object<__I::Extra>, Le<f64>: Parse<__I> + Object<__I::Extra>, Point<String>: Parse<__I> + Object<__I::Extra>,

fn enum_parse(kind: <Self as Enum>::Kind, input: __I) -> Result<Self>

Given an already-parsed EnumKind, parse the rest of a Parse Enum.

fn parse_as_enum(input: I) -> Result<Self, Error>

where <Self::Kind as EnumKind>::Tag: ParseInline<I>,

For implementing Parse::parse.

impl<__I: PointInput<Extra: Send + Sync>> EnumParseInline<__I> for Distributed

where bool: ParseInline<__I> + Inline<__I::Extra>, Le<i64>: ParseInline<__I> + Inline<__I::Extra>, Le<u64>: ParseInline<__I> + Inline<__I::Extra>, Le<f64>: ParseInline<__I> + Inline<__I::Extra>, Point<String>: ParseInline<__I> + Inline<__I::Extra>,

fn enum_parse_inline( kind: <Self as Enum>::Kind, input: &mut __I, ) -> Result<Self>

Given an already-parsed EnumKind, parse the rest of a ParseInline Enum.

fn parse_as_inline_enum(input: &mut I) -> Result<Self, Error>

where <Self::Kind as EnumKind>::Tag: ParseInline<I>,

For implementing ParseInline::parse_inline.

impl InlineOutput for Distributed

where bool: InlineOutput, Le<i64>: InlineOutput, Le<u64>: InlineOutput, Le<f64>: InlineOutput, Point<String>: InlineOutput, Point<Vec<Self>>: InlineOutput, Point<BTreeMap<LpString, Self>>: InlineOutput,

fn slice_to_output(slice: &[Self], output: &mut (impl Output + ?Sized))

where Self: Sized,

Specialisation point to allow types like u8 to provide better serialisation implementation for containers like Vec<u8>.

impl ListHashes for Distributed

fn list_hashes(&self, visitor: &mut (impl ?Sized + FnMut(Hash)))

[Hash]-only part of Topological::traverse.

fn topology_hash(&self) -> Hash

[Hash] of all [Hash]es the object refers to other objects by.

fn point_count(&self) -> usize

How many others this object refers to.

impl MaybeHasNiche for Distributed

type MnArray = <<Distributed as Enum>::Kind as MaybeHasNiche>::MnArray

Should implement MnArray. Not constraint explicitly, because that breaks things.

impl<__I: PointInput<Extra: Send + Sync + Clone>> Parse<__I> for Distributed

where bool: Parse<__I> + Object<__I::Extra>, Le<i64>: Parse<__I> + Object<__I::Extra>, Le<u64>: Parse<__I> + Object<__I::Extra>, Le<f64>: Parse<__I> + Object<__I::Extra>, Point<String>: Parse<__I> + Object<__I::Extra>,

fn parse(input: __I) -> Result<Self>

Parse consuming the whole stream.

impl<__I: PointInput<Extra: Send + Sync>> ParseInline<__I> for Distributed

where bool: ParseInline<__I> + Inline<__I::Extra>, Le<i64>: ParseInline<__I> + Inline<__I::Extra>, Le<u64>: ParseInline<__I> + Inline<__I::Extra>, Le<f64>: ParseInline<__I> + Inline<__I::Extra>, Point<String>: ParseInline<__I> + Inline<__I::Extra>,

fn parse_inline(input: &mut __I) -> Result<Self>

Parse without consuming the whole stream. Errors on unexpected EOF.

fn parse_as_inline(input: I) -> Result<Self, Error>

For implementing Parse::parse.

fn parse_vec(input: I) -> Result<Vec<Self>, Error>

Parse a Vec of Self. Customisable for optimisations.

fn parse_vec_n(input: &mut I, n: usize) -> Result<Vec<Self>, Error>

Parse a Vec of Self of length n. Customisable for optimisations.

fn parse_array<const N: usize>(input: &mut I) -> Result<[Self; N], Error>

Parse an array of Self. Customisable for optimisations.

fn parse_generic_array<N>(input: &mut I) -> Result<GenericArray<Self, N>, Error>

where N: ArrayLength,

Parse a GenericArray of Self. Customisable for optimisations.

impl Serialize for Distributed

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Tagged for Distributed

const TAGS: Tags = _

const HASH: Hash = _

impl ToOutput for Distributed

fn to_output(&self, output: &mut (impl ?Sized + Output))

Provide object’s byte representation to an Output.

fn hasher(&self) -> Sha256

Return a Sha256 hasher pre-filled with data of this object.

fn data_hash(&self) -> Hash

[Hash] of (real, i.e. serialized) data of this object.

fn mangle_hash(&self) -> Hash

“Mangle hash” of the object. This is used to introduce runtime distinction between data-identical objects similarly to compile-time Tagged::HASH.

fn output<T>(&self) -> T

where T: FromOutput, <T as FromOutput>::Output: Default,

Construct an Output, possibly finalising it afterwards.

fn vec(&self) -> Vec<u8>

Collect this object’s data (serialize the object).

impl Topological for Distributed

where Self: ToOutput + Tagged,

fn traverse(&self, visitor: &mut (impl ?Sized + PointVisitor))

List what objects this one refers to.

fn topology(&self) -> Vec<Arc<dyn Singular>>

Collect references into a dynamically-typed list.

fn byte_node(&self) -> (Vec<u8>, Arc<dyn Resolve>)

where Self: ToOutput,

Useful in Resolve::resolve and FetchBytes::fetch_bytes.

fn to_resolve(&self) -> Arc<dyn Resolve>

Reconstruct a Resolve usable for Parse::parseing this object based on references.

impl TryFrom<Value> for Distributed

type Error = DistributedParseError

The type returned in the event of a conversion error.

fn try_from(value: Value) -> Result<Self, Self::Error>

Performs the conversion.