Enum ciborium::Value

#[non_exhaustive]
pub enum Value {
    Integer(Integer),
    Bytes(Vec<u8>),
    Float(f64),
    Text(String),
    Bool(bool),
    Null,
    Tag(u64, Box<Value>),
    Array(Vec<Value>),
    Map(Vec<(Value, Value)>),
}

A representation of a dynamic CBOR value that can handled dynamically

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Integer(Integer)

An integer

Bytes(Vec<u8>)

Bytes

Float(f64)

A float

Text(String)

A string

Bool(bool)

A boolean

Null

Null

Tag(u64, Box<Value>)

Tag

Array(Vec<Value>)

An array

Map(Vec<(Value, Value)>)

A map

Implementations

impl Value

pub fn deserialized<'de, T: Deserialize<'de>>(&self) -> Result<T, Error>

Deserializes the Value into an object

impl Value

pub fn serialized<T: ?Sized + Serialize>(value: &T) -> Result<Self, Error>

Serializes an object into a Value

impl Value

pub fn is_integer(&self) -> bool

Returns true if the Value is an Integer. Returns false otherwise.

let value = Value::Integer(17.into());

assert!(value.is_integer());

pub fn as_integer(&self) -> Option<Integer>

If the Value is a Integer, returns a reference to the associated Integer data. Returns None otherwise.

let value = Value::Integer(17.into());

// We can read the number
assert_eq!(17, value.as_integer().unwrap().try_into().unwrap());

pub fn into_integer(self) -> Result<Integer, Self>

If the Value is a Integer, returns a the associated Integer data as Ok. Returns Err(Self) otherwise.

let value = Value::Integer(17.into());
assert_eq!(value.into_integer(), Ok(Integer::from(17)));

let value = Value::Bool(true);
assert_eq!(value.into_integer(), Err(Value::Bool(true)));

pub fn is_bytes(&self) -> bool

Returns true if the Value is a Bytes. Returns false otherwise.

let value = Value::Bytes(vec![104, 101, 108, 108, 111]);

assert!(value.is_bytes());

pub fn as_bytes(&self) -> Option<&Vec<u8>>

If the Value is a Bytes, returns a reference to the associated bytes vector. Returns None otherwise.

let value = Value::Bytes(vec![104, 101, 108, 108, 111]);

assert_eq!(std::str::from_utf8(value.as_bytes().unwrap()).unwrap(), "hello");

pub fn as_bytes_mut(&mut self) -> Option<&mut Vec<u8>>

If the Value is a Bytes, returns a mutable reference to the associated bytes vector. Returns None otherwise.

let mut value = Value::Bytes(vec![104, 101, 108, 108, 111]);
value.as_bytes_mut().unwrap().clear();

assert_eq!(value, Value::Bytes(vec![]));

pub fn into_bytes(self) -> Result<Vec<u8>, Self>

If the Value is a Bytes, returns a the associated Vec<u8> data as Ok. Returns Err(Self) otherwise.

let value = Value::Bytes(vec![104, 101, 108, 108, 111]);
assert_eq!(value.into_bytes(), Ok(vec![104, 101, 108, 108, 111]));

let value = Value::Bool(true);
assert_eq!(value.into_bytes(), Err(Value::Bool(true)));

pub fn is_float(&self) -> bool

Returns true if the Value is a Float. Returns false otherwise.

let value = Value::Float(17.0.into());

assert!(value.is_float());

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

If the Value is a Float, returns a reference to the associated float data. Returns None otherwise.

let value = Value::Float(17.0.into());

// We can read the float number
assert_eq!(value.as_float().unwrap(), 17.0_f64);

pub fn into_float(self) -> Result<f64, Self>

If the Value is a Float, returns a the associated f64 data as Ok. Returns Err(Self) otherwise.

let value = Value::Float(17.);
assert_eq!(value.into_float(), Ok(17.));

let value = Value::Bool(true);
assert_eq!(value.into_float(), Err(Value::Bool(true)));

pub fn is_text(&self) -> bool

Returns true if the Value is a Text. Returns false otherwise.

let value = Value::Text(String::from("hello"));

assert!(value.is_text());

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

If the Value is a Text, returns a reference to the associated String data. Returns None otherwise.

let value = Value::Text(String::from("hello"));

// We can read the String
assert_eq!(value.as_text().unwrap(), "hello");

pub fn as_text_mut(&mut self) -> Option<&mut String>

If the Value is a Text, returns a mutable reference to the associated String data. Returns None otherwise.

let mut value = Value::Text(String::from("hello"));
value.as_text_mut().unwrap().clear();

