/trunk/include/jeVariant.h

/*!

    @file jeClass.h 



    @author Vladimir Gumenuk (BlackIce)

    @date 04/23/2009

    @brief Maintains jet variant type definition



    @par Licence

    The contents of this file are subject to the Jet3D Public License

    Version 1.02 (the "License"); you may not use this file except in

    compliance with the License. You may obtain a copy of the License at

    http://www.jet3d.com



    @par

    Software distributed under the License is distributed on an "AS IS"

    basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.  See

    the License for the specific language governing rights and limitations

    under the License.



    @par

    The Original Code is Jet3D, released December 12, 1999.

    Copyright (C) 1996-1999 Eclipse Entertainment, L.L.C. All Rights Reserved

*/



#ifndef __jeVariant_h__

#define __jeVariant_h__



#pragma warning(disable:4267) // '=' : conversion from 'size_t' to 'DWORD', possible loss of data



//////////////////////////////////////////////////////////////////////////

// jeVariant



enum _VariantType

{

    VAR_EMPTY   = 0,

    VAR_CHAR,

    VAR_BYTE,

    VAR_SHORT,

    VAR_WORD,

    VAR_INTEGER,

    VAR_UINT,

    VAR_LONG,

    VAR_DWORD,

    VAR_FLOAT,

    VAR_DOUBLE,

    VAR_STRING,

    VAR_BIN,            // when applied to property declaration means static buffer declared as BYTE buf[SIZE];

    VAR_CLSUNKNOWN,

    VAR_VEC2D,

    VAR_VEC3D,

    VAR_XFORM,

    VAR_PLANE,

    VAR_BOOL,

};



typedef unsigned short VariantType;



typedef struct jeVariant

{

    VariantType         vt; // variant type

    union

    {

        char            cVal;

        BYTE            bVal;

        short           sVal;

        WORD            wVal;

        int             iVal;

        UINT            uiVal;

        long            lVal;

        DWORD           dwVal;

        jeFloat         fVal;

        double          dVal;

        jeString        strVal;

        LPBYTE          binVal;

        IClassUnknown  *punkVal;

        jeVec2d         vec2D;

        jeVec3d         vec3D;

        jeXForm3d       xForm3D;

        jePlane         Plane;

        bool            bBool;

    };

    DWORD               dwSize;

} jeVariant;



//////////////////////////////////////////////////////////////////////////

// variant api

inline void jeVariantInit( jeVariant *pv ) {

    pv->vt = VAR_EMPTY;

    pv->dwVal = 0;

    pv->dwSize = 0;

}



inline void jeVariantClear( jeVariant *pv ) {

    switch( pv->vt ) {

    case VAR_EMPTY: break;

    case VAR_CHAR:

    case VAR_BYTE:

    case VAR_SHORT:

    case VAR_WORD:

    case VAR_INTEGER:

    case VAR_UINT:

    case VAR_LONG:

    case VAR_DWORD: 

    case VAR_VEC2D:

    case VAR_VEC3D:

    case VAR_XFORM:

    case VAR_PLANE:

    case VAR_BOOL:

        pv->dwVal = 0; 

        break;

    case VAR_FLOAT:

        pv->fVal = 0.0f;

        break;

    case VAR_DOUBLE: 

        pv->dVal = 0.0; 

        break;

    case VAR_STRING:

        JE_RAM_FREE( pv->strVal );

        break;

    case VAR_BIN:

        JE_RAM_FREE( pv->binVal );

        break;

    case VAR_CLSUNKNOWN:

        pv->punkVal->Release();

        pv->punkVal = 0;

        break;

    }

    pv->vt = VAR_EMPTY;

    pv->dwSize = 0;

}



inline bool jeVariantCopy( jeVariant *pDst, const jeVariant *pSrc ) {

    if( pDst->vt != VAR_EMPTY )

        return false;

    pDst->dwSize = pSrc->dwSize;

    switch( pSrc->vt ) {

    case VAR_EMPTY: break;

    case VAR_CHAR:    pDst->cVal = pSrc->cVal; break;

    case VAR_BYTE:    pDst->bVal = pSrc->bVal; break;

    case VAR_SHORT:   pDst->sVal = pSrc->sVal; break;

    case VAR_WORD:    pDst->wVal = pSrc->wVal; break;

    case VAR_INTEGER: pDst->iVal = pSrc->iVal; break;

    case VAR_UINT:    pDst->uiVal = pSrc->uiVal; break;

    case VAR_LONG:    pDst->lVal = pSrc->lVal; break;

    case VAR_DWORD:   pDst->dwVal = pSrc->dwVal; break;

    case VAR_FLOAT:   pDst->fVal = pSrc->fVal; break;

    case VAR_DOUBLE:  pDst->dVal = pSrc->dVal; break;

    case VAR_STRING: 

        { 

            if( !pSrc->dwSize )

                return false;

            pDst->strVal = (jeString)JE_RAM_ALLOCATE( pSrc->dwSize+1 );

            if( !pDst->strVal )

                return false;

            char *d = pDst->strVal;

            char *s = pSrc->strVal;

            while( *d++ = *s++ ) ;

            *d = 0;

            pDst->dwSize = pSrc->dwSize;

        }

        break;

    case VAR_BIN:

        {

            if( !pSrc->dwSize )

                return false;

            pDst->binVal = (LPBYTE)JE_RAM_ALLOCATE( pSrc->dwSize );

            if( !pDst->binVal )

                return false;

            for( dword i = 0; i < pSrc->dwSize; i++ )

                pDst->binVal[i] = pSrc->binVal[i];

            pDst->dwSize = pSrc->dwSize;

        }

        break;

    case VAR_CLSUNKNOWN:

        if( !pSrc->punkVal )

            return false;

        pDst->punkVal = pSrc->punkVal;

        pDst->punkVal->AddRef();

        break;

    case VAR_VEC2D:

        pDst->vec2D = pSrc->vec2D;

        break;

    case VAR_VEC3D:

        pDst->vec3D = pSrc->vec3D;

        break;

    case VAR_XFORM:

        pDst->xForm3D = pSrc->xForm3D;

        break;

    case VAR_PLANE:

        pDst->Plane = pSrc->Plane;

        break;

    case VAR_BOOL:

        pDst->bBool = pSrc->bBool;

        break;

    }

    

    pDst->vt = pSrc->vt;

    return true;

}



