RandomAccessEnumerator.hh

Go to the documentation of this file.

#ifndef CASM_RandomAccessEnumerator
#define CASM_RandomAccessEnumerator
 
#include <string>
 
#include "casm/enumerator/Enumerator.hh"
#include "casm/enumerator/InputEnumerator.hh"
 
namespace CASM {
 
template <typename ValueType, bool IsConst>
class RandomAccessEnumIterator;
 
template <typename ValueType, bool IsConst>
class RandomAccessEnumeratorBase;
 
template <typename ValueType, bool IsConst>
class RandomAccessEnumerator;
 
template <typename ValueType, bool IsConst = true>
class RandomAccessEnumIteratorBase
    : public InputEnumIteratorBase<ValueType, IsConst> {
  friend RandomAccessEnumIterator<ValueType, IsConst>;
 
 public:
  using typename InputEnumIteratorBase<ValueType, IsConst>::step_type;
  using typename InputEnumIteratorBase<ValueType, IsConst>::value_type;
  using typename InputEnumIteratorBase<ValueType, IsConst>::reference;
  typedef step_type difference_type;
 
  RandomAccessEnumIteratorBase() {}
 
  RandomAccessEnumIteratorBase(
      RandomAccessEnumeratorBase<ValueType, IsConst> &enumerator, bool is_end)
      : InputEnumIteratorBase<ValueType, IsConst>(enumerator, is_end) {
    if (!is_end) {
      m_it_step = 0;
    } else {
      m_it_step = _enum().size();
    }
  }
 
  using InputEnumIteratorBase<ValueType, IsConst>::source;
  using InputEnumIteratorBase<ValueType, IsConst>::name;
 
  step_type step() const override { return m_it_step; }
 
  bool is_end() const override {
    this->_assert_ptr();
    return _constructed_as_end() || step() == _enum().size();
  }
 
  std::unique_ptr<RandomAccessEnumIteratorBase> clone() const {
    return std::unique_ptr<RandomAccessEnumIteratorBase>(this->_clone());
  }
 
 protected:
  using InputEnumIteratorBase<ValueType, IsConst>::_enum_ptr;
  using InputEnumIteratorBase<ValueType, IsConst>::_constructed_as_end;
 
 private:
  reference dereference() const override {
    _enum().goto_step(m_it_step);
    return _enum().current();
  }
 
  void increment() override { ++m_it_step; }
 
  void decrement() { --m_it_step; }
 
  void advance(step_type n) { m_it_step += n; }
 
  difference_type distance_to(const RandomAccessEnumIteratorBase &B) const {
    return B.m_it_step - m_it_step;
  }
 
  RandomAccessEnumIteratorBase<ValueType, IsConst> *_clone() const override {
    return new RandomAccessEnumIteratorBase<ValueType, IsConst>(*this);
  }
 
  RandomAccessEnumeratorBase<ValueType, IsConst> &_enum() {
    return static_cast<RandomAccessEnumeratorBase<ValueType, IsConst> &>(
        *_enum_ptr());
  }
 
  RandomAccessEnumeratorBase<ValueType, IsConst> &_enum() const {
    return static_cast<RandomAccessEnumeratorBase<ValueType, IsConst> &>(
        *_enum_ptr());
  }
 
  step_type m_it_step;
};
 
template <typename ValueType, bool IsConst = true>
class RandomAccessEnumIterator :
 