assert_eq!(value.as_text().unwrap(), &String::from(""));

pub fn into_text(self) -> Result<String, Self>

If the Value is a String, returns a the associated String data as Ok. Returns Err(Self) otherwise.

let value = Value::Text(String::from("hello"));
assert_eq!(value.into_text().as_deref(), Ok("hello"));

let value = Value::Bool(true);
assert_eq!(value.into_text(), Err(Value::Bool(true)));

pub fn is_bool(&self) -> bool

Returns true if the Value is a Bool. Returns false otherwise.

let value = Value::Bool(false);

assert!(value.is_bool());

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

If the Value is a Bool, returns a copy of the associated boolean value. Returns None otherwise.

let value = Value::Bool(false);

assert_eq!(value.as_bool().unwrap(), false);

pub fn into_bool(self) -> Result<bool, Self>

If the Value is a Bool, returns a the associated bool data as Ok. Returns Err(Self) otherwise.

let value = Value::Bool(false);
assert_eq!(value.into_bool(), Ok(false));

let value = Value::Float(17.);
assert_eq!(value.into_bool(), Err(Value::Float(17.)));

pub fn is_null(&self) -> bool

Returns true if the Value is a Null. Returns false otherwise.

let value = Value::Null;

assert!(value.is_null());

pub fn is_tag(&self) -> bool

Returns true if the Value is a Tag. Returns false otherwise.

let value = Value::Tag(61, Box::from(Value::Null));

assert!(value.is_tag());

pub fn as_tag(&self) -> Option<(u64, &Value)>

If the Value is a Tag, returns the associated tag value and a reference to the tag Value. Returns None otherwise.

let value = Value::Tag(61, Box::from(Value::Bytes(vec![104, 101, 108, 108, 111])));

let (tag, data) = value.as_tag().unwrap();
assert_eq!(tag, 61);
assert_eq!(data, &Value::Bytes(vec![104, 101, 108, 108, 111]));

pub fn as_tag_mut(&mut self) -> Option<(&mut u64, &mut Value)>

If the Value is a Tag, returns the associated tag value and a mutable reference to the tag Value. Returns None otherwise.

let mut value = Value::Tag(61, Box::from(Value::Bytes(vec![104, 101, 108, 108, 111])));

let (tag, mut data) = value.as_tag_mut().unwrap();
data.as_bytes_mut().unwrap().clear();
assert_eq!(tag, &61);
assert_eq!(data, &Value::Bytes(vec![]));

pub fn into_tag(self) -> Result<(u64, Box<Value>), Self>

If the Value is a Tag, returns a the associated pair of u64 and Box<value> data as Ok. Returns Err(Self) otherwise.

let value = Value::Tag(7, Box::new(Value::Float(12.)));
assert_eq!(value.into_tag(), Ok((7, Box::new(Value::Float(12.)))));

let value = Value::Bool(true);
assert_eq!(value.into_tag(), Err(Value::Bool(true)));

pub fn is_array(&self) -> bool

Returns true if the Value is an Array. Returns false otherwise.

let value = Value::Array(
    vec![
        Value::Text(String::from("foo")),
        Value::Text(String::from("bar"))
    ]
);

assert!(value.is_array());

pub fn as_array(&self) -> Option<&Vec<Value>>

If the Value is an Array, returns a reference to the associated vector. Returns None otherwise.

let value = Value::Array(
    vec![
        Value::Text(String::from("foo")),
        Value::Text(String::from("bar"))
    ]
);

// The length of `value` is 2 elements.
assert_eq!(value.as_array().unwrap().len(), 2);

pub fn as_array_mut(&mut self) -> Option<&mut Vec<Value>>

If the Value is an Array, returns a mutable reference to the associated vector. Returns None otherwise.

let mut value = Value::Array(
    vec![
        Value::Text(String::from("foo")),
        Value::Text(String::from("bar"))
    ]
);

value.as_array_mut().unwrap().clear();
assert_eq!(value, Value::Array(vec![]));

pub fn into_array(self) -> Result<Vec<Value>, Self>

If the Value is a Array, returns a the associated Vec<Value> data as Ok. Returns Err(Self) otherwise.

let mut value = Value::Array(
    vec![
        Value::Integer(17.into()),
        Value::Float(18.),
    ]
);
assert_eq!(value.into_array(), Ok(vec![Value::Integer(17.into()), Value::Float(18.)]));

let value = Value::Bool(true);
assert_eq!(value.into_array(), Err(Value::Bool(true)));

pub fn is_map(&self) -> bool

Returns true if the Value is a Map. Returns false otherwise.

