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

//! Reference counted handles to various TableProperties* types, that safely
//! preserve destruction order.

use crocksdb_ffi::{
    DBTableProperties, DBTablePropertiesCollection, DBTablePropertiesCollectionIterator,
    DBUserCollectedProperties,
};
use librocksdb_sys as crocksdb_ffi;
use std::rc::Rc;

/// This is a shared wrapper around a DBTablePropertiesCollection w/ dtor
#[derive(Clone)]
pub struct TablePropertiesCollectionHandle {
    shared: Rc<TablePropertiesCollectionHandleWithDrop>,
}

impl TablePropertiesCollectionHandle {
    pub unsafe fn new(ptr: *mut DBTablePropertiesCollection) -> TablePropertiesCollectionHandle {
        assert!(!ptr.is_null());
        TablePropertiesCollectionHandle {
            shared: Rc::new(TablePropertiesCollectionHandleWithDrop { ptr }),
        }
    }

    pub fn ptr(&self) -> *mut DBTablePropertiesCollection {
        self.shared.ptr
    }
}

struct TablePropertiesCollectionHandleWithDrop {
    ptr: *mut DBTablePropertiesCollection,
}

impl Drop for TablePropertiesCollectionHandleWithDrop {
    fn drop(&mut self) {
        unsafe {
            crocksdb_ffi::crocksdb_table_properties_collection_destroy(self.ptr);
        }
    }
}

/// This is a shared wrapper around a DBTablePropertiesCollection w/ dtor.
//
// # Safety
//
// The safety of this struct depends on drop order, with the iterator
// needing to drop before the collection.
#[derive(Clone)]
pub struct TablePropertiesCollectionIteratorHandle {
    shared: Rc<TablePropertiesCollectionIteratorHandleWithDrop>,
    collection: TablePropertiesCollectionHandle,
}

impl TablePropertiesCollectionIteratorHandle {
    pub fn new(
        collection: TablePropertiesCollectionHandle,
    ) -> TablePropertiesCollectionIteratorHandle {
        unsafe {
            let ptr =
                crocksdb_ffi::crocksdb_table_properties_collection_iter_create(collection.ptr());
            TablePropertiesCollectionIteratorHandle {
                shared: Rc::new(TablePropertiesCollectionIteratorHandleWithDrop { ptr }),
                collection,
            }
        }
    }

    pub fn ptr(&self) -> *mut DBTablePropertiesCollectionIterator {
        self.shared.ptr
    }
}

struct TablePropertiesCollectionIteratorHandleWithDrop {
    ptr: *mut DBTablePropertiesCollectionIterator,
}

impl Drop for TablePropertiesCollectionIteratorHandleWithDrop {
    fn drop(&mut self) {
        unsafe {
            crocksdb_ffi::crocksdb_table_properties_collection_iter_destroy(self.ptr);
        }
    }
}

// # Safety
//
// `ptr` is valid as long as the iterator is
#[derive(Clone)]
pub struct TablePropertiesHandle {
    ptr: *const DBTableProperties,
    iter_handle: TablePropertiesCollectionIteratorHandle,
}

impl TablePropertiesHandle {
    pub fn new(
        ptr: *const DBTableProperties,
        iter_handle: TablePropertiesCollectionIteratorHandle,
    ) -> TablePropertiesHandle {
        TablePropertiesHandle { ptr, iter_handle }
    }

    pub fn ptr(&self) -> *const DBTableProperties {
        self.ptr
    }
}

// # Safety
//
// `ptr` is valid as long as the table properties are
#[derive(Clone)]
pub struct UserCollectedPropertiesHandle {
    ptr: *const DBUserCollectedProperties,
    table_props_handle: TablePropertiesHandle,
}

impl UserCollectedPropertiesHandle {
    pub fn new(table_props_handle: TablePropertiesHandle) -> UserCollectedPropertiesHandle {
        unsafe {
            let ptr = crocksdb_ffi::crocksdb_table_properties_get_user_properties(
                table_props_handle.ptr(),
            );
            UserCollectedPropertiesHandle {
                ptr,
                table_props_handle,
            }
        }
    }

    pub fn ptr(&self) -> *const DBUserCollectedProperties {
        self.ptr
    }
}