Enum bencodex::BNode

pub enum BNode {
    Integer(i64),
    Bytes(Vec<u8>),
    List(BList),
    Dict(BDict),
}

Variants

Integer(i64)

Bytes(Vec<u8>)

List(BList)

Dict(BDict)

Implementations

impl BNode

pub fn serialize<W>(&self, buf: &mut W) -> Result<usize>where W: Write,

Examples found in repository

examples/ser/main.rs (line 11)

fn main() {
    let mut dict = BDict::new();
    dict.insert("bar".to_string(), "spam".into());
    dict.insert("foo".to_string(), 42.into());

    let bnode: BNode = dict.into();

    let mut buf = vec![];
    bnode.serialize(&mut buf).unwrap();
    assert_eq!("d3:bar4:spam3:fooi42ee".as_bytes(), buf)
}

examples/bufwriter/main.rs (line 19)

fn main() {
    let mut dict = BDict::new();
    dict.insert("bar".to_string(), "spam".into());
    dict.insert("foo".to_string(), 42.into());

    let bnode: BNode = dict.into();

    let mut file = File::create(
        env::current_dir()
            .unwrap()
            .join("examples")
            .join("bufwriter")
            .join("bufwriter-test.torrent"),
    )
    .unwrap();
    bnode.serialize(&mut file).unwrap();
}

pub fn as_integer(&self) -> Result<&i64, String>

Examples found in repository

examples/de/main.rs (line 6)

fn main() {
    let b = "d3:inti233e3:lstl7:bencodeee";
    let node = bencodex::parse(&mut b.bytes()).unwrap();

    let dict = node.as_dict().unwrap();
    let int = dict.get("int").unwrap().as_integer().unwrap();

    assert_eq!(int, &233);
    let list = dict.get("lst").unwrap().as_list().unwrap();
    assert_eq!(list.len(), 1);
    assert_eq!(
        list.get(0).unwrap().as_bytes().unwrap(),
        "bencode".as_bytes()
    );
}

examples/bufreader/main.rs (line 41)

fn main() {
    let f = File::open(
        env::current_dir()
            .unwrap()
            .join("examples")
            .join("bufreader")
            .join("bufreader-test.torrent"),
    )
    .unwrap();
    let reader = BufReader::new(f);

    let mut adapter = Adapter {
        bytes: reader.bytes(),
    };
    let bnode = bencodex::parse(&mut adapter).unwrap();
    let dict = bnode.as_dict().unwrap();
    assert_eq!(
        dict.get("bar").unwrap().as_bytes().unwrap(),
        "spam".as_bytes()
    );
    assert_eq!(dict.get("foo").unwrap().as_integer().unwrap(), &42);
}

pub fn as_bytes(&self) -> Result<&[u8], String>

Examples found in repository

examples/de/main.rs (line 12)

fn main() {
    let b = "d3:inti233e3:lstl7:bencodeee";
    let node = bencodex::parse(&mut b.bytes()).unwrap();

    let dict = node.as_dict().unwrap();
    let int = dict.get("int").unwrap().as_integer().unwrap();

    assert_eq!(int, &233);
    let list = dict.get("lst").unwrap().as_list().unwrap();
    assert_eq!(list.len(), 1);
    assert_eq!(
        list.get(0).unwrap().as_bytes().unwrap(),
        "bencode".as_bytes()
    );
}

examples/bufreader/main.rs (line 38)

fn main() {
    let f = File::open(
        env::current_dir()
            .unwrap()
            .join("examples")
            .join("bufreader")
            .join("bufreader-test.torrent"),
    )
    .unwrap();
    let reader = BufReader::new(f);

    let mut adapter = Adapter {
        bytes: reader.bytes(),
    };
    let bnode = bencodex::parse(&mut adapter).unwrap();
    let dict = bnode.as_dict().unwrap();
    assert_eq!(
        dict.get("bar").unwrap().as_bytes().unwrap(),
        "spam".as_bytes()
    );
    assert_eq!(dict.get("foo").unwrap().as_integer().unwrap(), &42);
}

pub fn as_list(&self) -> Result<&[BNode], String>

Examples found in repository

examples/de/main.rs (line 9)

fn main() {
    let b = "d3:inti233e3:lstl7:bencodeee";
    let node = bencodex::parse(&mut b.bytes()).unwrap();

    let dict = node.as_dict().unwrap();
    let int = dict.get("int").unwrap().as_integer().unwrap();

    assert_eq!(int, &233);
    let list = dict.get("lst").unwrap().as_list().unwrap();
    assert_eq!(list.len(), 1);
    assert_eq!(
        list.get(0).unwrap().as_bytes().unwrap(),
        "bencode".as_bytes()
    );
}

pub fn as_dict(&self) -> Result<&BDict, String>

Examples found in repository

examples/de/main.rs (line 5)

fn main() {
    let b = "d3:inti233e3:lstl7:bencodeee";
    let node = bencodex::parse(&mut b.bytes()).unwrap();

    let dict = node.as_dict().unwrap();
    let int = dict.get("int").unwrap().as_integer().unwrap();

    assert_eq!(int, &233);
    let list = dict.get("lst").unwrap().as_list().unwrap();
    assert_eq!(list.len(), 1);
    assert_eq!(
        list.get(0).unwrap().as_bytes().unwrap(),
        "bencode".as_bytes()
    );
}

examples/bufreader/main.rs (line 36)

fn main() {
    let f = File::open(
        env::current_dir()
            .unwrap()
            .join("examples")
            .join("bufreader")
            .join("bufreader-test.torrent"),
    )
    .unwrap();
    let reader = BufReader::new(f);

    let mut adapter = Adapter {
        bytes: reader.bytes(),
    };
    let bnode = bencodex::parse(&mut adapter).unwrap();
    let dict = bnode.as_dict().unwrap();
    assert_eq!(
        dict.get("bar").unwrap().as_bytes().unwrap(),
        "spam".as_bytes()
    );
    assert_eq!(dict.get("foo").unwrap().as_integer().unwrap(), &42);
}

Trait Implementations

impl Clone for BNode

fn clone(&self) -> BNode

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for BNode

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

Formats the value using the given formatter.

impl Display for BNode

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

Formats the value using the given formatter.

impl From<&[u8]> for BNode

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

Converts to this type from the input type.

impl From<&str> for BNode

fn from(value: &str) -> Self

Converts to this type from the input type.

impl From<BTreeMap<String, BNode, Global>> for BNode

fn from(value: BTreeMap<String, BNode>) -> Self

Converts to this type from the input type.

impl From<String> for BNode

fn from(value: String) -> Self

Converts to this type from the input type.

impl From<Vec<BNode, Global>> for BNode

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

Converts to this type from the input type.

impl From<Vec<u8, Global>> for BNode

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

Converts to this type from the input type.

impl From<i64> for BNode

fn from(value: i64) -> Self

Converts to this type from the input type.

impl PartialEq<BNode> for BNode

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

impl StructuralEq for BNode

impl StructuralPartialEq for BNode