DASSERT( 0 <= ind  &&  ind < currSize &&  fInitialized, "ranmge failure" );        if  ( ind != (currSize - 1) ) {            pArr[ ind ] = pArr[ currSize - 1 ];        }        currSize--;    }            void       moveToFront( int  pos )    {        T  tmp;        int                  ind;                DASSERT( 0 <= pos  &&  pos < currSize &&  fInitialized,                  "moveToFront: ranmge failure" );        tmp = pArr[ pos ];        for  (  ind = pos; ind > 0; ind-- )             pArr[ ind ] = pArr[ ind - 1 ];                pArr[ 0 ] = tmp;    }            void       deleteEntryByPosAndKeepOrder( int       pos )    {        int                  ind;                DASSERT( 0 <= pos  &&  pos < currSize &&  fInitialized,                  "ranmge failure" );                for  (  ind = pos; ind < currSize - 1; ind++ )             pArr[ ind ] = pArr[ ind + 1 ];                currSize--;    }        void       term( void )    {        if  ( ! fInitialized )            return;        if  ( pArr != NULL ) {            //delete[]  pArr;            term_Range( currSize );            free( (void *)pArr );            //printf( "%p free\n", pArr );            pArr = NULL;            ptrArr = NULL;        }                maxSize = currSize = 0;        fInitialized = false;    }            void       simulateTerm( void )    {        fInitialized = false;        pArr = NULL;        ptrArr = NULL;    }            void       insertQuick( const T   & var )    {        pArr[ currSize++ ] = var;    }    void       insertEntry( const T   & var )    {        //printf( "inserting entry!\n" );        DASSERT( 0 <= currSize  &&  currSize < maxSize, "insert failurex" );        //memset( (void *)(pArr + currSize), 0, sizeof( T ) );        ::new(pArr + currSize ) T( var );        currSize++;    }        void       insertEntryUnique( const T   & var )    {        int  pos;        pos = searchEntry( var );        if  ( pos >= 0 )            return;                pushx( var );    }        int        allocEntry()    {        if  ( currSize >= maxSize ) {            if  ( ! resize( 4 * currSize + 1 ) )                return  -1;        }        //printf( "bogi\n" );        DASSERT( currSize < maxSize, "insert failure" );        //memset( (void *)&(pArr[ currSize ]), 0, sizeof( T ) );        currSize++;        //printf( "bogi\n" );                return  currSize - 1;    }    int        allocEntryFast()    {        if  ( currSize >= maxSize ) {            if  ( ! resize( 10 * currSize + 1 ) )                return  -1;        }        return  currSize++;    }            bool       growAndInsert( const T   & var )    {        //printf( "growAndInsert!\n" );        if  ( currSize >= maxSize ) {            if  ( ! resize( 4 * currSize + 1 ) )                return  false;        }        insertEntry( var );                return  true;    }        void       push_in_beginning( const T  & var ) {        assert( growAndInsert( var ) );        for  ( int  ind = size()-1; ind > 0; ind-- )             (*this)[ ind ] = (*this)[ ind - 1 ];                (*this)[ 0 ] = var;    }    void       pushx( const T   & var )     {        //printf( "pushx!\n" );        assert( growAndInsert( var ) );    }        void       pushy( const T   & var )     {        if  ( currSize >= maxSize ) {            assert(resize( 4 * currSize + 1 ) );        }        insertQuick( var );    }        const T    & lastEntry( void )  const    {        DASSERT( currSize > 0, "Small Array::no last element to look at" );        return( pArr[ currSize - 1 ] );    }    T    & lastEntry( void )    {        DASSERT( currSize > 0, "Small Array::no last element to look at" );        return( pArr[ currSize - 1 ] );    }    void        pop( void )    {        DASSERT( currSize > 0, "Small Array::poping an empty stack" );        if  ( currSize > 0 )            currSize--;    }    int        searchEntry( const T   & var )    {        return   searchArrayEntry( pArr, sizeof( T ), currSize, &var );    }    int        findLocation( const T  & var ) {        for  ( int  ind = 0; ind < size(); ind++ )             if  ( pArr[ ind ] == var )                 return  ind;        return  -1;    }    };template<class T, int  maxSize>class  SmallArray {private:    int         currSize;    T           pArr[ maxSize ];public:    SmallArray( void )    {        currSize = 0;    }    bool  isFull( void ) const    {        return   currSize >= maxSize;    }    bool  isEmpty( void ) const    {        return   currSize <= 0;    }    void  init( void )    {        currSize = 0;    }    void  init( T        * ptr )    {        currSize = calcEntriesNum( (void *)ptr, sizeof( T ) );        memcpy( pArr, ptr, currSize * sizeof( T ) );    }    void  flush( void )    {        currSize = 0;    }    const T    & lastEntry( void )  const    {        DASSERT( currSize > 0, "Small Array::no last element to look at" );        return( pArr[ currSize - 1 ] );    }    T    & lastEntry( void )    {        DASSERT( currSize > 0, "Small Array::no last element to look at" );        return( pArr[ currSize - 1 ] );    }    const T &operator[]( int i )  const    {#ifndef  SARRAY_NO_RANGE_CHECK        DASSERT( 0 <= i  &&  i < currSize,                 "Small Array::Range failure" );#endif        return( pArr[ i ] );    }    const T &getEntry( int i )  const    {        DASSERT( 0 <= i  &&  i < currSize,                 "Small Array::Range failure" );        return( pArr[ i ] );    }    ~SmallArray( void )    {        term();    }    T &operator[]( int i )    {#ifndef  SARRAY_NO_RANGE_CHECK        DASSERT( 0 <= i  &&  i < currSize,                 "Small Array::Range failure" );#endif        return( pArr[ i ] );    }    int        getEntriesNum( void ) const    {        return    currSize;    }    int        size( void ) const    {        return    currSize;    }    void       bringToTop( const T    & var )    {        int                 ind;        ind = searchEntry( var );        if  ( ind >= 0  &&  ind < currSize - 1 )            exchange( pArr[ ind ], pArr[ currSize - 1 ] );    }    void       deleteEntryKeepOrder( const T      var )    {        int                   ind;        ind = searchEntry( var );        if  ( ind >= 0 ) {            memcpy( (void *)&(pArr[ ind ]),                     (void *)&(pArr[ ind + 1 ] ),                     (currSize - ind - 1 ) * sizeof( T ) );            currSize--;        }    }    void       deleteEntry( const T   & var )    {        int                 ind;        ind = searchEntry( var );        if  ( ind >= 0 ) {            pArr[ ind ] = pArr[ currSize - 1 ];            currSize--;        }    }    void       deleteEntryByPos( int       ind )    {        DASSERT( 0 <= ind  &&  ind < currSize,                 "Small Array::delete entry Range failure" );        pArr[ ind ] = pArr[ currSize - 1 ];        currSize--;    }    void        pop( void )    {        DASSERT( currSize > 0, "Small Array::poping an empty stack" );        if  ( currSize > 0 )            currSize--;    }    void       term( void )    {        currSize = 0;    }    void       insertEntry( const T   & var )    {        //DASSERT( currSize < maxSize, "Small Array::Insert failure" );        pArr[ currSize ] = var;        currSize++;    }    void       push( const T       & var )    {        insertEntry( var );    }    void       reset( void )    {        currSize = 0;    }    int        searchEntry( const T   & var )    {        return   searchArrayEntry( &pArr[0], sizeof( T ),                                   currSize, &var );    }    int        findLocation( const T  & var ) {        for  ( int  ind = 0; ind < size(); ind++ )             if  ( pArr[ ind ] == var )                 return  ind;        return  -1;    }};#endif  /* __SARRAY__H *//*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=* * * sarray.h - End of File\*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*/