/bitcoin/src/leveldb/table/iterator_wrapper.h

Source
// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file. See the AUTHORS file for names of contributors.

#ifndef STORAGE_LEVELDB_TABLE_ITERATOR_WRAPPER_H_
#define STORAGE_LEVELDB_TABLE_ITERATOR_WRAPPER_H_

#include "leveldb/iterator.h"
#include "leveldb/slice.h"

namespace leveldb {

// A internal wrapper class with an interface similar to Iterator that
// caches the valid() and key() results for an underlying iterator.
// This can help avoid virtual function calls and also gives better
// cache locality.
class IteratorWrapper {
 public:
  IteratorWrapper() : iter_(nullptr), valid_(false) {}
  explicit IteratorWrapper(Iterator* iter) : iter_(nullptr) { Set(iter); }
  ~IteratorWrapper() { delete iter_; }
  Iterator* iter() const { return iter_; }

  // Takes ownership of "iter" and will delete it when destroyed, or
  // when Set() is invoked again.
  void Set(Iterator* iter) {
    delete iter_;
    iter_ = iter;
    if (iter_ == nullptr) {
      valid_ = false;
    } else {
      Update();
    }
  }

  // Iterator interface methods
  bool Valid() const { return valid_; }
  Slice key() const {
    assert(Valid());
    return key_;
  }
  Slice value() const {
    assert(Valid());
    return iter_->value();
  }
  // Methods below require iter() != nullptr
  Status status() const {
    assert(iter_);
    return iter_->status();
  }
  void Next() {
    assert(iter_);
    iter_->Next();
    Update();
  }
  void Prev() {
    assert(iter_);
    iter_->Prev();
    Update();
  }
  void Seek(const Slice& k) {
    assert(iter_);
    iter_->Seek(k);
    Update();
  }
  void SeekToFirst() {
    assert(iter_);
    iter_->SeekToFirst();
    Update();
  }
  void SeekToLast() {
    assert(iter_);
    iter_->SeekToLast();
    Update();
  }

 private:
  void Update() {
    valid_ = iter_->Valid();
    if (valid_) {
      key_ = iter_->key();
    }
  }

  Iterator* iter_;
  bool valid_;
  Slice key_;
};

}  // namespace leveldb

#endif  // STORAGE_LEVELDB_TABLE_ITERATOR_WRAPPER_H_

Line	Count	Source
1		// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
2		// Use of this source code is governed by a BSD-style license that can be
3		// found in the LICENSE file. See the AUTHORS file for names of contributors.
4
5		#ifndef STORAGE_LEVELDB_TABLE_ITERATOR_WRAPPER_H_
6		#define STORAGE_LEVELDB_TABLE_ITERATOR_WRAPPER_H_
7
8		#include "leveldb/iterator.h"
9		#include "leveldb/slice.h"
10
11		namespace leveldb {
12
13		// A internal wrapper class with an interface similar to Iterator that
14		// caches the valid() and key() results for an underlying iterator.
15		// This can help avoid virtual function calls and also gives better
16		// cache locality.
17		class IteratorWrapper {
18		public:
19	14	IteratorWrapper() : iter_(nullptr), valid_(false) {}
20	76	explicit IteratorWrapper(Iterator* iter) : iter_(nullptr) { Set(iter); }
21	90	~IteratorWrapper() { delete iter_; }
22	221	Iterator* iter() const { return iter_; }
23
24		// Takes ownership of "iter" and will delete it when destroyed, or
25		// when Set() is invoked again.
26	132	void Set(Iterator* iter) {
27	132	delete iter_;
28	132	iter_ = iter;
29	132	if (iter_ == nullptr) { Branch (29:9): [True: 66, False: 66]
30	66	valid_ = false;
31	66	} else {
32	66	Update();
33	66	}
34	132	}
35
36		// Iterator interface methods
37	1.04k	bool Valid() const { return valid_; }
38	210	Slice key() const {
39	210	assert(Valid()); Branch (39:5): [True: 210, False: 0]
40	210	return key_;
41	210	}
42	202	Slice value() const {
43	202	assert(Valid()); Branch (43:5): [True: 202, False: 0]
44	202	return iter_->value();
45	202	}
46		// Methods below require iter() != nullptr
47	45	Status status() const {
48	45	assert(iter_); Branch (48:5): [True: 45, False: 0]
49	45	return iter_->status();
50	45	}
51	140	void Next() {
52	140	assert(iter_); Branch (52:5): [True: 140, False: 0]
53	140	iter_->Next();
54	140	Update();
55	140	}
56	0	void Prev() {
57	0	assert(iter_); Branch (57:5): [True: 0, False: 0]
58	0	iter_->Prev();
59	0	Update();
60	0	}
61	42	void Seek(const Slice& k) {
62	42	assert(iter_); Branch (62:5): [True: 42, False: 0]
63	42	iter_->Seek(k);
64	42	Update();
65	42	}
66	0	void SeekToFirst() {
67	0	assert(iter_); Branch (67:5): [True: 0, False: 0]
68	0	iter_->SeekToFirst();
69	0	Update();
70	0	}
71	0	void SeekToLast() {
72	0	assert(iter_); Branch (72:5): [True: 0, False: 0]
73	0	iter_->SeekToLast();
74	0	Update();
75	0	}
76
77		private:
78	248	void Update() {
79	248	valid_ = iter_->Valid();
80	248	if (valid_) { Branch (80:9): [True: 140, False: 108]
81	140	key_ = iter_->key();
82	140	}
83	248	}
84
85		Iterator* iter_;
86		bool valid_;
87		Slice key_;
88		};
89
90		} // namespace leveldb
91
92		#endif // STORAGE_LEVELDB_TABLE_ITERATOR_WRAPPER_H_

Coverage Report

Created: 2025-06-10 13:21