+ 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.h

Go to the documentation of this file.

// -*-c++-*-
//----------------------------< /-/ CLARAty /-/ >------------------------------
/**
 * @file  2d_array.h
 *
 * Defines a two dimensional array class and its functionality. The
 * two-dimensional array serves as a base class for math Matrix,
 * Vector and Image classes.  2D_Array class allocates continguous
 * memory for the arrays and carries out matrix indexing and some
 * basic operations such as == comparsions. This class requires and
 * guarantees that the elements are contiguous (but not necessarily
 * the memory allocated inside each element).
 *
 * <br>@b Designer(s):  Issa A.D. Nesnas 
 * <br>@b Author(s):    Issa A.D. Nesnas, Clay Kunz
 * <br>@b Date:         March 22, 2001
 *
 * <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>
 *
 * $Revision: 1.8 $
 */
//-----------------------------------------------------------------------------

#ifndef N_2D_ARRAY_H
#define N_2D_ARRAY_H

#include "claraty/share.h"
#include "claraty/2d_array_iterator.h"
#include "claraty/reference_count.h"
#include "claraty/2d_point.h"
#include "claraty/fdm.h"

#include <iostream>
#include <iomanip>
#include <assert.h>

namespace claraty {

/**
 * @ingroup math_data_structure
 */

// Forward declarations

template <class T> class N_2D_array;
typedef N_2D_Array<double> N_2D_Array_d;

//------------------------------------------------------------------------
//----------------------------< 2D_Array Class >--------------------------
//------------------------------------------------------------------------

template <typename T>
class N_2D_Array {

public:
  enum SIZE_TYPE { SQUARE, 
                   EQUALS,
                   NCOLS_EQUALS_NROWS };

  typedef T value_type;
  typedef value_type* pointer;
  typedef const value_type* const_pointer;
  typedef N_2D_Array_Iterator<T> iterator;
  typedef N_2D_Array_const_Iterator<T> const_iterator;
  typedef value_type& reference;
  typedef const value_type& const_reference;
  typedef size_t size_type;
  typedef ptrdiff_t difference_type;

protected: 
  // _mem_height isn't needed for any internals - it's just ept so that the
  // user can ask for it.
  int _num_of_rows, _num_of_cols, _mem_width, _mem_height;

  T   *_elements;
  T  **_index;

  T   *_mem_base;
  Reference_Count *_ref_count;

  bool _isSubarray;

public:

  // Constructors - not inherited
  //
  N_2D_Array()
    : _num_of_rows(0), 
      _num_of_cols(0), 
      _mem_width(0), 
      _mem_height(0),
      _elements(NULL), 
      _index(NULL), 
      _mem_base(0) 
  {
    _ref_count = new Reference_Count(1);
    _isSubarray = false;
  }

  N_2D_Array(int n_rows, int n_cols);

  // This constructor can be used to build an array from a sequence, passing
  // in an iterator as the third argument, or to build an array from a single
  // element, which will be copied into every element of the array. If the
  // type of argument three is the same as the type T of the array, then the
  // value is interpreted as a "filler" value to be copied into each element,
  // rather than as an iterator. The specialization happens in the _copy
  // function, declared below.
  template <class In>
  N_2D_Array(int n_rows, int n_cols, In start) {
    _init(n_rows, n_cols);
    _copy(start);
    _ref_count = new Reference_Count(1);
  }

  N_2D_Array(const N_2D_Array& m);

  // Subarray constructor. Subarrays are shallow copies of their parents, with
  // windows into shared data, which is reference-counted.
  N_2D_Array(const N_2D_Array& parent, int left, int top, int width, int height);

  // Assignments - not inherited
  //
  N_2D_Array& operator=  (const T&   rhs);        // Scalar Op - not inherited
  N_2D_Array& operator=  (const N_2D_Array& rhs);   // Array Op - not inherited

  virtual ~N_2D_Array() {
    _ref_count->decrement();
    delete [] _index;
    if (_ref_count->get_value() == 0) {
      delete [] _mem_base;
      delete _ref_count;
    }
  }

  template <class In>
  N_2D_Array& set_diagonal(int size, In start);

  N_2D_Array& set_diagonal(const N_2D_Array<T>& a) {
    return set_diagonal(a.get_size(), a.begin());
  }

  // Return matrix dimensions
  //
  int get_size() const { return _num_of_rows*_num_of_cols; }

  // ncols() is a short form of the original get_num_of_cols()
  int ncols() const { return _num_of_cols; }
  int get_num_of_cols() const { return _num_of_cols; }
  
