pacifica-rs 1.0.0

rust implementation of PacificA: Replication in Log-Based Distributed Storage Systems
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

use std::error::Error;
use std::fmt::{Debug, Display, Formatter};
use anyerror::AnyError;
use bytes::Bytes;

pub trait Codec<T> {

    ///Usually used to encode your Request
    fn encode(entry: &T) -> Result<Bytes, EncodeError<T>>;

    ///Usually used to decode your Request
    fn decode(bytes: Bytes) -> Result<T, DecodeError>;
}

#[derive(Clone, PartialEq, Eq)]
pub struct EncodeError<T>
{
    pub encode: T,
    pub source: AnyError,
}

#[derive(Clone, PartialEq, Eq)]
pub struct DecodeError
{
    pub decode: Bytes,
    pub source: AnyError,
}

impl DecodeError {

    pub fn new(decode: Bytes, source: AnyError) -> Self {
        DecodeError {
            decode,
            source,
        }
    }

    pub fn with_msg(decode: Bytes, msg: impl ToString) -> Self {
        DecodeError {
            decode,
            source: AnyError::error(msg),
        }
    }
}
impl<T> Debug for EncodeError<T> {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        write!(f, "Failed to encode. error: {}", self.source)
    }
}

impl<T> Display for EncodeError<T> {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        write!(f, "{:?}", self)
    }
}

impl<T> Error for EncodeError<T> {

}



impl Debug for DecodeError {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        write!(f, "Failed to decode. bytes:[len={}], error: {}", self.decode.len(),  self.source)
    }
}

impl Display for DecodeError {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        write!(f, "{:?}", self)
    }
}

impl Error for DecodeError {}