Counter.hh

Go to the documentation of this file.

#ifndef COUNTER_HH
#define COUNTER_HH

#include "casm/container/BaseCounter.hh"

namespace CASM {

  template<typename _Container, typename _value_type, typename _size_type, typename _Access, typename _Compare>
  class Counter;

  namespace CASM_TMP {
    template<typename _Container, typename _value_type, typename _size_type, typename _Access, typename _Compare>
    struct traits<Counter<_Container, _value_type, _size_type, _Access, _Compare> > {
      typedef BaseCounter<Counter<_Container, _value_type, _size_type, _Access, _Compare> > Base;
      typedef _Container Container;
      typedef _value_type value_type;
      typedef _size_type size_type;
      typedef _Access Access;
      typedef _Compare Compare;
    };
  }

  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> >
  class Counter : public BaseCounter<Counter<_Container, _value_type, _size_type, _Access, _Compare> > {
    typedef typename CASM_TMP::traits<Counter>::Base Base;
    using Base::_valid;
    using Base::_current;
    using Base::_increment;
    using Base::_upper;
    using Base::_lower;
    using Base::_initial;
    using Base::_final;
  public:
    typedef _Container Container;
    typedef _value_type value_type;
    typedef _size_type size_type;
    typedef _Access Access;
    typedef _Compare Compare;

    using Base::valid;
    using Base::initial;
    using Base::current;
    using Base::size;
    using Base::compare;
    using Base::operator();
    using Base::operator[];
    using Base::operator bool;

    Counter() {}


    Counter(const Container &_initial,
            const Container &_final,
            const Container &_increment,
            Access _access = Access(),
            Compare _compare = Compare()) :
      Base(_initial, _final, _increment, _access, _compare) {
      _init();
    }

    Counter &operator++() {
      if(!valid())
        return *this;
      size_type i = 0;
      while(compare(_upper(i), _current(i) + _increment(i)) ||
            compare(_current(i) + _increment(i), _lower(i))) {
        _current(i) = _initial(i);
        i++;
        if(i == this->size()) {
          _valid() = false;
          return *this;
        }
      }
      _current(i) += _increment(i);
      return *this;
    }

    void operator++(int) {
      ++(*this);
    }

    void set_current(const Container &new_current) {
      if(current().size() != new_current.size()) {
        std::cerr << "CRITICAL ERROR: In IsoCounter::set_current(), new state is incompatible with this counter.\n"
                  << "                Exiting...\n";
        exit(1);
      }
      _current() = new_current;
      _compute_validity();
    }


    void reset() {
      _current() = initial();
      _valid() = size() != 0;
    };

  private:
    void _init() {
      for(size_type i = 0; i < initial().size(); i++) {
        if(compare(_initial(i), _final(i))) {
          _lower(i) = _initial(i);
          _upper(i) = _final(i);
        }
        else {
          _lower(i) = _final(i);
          _upper(i) = _initial(i);
        }
      }
    }

    bool _compute_validity() {
      _valid() = true;
      for(size_type i = 0; i < size() && valid(); i++) {
        _valid() = valid()
                   && compare(_current(i), _upper(i))
                   && compare(_lower(i), _current(i));
      }
      return valid();
    }

  };


  template <typename EigenType>
  using EigenCounter = Counter< EigenType, typename EigenType::Scalar, typename EigenType::Index,
        CASM_TMP::ParenthesesAccess< EigenType, typename EigenType::Scalar, typename EigenType::Index> >;

  typedef EigenCounter<Eigen::VectorXd> EigenVectorXdCounter;
  typedef EigenCounter<Eigen::MatrixXd> EigenMatrixXdCounter;
  typedef EigenCounter<Eigen::Matrix3d> EigenMatrix3dCounter;
  typedef EigenCounter<Eigen::Vector3d> EigenVector3dCounter;
  typedef EigenCounter<Eigen::Vector3i> EigenVector3iCounter;
  typedef EigenCounter<Eigen::VectorXi> EigenVectorXiCounter;
  typedef EigenCounter<Eigen::MatrixXi> EigenMatrixXiCounter;
  typedef EigenCounter<Eigen::Matrix3i> EigenMatrix3iCounter;
}


#endif