Enumerator.hh

Go to the documentation of this file.

#ifndef CASM_Enumerator
#define CASM_Enumerator
 
#include <string>
 
#include "casm/casm_io/json/jsonParser.hh"  // TODO remove this dependency
#include "casm/global/definitions.hh"
#include "casm/misc/CASM_TMP.hh"
#include "casm/misc/cloneable_ptr.hh"
#include "casm/misc/unique_cloneable_map.hh"
 
namespace CASM {
 
// ---- Enumerator ---------------------
 
class EnumeratorBase {
 public:
  typedef long step_type;
 
  EnumeratorBase() : m_valid(false), m_step(0) {}
 
  virtual ~EnumeratorBase() {}
 
  step_type step() const { return m_step; }
 
  bool valid() const { return m_valid; }
 
  virtual jsonParser source(step_type step) const {
    jsonParser src;
    src["enumerated_by"] = this->name();
    src["step"] = step;
    return src;
  }
 
  virtual std::string name() const = 0;
 
 protected:
  void _initialize() {
    m_step = 0;
    m_valid = true;
  }
 
  void _set_step(step_type val) { m_step = val; }
 
  void _increment_step() { ++m_step; }
 
  void _decrement_step() { --m_step; }
 
  void _invalidate() { m_valid = false; }
 
  void _validate() { m_valid = true; }
 
 private:
  bool m_valid;
 
  step_type m_step;
};
 
template <typename ValueType, bool IsConst = true>
class ValEnumerator : public EnumeratorBase {
 public:
  typedef ValueType value_type;
  typedef CASM_TMP::ConstSwitch<IsConst, ValueType> &reference;
  using EnumeratorBase::step_type;
 
  ValEnumerator() : m_current_ptr(nullptr) {}
 
  virtual ~ValEnumerator() {}
 
  // -- from EnumeratorBase --
 
 public:
  using EnumeratorBase::name;    // pure virtual
  using EnumeratorBase::source;  // virtual
  using EnumeratorBase::step;
  using EnumeratorBase::valid;
 
 protected:
  using EnumeratorBase::_initialize;
 
  void _initialize(CASM_TMP::ConstSwitch<IsConst, value_type> *_initial) {
    _set_current_ptr(_initial);
    EnumeratorBase::_initialize();
  }
 
  using EnumeratorBase::_decrement_step;
  using EnumeratorBase::_increment_step;
  using EnumeratorBase::_invalidate;
  using EnumeratorBase::_set_step;
 
  // -- For ValEnumerator --
 
 public:
  reference current() const { return *m_current_ptr; }
 
 protected:
  void _set_current_ptr(CASM_TMP::ConstSwitch<IsConst, value_type> *_new) {
    m_current_ptr = _new;
  }
 
 private:
  CASM_TMP::ConstSwitch<IsConst, value_type> *m_current_ptr;
};
 
class EnumIteratorBase {
 public:
  typedef EnumeratorBase::step_type step_type;
 
  EnumIteratorBase() : m_enum_ptr(nullptr) {}
 
  EnumIteratorBase(EnumeratorBase &enumerator) : m_enum_ptr(&enumerator) {}
 
  virtual ~EnumIteratorBase() {}
 
  virtual step_type step() const = 0;
 
  jsonParser source() const { return _enum().source(this->step()); }
 
  std::string name() const { return m_enum_ptr->name(); }
 
  virtual bool is_end() const = 0;
 
  std::unique_ptr<EnumIteratorBase> clone() const {
    return std::unique_ptr<EnumIteratorBase>(this->_clone());
  }
 
 protected:
  void _assert_same_ptr(const EnumIteratorBase &other) const {
    assert((m_enum_ptr == other.m_enum_ptr) &&
           "Comparing EnumIterator referring to different enumerators is not "
           "allowed!");
  }
 
  void _assert_ptr() const {
    assert(m_enum_ptr && "EnumIterator does not point to any enumerator!");
  }
 
  void _assert_valid() const {
    assert(m_enum_ptr->valid() &&
           "EnumIterator points to an invalid enumerator!");
  }
 
  bool equal(const EnumIteratorBase &other) const {
    bool this_is_end = this->is_end();
    bool other_is_end = other.is_end();
 
    if (this_is_end != other_is_end) {
      return false;
    }
 
    if (this_is_end) {
      return true;
    }
 
    return (this->step() == other.step());
  }
 
  EnumeratorBase *_enum_ptr() { return m_enum_ptr; }
 
  EnumeratorBase *_enum_ptr() const { return m_enum_ptr; }
 
 private:
  virtual EnumIteratorBase *_clone() const = 0;
 
  EnumeratorBase &_enum() { return *m_enum_ptr; }
 
  EnumeratorBase &_enum() const { return *m_enum_ptr; }
 
  // pointer to Enumerator
  EnumeratorBase *m_enum_ptr;
};
 
template <typename ValueType, bool IsConst = true>
class ValEnumIterator : public EnumIteratorBase {
 public:
  using EnumIteratorBase::step_type;
  typedef ValueType value_type;
  typedef typename ValEnumerator<ValueType, IsConst>::reference reference;
 
  ValEnumIterator() {}
 
  ValEnumIterator(ValEnumerator<ValueType, IsConst> &enumerator)
      : EnumIteratorBase(enumerator) {}
 
  virtual ~ValEnumIterator() {}
 
  using EnumIteratorBase::is_end;  // pure virtual
  using EnumIteratorBase::name;
  using EnumIteratorBase::source;
  using EnumIteratorBase::step;  // pure virtual
 
  std::unique_ptr<EnumIteratorBase> clone() const {
    return std::unique_ptr<EnumIteratorBase>(this->_clone());
  }
 
 protected:
  using EnumIteratorBase::_assert_ptr;
  using EnumIteratorBase::_assert_same_ptr;
  using EnumIteratorBase::_assert_valid;
  using EnumIteratorBase::_enum_ptr;
  using EnumIteratorBase::equal;
 
 private:
  virtual EnumIteratorBase *_clone() const = 0;
  virtual reference dereference() const = 0;
};
 
template <typename EnumeratorType>
bool is_guaranteed_for_database_insert(EnumeratorType const &enumerator) {
  return false;
}
 
}  // namespace CASM
 
#endif