bitgrep 0.1.5

Binary grep for numerical data types
Documentation 
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
87
88
89
90
91
92
93

use std::path::Path;
use std::string::String;
use std::{fmt::Display, path::PathBuf};

use crate::hex;

pub(crate) enum Content {
    Simple,
    Context,
}

#[derive(Debug, PartialEq, Default)]
pub struct Output<T>
where
    T: Display,
{
    file_path: PathBuf,
    value_type: String, // Enum?
    value: T,           // Remove T and convert on own?
    data_context: DataContext,
}

impl<T> Output<T>
where
    T: Display,
{
    pub fn new(path: &Path, value: T, value_type: String, data_context: DataContext) -> Self {
        return Self {
            file_path: path.to_owned(),
            value,
            value_type,
            data_context,
        };
    }
}

#[derive(Debug, PartialEq, Default)]
pub struct DataContext {
    data: Vec<u8>,
    offset: usize,

    /// zero index of value in data
    value_index: usize,
    /// size of value
    value_size: usize,
}

impl DataContext {
    pub fn new(data: Vec<u8>, offset: usize) -> Self {
        let size = data.len();
        return DataContext {
            data,
            offset,
            value_index: 0,
            value_size: size,
        };
    }

    // TODO(danilan): add with_context()

    fn value_as_slice(&self) -> &[u8] {
        let range = self.value_index..(self.value_index + self.value_size);
        return &self.data[range];
    }
}

// TODO(danilan): Consider moving to newtypes implementing display
#[derive(Default)]
pub struct SimpleOutput {}

impl SimpleOutput {
    #[must_use]
    pub fn new() -> Self {
        return Self::default();
    }
}

pub trait Stringifier<T: Display> {
    fn stringify(&self, output: Output<T>) -> String;
}

impl<T: Display> Stringifier<T> for SimpleOutput {
    fn stringify(&self, output: Output<T>) -> String {
        return format!(
            "{}: [{:#01X}] {}: {} [{}]",
            output.file_path.display(),
            output.data_context.offset,
            output.value_type,
            output.value,
            hex::encode(output.data_context.value_as_slice()),
        );
    }
}