babbel_bencode 0.1.1

Fast, binary-safe BitTorrent Bencode parser, serializer, and DOM in pure Rust
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

//! Extension trait for schema validation and typed field querying on `Node` structures.
//! Segregates schema validation responsibilities from the core AST data representation (SRP & ISP compliant).

#[cfg(not(feature = "std"))]
use alloc::{
    format,
    string::String,
    vec::Vec,
    collections::BTreeMap as HashMap,
};

#[cfg(feature = "std")]
use std::collections::HashMap;

use crate::nodes::node::Node;

/// Trait providing dictionary schema validation and field extraction operations.
pub trait NodeQueryExt {
    /// Get a required field from a dictionary, returning an error if not found.
    fn get_required(&self, key: &str) -> Result<&Node, String>;
    /// Get a required integer field from a dictionary.
    fn get_int_required(&self, key: &str) -> Result<i64, String>;
    /// Get a required string field from a dictionary.
    fn get_string_required(&self, key: &str) -> Result<&str, String>;
    /// Get a required list field from a dictionary.
    fn get_list_required(&self, key: &str) -> Result<&Vec<Node>, String>;
    /// Get a required dictionary field from a dictionary.
    fn get_dict_required(&self, key: &str) -> Result<&HashMap<String, Node>, String>;

    /// Get an optional integer field, returning None if not found or not an integer.
    fn get_int_optional(&self, key: &str) -> Option<i64>;
    /// Get an optional string field, returning None if not found or not a string.
    fn get_string_optional(&self, key: &str) -> Option<&str>;
    /// Get an optional list field, returning None if not found or not a list.
    fn get_list_optional(&self, key: &str) -> Option<&Vec<Node>>;
    /// Get an optional dictionary field, returning None if not found or not a dictionary.
    fn get_dict_optional(&self, key: &str) -> Option<&HashMap<String, Node>>;
}

impl NodeQueryExt for Node {
    fn get_required(&self, key: &str) -> Result<&Node, String> {
        self.get(key)
            .ok_or_else(|| format!("Missing required field: '{}'", key))
    }

    fn get_int_required(&self, key: &str) -> Result<i64, String> {
        self.get_required(key)?
            .as_integer()
            .copied()
            .ok_or_else(|| format!("Field '{}' must be an integer", key))
    }

    fn get_string_required(&self, key: &str) -> Result<&str, String> {
        self.get_required(key)?
            .as_string()
            .ok_or_else(|| format!("Field '{}' must be a string", key))
    }

    fn get_list_required(&self, key: &str) -> Result<&Vec<Node>, String> {
        self.get_required(key)?
            .as_list()
            .ok_or_else(|| format!("Field '{}' must be a list", key))
    }

    fn get_dict_required(&self, key: &str) -> Result<&HashMap<String, Node>, String> {
        self.get_required(key)?
            .as_dictionary()
            .ok_or_else(|| format!("Field '{}' must be a dictionary", key))
    }

    fn get_int_optional(&self, key: &str) -> Option<i64> {
        self.get(key).and_then(|n| n.as_integer()).copied()
    }

    fn get_string_optional(&self, key: &str) -> Option<&str> {
        self.get(key).and_then(|n| n.as_string())
    }

    fn get_list_optional(&self, key: &str) -> Option<&Vec<Node>> {
        self.get(key).and_then(|n| n.as_list())
    }

    fn get_dict_optional(&self, key: &str) -> Option<&HashMap<String, Node>> {
        self.get(key).and_then(|n| n.as_dictionary())
    }
}