bee2-rs 0.2.3

Bindings for cryptographic library Bee2
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
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

use std::error::Error;

pub trait Bee2Error: Error {}

#[cfg(any(
    feature = "bign",
    feature = "belt",
    feature = "block",
    feature = "brng"
))]
macro_rules! error {
    ($visibility:vis struct $name:ident { $($struct_field_name:ident: $struct_field_type:ty),* $(,)? }, Default { $($struct_init:tt),* $(,)? } $(,)?) => {
        #[derive(Debug)]
        #[allow(dead_code)]
        $visibility struct $name {
            $(
                $visibility $struct_field_name: $struct_field_type
            ),*
            // $($struct_fields)*
        }

        impl $name {
            pub fn new_box($($struct_field_name: $struct_field_type),*) -> Box<dyn Bee2Error> {
                Box::new(Self {
                    $($struct_init),*
                }) as Box<dyn Bee2Error>
            }
        }

        impl std::fmt::Display for $name {
            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                std::fmt::Debug::fmt(&self, f)
            }
        }

        impl Error for $name {}
        impl Bee2Error for $name {}
    };
    ($visibility:vis struct $name:ident { $($struct_field_name:ident: $struct_field_type:ty),* } Default { $($struct_init:tt),* } enum $enum_name:ident { $($enum_field:ident $(($($enum_value:ty),*))?,)* } $(,)?) => {
        #[derive(Debug)]
        $visibility enum $enum_name {
            $($enum_field $(($($enum_value),*))?),*
        }
        error!(
            $visibility struct $name {
                kind: $enum_name,
                $($struct_field_name: $struct_field_type),*
            }, Default {
                kind,
                $($struct_init),*
            }
        );
    };
}

#[cfg(feature = "bign")]
error!(
    pub struct AnyError {
        error: Box<dyn std::error::Error>,
    },
    Default { error }
);
#[cfg(feature = "belt")]
error!(pub struct InvalidBlockError {}, Default {});
#[cfg(feature = "block")]
error!(
    pub struct InvalidPaddingError {}
    Default {}
    enum InvalidPaddingErrorKind {
        // `data`.
        NoBlocks(Vec<Box<[u8]>>),
        // `data`.
        NoData(Vec<Box<[u8]>>),
        // `data`, `last_block_byte_index`, `padding_byte`, `last_padding_byte`.
        InvalidPaddingData(Vec<Box<[u8]>>, usize, u8, u8),
        // `data`, `block_index`, `block_size`, `len_of_current_block`.
        DifferentBlockSizes(Vec<Box<[u8]>>, usize, u8, u8),
        // `data`, `expected_data_in_last_block`, `last_blocK_len`.
        NotEnoughData(Vec<Box<[u8]>>, u8, u8),
    }
);
#[cfg(feature = "bign")]
error!(
    pub struct BignError {
        code: u32,
    },
    Default { code }
);
#[cfg(feature = "bash")]
error!(
    pub struct BashError {}
    Default {}
    enum BashErrorKind {
        InvalidResistanceLevel,
        HashLengthIsTooLarge,
        CodeError(u32),
    }
);
#[cfg(feature = "brng")]
error!(
    pub struct BrngError {}
    Default {}
    enum BrngErrorKind {
        CodeError(u32),
    }
);
#[cfg(feature = "belt")]
error!(
    pub struct BeltError {}
    Default {}
    enum BeltErrorKind {
        CodeError(u32),
    }
);

pub type Result<T> = core::result::Result<T, Box<dyn Bee2Error>>;
pub type Bee2Result<T> = Result<T>;