use leveldb_sys::*;
use database::cache::Cache;
use database::snapshots::Snapshot;
use libc::size_t;
pub struct Options {
pub create_if_missing: bool,
pub error_if_exists: bool,
pub paranoid_checks: bool,
pub write_buffer_size: Option<size_t>,
pub max_open_files: Option<i32>,
pub block_size: Option<size_t>,
pub block_restart_interval: Option<i32>,
pub compression: Compression,
pub cache: Option<Cache>,
}
impl Options {
#[allow(clippy::new_without_default)]
pub fn new() -> Options {
Options {
create_if_missing: false,
error_if_exists: false,
paranoid_checks: false,
write_buffer_size: None,
max_open_files: None,
block_size: None,
block_restart_interval: None,
compression: Compression::No,
cache: None,
}
}
}
#[derive(Copy, Clone)]
pub struct WriteOptions {
pub sync: bool,
}
impl WriteOptions {
#[allow(clippy::new_without_default)]
pub fn new() -> WriteOptions {
WriteOptions { sync: false }
}
}
#[allow(missing_copy_implementations)]
pub struct ReadOptions<'a> {
pub verify_checksums: bool,
pub fill_cache: bool,
pub snapshot: Option<&'a Snapshot<'a>>,
}
impl<'a> ReadOptions<'a> {
#[allow(clippy::new_without_default)]
pub fn new() -> ReadOptions<'a> {
ReadOptions {
verify_checksums: false,
fill_cache: true,
snapshot: None,
}
}
}
#[allow(missing_docs, clippy::missing_safety_doc)]
pub unsafe fn c_options(
options: &Options,
comparator: Option<*mut leveldb_comparator_t>,
) -> *mut leveldb_options_t {
let c_options = leveldb_options_create();
leveldb_options_set_create_if_missing(c_options, options.create_if_missing as u8);
leveldb_options_set_error_if_exists(c_options, options.error_if_exists as u8);
leveldb_options_set_paranoid_checks(c_options, options.paranoid_checks as u8);
if let Some(wbs) = options.write_buffer_size {
leveldb_options_set_write_buffer_size(c_options, wbs);
}
if let Some(mf) = options.max_open_files {
leveldb_options_set_max_open_files(c_options, mf);
}
if let Some(bs) = options.block_size {
leveldb_options_set_block_size(c_options, bs);
}
if let Some(bi) = options.block_restart_interval {
leveldb_options_set_block_restart_interval(c_options, bi);
}
leveldb_options_set_compression(c_options, options.compression);
if let Some(c) = comparator {
leveldb_options_set_comparator(c_options, c);
}
if let Some(ref cache) = options.cache {
leveldb_options_set_cache(c_options, cache.raw_ptr());
}
c_options
}
#[allow(missing_docs, clippy::missing_safety_doc)]
pub unsafe fn c_writeoptions(options: WriteOptions) -> *mut leveldb_writeoptions_t {
let c_writeoptions = leveldb_writeoptions_create();
leveldb_writeoptions_set_sync(c_writeoptions, options.sync as u8);
c_writeoptions
}
#[allow(missing_docs, clippy::missing_safety_doc)]
pub unsafe fn c_readoptions<'a>(options: &ReadOptions<'a>) -> *mut leveldb_readoptions_t {
let c_readoptions = leveldb_readoptions_create();
leveldb_readoptions_set_verify_checksums(c_readoptions, options.verify_checksums as u8);
leveldb_readoptions_set_fill_cache(c_readoptions, options.fill_cache as u8);
if let Some(ref snapshot) = options.snapshot {
leveldb_readoptions_set_snapshot(c_readoptions, snapshot.raw_ptr());
}
c_readoptions
}