let value = Value::Map(
    vec![
        (Value::Text(String::from("foo")), Value::Text(String::from("bar")))
    ]
);

assert!(value.is_map());

pub fn as_map(&self) -> Option<&Vec<(Value, Value)>>

If the Value is a Map, returns a reference to the associated Map data. Returns None otherwise.

let value = Value::Map(
    vec![
        (Value::Text(String::from("foo")), Value::Text(String::from("bar")))
    ]
);

// The length of data is 1 entry (1 key/value pair).
assert_eq!(value.as_map().unwrap().len(), 1);

// The content of the first element is what we expect
assert_eq!(
    value.as_map().unwrap().get(0).unwrap(),
    &(Value::Text(String::from("foo")), Value::Text(String::from("bar")))
);

pub fn as_map_mut(&mut self) -> Option<&mut Vec<(Value, Value)>>

If the Value is a Map, returns a mutable reference to the associated Map Data. Returns None otherwise.

let mut value = Value::Map(
    vec![
        (Value::Text(String::from("foo")), Value::Text(String::from("bar")))
    ]
);

value.as_map_mut().unwrap().clear();
assert_eq!(value, Value::Map(vec![]));
assert_eq!(value.as_map().unwrap().len(), 0);

pub fn into_map(self) -> Result<Vec<(Value, Value)>, Self>

If the Value is a Map, returns a the associated Vec<(Value, Value)> data as Ok. Returns Err(Self) otherwise.

let mut value = Value::Map(
    vec![
        (Value::Text(String::from("key")), Value::Float(18.)),
    ]
);
assert_eq!(value.into_map(), Ok(vec![(Value::Text(String::from("key")), Value::Float(18.))]));

let value = Value::Bool(true);
assert_eq!(value.into_map(), Err(Value::Bool(true)));

Trait Implementations

impl Clone for Value

fn clone(&self) -> Value

Returns a copy 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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Value

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl From<&[(Value, Value)]> for Value

fn from(value: &[(Value, Value)]) -> Self

Converts to this type from the input type.

impl From<&[Value]> for Value

fn from(value: &[Value]) -> Self

Converts to this type from the input type.

impl From<&[u8]> for Value

fn from(value: &[u8]) -> Self

Converts to this type from the input type.

impl<'a> From<&'a Value> for Unexpected<'a>

fn from(value: &'a Value) -> Self

Converts to this type from the input type.

impl From<&str> for Value

fn from(value: &str) -> Self

Converts to this type from the input type.

impl From<CanonicalValue> for Value

fn from(v: CanonicalValue) -> Self

Converts to this type from the input type.

impl From<Integer> for Value

fn from(value: Integer) -> Self

Converts to this type from the input type.

impl From<String> for Value

fn from(value: String) -> Self

Converts to this type from the input type.

impl From<Value> for CanonicalValue

fn from(v: Value) -> Self

Converts to this type from the input type.

impl From<Vec<(Value, Value)>> for Value

fn from(value: Vec<(Value, Value)>) -> Self

Converts to this type from the input type.

impl From<Vec<Value>> for Value

fn from(value: Vec<Value>) -> Self

Converts to this type from the input type.

impl From<Vec<u8>> for Value

fn from(value: Vec<u8>) -> Self

Converts to this type from the input type.

impl From<bool> for Value

fn from(value: bool) -> Self

Converts to this type from the input type.

impl From<char> for Value

fn from(value: char) -> Self

Converts to this type from the input type.

impl From<f32> for Value

fn from(value: f32) -> Self

Converts to this type from the input type.

impl From<f64> for Value

fn from(value: f64) -> Self

Converts to this type from the input type.

impl From<i128> for Value

fn from(value: i128) -> Self

Converts to this type from the input type.

impl From<i16> for Value

fn from(value: i16) -> Self

Converts to this type from the input type.

impl From<i32> for Value

fn from(value: i32) -> Self

Converts to this type from the input type.

impl From<i64> for Value

fn from(value: i64) -> Self

Converts to this type from the input type.

impl From<i8> for Value

fn from(value: i8) -> Self

Converts to this type from the input type.

impl From<u128> for Value

fn from(value: u128) -> Self

Converts to this type from the input type.

impl From<u16> for Value

fn from(value: u16) -> Self

Converts to this type from the input type.

impl From<u32> for Value

fn from(value: u32) -> Self

Converts to this type from the input type.

impl From<u64> for Value

fn from(value: u64) -> Self

Converts to this type from the input type.

impl From<u8> for Value

fn from(value: u8) -> Self

Converts to this type from the input type.

impl PartialEq for Value

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

fn partial_cmp(&self, other: &Value) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for Value

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Value