  // nrows() is a short form of the original get_num_of_rows()
  int nrows() const { return _num_of_rows; }
  int get_num_of_rows() const { return _num_of_rows; }
  
  bool is_square() const { return _num_of_rows == _num_of_cols; }

  // This resizes the array, destroying its contents and re-allocating the
  // underlying space. It cannot be used on subarrays.
  // This has to be inlined here, or else a bug in the sparcSol2.6-CC compiler
  // surfaces, and there are link errors.
  //  virtual void resize(int newNumRows, int newNumCols) {

// had to comment virtual because it was causing warnings once we added resize function for N1D_Array: implementetion ofN1D_Array::resize hides N_2D_Array::resize. Warnings aren't generated once virtual is removed here.
    void resize(int newNumRows, int newNumCols) {
    if (_num_of_rows != newNumRows || _num_of_cols != newNumCols) {
      if (_isSubarray) {
        std::cerr << "N_2D_Array::resize cannot be used on a subarray!"
                  << std::endl;
        // throw exception
      } else if (_ref_count->get_value() != 1) {
        std::cerr << "N_2D_Array::resize cannot be used on an array being "
          "shared by subarrays" << std::endl;
        // throw exception
      } else if (get_size() == newNumRows * newNumCols &&
                 get_size() != 0) {
        delete [] _index;
        _num_of_rows = newNumRows;
        _num_of_cols = newNumCols;
        _mem_width = newNumCols;
        _mem_height = newNumRows;
        _init_index(true);
      } else {
        // total array size is different - reallocate everything. technically,
        // we could check the number of rows, and save a new/delete cycle on
        // the _index, but it's not that big of a deal if we're reallocating
        // the underlying data space anyway.
        delete [] _mem_base;
        delete [] _index;
        _init(newNumRows, newNumCols);
      }
    }
  }

  bool is_subarray() const { return _isSubarray; }

  // Iterator creators
  iterator begin() {
    return iterator(_elements, _is_noncontiguous(), _num_of_cols, _mem_width);
  }
  const_iterator begin() const {
    return const_iterator(_elements, _is_noncontiguous(), _num_of_cols,
                          _mem_width);
  }
  iterator end() {
    return iterator(_elements + _num_of_rows * _mem_width,
                    _is_noncontiguous(), _num_of_cols, _mem_width);
  }
  const_iterator end() const {
    return const_iterator(_elements + _num_of_rows * _mem_width,
                          _is_noncontiguous(), _num_of_cols, _mem_width);
  }

  // Subarray manipulation functions. These are not range-checked or
  // bounds-checked, so be sure you know your "parent" array dimensions before
  // changing the size or location of a subarray.
  
  // Move the subarray window into the parent array by the given
  // offset. Returns *this.
  N_2D_Array& displace_subarray(int delta_x, int delta_y);

  // Change the size and/or location of the subarray window into the
  // parent. Note that this sets the window with respect to the topmost parent
  // array (i.e. the actual memory buffer), which may not be the array that
  // this was created from. Returns *this.
  N_2D_Array& resize_subarray(int left, int top, int width, int height);

  // Makes this array a sub-array of another array. This can only be done on
  // arrays that have size zero (that have been built with the default
  // constructor or with initial size 0, 0) -- typically this isn't necessary,
  // since one can use the subarray constructor directly.
  N_2D_Array& associate_subarray(const N_2D_Array& parent,
                               int left, int top, int width, int height);

  // Returns the width (number of columns) of the topmost parent array.
  int get_full_num_cols() const { return _mem_width; }
  // Returns the height (number of rows) of the topmost parent array.
  int get_full_num_rows() const { return _mem_height; }

  // Dissociate relationship with shared memory block or parent if a
  // subarray and create a new memory block.  If the optional
  // arguments are specified they will be used for the new dimensions,
  // otherwise the dimensions will be kept the same as they were
  // before.  If the new size is the same as the old size and the
  // memory block is not shared, this does nothing.  Either way, it is
  // guaranteed after this operation that the memory will not be
  // shared.
  void dissociate(int new_nrows=-1, int new_ncols=-1) {
    int nrows = new_nrows, ncols = new_ncols;
    if(nrows < 0) {
      nrows = _num_of_rows;
    }
    if(ncols < 0) {
      ncols = _num_of_cols;
    }
    
    if (_isSubarray) {
      _isSubarray = false;
      _num_of_rows = 0;    // force re-allocation / compaction
      _num_of_cols = 0;
    }
    if (_ref_count->get_value() != 1) {
      _ref_count->decrement();
      _mem_base = 0;    // to prevent destruction of shared space on resize
      _num_of_rows = 0; // force re-allocation
      _num_of_cols = 0;
      _ref_count = new Reference_Count(1);  // get an independent reference count
    }
    // Resize if necessary
    if((nrows != _num_of_rows) || (ncols != _num_of_cols)) {
      resize(nrows, ncols);
    }
  }


