rs-leveldb 0.1.5

Almost-complete bindings for leveldb for Rust.
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
127
128
129
130
131
132
133
134

//! leveldb snapshots
//!
//! Snapshots give you a reference to the database at a certain
//! point in time and won't change while you work with them.
use leveldb_sys::*;

use super::db::Database;
use super::error::Error;
use super::options::{ReadOptions, c_readoptions};
use super::key::IntoLevelDBKey;
use super::iterator::{Iterable, Iterator, KeyIterator, ValueIterator};
use super::bytes::Bytes;
use std::ptr;
use libc::{c_char, size_t};

#[allow(missing_docs)]
struct RawSnapshot {
    db_ptr: *mut leveldb_t,
    ptr: *mut leveldb_snapshot_t,
}

impl Drop for RawSnapshot {
    fn drop(&mut self) {
        unsafe { leveldb_release_snapshot(self.db_ptr, self.ptr) };
    }
}

/// A database snapshot
///
/// Represents a database at a certain point in time,
/// and allows for all read operations (get and iteration).
pub struct Snapshot<'a> {
    raw: RawSnapshot,
    database: &'a Database,
}


impl<'a> Snapshot<'a> {
    /// fetches a key from the database
    ///
    /// Inserts this snapshot into ReadOptions before reading

    pub fn get(&self,
                  options: &ReadOptions,
                  key: &dyn IntoLevelDBKey)
                  -> Result<Option<Vec<u8>>, Error> {
        key.as_u8_slice_for_get(& |k| {
            self.get_u8(options, k)
        })
    }


    /// override the get_u8 of Database. Overriding is for avoiding the snapshot field of ReadOption,
    /// if so, a lifetime parameter must be added for ReadOption.
    pub fn get_u8(&self,
               options: &ReadOptions,
               key: &[u8])
               -> Result<Option<Vec<u8>>, Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let mut length: size_t = 0;
            let c_readoptions = c_readoptions(options);

            // add the extra snapshot information to c_readoptions
            leveldb_readoptions_set_snapshot(c_readoptions, self.raw_ptr());

            let result = leveldb_get(self.database.database.ptr,
                                     c_readoptions,
                                     key.as_ptr() as *mut c_char,
                                     key.len() as size_t,
                                     &mut length,
                                     &mut error);

            leveldb_readoptions_destroy(c_readoptions);

            if error == ptr::null_mut() {
                let bytes_opt = Bytes::from_raw(result as *mut u8, length);

                Ok(bytes_opt.map(|val| {val.into()}))
            } else {
                Err(Error::new_from_char(error))
            }
        }

    }

    #[inline]
    #[allow(missing_docs)]
    pub fn raw_ptr(&self) -> *mut leveldb_snapshot_t {
        self.raw.ptr
    }
}

/// Structs implementing the Snapshots trait can be
/// snapshotted.
pub trait Snapshots {
    /// Creates a snapshot and returns a struct
    /// representing it.
    fn snapshot(&self) -> Snapshot;
}

impl Snapshots for Database {
    fn snapshot(&self) -> Snapshot {
        let db_str = self.database.ptr;
        let snap = unsafe {
            leveldb_create_snapshot(db_str)
        };

        let raw = RawSnapshot {
            db_ptr: db_str,
            ptr: snap,
        };

        Snapshot {
            raw,
            database: self
        }
    }
}

impl<'a> Iterable<'a> for Snapshot<'a> {
    fn iter(&'a self, options: &ReadOptions) -> Iterator<'a> {
        Iterator::new(self.database, options, Some(self))
    }

    fn keys_iter(&'a self, options: &ReadOptions) -> KeyIterator<'a> {
        KeyIterator::new(self.database, options, Some(self))
    }

    fn value_iter(&'a self, options: &ReadOptions)-> ValueIterator<'a> {
        ValueIterator::new(self.database, options, Some(self))
    }
}