epoch.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2014-2015, Hewlett-Packard Development Company, LP.
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the Free
 * Software Foundation; either version 2 of the License, or (at your option)
 * any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
 * more details. You should have received a copy of the GNU General Public
 * License along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 *
 * HP designates this particular file as subject to the "Classpath" exception
 * as provided by HP in the LICENSE.txt file that accompanied this code.
 */
#ifndef FOEDUS_EPOCH_HPP_
#define FOEDUS_EPOCH_HPP_

#include <stdint.h>

#include <iosfwd>

#include "foedus/assert_nd.hpp"
#include "foedus/cxx11.hpp"

namespace foedus {
class Epoch {
 public:
  typedef uint32_t EpochInteger;
  enum Constants {
    kEpochInvalid = 0,
    kEpochInitialDurable = 1,
    kEpochInitialGrace = 2,
    kEpochInitialCurrent = 3,
    kEpochBits = 28,
    kEpochIntOverflow = (1 << kEpochBits),
    kEpochIntHalf = (1 << (kEpochBits - 1)),
  };

  Epoch() CXX11_NOEXCEPT : epoch_(kEpochInvalid) {}
  explicit Epoch(EpochInteger value) CXX11_NOEXCEPT : epoch_(value) {
    ASSERT_ND(value < kEpochIntOverflow);
  }
  // default copy-constructor/assignment/destructor suffice

  void    reset() { epoch_ = kEpochInvalid; }
  bool    is_valid() const {
    ASSERT_ND(epoch_ < kEpochIntOverflow);
    return epoch_ != kEpochInvalid;
  }

  EpochInteger value() const { return epoch_; }

  Epoch&  operator++() {
    ASSERT_ND(is_valid());  // we prohibit increment from invalid epoch
    if (epoch_ == kEpochIntOverflow - 1) {
      epoch_ = 1;  // skip 0, which is always an invalid epoch.
    } else {
      ++epoch_;
    }
    return *this;
  }
  Epoch&  operator--() {
    ASSERT_ND(is_valid());  // we prohibit decrement from invalid epoch
    if (epoch_ == 1) {
      epoch_ = kEpochIntOverflow - 1;  // skip 0, which is always an invalid epoch.
    } else {
      --epoch_;
    }
    return *this;
  }
  Epoch one_less() const {
    Epoch tmp(epoch_);
    tmp.operator--();
    return tmp;
  }
  Epoch one_more() const {
    Epoch tmp(epoch_);
    tmp.operator++();
    return tmp;
  }

  uint32_t subtract(const Epoch& other) const {
    ASSERT_ND(is_valid());
    if (epoch_ >= other.epoch_) {
      return epoch_ - other.epoch_;
    } else {
      // wrap around
      return epoch_ + kEpochIntOverflow - other.epoch_;
    }
  }

  void    store_min(const Epoch& other) {
    ASSERT_ND(other.is_valid());
    if (!is_valid() || other < *this) {
      epoch_ = other.epoch_;
    }
  }
  void    store_max(const Epoch& other) {
    ASSERT_ND(other.is_valid());
    if (!is_valid() || other > *this) {
      epoch_ = other.epoch_;
    }
  }

  bool before(const Epoch &other) const {
    ASSERT_ND(is_valid());
    ASSERT_ND(other.is_valid());
    int64_t diff = static_cast<int64_t>(other.epoch_) - static_cast<int64_t>(epoch_);
    return diff <= -kEpochIntHalf || (diff > 0 && diff < kEpochIntHalf);
  }

  bool    operator==(const Epoch &other)  const { return epoch_ == other.epoch_; }
  bool    operator!=(const Epoch &other)  const { return epoch_ != other.epoch_; }
  bool    operator<(const Epoch &other)   const { return before(other); }
  bool    operator>(const Epoch &other)   const { return other.before(*this); }
  bool    operator<=(const Epoch &other)  const { return !operator>(other); }
  bool    operator>=(const Epoch &other)  const { return !operator<(other); }

  friend std::ostream& operator<<(std::ostream& o, const Epoch& v);

 private:
  EpochInteger epoch_;
};

const Epoch INVALID_EPOCH;
}  // namespace foedus

#endif  // FOEDUS_EPOCH_HPP_