dumbarray.h

Go to the documentation of this file.

#ifndef DUMBARRAY_H
#define DUMBARRAY_H

#include <typedefs.h>


template< typename T>
class dumbarray
{
public:

  T ** xi;

  uint N;

  bool memoryManaged;

  dumbarray(dumbarray<T> const & x);

  dumbarray()
    : xi(0), N(0), memoryManaged(false) {}

  dumbarray
  (
    T ** xi_, 
    uintc N_,
    boolc memoryManaged_
  )
    : xi(xi_), N(N_), memoryManaged(memoryManaged_) {}

  ~dumbarray();

  dumbarray(uintc N_);

  void create(uintc N_);

  void clean();

  void operator = ( dumbarray<T> const & x );

 
  T & operator[](uintc i)
    { return *xi[i]; }

  T const operator[](uintc i) const
    { return *xi[i]; }

  T * & operator () (uint i)
    { return xi[i]; }

};


//----------------------------------------------------------
//  Implementation

template< typename T>
void dumbarray<T>::create(uintc N_)
{
  clean();
  N = N_;
  xi = new T*[N];
  memoryManaged=true;
}

template< typename T>
dumbarray<T>::~dumbarray()
{
  clean();
}


template< typename T>
dumbarray<T>::dumbarray(uintc N_)
  : xi(0), memoryManaged(false)
{
  create(N_);
}

template< typename T>
dumbarray<T>::dumbarray(dumbarray<T> const & x)
{
  xi = x.xi;
  N = x.N;
  memoryManaged = false;
}

template< typename T>
void dumbarray<T>::operator = ( dumbarray<T> const & x )
{
  if (&x==this)
    return;

  clean();

  xi = x.xi;
  N = x.N;
  memoryManaged = false;
}



template< typename T>
void dumbarray<T>::clean()
{
  if (memoryManaged) 
    delete[] xi;
  xi=0;
  N=0;
}



/*

  Purpose

  Why was this class written?  To plug into templates so
  an array could be accessed as a contiguous array but the
  elements are stored anywhere.

  This solves an fundamental problem between C and OOP.  Lets say two
  objects A and B process information in X variables.  If there is no
  global structure which both A and B see then how do they process
  the data efficiently?  The data could be copied. For example A processes
  X and copies it to B. B processes X. A and B are completely separate
  (which is good).

  OOP has a problem that C does not.  Data is locked up in objects which
  are not an array of contiguous memory. Further for efficiency the 
  processing of data is associated with its locality. 
  With this class this information
  can be formed into a contiguous memory (through the underneath pointer).
  
  Remember that in the example processing in A and B is both intensive.
  So if A owns the data then B will have to bend in some way to accomadate
  A.  Where redesignes are not practical the objects in B have the classes
  access A's data by the dumb array. 

*/

#endif