StrideIterPack_StrideIter.hpp

// @HEADER
// ***********************************************************************
// 
// Moocho: Multi-functional Object-Oriented arCHitecture for Optimization
//                  Copyright (2003) Sandia Corporation
// 
// Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive
// license for use of this work by or on behalf of the U.S. Government.
// 
// This library is free software; you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation; either version 2.1 of the
// License, or (at your option) any later version.
//  
// This library is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//  
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
// USA
// Questions? Contact Roscoe A. Bartlett (rabartl@sandia.gov) 
// 
// ***********************************************************************
// @HEADER

#ifndef STRIDE_ITER_H
#define STRIDE_ITER_H

#include "Moocho_ConfigDefs.hpp"

namespace StrideIterPack {

template<class T_iterator_type, class T_value_type, class T_reference_type
  , class T_pointer_type, class T_difference_type>
class stride_iter {
public:

  typedef std::random_access_iterator_tag           iterator_category;
  typedef T_iterator_type                   iterator_type;
  typedef T_value_type                    value_type;
  typedef T_reference_type                  reference;
  typedef T_pointer_type                    pointer;
  typedef T_difference_type                 difference_type;
  
    

  stride_iter() : current_(0), stride_(0)
  {}
  stride_iter(iterator_type current) :  current_(current), stride_(1)
  {}  
  stride_iter(iterator_type current, difference_type stride) :  current_(current), stride_(stride)
  {}
  template<class Iter, class Val, class Ref, class Ptr, class Diff>
  stride_iter(const stride_iter<Iter,Val,Ref,Ptr,Diff>& rhs) :current_(rhs.current()),stride_(rhs.stride())
  {}
  template<class Iter, class Val, class Ref, class Ptr, class Diff>
  stride_iter & operator=(const stride_iter<Iter,Val,Ref,Ptr,Diff>& rhs) {
    current_ = rhs.current(); stride_ = rhs.stride(); return *this;
  }



  reference   operator*() const {
    return *current_;
  }
  pointer   operator->() const {
    return  current_;
  }
  reference   operator[](difference_type n) const {
    return current_[n * stride_];
  }



  stride_iter&    operator++() {
    current_ += stride_;
    return *this;
  }
  const stride_iter operator++(int) {
    stride_iter tmp = *this;
    ++*this; return tmp;
  }
  stride_iter&    operator--() {
    current_ -= stride_;
    return *this;
  }
  const stride_iter operator--(int) {
    stride_iter tmp = *this;
    --*this; return tmp;
  }
  stride_iter     operator+(difference_type n) {
    return stride_iter(current_ + n * stride_, stride_);
  }
  const stride_iter operator+(difference_type n) const {
    return stride_iter(current_ + n * stride_, stride_);
  }
  stride_iter&    operator+=(difference_type n) {
    current_ += n * stride_;
    return *this;
  }
  stride_iter     operator-(difference_type n) {
    return stride_iter(current_ - n * stride_, stride_);
  }
  const stride_iter operator-(difference_type n) const {
    return stride_iter(current_ - n * stride_, stride_);
  }
  stride_iter&    operator-=(difference_type n) {
    current_ -= n * stride_;
    return *this;
  }


  difference_type   operator-(const stride_iter& itr) const {
    return (current_ - itr.current_)/stride_;
  }


  iterator_type current() const {
    return current_;
  }

  difference_type stride() const {
    return stride_;
  }


private:
  iterator_type     current_;
  difference_type     stride_;
};

// RAB: 2001/11/16: For some reason this \defgroup causing doxygen to crash
// when compiling RTOpPack?

/* \defgroup stride_iter_funcs_grp Non-member functions for StrideIterPack::stride_itr
 * \ingroup Misc_grp
 */
// @{

template<class Iter, class Val, class Ref, class Ptr, class Diff>
inline const stride_iter<Iter,Val,Ref,Ptr,Diff> operator+(Diff n
  , const stride_iter<Iter,Val,Ref,Ptr,Diff> itr) 
{ 
  return itr + n;
}

template<class Iter, class Val, class Ref, class Ptr, class Diff>
inline bool operator<(const stride_iter<Iter,Val,Ref,Ptr,Diff>& itr1, 
            const stride_iter<Iter,Val,Ref,Ptr,Diff>& itr2)
{ 
  return itr1.operator->() < itr2.operator->();
}
template<class Iter, class Val, class Ref, class Ptr, class Diff>
inline bool operator<=(const stride_iter<Iter,Val,Ref,Ptr,Diff>& itr1, 
             const stride_iter<Iter,Val,Ref,Ptr,Diff>& itr2)
{
  return itr1.operator->() <= itr2.operator->();
}
template<class Iter, class Val, class Ref, class Ptr, class Diff>
inline bool operator>(const stride_iter<Iter,Val,Ref,Ptr,Diff>& itr1, 
            const stride_iter<Iter,Val,Ref,Ptr,Diff>& itr2)
{
  return itr1.operator->() > itr2.operator->();
}
template<class Iter, class Val, class Ref, class Ptr, class Diff>
inline bool operator>=(const stride_iter<Iter,Val,Ref,Ptr,Diff>& itr1, 
             const stride_iter<Iter,Val,Ref,Ptr,Diff>& itr2)
{
  return itr1.operator->() >= itr2.operator->();
}
template<class Iter, class Val, class Ref, class Ptr, class Diff>
inline bool operator==(const stride_iter<Iter,Val,Ref,Ptr,Diff>& itr1, 
             const stride_iter<Iter,Val,Ref,Ptr,Diff>& itr2)
{
  return itr1.operator->() == itr2.operator->();
}
template<class Iter, class Val, class Ref, class Ptr, class Diff>
inline bool operator!=(const stride_iter<Iter,Val,Ref,Ptr,Diff>& itr1, 
             const stride_iter<Iter,Val,Ref,Ptr,Diff>& itr2)
{
  return itr1.operator->() != itr2.operator->();
}

// @}

} // end namespace StrideIterPack

#endif // STRIDE_ITER_H