fugue-db 0.2.16

A binary analysis framework written in Rust
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::ops::Deref;
use std::path::PathBuf;
use url::Url;

#[derive(Debug)]
pub enum Imported {
    Bytes(Vec<u8>),
    File(PathBuf),
}

/// The Backend trait for adding support for new backend
/// # Example
/// ```
/// use fugue_db::backend::{Backend, DatabaseImporterBackend, Imported};
/// use fugue_db::Error;
/// use url::Url;
/// pub struct MyNewTool{}
/// impl Backend for MyNewTool {
///     type Error = Error;
///     fn name(&self) -> &'static str {
///         "fugue-my-new-tool"
///     }
///     fn is_available(&self) -> bool {
///        todo!()
///     }
///     // ...
///     fn import(&self, program: &Url) -> Result<Imported, Self::Error> {
///         todo!()
///     }
///     fn is_preferred_for(&self, _: &Url) -> Option<bool> { todo!() }
/// }
/// ```
pub trait Backend {
    type Error: Into<crate::Error>;

    fn name(&self) -> &'static str;

    fn is_available(&self) -> bool;
    fn is_preferred_for(&self, path: &Url) -> Option<bool>;

    fn import(&self, program: &Url) -> Result<Imported, Self::Error>;
}

/// Wrapper for Backend 
#[repr(transparent)]
struct Importer<B, E>(B)
where
    B: Backend<Error = E>;

impl<B, E> Backend for Importer<B, E>
where
    B: Backend<Error = E>,
    E: Into<crate::Error>,
{
    type Error = crate::Error;

    fn name(&self) -> &'static str {
        self.0.name()
    }

    fn is_available(&self) -> bool {
        self.0.is_available()
    }

    fn is_preferred_for(&self, path: &Url) -> Option<bool> {
        self.0.is_preferred_for(path)
    }

    fn import(&self, program: &Url) -> Result<Imported, Self::Error> {
        self.0.import(program).map_err(|e| e.into())
    }
}

#[repr(transparent)]
pub struct DatabaseImporterBackend(Box<dyn Backend<Error = crate::Error>>);

impl DatabaseImporterBackend {
    pub fn new<B, E>(backend: B) -> Self
    where
        B: Backend<Error = E> + 'static,
        E: Into<crate::Error> + 'static,
    {
        Self(Box::new(Importer(backend)))
    }
}

impl Deref for DatabaseImporterBackend {
    type Target = dyn Backend<Error=crate::Error>;

    fn deref(&self) -> &Self::Target {
        &*self.0
    }
}