siamesedb 0.1.23

The simple local key-value store.
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
118
119
120
121
122
123
124
125
126

use super::super::super::{DbMapKeyType, HashValue};
use super::FileDbMap;
use std::fmt::{Display, Error, Formatter};
use std::ops::Deref;

/// DbBytes Map in a file databse.
pub type FileDbMapDbBytes = FileDbMap<DbBytes>;

/// db-key type. `&[u8]` can be used as keys.
#[derive(Debug, Default, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
pub struct DbBytes(Vec<u8>);

impl DbMapKeyType for DbBytes {
    #[inline]
    fn from_bytes(bytes: &[u8]) -> Self {
        DbBytes(bytes.to_vec())
    }
    #[inline]
    fn signature() -> [u8; 8] {
        *b"bytes\0\0\0"
    }
    #[inline]
    fn as_bytes(&self) -> &[u8] {
        self.0.as_slice()
    }
    #[inline]
    fn cmp_u8(&self, other: &[u8]) -> std::cmp::Ordering {
        self.0.as_slice().cmp(other)
    }
}
impl HashValue for DbBytes {}

impl Display for DbBytes {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
        let ss = String::from_utf8_lossy(&self.0).to_string();
        write!(f, "'{}'", ss)
    }
}

impl Deref for DbBytes {
    type Target = [u8];
    #[inline]
    fn deref(&self) -> &<Self as Deref>::Target {
        &self.0
    }
}

/*
impl Borrow<[u8]> for DbBytes {
    fn borrow(&self) -> &[u8] {
        &self.0
    }
}
*/

impl From<&[u8]> for DbBytes {
    #[inline]
    fn from(a: &[u8]) -> Self {
        DbBytes(a.to_vec())
    }
}

impl From<Vec<u8>> for DbBytes {
    #[inline]
    fn from(a: Vec<u8>) -> Self {
        DbBytes(a)
    }
}

impl From<&str> for DbBytes {
    #[inline]
    fn from(a: &str) -> Self {
        DbBytes(a.as_bytes().to_vec())
    }
}

impl From<String> for DbBytes {
    #[inline]
    fn from(a: String) -> Self {
        DbBytes(a.into_bytes())
    }
}

impl From<&String> for DbBytes {
    #[inline]
    fn from(a: &String) -> Self {
        DbBytes(a.as_bytes().to_vec())
    }
}

impl<const N: usize> From<&[u8; N]> for DbBytes {
    #[inline]
    fn from(a: &[u8; N]) -> Self {
        DbBytes(a.to_vec())
    }
}

impl From<u64> for DbBytes {
    #[inline]
    fn from(a: u64) -> Self {
        DbBytes(a.to_be_bytes().to_vec())
    }
}

impl From<&u64> for DbBytes {
    #[inline]
    fn from(a: &u64) -> Self {
        DbBytes(a.to_be_bytes().to_vec())
    }
}

/*
impl From<DbBytes> for DbBytes {
    #[inline]
    fn from(a: DbBytes) -> Self {
        DbBytes(a.0)
    }
}
*/

impl From<&DbBytes> for DbBytes {
    #[inline]
    fn from(a: &DbBytes) -> Self {
        DbBytes(a.0.clone())
    }
}