sarray.h

任意给定三维空间的点集

        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
\*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*/