Struct ben::Node

pub struct Node<'a> { /* fields omitted */ }

Methods

impl<'a> Node<'a>

pub fn parse(buf: &'a [u8]) -> Result<Self>

Parse given bencoded bytes.

Example:

    use ben::Node;

    let bytes = b"11:Hello World";
    let node = Node::parse(bytes).unwrap();
    assert_eq!("Hello World", node.as_str().unwrap());

pub fn parse_in(buf: &'a [u8], tokens: &'a mut Vec<Token>) -> Result<Self>

Parse given bencoded bytes using a given token buffer. It helps you reuse the buffer next time.

Example:

    use ben::Node;

    let mut v = vec![];
    let values: &[&[u8]] = &[b"5:Hello", b"5:World"];
    for bytes in values {
        let node = Node::parse_in(bytes, &mut v).unwrap();
        assert!(node.is_str());
    }

pub fn parse_prefix(buf: &'a [u8]) -> Result<(Self, usize)>

Parse given bencoded bytes from the beginning and returns index where one root object is parsed successfully.

Example:

    use ben::Node;

    let bytes = b"5:Hello World";
    let (node, i) = Node::parse_prefix(bytes).unwrap();
    assert_eq!("Hello", node.as_str().unwrap());
    assert_eq!(b" World", &bytes[i..]);

pub fn parse_prefix_in(
    buf: &'a [u8],
    tokens: &'a mut Vec<Token>
) -> Result<(Self, usize)>

Parse given bencoded bytes from the beginning and returns index where one root object is parsed successfully. It accepts a token buffer argument which helps reuse the buffer next time.

Example:

    use ben::Node;

    let mut v = vec![];
    let values: &[&[u8]] = &[b"5:Hello World", b"1:ade"];
    for bytes in values {
        let (node, i) = Node::parse_prefix_in(bytes, &mut v).unwrap();
        assert!(node.is_str());
    }

pub fn parse_max_tokens(buf: &'a [u8], max_tokens: usize) -> Result<Self>

Parse given bencoded bytes with limit on maximum number of tokens that can be parsed.

Example:

    use ben::{Node, Error};

    let bytes = b"l1:a2:bce";
    let err = Node::parse_max_tokens(bytes, 2).unwrap_err();
    assert_eq!(Error::NoMemory, err);

pub fn data(&self) -> &'a [u8]

Returns raw bytes inside this node.

Example:

    use ben::Node;

    let bytes = b"l1:a2:bce";
    let node = Node::parse(bytes).unwrap();
    assert_eq!(b"1:a2:bc", node.data());

pub fn is_list(&self) -> bool

Returns true if this node is a list.

pub fn is_dict(&self) -> bool

Returns true if this node is a dictionary.

pub fn is_str(&self) -> bool

Returns true if this node is a string.

pub fn is_int(&self) -> bool

Returns true if this node is a integer.

pub fn as_list(&self) -> Option<List>

Return this node as a List which provides further list operations such as get, iter etc.

Example:

    use ben::Node;

    let bytes = b"l1:a2:bce";
    let node = Node::parse(bytes).unwrap();
    let list = node.as_list().unwrap();
    assert_eq!("a", list.get_str(0).unwrap());
    assert_eq!("bc", list.get_str(1).unwrap());

pub fn as_dict(&self) -> Option<Dict>

Return this node as a Dict which provides further dictionary operations such as get, iter etc.

Example:

    use ben::Node;

    let bytes = b"d1:a2:bce";
    let node = Node::parse(bytes).unwrap();
    let dict = node.as_dict().unwrap();
    assert_eq!("bc", dict.get_str(b"a").unwrap());

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

Return this node as a i64.

Example:

    use ben::Node;

    let bytes = b"i123e";
    let node = Node::parse(bytes).unwrap();
    assert_eq!(123, node.as_int().unwrap());

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

Return this node as a i64.

Example:

    use ben::Node;

    let bytes = b"3:abc";
    let node = Node::parse(bytes).unwrap();
    assert_eq!("abc", node.as_str().unwrap());

Trait Implementations

impl<'_> Debug for Node<'_>

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

Formats the value using the given formatter.

impl<'a> PartialEq<Node<'a>> for Node<'a>

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

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Node<'a>) -> bool

This method tests for !=.

impl<'a> StructuralPartialEq for Node<'a>