InputEnumerator.hh

Go to the documentation of this file.

#ifndef CASM_InputEnumerator
#define CASM_InputEnumerator
 
#include <string>
 
#include "casm/enumerator/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) {}
 
  using EnumIteratorBase::name;
  using EnumIteratorBase::source;
 
  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;
 
 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;
};
 
}  // namespace CASM
 
#endif