SYMBOL INDEX (1438 symbols across 130 files) FILE: benchmarks/db_bench.cc type leveldb (line 132) | namespace leveldb { class CountComparator (line 137) | class CountComparator : public Comparator { method CountComparator (line 139) | CountComparator(const Comparator* wrapped) : wrapped_(wrapped) {} method Compare (line 141) | int Compare(const Slice& a, const Slice& b) const override { method FindShortestSeparator (line 146) | void FindShortestSeparator(std::string* start, method FindShortSuccessor (line 151) | void FindShortSuccessor(std::string* key) const override { method comparisons (line 155) | size_t comparisons() const { return count_.load(std::memory_order_re... method reset (line 157) | void reset() { count_.store(0, std::memory_order_relaxed); } class RandomGenerator (line 165) | class RandomGenerator { method RandomGenerator (line 171) | RandomGenerator() { method Slice (line 186) | Slice Generate(size_t len) { class KeyBuffer (line 196) | class KeyBuffer { method KeyBuffer (line 198) | KeyBuffer() { method KeyBuffer (line 202) | KeyBuffer& operator=(KeyBuffer& other) = delete; method KeyBuffer (line 203) | KeyBuffer(KeyBuffer& other) = delete; method Set (line 205) | void Set(int k) { method Slice (line 210) | Slice slice() const { return Slice(buffer_, FLAGS_key_prefix + 16); } function Slice (line 217) | static Slice TrimSpace(Slice s) { function AppendWithSpace (line 230) | static void AppendWithSpace(std::string* str, Slice msg) { class Stats (line 238) | class Stats { method Stats (line 251) | Stats() { Start(); } method Start (line 253) | void Start() { method Merge (line 263) | void Merge(const Stats& other) { method Stop (line 275) | void Stop() { method AddMessage (line 280) | void AddMessage(Slice msg) { AppendWithSpace(&message_, msg); } method FinishedSingleOp (line 282) | void FinishedSingleOp() { method AddBytes (line 315) | void AddBytes(int64_t n) { bytes_ += n; } method Report (line 317) | void Report(const Slice& name) { type SharedState (line 346) | struct SharedState { method SharedState (line 361) | SharedState(int total) type ThreadState (line 366) | struct ThreadState { method ThreadState (line 372) | ThreadState(int index, int seed) : tid(index), rand(seed), shared(nu... function Compress (line 375) | void Compress( function Uncompress (line 402) | void Uncompress( class Benchmark (line 428) | class Benchmark { method PrintHeader (line 442) | void PrintHeader() { method PrintWarnings (line 462) | void PrintWarnings() { method PrintEnvironment (line 484) | void PrintEnvironment() { method Benchmark (line 521) | Benchmark() method Run (line 552) | void Run() { type ThreadArg (line 675) | struct ThreadArg { method ThreadBody (line 682) | static void ThreadBody(void* v) { method RunBenchmark (line 710) | void RunBenchmark(int n, Slice name, method Crc32c (line 756) | void Crc32c(ThreadState* thread) { method SnappyCompress (line 775) | void SnappyCompress(ThreadState* thread) { method SnappyUncompress (line 779) | void SnappyUncompress(ThreadState* thread) { method ZstdCompress (line 784) | void ZstdCompress(ThreadState* thread) { method ZstdUncompress (line 792) | void ZstdUncompress(ThreadState* thread) { method Open (line 802) | void Open() { method OpenBench (line 826) | void OpenBench(ThreadState* thread) { method WriteSeq (line 834) | void WriteSeq(ThreadState* thread) { DoWrite(thread, true); } method WriteRandom (line 836) | void WriteRandom(ThreadState* thread) { DoWrite(thread, false); } method DoWrite (line 838) | void DoWrite(ThreadState* thread, bool seq) { method ReadSequential (line 868) | void ReadSequential(ThreadState* thread) { method ReadReverse (line 881) | void ReadReverse(ThreadState* thread) { method ReadRandom (line 894) | void ReadRandom(ThreadState* thread) { method ReadMissing (line 912) | void ReadMissing(ThreadState* thread) { method ReadHot (line 925) | void ReadHot(ThreadState* thread) { method SeekRandom (line 938) | void SeekRandom(ThreadState* thread) { method SeekOrdered (line 956) | void SeekOrdered(ThreadState* thread) { method DoDelete (line 975) | void DoDelete(ThreadState* thread, bool seq) { method DeleteSeq (line 996) | void DeleteSeq(ThreadState* thread) { DoDelete(thread, true); } method DeleteRandom (line 998) | void DeleteRandom(ThreadState* thread) { DoDelete(thread, false); } method ReadWhileWriting (line 1000) | void ReadWhileWriting(ThreadState* thread) { method Compact (line 1031) | void Compact(ThreadState* thread) { db_->CompactRange(nullptr, nullp... method PrintStats (line 1033) | void PrintStats(const char* key) { method WriteToFile (line 1041) | static void WriteToFile(void* arg, const char* buf, int n) { method HeapProfile (line 1045) | void HeapProfile() { function main (line 1066) | int main(int argc, char** argv) { FILE: benchmarks/db_bench_log.cc type leveldb (line 20) | namespace leveldb { function MakeKey (line 24) | std::string MakeKey(unsigned int num) { function BM_LogAndApply (line 30) | void BM_LogAndApply(benchmark::State& state) { FILE: benchmarks/db_bench_sqlite3.cc function ExecErrorCheck (line 85) | inline static void ExecErrorCheck(int status, char* err_msg) { function StepErrorCheck (line 93) | inline static void StepErrorCheck(int status) { function ErrorCheck (line 100) | inline static void ErrorCheck(int status) { function WalCheckpoint (line 107) | inline static void WalCheckpoint(sqlite3* db_) { type leveldb (line 115) | namespace leveldb { class RandomGenerator (line 119) | class RandomGenerator { method RandomGenerator (line 125) | RandomGenerator() { method Slice (line 140) | Slice Generate(int len) { function Slice (line 150) | static Slice TrimSpace(Slice s) { class Benchmark (line 164) | class Benchmark { method PrintHeader (line 182) | void PrintHeader() { method PrintWarnings (line 195) | void PrintWarnings() { method PrintEnvironment (line 208) | void PrintEnvironment() { method Start (line 243) | void Start() { method FinishedSingleOp (line 253) | void FinishedSingleOp() { method Stop (line 286) | void Stop(const Slice& name) { type Order (line 315) | enum Order { SEQUENTIAL, RANDOM } type DBState (line 316) | enum DBState { FRESH, EXISTING } method Benchmark (line 318) | Benchmark() method Run (line 346) | void Run() { method Open (line 421) | void Open() { method Write (line 483) | void Write(bool write_sync, Order order, DBState state, int num_entr... method Read (line 586) | void Read(Order order, int entries_per_batch) { method ReadSequential (line 655) | void ReadSequential() { function main (line 674) | int main(int argc, char** argv) { FILE: benchmarks/db_bench_tree_db.cc function DBSynchronize (line 75) | inline static void DBSynchronize(kyotocabinet::TreeDB* db_) { type leveldb (line 82) | namespace leveldb { class RandomGenerator (line 86) | class RandomGenerator { method RandomGenerator (line 92) | RandomGenerator() { method Slice (line 107) | Slice Generate(int len) { function Slice (line 117) | static Slice TrimSpace(Slice s) { class Benchmark (line 131) | class Benchmark { method PrintHeader (line 150) | void PrintHeader() { method PrintWarnings (line 170) | void PrintWarnings() { method PrintEnvironment (line 183) | void PrintEnvironment() { method Start (line 221) | void Start() { method FinishedSingleOp (line 231) | void FinishedSingleOp() { method Stop (line 264) | void Stop(const Slice& name) { type Order (line 293) | enum Order { SEQUENTIAL, RANDOM } type DBState (line 294) | enum DBState { FRESH, EXISTING } method Benchmark (line 296) | Benchmark() method Run (line 324) | void Run() { method Open (line 395) | void Open(bool sync) { method Write (line 428) | void Write(bool sync, Order order, DBState state, int num_entries, method ReadSequential (line 462) | void ReadSequential() { method ReadRandom (line 473) | void ReadRandom() { function main (line 487) | int main(int argc, char** argv) { FILE: db/autocompact_test.cc type leveldb (line 11) | namespace leveldb { class AutoCompactTest (line 13) | class AutoCompactTest : public testing::Test { method AutoCompactTest (line 15) | AutoCompactTest() { method Key (line 31) | std::string Key(int i) { method Size (line 37) | uint64_t Size(const Slice& start, const Slice& limit) { function TEST_F (line 106) | TEST_F(AutoCompactTest, ReadAll) { DoReads(kCount); } function TEST_F (line 108) | TEST_F(AutoCompactTest, ReadHalf) { DoReads(kCount / 2); } FILE: db/builder.cc type leveldb (line 15) | namespace leveldb { function Status (line 17) | Status BuildTable(const std::string& dbname, Env* env, const Options& ... FILE: db/builder.h function namespace (line 10) | namespace leveldb { FILE: db/c.cc type leveldb_t (line 49) | struct leveldb_t { type leveldb_iterator_t (line 52) | struct leveldb_iterator_t { type leveldb_writebatch_t (line 55) | struct leveldb_writebatch_t { type leveldb_snapshot_t (line 58) | struct leveldb_snapshot_t { type leveldb_readoptions_t (line 61) | struct leveldb_readoptions_t { type leveldb_writeoptions_t (line 64) | struct leveldb_writeoptions_t { type leveldb_options_t (line 67) | struct leveldb_options_t { type leveldb_cache_t (line 70) | struct leveldb_cache_t { type leveldb_seqfile_t (line 73) | struct leveldb_seqfile_t { type leveldb_randomfile_t (line 76) | struct leveldb_randomfile_t { type leveldb_writablefile_t (line 79) | struct leveldb_writablefile_t { type leveldb_logger_t (line 82) | struct leveldb_logger_t { type leveldb_filelock_t (line 85) | struct leveldb_filelock_t { type leveldb_comparator_t (line 89) | struct leveldb_comparator_t : public Comparator { method Compare (line 92) | int Compare(const Slice& a, const Slice& b) const override { method FindShortestSeparator (line 99) | void FindShortestSeparator(std::string*, const Slice&) const override {} method FindShortSuccessor (line 100) | void FindShortSuccessor(std::string* key) const override {} type leveldb_filterpolicy_t (line 109) | struct leveldb_filterpolicy_t : public FilterPolicy { method CreateFilter (line 114) | void CreateFilter(const Slice* keys, int n, std::string* dst) const ov... method KeyMayMatch (line 127) | bool KeyMayMatch(const Slice& key, const Slice& filter) const override { type leveldb_env_t (line 142) | struct leveldb_env_t { function SaveError (line 147) | static bool SaveError(char** errptr, const Status& s) { function leveldb_t (line 168) | leveldb_t* leveldb_open(const leveldb_options_t* options, const char* name, function leveldb_close (line 179) | void leveldb_close(leveldb_t* db) { function leveldb_put (line 184) | void leveldb_put(leveldb_t* db, const leveldb_writeoptions_t* options, function leveldb_delete (line 191) | void leveldb_delete(leveldb_t* db, const leveldb_writeoptions_t* options, function leveldb_write (line 196) | void leveldb_write(leveldb_t* db, const leveldb_writeoptions_t* options, function leveldb_iterator_t (line 219) | leveldb_iterator_t* leveldb_create_iterator( function leveldb_snapshot_t (line 226) | const leveldb_snapshot_t* leveldb_create_snapshot(leveldb_t* db) { function leveldb_release_snapshot (line 232) | void leveldb_release_snapshot(leveldb_t* db, function leveldb_approximate_sizes (line 248) | void leveldb_approximate_sizes(leveldb_t* db, int num_ranges, function leveldb_compact_range (line 263) | void leveldb_compact_range(leveldb_t* db, const char* start_key, function leveldb_destroy_db (line 273) | void leveldb_destroy_db(const leveldb_options_t* options, const char* name, function leveldb_repair_db (line 278) | void leveldb_repair_db(const leveldb_options_t* options, const char* name, function leveldb_iter_destroy (line 283) | void leveldb_iter_destroy(leveldb_iterator_t* iter) { function leveldb_iter_valid (line 288) | uint8_t leveldb_iter_valid(const leveldb_iterator_t* iter) { function leveldb_iter_seek_to_first (line 292) | void leveldb_iter_seek_to_first(leveldb_iterator_t* iter) { function leveldb_iter_seek_to_last (line 296) | void leveldb_iter_seek_to_last(leveldb_iterator_t* iter) { function leveldb_iter_seek (line 300) | void leveldb_iter_seek(leveldb_iterator_t* iter, const char* k, size_t k... function leveldb_iter_next (line 304) | void leveldb_iter_next(leveldb_iterator_t* iter) { iter->rep->Next(); } function leveldb_iter_prev (line 306) | void leveldb_iter_prev(leveldb_iterator_t* iter) { iter->rep->Prev(); } function leveldb_iter_get_error (line 320) | void leveldb_iter_get_error(const leveldb_iterator_t* iter, char** errpt... function leveldb_writebatch_t (line 324) | leveldb_writebatch_t* leveldb_writebatch_create() { function leveldb_writebatch_destroy (line 328) | void leveldb_writebatch_destroy(leveldb_writebatch_t* b) { delete b; } function leveldb_writebatch_clear (line 330) | void leveldb_writebatch_clear(leveldb_writebatch_t* b) { b->rep.Clear(); } function leveldb_writebatch_put (line 332) | void leveldb_writebatch_put(leveldb_writebatch_t* b, const char* key, function leveldb_writebatch_delete (line 337) | void leveldb_writebatch_delete(leveldb_writebatch_t* b, const char* key, function leveldb_writebatch_iterate (line 342) | void leveldb_writebatch_iterate(const leveldb_writebatch_t* b, void* state, function leveldb_writebatch_append (line 366) | void leveldb_writebatch_append(leveldb_writebatch_t* destination, function leveldb_options_t (line 371) | leveldb_options_t* leveldb_options_create() { return new leveldb_options... function leveldb_options_destroy (line 373) | void leveldb_options_destroy(leveldb_options_t* options) { delete option... function leveldb_options_set_comparator (line 375) | void leveldb_options_set_comparator(leveldb_options_t* opt, function leveldb_options_set_filter_policy (line 380) | void leveldb_options_set_filter_policy(leveldb_options_t* opt, function leveldb_options_set_create_if_missing (line 385) | void leveldb_options_set_create_if_missing(leveldb_options_t* opt, uint8... function leveldb_options_set_error_if_exists (line 389) | void leveldb_options_set_error_if_exists(leveldb_options_t* opt, uint8_t... function leveldb_options_set_paranoid_checks (line 393) | void leveldb_options_set_paranoid_checks(leveldb_options_t* opt, uint8_t... function leveldb_options_set_env (line 397) | void leveldb_options_set_env(leveldb_options_t* opt, leveldb_env_t* env) { function leveldb_options_set_info_log (line 401) | void leveldb_options_set_info_log(leveldb_options_t* opt, leveldb_logger... function leveldb_options_set_write_buffer_size (line 405) | void leveldb_options_set_write_buffer_size(leveldb_options_t* opt, size_... function leveldb_options_set_max_open_files (line 409) | void leveldb_options_set_max_open_files(leveldb_options_t* opt, int n) { function leveldb_options_set_cache (line 413) | void leveldb_options_set_cache(leveldb_options_t* opt, leveldb_cache_t* ... function leveldb_options_set_block_size (line 417) | void leveldb_options_set_block_size(leveldb_options_t* opt, size_t s) { function leveldb_options_set_block_restart_interval (line 421) | void leveldb_options_set_block_restart_interval(leveldb_options_t* opt, ... function leveldb_options_set_max_file_size (line 425) | void leveldb_options_set_max_file_size(leveldb_options_t* opt, size_t s) { function leveldb_options_set_compression (line 429) | void leveldb_options_set_compression(leveldb_options_t* opt, int t) { function leveldb_comparator_t (line 433) | leveldb_comparator_t* leveldb_comparator_create( method Compare (line 92) | int Compare(const Slice& a, const Slice& b) const override { method FindShortestSeparator (line 99) | void FindShortestSeparator(std::string*, const Slice&) const override {} method FindShortSuccessor (line 100) | void FindShortSuccessor(std::string* key) const override {} function leveldb_comparator_destroy (line 446) | void leveldb_comparator_destroy(leveldb_comparator_t* cmp) { delete cmp; } function leveldb_filterpolicy_t (line 448) | leveldb_filterpolicy_t* leveldb_filterpolicy_create( method CreateFilter (line 114) | void CreateFilter(const Slice* keys, int n, std::string* dst) const ov... method KeyMayMatch (line 127) | bool KeyMayMatch(const Slice& key, const Slice& filter) const override { function leveldb_filterpolicy_destroy (line 465) | void leveldb_filterpolicy_destroy(leveldb_filterpolicy_t* filter) { function leveldb_filterpolicy_t (line 469) | leveldb_filterpolicy_t* leveldb_filterpolicy_create_bloom(int bits_per_k... method CreateFilter (line 114) | void CreateFilter(const Slice* keys, int n, std::string* dst) const ov... method KeyMayMatch (line 127) | bool KeyMayMatch(const Slice& key, const Slice& filter) const override { function leveldb_readoptions_t (line 494) | leveldb_readoptions_t* leveldb_readoptions_create() { function leveldb_readoptions_destroy (line 498) | void leveldb_readoptions_destroy(leveldb_readoptions_t* opt) { delete op... function leveldb_readoptions_set_verify_checksums (line 500) | void leveldb_readoptions_set_verify_checksums(leveldb_readoptions_t* opt, function leveldb_readoptions_set_fill_cache (line 505) | void leveldb_readoptions_set_fill_cache(leveldb_readoptions_t* opt, uint... function leveldb_readoptions_set_snapshot (line 509) | void leveldb_readoptions_set_snapshot(leveldb_readoptions_t* opt, function leveldb_writeoptions_t (line 514) | leveldb_writeoptions_t* leveldb_writeoptions_create() { function leveldb_writeoptions_destroy (line 518) | void leveldb_writeoptions_destroy(leveldb_writeoptions_t* opt) { delete ... function leveldb_writeoptions_set_sync (line 520) | void leveldb_writeoptions_set_sync(leveldb_writeoptions_t* opt, uint8_t ... function leveldb_cache_t (line 524) | leveldb_cache_t* leveldb_cache_create_lru(size_t capacity) { function leveldb_cache_destroy (line 530) | void leveldb_cache_destroy(leveldb_cache_t* cache) { function leveldb_env_t (line 535) | leveldb_env_t* leveldb_create_default_env() { function leveldb_env_destroy (line 542) | void leveldb_env_destroy(leveldb_env_t* env) { function leveldb_free (line 559) | void leveldb_free(void* ptr) { std::free(ptr); } function leveldb_major_version (line 561) | int leveldb_major_version() { return kMajorVersion; } function leveldb_minor_version (line 563) | int leveldb_minor_version() { return kMinorVersion; } FILE: db/c_test.c function StartPhase (line 14) | static void StartPhase(const char* name) { function CheckEqual (line 31) | static void CheckEqual(const char* expected, const char* v, size_t n) { function Free (line 47) | static void Free(char** ptr) { function CheckGet (line 54) | static void CheckGet( function CheckIter (line 68) | static void CheckIter(leveldb_iterator_t* iter, function CheckPut (line 79) | static void CheckPut(void* ptr, function CheckDel (line 98) | static void CheckDel(void* ptr, const char* k, size_t klen) { function CmpDestroy (line 105) | static void CmpDestroy(void* arg) { } function CmpCompare (line 107) | static int CmpCompare(void* arg, const char* a, size_t alen, function FilterDestroy (line 124) | static void FilterDestroy(void* arg) { } function FilterKeyMatch (line 138) | uint8_t FilterKeyMatch(void* arg, const char* key, size_t length, function main (line 145) | int main(int argc, char** argv) { FILE: db/corruption_test.cc type leveldb (line 19) | namespace leveldb { class CorruptionTest (line 23) | class CorruptionTest : public testing::Test { method CorruptionTest (line 25) | CorruptionTest() method Status (line 43) | Status TryReopen() { method Reopen (line 49) | void Reopen() { ASSERT_LEVELDB_OK(TryReopen()); } method RepairDB (line 51) | void RepairDB() { method Build (line 57) | void Build(int n) { method Check (line 75) | void Check(int min_expected, int max_expected) { method Corrupt (line 113) | void Corrupt(FileType filetype, int offset, int bytes_to_corrupt) { method Property (line 159) | int Property(const std::string& name) { method Slice (line 171) | Slice Key(int i, std::string* storage) { method Slice (line 179) | Slice Value(int k, std::string* storage) { function TEST_F (line 193) | TEST_F(CorruptionTest, Recovery) { function TEST_F (line 204) | TEST_F(CorruptionTest, RecoverWriteError) { function TEST_F (line 210) | TEST_F(CorruptionTest, NewFileErrorDuringWrite) { function TEST_F (line 227) | TEST_F(CorruptionTest, TableFile) { function TEST_F (line 238) | TEST_F(CorruptionTest, TableFileRepair) { function TEST_F (line 254) | TEST_F(CorruptionTest, TableFileIndexData) { function TEST_F (line 264) | TEST_F(CorruptionTest, MissingDescriptor) { function TEST_F (line 271) | TEST_F(CorruptionTest, SequenceNumberRecovery) { function TEST_F (line 292) | TEST_F(CorruptionTest, CorruptedDescriptor) { function TEST_F (line 309) | TEST_F(CorruptionTest, CompactionInputError) { function TEST_F (line 324) | TEST_F(CorruptionTest, CompactionInputErrorParanoid) { function TEST_F (line 345) | TEST_F(CorruptionTest, UnrelatedKeys) { FILE: db/db_impl.cc type leveldb (line 38) | namespace leveldb { type DBImpl::Writer (line 43) | struct DBImpl::Writer { method Writer (line 44) | explicit Writer(port::Mutex* mu) type DBImpl::CompactionState (line 54) | struct DBImpl::CompactionState { type Output (line 56) | struct Output { method Output (line 62) | Output* current_output() { return &outputs[outputs.size() - 1]; } method CompactionState (line 64) | explicit CompactionState(Compaction* c) function ClipToRange (line 90) | static void ClipToRange(T* ptr, V minvalue, V maxvalue) { function Options (line 94) | Options SanitizeOptions(const std::string& dbname, function TableCacheSize (line 121) | static int TableCacheSize(const Options& sanitized_options) { function Status (line 181) | Status DBImpl::NewDB() { function Status (line 292) | Status DBImpl::Recover(VersionEdit* edit, bool* save_manifest) { function Status (line 385) | Status DBImpl::RecoverLogFile(uint64_t log_number, bool last_log, function Status (line 505) | Status DBImpl::WriteLevel0Table(MemTable* mem, VersionEdit* edit, function Status (line 643) | Status DBImpl::TEST_CompactMemTable() { function Status (line 806) | Status DBImpl::OpenCompactionOutputFile(CompactionState* compact) { function Status (line 831) | Status DBImpl::FinishCompactionOutputFile(CompactionState* compact, function Status (line 880) | Status DBImpl::InstallCompactionResults(CompactionState* compact) { function Status (line 898) | Status DBImpl::DoCompactionWork(CompactionState* compact) { type IterState (line 1061) | struct IterState { method IterState (line 1067) | IterState(port::Mutex* mutex, MemTable* mem, MemTable* imm, Version*... function CleanupIteratorState (line 1071) | static void CleanupIteratorState(void* arg1, void* arg2) { function Iterator (line 1083) | Iterator* DBImpl::NewInternalIterator(const ReadOptions& options, function Iterator (line 1110) | Iterator* DBImpl::TEST_NewInternalIterator() { function Status (line 1121) | Status DBImpl::Get(const ReadOptions& options, const Slice& key, function Iterator (line 1168) | Iterator* DBImpl::NewIterator(const ReadOptions& options) { function Snapshot (line 1187) | const Snapshot* DBImpl::GetSnapshot() { function Status (line 1198) | Status DBImpl::Put(const WriteOptions& o, const Slice& key, const Slic... function Status (line 1202) | Status DBImpl::Delete(const WriteOptions& options, const Slice& key) { function Status (line 1206) | Status DBImpl::Write(const WriteOptions& options, WriteBatch* updates) { function WriteBatch (line 1281) | WriteBatch* DBImpl::BuildBatchGroup(Writer** last_writer) { function Status (line 1331) | Status DBImpl::MakeRoomForWrite(bool force) { function Status (line 1489) | Status DB::Put(const WriteOptions& opt, const Slice& key, const Slice&... function Status (line 1495) | Status DB::Delete(const WriteOptions& opt, const Slice& key) { function Status (line 1503) | Status DB::Open(const Options& options, const std::string& dbname, DB*... function Status (line 1548) | Status DestroyDB(const std::string& dbname, const Options& options) { FILE: db/db_impl.h function namespace (line 21) | namespace leveldb { FILE: db/db_iter.cc type leveldb (line 17) | namespace leveldb { function DumpInternalIter (line 20) | static void DumpInternalIter(Iterator* iter) { class DBIter (line 39) | class DBIter : public Iterator { type Direction (line 46) | enum Direction { kForward, kReverse } method DBIter (line 48) | DBIter(DBImpl* db, const Comparator* cmp, Iterator* iter, SequenceNu... method DBIter (line 59) | DBIter(const DBIter&) = delete; method DBIter (line 60) | DBIter& operator=(const DBIter&) = delete; method Valid (line 63) | bool Valid() const override { return valid_; } method Slice (line 64) | Slice key() const override { method Slice (line 68) | Slice value() const override { method Status (line 72) | Status status() const override { method SaveKey (line 91) | inline void SaveKey(const Slice& k, std::string* dst) { method ClearSavedValue (line 95) | inline void ClearSavedValue() { method RandomCompactionPeriod (line 105) | size_t RandomCompactionPeriod() { function Iterator (line 312) | Iterator* NewDBIterator(DBImpl* db, const Comparator* user_key_compara... FILE: db/db_iter.h function namespace (line 13) | namespace leveldb { FILE: db/db_test.cc type leveldb (line 27) | namespace leveldb { function RandomString (line 29) | static std::string RandomString(Random* rnd, int len) { function RandomKey (line 35) | static std::string RandomKey(Random* rnd) { class AtomicCounter (line 43) | class AtomicCounter { method AtomicCounter (line 45) | AtomicCounter() : count_(0) {} method Increment (line 46) | void Increment() { IncrementBy(1); } method LOCKS_EXCLUDED (line 47) | LOCKS_EXCLUDED(mu_) { method LOCKS_EXCLUDED (line 51) | int Read() LOCKS_EXCLUDED(mu_) { method LOCKS_EXCLUDED (line 55) | void Reset() LOCKS_EXCLUDED(mu_) { function DelayMilliseconds (line 65) | void DelayMilliseconds(int millis) { function IsLdbFile (line 69) | bool IsLdbFile(const std::string& f) { function IsLogFile (line 73) | bool IsLogFile(const std::string& f) { function IsManifestFile (line 77) | bool IsManifestFile(const std::string& f) { class TestEnv (line 84) | class TestEnv : public EnvWrapper { method TestEnv (line 86) | explicit TestEnv(Env* base) : EnvWrapper(base), ignore_dot_files_(fa... method SetIgnoreDotFiles (line 88) | void SetIgnoreDotFiles(bool ignored) { ignore_dot_files_ = ignored; } method Status (line 90) | Status GetChildren(const std::string& dir, class SpecialEnv (line 114) | class SpecialEnv : public EnvWrapper { method SpecialEnv (line 144) | explicit SpecialEnv(Env* base) method Status (line 155) | Status NewWritableFile(const std::string& f, WritableFile** r) { method Status (line 235) | Status NewRandomAccessFile(const std::string& f, RandomAccessFile** ... class DBTest (line 260) | class DBTest : public testing::Test { method DBTest (line 268) | DBTest() : env_(new SpecialEnv(Env::Default())), option_config_(kDef... method ChangeOptions (line 285) | bool ChangeOptions() { method Options (line 296) | Options CurrentOptions() { method DBImpl (line 315) | DBImpl* dbfull() { return reinterpret_cast(db_); } method Reopen (line 317) | void Reopen(Options* options = nullptr) { method Close (line 321) | void Close() { method DestroyAndReopen (line 326) | void DestroyAndReopen(Options* options = nullptr) { method Status (line 333) | Status TryReopen(Options* options) { method Status (line 348) | Status Put(const std::string& k, const std::string& v) { method Status (line 352) | Status Delete(const std::string& k) { return db_->Delete(WriteOption... method Get (line 354) | std::string Get(const std::string& k, const Snapshot* snapshot = nul... method Contents (line 369) | std::string Contents() { method AllEntriesFor (line 394) | std::string AllEntriesFor(const Slice& user_key) { method NumTableFilesAtLevel (line 436) | int NumTableFilesAtLevel(int level) { method TotalTableFiles (line 443) | int TotalTableFiles() { method FilesPerLevel (line 452) | std::string FilesPerLevel() { method CountFiles (line 468) | int CountFiles() { method Size (line 474) | uint64_t Size(const Slice& start, const Slice& limit) { method Compact (line 481) | void Compact(const Slice& start, const Slice& limit) { method MakeTables (line 487) | void MakeTables(int n, const std::string& small_key, method FillLevels (line 498) | void FillLevels(const std::string& smallest, const std::string& larg... method DumpFileCounts (line 502) | void DumpFileCounts(const char* label) { method DumpSSTableList (line 515) | std::string DumpSSTableList() { method IterStatus (line 521) | std::string IterStatus(Iterator* iter) { method DeleteAnSSTFile (line 531) | bool DeleteAnSSTFile() { method RenameLDBToSST (line 546) | int RenameLDBToSST() { type OptionConfig (line 565) | enum OptionConfig { kDefault, kReuse, kFilter, kUncompressed, kEnd } function TEST_F (line 571) | TEST_F(DBTest, Empty) { function TEST_F (line 578) | TEST_F(DBTest, EmptyKey) { function TEST_F (line 587) | TEST_F(DBTest, EmptyValue) { function TEST_F (line 598) | TEST_F(DBTest, ReadWrite) { function TEST_F (line 609) | TEST_F(DBTest, PutDeleteGet) { function TEST_F (line 620) | TEST_F(DBTest, GetFromImmutableLayer) { function TEST_F (line 640) | TEST_F(DBTest, GetFromVersions) { function TEST_F (line 648) | TEST_F(DBTest, GetMemUsage) { function TEST_F (line 659) | TEST_F(DBTest, GetSnapshot) { function TEST_F (line 677) | TEST_F(DBTest, GetIdenticalSnapshots) { function TEST_F (line 702) | TEST_F(DBTest, IterateOverEmptySnapshot) { function TEST_F (line 726) | TEST_F(DBTest, GetLevel0Ordering) { function TEST_F (line 741) | TEST_F(DBTest, GetOrderedByLevels) { function TEST_F (line 753) | TEST_F(DBTest, GetPicksCorrectFile) { function TEST_F (line 768) | TEST_F(DBTest, GetEncountersEmptyLevel) { function TEST_F (line 806) | TEST_F(DBTest, IterEmpty) { function TEST_F (line 821) | TEST_F(DBTest, IterSingle) { function TEST_F (line 859) | TEST_F(DBTest, IterMulti) { function TEST_F (line 942) | TEST_F(DBTest, IterSmallAndLargeMix) { function TEST_F (line 980) | TEST_F(DBTest, IterMultiWithDelete) { function TEST_F (line 997) | TEST_F(DBTest, IterMultiWithDeleteAndCompaction) { function TEST_F (line 1017) | TEST_F(DBTest, Recover) { function TEST_F (line 1039) | TEST_F(DBTest, RecoveryWithEmptyLog) { function TEST_F (line 1053) | TEST_F(DBTest, RecoverDuringMemtableCompaction) { function Key (line 1076) | static std::string Key(int i) { function TEST_F (line 1082) | TEST_F(DBTest, MinorCompactionsHappen) { function TEST_F (line 1107) | TEST_F(DBTest, RecoverWithLargeLog) { function TEST_F (line 1131) | TEST_F(DBTest, CompactionsGenerateMultipleFiles) { function TEST_F (line 1157) | TEST_F(DBTest, RepeatedWritesToSameKey) { function TEST_F (line 1176) | TEST_F(DBTest, SparseMerge) { function Between (line 1216) | static bool Between(uint64_t val, uint64_t low, uint64_t high) { function TEST_F (line 1226) | TEST_F(DBTest, ApproximateSizes) { function TEST_F (line 1285) | TEST_F(DBTest, ApproximateSizes_MixOfSmallAndLarge) { function TEST_F (line 1328) | TEST_F(DBTest, IteratorPinsRef) { function TEST_F (line 1351) | TEST_F(DBTest, Snapshot) { function TEST_F (line 1380) | TEST_F(DBTest, HiddenValuesAreRemoved) { function TEST_F (line 1411) | TEST_F(DBTest, DeletionMarkers1) { function TEST_F (line 1440) | TEST_F(DBTest, DeletionMarkers2) { function TEST_F (line 1466) | TEST_F(DBTest, OverlapInLevel0) { function TEST_F (line 1508) | TEST_F(DBTest, L0_CompactionBug_Issue44_a) { function TEST_F (line 1525) | TEST_F(DBTest, L0_CompactionBug_Issue44_b) { function TEST_F (line 1551) | TEST_F(DBTest, Fflush_Issue474) { function TEST_F (line 1560) | TEST_F(DBTest, ComparatorCheck) { function TEST_F (line 1583) | TEST_F(DBTest, CustomComparator) { function TEST_F (line 1639) | TEST_F(DBTest, ManualCompaction) { function TEST_F (line 1673) | TEST_F(DBTest, DBOpen_Options) { function TEST_F (line 1712) | TEST_F(DBTest, DestroyEmptyDir) { function TEST_F (line 1746) | TEST_F(DBTest, DestroyOpenDB) { function TEST_F (line 1770) | TEST_F(DBTest, Locking) { function TEST_F (line 1777) | TEST_F(DBTest, NoSpace) { function TEST_F (line 1797) | TEST_F(DBTest, NonWritableFileSystem) { function TEST_F (line 1818) | TEST_F(DBTest, WriteSyncError) { function TEST_F (line 1849) | TEST_F(DBTest, ManifestWriteError) { function TEST_F (line 1889) | TEST_F(DBTest, MissingSSTFile) { function TEST_F (line 1906) | TEST_F(DBTest, StillReadSST) { function TEST_F (line 1922) | TEST_F(DBTest, FilesDeletedAfterCompaction) { function TEST_F (line 1933) | TEST_F(DBTest, BloomFilter) { function TEST_F (line 1980) | TEST_F(DBTest, LogCloseError) { type MTState (line 2014) | struct MTState { type MTThread (line 2021) | struct MTThread { function MTThreadBody (line 2026) | static void MTThreadBody(void* arg) { function TEST_F (line 2072) | TEST_F(DBTest, MultiThreaded) { class ModelDB (line 2108) | class ModelDB : public DB { class ModelSnapshot (line 2110) | class ModelSnapshot : public Snapshot { method ModelDB (line 2115) | explicit ModelDB(const Options& options) : options_(options) {} method Status (line 2117) | Status Put(const WriteOptions& o, const Slice& k, const Slice& v) ov... method Status (line 2120) | Status Delete(const WriteOptions& o, const Slice& key) override { method Status (line 2123) | Status Get(const ReadOptions& options, const Slice& key, method Iterator (line 2128) | Iterator* NewIterator(const ReadOptions& options) override { method Snapshot (line 2139) | const Snapshot* GetSnapshot() override { method ReleaseSnapshot (line 2145) | void ReleaseSnapshot(const Snapshot* snapshot) override { method Status (line 2148) | Status Write(const WriteOptions& options, WriteBatch* batch) override { method GetProperty (line 2162) | bool GetProperty(const Slice& property, std::string* value) override { method GetApproximateSizes (line 2165) | void GetApproximateSizes(const Range* r, int n, uint64_t* sizes) ove... method CompactRange (line 2170) | void CompactRange(const Slice* start, const Slice* end) override {} class ModelIter (line 2173) | class ModelIter : public Iterator { method ModelIter (line 2175) | ModelIter(const KVMap* map, bool owned) method Valid (line 2180) | bool Valid() const override { return iter_ != map_->end(); } method SeekToFirst (line 2181) | void SeekToFirst() override { iter_ = map_->begin(); } method SeekToLast (line 2182) | void SeekToLast() override { method Seek (line 2189) | void Seek(const Slice& k) override { method Next (line 2192) | void Next() override { ++iter_; } method Prev (line 2193) | void Prev() override { --iter_; } method Slice (line 2194) | Slice key() const override { return iter_->first; } method Slice (line 2195) | Slice value() const override { return iter_->second; } method Status (line 2196) | Status status() const override { return Status::OK(); } function CompareIterators (line 2207) | static bool CompareIterators(int step, DB* model, DB* db, function TEST_F (line 2292) | TEST_F(DBTest, Randomized) { FILE: db/dbformat.cc type leveldb (line 13) | namespace leveldb { function PackSequenceAndType (line 15) | static uint64_t PackSequenceAndType(uint64_t seq, ValueType t) { function AppendInternalKey (line 21) | void AppendInternalKey(std::string* result, const ParsedInternalKey& k... FILE: db/dbformat.h function namespace (line 20) | namespace leveldb { FILE: db/dbformat_test.cc type leveldb (line 10) | namespace leveldb { function IKey (line 12) | static std::string IKey(const std::string& user_key, uint64_t seq, function Shorten (line 19) | static std::string Shorten(const std::string& s, const std::string& l) { function ShortSuccessor (line 25) | static std::string ShortSuccessor(const std::string& s) { function TestKey (line 31) | static void TestKey(const std::string& key, uint64_t seq, ValueType vt) { function TEST (line 45) | TEST(FormatTest, InternalKey_EncodeDecode) { function TEST (line 67) | TEST(FormatTest, InternalKey_DecodeFromEmpty) { function TEST (line 73) | TEST(FormatTest, InternalKeyShortSeparator) { function TEST (line 107) | TEST(FormatTest, InternalKeyShortestSuccessor) { function TEST (line 114) | TEST(FormatTest, ParsedInternalKeyDebugString) { function TEST (line 120) | TEST(FormatTest, InternalKeyDebugString) { FILE: db/dumpfile.cc type leveldb (line 22) | namespace leveldb { function GuessType (line 26) | bool GuessType(const std::string& fname, FileType* type) { class CorruptionReporter (line 39) | class CorruptionReporter : public log::Reader::Reporter { method Corruption (line 41) | void Corruption(size_t bytes, const Status& status) override { function Status (line 54) | Status PrintLogContents(Env* env, const std::string& fname, class WriteBatchItemPrinter (line 75) | class WriteBatchItemPrinter : public WriteBatch::Handler { method Put (line 77) | void Put(const Slice& key, const Slice& value) override { method Delete (line 85) | void Delete(const Slice& key) override { function WriteBatchPrinter (line 97) | static void WriteBatchPrinter(uint64_t pos, Slice record, WritableFile... function Status (line 122) | Status DumpLog(Env* env, const std::string& fname, WritableFile* dst) { function VersionEditPrinter (line 128) | static void VersionEditPrinter(uint64_t pos, Slice record, WritableFil... function Status (line 143) | Status DumpDescriptor(Env* env, const std::string& fname, WritableFile... function Status (line 147) | Status DumpTable(Env* env, const std::string& fname, WritableFile* dst) { function Status (line 214) | Status DumpFile(Env* env, const std::string& fname, WritableFile* dst) { FILE: db/fault_injection_test.cc type leveldb (line 28) | namespace leveldb { class FaultInjectionTestEnv (line 34) | class FaultInjectionTestEnv method FaultInjectionTestEnv (line 129) | FaultInjectionTestEnv() method LOCKS_EXCLUDED (line 150) | LOCKS_EXCLUDED(mutex_) { method LOCKS_EXCLUDED (line 154) | LOCKS_EXCLUDED(mutex_) { function GetDirName (line 39) | static std::string GetDirName(const std::string& filename) { function Status (line 48) | Status SyncDir(const std::string& dir) { function Status (line 54) | Status Truncate(const std::string& filename, uint64_t length) { type FileState (line 85) | struct FileState { method FileState (line 91) | FileState(const std::string& filename) method FileState (line 97) | FileState() : pos_(-1), pos_at_last_sync_(-1), pos_at_last_flush_(-1... method IsFullySynced (line 99) | bool IsFullySynced() const { return pos_ <= 0 || pos_ == pos_at_last... class TestWritableFile (line 108) | class TestWritableFile : public WritableFile { class FaultInjectionTestEnv (line 127) | class FaultInjectionTestEnv : public EnvWrapper { method FaultInjectionTestEnv (line 129) | FaultInjectionTestEnv() method LOCKS_EXCLUDED (line 150) | LOCKS_EXCLUDED(mutex_) { method LOCKS_EXCLUDED (line 154) | LOCKS_EXCLUDED(mutex_) { function Status (line 179) | Status TestWritableFile::Append(const Slice& data) { function Status (line 187) | Status TestWritableFile::Close() { function Status (line 196) | Status TestWritableFile::Flush() { function Status (line 204) | Status TestWritableFile::SyncParent() { function Status (line 212) | Status TestWritableFile::Sync() { function Status (line 230) | Status FaultInjectionTestEnv::NewWritableFile(const std::string& fname, function Status (line 248) | Status FaultInjectionTestEnv::NewAppendableFile(const std::string& fname, function Status (line 268) | Status FaultInjectionTestEnv::DropUnsyncedFileData() { function Status (line 301) | Status FaultInjectionTestEnv::RemoveFile(const std::string& f) { function Status (line 310) | Status FaultInjectionTestEnv::RenameFile(const std::string& s, function Status (line 338) | Status FaultInjectionTestEnv::RemoveFilesCreatedAfterLastDirSync() { function Status (line 359) | Status FileState::DropUnsyncedData() const { class FaultInjectionTest (line 364) | class FaultInjectionTest : public testing::Test { type ExpectedVerifResult (line 366) | enum ExpectedVerifResult { VAL_EXPECT_NO_ERROR, VAL_EXPECT_ERROR } type ResetMethod (line 367) | enum ResetMethod { RESET_DROP_UNSYNCED_DATA, RESET_DELETE_UNSYNCED_F... method FaultInjectionTest (line 375) | FaultInjectionTest() method ReuseLogs (line 395) | void ReuseLogs(bool reuse) { options_.reuse_logs = reuse; } method Build (line 397) | void Build(int start_idx, int num_vals) { method Status (line 409) | Status ReadValue(int i, std::string* val) const { method Status (line 417) | Status Verify(int start_idx, int num_vals, method Slice (line 440) | Slice Key(int i, std::string* storage) const { method Slice (line 448) | Slice Value(int k, std::string* storage) const { method Status (line 453) | Status OpenDB() { method CloseDB (line 460) | void CloseDB() { method DeleteAllData (line 465) | void DeleteAllData() { method ResetDBState (line 474) | void ResetDBState(ResetMethod reset_method) { method PartialCompactTestPreFault (line 487) | void PartialCompactTestPreFault(int num_pre_sync, int num_post_sync) { method PartialCompactTestReopenWithFault (line 494) | void PartialCompactTestReopenWithFault(ResetMethod reset_method, method NoWriteTestPreFault (line 506) | void NoWriteTestPreFault() {} method NoWriteTestReopenWithFault (line 508) | void NoWriteTestReopenWithFault(ResetMethod reset_method) { method DoTest (line 514) | void DoTest() { function TEST_F (line 540) | TEST_F(FaultInjectionTest, FaultTestNoLogReuse) { function TEST_F (line 545) | TEST_F(FaultInjectionTest, FaultTestWithLogReuse) { FILE: db/filename.cc type leveldb (line 14) | namespace leveldb { function MakeFileName (line 20) | static std::string MakeFileName(const std::string& dbname, uint64_t nu... function LogFileName (line 28) | std::string LogFileName(const std::string& dbname, uint64_t number) { function TableFileName (line 33) | std::string TableFileName(const std::string& dbname, uint64_t number) { function SSTTableFileName (line 38) | std::string SSTTableFileName(const std::string& dbname, uint64_t numbe... function DescriptorFileName (line 43) | std::string DescriptorFileName(const std::string& dbname, uint64_t num... function CurrentFileName (line 51) | std::string CurrentFileName(const std::string& dbname) { function LockFileName (line 55) | std::string LockFileName(const std::string& dbname) { return dbname + ... function TempFileName (line 57) | std::string TempFileName(const std::string& dbname, uint64_t number) { function InfoLogFileName (line 62) | std::string InfoLogFileName(const std::string& dbname) { function OldInfoLogFileName (line 67) | std::string OldInfoLogFileName(const std::string& dbname) { function ParseFileName (line 78) | bool ParseFileName(const std::string& filename, uint64_t* number, function Status (line 123) | Status SetCurrentFile(Env* env, const std::string& dbname, FILE: db/filename.h function namespace (line 17) | namespace leveldb { FILE: db/filename_test.cc type leveldb (line 12) | namespace leveldb { function TEST (line 14) | TEST(FileNameTest, Parse) { function TEST (line 73) | TEST(FileNameTest, Construction) { FILE: db/leveldbutil.cc type leveldb (line 11) | namespace leveldb { class StdoutPrinter (line 14) | class StdoutPrinter : public WritableFile { method Status (line 16) | Status Append(const Slice& data) override { method Status (line 20) | Status Close() override { return Status::OK(); } method Status (line 21) | Status Flush() override { return Status::OK(); } method Status (line 22) | Status Sync() override { return Status::OK(); } function HandleDumpCommand (line 25) | bool HandleDumpCommand(Env* env, char** files, int num) { function Usage (line 41) | static void Usage() { function main (line 48) | int main(int argc, char** argv) { FILE: db/log_format.h function namespace (line 11) | namespace leveldb { FILE: db/log_reader.cc type leveldb (line 13) | namespace leveldb { type log (line 14) | namespace log { FILE: db/log_reader.h function namespace (line 14) | namespace leveldb { FILE: db/log_test.cc type leveldb (line 13) | namespace leveldb { type log (line 14) | namespace log { function BigString (line 18) | static std::string BigString(const std::string& partial_string, size... function NumberString (line 28) | static std::string NumberString(int n) { function RandomSkewedString (line 35) | static std::string RandomSkewedString(int i, Random* rnd) { class LogTest (line 39) | class LogTest : public testing::Test { method LogTest (line 41) | LogTest() method ReopenForAppend (line 52) | void ReopenForAppend() { method Write (line 57) | void Write(const std::string& msg) { method WrittenBytes (line 62) | size_t WrittenBytes() const { return dest_.contents_.size(); } method Read (line 64) | std::string Read() { method IncrementByte (line 78) | void IncrementByte(int offset, int delta) { method SetByte (line 82) | void SetByte(int offset, char new_byte) { method ShrinkSize (line 86) | void ShrinkSize(int bytes) { method FixChecksum (line 90) | void FixChecksum(int header_offset, int len) { method ForceError (line 97) | void ForceError() { source_.force_error_ = true; } method DroppedBytes (line 99) | size_t DroppedBytes() const { return report_.dropped_bytes_; } method ReportMessage (line 101) | std::string ReportMessage() const { return report_.message_; } method MatchError (line 104) | std::string MatchError(const std::string& msg) const { method WriteInitialOffsetLog (line 112) | void WriteInitialOffsetLog() { method StartReadingAt (line 120) | void StartReadingAt(uint64_t initial_offset) { method CheckOffsetPastEndReturnsNoRecords (line 125) | void CheckOffsetPastEndReturnsNoRecords(uint64_t offset_past_end) { method CheckInitialOffsetRecord (line 137) | void CheckInitialOffsetRecord(uint64_t initial_offset, class StringDest (line 162) | class StringDest : public WritableFile { method Status (line 164) | Status Close() override { return Status::OK(); } method Status (line 165) | Status Flush() override { return Status::OK(); } method Status (line 166) | Status Sync() override { return Status::OK(); } method Status (line 167) | Status Append(const Slice& slice) override { class StringSource (line 175) | class StringSource : public SequentialFile { method StringSource (line 177) | StringSource() : force_error_(false), returned_partial_(false) {} method Status (line 179) | Status Read(size_t n, Slice* result, char* scratch) override { method Status (line 197) | Status Skip(uint64_t n) override { class ReportCollector (line 213) | class ReportCollector : public Reader::Reporter { method ReportCollector (line 215) | ReportCollector() : dropped_bytes_(0) {} method Corruption (line 216) | void Corruption(size_t bytes, const Status& status) override { function TEST_F (line 261) | TEST_F(LogTest, Empty) { ASSERT_EQ("EOF", Read()); } function TEST_F (line 263) | TEST_F(LogTest, ReadWrite) { function TEST_F (line 276) | TEST_F(LogTest, ManyBlocks) { function TEST_F (line 286) | TEST_F(LogTest, Fragmentation) { function TEST_F (line 296) | TEST_F(LogTest, MarginalTrailer) { function TEST_F (line 309) | TEST_F(LogTest, MarginalTrailer2) { function TEST_F (line 322) | TEST_F(LogTest, ShortTrailer) { function TEST_F (line 334) | TEST_F(LogTest, AlignedEof) { function TEST_F (line 342) | TEST_F(LogTest, OpenForAppend) { function TEST_F (line 351) | TEST_F(LogTest, RandomRead) { function TEST_F (line 366) | TEST_F(LogTest, ReadError) { function TEST_F (line 374) | TEST_F(LogTest, BadRecordType) { function TEST_F (line 384) | TEST_F(LogTest, TruncatedTrailingRecordIsIgnored) { function TEST_F (line 393) | TEST_F(LogTest, BadLength) { function TEST_F (line 404) | TEST_F(LogTest, BadLengthAtEndIsIgnored) { function TEST_F (line 412) | TEST_F(LogTest, ChecksumMismatch) { function TEST_F (line 420) | TEST_F(LogTest, UnexpectedMiddleType) { function TEST_F (line 429) | TEST_F(LogTest, UnexpectedLastType) { function TEST_F (line 438) | TEST_F(LogTest, UnexpectedFullType) { function TEST_F (line 449) | TEST_F(LogTest, UnexpectedFirstType) { function TEST_F (line 460) | TEST_F(LogTest, MissingLastIsIgnored) { function TEST_F (line 469) | TEST_F(LogTest, PartialLastIsIgnored) { function TEST_F (line 478) | TEST_F(LogTest, SkipIntoMultiRecord) { function TEST_F (line 494) | TEST_F(LogTest, ErrorJoinsRecords) { function TEST_F (line 517) | TEST_F(LogTest, ReadStart) { CheckInitialOffsetRecord(0, 0); } function TEST_F (line 519) | TEST_F(LogTest, ReadSecondOneOff) { CheckInitialOffsetRecord(1, 1); } function TEST_F (line 521) | TEST_F(LogTest, ReadSecondTenThousand) { CheckInitialOffsetRecord(10... function TEST_F (line 523) | TEST_F(LogTest, ReadSecondStart) { CheckInitialOffsetRecord(10007, 1... function TEST_F (line 525) | TEST_F(LogTest, ReadThirdOneOff) { CheckInitialOffsetRecord(10008, 2... function TEST_F (line 527) | TEST_F(LogTest, ReadThirdStart) { CheckInitialOffsetRecord(20014, 2); } function TEST_F (line 529) | TEST_F(LogTest, ReadFourthOneOff) { CheckInitialOffsetRecord(20015, ... function TEST_F (line 531) | TEST_F(LogTest, ReadFourthFirstBlockTrailer) { function TEST_F (line 535) | TEST_F(LogTest, ReadFourthMiddleBlock) { function TEST_F (line 539) | TEST_F(LogTest, ReadFourthLastBlock) { function TEST_F (line 543) | TEST_F(LogTest, ReadFourthStart) { function TEST_F (line 549) | TEST_F(LogTest, ReadInitialOffsetIntoBlockPadding) { function TEST_F (line 553) | TEST_F(LogTest, ReadEnd) { CheckOffsetPastEndReturnsNoRecords(0); } function TEST_F (line 555) | TEST_F(LogTest, ReadPastEnd) { CheckOffsetPastEndReturnsNoRecords(5); } FILE: db/log_writer.cc type leveldb (line 13) | namespace leveldb { type log (line 14) | namespace log { function InitTypeCrc (line 16) | static void InitTypeCrc(uint32_t* type_crc) { function Status (line 34) | Status Writer::AddRecord(const Slice& slice) { function Status (line 82) | Status Writer::EmitPhysicalRecord(RecordType t, const char* ptr, FILE: db/log_writer.h function namespace (line 14) | namespace leveldb { FILE: db/memtable.cc type leveldb (line 12) | namespace leveldb { function Slice (line 14) | static Slice GetLengthPrefixedSlice(const char* data) { class MemTableIterator (line 46) | class MemTableIterator : public Iterator { method MemTableIterator (line 48) | explicit MemTableIterator(MemTable::Table* table) : iter_(table) {} method MemTableIterator (line 50) | MemTableIterator(const MemTableIterator&) = delete; method MemTableIterator (line 51) | MemTableIterator& operator=(const MemTableIterator&) = delete; method Valid (line 55) | bool Valid() const override { return iter_.Valid(); } method Seek (line 56) | void Seek(const Slice& k) override { iter_.Seek(EncodeKey(&tmp_, k)); } method SeekToFirst (line 57) | void SeekToFirst() override { iter_.SeekToFirst(); } method SeekToLast (line 58) | void SeekToLast() override { iter_.SeekToLast(); } method Next (line 59) | void Next() override { iter_.Next(); } method Prev (line 60) | void Prev() override { iter_.Prev(); } method Slice (line 61) | Slice key() const override { return GetLengthPrefixedSlice(iter_.key... method Slice (line 62) | Slice value() const override { method Status (line 67) | Status status() const override { return Status::OK(); } function Iterator (line 74) | Iterator* MemTable::NewIterator() { return new MemTableIterator(&table... FILE: db/memtable.h function namespace (line 15) | namespace leveldb { FILE: db/recovery_test.cc type leveldb (line 16) | namespace leveldb { class RecoveryTest (line 18) | class RecoveryTest : public testing::Test { method RecoveryTest (line 20) | RecoveryTest() : env_(Env::Default()), db_(nullptr) { method DBImpl (line 31) | DBImpl* dbfull() const { return reinterpret_cast(db_); } method Env (line 32) | Env* env() const { return env_; } method CanAppend (line 34) | bool CanAppend() { method Close (line 45) | void Close() { method Status (line 50) | Status OpenWithStatus(Options* options = nullptr) { method Open (line 65) | void Open(Options* options = nullptr) { method Status (line 70) | Status Put(const std::string& k, const std::string& v) { method Get (line 74) | std::string Get(const std::string& k, const Snapshot* snapshot = nul... method ManifestFileName (line 85) | std::string ManifestFileName() { method LogName (line 96) | std::string LogName(uint64_t number) { return LogFileName(dbname_, n... method RemoveLogFiles (line 98) | size_t RemoveLogFiles() { method RemoveManifestFile (line 109) | void RemoveManifestFile() { method FirstLogFile (line 113) | uint64_t FirstLogFile() { return GetFiles(kLogFile)[0]; } method GetFiles (line 115) | std::vector GetFiles(FileType t) { method NumLogs (line 129) | int NumLogs() { return GetFiles(kLogFile).size(); } method NumTables (line 131) | int NumTables() { return GetFiles(kTableFile).size(); } method FileSize (line 133) | uint64_t FileSize(const std::string& fname) { method CompactMemTable (line 139) | void CompactMemTable() { dbfull()->TEST_CompactMemTable(); } method MakeLogFile (line 142) | void MakeLogFile(uint64_t lognum, SequenceNumber seq, Slice key, Sli... function TEST_F (line 161) | TEST_F(RecoveryTest, ManifestReused) { function TEST_F (line 178) | TEST_F(RecoveryTest, LargeManifestCompacted) { function TEST_F (line 210) | TEST_F(RecoveryTest, NoLogFiles) { function TEST_F (line 219) | TEST_F(RecoveryTest, LogFileReuse) { function TEST_F (line 250) | TEST_F(RecoveryTest, MultipleMemTables) { function TEST_F (line 279) | TEST_F(RecoveryTest, MultipleLogFiles) { function TEST_F (line 325) | TEST_F(RecoveryTest, ManifestMissing) { FILE: db/repair.cc type leveldb (line 41) | namespace leveldb { class Repairer (line 45) | class Repairer { method Repairer (line 47) | Repairer(const std::string& dbname, const Options& options) method Status (line 70) | Status Run() { type TableInfo (line 93) | struct TableInfo { method Status (line 98) | Status FindFiles() { method ConvertLogFilesToTables (line 131) | void ConvertLogFilesToTables() { method Status (line 143) | Status ConvertLogToTable(uint64_t log) { method ExtractMetaData (line 221) | void ExtractMetaData() { method Iterator (line 227) | Iterator* NewTableIterator(const FileMetaData& meta) { method ScanTable (line 235) | void ScanTable(uint64_t number) { method RepairTable (line 294) | void RepairTable(const std::string& src, TableInfo t) { method Status (line 348) | Status WriteDescriptor() { method ArchiveFile (line 408) | void ArchiveFile(const std::string& fname) { function Status (line 446) | Status RepairDB(const std::string& dbname, const Options& options) { FILE: db/skiplist.h function namespace (line 37) | namespace leveldb { FILE: db/skiplist_test.cc type leveldb (line 19) | namespace leveldb { type Comparator (line 23) | struct Comparator { function TEST (line 35) | TEST(SkipTest, Empty) { function TEST (line 51) | TEST(SkipTest, InsertAndLookup) { class ConcurrentTest (line 152) | class ConcurrentTest { method key (line 156) | static uint64_t key(Key key) { return (key >> 40); } method gen (line 157) | static uint64_t gen(Key key) { return (key >> 8) & 0xffffffffu; } method hash (line 158) | static uint64_t hash(Key key) { return key & 0xff; } method HashNumbers (line 160) | static uint64_t HashNumbers(uint64_t k, uint64_t g) { method Key (line 165) | static Key MakeKey(uint64_t k, uint64_t g) { method IsValidKey (line 172) | static bool IsValidKey(Key k) { method Key (line 176) | static Key RandomTarget(Random* rnd) { type State (line 191) | struct State { method Set (line 193) | void Set(int k, int v) { method Get (line 196) | int Get(int k) { return generation[k].load(std::memory_order_acqui... method State (line 198) | State() { method ConcurrentTest (line 215) | ConcurrentTest() : list_(Comparator(), &arena_) {} method WriteStep (line 218) | void WriteStep(Random* rnd) { method ReadStep (line 226) | void ReadStep(Random* rnd) { function TEST (line 289) | TEST(SkipTest, ConcurrentWithoutThreads) { class TestState (line 298) | class TestState { type ReaderState (line 304) | enum ReaderState { STARTING, RUNNING, DONE } method TestState (line 306) | explicit TestState(int s) method LOCKS_EXCLUDED (line 309) | LOCKS_EXCLUDED(mu_) { method LOCKS_EXCLUDED (line 317) | LOCKS_EXCLUDED(mu_) { function ConcurrentReader (line 330) | static void ConcurrentReader(void* arg) { function RunConcurrent (line 342) | static void RunConcurrent(int run) { function TEST (line 362) | TEST(SkipTest, Concurrent1) { RunConcurrent(1); } function TEST (line 363) | TEST(SkipTest, Concurrent2) { RunConcurrent(2); } function TEST (line 364) | TEST(SkipTest, Concurrent3) { RunConcurrent(3); } function TEST (line 365) | TEST(SkipTest, Concurrent4) { RunConcurrent(4); } function TEST (line 366) | TEST(SkipTest, Concurrent5) { RunConcurrent(5); } FILE: db/snapshot.h function namespace (line 11) | namespace leveldb { function class (line 39) | class SnapshotList { FILE: db/table_cache.cc type leveldb (line 12) | namespace leveldb { type TableAndFile (line 14) | struct TableAndFile { function DeleteEntry (line 19) | static void DeleteEntry(const Slice& key, void* value) { function UnrefEntry (line 26) | static void UnrefEntry(void* arg1, void* arg2) { function Status (line 41) | Status TableCache::FindTable(uint64_t file_number, uint64_t file_size, function Iterator (line 78) | Iterator* TableCache::NewIterator(const ReadOptions& options, function Status (line 100) | Status TableCache::Get(const ReadOptions& options, uint64_t file_number, FILE: db/table_cache.h function namespace (line 18) | namespace leveldb { FILE: db/version_edit.cc type leveldb (line 10) | namespace leveldb { type Tag (line 14) | enum Tag { function GetInternalKey (line 87) | static bool GetInternalKey(Slice* input, InternalKey* dst) { function GetLevel (line 96) | static bool GetLevel(Slice* input, int* level) { function Status (line 106) | Status VersionEdit::DecodeFrom(const Slice& src) { FILE: db/version_edit.h function namespace (line 14) | namespace leveldb { FILE: db/version_edit_test.cc type leveldb (line 9) | namespace leveldb { function TestEncodeDecode (line 11) | static void TestEncodeDecode(const VersionEdit& edit) { function TEST (line 21) | TEST(VersionEditTest, EncodeDecode) { FILE: db/version_set.cc type leveldb (line 22) | namespace leveldb { function TargetFileSize (line 24) | static size_t TargetFileSize(const Options* options) { function MaxGrandParentOverlapBytes (line 30) | static int64_t MaxGrandParentOverlapBytes(const Options* options) { function ExpandedCompactionByteSizeLimit (line 37) | static int64_t ExpandedCompactionByteSizeLimit(const Options* options) { function MaxBytesForLevel (line 41) | static double MaxBytesForLevel(const Options* options, int level) { function MaxFileSizeForLevel (line 54) | static uint64_t MaxFileSizeForLevel(const Options* options, int level) { function TotalFileSize (line 59) | static int64_t TotalFileSize(const std::vector& files) { function FindFile (line 87) | int FindFile(const InternalKeyComparator& icmp, function AfterFile (line 107) | static bool AfterFile(const Comparator* ucmp, const Slice* user_key, function BeforeFile (line 114) | static bool BeforeFile(const Comparator* ucmp, const Slice* user_key, function SomeFileOverlapsRange (line 121) | bool SomeFileOverlapsRange(const InternalKeyComparator& icmp, class Version::LevelFileNumIterator (line 163) | class Version::LevelFileNumIterator : public Iterator { method LevelFileNumIterator (line 165) | LevelFileNumIterator(const InternalKeyComparator& icmp, method Valid (line 169) | bool Valid() const override { return index_ < flist_->size(); } method Seek (line 170) | void Seek(const Slice& target) override { method SeekToFirst (line 173) | void SeekToFirst() override { index_ = 0; } method SeekToLast (line 174) | void SeekToLast() override { method Next (line 177) | void Next() override { method Prev (line 181) | void Prev() override { method Slice (line 189) | Slice key() const override { method Slice (line 193) | Slice value() const override { method Status (line 199) | Status status() const override { return Status::OK(); } function Iterator (line 210) | static Iterator* GetFileIterator(void* arg, const ReadOptions& options, function Iterator (line 222) | Iterator* Version::NewConcatenatingIterator(const ReadOptions& options, type SaverState (line 249) | enum SaverState { type Saver (line 255) | struct Saver { function SaveValue (line 262) | static void SaveValue(void* arg, const Slice& ikey, const Slice& v) { function NewestFirst (line 277) | static bool NewestFirst(FileMetaData* a, FileMetaData* b) { function Status (line 324) | Status Version::Get(const ReadOptions& options, const LookupKey& k, type State (line 421) | struct State { method Match (line 425) | static bool Match(void* arg, int level, FileMetaData* f) { class VersionSet::Builder (line 569) | class VersionSet::Builder { type BySmallestKey (line 572) | struct BySmallestKey { type LevelState (line 587) | struct LevelState { method Builder (line 598) | Builder(VersionSet* vset, Version* base) : vset_(vset), base_(base) { method Apply (line 629) | void Apply(const VersionEdit* edit) { method SaveTo (line 672) | void SaveTo(Version* v) { method MaybeAddFile (line 717) | void MaybeAddFile(Version* v, int level, FileMetaData* f) { function Status (line 777) | Status VersionSet::LogAndApply(VersionEdit* edit, port::Mutex* mu) { function Status (line 861) | Status VersionSet::Recover(bool* save_manifest) { function Status (line 1069) | Status VersionSet::WriteSnapshot(log::Writer* log) { function Iterator (line 1219) | Iterator* VersionSet::MakeInputIterator(Compaction* c) { function Compaction (line 1252) | Compaction* VersionSet::PickCompaction() { function FindLargestKey (line 1308) | bool FindLargestKey(const InternalKeyComparator& icmp, function FileMetaData (line 1326) | FileMetaData* FindSmallestBoundaryFile( function AddBoundaryInputs (line 1360) | void AddBoundaryInputs(const InternalKeyComparator& icmp, function Compaction (line 1448) | Compaction* VersionSet::CompactRange(int level, const InternalKey* begin, FILE: db/version_set.h function namespace (line 29) | namespace log { function class (line 60) | class Version { function class (line 167) | class VersionSet { FILE: db/version_set_test.cc type leveldb (line 11) | namespace leveldb { class FindFileTest (line 13) | class FindFileTest : public testing::Test { method FindFileTest (line 15) | FindFileTest() : disjoint_sorted_files_(true) {} method Add (line 23) | void Add(const char* smallest, const char* largest, method Find (line 33) | int Find(const char* key) { method Overlaps (line 39) | bool Overlaps(const char* smallest, const char* largest) { function TEST_F (line 54) | TEST_F(FindFileTest, Empty) { function TEST_F (line 62) | TEST_F(FindFileTest, Single) { function TEST_F (line 92) | TEST_F(FindFileTest, Multiple) { function TEST_F (line 130) | TEST_F(FindFileTest, MultipleNullBoundaries) { function TEST_F (line 150) | TEST_F(FindFileTest, OverlapSequenceChecks) { function TEST_F (line 159) | TEST_F(FindFileTest, OverlappingFiles) { class AddBoundaryInputsTest (line 181) | class AddBoundaryInputsTest : public testing::Test { method AddBoundaryInputsTest (line 188) | AddBoundaryInputsTest() : icmp_(BytewiseComparator()) {} method FileMetaData (line 197) | FileMetaData* CreateFileMetaData(uint64_t number, InternalKey smallest, function TEST_F (line 208) | TEST_F(AddBoundaryInputsTest, TestEmptyFileSets) { function TEST_F (line 214) | TEST_F(AddBoundaryInputsTest, TestEmptyLevelFiles) { function TEST_F (line 226) | TEST_F(AddBoundaryInputsTest, TestEmptyCompactionFiles) { function TEST_F (line 238) | TEST_F(AddBoundaryInputsTest, TestNoBoundaryFiles) { function TEST_F (line 259) | TEST_F(AddBoundaryInputsTest, TestOneBoundaryFiles) { function TEST_F (line 281) | TEST_F(AddBoundaryInputsTest, TestTwoBoundaryFiles) { function TEST_F (line 304) | TEST_F(AddBoundaryInputsTest, TestDisjoinFilePointers) { FILE: db/write_batch.cc type leveldb (line 24) | namespace leveldb { function Status (line 42) | Status WriteBatch::Iterate(Handler* handler) const { function SequenceNumber (line 90) | SequenceNumber WriteBatchInternal::Sequence(const WriteBatch* b) { class MemTableInserter (line 116) | class MemTableInserter : public WriteBatch::Handler { method Put (line 121) | void Put(const Slice& key, const Slice& value) override { method Delete (line 125) | void Delete(const Slice& key) override { function Status (line 132) | Status WriteBatchInternal::InsertInto(const WriteBatch* b, MemTable* m... FILE: db/write_batch_internal.h function namespace (line 11) | namespace leveldb { FILE: db/write_batch_test.cc type leveldb (line 12) | namespace leveldb { function PrintContents (line 14) | static std::string PrintContents(WriteBatch* b) { function TEST (line 54) | TEST(WriteBatchTest, Empty) { function TEST (line 60) | TEST(WriteBatchTest, Multiple) { function TEST (line 75) | TEST(WriteBatchTest, Corruption) { function TEST (line 89) | TEST(WriteBatchTest, Append) { function TEST (line 115) | TEST(WriteBatchTest, ApproximateSize) { FILE: helpers/memenv/memenv.cc type leveldb (line 19) | namespace leveldb { class FileState (line 23) | class FileState { method FileState (line 27) | FileState() : refs_(0), size_(0) {} method FileState (line 30) | FileState(const FileState&) = delete; method FileState (line 31) | FileState& operator=(const FileState&) = delete; method Ref (line 34) | void Ref() { method Unref (line 40) | void Unref() { method Size (line 57) | uint64_t Size() const { method Truncate (line 62) | void Truncate() { method Status (line 71) | Status Read(uint64_t offset, size_t n, Slice* result, char* scratch)... method Status (line 108) | Status Append(const Slice& data) { class SequentialFileImpl (line 152) | class SequentialFileImpl : public SequentialFile { method SequentialFileImpl (line 154) | explicit SequentialFileImpl(FileState* file) : file_(file), pos_(0) { method Status (line 160) | Status Read(size_t n, Slice* result, char* scratch) override { method Status (line 168) | Status Skip(uint64_t n) override { class RandomAccessFileImpl (line 185) | class RandomAccessFileImpl : public RandomAccessFile { method RandomAccessFileImpl (line 187) | explicit RandomAccessFileImpl(FileState* file) : file_(file) { file_... method Status (line 191) | Status Read(uint64_t offset, size_t n, Slice* result, class WritableFileImpl (line 200) | class WritableFileImpl : public WritableFile { method WritableFileImpl (line 202) | WritableFileImpl(FileState* file) : file_(file) { file_->Ref(); } method Status (line 206) | Status Append(const Slice& data) override { return file_->Append(dat... method Status (line 208) | Status Close() override { return Status::OK(); } method Status (line 209) | Status Flush() override { return Status::OK(); } method Status (line 210) | Status Sync() override { return Status::OK(); } class NoOpLogger (line 216) | class NoOpLogger : public Logger { method Logv (line 218) | void Logv(const char* format, std::va_list ap) override {} class InMemoryEnv (line 221) | class InMemoryEnv : public EnvWrapper { method InMemoryEnv (line 223) | explicit InMemoryEnv(Env* base_env) : EnvWrapper(base_env) {} method Status (line 232) | Status NewSequentialFile(const std::string& fname, method Status (line 244) | Status NewRandomAccessFile(const std::string& fname, method Status (line 256) | Status NewWritableFile(const std::string& fname, method Status (line 276) | Status NewAppendableFile(const std::string& fname, method FileExists (line 289) | bool FileExists(const std::string& fname) override { method Status (line 294) | Status GetChildren(const std::string& dir, method EXCLUSIVE_LOCKS_REQUIRED (line 312) | EXCLUSIVE_LOCKS_REQUIRED(mutex_) { method Status (line 321) | Status RemoveFile(const std::string& fname) override { method Status (line 331) | Status CreateDir(const std::string& dirname) override { return Statu... method Status (line 333) | Status RemoveDir(const std::string& dirname) override { return Statu... method Status (line 335) | Status GetFileSize(const std::string& fname, uint64_t* file_size) ov... method Status (line 345) | Status RenameFile(const std::string& src, method Status (line 358) | Status LockFile(const std::string& fname, FileLock** lock) override { method Status (line 363) | Status UnlockFile(FileLock* lock) override { method Status (line 368) | Status GetTestDirectory(std::string* path) override { method Status (line 373) | Status NewLogger(const std::string& fname, Logger** result) override { function Env (line 388) | Env* NewMemEnv(Env* base_env) { return new InMemoryEnv(base_env); } FILE: helpers/memenv/memenv.h function namespace (line 10) | namespace leveldb { FILE: helpers/memenv/memenv_test.cc type leveldb (line 16) | namespace leveldb { class MemEnvTest (line 18) | class MemEnvTest : public testing::Test { method MemEnvTest (line 20) | MemEnvTest() : env_(NewMemEnv(Env::Default())) {} function TEST_F (line 26) | TEST_F(MemEnvTest, Basics) { function TEST_F (line 94) | TEST_F(MemEnvTest, ReadWrite) { function TEST_F (line 137) | TEST_F(MemEnvTest, Locks) { function TEST_F (line 145) | TEST_F(MemEnvTest, Misc) { function TEST_F (line 160) | TEST_F(MemEnvTest, LargeWrite) { function TEST_F (line 193) | TEST_F(MemEnvTest, OverwriteOpenFile) { function TEST_F (line 216) | TEST_F(MemEnvTest, DBTest) { FILE: include/leveldb/c.h type leveldb_t (line 55) | typedef struct leveldb_t leveldb_t; type leveldb_cache_t (line 56) | typedef struct leveldb_cache_t leveldb_cache_t; type leveldb_comparator_t (line 57) | typedef struct leveldb_comparator_t leveldb_comparator_t; type leveldb_env_t (line 58) | typedef struct leveldb_env_t leveldb_env_t; type leveldb_filelock_t (line 59) | typedef struct leveldb_filelock_t leveldb_filelock_t; type leveldb_filterpolicy_t (line 60) | typedef struct leveldb_filterpolicy_t leveldb_filterpolicy_t; type leveldb_iterator_t (line 61) | typedef struct leveldb_iterator_t leveldb_iterator_t; type leveldb_logger_t (line 62) | typedef struct leveldb_logger_t leveldb_logger_t; type leveldb_options_t (line 63) | typedef struct leveldb_options_t leveldb_options_t; type leveldb_randomfile_t (line 64) | typedef struct leveldb_randomfile_t leveldb_randomfile_t; type leveldb_readoptions_t (line 65) | typedef struct leveldb_readoptions_t leveldb_readoptions_t; type leveldb_seqfile_t (line 66) | typedef struct leveldb_seqfile_t leveldb_seqfile_t; type leveldb_snapshot_t (line 67) | typedef struct leveldb_snapshot_t leveldb_snapshot_t; type leveldb_writablefile_t (line 68) | typedef struct leveldb_writablefile_t leveldb_writablefile_t; type leveldb_writebatch_t (line 69) | typedef struct leveldb_writebatch_t leveldb_writebatch_t; type leveldb_writeoptions_t (line 70) | typedef struct leveldb_writeoptions_t leveldb_writeoptions_t; FILE: include/leveldb/cache.h function namespace (line 26) | namespace leveldb { FILE: include/leveldb/comparator.h function namespace (line 12) | namespace leveldb { FILE: include/leveldb/db.h function namespace (line 15) | namespace leveldb { FILE: include/leveldb/dumpfile.h function namespace (line 14) | namespace leveldb { FILE: include/leveldb/env.h function namespace (line 42) | namespace leveldb { FILE: include/leveldb/filter_policy.h function namespace (line 23) | namespace leveldb { FILE: include/leveldb/iterator.h type CleanupNode (line 86) | struct CleanupNode { FILE: include/leveldb/options.h function namespace (line 12) | namespace leveldb { FILE: include/leveldb/slice.h function namespace (line 25) | namespace leveldb { function compare (line 103) | inline int Slice::compare(const Slice& b) const { FILE: include/leveldb/status.h function namespace (line 22) | namespace leveldb { FILE: include/leveldb/table.h function namespace (line 13) | namespace leveldb { FILE: include/leveldb/table_builder.h function namespace (line 22) | namespace leveldb { FILE: include/leveldb/write_batch.h function namespace (line 29) | namespace leveldb { FILE: issues/issue178_test.cc function Key1 (line 19) | std::string Key1(int i) { function Key2 (line 25) | std::string Key2(int i) { return Key1(i) + "_xxx"; } function TEST (line 27) | TEST(Issue178, Test) { FILE: issues/issue200_test.cc type leveldb (line 13) | namespace leveldb { function TEST (line 15) | TEST(Issue200, Test) { FILE: issues/issue320_test.cc type leveldb (line 17) | namespace leveldb { function GenerateRandomNumber (line 22) | int GenerateRandomNumber(int max) { return std::rand() % max; } function CreateRandomString (line 24) | std::string CreateRandomString(int32_t index) { function TEST (line 41) | TEST(Issue320, Test) { FILE: port/port_example.h function namespace (line 15) | namespace leveldb { FILE: port/port_stdcxx.h function namespace (line 45) | namespace leveldb { FILE: table/block.cc type leveldb (line 18) | namespace leveldb { class Block::Iter (line 77) | class Block::Iter : public Iterator { method Compare (line 91) | inline int Compare(const Slice& a, const Slice& b) const { method NextEntryOffset (line 96) | inline uint32_t NextEntryOffset() const { method GetRestartPoint (line 100) | uint32_t GetRestartPoint(uint32_t index) { method SeekToRestartPoint (line 105) | void SeekToRestartPoint(uint32_t index) { method Iter (line 116) | Iter(const Comparator* comparator, const char* data, uint32_t restarts, method Valid (line 127) | bool Valid() const override { return current_ < restarts_; } method Status (line 128) | Status status() const override { return status_; } method Slice (line 129) | Slice key() const override { method Slice (line 133) | Slice value() const override { method Next (line 138) | void Next() override { method Prev (line 143) | void Prev() override { method Seek (line 164) | void Seek(const Slice& target) override { method SeekToFirst (line 229) | void SeekToFirst() override { method SeekToLast (line 234) | void SeekToLast() override { method CorruptionError (line 242) | void CorruptionError() { method ParseNextKey (line 250) | bool ParseNextKey() { function Iterator (line 280) | Iterator* Block::NewIterator(const Comparator* comparator) { FILE: table/block.h function namespace (line 13) | namespace leveldb { FILE: table/block_builder.cc type leveldb (line 38) | namespace leveldb { function Slice (line 61) | Slice BlockBuilder::Finish() { FILE: table/block_builder.h function namespace (line 13) | namespace leveldb { FILE: table/filter_block.cc type leveldb (line 10) | namespace leveldb { function Slice (line 35) | Slice FilterBlockBuilder::Finish() { FILE: table/filter_block.h function namespace (line 20) | namespace leveldb { FILE: table/filter_block_test.cc type leveldb (line 14) | namespace leveldb { class TestHashFilter (line 17) | class TestHashFilter : public FilterPolicy { method CreateFilter (line 21) | void CreateFilter(const Slice* keys, int n, std::string* dst) const ... method KeyMayMatch (line 28) | bool KeyMayMatch(const Slice& key, const Slice& filter) const overri... class FilterBlockTest (line 39) | class FilterBlockTest : public testing::Test { function TEST_F (line 44) | TEST_F(FilterBlockTest, EmptyBuilder) { function TEST_F (line 53) | TEST_F(FilterBlockTest, SingleChunk) { function TEST_F (line 74) | TEST_F(FilterBlockTest, MultiChunk) { FILE: table/format.cc type leveldb (line 14) | namespace leveldb { function Status (line 24) | Status BlockHandle::DecodeFrom(Slice* input) { function Status (line 43) | Status Footer::DecodeFrom(Slice* input) { function Status (line 69) | Status ReadBlock(RandomAccessFile* file, const ReadOptions& options, FILE: table/format.h function namespace (line 15) | namespace leveldb { FILE: table/iterator.cc type leveldb (line 7) | namespace leveldb { class EmptyIterator (line 43) | class EmptyIterator : public Iterator { method EmptyIterator (line 45) | EmptyIterator(const Status& s) : status_(s) {} method Valid (line 48) | bool Valid() const override { return false; } method Seek (line 49) | void Seek(const Slice& target) override {} method SeekToFirst (line 50) | void SeekToFirst() override {} method SeekToLast (line 51) | void SeekToLast() override {} method Next (line 52) | void Next() override { assert(false); } method Prev (line 53) | void Prev() override { assert(false); } method Slice (line 54) | Slice key() const override { method Slice (line 58) | Slice value() const override { method Status (line 62) | Status status() const override { return status_; } function Iterator (line 70) | Iterator* NewEmptyIterator() { return new EmptyIterator(Status::OK()); } function Iterator (line 72) | Iterator* NewErrorIterator(const Status& status) { FILE: table/iterator_wrapper.h function namespace (line 11) | namespace leveldb { FILE: table/merger.cc type leveldb (line 11) | namespace leveldb { class MergingIterator (line 14) | class MergingIterator : public Iterator { method MergingIterator (line 16) | MergingIterator(const Comparator* comparator, Iterator** children, i... method Valid (line 29) | bool Valid() const override { return (current_ != nullptr); } method SeekToFirst (line 31) | void SeekToFirst() override { method SeekToLast (line 39) | void SeekToLast() override { method Seek (line 47) | void Seek(const Slice& target) override { method Next (line 55) | void Next() override { method Prev (line 81) | void Prev() override { method Slice (line 110) | Slice key() const override { method Slice (line 115) | Slice value() const override { method Status (line 120) | Status status() const override { type Direction (line 133) | enum Direction { kForward, kReverse } function Iterator (line 179) | Iterator* NewMergingIterator(const Comparator* comparator, Iterator** ... FILE: table/merger.h function namespace (line 8) | namespace leveldb { FILE: table/table.cc type leveldb (line 18) | namespace leveldb { type Table::Rep (line 20) | struct Table::Rep { function Status (line 38) | Status Table::Open(const Options& options, RandomAccessFile* file, function DeleteBlock (line 136) | static void DeleteBlock(void* arg, void* ignored) { function DeleteCachedBlock (line 140) | static void DeleteCachedBlock(const Slice& key, void* value) { function ReleaseBlock (line 145) | static void ReleaseBlock(void* arg, void* h) { function Iterator (line 153) | Iterator* Table::BlockReader(void* arg, const ReadOptions& options, function Iterator (line 208) | Iterator* Table::NewIterator(const ReadOptions& options) const { function Status (line 214) | Status Table::InternalGet(const ReadOptions& options, const Slice& k, ... FILE: table/table_builder.cc type leveldb (line 19) | namespace leveldb { type TableBuilder::Rep (line 21) | struct TableBuilder::Rep { method Rep (line 22) | Rep(const Options& opt, WritableFile* f) function Status (line 78) | Status TableBuilder::ChangeOptions(const Options& options) { function Status (line 211) | Status TableBuilder::status() const { return rep_->status; } function Status (line 213) | Status TableBuilder::Finish() { FILE: table/table_test.cc type leveldb (line 25) | namespace leveldb { function Reverse (line 29) | static std::string Reverse(const Slice& key) { class ReverseKeyComparator (line 40) | class ReverseKeyComparator : public Comparator { method Compare (line 46) | int Compare(const Slice& a, const Slice& b) const override { method FindShortestSeparator (line 50) | void FindShortestSeparator(std::string* start, method FindShortSuccessor (line 58) | void FindShortSuccessor(std::string* key) const override { function Increment (line 67) | static void Increment(const Comparator* cmp, std::string* key) { type STLLessThan (line 80) | struct STLLessThan { method STLLessThan (line 83) | STLLessThan() : cmp(BytewiseComparator()) {} method STLLessThan (line 84) | STLLessThan(const Comparator* c) : cmp(c) {} class StringSink (line 91) | class StringSink : public WritableFile { method Status (line 97) | Status Close() override { return Status::OK(); } method Status (line 98) | Status Flush() override { return Status::OK(); } method Status (line 99) | Status Sync() override { return Status::OK(); } method Status (line 101) | Status Append(const Slice& data) override { class StringSource (line 110) | class StringSource : public RandomAccessFile { method StringSource (line 112) | StringSource(const Slice& contents) method Size (line 117) | uint64_t Size() const { return contents_.size(); } method Status (line 119) | Status Read(uint64_t offset, size_t n, Slice* result, class Constructor (line 140) | class Constructor { method Constructor (line 142) | explicit Constructor(const Comparator* cmp) : data_(STLLessThan(cmp)... method Add (line 145) | void Add(const std::string& key, const Slice& value) { method Finish (line 152) | void Finish(const Options& options, std::vector* keys, method KVMap (line 169) | const KVMap& data() const { return data_; } method DB (line 171) | virtual DB* db() const { return nullptr; } class BlockConstructor (line 177) | class BlockConstructor : public Constructor { method BlockConstructor (line 179) | explicit BlockConstructor(const Comparator* cmp) method Status (line 182) | Status FinishImpl(const Options& options, const KVMap& data) override { method Iterator (line 199) | Iterator* NewIterator() const override { class TableConstructor (line 211) | class TableConstructor : public Constructor { method TableConstructor (line 213) | TableConstructor(const Comparator* cmp) method Status (line 216) | Status FinishImpl(const Options& options, const KVMap& data) override { method Iterator (line 237) | Iterator* NewIterator() const override { method ApproximateOffsetOf (line 241) | uint64_t ApproximateOffsetOf(const Slice& key) const { method Reset (line 246) | void Reset() { class KeyConvertingIterator (line 260) | class KeyConvertingIterator : public Iterator { method KeyConvertingIterator (line 262) | explicit KeyConvertingIterator(Iterator* iter) : iter_(iter) {} method KeyConvertingIterator (line 264) | KeyConvertingIterator(const KeyConvertingIterator&) = delete; method KeyConvertingIterator (line 265) | KeyConvertingIterator& operator=(const KeyConvertingIterator&) = del... method Valid (line 269) | bool Valid() const override { return iter_->Valid(); } method Seek (line 270) | void Seek(const Slice& target) override { method SeekToFirst (line 276) | void SeekToFirst() override { iter_->SeekToFirst(); } method SeekToLast (line 277) | void SeekToLast() override { iter_->SeekToLast(); } method Next (line 278) | void Next() override { iter_->Next(); } method Prev (line 279) | void Prev() override { iter_->Prev(); } method Slice (line 281) | Slice key() const override { method Slice (line 291) | Slice value() const override { return iter_->value(); } method Status (line 292) | Status status() const override { class MemTableConstructor (line 301) | class MemTableConstructor : public Constructor { method MemTableConstructor (line 303) | explicit MemTableConstructor(const Comparator* cmp) method Status (line 309) | Status FinishImpl(const Options& options, const KVMap& data) override { method Iterator (line 320) | Iterator* NewIterator() const override { class DBConstructor (line 329) | class DBConstructor : public Constructor { method DBConstructor (line 331) | explicit DBConstructor(const Comparator* cmp) method Status (line 337) | Status FinishImpl(const Options& options, const KVMap& data) override { method Iterator (line 348) | Iterator* NewIterator() const override { method DB (line 352) | DB* db() const override { return db_; } method NewDB (line 355) | void NewDB() { type TestType (line 374) | enum TestType { TABLE_TEST, BLOCK_TEST, MEMTABLE_TEST, DB_TEST } type TestArgs (line 376) | struct TestArgs { class Harness (line 407) | class Harness : public testing::Test { method Harness (line 409) | Harness() : constructor_(nullptr) {} method Init (line 411) | void Init(const TestArgs& args) { method Add (line 441) | void Add(const std::string& key, const std::string& value) { method Test (line 445) | void Test(Random* rnd) { method TestForwardScan (line 455) | void TestForwardScan(const std::vector& keys, method TestBackwardScan (line 469) | void TestBackwardScan(const std::vector& keys, method TestRandomAccess (line 483) | void TestRandomAccess(Random* rnd, const std::vector& k... method ToString (line 552) | std::string ToString(const KVMap& data, const KVMap::const_iterator&... method ToString (line 560) | std::string ToString(const KVMap& data, method ToString (line 569) | std::string ToString(const Iterator* it) { method PickRandomKey (line 577) | std::string PickRandomKey(Random* rnd, const std::vectordb(); } function TEST_F (line 613) | TEST_F(Harness, Empty) { function TEST_F (line 624) | TEST_F(Harness, ZeroRestartPointsInBlock) { function TEST_F (line 643) | TEST_F(Harness, SimpleEmptyKey) { function TEST_F (line 652) | TEST_F(Harness, SimpleSingle) { function TEST_F (line 661) | TEST_F(Harness, SimpleMulti) { function TEST_F (line 672) | TEST_F(Harness, SimpleSpecialKey) { function TEST_F (line 681) | TEST_F(Harness, Randomized) { function TEST_F (line 701) | TEST_F(Harness, RandomizedLongDB) { function TEST (line 725) | TEST(MemTableTest, Simple) { function Between (line 749) | static bool Between(uint64_t val, uint64_t low, uint64_t high) { function TEST (line 759) | TEST(TableTest, ApproximateOffsetOfPlain) { function CompressionSupported (line 788) | static bool CompressionSupported(CompressionType type) { class CompressionTableTest (line 799) | class CompressionTableTest function TEST_P (line 806) | TEST_P(CompressionTableTest, ApproximateOffsetOfCompressed) { FILE: table/two_level_iterator.cc type leveldb (line 12) | namespace leveldb { class TwoLevelIterator (line 18) | class TwoLevelIterator : public Iterator { method Valid (line 31) | bool Valid() const override { return data_iter_.Valid(); } method Slice (line 32) | Slice key() const override { method Slice (line 36) | Slice value() const override { method Status (line 40) | Status status() const override { method SaveError (line 52) | void SaveError(const Status& s) { function Iterator (line 165) | Iterator* NewTwoLevelIterator(Iterator* index_iter, FILE: table/two_level_iterator.h function namespace (line 10) | namespace leveldb { FILE: util/arena.cc type leveldb (line 7) | namespace leveldb { FILE: util/arena.h function namespace (line 14) | namespace leveldb { FILE: util/arena_test.cc type leveldb (line 10) | namespace leveldb { function TEST (line 12) | TEST(ArenaTest, Empty) { Arena arena; } function TEST (line 14) | TEST(ArenaTest, Simple) { FILE: util/bloom.cc type leveldb (line 10) | namespace leveldb { function BloomHash (line 13) | static uint32_t BloomHash(const Slice& key) { class BloomFilterPolicy (line 17) | class BloomFilterPolicy : public FilterPolicy { method BloomFilterPolicy (line 19) | explicit BloomFilterPolicy(int bits_per_key) : bits_per_key_(bits_pe... method CreateFilter (line 28) | void CreateFilter(const Slice* keys, int n, std::string* dst) const ... method KeyMayMatch (line 56) | bool KeyMayMatch(const Slice& key, const Slice& bloom_filter) const ... function FilterPolicy (line 88) | const FilterPolicy* NewBloomFilterPolicy(int bits_per_key) { FILE: util/bloom_test.cc type leveldb (line 11) | namespace leveldb { function Slice (line 15) | static Slice Key(int i, char* buffer) { class BloomTest (line 20) | class BloomTest : public testing::Test { method BloomTest (line 22) | BloomTest() : policy_(NewBloomFilterPolicy(10)) {} method Reset (line 26) | void Reset() { method Add (line 31) | void Add(const Slice& s) { keys_.push_back(s.ToString()); } method Build (line 33) | void Build() { method FilterSize (line 45) | size_t FilterSize() const { return filter_.size(); } method DumpFilter (line 47) | void DumpFilter() { method Matches (line 58) | bool Matches(const Slice& s) { method FalsePositiveRate (line 65) | double FalsePositiveRate() { function TEST_F (line 82) | TEST_F(BloomTest, EmptyFilter) { function TEST_F (line 87) | TEST_F(BloomTest, Small) { function NextLength (line 96) | static int NextLength(int length) { function TEST_F (line 109) | TEST_F(BloomTest, VaryingLengths) { FILE: util/cache.cc type leveldb (line 16) | namespace leveldb { type LRUHandle (line 43) | struct LRUHandle { method Slice (line 56) | Slice key() const { class HandleTable (line 70) | class HandleTable { method HandleTable (line 72) | HandleTable() : length_(0), elems_(0), list_(nullptr) { Resize(); } method LRUHandle (line 75) | LRUHandle* Lookup(const Slice& key, uint32_t hash) { method LRUHandle (line 79) | LRUHandle* Insert(LRUHandle* h) { method LRUHandle (line 95) | LRUHandle* Remove(const Slice& key, uint32_t hash) { method LRUHandle (line 115) | LRUHandle** FindPointer(const Slice& key, uint32_t hash) { method Resize (line 123) | void Resize() { class LRUCache (line 151) | class LRUCache { method SetCapacity (line 157) | void SetCapacity(size_t capacity) { capacity_ = capacity; } method TotalCharge (line 167) | size_t TotalCharge() const { class ShardedLRUCache (line 339) | class ShardedLRUCache : public Cache { method HashSlice (line 345) | static inline uint32_t HashSlice(const Slice& s) { method Shard (line 349) | static uint32_t Shard(uint32_t hash) { return hash >> (32 - kNumShar... method ShardedLRUCache (line 352) | explicit ShardedLRUCache(size_t capacity) : last_id_(0) { method Handle (line 359) | Handle* Insert(const Slice& key, void* value, size_t charge, method Handle (line 364) | Handle* Lookup(const Slice& key) override { method Release (line 368) | void Release(Handle* handle) override { method Erase (line 372) | void Erase(const Slice& key) override { method NewId (line 379) | uint64_t NewId() override { method Prune (line 383) | void Prune() override { method TotalCharge (line 388) | size_t TotalCharge() const override { function Cache (line 399) | Cache* NewLRUCache(size_t capacity) { return new ShardedLRUCache(capac... FILE: util/cache_test.cc type leveldb (line 12) | namespace leveldb { function EncodeKey (line 15) | static std::string EncodeKey(int k) { function DecodeKey (line 20) | static int DecodeKey(const Slice& k) { function DecodeValue (line 25) | static int DecodeValue(void* v) { return reinterpret_cast(v... class CacheTest (line 27) | class CacheTest : public testing::Test { method Deleter (line 29) | static void Deleter(const Slice& key, void* v) { method CacheTest (line 39) | CacheTest() : cache_(NewLRUCache(kCacheSize)) { current_ = this; } method Lookup (line 43) | int Lookup(int key) { method Insert (line 52) | void Insert(int key, int value, int charge = 1) { method Erase (line 62) | void Erase(int key) { cache_->Erase(EncodeKey(key)); } function TEST_F (line 67) | TEST_F(CacheTest, HitAndMiss) { function TEST_F (line 90) | TEST_F(CacheTest, Erase) { function TEST_F (line 109) | TEST_F(CacheTest, EntriesArePinned) { function TEST_F (line 134) | TEST_F(CacheTest, EvictionPolicy) { function TEST_F (line 153) | TEST_F(CacheTest, UseExceedsCacheSize) { function TEST_F (line 170) | TEST_F(CacheTest, HeavyEntries) { function TEST_F (line 197) | TEST_F(CacheTest, NewId) { function TEST_F (line 203) | TEST_F(CacheTest, Prune) { function TEST_F (line 216) | TEST_F(CacheTest, ZeroSizeCache) { FILE: util/coding.cc type leveldb (line 7) | namespace leveldb { function PutFixed32 (line 9) | void PutFixed32(std::string* dst, uint32_t value) { function PutFixed64 (line 15) | void PutFixed64(std::string* dst, uint64_t value) { function PutVarint32 (line 49) | void PutVarint32(std::string* dst, uint32_t v) { function PutVarint64 (line 66) | void PutVarint64(std::string* dst, uint64_t v) { function PutLengthPrefixedSlice (line 72) | void PutLengthPrefixedSlice(std::string* dst, const Slice& value) { function VarintLength (line 77) | int VarintLength(uint64_t v) { function GetVarint32 (line 104) | bool GetVarint32(Slice* input, uint32_t* value) { function GetVarint64 (line 133) | bool GetVarint64(Slice* input, uint64_t* value) { function GetLengthPrefixedSlice (line 145) | bool GetLengthPrefixedSlice(Slice* input, Slice* result) { FILE: util/coding.h function namespace (line 20) | namespace leveldb { FILE: util/coding_test.cc type leveldb (line 11) | namespace leveldb { function TEST (line 13) | TEST(Coding, Fixed32) { function TEST (line 27) | TEST(Coding, Fixed64) { function TEST (line 55) | TEST(Coding, EncodingOutput) { function TEST (line 77) | TEST(Coding, Varint32) { function TEST (line 98) | TEST(Coding, Varint64) { function TEST (line 133) | TEST(Coding, Varint32Overflow) { function TEST (line 140) | TEST(Coding, Varint32Truncation) { function TEST (line 153) | TEST(Coding, Varint64Overflow) { function TEST (line 160) | TEST(Coding, Varint64Truncation) { function TEST (line 173) | TEST(Coding, Strings) { FILE: util/comparator.cc type leveldb (line 16) | namespace leveldb { class BytewiseComparatorImpl (line 21) | class BytewiseComparatorImpl : public Comparator { method BytewiseComparatorImpl (line 23) | BytewiseComparatorImpl() = default; method Compare (line 27) | int Compare(const Slice& a, const Slice& b) const override { method FindShortestSeparator (line 31) | void FindShortestSeparator(std::string* start, method FindShortSuccessor (line 54) | void FindShortSuccessor(std::string* key) const override { function Comparator (line 70) | const Comparator* BytewiseComparator() { FILE: util/crc32c.cc type leveldb (line 15) | namespace leveldb { type crc32c (line 16) | namespace crc32c { function ReadUint32LE (line 249) | inline uint32_t ReadUint32LE(const uint8_t* buffer) { function CanAccelerateCRC32C (line 267) | static bool CanAccelerateCRC32C() { function Extend (line 276) | uint32_t Extend(uint32_t crc, const char* data, size_t n) { FILE: util/crc32c.h function namespace (line 11) | namespace leveldb { FILE: util/crc32c_test.cc type leveldb (line 9) | namespace leveldb { type crc32c (line 10) | namespace crc32c { function TEST (line 12) | TEST(CRC, StandardResults) { function TEST (line 41) | TEST(CRC, Values) { ASSERT_NE(Value("a", 1), Value("foo", 3)); } function TEST (line 43) | TEST(CRC, Extend) { function TEST (line 47) | TEST(CRC, Mask) { FILE: util/env.cc type leveldb (line 15) | namespace leveldb { function Status (line 21) | Status Env::NewAppendableFile(const std::string& fname, WritableFile**... function Status (line 25) | Status Env::RemoveDir(const std::string& dirname) { return DeleteDir(d... function Status (line 26) | Status Env::DeleteDir(const std::string& dirname) { return RemoveDir(d... function Status (line 28) | Status Env::RemoveFile(const std::string& fname) { return DeleteFile(f... function Status (line 29) | Status Env::DeleteFile(const std::string& fname) { return RemoveFile(f... function Log (line 41) | void Log(Logger* info_log, const char* format, ...) { function Status (line 50) | static Status DoWriteStringToFile(Env* env, const Slice& data, function Status (line 71) | Status WriteStringToFile(Env* env, const Slice& data, function Status (line 76) | Status WriteStringToFileSync(Env* env, const Slice& data, function Status (line 81) | Status ReadFileToString(Env* env, const std::string& fname, std::strin... FILE: util/env_posix.cc function Status (line 61) | Status PosixError(const std::string& context, int error_number) { class Limiter (line 73) | class Limiter { method Limiter (line 85) | Limiter(const Limiter&) = delete; method Limiter (line 86) | Limiter operator=(const Limiter&) = delete; method Acquire (line 90) | bool Acquire() { method Release (line 109) | void Release() { class PosixSequentialFile (line 136) | class PosixSequentialFile final : public SequentialFile { method PosixSequentialFile (line 138) | PosixSequentialFile(std::string filename, int fd) method Status (line 142) | Status Read(size_t n, Slice* result, char* scratch) override { method Status (line 159) | Status Skip(uint64_t n) override { class PosixRandomAccessFile (line 176) | class PosixRandomAccessFile final : public RandomAccessFile { method PosixRandomAccessFile (line 180) | PosixRandomAccessFile(std::string filename, int fd, Limiter* fd_limi... method Status (line 199) | Status Read(uint64_t offset, size_t n, Slice* result, class PosixMmapReadableFile (line 238) | class PosixMmapReadableFile final : public RandomAccessFile { method PosixMmapReadableFile (line 247) | PosixMmapReadableFile(std::string filename, char* mmap_base, size_t ... method Status (line 259) | Status Read(uint64_t offset, size_t n, Slice* result, class PosixWritableFile (line 277) | class PosixWritableFile final : public WritableFile { method PosixWritableFile (line 279) | PosixWritableFile(std::string filename, int fd) method Status (line 293) | Status Append(const Slice& data) override { method Status (line 322) | Status Close() override { method Status (line 332) | Status Flush() override { return FlushBuffer(); } method Status (line 334) | Status Sync() override { method Status (line 354) | Status FlushBuffer() { method Status (line 360) | Status WriteUnbuffered(const char* data, size_t size) { method Status (line 375) | Status SyncDirIfManifest() { method Status (line 397) | static Status SyncFd(int fd, const std::string& fd_path) { method Dirname (line 423) | static std::string Dirname(const std::string& filename) { method Slice (line 439) | static Slice Basename(const std::string& filename) { method IsManifest (line 453) | static bool IsManifest(const std::string& filename) { method LockOrUnlock (line 467) | int LockOrUnlock(int fd, bool lock) { class PosixFileLock (line 479) | class PosixFileLock : public FileLock { method PosixFileLock (line 481) | PosixFileLock(int fd, std::string filename) method fd (line 484) | int fd() const { return fd_; } class PosixLockTable (line 499) | class PosixLockTable { method LOCKS_EXCLUDED (line 501) | LOCKS_EXCLUDED(mu_) { method LOCKS_EXCLUDED (line 507) | LOCKS_EXCLUDED(mu_) { class PosixEnv (line 518) | class PosixEnv : public Env { method Status (line 528) | Status NewSequentialFile(const std::string& filename, method Status (line 540) | Status NewRandomAccessFile(const std::string& filename, method Status (line 573) | Status NewWritableFile(const std::string& filename, method Status (line 586) | Status NewAppendableFile(const std::string& filename, method FileExists (line 599) | bool FileExists(const std::string& filename) override { method Status (line 603) | Status GetChildren(const std::string& directory_path, method Status (line 618) | Status RemoveFile(const std::string& filename) override { method Status (line 625) | Status CreateDir(const std::string& dirname) override { method Status (line 632) | Status RemoveDir(const std::string& dirname) override { method Status (line 639) | Status GetFileSize(const std::string& filename, uint64_t* size) over... method Status (line 649) | Status RenameFile(const std::string& from, const std::string& to) ov... method Status (line 656) | Status LockFile(const std::string& filename, FileLock** lock) overri... method Status (line 680) | Status UnlockFile(FileLock* lock) override { method StartThread (line 694) | void StartThread(void (*thread_main)(void* thread_main_arg), method Status (line 700) | Status GetTestDirectory(std::string* result) override { method Status (line 717) | Status NewLogger(const std::string& filename, Logger** result) overr... method NowMicros (line 736) | uint64_t NowMicros() override { method SleepForMicroseconds (line 743) | void SleepForMicroseconds(int micros) override { method BackgroundThreadEntryPoint (line 750) | static void BackgroundThreadEntryPoint(PosixEnv* env) { type BackgroundWorkItem (line 760) | struct BackgroundWorkItem { method BackgroundWorkItem (line 761) | explicit BackgroundWorkItem(void (*function)(void* arg), void* arg) method MaxMmaps (line 781) | int MaxMmaps() { return g_mmap_limit; } method MaxOpenFiles (line 784) | int MaxOpenFiles() { method namespace (line 854) | namespace { method Env (line 924) | Env* Env::Default() { FILE: util/env_posix_test.cc function TestCloseOnExecHelperMain (line 59) | int TestCloseOnExecHelperMain(char* pid_arg) { function GetMaxFileDescriptor (line 79) | void GetMaxFileDescriptor(int* result_fd) { function GetOpenFileDescriptors (line 89) | void GetOpenFileDescriptors(std::unordered_set* open_fds) { function GetNewlyOpenedFileDescriptor (line 113) | void GetNewlyOpenedFileDescriptor( function CheckCloseOnExecDoesNotLeakFDs (line 128) | void CheckCloseOnExecDoesNotLeakFDs( type leveldb (line 167) | namespace leveldb { class EnvPosixTest (line 172) | class EnvPosixTest : public testing::Test { method SetFileLimits (line 174) | static void SetFileLimits(int read_only_file_limit, int mmap_limit) { method EnvPosixTest (line 179) | EnvPosixTest() : env_(Env::Default()) {} function TEST_F (line 184) | TEST_F(EnvPosixTest, TestOpenOnRead) { function TEST_F (line 217) | TEST_F(EnvPosixTest, TestCloseOnExecSequentialFile) { function TEST_F (line 234) | TEST_F(EnvPosixTest, TestCloseOnExecRandomAccessFile) { function TEST_F (line 262) | TEST_F(EnvPosixTest, TestCloseOnExecWritableFile) { function TEST_F (line 279) | TEST_F(EnvPosixTest, TestCloseOnExecAppendableFile) { function TEST_F (line 296) | TEST_F(EnvPosixTest, TestCloseOnExecLockFile) { function TEST_F (line 313) | TEST_F(EnvPosixTest, TestCloseOnExecLogger) { function main (line 334) | int main(int argc, char** argv) { FILE: util/env_posix_test_helper.h function namespace (line 8) | namespace leveldb { FILE: util/env_test.cc type leveldb (line 15) | namespace leveldb { class EnvTest (line 17) | class EnvTest : public testing::Test { method EnvTest (line 19) | EnvTest() : env_(Env::Default()) {} function TEST_F (line 24) | TEST_F(EnvTest, ReadWrite) { function TEST_F (line 71) | TEST_F(EnvTest, RunImmediately) { function TEST_F (line 95) | TEST_F(EnvTest, RunMany) { type State (line 140) | struct State { method State (line 147) | State(int val, int num_running) : val(val), num_running(num_running) {} function ThreadBody (line 150) | static void ThreadBody(void* arg) { function TEST_F (line 159) | TEST_F(EnvTest, StartThread) { function TEST_F (line 172) | TEST_F(EnvTest, TestOpenNonExistentFile) { function TEST_F (line 200) | TEST_F(EnvTest, ReopenWritableFile) { function TEST_F (line 224) | TEST_F(EnvTest, ReopenAppendableFile) { FILE: util/env_windows.cc function GetWindowsErrorMessage (line 48) | std::string GetWindowsErrorMessage(DWORD error_code) { function Status (line 65) | Status WindowsError(const std::string& context, DWORD error_code) { class ScopedHandle (line 71) | class ScopedHandle { method ScopedHandle (line 73) | ScopedHandle(HANDLE handle) : handle_(handle) {} method ScopedHandle (line 74) | ScopedHandle(const ScopedHandle&) = delete; method ScopedHandle (line 75) | ScopedHandle(ScopedHandle&& other) noexcept : handle_(other.Release()) {} method ScopedHandle (line 78) | ScopedHandle& operator=(const ScopedHandle&) = delete; method ScopedHandle (line 80) | ScopedHandle& operator=(ScopedHandle&& rhs) noexcept { method Close (line 85) | bool Close() { method is_valid (line 94) | bool is_valid() const { method HANDLE (line 98) | HANDLE get() const { return handle_; } method HANDLE (line 100) | HANDLE Release() { class Limiter (line 114) | class Limiter { method Limiter (line 126) | Limiter(const Limiter&) = delete; method Limiter (line 127) | Limiter operator=(const Limiter&) = delete; method Acquire (line 131) | bool Acquire() { method Release (line 143) | void Release() { class WindowsSequentialFile (line 166) | class WindowsSequentialFile : public SequentialFile { method WindowsSequentialFile (line 168) | WindowsSequentialFile(std::string filename, ScopedHandle handle) method Status (line 172) | Status Read(size_t n, Slice* result, char* scratch) override { method Status (line 187) | Status Skip(uint64_t n) override { class WindowsRandomAccessFile (line 201) | class WindowsRandomAccessFile : public RandomAccessFile { method WindowsRandomAccessFile (line 203) | WindowsRandomAccessFile(std::string filename, ScopedHandle handle) method Status (line 208) | Status Read(uint64_t offset, size_t n, Slice* result, class WindowsMmapReadableFile (line 233) | class WindowsMmapReadableFile : public RandomAccessFile { method WindowsMmapReadableFile (line 236) | WindowsMmapReadableFile(std::string filename, char* mmap_base, size_... method Status (line 248) | Status Read(uint64_t offset, size_t n, Slice* result, class WindowsWritableFile (line 266) | class WindowsWritableFile : public WritableFile { method WindowsWritableFile (line 268) | WindowsWritableFile(std::string filename, ScopedHandle handle) method Status (line 273) | Status Append(const Slice& data) override { method Status (line 302) | Status Close() override { method Status (line 310) | Status Flush() override { return FlushBuffer(); } method Status (line 312) | Status Sync() override { method Status (line 329) | Status FlushBuffer() { method Status (line 335) | Status WriteUnbuffered(const char* data, size_t size) { method LockOrUnlock (line 356) | bool LockOrUnlock(HANDLE handle, bool lock) { class WindowsFileLock (line 370) | class WindowsFileLock : public FileLock { method WindowsFileLock (line 372) | WindowsFileLock(ScopedHandle handle, std::string filename) method ScopedHandle (line 375) | const ScopedHandle& handle() const { return handle_; } class WindowsEnv (line 383) | class WindowsEnv : public Env { method Status (line 393) | Status NewSequentialFile(const std::string& filename, method Status (line 410) | Status NewRandomAccessFile(const std::string& filename, method Status (line 457) | Status NewWritableFile(const std::string& filename, method Status (line 474) | Status NewAppendableFile(const std::string& filename, method FileExists (line 491) | bool FileExists(const std::string& filename) override { method Status (line 495) | Status GetChildren(const std::string& directory_path, method Status (line 524) | Status RemoveFile(const std::string& filename) override { method Status (line 531) | Status CreateDir(const std::string& dirname) override { method Status (line 538) | Status RemoveDir(const std::string& dirname) override { method Status (line 545) | Status GetFileSize(const std::string& filename, uint64_t* size) over... method Status (line 558) | Status RenameFile(const std::string& from, const std::string& to) ov... method Status (line 587) | Status LockFile(const std::string& filename, FileLock** lock) overri... method Status (line 604) | Status UnlockFile(FileLock* lock) override { method StartThread (line 618) | void StartThread(void (*thread_main)(void* thread_main_arg), method Status (line 624) | Status GetTestDirectory(std::string* result) override { method Status (line 644) | Status NewLogger(const std::string& filename, Logger** result) overr... method NowMicros (line 655) | uint64_t NowMicros() override { method SleepForMicroseconds (line 668) | void SleepForMicroseconds(int micros) override { method BackgroundThreadEntryPoint (line 675) | static void BackgroundThreadEntryPoint(WindowsEnv* env) { type BackgroundWorkItem (line 685) | struct BackgroundWorkItem { method BackgroundWorkItem (line 686) | explicit BackgroundWorkItem(void (*function)(void* arg), void* arg) method MaxMmaps (line 704) | int MaxMmaps() { return g_mmap_limit; } class SingletonEnv (line 764) | class SingletonEnv { method SingletonEnv (line 766) | SingletonEnv() { method SingletonEnv (line 782) | SingletonEnv(const SingletonEnv&) = delete; method SingletonEnv (line 783) | SingletonEnv& operator=(const SingletonEnv&) = delete; method Env (line 785) | Env* env() { return reinterpret_cast(&env_storage_); } method AssertEnvNotInitialized (line 787) | static void AssertEnvNotInitialized() { method Env (line 814) | Env* Env::Default() { FILE: util/env_windows_test.cc type leveldb (line 11) | namespace leveldb { class EnvWindowsTest (line 15) | class EnvWindowsTest : public testing::Test { method SetFileLimits (line 17) | static void SetFileLimits(int mmap_limit) { method EnvWindowsTest (line 21) | EnvWindowsTest() : env_(Env::Default()) {} function TEST_F (line 26) | TEST_F(EnvWindowsTest, TestOpenOnRead) { function main (line 60) | int main(int argc, char** argv) { FILE: util/env_windows_test_helper.h function namespace (line 8) | namespace leveldb { FILE: util/filter_policy.cc type leveldb (line 7) | namespace leveldb { FILE: util/hash.cc type leveldb (line 20) | namespace leveldb { function Hash (line 22) | uint32_t Hash(const char* data, size_t n, uint32_t seed) { FILE: util/hash.h function namespace (line 13) | namespace leveldb { FILE: util/hash_test.cc type leveldb (line 9) | namespace leveldb { function TEST (line 11) | TEST(HASH, SignedUnsignedIssue) { FILE: util/histogram.cc type leveldb (line 12) | namespace leveldb { FILE: util/histogram.h function namespace (line 10) | namespace leveldb { FILE: util/logging.cc type leveldb (line 15) | namespace leveldb { function AppendNumberTo (line 17) | void AppendNumberTo(std::string* str, uint64_t num) { function AppendEscapedStringTo (line 23) | void AppendEscapedStringTo(std::string* str, const Slice& value) { function NumberToString (line 37) | std::string NumberToString(uint64_t num) { function EscapeString (line 43) | std::string EscapeString(const Slice& value) { function ConsumeDecimalNumber (line 49) | bool ConsumeDecimalNumber(Slice* in, uint64_t* val) { FILE: util/logging.h function namespace (line 17) | namespace leveldb { FILE: util/logging_test.cc type leveldb (line 13) | namespace leveldb { function TEST (line 15) | TEST(Logging, NumberToString) { function ConsumeDecimalNumberRoundtripTest (line 40) | void ConsumeDecimalNumberRoundtripTest(uint64_t number, function TEST (line 53) | TEST(Logging, ConsumeDecimalNumberRoundtrip) { function TEST (line 75) | TEST(Logging, ConsumeDecimalNumberRoundtripWithPadding) { function ConsumeDecimalNumberOverflowTest (line 93) | void ConsumeDecimalNumberOverflowTest(const std::string& input_string) { function TEST (line 100) | TEST(Logging, ConsumeDecimalNumberOverflow) { function ConsumeDecimalNumberNoDigitsTest (line 120) | void ConsumeDecimalNumberNoDigitsTest(const std::string& input_string) { function TEST (line 129) | TEST(Logging, ConsumeDecimalNumberNoDigits) { FILE: util/mutexlock.h function namespace (line 11) | namespace leveldb { FILE: util/no_destructor.h function namespace (line 12) | namespace leveldb { FILE: util/no_destructor_test.cc type leveldb (line 13) | namespace leveldb { type DoNotDestruct (line 17) | struct DoNotDestruct { method DoNotDestruct (line 19) | DoNotDestruct(uint32_t a, uint64_t b) : a(a), b(b) {} function TEST (line 32) | TEST(NoDestructorTest, StackInstance) { function TEST (line 38) | TEST(NoDestructorTest, StaticInstance) { FILE: util/options.cc type leveldb (line 10) | namespace leveldb { FILE: util/posix_logger.h function namespace (line 22) | namespace leveldb { FILE: util/random.h function namespace (line 10) | namespace leveldb { FILE: util/status.cc type leveldb (line 11) | namespace leveldb { FILE: util/status_test.cc type leveldb (line 12) | namespace leveldb { function TEST (line 14) | TEST(Status, MoveConstructor) { FILE: util/testutil.cc type leveldb (line 11) | namespace leveldb { type test (line 12) | namespace test { function Slice (line 14) | Slice RandomString(Random* rnd, int len, std::string* dst) { function RandomKey (line 22) | std::string RandomKey(Random* rnd, int len) { function Slice (line 34) | Slice CompressibleString(Random* rnd, double compressed_fraction, si... FILE: util/testutil.h function namespace (line 15) | namespace leveldb { FILE: util/windows_logger.h function namespace (line 19) | namespace leveldb {