Main Page   Packages   Namespace List   Class Hierarchy   Alphabetical List   Compound List   File List   Compound Members   File Members   Search  

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

Go to the documentation of this file.
00001 // Implementation of class Array
00002 
00003 #include <j2k/Fred/Math/Array.hpp>
00004 
00005 #ifndef __J2K__ARRAY_CPP__
00006 #define __J2K__ARRAY_CPP__
00007 
00008 #define MC_ClassImpl_Array( NAME, ELEM, DEFAULT_SIZE, ZERO )              \
00009                                                                           \
00010 UINT Array_##NAME##::arrayCount = 0;                                      \
00011                                                                           \
00012 Array_##NAME##::Array_##NAME##()                                          \
00013   : size( DEFAULT_SIZE ), ptr( NULL ) {                                   \
00014   setSize( DEFAULT_SIZE );                                                \
00015 }                                                                         \
00016                                                                           \
00017 Array_##NAME##::Array_##NAME##( UINT arraySize )                          \
00018   : size( arraySize ), ptr( NULL ) {                                      \
00019   setSize( arraySize );                                                   \
00020 }                                                                         \
00021                                                                           \
00022 Array_##NAME##::Array_##NAME##( const Array_##NAME##& src )               \
00023    : size( src.size ), ptr( NULL ) {                                      \
00024    setSize( src.size );                                                   \
00025 }                                                                         \
00026                                                                           \
00027 Array_##NAME##::~Array_##NAME##() {                                       \
00028    delete [] ptr;                                                         \
00029    --arrayCount;                                                          \
00030 }                                                                         \
00031                                                                           \
00032 void Array_##NAME##::setSize( UINT arraySize )                            \
00033 {                                                                         \
00034    if ( ptr != NULL ) {                                                   \
00035       delete [] ptr;                                                      \
00036       --arrayCount;                                                       \
00037    }                                                                      \
00038                                                                           \
00039    if ( arraySize < 1 ) {                                                 \
00040       size = DEFAULT_SIZE;                                                \
00041    } else {                                                               \
00042       size = arraySize;                                                   \
00043    }                                                                      \
00044                                                                           \
00045    ptr = new NAME##[ size ];     /* Create space for Array            */  \
00046    assert( ptr != NULL );        /* Terminate if memory not allocated */  \
00047    ++arrayCount;                 /* Count one more object             */  \
00048    Reset();                                                               \
00049 }                                                                         \
00050                                                                           \
00051 void Array_##NAME##::Reset() {                                            \
00052    for( UINT i = 0; i < size; i++ ) {                                     \
00053       ptr[ i ] = ZERO;           /* Initialize Array                  */  \
00054    }                                                                      \
00055 }                                                                         \
00056                                                                           \
00057                                                                           \
00058 UINT Array_##NAME##::getSize() const {                                    \
00059   return size;                                                            \
00060 }                                                                         \
00061                                                                           \
00062 /* Overloaded assignment operator                            */           \
00063 /* const return to avoid side effects of ( a1 = a2 ) = a3    */           \
00064 const Array_##NAME##&                                                     \
00065   Array_##NAME##::operator=( const Array_##NAME##&  right ) {             \
00066                                                                           \
00067    if ( &right != this ) {      /* Check for self-assignment */           \
00068                                                                           \
00069       /* For arrays of different sizes, deallocate original  */           \
00070       /* left side Array, then allocate new left side Array. */           \
00071       if ( size != right.size ) {                                         \
00072          setSize( right.size );                                           \
00073       }                                                                   \
00074                                                                           \
00075       for( UINT i = 0; i < size; i++ ) {                                  \
00076          ptr[ i ] = right.ptr[ i ];                                       \
00077       }                                                                   \
00078    }                                                                      \
00079                                                                           \
00080    return *this;                       /* Enable cascading x = y = z; */  \
00081 }                                                                         \
00082                                                                           \
00083 /* Determine if two arrays are equal */                                   \
00084 BOOL Array_##NAME##::operator==( const Array_##NAME##&  right ) const     \
00085 {                                                                         \
00086    if ( size != right.size ) {                                            \
00087       return FALSE;                    /* arrays of different sizes   */  \
00088    }                                                                      \
00089                                                                           \
00090    for ( UINT i = 0; i < size; i++ )                                      \
00091       if ( ptr[ i ] != right.ptr[ i ] )                                   \
00092          return FALSE;                 /* arrays are not equal        */  \
00093                                                                           \
00094    return TRUE;                        /* arrays are equal            */  \
00095 }                                                                         \
00096                                                                           \
00097 /* Overloaded subscript operator for non-const Arrays */                  \
00098 /* reference return creates an lvalue                 */                  \
00099 ELEM##& Array_##NAME##::operator[]( UINT subscript )                      \
00100 {                                                                         \
00101    /* out of range, so return last Element. */                            \
00102    if ( subscript >= size ) {                                             \
00103       return ptr[ size-1 ];                                               \
00104    }                                                                      \
00105                                                                           \
00106    return ptr[ subscript ];                                               \
00107 }                                                                         \
00108                                                                           \
00109 /* Overloaded subscript operator for const Arrays    */                   \
00110 /* const reference return creates an rvalue          */                   \
00111 const ELEM##&  Array_##NAME##::operator[]( UINT subscript ) const         \
00112 {                                                                         \
00113    /* out of range, so return last Element. */                            \
00114    if ( subscript >= size ) {                                             \
00115       return ptr[ size-1 ];                                               \
00116    }                                                                      \
00117                                                                           \
00118    return ptr[ subscript ];            /* const reference return */       \
00119 }                                                                         \
00120                                                                           \
00121 /* Return the number of Array objects instantiated  */                    \
00122 /* static functions cannot be const                 */                    \
00123 UINT Array_##NAME##::getArrayCount() { return arrayCount; }               \
00124                                                                           \
00125 /* Overloaded input operator for class Array;       */                    \
00126 /* inputs values for entire Array.                  */                    \
00127 istream& operator>>( istream& input, Array_##NAME##& a )                  \
00128 {                                                                         \
00129    for ( UINT i = 0; i < a.size; i++ ) {                                  \
00130       input >> a.ptr[ i ];                                                \
00131    }                                                                      \
00132                                                                           \
00133    return input;   /* enables cin >> x >> y; */                           \
00134 }                                                                         \
00135                                                                           \
00136 /* Overloaded output operator for class Array  */                         \
00137 ostream& operator<<( ostream& output, const Array_##NAME##& a )           \
00138 {                                                                         \
00139    UINT i;                                                                \
00140                                                                           \
00141    for ( i = 0; i < a.size; i++ ) {                                       \
00142       output << setw( 12 ) << a.ptr[ i ];                                 \
00143                                                                           \
00144       if ( ( i + 1 ) % 4 == 0 )     /* 4 numbers per row of output */     \
00145          output << endl;                                                  \
00146    }                                                                      \
00147                                                                           \
00148    if ( i % 4 != 0 )                                                      \
00149       output << endl;                                                     \
00150                                                                           \
00151    return output;                   /* Enable:  cout << x << y;    */     \
00152 }                                                                         \
00153 
00154 
00155 #endif

Generated on Sun Oct 14 18:46:12 2001 for Standard J2K Library by doxygen1.2.11.1 written by Dimitri van Heesch, © 1997-2001