SymCompare.hh

Go to the documentation of this file.

#ifndef CASM_SymCompare
#define CASM_SymCompare
 
#include <memory>
#include <utility>
 
#include "casm/global/definitions.hh"
#include "casm/misc/cloneable_ptr.hh"
 
namespace CASM {
 
class SymOp;
class SymOpRepresentation;
 
template <typename Base>
class SymCompare : public Base {
 public:
  using MostDerived = typename Base::MostDerived;
  using Base::derived;
 
  using Element = typename traits<MostDerived>::Element;
 
  Element copy_apply(SymOp const &op, Element obj) const;
 
  Element spatial_prepare(Element obj) const;
 
  Element representation_prepare(Element obj) const;
 
  Element prepare(Element obj) const;
 
  bool compare(const Element &A, const Element &B) const;
 
  bool equal(const Element &A, const Element &B) const;
 
  using InvariantsType = typename traits<MostDerived>::InvariantsType;
 
  InvariantsType make_invariants(const Element &element) const;
 
  bool invariants_compare(const InvariantsType &A,
                          const InvariantsType &B) const;
 
  bool invariants_equal(const InvariantsType &A, const InvariantsType &B) const;
 
  bool inter_orbit_compare(const Element &A, const InvariantsType &A_invariants,
                           const Element &B,
                           const InvariantsType &B_invariants) const;
 
  bool inter_orbit_equal(const Element &A, const InvariantsType &A_invariants,
                         const Element &B,
                         const InvariantsType &B_invariants) const;
 
  std::unique_ptr<SymOpRepresentation> canonical_transform(
      Element const &obj) const;
 
  SymOp const &spatial_transform() const;
 
 protected:
  bool inter_orbit_compare_impl(const Element &A,
                                const InvariantsType &A_invariants,
                                const Element &B,
                                const InvariantsType &B_invariants) const;
};
 
template <typename Base>
typename SymCompare<Base>::Element SymCompare<Base>::copy_apply(
    SymOp const &op, Element obj) const {
  return derived().copy_apply_impl(op, obj);
}
 
template <typename Base>
typename SymCompare<Base>::Element SymCompare<Base>::spatial_prepare(
    Element obj) const {
  return derived().spatial_prepare_impl(obj);
}
 
template <typename Base>
typename SymCompare<Base>::Element SymCompare<Base>::representation_prepare(
    Element obj) const {
  return derived().representation_prepare_impl(obj);
}
 
template <typename Base>
typename SymCompare<Base>::Element SymCompare<Base>::prepare(
    Element obj) const {
  return spatial_prepare(representation_prepare(obj));
}
 
template <typename Base>
bool SymCompare<Base>::compare(const Element &A, const Element &B) const {
  return derived().compare_impl(A, B);
}
 
template <typename Base>
bool SymCompare<Base>::equal(const Element &A, const Element &B) const {
  return !compare(A, B) && !compare(B, A);
}
 
template <typename Base>
typename SymCompare<Base>::InvariantsType SymCompare<Base>::make_invariants(
    const Element &obj) const {
  return derived().make_invariants_impl(obj);
}
 
template <typename Base>
bool SymCompare<Base>::invariants_compare(const InvariantsType &A,
                                          const InvariantsType &B) const {
  return derived().invariants_compare_impl(A, B);
}
 
template <typename Base>
bool SymCompare<Base>::invariants_equal(const InvariantsType &A,
                                        const InvariantsType &B) const {
  return !invariants_compare(A, B) && !invariants_compare(B, A);
}
 
template <typename Base>
bool SymCompare<Base>::inter_orbit_compare(
    const Element &A, const InvariantsType &A_invariants, const Element &B,
    const InvariantsType &B_invariants) const {
  return derived().inter_orbit_compare_impl(A, A_invariants, B, B_invariants);
}
 
template <typename Base>
bool SymCompare<Base>::inter_orbit_equal(
    const Element &A, const InvariantsType &A_invariants, const Element &B,
    const InvariantsType &B_invariants) const {
  return !inter_orbit_compare(A, A_invariants, B, B_invariants) &&
         !inter_orbit_compare(B, B_invariants, A, A_invariants);
}
 
template <typename Base>
std::unique_ptr<SymOpRepresentation> SymCompare<Base>::canonical_transform(
    Element const &obj) const {
  return derived().canonical_transform_impl(obj);
}
 
template <typename Base>
SymOp const &SymCompare<Base>::spatial_transform() const {
  return derived().spatial_transform_impl();
}
 
template <typename Base>
bool SymCompare<Base>::inter_orbit_compare_impl(
    const Element &A, const InvariantsType &A_invariants, const Element &B,
    const InvariantsType &B_invariants) const {
  // first compare invariants
  if (this->invariants_compare(A_invariants, B_invariants)) {
    return true;
  }
  if (this->invariants_compare(B_invariants, A_invariants)) {
    return false;
  }
 
  // next compare A and B
  return this->compare(A, B);
}
 
}  // namespace CASM
 
#endif