ScelEnum.hh

Go to the documentation of this file.

#ifndef CASM_ScelEnum
#define CASM_ScelEnum

#include "casm/misc/cloneable_ptr.hh"
#include "casm/crystallography/SupercellEnumerator.hh"
#include "casm/container/InputEnumerator.hh"
#include "casm/container/RandomAccessEnumerator.hh"
#include "casm/clex/Supercell.hh"

extern "C" {
  CASM::EnumInterfaceBase *make_ScelEnum_interface();
}

namespace CASM {


  template<bool IsConst = true>
  class ScelEnumByNameT : public RandomAccessEnumeratorBase<Supercell, IsConst> {

    // -- Required members -------------------

  public:

    using typename RandomAccessEnumeratorBase<Supercell, IsConst>::step_type;

    ScelEnumByNameT(PrimClex &primclex, std::initializer_list<std::string> scelnames);

    template<typename ScelNameIterator>
    ScelEnumByNameT(PrimClex &primclex, ScelNameIterator begin, ScelNameIterator end);

    ScelEnumByNameT(PrimClex &primclex, const jsonParser &input);

    std::string name() const override;

    static const std::string enumerator_name;


  private:

    Supercell *at_step(step_type n) override;

    // -- Unique -------------------

    void _init();

    PrimClex *m_primclex;

    std::vector<Supercell *> m_scelptr;
  };

  typedef ScelEnumByNameT<true> ConstScelEnumByName;

  typedef ScelEnumByNameT<false> ScelEnumByName;


  template<bool IsConst = true>
  class ScelEnumByPropsT : public InputEnumeratorBase<Supercell, IsConst> {

  public:

    ScelEnumByPropsT(PrimClex &primclex, const ScelEnumProps &enum_props, bool existing_only = false);

    ScelEnumByPropsT(PrimClex &primclex, const jsonParser &input);

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


    std::string name() const override;

    static const std::string enumerator_name;


  private:

    bool _include(const Lattice &lat) const;

    void increment() override;

    PrimClex *m_primclex;

    std::unique_ptr<SupercellEnumerator<Lattice> > m_lattice_enum;
    SupercellEnumerator<Lattice>::const_iterator m_lat_it;
    SupercellEnumerator<Lattice>::const_iterator m_lat_end;

    bool m_existing_only;
  };

  typedef ScelEnumByPropsT<true> ConstScelEnumByProps;

  typedef ScelEnumByPropsT<false> ScelEnumByProps;


  template<bool IsConst = true>
  class ScelEnumT : public InputEnumeratorBase<Supercell, IsConst> {

  public:

    ScelEnumT(PrimClex &primclex, const jsonParser &input);

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


    std::string name() const override;

    static const std::string enumerator_name;
    static const std::string interface_help;
    static int run(PrimClex &primclex, const jsonParser &kwargs, const Completer::EnumOption &enum_opt);


  private:

    void increment() override;

    InputEnumIterator<Supercell, false> m_it;
    InputEnumIterator<Supercell, false> m_end;
    InputEnumerator<Supercell, false> m_enum;
  };

  typedef ScelEnumT<true> ConstScelEnum;

  typedef ScelEnumT<false> ScelEnum;

}

#endif