//////////////////////////////////////////////////////////////////////////

// CVariant

class CVariant : public jeVariant

{

public:

    CVariant() { jeVariantInit( this ); }

    ~CVariant() { jeVariantClear( this ); }



    CVariant( char  c ) {

        vt = VAR_CHAR;

        cVal = c;

        dwSize = sizeof(char);

    }



    CVariant( BYTE  b ) {

        vt = VAR_BYTE;

        bVal = b;

        dwSize = sizeof(BYTE);

    }



    CVariant( short s ) {

        vt = VAR_SHORT;

        sVal = s;

        dwSize = sizeof(short);

    }



    CVariant( WORD  w ) {

        vt = VAR_WORD;

        wVal = w;

        dwSize = sizeof(WORD);

    }



    CVariant( int i ) {

        vt = VAR_INTEGER;

        iVal = i;

        dwSize = sizeof(int);

    }



    CVariant( UINT  u ) {

        vt = VAR_UINT;

        uiVal = u;

        dwSize = sizeof(uint);

    }



    CVariant( long  l ) {

        vt = VAR_LONG;

        lVal = l;

        dwSize = sizeof(long);

    }



    CVariant( DWORD dw ) {

        vt = VAR_DWORD;

        dwVal = dw;

        dwSize = sizeof(dword);

    }



    CVariant( float f ) {

        vt = VAR_FLOAT;

        fVal = f;

        dwSize = sizeof(float);

    }



    CVariant( double d ) {

        vt = VAR_DOUBLE;

        dVal = d;

        dwSize = sizeof(double);

    }



    CVariant( bool b ) {

        vt = VAR_BOOL;

        bBool = b;

        dwSize = sizeof(bool);

    }



    CVariant( const jeVec2d& v ) {

        vt = VAR_VEC2D;

        vec2D = v;

        dwSize = sizeof(jeVec2d);

    }



    CVariant( const jeVec3d& v ) {

        vt = VAR_VEC3D;

        vec3D = v;

        dwSize = sizeof(jeVec3d);

    }



    CVariant( const jeXForm3d& x ) {

        vt = VAR_XFORM;

        xForm3D = x;

        dwSize = sizeof(jeXForm3d);

    }



    CVariant( const jePlane& x ) {

        vt = VAR_PLANE;

        Plane = x;

        dwSize = sizeof(jePlane);

    }

    

    CVariant( jecString str ) {

        assert( str );

        vt = VAR_STRING;

        dwSize = strlen( str );

        strVal = (jeString)JE_RAM_ALLOCATE( dwSize + 1 );

        char *d = strVal;

        const char *s = str;

        while( *d++ = *s++ ) ;

        *d = 0;

    }



    CVariant( const LPBYTE pbin, DWORD dwSize ) {

        assert( pbin );

        assert( dwSize != 0 );

        vt = VAR_BIN;

        dwSize = dwSize;

        binVal = (LPBYTE)JE_RAM_ALLOCATE( dwSize );

        for( dword i = 0; i < dwSize; i++ )

            binVal[i] = pbin[i];

    }



    CVariant( IClassUnknown *punk ) {

        assert( punk );

        vt = VAR_CLSUNKNOWN;

        punkVal = punk;

        punkVal->AddRef();

    }



    CVariant( const jeVariant& v ) {

        jeVariantInit( this );

        jeVariantCopy( this, &v );

    }



    CVariant& operator= ( const CVariant& v ) {

        jeVariantClear( this );

        jeVariantCopy( this, &v );

        return (*this);

    }



    void clear() {

        jeVariantClear( this );

    }



    bool Detach( jeVariant& v ) {

        bool bRet = jeVariantCopy( &v, this );

        jeVariantClear( this );

        return bRet;

    }

};



//////////////////////////////////////////////////////////////////////////



#pragma warning(default:4267)



#endif // __jeVariant_h__