/*
* Copyright (c) 2007-2008 Nokia Corporation and/or its subsidiary(-ies). 
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:  MulVarianttype implementation
*
*/


#include <mul/mulvarianttype.h>

#include <mul/imulvarianttype.h>
#include <osn/osnnew.h>

#include "mulassert.h"

using namespace osncore;
using namespace std;

namespace Alf
    {
    
_LIT( KUnknownDataType, "Unknown data type" );

// ---------------------------------------------------------------------------
// Defination of class MulVariantTypeImpl
// ---------------------------------------------------------------------------
//

class MulVariantType::MulVariantTypeImpl
    {     
public:
    
    ~MulVariantTypeImpl()
        {
        if( mDataType == IMulVariantType::EDes )
            {
            if( mData.mDes )
                {
                delete mData.mDes;
                }
            }
        else if( mDataType == IMulVariantType::EMap )
            {
            if( mData.mMap )
                {
                delete mData.mMap;
                }
            }
      
        }
    
    MulVariantTypeImpl()
        {
        mData.mDes = NULL;
        mData.mMap = NULL;
        mDataType = IMulVariantType::EUnknown;
        }
    
public:
    
    union TData
        {
        bool     mBool;  // Boolean
        int      mInt;   // 32-bit integer
        uint     mUint;  // 32-bit unsigned integer
        double   mReal;  // 64-bit real
        HBufC*   mDes;   // 16 bit descriptor 
        IAlfMap* mMap;
        };
    
    TData mData;
    IMulVariantType::TMulType mDataType;
    
    };

void MulVariantType::Construct( TMulType aType )
    {
    mVarData.reset( new (EMM) MulVariantTypeImpl() );
    mVarData->mDataType = aType;
    }

// ---------------------------------------------------------------------------
// MulVariantType
// ---------------------------------------------------------------------------
//
OSN_EXPORT MulVariantType::MulVariantType()	
	{
	Construct(IMulVariantType::EUnknown );
	// No implementation required
	}

// ---------------------------------------------------------------------------
// MulVariantType
// ---------------------------------------------------------------------------
//
OSN_EXPORT MulVariantType::MulVariantType( const TDesC& aDes )
    {
    Construct(IMulVariantType::EDes );
    mVarData->mData.mDes = aDes.AllocL();
    }

// ---------------------------------------------------------------------------
// MulVariantType
// ---------------------------------------------------------------------------
//
OSN_EXPORT MulVariantType::MulVariantType(const int& aValue)
	{
	Construct(IMulVariantType::EInt );
	mVarData->mData.mInt = aValue;
	}

// ---------------------------------------------------------------------------
// MulVariantType
// ---------------------------------------------------------------------------
//
OSN_EXPORT MulVariantType::MulVariantType(const uint& aValue)	
	{
	Construct(IMulVariantType::EUint );
	mVarData->mData.mUint = aValue;
	}

// ---------------------------------------------------------------------------
// MulVariantType
// ---------------------------------------------------------------------------
//
OSN_EXPORT MulVariantType::MulVariantType(const double& aValue)	
	{
	Construct(IMulVariantType::EReal );
	mVarData->mData.mReal = aValue;
	}

// ---------------------------------------------------------------------------
// MulVariantType
// ---------------------------------------------------------------------------
//
OSN_EXPORT MulVariantType::MulVariantType(const bool& aValue)	
	{
	Construct(IMulVariantType::EBool );
	mVarData->mData.mBool = aValue;
	}

// ---------------------------------------------------------------------------
// MulVariantType
// ---------------------------------------------------------------------------
//
OSN_EXPORT MulVariantType::MulVariantType( IAlfMap& aData )  
    {
    Construct(IMulVariantType::EMap );
    mVarData->mData.mMap = aData.clone();
    }

// ---------------------------------------------------------------------------
// ~MulVariantType
// ---------------------------------------------------------------------------
//
OSN_EXPORT MulVariantType::~MulVariantType()    
    {
    // No implementation required
    }

// ---------------------------------------------------------------------------
// MulType
// ---------------------------------------------------------------------------
//
OSN_EXPORT IMulVariantType::TMulType MulVariantType::Type() const
    {
    return mVarData->mDataType;
    }

// ---------------------------------------------------------------------------
// DesC
// ---------------------------------------------------------------------------
//
OSN_EXPORT const TDesC& MulVariantType::DesC() const
    {
    if ( Type() != IMulVariantType::EDes ) 
        {
        __MUL_ASSERT(false, KUnknownDataType );
        }
    return *mVarData->mData.mDes;
    }
	
// ---------------------------------------------------------------------------
// Clone
// ---------------------------------------------------------------------------
//
OSN_EXPORT std::auto_ptr< IMulVariantType > MulVariantType::Clone()
	{
	std::auto_ptr<IMulVariantType> clone;
	
	switch( Type() )
		{
		case IMulVariantType::EBool:
		    {
	        clone.reset( new (EMM) MulVariantType( boolean() ) );
	        return clone;
		    }
		case IMulVariantType::EInt:
		    {
		    clone.reset( new (EMM) MulVariantType( integer() ) ) ;
		    return clone;
		    }
		case IMulVariantType::EUint:
		    {
		    clone.reset( new (EMM) MulVariantType( uinteger() ) );
		    return clone;
		    }
		case IMulVariantType::EReal:
		    {
		    clone.reset( new (EMM) MulVariantType( real() ) );
		    return clone;
		    }
		case IMulVariantType::EDes:
			{
			clone.reset( new (EMM) MulVariantType( DesC() ) ) ;
			return clone;
			}
		case IAlfVariantType::EMap:
		    {
		    clone.reset( new (EMM) MulVariantType( Map() ) ) ;
		    return clone;
		    }
		case IAlfVariantType::ECustomData: //delebrate fallthrough
		default :
			{
			__MUL_ASSERT( false, KUnknownDataType );
			return clone;
			}
		}
	}

// ---------------------------------------------------------------------------
// boolean
// ---------------------------------------------------------------------------
//
OSN_EXPORT bool MulVariantType::boolean() const
	{
    if ( Type() != IMulVariantType::EBool ) 
        {
        __MUL_ASSERT( false, KUnknownDataType );
        }
    return mVarData->mData.mBool;
	}

// ---------------------------------------------------------------------------
// integer
// ---------------------------------------------------------------------------
//
OSN_EXPORT int MulVariantType::integer() const
	{
	if ( Type() != IMulVariantType::EInt ) 
       {
       __MUL_ASSERT( false, KUnknownDataType );
       }
    return mVarData->mData.mInt;
	}

// ---------------------------------------------------------------------------
// uinteger
// ---------------------------------------------------------------------------
//
OSN_EXPORT uint MulVariantType::uinteger() const
	{
	if ( Type() != IMulVariantType::EUint ) 
       {
       __MUL_ASSERT( false, KUnknownDataType );
       }
	return mVarData->mData.mUint;
	}

// ---------------------------------------------------------------------------
// real
// ---------------------------------------------------------------------------
//
OSN_EXPORT double MulVariantType::real() const
	{
	if ( Type() != IMulVariantType::EUint ) 
       {
       __MUL_ASSERT( false, KUnknownDataType );
       }
	return mVarData->mData.mReal;
	}

// ---------------------------------------------------------------------------
// map
// ---------------------------------------------------------------------------
//
OSN_EXPORT IAlfMap& MulVariantType::Map() const
	{
	if ( Type() != IMulVariantType::EMap ) 
       {
       __MUL_ASSERT( false, KUnknownDataType );
       }
	return *mVarData->mData.mMap;
	}

    }// namespace Alf	

//End of file