+ View the NASA Portal

Search JPL

Search CLARAty

- Algorithms- Infrastructure - Doxygen (public)- Doxygen (private)- Tutorials

- Repository- Nightly Build- Nightly Regression- Feature/Bug Tracking- Build Targets- Procedure- Conventions- Tools

2d_array_iterator.h

Go to the documentation of this file.

// -*-c++-*-
//----------------------------< /-/ CLARAty /-/ >------------------------------
/**
 * @file  2d_array_iterator.h
 *
 * This header provides iterator and const_iterator classes for the
 * Array_2D hierarchy. These classes have to exist to support
 * subarrays. They're heavier than simply using pointers, but allow
 * one to use Array_2D's without caring whether or not the underlying
 * memory is contiguous (i.e. without worrying about subarrays).
 *
 * The constructors are private; these can only be built by Array_2D's
 * themselves (and copied from other iterators) -- this is so that we
 * can change the implementation without messing everyone up.
 *
 * <br>@b Designer(s):  Clay Kunz
 * <br>@b Author(s):    Clay Kunz
 * <br>@b Date:         January 9, 2002
 *
 * <b>Software License:</b><br>
 * <code> http://claraty.jpl.nasa.gov/license/open_src/  or 
 *        file: license/open_src.txt </code>
 *
 * &copy; 2006, Jet Propulsion Laboratory, California Institute of Technology<br>
 * &copy; 2006, NASA Ames Research Center
 *
 * $Revision: 1.4 $
 */
//-----------------------------------------------------------------------------

#ifndef N_2D_ARRAY_ITERATOR_H
#define N_2D_ARRAY_ITERATOR_H

#include "claraty/share.h"

#include <stddef.h>
#include <iterator>

namespace claraty {

template <class T> class N_2D_Array;
template <class T> class N_2D_Array_const_Iterator;

// Question: operator==. Should it check just the pointer, or should it check
// everything? Is it enough to point to the same thing, or should it also
// point to the same kind of subarray?

// Also: these iterators are currently bidirectional, but not
// random-access. To support random access operations, these operators need to
// be added: [], +(int), -(int), and -(iterator) for returning the distance
// between two pointers.

template <class T>
class N_2D_Array_Iterator {

  T *ptr;
  int offset;
  const int width, stride;
  const bool fromSubarray;

  friend class N_2D_Array<T>;
  friend class N_2D_Array_const_Iterator<T>;

  N_2D_Array_Iterator(T *pt, bool sub = false, int w = 0, int s = 0)
    : ptr(pt), offset(0), width(w), stride(s), fromSubarray(sub) { }

public:

  typedef std::bidirectional_iterator_tag iterator_category; // needs STL
  typedef T value_type;
  typedef ptrdiff_t difference_type;
  typedef T* pointer;
  typedef T& reference;

  // default operator= and copy ctors are what we want.

  // dereferencing
  T& operator*() { return *ptr; }
  T *operator->() { return ptr; }

  const T& operator*() const { return *ptr; }
  const T *operator->() const { return ptr; }

  bool operator==(const N_2D_Array_Iterator<T>& rhs) const {
    return ptr == rhs.ptr;
  }
  bool operator!=(const N_2D_Array_Iterator<T>& rhs) const {
    return !(*this == rhs);
  }

  // pointer arithmetic
  N_2D_Array_Iterator<T>& operator++() {    // prefix
    ++ptr;
    if (fromSubarray && ++offset == width) {
      ptr = ptr - width + stride;
      offset = 0;
    }
    return *this;
  }
  N_2D_Array_Iterator<T> operator++(int) {  // postfix
    N_2D_Array_Iterator<T> tmp = *this;
    ++*this;
    return tmp;
  }

  N_2D_Array_Iterator<T>& operator--() {    // prefix
    --ptr;
    if (fromSubarray && --offset == -1) {
      ptr = ptr + width - stride;
      offset = 0;
    }
    return *this;
  }
  N_2D_Array_Iterator<T> operator--(int) {  // postfix
    N_2D_Array_Iterator<T> tmp = *this;
    --*this;
    return tmp;
  }
};

template <class T>
class N_2D_Array_const_Iterator {

  const T *ptr;
  int offset;
  const int width, stride;
  const bool fromSubarray;

  friend class N_2D_Array<T>;

  N_2D_Array_const_Iterator(const T *pt, bool sub = false, int w = 0, int s = 0)
    : ptr(pt), offset(0), width(w), stride(s), fromSubarray(sub) { }

public:

  typedef std::bidirectional_iterator_tag iterator_category; // needs STL
  typedef T value_type;
  typedef ptrdiff_t difference_type;
  typedef const T* pointer;
  typedef const T& reference;

  // default operator= and copy ctors are what we want.

  // one more constructor for making a const iterator from a non-const one
  N_2D_Array_const_Iterator(const N_2D_Array_Iterator<T>& rhs)
    : ptr(rhs.ptr), offset(rhs.offset), width(rhs.width), stride(rhs.stride),
      fromSubarray(rhs.fromSubarray)
  {
  }

  // dereferencing
  const T& operator*() const { return *ptr; }
  const T *operator->() const { return ptr; }

  bool operator==(const N_2D_Array_const_Iterator<T>& rhs) const {
    return ptr == rhs.ptr;
  }
  bool operator!=(const N_2D_Array_const_Iterator<T>& rhs) const {
    return !(*this == rhs);
  }

  // pointer arithmetic
  N_2D_Array_const_Iterator<T>& operator++() {    // prefix
    ++ptr;
    if (fromSubarray && ++offset == width) {
      ptr = ptr - width + stride;
      offset = 0;
    }
    return *this;
  }
  N_2D_Array_const_Iterator<T> operator++(int) {  // postfix
    N_2D_Array_const_Iterator<T> tmp = *this;
    ++*this;
    return tmp;
  }

  N_2D_Array_const_Iterator<T>& operator--() {    // prefix
    --ptr;
    if (fromSubarray && --offset == -1) {
      ptr = ptr + width - stride;
      offset = 0;
    }
    return *this;
  }
  N_2D_Array_const_Iterator<T> operator--(int) {  // postfix
    N_2D_Array_const_Iterator<T> tmp = *this;
    --*this;
    return tmp;
  }
};

} // namespace claraty

#endif // N_2D_ARRAY_ITERATOR_H

Last modified: June 05 2007 10:19:53

JPL PRIVACY STATEMENT GLOSSARY SITEMAP FEEDBACK CONTACT US

Site Manager: Issa A.D. Nesnas
Site Maintainer: Kelly Breed
Document Clearance #: CL 07-0635