Struct Sequence 

pub struct Sequence<'a> { /* private fields */ }

A CBOR Sequence.

Typical actions on this are the same as on StandaloneItem, but it can process multiple CBOR items in a row, and thus offers interaction with all those items:

let from_edn = Sequence::parse("
    1
    2
    3
").unwrap();
assert_eq!(from_edn.items().count(), 3);

Implementations

impl<'a> Sequence<'a>

pub fn parse(s: &'a str) -> Result<Self, ParseError>

Ingests CBOR Diagnostic Notation (EDN) representing a CBOR sequence

Note that this will only return syntactic errors. Content errors that make it impossible to produce this as CBOR, such as non-matching encoding indicators or unknown application oriented literals, are not reported.

pub fn serialize(&self) -> String

Produce an EDN String from the sequence

pub fn from_cbor(cbor: &[u8]) -> Result<Self, CborError>

pub fn from_cbor_possibly_incomplete(cbor: &[u8]) -> Result<Self, CborError>

Parses a CBOR sequence, allowing incomplete items.

If at the end of the data there is an incomplete CBOR item, rather than producing an error, this produces ellipses wherever there is incomplete data.

let from_cbor = Sequence::from_cbor_possibly_incomplete(
    &[0x82, 0x65, 0x61, 0x62, 0x63]
).unwrap();
assert_eq!(from_cbor.serialize(), r#"["abc" + ..., ...], ..."#);

pub fn to_cbor(&self) -> Result<Vec<u8>, InconsistentEdn>

Encode into a binary CBOR representation

pub fn new(items: impl Iterator<Item = Item<'a>>) -> Self

Construct a CBOR sequence from items

pub fn items(&self) -> impl Iterator<Item = &Item<'a>>

Access the items of the sequence

pub fn items_mut(&mut self) -> impl Iterator<Item = &mut Item<'a>>

Mutably access the items of the sequence

pub fn get_items_mut(&mut self) -> impl Iterator<Item = &mut Item<'a>>

👎Deprecated:

renamed to items_mut()

pub fn discard_encoding_indicators(&mut self)

Removes any encoding indicators present in the sequence.

This does not affect space or comments; in particular, an item containing only the necessary space may be left with extraneous (but harmless) space that was previously needed to set an encoding indicator apart from a value.

pub fn cloned<'any>(&self) -> Sequence<'any>

Clone the item, turning any Cow::Borrowed into owned versions, which can then satisfy any lifetime.

Trait Implementations

impl<'a> Clone for Sequence<'a>

fn clone(&self) -> Sequence<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Sequence<'a>

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

Formats the value using the given formatter.

impl<'a> PartialEq for Sequence<'a>

fn eq(&self, other: &Sequence<'a>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<'a> StructuralPartialEq for Sequence<'a>

impl<'a> Transformable<'a> for Sequence<'a>

fn set_delimiters(&mut self, policy: DelimiterPolicy)

Alters how space and comments are placed inside the item.

fn visit_application_literals<F>(&mut self, f: &mut F)

where F: FnMut(String, String, &mut Item<'a>) -> Result<(), String> + ?Sized,

For each item in the tree that is a single application literal, call a callback.

fn visit_tag<F>(&mut self, f: &mut F)

where F: FnMut(u64, &mut Item<'a>) -> Result<(), String> + ?Sized,

For each item in the full tree (including embedded representations) that is tagged, call a callback.