  // Return rows and cols
  N_2D_Array<T> get_row(int row) const;
  N_2D_Array<T> get_col(int col) const;

  const T *get_row_pointer(int row) const { return _index[row]; }
  
  iterator column_iterator(int col) {
    return iterator(_elements + col, true, 1, _mem_width);
  }
  const_iterator column_iterator(int col) const {
    return const_iterator(_elements + col, true, 1, _mem_width);
  }
  

  // Indexing for read and write operations. Using the _index is 2.5 times
  // faster than using the _elements[r*_num_of_cols+c].
  //
  T& operator()(int r, int c) { return _index[r][c]; }
  const T& operator()(int r, int c) const { return _index[r][c]; }

  // more explicit indexing operators, to keep order of operations from
  // getting confused
  T& rc(int row, int column) { return operator()(row, column); }
  const T& rc(int row, int column) const { return operator()(row, column); }

  T& xy(int x, int y) { return operator()(y, x); }
  const T& xy(int x, int y) const { return operator()(y, x); }

  T& xy(const N_2D_Point_i &p) { return xy(p.x(), p.y()); }
  const T& xy(const N_2D_Point_i &p) const { return xy(p.x(), p.y()); }
  
  // Writes the whole array to the stream (operator<< only writes the
  // first 10 rows and columns).
  void write(std::ostream& os) const;

  // Conversion operators
  //
  // bool operator (see function definition)
 
  operator void *() const;              

  // N_2D_Array operations
  //
  N_2D_Array operator== (const N_2D_Array& rhs) const;       // Array Op
  N_2D_Array transpose() const;             

  bool io(FDM_Map map);

protected: 
  // This is a dangerous operation, which will definately fail on subarrays,
  // and is only provided for quick element lookup, when you know doing this
  // will do the right thing.
  T& element(int i) { return _elements[i]; }
  const T& element(int i) const { return _elements[i]; }

  // this is evil, but may be necessary to avoid unnecessary double allocation
  // on large block copies (like image grabs from framegrabbers)
  T *get_data() { assert(!is_subarray()); return _mem_base; }
  const T *get_data() const { assert(!is_subarray()); return _mem_base; }

protected: 

  template <class In>
  void    _copy         (In start);         // copy from sequence

  void    _copy         (T filler);  // fill array with filler

  template <class rhsType>
  int     _check_size   (SIZE_TYPE type, const N_2D_Array<rhsType>& rhs) const;

  // For subclasses that do their own memory management, these functions are
  // provided to short-circuit the allocation and deallocation of the
  // _elements array. The _init_special function allows the subclass to set
  // the pointers to reasonable values (so that the _index can be created
  // correctly), while allowing allocation to be skipped.
  void _init_special(int nr, int nc, T *data, int memwidth);
  void _drop_memory() {
    _elements = NULL;
    _mem_base = NULL;
  }

  // it's helpful for derived classes to have access to these (e.g. for resize f-n)
//private:
  void    _init         (int n_rows, int n_cols);
  void    _init_index(bool allocate = true);

