Enum BdecodeNode 

pub enum BdecodeNode {
    Dict(Dict),
    List(List),
    Str(Str),
    Int(Int),
    End(End),
}

用于存放解析后的数据

Variants

Dict(Dict)

List(List)

Str(Str)

Int(Int)

End(End)

Implementations

impl BdecodeNode

pub fn new( token_idx: u32, tokens: Arc<Vec<BdecodeToken>>, buffer: Arc<Vec<u8>>, ) -> BdecodeNode

pub fn as_int(&self) -> Result<i64, BdecodeError>

pub fn as_str(&self) -> Cow<'_, [u8]>

pub fn len(&self) -> usize

Examples found in repository

examples/decode.rs (line 12)

fn main() {
    let buf = "d 2:k1 2:v1 2:k2 l i1e i2e e 3:k03 i3e 2:k4 d 2:k5 i5e 2:k6 i6e e e".replace(" ", "");

    let root_node = BdecodeNode::parse_buffer(buf.into()).unwrap();
    println!("{}", root_node.to_json());

    let k2_node = root_node.dict_find(b"k2").unwrap();
    println!("{}", k2_node.to_json());
   
    for i in 0..k2_node.len() {
        let val = k2_node.list_item_as_int(i).unwrap();
        println!("item_{} = {}", i, val)
    }
}

pub fn list_item(&self, index: usize) -> BdecodeNode

pub fn list_item_as_int(&self, index: usize) -> Result<i64, BdecodeError>

Examples found in repository

examples/decode.rs (line 13)

fn main() {
    let buf = "d 2:k1 2:v1 2:k2 l i1e i2e e 3:k03 i3e 2:k4 d 2:k5 i5e 2:k6 i6e e e".replace(" ", "");

    let root_node = BdecodeNode::parse_buffer(buf.into()).unwrap();
    println!("{}", root_node.to_json());

    let k2_node = root_node.dict_find(b"k2").unwrap();
    println!("{}", k2_node.to_json());
   
    for i in 0..k2_node.len() {
        let val = k2_node.list_item_as_int(i).unwrap();
        println!("item_{} = {}", i, val)
    }
}

pub fn list_item_as_str(&self, index: usize) -> Cow<'_, [u8]>

pub fn dict_item(&self, index: usize) -> (BdecodeNode, BdecodeNode)

pub fn dict_find(&self, key: &[u8]) -> Option<BdecodeNode>

Examples found in repository

examples/decode.rs (line 9)

fn main() {
    let buf = "d 2:k1 2:v1 2:k2 l i1e i2e e 3:k03 i3e 2:k4 d 2:k5 i5e 2:k6 i6e e e".replace(" ", "");

    let root_node = BdecodeNode::parse_buffer(buf.into()).unwrap();
    println!("{}", root_node.to_json());

    let k2_node = root_node.dict_find(b"k2").unwrap();
    println!("{}", k2_node.to_json());
   
    for i in 0..k2_node.len() {
        let val = k2_node.list_item_as_int(i).unwrap();
        println!("item_{} = {}", i, val)
    }
}

pub fn dict_find_as_str(&self, key: &[u8]) -> Option<Cow<'_, [u8]>>

pub fn dict_find_as_int(&self, key: &[u8]) -> Option<i64>

pub fn dict_find_as_list(&self, key: &[u8]) -> Option<Vec<BdecodeNode>>

pub fn dict_find_as_dict( &self, key: &[u8], ) -> Option<HashMap<Cow<'_, [u8]>, BdecodeNode>>

pub fn parse( buffer: Vec<u8>, depth_limit: Option<usize>, token_limit: Option<i32>, ) -> Result<Self, BdecodeError>

pub fn parse_buffer(buffer: Vec<u8>) -> Result<Self, BdecodeError>

Examples found in repository

examples/decode.rs (line 6)

fn main() {
    let buf = "d 2:k1 2:v1 2:k2 l i1e i2e e 3:k03 i3e 2:k4 d 2:k5 i5e 2:k6 i6e e e".replace(" ", "");

    let root_node = BdecodeNode::parse_buffer(buf.into()).unwrap();
    println!("{}", root_node.to_json());

    let k2_node = root_node.dict_find(b"k2").unwrap();
    println!("{}", k2_node.to_json());
   
    for i in 0..k2_node.len() {
        let val = k2_node.list_item_as_int(i).unwrap();
        println!("item_{} = {}", i, val)
    }
}

pub fn to_json(&self) -> String

Examples found in repository

examples/decode.rs (line 7)

fn main() {
    let buf = "d 2:k1 2:v1 2:k2 l i1e i2e e 3:k03 i3e 2:k4 d 2:k5 i5e 2:k6 i6e e e".replace(" ", "");

    let root_node = BdecodeNode::parse_buffer(buf.into()).unwrap();
    println!("{}", root_node.to_json());

    let k2_node = root_node.dict_find(b"k2").unwrap();
    println!("{}", k2_node.to_json());
   
    for i in 0..k2_node.len() {
        let val = k2_node.list_item_as_int(i).unwrap();
        println!("item_{} = {}", i, val)
    }
}

Trait Implementations

impl Clone for BdecodeNode

fn clone(&self) -> BdecodeNode

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BdecodeNode

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

Formats the value using the given formatter.