AbstractLinAlgPack_TransSparseCOOElementViewIter.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 TRANS_SPARSE_COO_ELEMENT_VIEW_ITER_H
#define TRANS_SPARSE_COO_ELEMENT_VIEW_ITER_H

#include <iterator>

#include "AbstractLinAlgPack_Types.hpp"

namespace AbstractLinAlgPack {

template <class T_Iter, class T_IterCat, class T_Indice, class T_ValRef, class T_Diff>
class TransSparseCOOElementViewIter {
public:

  template <class TT_Iter, class TT_IterCat, class TT_Indice, class TT_ValRef, class TT_Diff>
  class ElementView {
  public:

    // friends

    friend
    class TransSparseCOOElementViewIter<TT_Iter,TT_IterCat,TT_Indice,TT_ValRef,TT_Diff>;

    // typedefs

    typedef TT_Indice           indice_type;
    typedef TT_ValRef           value_ref_type;

    ElementView(const TT_Iter& iter) : encap_iter_(iter)
    {}

    // access functions

    value_ref_type value() const {
      return encap_iter_->value();
    }

    indice_type row_i() const {
      return encap_iter_->col_j();
    }

    indice_type col_j() const {
      return encap_iter_->row_i();
    }

  private:
    TT_Iter encap_iter_;// iterator that is manipulated by
              // the host iterator

    // not defined and not to be called
    ElementView();
    ElementView& operator=(const ElementView&);
  };

  // Local typedefs

  typedef ElementView<T_Iter,T_IterCat,T_Indice
              ,T_ValRef,T_Diff>       element_view_type;
  typedef T_Iter                      encap_iter_type;
  typedef TransSparseCOOElementViewIter<T_Iter,T_IterCat
                ,T_Indice,T_ValRef,T_Diff>  iterator_type;

  // Standard C+ library types for iterators

  typedef T_IterCat                   iterator_category;
  typedef element_view_type               value_type;
  typedef element_view_type&                reference_type;
  typedef element_view_type*                pointer_type;
  typedef T_Diff                      difference_type;
  typedef size_t                      distance_type;

  //  end Public Types


  TransSparseCOOElementViewIter(T_Iter itr) : element_view_(itr)
  {}



  // Access
  reference_type    operator*() const {
    return const_cast<element_view_type&>(element_view_);
  }
  pointer_type    operator->() const {
    return const_cast<element_view_type*>(&element_view_);
  }
  value_type      operator[](distance_type n) const {
    return element_view_type(element_view_.encap_iter_ + n);
  }
  // Incrementation
  // ++itr
  iterator_type&    operator++() {
    element_view_.encap_iter_++;
    return *this;
  }
  // itr++
  const iterator_type operator++(int) {
    iterator_type tmp = *this;
    ++*this;
    return tmp;
  }
  // --itr
  iterator_type&    operator--() {
    element_view_.encap_iter_--;
    return *this;
  }
  // itr--
  const iterator_type operator--(int) {
    iterator_type tmp = *this;
    --*this;
    return tmp;
  }
  // itr + n 
  iterator_type     operator+(distance_type n) {
    return iterator_type(element_view_.encap_iter_ + n);
  }
  const iterator_type   operator+(distance_type n) const {
    return iterator_type(element_view_.encap_iter_ + n);
  }
  // itr += n
  iterator_type&    operator+=(distance_type n) {
    element_view_.encap_iter_ += n;
    return *this;
  }
  // itr - n
  iterator_type     operator-(distance_type n) {
    return iterator_type(element_view_.encap_iter_ - n);
  }
  const iterator_type operator-(distance_type n) const {
    return iterator_type(element_view_.encap_iter_ - n);
  }
  // itr -= n
  iterator_type&    operator-=(distance_type n) {
    element_view_.encap_iter_ -= n;
    return *this;
  }
  // distance = itr1 - itr2 (distance between elements)
  distance_type   operator-(const iterator_type& itr) const {
    return element_view_.encap_iter_ - itr.element_view_.encap_iter_;
  }



  // <
  bool operator<(const iterator_type& itr)
  { 
    return element_view_.encap_iter_ < itr.element_view_.encap_iter_;
  }
  // <=
  bool operator<=(const iterator_type& itr)
  { 
    return element_view_.encap_iter_ <= itr.element_view_.encap_iter_;
  }
  // >
  bool operator>(const iterator_type& itr)
  { 
    return element_view_.encap_iter_ > itr.element_view_.encap_iter_;
  }
  // >=
  bool operator>=(const iterator_type& itr)
  { 
    return element_view_.encap_iter_ >= itr.element_view_.encap_iter_;
  }
  // ==
  bool operator==(const iterator_type& itr)
  { 
    return element_view_.encap_iter_ == itr.element_view_.encap_iter_;
  }
  // !=
  bool operator!=(const iterator_type& itr)
  { 
    return element_view_.encap_iter_ != itr.element_view_.encap_iter_;
  }


private:
  element_view_type element_view_;
  
  // not defined and not to be called
  TransSparseCOOElementViewIter();

};  // end class TransSparseCOOElementViewIter

// ///////////////////////////////////////////////////////////////////////////////////////
// Nonmember functions

// Allow distance_type as lhs argument in n + itr

//template <class Iter, class Cat, class Indice, class ValRef, class Diff>
//inline TransSparseCOOElementViewIter<Iter,Cat,Indice,ValRef,Diff>
//operator+(Diff n, TransSparseCOOElementViewIter<Iter,Cat,Indice,ValRef,Diff> itr)
//{
//  return itr + n;
//}

template <class Iter, class Cat, class Indice, class ValRef, class Diff>
inline TransSparseCOOElementViewIter<Iter,Cat,Indice,ValRef,Diff>
operator+(Diff n, const TransSparseCOOElementViewIter<Iter,Cat,Indice,ValRef,Diff> itr)
{
  return itr + n;
}

} // end namespace AbstractLinAlgPack 

#endif // TRANS_SPARSE_COO_ELEMENT_VIEW_ITER_H