BaseCounter.hh

Go to the documentation of this file.

#ifndef BASECOUNTER_HH
#define BASECOUNTER_HH
 
#include <iterator>
 
#include "casm/misc/CASM_TMP.hh"
 
namespace CASM {
 
template <typename CounterType>
class CounterValueIterator {
 public:
  typedef typename CounterType::value_type value_type;
  typedef typename CounterType::size_type difference_type;
  typedef typename CounterType::size_type size_type;
  typedef std::random_access_iterator_tag iterator_category;
  typedef const value_type &reference;
  typedef const value_type *pointer;
 
  CounterValueIterator(CounterType const *_counter_ptr = nullptr,
                       size_type _ind = 0)
      : m_counter_ptr(_counter_ptr), m_ind(_ind) {}
 
  // explicit CounterValueIterator(const CounterValueIterator &_it) :
  //  m_counter_ptr(_it.m_counter_ptr),
  //  m_ind(_it.m_ind) {}
 
  bool operator==(const CounterValueIterator &_it) {
    return (m_counter_ptr == _it.m_counter_ptr && m_ind == _it.m_ind);
  }
 
  bool operator!=(const CounterValueIterator &_it) { return !((*this) == _it); }
 
  CounterValueIterator &operator++() {
    ++m_ind;
    return *this;
  }
 
  CounterValueIterator operator++(int) {
    CounterValueIterator t_it(*this);
    ++(*this);
    return t_it;
  }
 
  reference operator*() const { return (*m_counter_ptr)[m_ind]; }
  pointer operator->() const { return &operator*(); }
 
 private:
  CounterType const *m_counter_ptr;
  size_type m_ind;
};
 
/*template<typename Container,
         typename value_type = typename Container::value_type,
         typename size_type = typename Container::size_type,
         typename Access = CASM_TMP::BracketAccess<Container, value_type,
   size_type>, typename Compare = CASM_TMP::MuchLessThan<value_type> >
*/
template <typename DerivedCounter>
class BaseCounter {
 public:
  typedef typename traits<DerivedCounter>::Container Container;
  typedef typename traits<DerivedCounter>::value_type value_type;
  typedef typename traits<DerivedCounter>::size_type size_type;
  typedef typename traits<DerivedCounter>::Access Access;
  typedef typename traits<DerivedCounter>::Compare Compare;
  typedef CounterValueIterator<DerivedCounter> const_value_iterator;
 
  BaseCounter() {}
 
  BaseCounter(const Container &_initial, const Container &_final,
              const Container &_increment, Access _access = Access(),
              Compare _compare = Compare())
      : m_access(_access),
        m_compare(_compare),
        m_initial(_initial),
        m_final(_final),
        m_increment(_increment),
        m_lower(_initial),
        m_upper(_initial),
        m_current(_initial),
        m_valid(_initial.size() != 0) {
    //_init();
  }
 
  bool valid() const { return m_valid; };
 
  operator bool() const { return valid(); }
 
  operator const Container &() const { return m_current; }
 
  const value_type &operator[](size_type index) const {
    return m_access(m_current, index);
  };
 
  size_type size() const { return m_current.size(); }
 
  const_value_iterator value_begin() const {
    return const_value_iterator(static_cast<DerivedCounter const *>(this), 0);
  }
 
  const_value_iterator value_end() const {
    return const_value_iterator(static_cast<DerivedCounter const *>(this),
                                size());
  }
 
  bool compare(const value_type &A, const value_type &B) {
    return m_compare(A, B);
  }
 
  const Container &current() const { return m_current; }
 
  const value_type &current(size_type index) const {
    return m_access(m_current, index);
  }
 
  const Container &operator()() const { return m_current; }
 
  const Container &initial() const { return m_initial; }
 
  const Container & final() const { return m_final; }
 
  const Container &increment() const { return m_increment; }
 
 protected:
  bool &_valid() { return m_valid; }
 
  const value_type &_current(size_type index) const {
    return m_access(m_current, index);
  }
 
  value_type &_current(size_type index) { return m_access(m_current, index); }
 
  Container &_current() { return m_current; }
 
  const value_type &_initial(size_type index) const {
    return m_access(m_initial, index);
  }
 
  value_type &_initial(size_type index) { return m_access(m_initial, index); }
 
  const value_type &_final(size_type index) const {
    return m_access(m_final, index);
  }
 
  value_type &_final(size_type index) { return m_access(m_final, index); }
 
  const value_type &_increment(size_type index) const {
    return m_access(m_increment, index);
  }
 
  value_type &_increment(size_type index) {
    return m_access(m_increment, index);
  }
 
  const value_type &_upper(size_type index) const {
    return m_access(m_upper, index);
  }
 
  value_type &_upper(size_type index) { return m_access(m_upper, index); }
 
  const value_type &_lower(size_type index) const {
    return m_access(m_lower, index);
  }
 
  value_type &_lower(size_type index) { return m_access(m_lower, index); }
 
 private:
  Access m_access;
 
  Compare m_compare;
 
  Container m_initial;
 
  Container m_final;
 
  Container m_increment;
 
  Container m_lower;
 
  Container m_upper;
 
  Container m_current;
 
  bool m_valid;
};
 
}  // namespace CASM
 
#endif