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.
// 
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// 1. Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
//
// 3. Neither the name of the Corporation nor the names of the
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// 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