InputEnumerator.hh

Go to the documentation of this file.

#ifndef CASM_InputEnumerator
#define CASM_InputEnumerator

#include <string>

#include "casm/container/Enumerator.hh"

namespace CASM {

  template<typename ValueType, bool IsConst>
  class InputEnumeratorBase;

  template<typename ValueType, bool IsConst>
  class InputEnumIterator;


  template<typename ValueType, bool IsConst = true>
  class InputEnumIteratorBase : public ValEnumIterator<ValueType, IsConst> {

    friend InputEnumIterator<ValueType, IsConst>;

  public:

    using typename ValEnumIterator<ValueType, IsConst>::step_type;
    using typename ValEnumIterator<ValueType, IsConst>::value_type;
    using typename ValEnumIterator<ValueType, IsConst>::reference;


    InputEnumIteratorBase() {}

    InputEnumIteratorBase(InputEnumeratorBase<ValueType, IsConst> &enumerator, bool is_end) :
      ValEnumIterator<ValueType, IsConst>(enumerator), m_constructed_as_end(is_end) {}

    virtual ~InputEnumIteratorBase() {}


    using EnumIteratorBase::source;
    using EnumIteratorBase::name;

    virtual step_type step() const override {
      this->_assert_ptr();
      return _enum().step();
    }

    virtual bool is_end() const override {
      this->_assert_ptr();
      return _constructed_as_end() || !this->_enum().valid();
    }

    std::unique_ptr<InputEnumIteratorBase> clone() const {
      return std::unique_ptr<InputEnumIteratorBase>(this->_clone());
    }

  protected:
    using ValEnumIterator<ValueType, IsConst>::_enum_ptr;

    bool _constructed_as_end() const {
      return m_constructed_as_end;
    }

  private:

    virtual InputEnumIteratorBase<ValueType, IsConst> *_clone() const override {
      return new InputEnumIteratorBase<ValueType, IsConst>(*this);
    }

    virtual reference dereference() const override {
      return _enum().current();
    }

    virtual void increment() {
      _enum().increment();
    }

    InputEnumeratorBase<ValueType, IsConst> &_enum() {
      return static_cast<InputEnumeratorBase<ValueType, IsConst>&>(*_enum_ptr());
    }

    InputEnumeratorBase<ValueType, IsConst> &_enum() const {
      return static_cast<InputEnumeratorBase<ValueType, IsConst>&>(*_enum_ptr());
    }

    bool m_constructed_as_end;
  };


  template<typename ValueType, bool IsConst = true>
  class InputEnumIterator :

    public boost::iterator_facade <
    InputEnumIterator<ValueType, IsConst>,
    ValueType,
    std::input_iterator_tag,
    CASM_TMP::ConstSwitch<IsConst, ValueType> &,
    long > {

  public:

    typedef typename InputEnumIteratorBase<ValueType, IsConst>::step_type step_type;
    typedef ValueType value_type;
    typedef typename InputEnumIteratorBase<ValueType, IsConst>::reference reference;


    InputEnumIterator() {}

    InputEnumIterator(const InputEnumIteratorBase<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();
    }


  private:

    friend boost::iterator_core_access;

    void increment() {
      m_ptr->increment();
    }

    reference dereference() const {
      return m_ptr->dereference();
    }

    bool equal(const InputEnumIterator &B) const {
      return m_ptr->equal(*(B.m_ptr));
    }

    notstd::cloneable_ptr<InputEnumIteratorBase<ValueType, IsConst> > m_ptr;
  };


  template<typename ValueType, bool IsConst = true>
  class InputEnumeratorBase : public ValEnumerator<ValueType, IsConst> {

    friend InputEnumIteratorBase<ValueType, IsConst>;

  public:

    using typename ValEnumerator<ValueType, IsConst>::step_type;
    using typename ValEnumerator<ValueType, IsConst>::value_type;
    using typename ValEnumerator<ValueType, IsConst>::reference;
    typedef InputEnumIterator<ValueType, IsConst> iterator;


    InputEnumeratorBase() {}

    virtual ~InputEnumeratorBase() {}


    using ValEnumerator<ValueType, IsConst>::step;
    using ValEnumerator<ValueType, IsConst>::valid;
    using ValEnumerator<ValueType, IsConst>::source; // virtual
    using ValEnumerator<ValueType, IsConst>::name; // pure virtual
    using ValEnumerator<ValueType, IsConst>::current;

    iterator begin() {
      return InputEnumIteratorBase<ValueType, IsConst>(*this, false);
    }

    iterator end() {
      return InputEnumIteratorBase<ValueType, IsConst>(*this, true);
    }


  protected:

    using ValEnumerator<ValueType, IsConst>::_initialize;
    using ValEnumerator<ValueType, IsConst>::_set_step;
    using ValEnumerator<ValueType, IsConst>::_increment_step;
    using ValEnumerator<ValueType, IsConst>::_invalidate;
    using ValEnumerator<ValueType, IsConst>::_set_current_ptr;
    using ValEnumerator<ValueType, IsConst>::_current;


  private:

    //using ValEnumerator<ValueType, IsConst>::_decrement_step; // hide
    virtual void increment() = 0;

  };

  template<typename ValueType, bool IsConst = true>
  class InputEnumerator {

  public:

    typedef typename InputEnumeratorBase<ValueType, IsConst>::step_type step_type;
    typedef typename InputEnumeratorBase<ValueType, IsConst>::value_type value_type;
    typedef typename InputEnumeratorBase<ValueType, IsConst>::reference reference;
    typedef typename InputEnumeratorBase<ValueType, IsConst>::iterator iterator;


    InputEnumerator() {}

    InputEnumerator(std::unique_ptr<InputEnumeratorBase<ValueType, IsConst> > e) :
      ptr(notstd::clone(e)) {}

    InputEnumerator(const InputEnumerator &) = delete;
    InputEnumerator &operator=(const InputEnumerator &) = delete;


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

    reference current() const {
      return ptr->current();
    }

    iterator begin() {
      return ptr->begin();
    }

    iterator end() {
      return ptr->end();
    }

    std::unique_ptr<InputEnumeratorBase<ValueType, IsConst> > ptr;
  };

}

#endif