libdb 0.1.1

statically linked rust bindings for Berkeley DB
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

use std::slice;
use std::ops::Deref;
use libc;
use libc::c_void;
use std::fmt;

use libdb_sys::ffi;

pub enum DBT<'a> {
    Owned(&'a [u8]),
    Ptr(ffi::DBT),
}

// impl<'a> DBT<'a> {

//     fn as_bytes(&self) -> [u8] {
//         *self
//     }
// }

impl<'a> DBT<'a> {

    pub fn as_slice(&self) -> &[u8] {
        match self {
            &DBT::Owned(s) => s,
            &DBT::Ptr(ptr) => unsafe { slice::from_raw_parts(ptr.data as *const u8, ptr.size as usize) }
        }
    }
}

impl<'a> fmt::Debug for DBT<'a> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{:?}", self.as_slice())
    }
}

impl<'a> Drop for DBT<'a> {
    fn drop(&mut self) {
        if let &mut DBT::Ptr(ptr) = self {
            unsafe { libc::free(ptr.data as *mut c_void); }
        }
    }
}

impl<'a> Deref for DBT<'a> {
    type Target = [u8];

    fn deref(&self) -> &[u8] {
        self.as_slice()
    }
}

impl<'a> From<ffi::DBT> for DBT<'a> {
    fn from(ptr: ffi::DBT) -> Self {
        DBT::Ptr(ptr)
    }
}



// / A database thang
// /
// / 
// pub struct DBT<'a> {
//     /// Pointer to the data.
//     data: *mut u8,

//     // Length of the data.
//     size: u32,

//     // Length of a user-supplied buffer.
//     ulen: u32,

//     // dlen and doff are used by BDB for partial reads/updates
//     dlen: u32,
//     doff: u32,
// }

// impl DBT {

//     pub fn from_raw_parts(data: *mut u8, len: u32) -> DBT {
//         DBT {
//             data: data,
//             size: len,
//             ulen: len,
//             dlen: 0,
//             doff: 0,
//         }
//     }

//     pub fn len(&self) -> u32 {
//         self.size
//     }

//     pub fn as_mut_ptr(&mut self) -> *mut u8 {
//         self.data
//     }
// }

// impl From<&mut [u8]> for DBT {
//     fn from(data: &mut [u8]) -> Self {

//     }
// }

// impl Deref for DBT {
//     type Target = [u8];

//     fn deref(&self) -> &[u8] {
//         unsafe { slice::from_raw_parts(self.data, self.size as usize) }
//     }
// }

// impl Drop for DBT {
//     fn drop(&mut self) {
//         unsafe {
//             libc::free(self.data as *mut c_void);
//         }
//     }
// }