summaryrefslogtreecommitdiff
path: root/src/leveldb/include
diff options
context:
space:
mode:
Diffstat (limited to 'src/leveldb/include')
-rw-r--r--src/leveldb/include/leveldb/c.h291
-rw-r--r--src/leveldb/include/leveldb/cache.h99
-rw-r--r--src/leveldb/include/leveldb/comparator.h63
-rw-r--r--src/leveldb/include/leveldb/db.h161
-rw-r--r--src/leveldb/include/leveldb/env.h333
-rw-r--r--src/leveldb/include/leveldb/filter_policy.h70
-rw-r--r--src/leveldb/include/leveldb/iterator.h100
-rw-r--r--src/leveldb/include/leveldb/options.h195
-rw-r--r--src/leveldb/include/leveldb/slice.h109
-rw-r--r--src/leveldb/include/leveldb/status.h106
-rw-r--r--src/leveldb/include/leveldb/table.h85
-rw-r--r--src/leveldb/include/leveldb/table_builder.h92
-rw-r--r--src/leveldb/include/leveldb/write_batch.h64
13 files changed, 0 insertions, 1768 deletions
diff --git a/src/leveldb/include/leveldb/c.h b/src/leveldb/include/leveldb/c.h
deleted file mode 100644
index 1fa58866c..000000000
--- a/src/leveldb/include/leveldb/c.h
+++ /dev/null
@@ -1,291 +0,0 @@
-/* Copyright (c) 2011 The LevelDB Authors. All rights reserved.
- Use of this source code is governed by a BSD-style license that can be
- found in the LICENSE file. See the AUTHORS file for names of contributors.
-
- C bindings for leveldb. May be useful as a stable ABI that can be
- used by programs that keep leveldb in a shared library, or for
- a JNI api.
-
- Does not support:
- . getters for the option types
- . custom comparators that implement key shortening
- . capturing post-write-snapshot
- . custom iter, db, env, cache implementations using just the C bindings
-
- Some conventions:
-
- (1) We expose just opaque struct pointers and functions to clients.
- This allows us to change internal representations without having to
- recompile clients.
-
- (2) For simplicity, there is no equivalent to the Slice type. Instead,
- the caller has to pass the pointer and length as separate
- arguments.
-
- (3) Errors are represented by a null-terminated c string. NULL
- means no error. All operations that can raise an error are passed
- a "char** errptr" as the last argument. One of the following must
- be true on entry:
- *errptr == NULL
- *errptr points to a malloc()ed null-terminated error message
- (On Windows, *errptr must have been malloc()-ed by this library.)
- On success, a leveldb routine leaves *errptr unchanged.
- On failure, leveldb frees the old value of *errptr and
- set *errptr to a malloc()ed error message.
-
- (4) Bools have the type unsigned char (0 == false; rest == true)
-
- (5) All of the pointer arguments must be non-NULL.
-*/
-
-#ifndef STORAGE_LEVELDB_INCLUDE_C_H_
-#define STORAGE_LEVELDB_INCLUDE_C_H_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include <stdarg.h>
-#include <stddef.h>
-#include <stdint.h>
-
-/* Exported types */
-
-typedef struct leveldb_t leveldb_t;
-typedef struct leveldb_cache_t leveldb_cache_t;
-typedef struct leveldb_comparator_t leveldb_comparator_t;
-typedef struct leveldb_env_t leveldb_env_t;
-typedef struct leveldb_filelock_t leveldb_filelock_t;
-typedef struct leveldb_filterpolicy_t leveldb_filterpolicy_t;
-typedef struct leveldb_iterator_t leveldb_iterator_t;
-typedef struct leveldb_logger_t leveldb_logger_t;
-typedef struct leveldb_options_t leveldb_options_t;
-typedef struct leveldb_randomfile_t leveldb_randomfile_t;
-typedef struct leveldb_readoptions_t leveldb_readoptions_t;
-typedef struct leveldb_seqfile_t leveldb_seqfile_t;
-typedef struct leveldb_snapshot_t leveldb_snapshot_t;
-typedef struct leveldb_writablefile_t leveldb_writablefile_t;
-typedef struct leveldb_writebatch_t leveldb_writebatch_t;
-typedef struct leveldb_writeoptions_t leveldb_writeoptions_t;
-
-/* DB operations */
-
-extern leveldb_t* leveldb_open(
- const leveldb_options_t* options,
- const char* name,
- char** errptr);
-
-extern void leveldb_close(leveldb_t* db);
-
-extern void leveldb_put(
- leveldb_t* db,
- const leveldb_writeoptions_t* options,
- const char* key, size_t keylen,
- const char* val, size_t vallen,
- char** errptr);
-
-extern void leveldb_delete(
- leveldb_t* db,
- const leveldb_writeoptions_t* options,
- const char* key, size_t keylen,
- char** errptr);
-
-extern void leveldb_write(
- leveldb_t* db,
- const leveldb_writeoptions_t* options,
- leveldb_writebatch_t* batch,
- char** errptr);
-
-/* Returns NULL if not found. A malloc()ed array otherwise.
- Stores the length of the array in *vallen. */
-extern char* leveldb_get(
- leveldb_t* db,
- const leveldb_readoptions_t* options,
- const char* key, size_t keylen,
- size_t* vallen,
- char** errptr);
-
-extern leveldb_iterator_t* leveldb_create_iterator(
- leveldb_t* db,
- const leveldb_readoptions_t* options);
-
-extern const leveldb_snapshot_t* leveldb_create_snapshot(
- leveldb_t* db);
-
-extern void leveldb_release_snapshot(
- leveldb_t* db,
- const leveldb_snapshot_t* snapshot);
-
-/* Returns NULL if property name is unknown.
- Else returns a pointer to a malloc()-ed null-terminated value. */
-extern char* leveldb_property_value(
- leveldb_t* db,
- const char* propname);
-
-extern void leveldb_approximate_sizes(
- leveldb_t* db,
- int num_ranges,
- const char* const* range_start_key, const size_t* range_start_key_len,
- const char* const* range_limit_key, const size_t* range_limit_key_len,
- uint64_t* sizes);
-
-extern void leveldb_compact_range(
- leveldb_t* db,
- const char* start_key, size_t start_key_len,
- const char* limit_key, size_t limit_key_len);
-
-/* Management operations */
-
-extern void leveldb_destroy_db(
- const leveldb_options_t* options,
- const char* name,
- char** errptr);
-
-extern void leveldb_repair_db(
- const leveldb_options_t* options,
- const char* name,
- char** errptr);
-
-/* Iterator */
-
-extern void leveldb_iter_destroy(leveldb_iterator_t*);
-extern unsigned char leveldb_iter_valid(const leveldb_iterator_t*);
-extern void leveldb_iter_seek_to_first(leveldb_iterator_t*);
-extern void leveldb_iter_seek_to_last(leveldb_iterator_t*);
-extern void leveldb_iter_seek(leveldb_iterator_t*, const char* k, size_t klen);
-extern void leveldb_iter_next(leveldb_iterator_t*);
-extern void leveldb_iter_prev(leveldb_iterator_t*);
-extern const char* leveldb_iter_key(const leveldb_iterator_t*, size_t* klen);
-extern const char* leveldb_iter_value(const leveldb_iterator_t*, size_t* vlen);
-extern void leveldb_iter_get_error(const leveldb_iterator_t*, char** errptr);
-
-/* Write batch */
-
-extern leveldb_writebatch_t* leveldb_writebatch_create();
-extern void leveldb_writebatch_destroy(leveldb_writebatch_t*);
-extern void leveldb_writebatch_clear(leveldb_writebatch_t*);
-extern void leveldb_writebatch_put(
- leveldb_writebatch_t*,
- const char* key, size_t klen,
- const char* val, size_t vlen);
-extern void leveldb_writebatch_delete(
- leveldb_writebatch_t*,
- const char* key, size_t klen);
-extern void leveldb_writebatch_iterate(
- leveldb_writebatch_t*,
- void* state,
- void (*put)(void*, const char* k, size_t klen, const char* v, size_t vlen),
- void (*deleted)(void*, const char* k, size_t klen));
-
-/* Options */
-
-extern leveldb_options_t* leveldb_options_create();
-extern void leveldb_options_destroy(leveldb_options_t*);
-extern void leveldb_options_set_comparator(
- leveldb_options_t*,
- leveldb_comparator_t*);
-extern void leveldb_options_set_filter_policy(
- leveldb_options_t*,
- leveldb_filterpolicy_t*);
-extern void leveldb_options_set_create_if_missing(
- leveldb_options_t*, unsigned char);
-extern void leveldb_options_set_error_if_exists(
- leveldb_options_t*, unsigned char);
-extern void leveldb_options_set_paranoid_checks(
- leveldb_options_t*, unsigned char);
-extern void leveldb_options_set_env(leveldb_options_t*, leveldb_env_t*);
-extern void leveldb_options_set_info_log(leveldb_options_t*, leveldb_logger_t*);
-extern void leveldb_options_set_write_buffer_size(leveldb_options_t*, size_t);
-extern void leveldb_options_set_max_open_files(leveldb_options_t*, int);
-extern void leveldb_options_set_cache(leveldb_options_t*, leveldb_cache_t*);
-extern void leveldb_options_set_block_size(leveldb_options_t*, size_t);
-extern void leveldb_options_set_block_restart_interval(leveldb_options_t*, int);
-
-enum {
- leveldb_no_compression = 0,
- leveldb_snappy_compression = 1
-};
-extern void leveldb_options_set_compression(leveldb_options_t*, int);
-
-/* Comparator */
-
-extern leveldb_comparator_t* leveldb_comparator_create(
- void* state,
- void (*destructor)(void*),
- int (*compare)(
- void*,
- const char* a, size_t alen,
- const char* b, size_t blen),
- const char* (*name)(void*));
-extern void leveldb_comparator_destroy(leveldb_comparator_t*);
-
-/* Filter policy */
-
-extern leveldb_filterpolicy_t* leveldb_filterpolicy_create(
- void* state,
- void (*destructor)(void*),
- char* (*create_filter)(
- void*,
- const char* const* key_array, const size_t* key_length_array,
- int num_keys,
- size_t* filter_length),
- unsigned char (*key_may_match)(
- void*,
- const char* key, size_t length,
- const char* filter, size_t filter_length),
- const char* (*name)(void*));
-extern void leveldb_filterpolicy_destroy(leveldb_filterpolicy_t*);
-
-extern leveldb_filterpolicy_t* leveldb_filterpolicy_create_bloom(
- int bits_per_key);
-
-/* Read options */
-
-extern leveldb_readoptions_t* leveldb_readoptions_create();
-extern void leveldb_readoptions_destroy(leveldb_readoptions_t*);
-extern void leveldb_readoptions_set_verify_checksums(
- leveldb_readoptions_t*,
- unsigned char);
-extern void leveldb_readoptions_set_fill_cache(
- leveldb_readoptions_t*, unsigned char);
-extern void leveldb_readoptions_set_snapshot(
- leveldb_readoptions_t*,
- const leveldb_snapshot_t*);
-
-/* Write options */
-
-extern leveldb_writeoptions_t* leveldb_writeoptions_create();
-extern void leveldb_writeoptions_destroy(leveldb_writeoptions_t*);
-extern void leveldb_writeoptions_set_sync(
- leveldb_writeoptions_t*, unsigned char);
-
-/* Cache */
-
-extern leveldb_cache_t* leveldb_cache_create_lru(size_t capacity);
-extern void leveldb_cache_destroy(leveldb_cache_t* cache);
-
-/* Env */
-
-extern leveldb_env_t* leveldb_create_default_env();
-extern void leveldb_env_destroy(leveldb_env_t*);
-
-/* Utility */
-
-/* Calls free(ptr).
- REQUIRES: ptr was malloc()-ed and returned by one of the routines
- in this file. Note that in certain cases (typically on Windows), you
- may need to call this routine instead of free(ptr) to dispose of
- malloc()-ed memory returned by this library. */
-extern void leveldb_free(void* ptr);
-
-/* Return the major version number for this release. */
-extern int leveldb_major_version();
-
-/* Return the minor version number for this release. */
-extern int leveldb_minor_version();
-
-#ifdef __cplusplus
-} /* end extern "C" */
-#endif
-
-#endif /* STORAGE_LEVELDB_INCLUDE_C_H_ */
diff --git a/src/leveldb/include/leveldb/cache.h b/src/leveldb/include/leveldb/cache.h
deleted file mode 100644
index 5e3b47637..000000000
--- a/src/leveldb/include/leveldb/cache.h
+++ /dev/null
@@ -1,99 +0,0 @@
-// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file. See the AUTHORS file for names of contributors.
-//
-// A Cache is an interface that maps keys to values. It has internal
-// synchronization and may be safely accessed concurrently from
-// multiple threads. It may automatically evict entries to make room
-// for new entries. Values have a specified charge against the cache
-// capacity. For example, a cache where the values are variable
-// length strings, may use the length of the string as the charge for
-// the string.
-//
-// A builtin cache implementation with a least-recently-used eviction
-// policy is provided. Clients may use their own implementations if
-// they want something more sophisticated (like scan-resistance, a
-// custom eviction policy, variable cache sizing, etc.)
-
-#ifndef STORAGE_LEVELDB_INCLUDE_CACHE_H_
-#define STORAGE_LEVELDB_INCLUDE_CACHE_H_
-
-#include <stdint.h>
-#include "leveldb/slice.h"
-
-namespace leveldb {
-
-class Cache;
-
-// Create a new cache with a fixed size capacity. This implementation
-// of Cache uses a least-recently-used eviction policy.
-extern Cache* NewLRUCache(size_t capacity);
-
-class Cache {
- public:
- Cache() { }
-
- // Destroys all existing entries by calling the "deleter"
- // function that was passed to the constructor.
- virtual ~Cache();
-
- // Opaque handle to an entry stored in the cache.
- struct Handle { };
-
- // Insert a mapping from key->value into the cache and assign it
- // the specified charge against the total cache capacity.
- //
- // Returns a handle that corresponds to the mapping. The caller
- // must call this->Release(handle) when the returned mapping is no
- // longer needed.
- //
- // When the inserted entry is no longer needed, the key and
- // value will be passed to "deleter".
- virtual Handle* Insert(const Slice& key, void* value, size_t charge,
- void (*deleter)(const Slice& key, void* value)) = 0;
-
- // If the cache has no mapping for "key", returns NULL.
- //
- // Else return a handle that corresponds to the mapping. The caller
- // must call this->Release(handle) when the returned mapping is no
- // longer needed.
- virtual Handle* Lookup(const Slice& key) = 0;
-
- // Release a mapping returned by a previous Lookup().
- // REQUIRES: handle must not have been released yet.
- // REQUIRES: handle must have been returned by a method on *this.
- virtual void Release(Handle* handle) = 0;
-
- // Return the value encapsulated in a handle returned by a
- // successful Lookup().
- // REQUIRES: handle must not have been released yet.
- // REQUIRES: handle must have been returned by a method on *this.
- virtual void* Value(Handle* handle) = 0;
-
- // If the cache contains entry for key, erase it. Note that the
- // underlying entry will be kept around until all existing handles
- // to it have been released.
- virtual void Erase(const Slice& key) = 0;
-
- // Return a new numeric id. May be used by multiple clients who are
- // sharing the same cache to partition the key space. Typically the
- // client will allocate a new id at startup and prepend the id to
- // its cache keys.
- virtual uint64_t NewId() = 0;
-
- private:
- void LRU_Remove(Handle* e);
- void LRU_Append(Handle* e);
- void Unref(Handle* e);
-
- struct Rep;
- Rep* rep_;
-
- // No copying allowed
- Cache(const Cache&);
- void operator=(const Cache&);
-};
-
-} // namespace leveldb
-
-#endif // STORAGE_LEVELDB_UTIL_CACHE_H_
diff --git a/src/leveldb/include/leveldb/comparator.h b/src/leveldb/include/leveldb/comparator.h
deleted file mode 100644
index 556b984c7..000000000
--- a/src/leveldb/include/leveldb/comparator.h
+++ /dev/null
@@ -1,63 +0,0 @@
-// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file. See the AUTHORS file for names of contributors.
-
-#ifndef STORAGE_LEVELDB_INCLUDE_COMPARATOR_H_
-#define STORAGE_LEVELDB_INCLUDE_COMPARATOR_H_
-
-#include <string>
-
-namespace leveldb {
-
-class Slice;
-
-// A Comparator object provides a total order across slices that are
-// used as keys in an sstable or a database. A Comparator implementation
-// must be thread-safe since leveldb may invoke its methods concurrently
-// from multiple threads.
-class Comparator {
- public:
- virtual ~Comparator();
-
- // Three-way comparison. Returns value:
- // < 0 iff "a" < "b",
- // == 0 iff "a" == "b",
- // > 0 iff "a" > "b"
- virtual int Compare(const Slice& a, const Slice& b) const = 0;
-
- // The name of the comparator. Used to check for comparator
- // mismatches (i.e., a DB created with one comparator is
- // accessed using a different comparator.
- //
- // The client of this package should switch to a new name whenever
- // the comparator implementation changes in a way that will cause
- // the relative ordering of any two keys to change.
- //
- // Names starting with "leveldb." are reserved and should not be used
- // by any clients of this package.
- virtual const char* Name() const = 0;
-
- // Advanced functions: these are used to reduce the space requirements
- // for internal data structures like index blocks.
-
- // If *start < limit, changes *start to a short string in [start,limit).
- // Simple comparator implementations may return with *start unchanged,
- // i.e., an implementation of this method that does nothing is correct.
- virtual void FindShortestSeparator(
- std::string* start,
- const Slice& limit) const = 0;
-
- // Changes *key to a short string >= *key.
- // Simple comparator implementations may return with *key unchanged,
- // i.e., an implementation of this method that does nothing is correct.
- virtual void FindShortSuccessor(std::string* key) const = 0;
-};
-
-// Return a builtin comparator that uses lexicographic byte-wise
-// ordering. The result remains the property of this module and
-// must not be deleted.
-extern const Comparator* BytewiseComparator();
-
-} // namespace leveldb
-
-#endif // STORAGE_LEVELDB_INCLUDE_COMPARATOR_H_
diff --git a/src/leveldb/include/leveldb/db.h b/src/leveldb/include/leveldb/db.h
deleted file mode 100644
index 79142f5b2..000000000
--- a/src/leveldb/include/leveldb/db.h
+++ /dev/null
@@ -1,161 +0,0 @@
-// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file. See the AUTHORS file for names of contributors.
-
-#ifndef STORAGE_LEVELDB_INCLUDE_DB_H_
-#define STORAGE_LEVELDB_INCLUDE_DB_H_
-
-#include <stdint.h>
-#include <stdio.h>
-#include "leveldb/iterator.h"
-#include "leveldb/options.h"
-
-namespace leveldb {
-
-// Update Makefile if you change these
-static const int kMajorVersion = 1;
-static const int kMinorVersion = 7;
-
-struct Options;
-struct ReadOptions;
-struct WriteOptions;
-class WriteBatch;
-
-// Abstract handle to particular state of a DB.
-// A Snapshot is an immutable object and can therefore be safely
-// accessed from multiple threads without any external synchronization.
-class Snapshot {
- protected:
- virtual ~Snapshot();
-};
-
-// A range of keys
-struct Range {
- Slice start; // Included in the range
- Slice limit; // Not included in the range
-
- Range() { }
- Range(const Slice& s, const Slice& l) : start(s), limit(l) { }
-};
-
-// A DB is a persistent ordered map from keys to values.
-// A DB is safe for concurrent access from multiple threads without
-// any external synchronization.
-class DB {
- public:
- // Open the database with the specified "name".
- // Stores a pointer to a heap-allocated database in *dbptr and returns
- // OK on success.
- // Stores NULL in *dbptr and returns a non-OK status on error.
- // Caller should delete *dbptr when it is no longer needed.
- static Status Open(const Options& options,
- const std::string& name,
- DB** dbptr);
-
- DB() { }
- virtual ~DB();
-
- // Set the database entry for "key" to "value". Returns OK on success,
- // and a non-OK status on error.
- // Note: consider setting options.sync = true.
- virtual Status Put(const WriteOptions& options,
- const Slice& key,
- const Slice& value) = 0;
-
- // Remove the database entry (if any) for "key". Returns OK on
- // success, and a non-OK status on error. It is not an error if "key"
- // did not exist in the database.
- // Note: consider setting options.sync = true.
- virtual Status Delete(const WriteOptions& options, const Slice& key) = 0;
-
- // Apply the specified updates to the database.
- // Returns OK on success, non-OK on failure.
- // Note: consider setting options.sync = true.
- virtual Status Write(const WriteOptions& options, WriteBatch* updates) = 0;
-
- // If the database contains an entry for "key" store the
- // corresponding value in *value and return OK.
- //
- // If there is no entry for "key" leave *value unchanged and return
- // a status for which Status::IsNotFound() returns true.
- //
- // May return some other Status on an error.
- virtual Status Get(const ReadOptions& options,
- const Slice& key, std::string* value) = 0;
-
- // Return a heap-allocated iterator over the contents of the database.
- // The result of NewIterator() is initially invalid (caller must
- // call one of the Seek methods on the iterator before using it).
- //
- // Caller should delete the iterator when it is no longer needed.
- // The returned iterator should be deleted before this db is deleted.
- virtual Iterator* NewIterator(const ReadOptions& options) = 0;
-
- // Return a handle to the current DB state. Iterators created with
- // this handle will all observe a stable snapshot of the current DB
- // state. The caller must call ReleaseSnapshot(result) when the
- // snapshot is no longer needed.
- virtual const Snapshot* GetSnapshot() = 0;
-
- // Release a previously acquired snapshot. The caller must not
- // use "snapshot" after this call.
- virtual void ReleaseSnapshot(const Snapshot* snapshot) = 0;
-
- // DB implementations can export properties about their state
- // via this method. If "property" is a valid property understood by this
- // DB implementation, fills "*value" with its current value and returns
- // true. Otherwise returns false.
- //
- //
- // Valid property names include:
- //
- // "leveldb.num-files-at-level<N>" - return the number of files at level <N>,
- // where <N> is an ASCII representation of a level number (e.g. "0").
- // "leveldb.stats" - returns a multi-line string that describes statistics
- // about the internal operation of the DB.
- // "leveldb.sstables" - returns a multi-line string that describes all
- // of the sstables that make up the db contents.
- virtual bool GetProperty(const Slice& property, std::string* value) = 0;
-
- // For each i in [0,n-1], store in "sizes[i]", the approximate
- // file system space used by keys in "[range[i].start .. range[i].limit)".
- //
- // Note that the returned sizes measure file system space usage, so
- // if the user data compresses by a factor of ten, the returned
- // sizes will be one-tenth the size of the corresponding user data size.
- //
- // The results may not include the sizes of recently written data.
- virtual void GetApproximateSizes(const Range* range, int n,
- uint64_t* sizes) = 0;
-
- // Compact the underlying storage for the key range [*begin,*end].
- // In particular, deleted and overwritten versions are discarded,
- // and the data is rearranged to reduce the cost of operations
- // needed to access the data. This operation should typically only
- // be invoked by users who understand the underlying implementation.
- //
- // begin==NULL is treated as a key before all keys in the database.
- // end==NULL is treated as a key after all keys in the database.
- // Therefore the following call will compact the entire database:
- // db->CompactRange(NULL, NULL);
- virtual void CompactRange(const Slice* begin, const Slice* end) = 0;
-
- private:
- // No copying allowed
- DB(const DB&);
- void operator=(const DB&);
-};
-
-// Destroy the contents of the specified database.
-// Be very careful using this method.
-Status DestroyDB(const std::string& name, const Options& options);
-
-// If a DB cannot be opened, you may attempt to call this method to
-// resurrect as much of the contents of the database as possible.
-// Some data may be lost, so be careful when calling this function
-// on a database that contains important information.
-Status RepairDB(const std::string& dbname, const Options& options);
-
-} // namespace leveldb
-
-#endif // STORAGE_LEVELDB_INCLUDE_DB_H_
diff --git a/src/leveldb/include/leveldb/env.h b/src/leveldb/include/leveldb/env.h
deleted file mode 100644
index fa32289f5..000000000
--- a/src/leveldb/include/leveldb/env.h
+++ /dev/null
@@ -1,333 +0,0 @@
-// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file. See the AUTHORS file for names of contributors.
-//
-// An Env is an interface used by the leveldb implementation to access
-// operating system functionality like the filesystem etc. Callers
-// may wish to provide a custom Env object when opening a database to
-// get fine gain control; e.g., to rate limit file system operations.
-//
-// All Env implementations are safe for concurrent access from
-// multiple threads without any external synchronization.
-
-#ifndef STORAGE_LEVELDB_INCLUDE_ENV_H_
-#define STORAGE_LEVELDB_INCLUDE_ENV_H_
-
-#include <cstdarg>
-#include <string>
-#include <vector>
-#include <stdint.h>
-#include "leveldb/status.h"
-
-namespace leveldb {
-
-class FileLock;
-class Logger;
-class RandomAccessFile;
-class SequentialFile;
-class Slice;
-class WritableFile;
-
-class Env {
- public:
- Env() { }
- virtual ~Env();
-
- // Return a default environment suitable for the current operating
- // system. Sophisticated users may wish to provide their own Env
- // implementation instead of relying on this default environment.
- //
- // The result of Default() belongs to leveldb and must never be deleted.
- static Env* Default();
-
- // Create a brand new sequentially-readable file with the specified name.
- // On success, stores a pointer to the new file in *result and returns OK.
- // On failure stores NULL in *result and returns non-OK. If the file does
- // not exist, returns a non-OK status.
- //
- // The returned file will only be accessed by one thread at a time.
- virtual Status NewSequentialFile(const std::string& fname,
- SequentialFile** result) = 0;
-
- // Create a brand new random access read-only file with the
- // specified name. On success, stores a pointer to the new file in
- // *result and returns OK. On failure stores NULL in *result and
- // returns non-OK. If the file does not exist, returns a non-OK
- // status.
- //
- // The returned file may be concurrently accessed by multiple threads.
- virtual Status NewRandomAccessFile(const std::string& fname,
- RandomAccessFile** result) = 0;
-
- // Create an object that writes to a new file with the specified
- // name. Deletes any existing file with the same name and creates a
- // new file. On success, stores a pointer to the new file in
- // *result and returns OK. On failure stores NULL in *result and
- // returns non-OK.
- //
- // The returned file will only be accessed by one thread at a time.
- virtual Status NewWritableFile(const std::string& fname,
- WritableFile** result) = 0;
-
- // Returns true iff the named file exists.
- virtual bool FileExists(const std::string& fname) = 0;
-
- // Store in *result the names of the children of the specified directory.
- // The names are relative to "dir".
- // Original contents of *results are dropped.
- virtual Status GetChildren(const std::string& dir,
- std::vector<std::string>* result) = 0;
-
- // Delete the named file.
- virtual Status DeleteFile(const std::string& fname) = 0;
-
- // Create the specified directory.
- virtual Status CreateDir(const std::string& dirname) = 0;
-
- // Delete the specified directory.
- virtual Status DeleteDir(const std::string& dirname) = 0;
-
- // Store the size of fname in *file_size.
- virtual Status GetFileSize(const std::string& fname, uint64_t* file_size) = 0;
-
- // Rename file src to target.
- virtual Status RenameFile(const std::string& src,
- const std::string& target) = 0;
-
- // Lock the specified file. Used to prevent concurrent access to
- // the same db by multiple processes. On failure, stores NULL in
- // *lock and returns non-OK.
- //
- // On success, stores a pointer to the object that represents the
- // acquired lock in *lock and returns OK. The caller should call
- // UnlockFile(*lock) to release the lock. If the process exits,
- // the lock will be automatically released.
- //
- // If somebody else already holds the lock, finishes immediately
- // with a failure. I.e., this call does not wait for existing locks
- // to go away.
- //
- // May create the named file if it does not already exist.
- virtual Status LockFile(const std::string& fname, FileLock** lock) = 0;
-
- // Release the lock acquired by a previous successful call to LockFile.
- // REQUIRES: lock was returned by a successful LockFile() call
- // REQUIRES: lock has not already been unlocked.
- virtual Status UnlockFile(FileLock* lock) = 0;
-
- // Arrange to run "(*function)(arg)" once in a background thread.
- //
- // "function" may run in an unspecified thread. Multiple functions
- // added to the same Env may run concurrently in different threads.
- // I.e., the caller may not assume that background work items are
- // serialized.
- virtual void Schedule(
- void (*function)(void* arg),
- void* arg) = 0;
-
- // Start a new thread, invoking "function(arg)" within the new thread.
- // When "function(arg)" returns, the thread will be destroyed.
- virtual void StartThread(void (*function)(void* arg), void* arg) = 0;
-
- // *path is set to a temporary directory that can be used for testing. It may
- // or many not have just been created. The directory may or may not differ
- // between runs of the same process, but subsequent calls will return the
- // same directory.
- virtual Status GetTestDirectory(std::string* path) = 0;
-
- // Create and return a log file for storing informational messages.
- virtual Status NewLogger(const std::string& fname, Logger** result) = 0;
-
- // Returns the number of micro-seconds since some fixed point in time. Only
- // useful for computing deltas of time.
- virtual uint64_t NowMicros() = 0;
-
- // Sleep/delay the thread for the perscribed number of micro-seconds.
- virtual void SleepForMicroseconds(int micros) = 0;
-
- private:
- // No copying allowed
- Env(const Env&);
- void operator=(const Env&);
-};
-
-// A file abstraction for reading sequentially through a file
-class SequentialFile {
- public:
- SequentialFile() { }
- virtual ~SequentialFile();
-
- // Read up to "n" bytes from the file. "scratch[0..n-1]" may be
- // written by this routine. Sets "*result" to the data that was
- // read (including if fewer than "n" bytes were successfully read).
- // May set "*result" to point at data in "scratch[0..n-1]", so
- // "scratch[0..n-1]" must be live when "*result" is used.
- // If an error was encountered, returns a non-OK status.
- //
- // REQUIRES: External synchronization
- virtual Status Read(size_t n, Slice* result, char* scratch) = 0;
-
- // Skip "n" bytes from the file. This is guaranteed to be no
- // slower that reading the same data, but may be faster.
- //
- // If end of file is reached, skipping will stop at the end of the
- // file, and Skip will return OK.
- //
- // REQUIRES: External synchronization
- virtual Status Skip(uint64_t n) = 0;
-
- private:
- // No copying allowed
- SequentialFile(const SequentialFile&);
- void operator=(const SequentialFile&);
-};
-
-// A file abstraction for randomly reading the contents of a file.
-class RandomAccessFile {
- public:
- RandomAccessFile() { }
- virtual ~RandomAccessFile();
-
- // Read up to "n" bytes from the file starting at "offset".
- // "scratch[0..n-1]" may be written by this routine. Sets "*result"
- // to the data that was read (including if fewer than "n" bytes were
- // successfully read). May set "*result" to point at data in
- // "scratch[0..n-1]", so "scratch[0..n-1]" must be live when
- // "*result" is used. If an error was encountered, returns a non-OK
- // status.
- //
- // Safe for concurrent use by multiple threads.
- virtual Status Read(uint64_t offset, size_t n, Slice* result,
- char* scratch) const = 0;
-
- private:
- // No copying allowed
- RandomAccessFile(const RandomAccessFile&);
- void operator=(const RandomAccessFile&);
-};
-
-// A file abstraction for sequential writing. The implementation
-// must provide buffering since callers may append small fragments
-// at a time to the file.
-class WritableFile {
- public:
- WritableFile() { }
- virtual ~WritableFile();
-
- virtual Status Append(const Slice& data) = 0;
- virtual Status Close() = 0;
- virtual Status Flush() = 0;
- virtual Status Sync() = 0;
-
- private:
- // No copying allowed
- WritableFile(const WritableFile&);
- void operator=(const WritableFile&);
-};
-
-// An interface for writing log messages.
-class Logger {
- public:
- Logger() { }
- virtual ~Logger();
-
- // Write an entry to the log file with the specified format.
- virtual void Logv(const char* format, va_list ap) = 0;
-
- private:
- // No copying allowed
- Logger(const Logger&);
- void operator=(const Logger&);
-};
-
-
-// Identifies a locked file.
-class FileLock {
- public:
- FileLock() { }
- virtual ~FileLock();
- private:
- // No copying allowed
- FileLock(const FileLock&);
- void operator=(const FileLock&);
-};
-
-// Log the specified data to *info_log if info_log is non-NULL.
-extern void Log(Logger* info_log, const char* format, ...)
-# if defined(__GNUC__) || defined(__clang__)
- __attribute__((__format__ (__printf__, 2, 3)))
-# endif
- ;
-
-// A utility routine: write "data" to the named file.
-extern Status WriteStringToFile(Env* env, const Slice& data,
- const std::string& fname);
-
-// A utility routine: read contents of named file into *data
-extern Status ReadFileToString(Env* env, const std::string& fname,
- std::string* data);
-
-// An implementation of Env that forwards all calls to another Env.
-// May be useful to clients who wish to override just part of the
-// functionality of another Env.
-class EnvWrapper : public Env {
- public:
- // Initialize an EnvWrapper that delegates all calls to *t
- explicit EnvWrapper(Env* t) : target_(t) { }
- virtual ~EnvWrapper();
-
- // Return the target to which this Env forwards all calls
- Env* target() const { return target_; }
-
- // The following text is boilerplate that forwards all methods to target()
- Status NewSequentialFile(const std::string& f, SequentialFile** r) {
- return target_->NewSequentialFile(f, r);
- }
- Status NewRandomAccessFile(const std::string& f, RandomAccessFile** r) {
- return target_->NewRandomAccessFile(f, r);
- }
- Status NewWritableFile(const std::string& f, WritableFile** r) {
- return target_->NewWritableFile(f, r);
- }
- bool FileExists(const std::string& f) { return target_->FileExists(f); }
- Status GetChildren(const std::string& dir, std::vector<std::string>* r) {
- return target_->GetChildren(dir, r);
- }
- Status DeleteFile(const std::string& f) { return target_->DeleteFile(f); }
- Status CreateDir(const std::string& d) { return target_->CreateDir(d); }
- Status DeleteDir(const std::string& d) { return target_->DeleteDir(d); }
- Status GetFileSize(const std::string& f, uint64_t* s) {
- return target_->GetFileSize(f, s);
- }
- Status RenameFile(const std::string& s, const std::string& t) {
- return target_->RenameFile(s, t);
- }
- Status LockFile(const std::string& f, FileLock** l) {
- return target_->LockFile(f, l);
- }
- Status UnlockFile(FileLock* l) { return target_->UnlockFile(l); }
- void Schedule(void (*f)(void*), void* a) {
- return target_->Schedule(f, a);
- }
- void StartThread(void (*f)(void*), void* a) {
- return target_->StartThread(f, a);
- }
- virtual Status GetTestDirectory(std::string* path) {
- return target_->GetTestDirectory(path);
- }
- virtual Status NewLogger(const std::string& fname, Logger** result) {
- return target_->NewLogger(fname, result);
- }
- uint64_t NowMicros() {
- return target_->NowMicros();
- }
- void SleepForMicroseconds(int micros) {
- target_->SleepForMicroseconds(micros);
- }
- private:
- Env* target_;
-};
-
-} // namespace leveldb
-
-#endif // STORAGE_LEVELDB_INCLUDE_ENV_H_
diff --git a/src/leveldb/include/leveldb/filter_policy.h b/src/leveldb/include/leveldb/filter_policy.h
deleted file mode 100644
index 1fba08001..000000000
--- a/src/leveldb/include/leveldb/filter_policy.h
+++ /dev/null
@@ -1,70 +0,0 @@
-// Copyright (c) 2012 The LevelDB Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file. See the AUTHORS file for names of contributors.
-//
-// A database can be configured with a custom FilterPolicy object.
-// This object is responsible for creating a small filter from a set
-// of keys. These filters are stored in leveldb and are consulted
-// automatically by leveldb to decide whether or not to read some
-// information from disk. In many cases, a filter can cut down the
-// number of disk seeks form a handful to a single disk seek per
-// DB::Get() call.
-//
-// Most people will want to use the builtin bloom filter support (see
-// NewBloomFilterPolicy() below).
-
-#ifndef STORAGE_LEVELDB_INCLUDE_FILTER_POLICY_H_
-#define STORAGE_LEVELDB_INCLUDE_FILTER_POLICY_H_
-
-#include <string>
-
-namespace leveldb {
-
-class Slice;
-
-class FilterPolicy {
- public:
- virtual ~FilterPolicy();
-
- // Return the name of this policy. Note that if the filter encoding
- // changes in an incompatible way, the name returned by this method
- // must be changed. Otherwise, old incompatible filters may be
- // passed to methods of this type.
- virtual const char* Name() const = 0;
-
- // keys[0,n-1] contains a list of keys (potentially with duplicates)
- // that are ordered according to the user supplied comparator.
- // Append a filter that summarizes keys[0,n-1] to *dst.
- //
- // Warning: do not change the initial contents of *dst. Instead,
- // append the newly constructed filter to *dst.
- virtual void CreateFilter(const Slice* keys, int n, std::string* dst)
- const = 0;
-
- // "filter" contains the data appended by a preceding call to
- // CreateFilter() on this class. This method must return true if
- // the key was in the list of keys passed to CreateFilter().
- // This method may return true or false if the key was not on the
- // list, but it should aim to return false with a high probability.
- virtual bool KeyMayMatch(const Slice& key, const Slice& filter) const = 0;
-};
-
-// Return a new filter policy that uses a bloom filter with approximately
-// the specified number of bits per key. A good value for bits_per_key
-// is 10, which yields a filter with ~ 1% false positive rate.
-//
-// Callers must delete the result after any database that is using the
-// result has been closed.
-//
-// Note: if you are using a custom comparator that ignores some parts
-// of the keys being compared, you must not use NewBloomFilterPolicy()
-// and must provide your own FilterPolicy that also ignores the
-// corresponding parts of the keys. For example, if the comparator
-// ignores trailing spaces, it would be incorrect to use a
-// FilterPolicy (like NewBloomFilterPolicy) that does not ignore
-// trailing spaces in keys.
-extern const FilterPolicy* NewBloomFilterPolicy(int bits_per_key);
-
-}
-
-#endif // STORAGE_LEVELDB_INCLUDE_FILTER_POLICY_H_
diff --git a/src/leveldb/include/leveldb/iterator.h b/src/leveldb/include/leveldb/iterator.h
deleted file mode 100644
index ad543eb46..000000000
--- a/src/leveldb/include/leveldb/iterator.h
+++ /dev/null
@@ -1,100 +0,0 @@
-// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file. See the AUTHORS file for names of contributors.
-//
-// An iterator yields a sequence of key/value pairs from a source.
-// The following class defines the interface. Multiple implementations
-// are provided by this library. In particular, iterators are provided
-// to access the contents of a Table or a DB.
-//
-// Multiple threads can invoke const methods on an Iterator without
-// external synchronization, but if any of the threads may call a
-// non-const method, all threads accessing the same Iterator must use
-// external synchronization.
-
-#ifndef STORAGE_LEVELDB_INCLUDE_ITERATOR_H_
-#define STORAGE_LEVELDB_INCLUDE_ITERATOR_H_
-
-#include "leveldb/slice.h"
-#include "leveldb/status.h"
-
-namespace leveldb {
-
-class Iterator {
- public:
- Iterator();
- virtual ~Iterator();
-
- // An iterator is either positioned at a key/value pair, or
- // not valid. This method returns true iff the iterator is valid.
- virtual bool Valid() const = 0;
-
- // Position at the first key in the source. The iterator is Valid()
- // after this call iff the source is not empty.
- virtual void SeekToFirst() = 0;
-
- // Position at the last key in the source. The iterator is
- // Valid() after this call iff the source is not empty.
- virtual void SeekToLast() = 0;
-
- // Position at the first key in the source that at or past target
- // The iterator is Valid() after this call iff the source contains
- // an entry that comes at or past target.
- virtual void Seek(const Slice& target) = 0;
-
- // Moves to the next entry in the source. After this call, Valid() is
- // true iff the iterator was not positioned at the last entry in the source.
- // REQUIRES: Valid()
- virtual void Next() = 0;
-
- // Moves to the previous entry in the source. After this call, Valid() is
- // true iff the iterator was not positioned at the first entry in source.
- // REQUIRES: Valid()
- virtual void Prev() = 0;
-
- // Return the key for the current entry. The underlying storage for
- // the returned slice is valid only until the next modification of
- // the iterator.
- // REQUIRES: Valid()
- virtual Slice key() const = 0;
-
- // Return the value for the current entry. The underlying storage for
- // the returned slice is valid only until the next modification of
- // the iterator.
- // REQUIRES: !AtEnd() && !AtStart()
- virtual Slice value() const = 0;
-
- // If an error has occurred, return it. Else return an ok status.
- virtual Status status() const = 0;
-
- // Clients are allowed to register function/arg1/arg2 triples that
- // will be invoked when this iterator is destroyed.
- //
- // Note that unlike all of the preceding methods, this method is
- // not abstract and therefore clients should not override it.
- typedef void (*CleanupFunction)(void* arg1, void* arg2);
- void RegisterCleanup(CleanupFunction function, void* arg1, void* arg2);
-
- private:
- struct Cleanup {
- CleanupFunction function;
- void* arg1;
- void* arg2;
- Cleanup* next;
- };
- Cleanup cleanup_;
-
- // No copying allowed
- Iterator(const Iterator&);
- void operator=(const Iterator&);
-};
-
-// Return an empty iterator (yields nothing).
-extern Iterator* NewEmptyIterator();
-
-// Return an empty iterator with the specified status.
-extern Iterator* NewErrorIterator(const Status& status);
-
-} // namespace leveldb
-
-#endif // STORAGE_LEVELDB_INCLUDE_ITERATOR_H_
diff --git a/src/leveldb/include/leveldb/options.h b/src/leveldb/include/leveldb/options.h
deleted file mode 100644
index fdda718d3..000000000
--- a/src/leveldb/include/leveldb/options.h
+++ /dev/null
@@ -1,195 +0,0 @@
-// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file. See the AUTHORS file for names of contributors.
-
-#ifndef STORAGE_LEVELDB_INCLUDE_OPTIONS_H_
-#define STORAGE_LEVELDB_INCLUDE_OPTIONS_H_
-
-#include <stddef.h>
-
-namespace leveldb {
-
-class Cache;
-class Comparator;
-class Env;
-class FilterPolicy;
-class Logger;
-class Snapshot;
-
-// DB contents are stored in a set of blocks, each of which holds a
-// sequence of key,value pairs. Each block may be compressed before
-// being stored in a file. The following enum describes which
-// compression method (if any) is used to compress a block.
-enum CompressionType {
- // NOTE: do not change the values of existing entries, as these are
- // part of the persistent format on disk.
- kNoCompression = 0x0,
- kSnappyCompression = 0x1
-};
-
-// Options to control the behavior of a database (passed to DB::Open)
-struct Options {
- // -------------------
- // Parameters that affect behavior
-
- // Comparator used to define the order of keys in the table.
- // Default: a comparator that uses lexicographic byte-wise ordering
- //
- // REQUIRES: The client must ensure that the comparator supplied
- // here has the same name and orders keys *exactly* the same as the
- // comparator provided to previous open calls on the same DB.
- const Comparator* comparator;
-
- // If true, the database will be created if it is missing.
- // Default: false
- bool create_if_missing;
-
- // If true, an error is raised if the database already exists.
- // Default: false
- bool error_if_exists;
-
- // If true, the implementation will do aggressive checking of the
- // data it is processing and will stop early if it detects any
- // errors. This may have unforeseen ramifications: for example, a
- // corruption of one DB entry may cause a large number of entries to
- // become unreadable or for the entire DB to become unopenable.
- // Default: false
- bool paranoid_checks;
-
- // Use the specified object to interact with the environment,
- // e.g. to read/write files, schedule background work, etc.
- // Default: Env::Default()
- Env* env;
-
- // Any internal progress/error information generated by the db will
- // be written to info_log if it is non-NULL, or to a file stored
- // in the same directory as the DB contents if info_log is NULL.
- // Default: NULL
- Logger* info_log;
-
- // -------------------
- // Parameters that affect performance
-
- // Amount of data to build up in memory (backed by an unsorted log
- // on disk) before converting to a sorted on-disk file.
- //
- // Larger values increase performance, especially during bulk loads.
- // Up to two write buffers may be held in memory at the same time,
- // so you may wish to adjust this parameter to control memory usage.
- // Also, a larger write buffer will result in a longer recovery time
- // the next time the database is opened.
- //
- // Default: 4MB
- size_t write_buffer_size;
-
- // Number of open files that can be used by the DB. You may need to
- // increase this if your database has a large working set (budget
- // one open file per 2MB of working set).
- //
- // Default: 1000
- int max_open_files;
-
- // Control over blocks (user data is stored in a set of blocks, and
- // a block is the unit of reading from disk).
-
- // If non-NULL, use the specified cache for blocks.
- // If NULL, leveldb will automatically create and use an 8MB internal cache.
- // Default: NULL
- Cache* block_cache;
-
- // Approximate size of user data packed per block. Note that the
- // block size specified here corresponds to uncompressed data. The
- // actual size of the unit read from disk may be smaller if
- // compression is enabled. This parameter can be changed dynamically.
- //
- // Default: 4K
- size_t block_size;
-
- // Number of keys between restart points for delta encoding of keys.
- // This parameter can be changed dynamically. Most clients should
- // leave this parameter alone.
- //
- // Default: 16
- int block_restart_interval;
-
- // Compress blocks using the specified compression algorithm. This
- // parameter can be changed dynamically.
- //
- // Default: kSnappyCompression, which gives lightweight but fast
- // compression.
- //
- // Typical speeds of kSnappyCompression on an Intel(R) Core(TM)2 2.4GHz:
- // ~200-500MB/s compression
- // ~400-800MB/s decompression
- // Note that these speeds are significantly faster than most
- // persistent storage speeds, and therefore it is typically never
- // worth switching to kNoCompression. Even if the input data is
- // incompressible, the kSnappyCompression implementation will
- // efficiently detect that and will switch to uncompressed mode.
- CompressionType compression;
-
- // If non-NULL, use the specified filter policy to reduce disk reads.
- // Many applications will benefit from passing the result of
- // NewBloomFilterPolicy() here.
- //
- // Default: NULL
- const FilterPolicy* filter_policy;
-
- // Create an Options object with default values for all fields.
- Options();
-};
-
-// Options that control read operations
-struct ReadOptions {
- // If true, all data read from underlying storage will be
- // verified against corresponding checksums.
- // Default: false
- bool verify_checksums;
-
- // Should the data read for this iteration be cached in memory?
- // Callers may wish to set this field to false for bulk scans.
- // Default: true
- bool fill_cache;
-
- // If "snapshot" is non-NULL, read as of the supplied snapshot
- // (which must belong to the DB that is being read and which must
- // not have been released). If "snapshot" is NULL, use an impliicit
- // snapshot of the state at the beginning of this read operation.
- // Default: NULL
- const Snapshot* snapshot;
-
- ReadOptions()
- : verify_checksums(false),
- fill_cache(true),
- snapshot(NULL) {
- }
-};
-
-// Options that control write operations
-struct WriteOptions {
- // If true, the write will be flushed from the operating system
- // buffer cache (by calling WritableFile::Sync()) before the write
- // is considered complete. If this flag is true, writes will be
- // slower.
- //
- // If this flag is false, and the machine crashes, some recent
- // writes may be lost. Note that if it is just the process that
- // crashes (i.e., the machine does not reboot), no writes will be
- // lost even if sync==false.
- //
- // In other words, a DB write with sync==false has similar
- // crash semantics as the "write()" system call. A DB write
- // with sync==true has similar crash semantics to a "write()"
- // system call followed by "fsync()".
- //
- // Default: false
- bool sync;
-
- WriteOptions()
- : sync(false) {
- }
-};
-
-} // namespace leveldb
-
-#endif // STORAGE_LEVELDB_INCLUDE_OPTIONS_H_
diff --git a/src/leveldb/include/leveldb/slice.h b/src/leveldb/include/leveldb/slice.h
deleted file mode 100644
index 74ea8fa49..000000000
--- a/src/leveldb/include/leveldb/slice.h
+++ /dev/null
@@ -1,109 +0,0 @@
-// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file. See the AUTHORS file for names of contributors.
-//
-// Slice is a simple structure containing a pointer into some external
-// storage and a size. The user of a Slice must ensure that the slice
-// is not used after the corresponding external storage has been
-// deallocated.
-//
-// Multiple threads can invoke const methods on a Slice without
-// external synchronization, but if any of the threads may call a
-// non-const method, all threads accessing the same Slice must use
-// external synchronization.
-
-#ifndef STORAGE_LEVELDB_INCLUDE_SLICE_H_
-#define STORAGE_LEVELDB_INCLUDE_SLICE_H_
-
-#include <assert.h>
-#include <stddef.h>
-#include <string.h>
-#include <string>
-
-namespace leveldb {
-
-class Slice {
- public:
- // Create an empty slice.
- Slice() : data_(""), size_(0) { }
-
- // Create a slice that refers to d[0,n-1].
- Slice(const char* d, size_t n) : data_(d), size_(n) { }
-
- // Create a slice that refers to the contents of "s"
- Slice(const std::string& s) : data_(s.data()), size_(s.size()) { }
-
- // Create a slice that refers to s[0,strlen(s)-1]
- Slice(const char* s) : data_(s), size_(strlen(s)) { }
-
- // Return a pointer to the beginning of the referenced data
- const char* data() const { return data_; }
-
- // Return the length (in bytes) of the referenced data
- size_t size() const { return size_; }
-
- // Return true iff the length of the referenced data is zero
- bool empty() const { return size_ == 0; }
-
- // Return the ith byte in the referenced data.
- // REQUIRES: n < size()
- char operator[](size_t n) const {
- assert(n < size());
- return data_[n];
- }
-
- // Change this slice to refer to an empty array
- void clear() { data_ = ""; size_ = 0; }
-
- // Drop the first "n" bytes from this slice.
- void remove_prefix(size_t n) {
- assert(n <= size());
- data_ += n;
- size_ -= n;
- }
-
- // Return a string that contains the copy of the referenced data.
- std::string ToString() const { return std::string(data_, size_); }
-
- // Three-way comparison. Returns value:
- // < 0 iff "*this" < "b",
- // == 0 iff "*this" == "b",
- // > 0 iff "*this" > "b"
- int compare(const Slice& b) const;
-
- // Return true iff "x" is a prefix of "*this"
- bool starts_with(const Slice& x) const {
- return ((size_ >= x.size_) &&
- (memcmp(data_, x.data_, x.size_) == 0));
- }
-
- private:
- const char* data_;
- size_t size_;
-
- // Intentionally copyable
-};
-
-inline bool operator==(const Slice& x, const Slice& y) {
- return ((x.size() == y.size()) &&
- (memcmp(x.data(), y.data(), x.size()) == 0));
-}
-
-inline bool operator!=(const Slice& x, const Slice& y) {
- return !(x == y);
-}
-
-inline int Slice::compare(const Slice& b) const {
- const int min_len = (size_ < b.size_) ? size_ : b.size_;
- int r = memcmp(data_, b.data_, min_len);
- if (r == 0) {
- if (size_ < b.size_) r = -1;
- else if (size_ > b.size_) r = +1;
- }
- return r;
-}
-
-} // namespace leveldb
-
-
-#endif // STORAGE_LEVELDB_INCLUDE_SLICE_H_
diff --git a/src/leveldb/include/leveldb/status.h b/src/leveldb/include/leveldb/status.h
deleted file mode 100644
index 11dbd4b47..000000000
--- a/src/leveldb/include/leveldb/status.h
+++ /dev/null
@@ -1,106 +0,0 @@
-// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file. See the AUTHORS file for names of contributors.
-//
-// A Status encapsulates the result of an operation. It may indicate success,
-// or it may indicate an error with an associated error message.
-//
-// Multiple threads can invoke const methods on a Status without
-// external synchronization, but if any of the threads may call a
-// non-const method, all threads accessing the same Status must use
-// external synchronization.
-
-#ifndef STORAGE_LEVELDB_INCLUDE_STATUS_H_
-#define STORAGE_LEVELDB_INCLUDE_STATUS_H_
-
-#include <string>
-#include "leveldb/slice.h"
-
-namespace leveldb {
-
-class Status {
- public:
- // Create a success status.
- Status() : state_(NULL) { }
- ~Status() { delete[] state_; }
-
- // Copy the specified status.
- Status(const Status& s);
- void operator=(const Status& s);
-
- // Return a success status.
- static Status OK() { return Status(); }
-
- // Return error status of an appropriate type.
- static Status NotFound(const Slice& msg, const Slice& msg2 = Slice()) {
- return Status(kNotFound, msg, msg2);
- }
- static Status Corruption(const Slice& msg, const Slice& msg2 = Slice()) {
- return Status(kCorruption, msg, msg2);
- }
- static Status NotSupported(const Slice& msg, const Slice& msg2 = Slice()) {
- return Status(kNotSupported, msg, msg2);
- }
- static Status InvalidArgument(const Slice& msg, const Slice& msg2 = Slice()) {
- return Status(kInvalidArgument, msg, msg2);
- }
- static Status IOError(const Slice& msg, const Slice& msg2 = Slice()) {
- return Status(kIOError, msg, msg2);
- }
-
- // Returns true iff the status indicates success.
- bool ok() const { return (state_ == NULL); }
-
- // Returns true iff the status indicates a NotFound error.
- bool IsNotFound() const { return code() == kNotFound; }
-
- // Returns true iff the status indicates a Corruption error.
- bool IsCorruption() const { return code() == kCorruption; }
-
- // Returns true iff the status indicates an IOError.
- bool IsIOError() const { return code() == kIOError; }
-
- // Return a string representation of this status suitable for printing.
- // Returns the string "OK" for success.
- std::string ToString() const;
-
- private:
- // OK status has a NULL state_. Otherwise, state_ is a new[] array
- // of the following form:
- // state_[0..3] == length of message
- // state_[4] == code
- // state_[5..] == message
- const char* state_;
-
- enum Code {
- kOk = 0,
- kNotFound = 1,
- kCorruption = 2,
- kNotSupported = 3,
- kInvalidArgument = 4,
- kIOError = 5
- };
-
- Code code() const {
- return (state_ == NULL) ? kOk : static_cast<Code>(state_[4]);
- }
-
- Status(Code code, const Slice& msg, const Slice& msg2);
- static const char* CopyState(const char* s);
-};
-
-inline Status::Status(const Status& s) {
- state_ = (s.state_ == NULL) ? NULL : CopyState(s.state_);
-}
-inline void Status::operator=(const Status& s) {
- // The following condition catches both aliasing (when this == &s),
- // and the common case where both s and *this are ok.
- if (state_ != s.state_) {
- delete[] state_;
- state_ = (s.state_ == NULL) ? NULL : CopyState(s.state_);
- }
-}
-
-} // namespace leveldb
-
-#endif // STORAGE_LEVELDB_INCLUDE_STATUS_H_
diff --git a/src/leveldb/include/leveldb/table.h b/src/leveldb/include/leveldb/table.h
deleted file mode 100644
index a9746c3f5..000000000
--- a/src/leveldb/include/leveldb/table.h
+++ /dev/null
@@ -1,85 +0,0 @@
-// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file. See the AUTHORS file for names of contributors.
-
-#ifndef STORAGE_LEVELDB_INCLUDE_TABLE_H_
-#define STORAGE_LEVELDB_INCLUDE_TABLE_H_
-
-#include <stdint.h>
-#include "leveldb/iterator.h"
-
-namespace leveldb {
-
-class Block;
-class BlockHandle;
-class Footer;
-struct Options;
-class RandomAccessFile;
-struct ReadOptions;
-class TableCache;
-
-// A Table is a sorted map from strings to strings. Tables are
-// immutable and persistent. A Table may be safely accessed from
-// multiple threads without external synchronization.
-class Table {
- public:
- // Attempt to open the table that is stored in bytes [0..file_size)
- // of "file", and read the metadata entries necessary to allow
- // retrieving data from the table.
- //
- // If successful, returns ok and sets "*table" to the newly opened
- // table. The client should delete "*table" when no longer needed.
- // If there was an error while initializing the table, sets "*table"
- // to NULL and returns a non-ok status. Does not take ownership of
- // "*source", but the client must ensure that "source" remains live
- // for the duration of the returned table's lifetime.
- //
- // *file must remain live while this Table is in use.
- static Status Open(const Options& options,
- RandomAccessFile* file,
- uint64_t file_size,
- Table** table);
-
- ~Table();
-
- // Returns a new iterator over the table contents.
- // The result of NewIterator() is initially invalid (caller must
- // call one of the Seek methods on the iterator before using it).
- Iterator* NewIterator(const ReadOptions&) const;
-
- // Given a key, return an approximate byte offset in the file where
- // the data for that key begins (or would begin if the key were
- // present in the file). The returned value is in terms of file
- // bytes, and so includes effects like compression of the underlying data.
- // E.g., the approximate offset of the last key in the table will
- // be close to the file length.
- uint64_t ApproximateOffsetOf(const Slice& key) const;
-
- private:
- struct Rep;
- Rep* rep_;
-
- explicit Table(Rep* rep) { rep_ = rep; }
- static Iterator* BlockReader(void*, const ReadOptions&, const Slice&);
-
- // Calls (*handle_result)(arg, ...) with the entry found after a call
- // to Seek(key). May not make such a call if filter policy says
- // that key is not present.
- friend class TableCache;
- Status InternalGet(
- const ReadOptions&, const Slice& key,
- void* arg,
- void (*handle_result)(void* arg, const Slice& k, const Slice& v));
-
-
- void ReadMeta(const Footer& footer);
- void ReadFilter(const Slice& filter_handle_value);
-
- // No copying allowed
- Table(const Table&);
- void operator=(const Table&);
-};
-
-} // namespace leveldb
-
-#endif // STORAGE_LEVELDB_INCLUDE_TABLE_H_
diff --git a/src/leveldb/include/leveldb/table_builder.h b/src/leveldb/include/leveldb/table_builder.h
deleted file mode 100644
index 5fd1dc71f..000000000
--- a/src/leveldb/include/leveldb/table_builder.h
+++ /dev/null
@@ -1,92 +0,0 @@
-// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file. See the AUTHORS file for names of contributors.
-//
-// TableBuilder provides the interface used to build a Table
-// (an immutable and sorted map from keys to values).
-//
-// Multiple threads can invoke const methods on a TableBuilder without
-// external synchronization, but if any of the threads may call a
-// non-const method, all threads accessing the same TableBuilder must use
-// external synchronization.
-
-#ifndef STORAGE_LEVELDB_INCLUDE_TABLE_BUILDER_H_
-#define STORAGE_LEVELDB_INCLUDE_TABLE_BUILDER_H_
-
-#include <stdint.h>
-#include "leveldb/options.h"
-#include "leveldb/status.h"
-
-namespace leveldb {
-
-class BlockBuilder;
-class BlockHandle;
-class WritableFile;
-
-class TableBuilder {
- public:
- // Create a builder that will store the contents of the table it is
- // building in *file. Does not close the file. It is up to the
- // caller to close the file after calling Finish().
- TableBuilder(const Options& options, WritableFile* file);
-
- // REQUIRES: Either Finish() or Abandon() has been called.
- ~TableBuilder();
-
- // Change the options used by this builder. Note: only some of the
- // option fields can be changed after construction. If a field is
- // not allowed to change dynamically and its value in the structure
- // passed to the constructor is different from its value in the
- // structure passed to this method, this method will return an error
- // without changing any fields.
- Status ChangeOptions(const Options& options);
-
- // Add key,value to the table being constructed.
- // REQUIRES: key is after any previously added key according to comparator.
- // REQUIRES: Finish(), Abandon() have not been called
- void Add(const Slice& key, const Slice& value);
-
- // Advanced operation: flush any buffered key/value pairs to file.
- // Can be used to ensure that two adjacent entries never live in
- // the same data block. Most clients should not need to use this method.
- // REQUIRES: Finish(), Abandon() have not been called
- void Flush();
-
- // Return non-ok iff some error has been detected.
- Status status() const;
-
- // Finish building the table. Stops using the file passed to the
- // constructor after this function returns.
- // REQUIRES: Finish(), Abandon() have not been called
- Status Finish();
-
- // Indicate that the contents of this builder should be abandoned. Stops
- // using the file passed to the constructor after this function returns.
- // If the caller is not going to call Finish(), it must call Abandon()
- // before destroying this builder.
- // REQUIRES: Finish(), Abandon() have not been called
- void Abandon();
-
- // Number of calls to Add() so far.
- uint64_t NumEntries() const;
-
- // Size of the file generated so far. If invoked after a successful
- // Finish() call, returns the size of the final generated file.
- uint64_t FileSize() const;
-
- private:
- bool ok() const { return status().ok(); }
- void WriteBlock(BlockBuilder* block, BlockHandle* handle);
- void WriteRawBlock(const Slice& data, CompressionType, BlockHandle* handle);
-
- struct Rep;
- Rep* rep_;
-
- // No copying allowed
- TableBuilder(const TableBuilder&);
- void operator=(const TableBuilder&);
-};
-
-} // namespace leveldb
-
-#endif // STORAGE_LEVELDB_INCLUDE_TABLE_BUILDER_H_
diff --git a/src/leveldb/include/leveldb/write_batch.h b/src/leveldb/include/leveldb/write_batch.h
deleted file mode 100644
index ee9aab68e..000000000
--- a/src/leveldb/include/leveldb/write_batch.h
+++ /dev/null
@@ -1,64 +0,0 @@
-// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file. See the AUTHORS file for names of contributors.
-//
-// WriteBatch holds a collection of updates to apply atomically to a DB.
-//
-// The updates are applied in the order in which they are added
-// to the WriteBatch. For example, the value of "key" will be "v3"
-// after the following batch is written:
-//
-// batch.Put("key", "v1");
-// batch.Delete("key");
-// batch.Put("key", "v2");
-// batch.Put("key", "v3");
-//
-// Multiple threads can invoke const methods on a WriteBatch without
-// external synchronization, but if any of the threads may call a
-// non-const method, all threads accessing the same WriteBatch must use
-// external synchronization.
-
-#ifndef STORAGE_LEVELDB_INCLUDE_WRITE_BATCH_H_
-#define STORAGE_LEVELDB_INCLUDE_WRITE_BATCH_H_
-
-#include <string>
-#include "leveldb/status.h"
-
-namespace leveldb {
-
-class Slice;
-
-class WriteBatch {
- public:
- WriteBatch();
- ~WriteBatch();
-
- // Store the mapping "key->value" in the database.
- void Put(const Slice& key, const Slice& value);
-
- // If the database contains a mapping for "key", erase it. Else do nothing.
- void Delete(const Slice& key);
-
- // Clear all updates buffered in this batch.
- void Clear();
-
- // Support for iterating over the contents of a batch.
- class Handler {
- public:
- virtual ~Handler();
- virtual void Put(const Slice& key, const Slice& value) = 0;
- virtual void Delete(const Slice& key) = 0;
- };
- Status Iterate(Handler* handler) const;
-
- private:
- friend class WriteBatchInternal;
-
- std::string rep_; // See comment in write_batch.cc for the format of rep_
-
- // Intentionally copyable
-};
-
-} // namespace leveldb
-
-#endif // STORAGE_LEVELDB_INCLUDE_WRITE_BATCH_H_