/*

* 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