msb-imago 0.1.4

A library for accessing virtual machine disk images.
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
94

//! Helper macros.

pub(crate) mod on_disk_struct;

/// Implements `TryFrom` for enums from their numerical representation.
macro_rules! numerical_enum {
    (
        $(#[$attr:meta])*
        $vis:vis enum $enum_name:ident as $repr:tt {
            $(
                $(#[$id_attr:meta])*
                $identifier:ident = $value:expr,
            )+
        }
    ) => {
        $(#[$attr])*
        #[derive(Copy, Clone, Debug, Eq, PartialEq)]
        #[repr($repr)]
        $vis enum $enum_name {
            $(
                $(#[$id_attr])*
                $identifier = $value,
            )+
        }

        impl TryFrom<$repr> for $enum_name {
            type Error = std::io::Error;

            fn try_from(val: $repr) -> std::io::Result<Self> {
                match val {
                    $(x if x == $value => Ok($enum_name::$identifier),)*
                    _ => Err(std::io::Error::new(
                            std::io::ErrorKind::InvalidData,
                            format!(
                                "Invalid value for {}: {val:x}",
                                stringify!($enum_name),
                            ),
                    )),
                }
            }
        }
    }
}

pub(crate) use numerical_enum;

/// Implements a function as itself.
///
/// For traits that generalize interfaces that duplicate what we have on the struct itself, too.
/// For example, we want to have `IoVectorTrait`, but not export it; requiring users to import that
/// trait just for `.len()` is silly.  So `.len()` is implemented directly on both `IoVector` and
/// `IoVectorMut` -- still, we want to have a generic `IoVectorTrait::len()`, too.  This is what
/// this macro implements.
macro_rules! passthrough_trait_fn {
    { fn $name:ident($($param:ident: $type:ty),*) -> $ret:ty; } => {
        fn $name($($param: $type),*) -> $ret {
            Self::$name($($param),*)
        }
    };

    { fn $name:ident(self$(, $param:ident: $type:ty)*) -> $ret:ty; } => {
        passthrough_trait_fn! { fn $name(self: Self$(, $param: $type)*) -> $ret; }
    };

    { fn $name:ident(&self$(, $param:ident: $type:ty)*) -> $ret:ty; } => {
        passthrough_trait_fn! { fn $name(self: &Self$(, $param: $type)*) -> $ret; }
    };

    { fn $name:ident(&mut self$(, $param:ident: $type:ty)*) -> $ret:ty; } => {
        passthrough_trait_fn! { fn $name(self: &mut Self$(, $param: $type)*) -> $ret; }
    };

    { fn $name:ident(self$(, $param:ident: $type:ty)*); } => {
        passthrough_trait_fn! { fn $name(self$(, $param: $type)*) -> (); }
    };

    { fn $name:ident(&self$(, $param:ident: $type:ty)*); } => {
        passthrough_trait_fn! { fn $name(&self$(, $param: $type)*) -> (); }
    };

    { fn $name:ident(&mut self$(, $param:ident: $type:ty)*); } => {
        passthrough_trait_fn! { fn $name(&mut self$(, $param: $type)*) -> (); }
    };
}

pub(crate) use passthrough_trait_fn;

/// Evaluate to the last element in the list, separated by commas.
macro_rules! last_element {
    ($x:expr) => ($x);
    ($x:expr, $($tail:expr),+) => ($crate::macros::last_element!($($tail),+));
}

pub(crate) use last_element;