Enumerator.hh

Go to the documentation of this file.

#ifndef CASM_Enumerator
#define CASM_Enumerator

#include <string>

#include "casm/casm_io/jsonParser.hh"
#include "casm/misc/cloneable_ptr.hh"
#include "casm/misc/unique_cloneable_map.hh"

namespace CASM {

  template<typename ValueType, bool IsConst>
  class ValEnumerator;

  // ---- Enumerator ---------------------

  class EnumeratorBase {

  public:

    typedef long step_type;

    EnumeratorBase() :
      m_valid(false),
      m_step(0) {}

    ~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::step;
    using EnumeratorBase::valid;
    using EnumeratorBase::source; // virtual
    using EnumeratorBase::name; // pure virtual

  protected:

    void _initialize(value_type *_initial) {
      _set_current_ptr(_initial);
      EnumeratorBase::_initialize();
    }

    using EnumeratorBase::_set_step;
    using EnumeratorBase::_increment_step;
    using EnumeratorBase::_decrement_step;
    using EnumeratorBase::_invalidate;


    // -- For ValEnumerator --

  public:

    reference current() const {
      return *m_current_ptr;
    }

  protected:

    void _set_current_ptr(value_type *_new) {
      m_current_ptr = _new;
    }

    value_type &_current() {
      return *m_current_ptr;
    }

  private:

    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::step; // pure virtual
    using EnumIteratorBase::source;
    using EnumIteratorBase::name;
    using EnumIteratorBase::is_end; // pure virtual

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

  protected:

    using EnumIteratorBase::_assert_same_ptr;
    using EnumIteratorBase::_assert_ptr;
    using EnumIteratorBase::_assert_valid;
    using EnumIteratorBase::equal;
    using EnumIteratorBase::_enum_ptr;

  private:

    virtual EnumIteratorBase *_clone() const = 0;
    virtual reference dereference() const = 0;

  };

  // ---- Interface ---------------------

  class PrimClex;
  template<bool>
  class ScelEnumT;
  typedef ScelEnumT<false> ScelEnum;
  class ScelEnumProps;
  class Lattice;
  template<typename T>
  class SupercellEnumerator;

  namespace Completer {
    class EnumOption;
  }

  class EnumInterfaceBase {

  public:

    EnumInterfaceBase() {}

    virtual ~EnumInterfaceBase() {}

    virtual std::string help() const = 0;

    virtual std::string name() const = 0;

    virtual int run(PrimClex &primclex, const jsonParser &kwargs, const Completer::EnumOption &enum_opt) const = 0;

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

  private:

    virtual EnumInterfaceBase *_clone() const = 0;

  };


  typedef notstd::unique_cloneable_map<std::string, EnumInterfaceBase> EnumeratorMap;

  inline EnumeratorMap make_enumerator_map() {

    return EnumeratorMap(
    [](const EnumInterfaceBase & e) -> std::string {
      return e.name();
    },
    [](const EnumInterfaceBase & e) -> notstd::cloneable_ptr<EnumInterfaceBase> {
      return notstd::clone(e);
    });
  }

  jsonParser make_enumerator_scel_enum_input(
    const jsonParser &_kwargs,
    const Completer::EnumOption &enum_opt);

  ScelEnumProps make_enumerator_scel_enum_props(
    PrimClex &primclex,
    const jsonParser &_kwargs,
    const Completer::EnumOption &enum_opt);

  std::unique_ptr<SupercellEnumerator<Lattice> > make_enumerator_superlat_enum(
    PrimClex &primclex,
    const jsonParser &_kwargs,
    const Completer::EnumOption &enum_opt);

  std::unique_ptr<ScelEnum> make_enumerator_scel_enum(
    PrimClex &primclex,
    const jsonParser &_kwargs,
    const Completer::EnumOption &enum_opt);

  std::vector<std::string> make_enumerator_filter_expr(
    const jsonParser &_kwargs,
    const Completer::EnumOption &enum_opt);

  template<typename ScelIterator, typename ConfigEnumConstructor>
  int insert_unique_canon_configs(
    std::string method,
    PrimClex &primclex,
    ScelIterator begin,
    ScelIterator end,
    ConfigEnumConstructor f,
    std::vector<std::string> filter_expr);

  template<typename ScelIterator, typename ConfigEnumConstructor>
  int insert_configs(
    std::string method,
    PrimClex &primclex,
    ScelIterator begin,
    ScelIterator end,
    ConfigEnumConstructor f,
    std::vector<std::string> filter_expr,
    bool primitive_only);

  template<typename LatticeIterator, typename ConfigEnumConstructor>
  int insert_configs_via_lattice_enum(
    std::string method,
    PrimClex &primclex,
    LatticeIterator begin,
    LatticeIterator end,
    ConfigEnumConstructor f,
    std::vector<std::string> filter_expr,
    bool primitive_only);

  template<typename Derived>
  class EnumInterface : public EnumInterfaceBase {

  public:

    std::string help() const override {
      return Derived::interface_help;
    }

    std::string name() const override {
      return Derived::enumerator_name;
    }

    int run(PrimClex &primclex, const jsonParser &kwargs, const Completer::EnumOption &enum_opt) const override {
      return Derived::run(primclex, kwargs, enum_opt);
    }

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

  private:

    EnumInterfaceBase *_clone() const override {
      return new EnumInterface<Derived>(*this);
    }


  };

}

#endif