/net/fileserver/nas/home/mdh/vrq/src/cuint.h

Go to the documentation of this file.

/*****************************************************************************
 * Copyright (C) 1997-2007, Mark Hummel
 * This file is part of Vrq.
 *
 * Vrq is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * Vrq is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, 
 * Boston, MA  02110-1301  USA
 *****************************************************************************
 */
/*******************************************************************
 *
 *      cuint.hpp       
 *              - header file for cuint.hpp 
 *                
 *
 *******************************************************************
 */

#ifndef CUINT_HPP
#define CUINT_HPP

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "glue.h"
#include "cobstack.h"


#ifndef MAX
#define MAX(a,b)        ((a)<(b)?(b):(a))
#endif // MAX

#define CUINT_DEFAULT_SIZE      (4)     // size in 32 bit words

class   CUInt {
private:
    unsigned int        defaultData[CUINT_DEFAULT_SIZE];
    unsigned int        *data;                          
    int         allocatedSize;                  
    int         size;                           
    CObstack*   heap;                           
public:

    CUInt( void ) 
    {
        heap = NULL;
        allocatedSize = CUINT_DEFAULT_SIZE;
        data = defaultData;
        size = 1;
        data[0] = 0;
    };          
    
    CUInt( unsigned int aValue ) 
    {
        heap = NULL;
        allocatedSize = CUINT_DEFAULT_SIZE;
        data = defaultData;
        size = 1;
        data[0] = aValue;
    };          
    
    
    CUInt( const CUInt &aValue ) 
    {
        INT32   i;
        
        heap = NULL;
        allocatedSize = CUINT_DEFAULT_SIZE;
        data = defaultData;
        size = 1;
        grow( aValue.size );
        for( i = 0; i < size; i++ ) {
                data[i] = aValue.data[i];
        }
    };          
    
    virtual ~CUInt()    
    {
        if( heap == NULL && data != defaultData ) {
                shell_xfree( data, size );
                data = NULL;
        }
    } ;
    
    
    void SetHeap( CObstack* aHeap )
    {
        heap = aHeap;
    }
    
    const CUInt &operator=( const CUInt &aValue )        
    {
        INT32   i;
        
        grow( aValue.size );
        for( i = 0; i < size; i++ ) {
                data[i] = aValue.data[i];
        }
        return( aValue );
    };
    
    const UINT64 operator=( const UINT64 aValue )        
    {
        if( aValue>>32 != 0 ) {
                grow( 2 );
                data[0] = aValue;
                data[1] = aValue>>32;
        } else {
                grow( 1 );
                data[0] = aValue;
        }
        return( aValue );
    };
    
    void        Truncate( int newSize )
    {
        grow( newSize );
    };

    CUInt operator~( void ) const;
    
    CUInt operator+( const CUInt & ) const;
    CUInt operator+( const unsigned int ) const;
    CUInt operator-( const CUInt & ) const;
    CUInt operator-( unsigned int ) const;
    CUInt operator*( const CUInt & ) const;
    CUInt operator*( unsigned int ) const;
    CUInt operator/( const CUInt & ) const;
    CUInt operator/( unsigned int ) const;
    CUInt operator%( const CUInt & ) const;
    CUInt operator%( unsigned int ) const;
    CUInt operator>>( const CUInt & ) const;
    CUInt operator>>( unsigned int ) const;
    CUInt operator<<( const CUInt & ) const;
    CUInt operator<<( unsigned int ) const;
    CUInt operator&( const CUInt & ) const;
    CUInt operator&( unsigned int ) const;
    CUInt operator|( const CUInt & ) const;
    CUInt operator|( unsigned int ) const;
    CUInt operator^( const CUInt & ) const;
    CUInt operator^( unsigned int ) const;
    
    int operator<( const CUInt & ) const;
    int operator<( unsigned int ) const;
    int operator<=( const CUInt & ) const;
    int operator<=( unsigned int ) const;
    int operator>( const CUInt & ) const;
    int operator>( unsigned int ) const;
    int operator>=( const CUInt & ) const;
    int operator>=( unsigned int ) const;
    int operator==( const CUInt & ) const;
    int operator==( unsigned int ) const;
    int operator!=( const CUInt & ) const;
    int operator!=( unsigned int ) const;
    
    UINT32 GetUINT32() const; 
    UINT64 GetUINT64() const;
    
    UINT32 Size();
    
private:
    void calibrate( void )
    {
        int     i;
        for( i=size-1; i>0; i-- ) {
            if( data[i] != 0 ) {
                break;
            }
        }       
        size = i+1;
        return;
    };
    void grow( int aSize )
    {
        int i;
    
        if( aSize <= size ) {
            size = aSize;
            return;
        }
        if( allocatedSize < aSize ) {
            if( heap == NULL ) {
                if( data != defaultData ) {
                    unsigned int* newData;
                    newData = (unsigned int*)shell_xmalloc( aSize*4);
                    memcpy( newData, data, size*4 );
                    shell_xfree( data, allocatedSize*4 );
                    data = newData;
                } else {
                    data = (unsigned int*)shell_xmalloc( aSize*4 );
                    memcpy( data, defaultData, size*4 );
                }
            } else {
                unsigned int*   newData;
                newData = (unsigned int*)heap->Alloc( aSize*4 );
                memcpy( newData, data, size*4 );
                data = newData;
            }
            allocatedSize = aSize;
        }
        for( i=size; i < aSize; i++ ) {
            data[i] = 0;
        }
        size = aSize;
    };  
};




#endif // CUINT_HPP