Struct Node 

pub struct Node { /* private fields */ }

A node of a bracket file: a Value plus the position it was parsed from.

Quoted strings and atoms are kept distinct, so text written by the platform is written back byte for byte. Whitespace between items is not kept: writing uses the platform layout. Equality and hashing ignore the position.

Like parsing and writing, cloning, comparison, hashing, Debug and dropping are not recursive: a tree of any depth does not overflow the stack.

Implementations

impl Node

pub fn list(items: impl IntoIterator<Item = Node>) -> Self

A list of nodes.

pub fn atom(value: impl Into<String>) -> Self

An unquoted atom (GUID, literal, number).

pub fn string(value: impl Into<String>) -> Self

A quoted string.

There is no From<&str> for building: Node::try_from(&str) parses text.

pub fn counted(items: impl IntoIterator<Item = Node>) -> Self

A counted list {count,item1,item2,...}, the common 1C shape.

pub fn value(&self) -> &Value

pub fn into_value(self) -> Value

pub fn value_mut(&mut self) -> &mut Value

Mutable access to the content; the position stays where the node was parsed.

pub fn position(&self) -> Option<Position>

Where the node starts in the input; None for nodes built in code.

Edits do not change it: it always refers to the original text.

pub fn is_list(&self) -> bool

pub fn is_str(&self) -> bool

pub fn is_atom(&self) -> bool

pub fn is_empty_atom(&self) -> bool

An empty atom: no value between commas ({1,,2}).

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

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

Value of a string or an atom.

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

Quoted string only.

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

Atom only.

pub fn as_parsed<T: FromStr>(&self) -> Option<T>

Atom parsed into any FromStr type: node.as_parsed::<u32>().

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

pub fn as_u64(&self) -> Option<u64>

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

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

Atom 1 is true, 0 is false.

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

An atom shaped like a GUID xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.

pub fn as_base64(&self) -> Option<String>

Payload of a #base64:… atom without the prefix and line breaks (not decoded).

pub fn get(&self, idx: usize) -> Option<&Node>

List item by index.

pub fn get_path(&self, path: &[usize]) -> Option<&Node>

Item by a path of indices from this node: node.get_path(&[1, 0, 2]).

pub fn len(&self) -> usize

Number of list items; 0 for strings and atoms.

pub fn is_empty(&self) -> bool

List without items; strings and atoms are considered empty too.

pub fn iter(&self) -> Iter<'_, Node>

List items; an empty iterator for strings and atoms.

pub fn into_list(self) -> Option<Vec<Node>>

pub fn into_string(self) -> Option<String>

Value of a string or an atom.

pub fn try_list(&self) -> Result<&[Node], AccessError>

pub fn try_str(&self) -> Result<&str, AccessError>

pub fn try_quoted(&self) -> Result<&str, AccessError>

pub fn try_atom(&self) -> Result<&str, AccessError>

pub fn try_parse<T>(&self) -> Result<T, AccessError>

where T: FromStr, T::Err: Display,

Atom parsed into any FromStr type: node.try_parse::<u32>()?.

The error names the target type and keeps the reason from FromStr::Err.

pub fn try_i64(&self) -> Result<i64, AccessError>

pub fn try_u64(&self) -> Result<u64, AccessError>

pub fn try_f64(&self) -> Result<f64, AccessError>

pub fn try_bool(&self) -> Result<bool, AccessError>

pub fn try_guid(&self) -> Result<&str, AccessError>

pub fn try_get(&self, idx: usize) -> Result<&Node, AccessError>

pub fn try_get_path(&self, path: &[usize]) -> Result<&Node, AccessError>

Item by a path of indices: node.try_get_path(&[0, 2, 0])?.

On failure the error carries the path to the node that could not be indexed.

pub fn as_list_mut(&mut self) -> Option<&mut Vec<Node>>

List items for editing: replace, push, insert or remove nodes.

pub fn get_mut(&mut self, idx: usize) -> Option<&mut Node>

pub fn get_path_mut(&mut self, path: &[usize]) -> Option<&mut Node>

pub fn iter_mut(&mut self) -> IterMut<'_, Node>

List items; an empty iterator for strings and atoms.

pub fn try_list_mut(&mut self) -> Result<&mut Vec<Node>, AccessError>

pub fn try_get_mut(&mut self, idx: usize) -> Result<&mut Node, AccessError>

pub fn try_get_path_mut( &mut self, path: &[usize], ) -> Result<&mut Node, AccessError>

Item by a path of indices for editing: *node.try_get_path_mut(&[1, 0])? = Node::from(2).

pub fn try_counted(&self) -> Result<&[Node], AccessError>

