Enum expry::DecodedValue

source ·

pub enum DecodedValue<'a> {
    Null,
    Bool(bool),
    Int(i64),
    Float(f32),
    Double(f64),
    String(&'a [u8]),
    Array(DecodedArray<'a>),
    Object(DecodedObject<'a>),
}

Expand description

The central data type of expry. It is modelled similar to JSON, however, contains a couple of noteworthy differences.

The differences with JSON:

There is an explicit integer type;
Floats are either 32-bits or 64-bits;
All strings are u8: they can contain both text or binary data.

To convert DecodedValue to JSON, one can use the formatting options like:

use expry::*;
let value = value!({"foo": 42});
let output = format!("JSON output: {}", value);
assert_eq!(output, r#"JSON output: {"foo":42}"#);

Variants§

§

Null

§

Bool(bool)

§

Int(i64)

Signed 64-bits integer (that is packed into smaller value in the wire format if possible).

§

Float(f32)

32-bits float type.

§

Double(f64)

64-bits float type.

§

String(&'a [u8])

Can be both binary data as regular strings. So not necessary UTF-8 (like Rust strings).

§

Implementations§

source §

pub fn size_of_binary(&self) -> usize

Returns the size needed if we serialize the Binary to a binary wire-format. See DecodedValue::print_binary() for explanation of the compact argument.

source

pub fn print_binary<E, Out: RawOutput<E>>( &self, writer: &mut Out ) -> Result<(), E>

Converts a Binary to a wire representation of that Binary. This wire representation can be sent to other implementations as it is stable and ‘endian safe’.

For objects we have a compact representation and one that inserts hints how to process the wire-representation faster when using an expression to evaluate the Binary to another value. This is controlled with the compact argument.

This function expects that the writer has enough room. The needed room can be queried beforehand by using the DecodedValue::size_of_binary.

source

pub fn encode_to_vec(&self) -> EncodedValueVec

Converts a Binary to a wire representation of that Binary, in a self contained EncodedValueVec unsing DecodedValue::print_binary.

source

pub fn encode_to_scope<'c>( &self, scope: &mut MemoryScope<'c> ) -> EncodedValueRef<'c>

Converts a Binary to a wire representation of that Binary, in a self contained EncodedValueVec unsing DecodedValue::print_binary.

source

pub fn print_json(&self, writer: &mut String) -> Result<(), Utf8Error>

Convert a Binary value to a JSON output.

Note that some Binary values can not be encoded, because not all strings can be encoded as UTF-8. If this is the case, this method will result in a Utf8Error. If non-UTF8 data needs to be ignored, use format!("{}", decoded_value) or similar methods.

source

pub fn easy(&'a self) -> Easy<'a>

source §

impl<'a> DecodedValue<'a>

source

pub fn decoded_type_of(type_and_length: u64) -> Result<ValueType, EncodingError>

source

pub const fn type_of_binary(type_and_length: u64) -> u8

Based on a variable length integer read for the wire, return the ValueType raw number.

source

pub const fn length_of_binary(type_and_length: u64) -> usize

Based on a variable length integer read for the wire, return the length of the current entry.

source

pub fn decoded_type_and_length( type_and_length: u64 ) -> Result<(ValueType, usize), EncodingError>

source

pub fn decode<'b>( reader: &mut RawReader<'a> ) -> Result<DecodedValue<'b>, EncodingError>
where 'a: 'b,

Parse the wire-format. Note that although the input is malformed, it can still work out (keys of objects are not properly sorted, will not have an impact).

source