RandomAccessEnumerator.hh

Go to the documentation of this file.

#ifndef CASM_RandomAccessEnumerator
#define CASM_RandomAccessEnumerator

#include <string>

#include "casm/container/Enumerator.hh"
#include "casm/container/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) {}

    ~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->dereference();
    }

    reference back() {
      this->goto_step(size() - 1);
      return this->dereference();
    }

    reference initial() {
      return front();
    }

    reference final() {
      return back();
    }

    reference operator[](size_type n) {
      this->goto_step(n);
      return this->dereference();
    }

  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;
    using ValEnumerator<ValueType, IsConst>::_current;

    void _set_size(size_type val) {
      m_size = val;
    }

  private:

    virtual 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;
  };

}

#endif