Items of a counted list {count,item1,item2,...}: {2,a,b} gives [a, b].

Fails if the count is not a number or does not match the number of items.

pub fn walk<'a>(&'a self, visit: impl FnMut(&[usize], &'a Node))

Pre-order depth-first traversal with the path from the root. Not recursive: forms can be deeply nested.

pub fn describe(&self) -> String

Short description of the node for error messages.

impl Node

pub fn from_reader<R: Read>(reader: R) -> Result<Node, ParseError>

Parses a single top-level value from any source.

A leading BOM and surrounding whitespace are allowed. Reads byte by byte through a buffer without loading the whole input into memory.

impl Node

pub fn write_to<W: Write>(&self, writer: W) -> Result<()>

Writes the bracket file text to any io::Write.

Trait Implementations

impl Clone for Node

fn clone(&self) -> Self

Not recursive: a deep tree does not overflow the stack.

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

Performs copy-assignment from source.

impl Debug for Node

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

Shows only the value: positions would drown the tree in noise.

impl<'de> Deserialize<'de> for Node

Available on crate feature serde only.

From this crate’s deserializer a node comes out as is, positions included.

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

Deserialize this value from the given Serde deserializer.

impl Display for Node

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

Formats the value using the given formatter.

impl Drop for Node

fn drop(&mut self)

Not recursive: nested lists are moved onto a heap stack and dropped one by one.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl Eq for Node

impl From<&Node> for String

fn from(node: &Node) -> Self

Converts to this type from the input type.

impl From<&Node> for Vec<u8>

fn from(node: &Node) -> Self

Converts to this type from the input type.

impl From<Value> for Node

fn from(value: Value) -> Self

Converts to this type from the input type.

impl From<Vec<Node>> for Node

fn from(items: Vec<Node>) -> Self

Converts to this type from the input type.

impl From<bool> for Node

fn from(b: bool) -> Self

Converts to this type from the input type.

impl From<i8> for Node

fn from(n: i8) -> Self

Converts to this type from the input type.

impl From<i16> for Node

fn from(n: i16) -> Self

Converts to this type from the input type.

impl From<i32> for Node

fn from(n: i32) -> Self

Converts to this type from the input type.

impl From<i64> for Node

fn from(n: i64) -> Self

Converts to this type from the input type.

impl From<isize> for Node

fn from(n: isize) -> Self

Converts to this type from the input type.

impl From<u8> for Node

fn from(n: u8) -> Self

Converts to this type from the input type.

impl From<u16> for Node

fn from(n: u16) -> Self

Converts to this type from the input type.

impl From<u32> for Node

fn from(n: u32) -> Self

Converts to this type from the input type.

impl From<u64> for Node

fn from(n: u64) -> Self

Converts to this type from the input type.

impl From<usize> for Node

fn from(n: usize) -> Self

Converts to this type from the input type.

impl<T: Into<Node>> FromIterator<T> for Node

fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self

Creates a value from an iterator.

impl FromStr for Node

type Err = ParseError

The associated error which can be returned from parsing.

fn from_str(text: &str) -> Result<Node, ParseError>

Parses a string s to return a value of this type.

impl Hash for Node

fn hash<H: Hasher>(&self, state: &mut H)

Ignores positions. Not recursive: pre-order with list lengths.

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 Index<usize> for Node

type Output = Node

The returned type after indexing.

fn index(&self, idx: usize) -> &Node

Performs the indexing (container[index]) operation.

impl IndexMut<usize> for Node

fn index_mut(&mut self, idx: usize) -> &mut Node

Performs the mutable indexing (container[index]) operation.

impl<'a> IntoIterator for &'a Node

type Item = &'a Node

The type of the elements being iterated over.

type IntoIter = Iter<'a, Node>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a> IntoIterator for &'a mut Node

type Item = &'a mut Node

The type of the elements being iterated over.

type IntoIter = IterMut<'a, Node>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl PartialEq for Node

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

Ignores positions. Not recursive.

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

Inequality operator !=.

impl Serialize for Node

Available on crate feature serde only.

Positions are not written: they belong to the parsed text.

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

Serialize this value into the given Serde serializer.

impl TryFrom<&Path> for Node

type Error = ParseError

The type returned in the event of a conversion error.

fn try_from(path: &Path) -> Result<Node, ParseError>

Performs the conversion.

impl TryFrom<&[u8]> for Node

type Error = ParseError

The type returned in the event of a conversion error.

fn try_from(bytes: &[u8]) -> Result<Node, ParseError>

Performs the conversion.

impl TryFrom<&str> for Node

type Error = ParseError

The type returned in the event of a conversion error.

fn try_from(text: &str) -> Result<Node, ParseError>

Performs the conversion.