Branch data     Line data    Source code

       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                 :         277 :   IteratorWrapper() : iter_(nullptr), valid_(false) {}
      20   [ +  -  +  - ]:         424 :   explicit IteratorWrapper(Iterator* iter) : iter_(nullptr) { Set(iter); }
      21         [ +  + ]:        1125 :   ~IteratorWrapper() { delete iter_; }
      22   [ +  +  +  +  :       15911 :   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                 :        1971 :   void Set(Iterator* iter) {
      27         [ +  + ]:        1971 :     delete iter_;
      28                 :        1971 :     iter_ = iter;
      29         [ +  + ]:        1971 :     if (iter_ == nullptr) {
      30                 :         872 :       valid_ = false;
      31                 :             :     } else {
      32                 :        1099 :       Update();
      33                 :             :     }
      34                 :        1971 :   }
      35                 :             : 
      36                 :             :   // Iterator interface methods
      37   [ +  +  -  -  :       47510 :   bool Valid() const { return valid_; }
          -  -  +  +  +  
           + ][ -  -  +  
             +  -  -  -  
                      - ]
      38                 :       79323 :   Slice key() const {
      39         [ -  + ]:       79323 :     assert(Valid());
      40                 :       79323 :     return key_;
      41                 :             :   }
      42                 :       42014 :   Slice value() const {
      43         [ -  + ]:       42014 :     assert(Valid());
      44                 :       42014 :     return iter_->value();
      45                 :             :   }
      46                 :             :   // Methods below require iter() != nullptr
      47                 :         667 :   Status status() const {
      48         [ -  + ]:         667 :     assert(iter_);
      49                 :         667 :     return iter_->status();
      50                 :             :   }
      51                 :       24127 :   void Next() {
      52         [ -  + ]:       24127 :     assert(iter_);
      53                 :       24127 :     iter_->Next();
      54                 :       24127 :     Update();
      55                 :       24127 :   }
      56                 :           0 :   void Prev() {
      57         [ #  # ]:           0 :     assert(iter_);
      58                 :           0 :     iter_->Prev();
      59                 :           0 :     Update();
      60                 :           0 :   }
      61                 :         576 :   void Seek(const Slice& k) {
      62         [ -  + ]:         576 :     assert(iter_);
      63                 :         576 :     iter_->Seek(k);
      64                 :         576 :     Update();
      65                 :         576 :   }
      66                 :         340 :   void SeekToFirst() {
      67         [ -  + ]:         340 :     assert(iter_);
      68                 :         340 :     iter_->SeekToFirst();
      69                 :         340 :     Update();
      70                 :         340 :   }
      71                 :           0 :   void SeekToLast() {
      72         [ #  # ]:           0 :     assert(iter_);
      73                 :           0 :     iter_->SeekToLast();
      74                 :           0 :     Update();
      75                 :           0 :   }
      76                 :             : 
      77                 :             :  private:
      78                 :       26142 :   void Update() {
      79                 :       26142 :     valid_ = iter_->Valid();
      80         [ +  + ]:       26142 :     if (valid_) {
      81                 :       24179 :       key_ = iter_->key();
      82                 :             :     }
      83                 :       26142 :   }
      84                 :             : 
      85                 :             :   Iterator* iter_;
      86                 :             :   bool valid_;
      87                 :             :   Slice key_;
      88                 :             : };
      89                 :             : 
      90                 :             : }  // namespace leveldb
      91                 :             : 
      92                 :             : #endif  // STORAGE_LEVELDB_TABLE_ITERATOR_WRAPPER_H_