Enum Value 

pub enum Value {
    Null,
    Bool(bool),
    Int(i64),
    Float(f64),
    Str(String),
    List(Vec<Value>),
    Map(Map),
    Ref(Ref),
    Bytes(Vec<u8>),
}

The text form has no syntax of its own for the typed values (Ref, Bytes): they’re written as strings ("@file:images/logo.png"), so every file stays JSON, and the schema of a field says what its string means. The binary form keeps the type.

A Str holds a string as spelled: one that starts with @ is a typed value’s spelling, read by the field’s schema (crate::typed::classify), and plain text starting with @ is kept with it doubled ("@@everyone"). Text and binary forms carry it as is; Schema::write of a String doubles the @, its read undoes it.

Variants

Null

Nothing.

Bool(bool)

true or false.

Int(i64)

An integer.

Float(f64)

A number with a fraction or an exponent.

Str(String)

A string, as spelled (a plain one’s leading @ doubled).

List(Vec<Value>)

A list.

Map(Map)

A map, in file order.

Ref(Ref)

@file:images/logo.png — something of some kind, by id.

Bytes(Vec<u8>)

Bytes as they are — a picture, a sound — written @bytes:<base64> as text.

Implementations

impl Value

pub fn borrow<'a>(&'a self, arena: &'a Bump) -> ValueRef<'a>

This value, borrowed (lists and maps in arena) — what schemas read.

impl Value

pub fn kind(&self) -> ValueKind

Which case it is.

pub fn is_null(&self) -> bool

Whether it’s null.

pub fn as_bool(&self) -> Option<bool>

The bool, if it’s one.

pub fn as_i64(&self) -> Option<i64>

The integer, if it’s one (a float with no fraction is).

pub fn as_f64(&self) -> Option<f64>

The number, if it’s one.

pub fn as_str(&self) -> Option<&str>

The string, if it’s one.

pub fn as_list(&self) -> Option<&[Value]>

The list, if it’s one.

pub fn as_map(&self) -> Option<&Map>

The map, if it’s one.

pub fn get(&self, key: &str) -> Option<&Value>

self[key] of a map, None for anything else.

pub fn at(&self, path: &Path) -> Option<&Value>

The value at path.

pub fn at_mut(&mut self, segs: &[Seg]) -> Option<&mut Value>

The value segs lead to, to change.

Trait Implementations

impl Clone for Value

fn clone(&self) -> Value

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<(), Error>

Formats the value using the given formatter.

impl Default for Value

fn default() -> Value

Returns the “default value” for a type.

impl From<&str> for Value

fn from(s: &str) -> Value

Converts to this type from the input type.

impl From<Map> for Value

fn from(m: Map) -> Value

Converts to this type from the input type.

impl From<String> for Value

fn from(s: String) -> Value

Converts to this type from the input type.

impl From<Vec<Value>> for Value

fn from(l: Vec<Value>) -> Value

Converts to this type from the input type.

impl From<bool> for Value

fn from(b: bool) -> Value

Converts to this type from the input type.

impl From<f64> for Value

fn from(f: f64) -> Value

Converts to this type from the input type.

impl From<i64> for Value

fn from(n: i64) -> Value

Converts to this type from the input type.

impl PartialEq for Value

fn eq(&self, other: &Value) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Schema for Value

fn shape() -> Shape

What the format looks like.

fn read(v: &ValueRef<'_>, _: &mut Reader<'_>) -> Option<Value>

Reads v. Problems go to cx at its current path; None when the value couldn’t be read (the problem is in cx).

fn write(&self) -> Value

The value, as the format writes it.

fn write_text(&self, w: &mut Writer)

Writes itself as text, straight (crate::text::Writer) — Schema::write’s value as text, unless the type knows better (derived ones do): no value tree is built on the way.

fn absent() -> Option<Self>

The value of a field that isn’t there — None: the field is required.

fn skip(&self) -> bool

Whether a struct leaves this field out when writing it.

fn encode(&self, w: &mut Writer)

Writes itself in the binary form, straight — Schema::write’s value encoded, unless the type knows better (derived ones do).

fn decode(d: &mut Decoder<'_>) -> Option<Self>

Reads itself from the binary form, straight; None when it isn’t what Schema::encode writes — then read_bytes reads the slow way, which says what’s wrong. Through a value unless the type knows better (derived ones do).

fn pack(&self, p: &mut Packer)

Packs itself into a frame (crate::frame): its binary form as bytes, unless the type packs itself (derived ones and plain types do).

fn unpack(u: &mut Unpacker<'_>) -> Option<Self>

Reads itself out of a frame; None if the bytes aren’t what Schema::pack writes.

fn pack_list(items: &[Self], p: &mut Packer)

A list of these packed: a count, then each one (floats raw).

fn unpack_list(u: &mut Unpacker<'_>) -> Option<Vec<Self>>

A list of these out of a frame.

fn encode_list(items: &[Self], w: &mut Writer)

A list of these written straight (numbers pack theirs).

fn decode_list(d: &mut Decoder<'_>) -> Option<Vec<Self>>

A list of these read straight.

impl StructuralPartialEq for Value