// -*-C++-*-

#ifndef VEC_MASK_H
#define VEC_MASK_H

#include <cstdlib>



namespace vecmathlib {
  
  template<typename realvec_t>
  class mask_t {
    
    typedef typename realvec_t::boolvec_t boolvec_t;
    typedef typename realvec_t::intvec_t intvec_t;
    static const int size = realvec_t::size;
    
  public:
    std::ptrdiff_t imin, imax;
    std::ptrdiff_t i;
    boolvec_t m;
    bool all_m;
    
  public:
    
    // Construct a mask from a boolvec
    mask_t(boolvec_t m_): m(m_), all_m(all(m)) {}
    
    // Construct a mask for a particular location i
    mask_t(std::ptrdiff_t i_,
           std::ptrdiff_t imin_, std::ptrdiff_t imax_, std::ptrdiff_t ioff):
      imin(imin_), imax(imax_), i(i_)
    {
      all_m = i-imin >= 0 && i+size-1-imax < 0;
      if (__builtin_expect(all_m, true)) {
        m = true;
      } else {
        m = (! isignbit(intvec_t(i          - imin) + intvec_t::iota()) &&
               isignbit(intvec_t(i + size-1 - imax) + intvec_t::iota()));
      }
    }
    
    // Construct a mask for a loop starting at imin, aligned down
    mask_t(std::ptrdiff_t imin_, std::ptrdiff_t imax_, std::ptrdiff_t ioff):
      imin(imin_), imax(imax_), i(imin_ - (ioff + imin_) % size)
    {
      all_m = i-imin >= 0 && i+size-1-imax < 0;
      if (__builtin_expect(all_m, true)) {
        m = true;
      } else {
        m = (! isignbit(intvec_t(i          - imin) + intvec_t::iota()) &&
               isignbit(intvec_t(i + size-1 - imax) + intvec_t::iota()));
      }
    }
    
    // Get current index
    std::ptrdiff_t index() const { return i; }
    
    // Looping condition
    operator bool() const { return i<imax; }
    
    // Loop stepper
    void operator++()
    {
      i += size;
      all_m = i + size-1 - imax < 0;
      if (__builtin_expect(all_m, true)) {
        m = true;
      } else {
        m = isignbit(intvec_t(i + size-1 - imax) + intvec_t::iota());
      }
    }
  };
  
} // namespace vecmathlib

#endif  // #ifndef VEC_MASK_H