Struct pancake_types::types::SubValueSpec

pub struct SubValueSpec {
    pub member_idxs: Vec<u32>,
    pub datum_type: DatumType,
}

SubValueSpec specifies a contiguous sub-portion of a Value.

The spec is a DSL for locating this sub-portion, as well as an extractor of this sub-portion.

Specification

member_idxs:

• The empty member_idxs specifies the whole Value.
• Each member_idx specifies a member within a Datum::Tuple. A series of member_idxs specifies members within nested Tuples.

datum_type:

• The datum_type equalling DatumType::Tuple specifies the whole (nested) Tuple.

For example, given a tuple-typed Value

Value(
    Datum::Tuple(vec![
        Datum::I64(0),
        Datum::Tuple(vec![
            Datum::I64(1),
            Datum::Str(String::from("2")),
            Datum::Tuple(vec![
                Datum::I64(3),
                Datum::Str(String::from("4")),
            ])
        ])
    ])
)

If you want to specify the Datum::I64(1):

SubValueSpec {
    member_idxs: vec![1, 0],
    datum_type: DatumType::I64,
}

If you want to specify the Datum::Tuple containing data 3 and 4:

SubValueSpec {
    member_idxs: vec![1, 2],
    datum_type: DatumType::Tuple,
}

Fields

member_idxs: Vec<u32>

datum_type: DatumType

Implementations

impl SubValueSpec

pub fn whole(datum_type: DatumType) -> Self

impl SubValueSpec

pub fn extract(&self, pv: &Arc<Value>) -> Option<SVShared>

impl SubValueSpec

pub fn ser<W: Write>(&self, w: &mut W) -> Result<()>

pub fn deser<R: BufRead>(r: &mut R) -> Result<Self>

pub fn ser_solo(&self) -> Result<Vec<u8>>

pub fn deser_solo(buf: &[u8]) -> Result<Self>

Trait Implementations

impl Debug for SubValueSpec

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

Formats the value using the given formatter.

impl Hash for SubValueSpec

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 SubValueSpec

fn eq(&self, other: &SubValueSpec) -> 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 Eq for SubValueSpec

impl StructuralEq for SubValueSpec

impl StructuralPartialEq for SubValueSpec