GenericCluster.hh

Go to the documentation of this file.

#ifndef CASM_GenericCluster
#define CASM_GenericCluster
 
#include <algorithm>
#include <vector>
 
#include "casm/container/Permutation.hh"
#include "casm/container/algorithm.hh"
#include "casm/misc/Comparisons.hh"
 
namespace CASM {
 
/* -- GenericCluster Declarations ------------------------------------- */
 
template <typename Base>
class GenericCluster : public Comparisons<Base> {
 public:
  typedef typename Base::MostDerived MostDerived;
  using Base::derived;
 
  typedef typename traits<MostDerived>::Element Element;
  typedef Index size_type;
 
  typedef typename std::vector<Element>::value_type value_type;
  typedef typename std::vector<Element>::iterator iterator;
  typedef typename std::vector<Element>::const_iterator const_iterator;
 
  iterator begin() { return derived().elements().begin(); }
 
  const_iterator begin() const { return derived().elements().begin(); }
 
  iterator end() { return derived().elements().end(); }
 
  const_iterator end() const { return derived().elements().end(); }
 
  const_iterator cbegin() const { return derived().elements().cbegin(); }
 
  const_iterator cend() const { return derived().elements().cend(); }
 
  size_type size() const { return derived().elements().size(); }
 
  value_type &operator[](size_type index) { return derived().element(index); }
 
  value_type const &operator[](size_type index) const {
    return derived().element(index);
  }
 
  value_type &element(size_type index) { return derived().elements()[index]; }
 
  value_type const &element(size_type index) const {
    return derived().elements()[index];
  }
 
  MostDerived &sort() { return derived().sort_impl(); }
 
  MostDerived sorted() const {
    MostDerived tmp{derived()};
    return tmp.sort();
  }
 
  bool is_sorted() const { return derived().is_sorted_impl(); }
 
  Permutation sort_permutation() const {
    return derived().sort_permutation_impl();
  }
 
  bool operator<(MostDerived const &B) const {
    return derived().compare_impl(B);
  }
 
 protected:
  GenericCluster() {}
 
  MostDerived &sort_impl() {
    std::sort(begin(), end());
    return derived();
  }
 
  bool is_sorted_impl() const { return std::is_sorted(begin(), end()); }
 
  Permutation sort_permutation_impl() const {
    if (size() == 0) return Permutation(0);
    std::vector<Index> ind = sequence(Index(0), Index(size() - 1));
 
    std::sort(ind.begin(), ind.end(), [&](const Index &a, const Index &b) {
      return (this->derived().element(a) < this->derived().element(b));
    });
 
    return Permutation(std::move(ind));
  }
 
  bool compare_impl(MostDerived const &B) const {
    if (size() != B.size()) {
      return size() < B.size();
    }
    return lexicographical_compare(begin(), end(), B.begin(), B.end());
  }
};
}  // namespace CASM
 
#endif