BaseCounter.hh

Go to the documentation of this file.

#ifndef BASECOUNTER_HH
#define BASECOUNTER_HH

#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 size_type;

    CounterValueIterator(CounterType const *_counter_ptr = nullptr, size_type _ind = 0) : m_counter_ptr(_counter_ptr), m_ind(_ind) {}
    //CounterValueIterator(const CounterValueIterator &_it);

    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;
    }

    const value_type &operator*() const {
      return (*m_counter_ptr)[m_ind];
    }
    value_type const *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 CASM_TMP::traits<DerivedCounter>::Container Container;
    typedef typename CASM_TMP::traits<DerivedCounter>::value_type value_type;
    typedef typename CASM_TMP::traits<DerivedCounter>::size_type size_type;
    typedef typename CASM_TMP::traits<DerivedCounter>::Access Access;
    typedef typename CASM_TMP::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;

  };

}

#endif