Search  

---

C:/temp/src/j2k/Beta/Math/Array.cpp

Go to the documentation of this file.

// Implementation of class Array

#include <j2k/Fred/Math/Array.hpp>

#ifndef __J2K__ARRAY_CPP__
#define __J2K__ARRAY_CPP__

#define MC_ClassImpl_Array( NAME, ELEM, DEFAULT_SIZE, ZERO )              \
                                                                          \
UINT Array_##NAME##::arrayCount = 0;                                      \
                                                                          \
Array_##NAME##::Array_##NAME##()                                          \
  : size( DEFAULT_SIZE ), ptr( NULL ) {                                   \
  setSize( DEFAULT_SIZE );                                                \
}                                                                         \
                                                                          \
Array_##NAME##::Array_##NAME##( UINT arraySize )                          \
  : size( arraySize ), ptr( NULL ) {                                      \
  setSize( arraySize );                                                   \
}                                                                         \
                                                                          \
Array_##NAME##::Array_##NAME##( const Array_##NAME##& src )               \
   : size( src.size ), ptr( NULL ) {                                      \
   setSize( src.size );                                                   \
}                                                                         \
                                                                          \
Array_##NAME##::~Array_##NAME##() {                                       \
   delete [] ptr;                                                         \
   --arrayCount;                                                          \
}                                                                         \
                                                                          \
void Array_##NAME##::setSize( UINT arraySize )                            \
{                                                                         \
   if ( ptr != NULL ) {                                                   \
      delete [] ptr;                                                      \
      --arrayCount;                                                       \
   }                                                                      \
                                                                          \
   if ( arraySize < 1 ) {                                                 \
      size = DEFAULT_SIZE;                                                \
   } else {                                                               \
      size = arraySize;                                                   \
   }                                                                      \
                                                                          \
   ptr = new NAME##[ size ];     /* Create space for Array            */  \
   assert( ptr != NULL );        /* Terminate if memory not allocated */  \
   ++arrayCount;                 /* Count one more object             */  \
   Reset();                                                               \
}                                                                         \
                                                                          \
void Array_##NAME##::Reset() {                                            \
   for( UINT i = 0; i < size; i++ ) {                                     \
      ptr[ i ] = ZERO;           /* Initialize Array                  */  \
   }                                                                      \
}                                                                         \
                                                                          \
                                                                          \
UINT Array_##NAME##::getSize() const {                                    \
  return size;                                                            \
}                                                                         \
                                                                          \
/* Overloaded assignment operator                            */           \
/* const return to avoid side effects of ( a1 = a2 ) = a3    */           \
const Array_##NAME##&                                                     \
  Array_##NAME##::operator=( const Array_##NAME##&  right ) {             \
                                                                          \
   if ( &right != this ) {      /* Check for self-assignment */           \
                                                                          \
      /* For arrays of different sizes, deallocate original  */           \
      /* left side Array, then allocate new left side Array. */           \
      if ( size != right.size ) {                                         \
         setSize( right.size );                                           \
      }                                                                   \
                                                                          \
      for( UINT i = 0; i < size; i++ ) {                                  \
         ptr[ i ] = right.ptr[ i ];                                       \
      }                                                                   \
   }                                                                      \
                                                                          \
   return *this;                       /* Enable cascading x = y = z; */  \
}                                                                         \
                                                                          \
/* Determine if two arrays are equal */                                   \
BOOL Array_##NAME##::operator==( const Array_##NAME##&  right ) const     \
{                                                                         \
   if ( size != right.size ) {                                            \
      return FALSE;                    /* arrays of different sizes   */  \
   }                                                                      \
                                                                          \
   for ( UINT i = 0; i < size; i++ )                                      \
      if ( ptr[ i ] != right.ptr[ i ] )                                   \
         return FALSE;                 /* arrays are not equal        */  \
                                                                          \
   return TRUE;                        /* arrays are equal            */  \
}                                                                         \
                                                                          \
/* Overloaded subscript operator for non-const Arrays */                  \
/* reference return creates an lvalue                 */                  \
ELEM##& Array_##NAME##::operator[]( UINT subscript )                      \
{                                                                         \
   /* out of range, so return last Element. */                            \
   if ( subscript >= size ) {                                             \
      return ptr[ size-1 ];                                               \
   }                                                                      \
                                                                          \
   return ptr[ subscript ];                                               \
}                                                                         \
                                                                          \
/* Overloaded subscript operator for const Arrays    */                   \
/* const reference return creates an rvalue          */                   \
const ELEM##&  Array_##NAME##::operator[]( UINT subscript ) const         \
{                                                                         \
   /* out of range, so return last Element. */                            \
   if ( subscript >= size ) {                                             \
      return ptr[ size-1 ];                                               \
   }                                                                      \
                                                                          \
   return ptr[ subscript ];            /* const reference return */       \
}                                                                         \
                                                                          \
/* Return the number of Array objects instantiated  */                    \
/* static functions cannot be const                 */                    \
UINT Array_##NAME##::getArrayCount() { return arrayCount; }               \
                                                                          \
/* Overloaded input operator for class Array;       */                    \
/* inputs values for entire Array.                  */                    \
istream& operator>>( istream& input, Array_##NAME##& a )                  \
{                                                                         \
   for ( UINT i = 0; i < a.size; i++ ) {                                  \
      input >> a.ptr[ i ];                                                \
   }                                                                      \
                                                                          \
   return input;   /* enables cin >> x >> y; */                           \
}                                                                         \
                                                                          \
/* Overloaded output operator for class Array  */                         \
ostream& operator<<( ostream& output, const Array_##NAME##& a )           \
{                                                                         \
   UINT i;                                                                \
                                                                          \
   for ( i = 0; i < a.size; i++ ) {                                       \
      output << setw( 12 ) << a.ptr[ i ];                                 \
                                                                          \
      if ( ( i + 1 ) % 4 == 0 )     /* 4 numbers per row of output */     \
         output << endl;                                                  \
   }                                                                      \
                                                                          \
   if ( i % 4 != 0 )                                                      \
      output << endl;                                                     \
                                                                          \
   return output;                   /* Enable:  cout << x << y;    */     \
}                                                                         \


#endif

---