    public boost::iterator_facade<RandomAccessEnumIterator<ValueType, IsConst>,
                                  ValueType, boost::random_access_traversal_tag,
                                  CASM_TMP::ConstSwitch<IsConst, ValueType> &,
                                  long> {
 public:
  typedef typename RandomAccessEnumIteratorBase<ValueType, IsConst>::step_type
      step_type;
  typedef ValueType value_type;
  typedef typename RandomAccessEnumIteratorBase<ValueType, IsConst>::reference
      reference;
  typedef step_type difference_type;
 
  RandomAccessEnumIterator() {}
 
  RandomAccessEnumIterator(
      const RandomAccessEnumIteratorBase<ValueType, IsConst> &it)
      : m_ptr(notstd::clone(it)) {}
 
  step_type step() const { return m_ptr->step(); }
 
  jsonParser source() const { return m_ptr->source(); }
 
  std::string name() const { return m_ptr->name(); }
 
  std::unique_ptr<RandomAccessEnumIterator> clone() const {
    return std::unique_ptr<RandomAccessEnumIterator>(this->_clone());
  }
 
 private:
  friend boost::iterator_core_access;
 
  RandomAccessEnumIterator *_clone() const {
    return new RandomAccessEnumIterator(*this);
  }
 
  bool equal(const RandomAccessEnumIterator &B) const {
    return m_ptr->equal(*(B.m_ptr));
  }
 
  reference dereference() const { return m_ptr->dereference(); }
 
  void increment() { m_ptr->increment(); }
 
  void decrement() { m_ptr->decrement(); }
 
  void advance(step_type n) { m_ptr->advance(n); }
 
  difference_type distance_to(const RandomAccessEnumIterator &B) const {
    return m_ptr->distance_to(*(B.m_ptr));
  }
 
  notstd::cloneable_ptr<RandomAccessEnumIteratorBase<ValueType, IsConst> >
      m_ptr;
};
 
template <typename ValueType, bool IsConst = true>
class RandomAccessEnumeratorBase
    : public InputEnumeratorBase<ValueType, IsConst> {
  friend RandomAccessEnumIteratorBase<ValueType, IsConst>;
 
 public:
  using typename InputEnumeratorBase<ValueType, IsConst>::step_type;
  using typename InputEnumeratorBase<ValueType, IsConst>::value_type;
  using typename InputEnumeratorBase<ValueType, IsConst>::reference;
  typedef RandomAccessEnumIterator<ValueType, IsConst> iterator;
  typedef std::reverse_iterator<iterator> reverse_iterator;
  typedef step_type size_type;
 
  RandomAccessEnumeratorBase(size_type size = 0)
      : InputEnumeratorBase<ValueType, IsConst>(), m_size(size) {}
 
  virtual ~RandomAccessEnumeratorBase() {}
 
  using InputEnumeratorBase<ValueType, IsConst>::step;
  using InputEnumeratorBase<ValueType, IsConst>::valid;
  using InputEnumeratorBase<ValueType, IsConst>::source;  // virtual
  using InputEnumeratorBase<ValueType, IsConst>::name;    // pure virtual
  using InputEnumeratorBase<ValueType, IsConst>::current;
 
  iterator begin() {
    return RandomAccessEnumIteratorBase<ValueType, IsConst>(*this, false);
  }
 
  iterator end() {
    return RandomAccessEnumIteratorBase<ValueType, IsConst>(*this, true);
  }
 
  reverse_iterator rbegin() { return reverse_iterator(end()); }
 
  reverse_iterator rend() { return reverse_iterator(begin()); }
 
  size_type size() const { return m_size; };
 
  reference front() {
    this->goto_step(0);
    return this->current();
  }
 
  reference back() {
    this->goto_step(size() - 1);
    return this->current();
  }
 
  reference initial() { return front(); }
 
  reference final() { return back(); }
 
  reference operator[](size_type n) {
    this->goto_step(n);
    return this->current();
  }
 
 protected:
  using ValEnumerator<ValueType, IsConst>::_initialize;
  using ValEnumerator<ValueType, IsConst>::_set_step;
  using ValEnumerator<ValueType, IsConst>::_increment_step;
  using ValEnumerator<ValueType, IsConst>::_decrement_step;
  using ValEnumerator<ValueType, IsConst>::_invalidate;
  using ValEnumerator<ValueType, IsConst>::_set_current_ptr;
 
  void _set_size(size_type val) { m_size = val; }
 
 private:
  virtual CASM_TMP::ConstSwitch<IsConst, value_type> *at_step(step_type n) = 0;
 
  void goto_step(step_type n) {
    if (this->step() == n) {
      return;
    }
    this->_set_step(n);
    if (n >= 0 && n < this->size()) {
      this->_validate();
      this->_set_current_ptr(this->at_step(n));
    } else {
      this->_invalidate();
    }
  }
 
  void increment() override { goto_step(step() + 1); }
 
  size_type m_size;
};
 
template <typename ValueType, bool IsConst = true>
class RandomAccessEnumerator {
 public:
  typedef typename RandomAccessEnumeratorBase<ValueType, IsConst>::step_type
      step_type;
  typedef ValueType value_type;
  typedef typename RandomAccessEnumeratorBase<ValueType, IsConst>::reference
      reference;
  typedef RandomAccessEnumIterator<ValueType, IsConst> iterator;
  typedef std::reverse_iterator<iterator> reverse_iterator;
  typedef typename RandomAccessEnumeratorBase<ValueType, IsConst>::size_type
      size_type;
 
  RandomAccessEnumerator() {}
 
  RandomAccessEnumerator(
      std::unique_ptr<RandomAccessEnumeratorBase<ValueType, IsConst> > e)
      : ptr(e.release()) {}
 
  RandomAccessEnumerator(const RandomAccessEnumerator &) = delete;
  RandomAccessEnumerator &operator=(const RandomAccessEnumerator &) = delete;
 
  iterator begin() { return ptr->begin(); }
 
  iterator end() { return ptr->end(); }
 
  reverse_iterator rbegin() { return reverse_iterator(end()); }
 
  reverse_iterator rend() { return reverse_iterator(begin()); }
 
  reference current() const { return ptr->current(); }
 
  step_type step() const { return ptr->step(); }
 
  bool valid() const { return ptr->valid(); }
 
  jsonParser source(step_type step) const { return ptr->source(step); }
 
  std::string name() const { return ptr->name(); }
 
  std::unique_ptr<RandomAccessEnumeratorBase<ValueType, IsConst> > ptr;
};
 
}  // namespace CASM
 
#endif