  // returns true if the elements of the array are in noncontiguous memory
  // (i.e. this is a subarray which doesn't span the width of the parent).
  bool _is_noncontiguous() const {
    return _num_of_cols != _mem_width;
  }
};
//------------------------------------------------------------------------










//------------------------------------------------------------------------- 
//---------------------< N_2D_Array Member Functions >-----------------------
//------------------------------------------------------------------------- 

template <class T>
void N_2D_Array<T>::_init_special(int n_rows, int n_cols, T *data, int memwidth)
{
  _num_of_rows = n_rows;
  _num_of_cols = n_cols;
  _mem_width = memwidth;

  _elements = data;
  _mem_base = data;

  _init_index();
}

template <class T>
void N_2D_Array<T>::_init(int n_rows, int n_cols)
{
  // Allocate contiguous space for all the elements in the array.

  // Init only gets called on non-subarray
  _isSubarray = false;

  _num_of_rows = n_rows;
  _num_of_cols = n_cols;
  _mem_width = _num_of_cols;
  _mem_height = _num_of_rows;

  if (n_rows==0 || n_cols==0) {
    _elements = NULL;
    _mem_base = NULL;
    _index = NULL;
    return; 
  }

  _mem_base = new T[n_rows*n_cols];
  _elements = _mem_base;

  // Copy pointer to the beginning of every row into index pointer array
  //
  _init_index();
}
//------------------------------------------------------------------------- 

template <class T>
void N_2D_Array<T>::_init_index(bool allocate)
{
  // Allocate memory for the row pointers. These are needed to address the 
  // individual elements of the matrix using the index **
  
  typedef T* p_T;

  if (allocate)
    _index = new p_T[_num_of_rows];

  // Initialize index vector that points to the beginning of every row
  int i;
  T *p_row;
  for (i = 0, p_row = _elements; i < _num_of_rows; i++, p_row += _mem_width)
    _index[i]= p_row;
}
//------------------------------------------------------------------------- 
template <class T>
template <class In>
void N_2D_Array<T>::_copy(In start)
{
  if (is_subarray()) {
    iterator it = begin(), last = end();
    for (; it != last; ++it, ++start)
      *it = (int)*start; // compiler warning *it is an int
  } else {
    T *it = _elements, *last = _elements + _num_of_rows * _num_of_cols;
    for (; it != last; ++it, ++start)
      *it = (int)*start; // compiler waring *it is an int
  }    
}
//-------------------------------------------------------------------------

template <class T>
void N_2D_Array<T>::_copy(T filler)
{
  iterator it = begin(), last = end();
  for (; it != last; ++it)
    *it = filler;
}

//-------------------------------------------------------------------------
// CONSTRUCTORS
//-------------------------------------------------------------------------


template <class T>
N_2D_Array<T>::N_2D_Array(int num_of_rows, int num_of_cols)
{
  // elements are created using the default constructor (so may have undefined
  // values)
  _init(num_of_rows, num_of_cols);
  _ref_count = new Reference_Count(1);
}
//-------------------------------------------------------------------------

template <class T>
N_2D_Array<T>::N_2D_Array(const N_2D_Array& m)
{
  _init(m._num_of_rows, m._num_of_cols);
  if (m.is_subarray())
    _copy(m.begin());
  else
    _copy(m._elements);
  _ref_count = new Reference_Count(1);

  // cout << "N_2D_Array constructor N_2D_Array(const N_2D_Array&)" << std::endl;
}
//-------------------------------------------------------------------------

template <class T>
N_2D_Array<T>::N_2D_Array(const N_2D_Array& parent, int left, int top, int width,
                      int height)
  : _num_of_rows(height), _num_of_cols(width),
    _mem_width(parent._mem_width), _mem_height(parent._mem_height),
    _mem_base(parent._mem_base), _ref_count(parent._ref_count)
{
  _isSubarray = true;
  _ref_count->increment();
  _elements = parent._elements + top * _mem_width + left;
  _init_index();
}

//-------------------------------------------------------------------------

template <class T>
template <class In>
N_2D_Array<T>& N_2D_Array<T>::set_diagonal(int size, In start) 
{
  if (!is_square()) 
    std::cerr << "matrix error: cannot set diagonal on a non-square matrix"
              << std::endl;
  else if (size!=_num_of_cols) 
    std::cerr << "matrix error: number of diagonal elements (" << size << ") "
              << "is not the same as matrix dimension of " << _num_of_cols
              << std::endl;
  else 
    for (int i = 0; i < _num_of_cols; ++i, ++start)
      operator()(i, i) = *start;
  return *this;
}

//-------------------------------------------------------------------------

template <class T>
N_2D_Array<T>& N_2D_Array<T>::displace_subarray(int delta_x, int delta_y)
{
  if (!_isSubarray) { // @@ This should throw an exception
    std::cerr << "N_2D_Array::displace_subarray requires *this to be a subarray!"
         << std::endl;
    return *this;
  }
  size_t offset = delta_y * _mem_width + delta_x;
  _elements += offset;
  for (int i = 0; i < _num_of_rows; i++)
    _index[i] += offset;
  return *this;
}
//-------------------------------------------------------------------------

template <class T>
N_2D_Array<T>& N_2D_Array<T>::resize_subarray(int left, int top,
                                          int width, int height)
{
  if (!_isSubarray) { // @@ This should throw an exception
    std::cerr << "N_2D_Array::resize_subarray requires *this to be a subarray!"
         << std::endl;
    return *this;
  }
  _num_of_cols = width;
  _elements = _mem_base + top * _mem_width + left;
  if (height == _num_of_rows) {
    // same number of rows - don't reallocate the _index
    _init_index(false);
  } else {
    _num_of_rows = height;
    delete [] _index;
    _init_index();
  }
  return *this;
}
//-------------------------------------------------------------------------

template <class T>
N_2D_Array<T>& N_2D_Array<T>::associate_subarray(const N_2D_Array& parent,
                                             int left, int top,
                                             int width, int height)
{
  if (_isSubarray || _elements != NULL || _index != NULL) {
    std::cerr << "N_2D_Array::associate_subarray: this function can only be used "
      "on uninitialized arrays" << std::endl;
    return *this;
  }
  delete _ref_count;
  _ref_count = parent._ref_count;
  _ref_count->increment();
  _isSubarray = true;

  _num_of_rows = height;
  _num_of_cols = width;
  _mem_width = parent._mem_width;
  _mem_height = parent._mem_height;
  _mem_base = parent._mem_base;
  _elements = parent._elements + top * _mem_width + left;
  _init_index();
  return *this;
}

//-------------------------------------------------------------------------

template <class T>
N_2D_Array<T> N_2D_Array<T>::get_row(int row) const
{
  if (row < 0 || row > _num_of_rows) {
    std::cerr << "array error: row " << row << " exceeds matrix number of rows = " 
         <<  _num_of_cols << std::endl;
    return N_2D_Array<T>();
  }
  else 
    return N_2D_Array<T>(1, _num_of_cols, _index[row]);
}
//-------------------------------------------------------------------------

template <class T>
N_2D_Array<T> N_2D_Array<T>::get_col(int col) const
{
  if (col < 0 || col > _num_of_cols) {
    std::cerr << "array error: col " << col << " exceeds matrix number of columns = " 
         <<  _num_of_cols << std::endl;      
    return N_2D_Array<T>();
  }
  else {
    N_2D_Array<T> col_array(_num_of_rows, 1);
    for (int row = 0; row < _num_of_rows; row++)
      col_array(row, 0) = operator()(row, col);
    return col_array;
  }
}
//-------------------------------------------------------------------------

template <class T>
N_2D_Array<T>::operator void *() const
{
  // Bool operator but using void * instead to avoid direct conversion to int
  // so when you type 3*array, you do not get 3, rather you get a compile error

  for (const_iterator it = begin(); it != end(); ++it)
    if (*it == 0)
      return (void *)false;
  return (void *)true;
}
//-------------------------------------------------------------------------

template <class T>
N_2D_Array<T>& N_2D_Array<T>::operator=(const T& filler)
{
  _copy(filler);
  return *this;
}
//-------------------------------------------------------------------------

template <class T>
N_2D_Array<T>& N_2D_Array<T>::operator=(const N_2D_Array& rhs)
{
  if (this == &rhs) return *this;
  
  resize(rhs.get_num_of_rows(), rhs.get_num_of_cols());

  _copy(rhs.begin());

  return *this;
}
//-------------------------------------------------------------------------
// RETURNS OBJECT

template <class T> 
N_2D_Array<T> N_2D_Array<T>::transpose() const
{ 
  N_2D_Array tmp(_num_of_cols, _num_of_rows);
  iterator it_tmp = tmp.begin();
  for (int i = 0; i < _num_of_cols; ++i) 
    for (int j = 0; j < _num_of_rows; ++j, ++it_tmp)
      *it_tmp = operator()(j, i);
  return tmp;
}
//-------------------------------------------------------------------------
// RETURNS OBJECT

template <class T> 
N_2D_Array<T> N_2D_Array<T>::operator==(const N_2D_Array& rhs) const 
{ 
  if (this == &rhs) return N_2D_Array(_num_of_rows, _num_of_cols, (T)true); 

  if (_check_size(EQUALS, rhs) == ERROR) {
    // MUST THROW AN EXCEPTION HERE, BUT FOR NOW
    return N_2D_Array(1, 1, (T)false);
  }

  N_2D_Array result(_num_of_rows, _num_of_cols);
  const_iterator it_lhs = begin(), it_rhs = rhs.begin();
  iterator it_res = result.begin();
  for (int i = 0; i < get_size(); ++i, ++it_lhs, ++it_rhs, ++it_res) 
    *it_res = (*it_lhs == *it_rhs);
  return result;
}
//-------------------------------------------------------------------------

template <class T>
void N_2D_Array<T>::write(std::ostream& os) const
{
  std::ios::fmtflags oldBase;
  int oldPrecision;

  os << "size: (" << get_num_of_rows() << ", " << get_num_of_cols()
     << " )" << std::endl;
  os.setf(std::ios::showpoint);

  if (sizeof(T)==1) {
    oldBase = os.setf(std::ios::hex, std::ios::basefield);
  } 
  else {
    oldPrecision = os.precision();
    os.precision(4);
  }

  if (get_num_of_cols() != 0)
    for (int i = 0; i < get_num_of_rows(); ++i) {
      os << "[ ";
      for (int j = 0; j < get_num_of_cols(); ++j) {
        const T& el = rc(i, j);
        os << " " << std::setw(8) << el;
      }
      os << " ]" << std::endl;
    }
  if (sizeof(T)==1) 
    os.setf(oldBase, std::ios::basefield);
  else
    os.precision(oldPrecision);
}

//-------------------------------------------------------------------------

template <class T>
std::ostream& operator<<(std::ostream& os, const N_2D_Array<T>& m)
{
  std::ios::fmtflags oldBase;
  int oldPrecision;

  os << "size: (" << m.get_num_of_rows() << ", " << m.get_num_of_cols()
     << " )" << std::endl;

  os.setf(std::ios::showpoint);

  if (sizeof(T)==1) {
    oldBase = os.setf(std::ios::hex, std::ios::basefield);
  } 
  else {
    oldPrecision = os.precision();
    os.precision(4);
  }

  if (m.get_num_of_cols() != 0)
    for (int i = 0; i < cl_min(10, m.get_num_of_rows()); ++i) {
      os << "[ ";
      for (int j = 0; j < cl_min(10, m.get_num_of_cols()); ++j) {
        const T& el = m(i, j);
        os << " " << std::setw(8) << ((sizeof(T)==1) ? (int)el : el);
      }
      os << " ]" << std::endl;
    }
  if (sizeof(T)==1) 
    os.setf(oldBase, std::ios::basefield);
  else
    os.precision(oldPrecision);

  return os;
}
//-------------------------------------------------------------------------

template <class T>
template <class rhsType>
int N_2D_Array<T>::_check_size (SIZE_TYPE operation, 
                              const N_2D_Array<rhsType>& rhs) const
{
  int status = ERROR;

  switch (operation) {
  case EQUALS:
    status = ((_num_of_rows == rhs.get_num_of_rows()) &&
              (_num_of_cols == rhs.get_num_of_cols())) ? OK : ERROR;
    break;
  case NCOLS_EQUALS_NROWS:
    status = (_num_of_cols == rhs.get_num_of_rows()) ? OK : ERROR; 
    break;
  case SQUARE:
    status = (_num_of_rows == _num_of_cols)  ? OK : ERROR;
    break;
  } // switch

  if (status==ERROR) 
    std::cerr << "Array 2D error: array dimensions do not match lhs(" << _num_of_rows 
         << "x" << _num_of_cols << "), rhs (" << rhs.get_num_of_rows() << "x" 
         << rhs.get_num_of_cols() << ")" << std::endl;

  return status;
}
//-------------------------------------------------------------------------

// i/o flattens an array - subarrays are written just like
// non-shared-memory arrays, and loading into an array always
// repackages the object into its own proper memory space.  It is
// broken up into multiple calls in order to allow subclasses to put
// fields in the same map node.  Note that unlike normal io_object
// routines these use a reference for the node, and should be used
// with care.
template <typename T>
bool N_2D_Array<T>::
io(FDM_Map map)
{
  int nr = nrows(), nc = ncols();

  bool ok = true;

  ok &= map.field("nrows", nr);
  ok &= map.field("ncols", nc);

  // If we're reading, dissociate from any sharing and set to the new
  // size.  If the memory isn't shared and the size hasn't changed,
  // this does nothing.
  if (map.is_read()) {
    dissociate(nr, nc);
  }

  FDM_Array a = map.field_node("elements");

  for (int r = 0; r < nr; r++)
    for (int c = 0; c < nc; c++)
      ok &= a.element(_index[r][c]);
  
  return ok;
}
//------------------------------------------------------------------------

template <typename T>
bool io_object(FDM_Untyped_Node node, N_2D_Array<T>& rhs)
{
  FDM_Map map(node);

  return(rhs.io(map, rhs));
}
//------------------------------------------------------------------------

} // namespace claraty

#endif // N_2D_ARRAY_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