text: // Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
  // This source code is licensed under the BSD-style license found in the
  // LICENSE file in the root directory of this source tree. An additional grant
  // of patent rights can be found in the PATENTS file in the same directory.
  //
  // The following only applies to changes made to this file as part of YugaByte development.
  //
  // Portions Copyright (c) YugaByte, Inc.
  //
  // Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
  // in compliance with the License.  You may obtain a copy of the License at
  //
  // http://www.apache.org/licenses/LICENSE-2.0
  //
  // Unless required by applicable law or agreed to in writing, software distributed under the License
  // is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
  // or implied.  See the License for the specific language governing permissions and limitations
  // under the License.
  //
  
  #ifndef STORAGE_ROCKSDB_INCLUDE_TRANSACTION_LOG_ITERATOR_H_
  #define STORAGE_ROCKSDB_INCLUDE_TRANSACTION_LOG_ITERATOR_H_
  
  #include "yb/rocksdb/status.h"
  #include "yb/rocksdb/types.h"
  #include "yb/rocksdb/write_batch.h"
  #include <memory>
  #include <vector>
  
  namespace rocksdb {
  
  class LogFile;
  typedef std::vector<std::unique_ptr<LogFile>> VectorLogPtr;
  
  enum  WalFileType {
    /* Indicates that WAL file is in archive directory. WAL files are moved from
     * the main db directory to archive directory once they are not live and stay
     * there until cleaned up. Files are cleaned depending on archive size
     * (Options::WAL_size_limit_MB) and time since last cleaning
     * (Options::WAL_ttl_seconds).
     */
    kArchivedLogFile = 0,
  
    /* Indicates that WAL file is live and resides in the main db directory */
    kAliveLogFile = 1
  } ;
  
  class LogFile {
   public:
    LogFile() {}
    virtual ~LogFile() {}
  
    // Returns log file's pathname relative to the main db dir
    // Eg. For a live-log-file = /000003.log
    //     For an archived-log-file = /archive/000003.log
    virtual std::string PathName() const = 0;
  
  
    // Primary identifier for log file.
    // This is directly proportional to creation time of the log file
    virtual uint64_t LogNumber() const = 0;
  
    // Log file can be either alive or archived
    virtual WalFileType Type() const = 0;
  
    // Starting sequence number of writebatch written in this log file
    virtual SequenceNumber StartSequence() const = 0;
  
    // Size of log file on disk in Bytes
    virtual uint64_t SizeFileBytes() const = 0;
  };
  
  struct BatchResult {
    SequenceNumber sequence = 0;
    std::unique_ptr<WriteBatch> writeBatchPtr;
  
    // Add empty __ctor and __dtor for the rule of five
    // However, preserve the original semantics and prohibit copying
    // as the unique_ptr member does not copy.
    BatchResult() {}
  
    ~BatchResult() {}
  
    BatchResult(const BatchResult&) = delete;
  
    BatchResult& operator=(const BatchResult&) = delete;
  
    BatchResult(BatchResult&& bResult)
        : sequence(std::move(bResult.sequence)),
          writeBatchPtr(std::move(bResult.writeBatchPtr)) {}
  
    BatchResult& operator=(BatchResult&& bResult) {
      sequence = std::move(bResult.sequence);
      writeBatchPtr = std::move(bResult.writeBatchPtr);
      return *this;
    }
  };
  
  // A TransactionLogIterator is used to iterate over the transactions in a db.
  // One run of the iterator is continuous, i.e. the iterator will stop at the
  // beginning of any gap in sequences
  class TransactionLogIterator {
   public:
    TransactionLogIterator() {}
    virtual ~TransactionLogIterator() {}
  
    // An iterator is either positioned at a WriteBatch or not valid.
    // This method returns true if the iterator is valid.
    // Can read data from a valid iterator.
    virtual bool Valid() = 0;
  
    // Moves the iterator to the next WriteBatch.
    // REQUIRES: Valid() to be true.
    virtual void Next() = 0;
  
    // Returns ok if the iterator is valid.
    // Returns the Error when something has gone wrong.
    virtual Status status() = 0;
  
    // If valid return's the current write_batch and the sequence number of the
    // earliest transaction contained in the batch.
    // ONLY use if Valid() is true and status() is OK.
    virtual BatchResult GetBatch() = 0;
  
    // The read options for TransactionLogIterator.
    struct ReadOptions {
      // If true, all data read from underlying storage will be
      // verified against corresponding checksums.
      // Default: true
      bool verify_checksums_;
  
      ReadOptions() : verify_checksums_(true) {}
  
      explicit ReadOptions(bool verify_checksums)
          : verify_checksums_(verify_checksums) {}
    };
  };
  } //  namespace rocksdb
  
  #endif  // STORAGE_ROCKSDB_INCLUDE_TRANSACTION_LOG_ITERATOR_H_
  