EnumEquivalents.hh

Go to the documentation of this file.

#ifndef CASM_EnumEquivalents
#define CASM_EnumEquivalents
 
#include "casm/enumerator/InputEnumerator.hh"
#include "casm/misc/cloneable_ptr.hh"
 
namespace CASM {
 
template <typename ObjectType, typename SymOpIterator, typename SymOpType,
          typename SymOpCompare>
class EnumEquivalents;
 
template <typename ObjectType, typename SymOpIterator, typename SymOpType,
          typename SymOpCompare>
struct traits<
    EnumEquivalents<ObjectType, SymOpIterator, SymOpType, SymOpCompare> > {
  static const std::string name;
};
 
template <typename ObjectType, typename SymOpIterator,
          typename SymOpType =
              typename std::iterator_traits<SymOpIterator>::value_type,
          typename SymOpCompare = std::less<SymOpType> >
class EnumEquivalents : public InputEnumeratorBase<ObjectType> {
  // -- Required members -------------------
 
 public:
  template <typename MakeInvariantSubgroup>
  EnumEquivalents(const ObjectType &generating_obj, SymOpIterator begin,
                  SymOpIterator end,
                  MakeInvariantSubgroup f = MakeInvariantSubgroup(),
                  SymOpCompare compare = SymOpCompare())
      : m_initial(notstd::clone(generating_obj)),
        m_current(m_initial),
        m_symop_it(begin),
        m_symop_end(end),
        m_compare(compare) {
    f(generating_obj, begin, end, std::back_inserter(m_invariant_subgroup));
 
    this->_initialize(&(*m_current));
 
    if (!_check(*m_symop_it)) {
      increment();
    }
 
    // set step to 0
    if (this->valid()) {
      this->_set_step(0);
    }
  }
 
 public:
  // -- Unique -------------------
 
  const ObjectType &generator() const { return *m_initial; }
 
  const SymOpType &sym_op() const { return *m_symop_it; }
 
  const std::vector<SymOpType> &invariant_subgroup() const {
    return m_invariant_subgroup;
  }
 
 private:
  // -- Required members -------------------
 
  void increment() override {
    while (++m_symop_it != m_symop_end && !_check(*m_symop_it)) {
      // increment
    }
    if (m_symop_it == m_symop_end) {
      this->_invalidate();
    } else {
      // generate equivalent by applying symop
      *m_current = copy_apply(*m_symop_it, *m_initial);
 
      // increment
      this->_increment_step();
    }
  }
 
  // -- Unique -------------------
 
  bool _check(const SymOpType &X) const {
    return std::none_of(
        invariant_subgroup().begin(), invariant_subgroup().end(),
        [&](const SymOpType &Bi) { return m_compare(X * Bi, X); });
  }
 
  notstd::cloneable_ptr<ObjectType> m_initial;
  notstd::cloneable_ptr<ObjectType> m_current;
  SymOpIterator m_symop_it;
  SymOpIterator m_symop_end;
  std::vector<SymOpType> m_invariant_subgroup;
  SymOpCompare m_compare;
};
 
template <typename ObjectType, typename SymOpIterator, typename SymOpType,
          typename SymOpCompare>
const std::string traits<EnumEquivalents<ObjectType, SymOpIterator, SymOpType,
                                         SymOpCompare> >::name =
    "EnumEquivalents";
 
}  // namespace CASM
 
#endif