// Copyright (c) 2006-2009 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:

//

/**

 @file

 @publishedPartner

*/

#include <mtp/cmtptypecompoundbase.h>

#include <mtp/cmtptypestring.h>

#include <mtp/rmtptype.h>

#include "mtpdatatypespanic.h"

/**

Destructor

*/

EXPORT_C CMTPTypeCompoundBase::~CMTPTypeCompoundBase()

    {

    Reset();    

    }

/**

Provides a copy of the specified element.

@param aElementId The identifier of the requested element.

@param aElement The MMTPType target data buffer.

@leave KErrNotSupported, if the element is not readable.

@leave One of the system wide error code, if a processing error occurs. 

@panic MTPDataTypes 3, if the target buffer type does not match the requested

element.

*/

EXPORT_C void CMTPTypeCompoundBase::GetL(TInt aElementId, MMTPType& aElement) const

    {

    if (!ReadableElementL(aElementId))

        {

        User::Leave(KErrNotSupported);            

        }

    const TElementInfo& info(ElementInfo(aElementId));

    if (info.iType == EMTPTypeFlat)

        {

        RMTPTypeCompoundFlatChunk* chunk(static_cast<RMTPTypeCompoundFlatChunk*>(iChunks[info.iChunkId]));

        chunk->GetL(aElementId, aElement);

        }

    else

        {

        CopyL(*iChunks[info.iChunkId], aElement);

        }

    }

/**

Updates the specified element.

@param aElementId The identifier of the element to update.

@param aElement The MMTPType source data buffer.

@leave KErrNotSupported, if the element is not writeable.

@leave One of the system wide error code, if a processing error occurs. 

@panic MTPDataTypes 3, if the source buffer type does not match the requested 

element.

*/  

EXPORT_C void CMTPTypeCompoundBase::SetL(TInt aElementId, const MMTPType& aElement)

    {

    if (!WriteableElementL(aElementId))

        {

        User::Leave(KErrNotSupported);            

        }

    const TElementInfo& info(ElementInfo(aElementId));

    if (info.iType == EMTPTypeFlat)

        {

        RMTPTypeCompoundFlatChunk* chunk(static_cast<RMTPTypeCompoundFlatChunk*>(iChunks[info.iChunkId]));

        chunk->SetL(aElementId, aElement);

        }

    else

        {

        CopyL(aElement, *iChunks[info.iChunkId]);

        }

    }

/**

Updates the specified element.

@param aElementId The identifier of the element to update.

@param aData The source data.

@leave KErrNotSupported, if the element is not writeable.

@leave One of the system wide error code, if a processing error occurs. 

@panic MTPDataTypes 3, if the source data type does not match the requested 

element.

*/    

EXPORT_C void CMTPTypeCompoundBase::SetInt8L(TInt aElementId, TInt8 aData)

    {

    if (!WriteableElementL(aElementId))

        {

        User::Leave(KErrNotSupported);            

        }

    const TElementInfo& info(ElementInfo(aElementId));

    switch (info.iType)

        {

    case EMTPTypeFlat:

        {

        RMTPTypeCompoundFlatChunk* chunk(static_cast<RMTPTypeCompoundFlatChunk*>(iChunks[info.iChunkId]));

        chunk->SetInt8(aElementId, aData);

        }

        break;

    case EMTPTypeReference:

        {

        RMTPType* chunk(static_cast<RMTPType*>(iChunks[info.iChunkId]));

        __ASSERT_DEBUG(chunk->Type() == EMTPTypeINT8, Panic(EMTPTypeIdMismatch));   

        static_cast<TMTPTypeInt8&>(chunk->Data()).Set(aData);

        }

        break;

    case EMTPTypeINT8:

        {

        TMTPTypeInt8* chunk(static_cast<TMTPTypeInt8*>(iChunks[info.iChunkId]));

        chunk->Set(aData);

        }

        break;

    default:

        Panic(EMTPTypeIdMismatch);

        break;

        }

    }

/**

Updates the specified element.

@param aElementId The identifier of the element to update.

@param aData The source data.

@leave KErrNotSupported, if the element is not writeable.

@leave One of the system wide error code, if a processing error occurs. 

@panic MTPDataTypes 3, if the source data type does not match the requested 

element.

*/    

EXPORT_C void CMTPTypeCompoundBase::SetInt16L(TInt aElementId, TInt16 aData)

    {

    if (!WriteableElementL(aElementId))

        {

        User::Leave(KErrNotSupported);            

        }

    const TElementInfo& info(ElementInfo(aElementId));

    switch (info.iType)

        {

    case EMTPTypeFlat:

        {

        RMTPTypeCompoundFlatChunk* chunk(static_cast<RMTPTypeCompoundFlatChunk*>(iChunks[info.iChunkId]));

        chunk->SetInt16(aElementId, aData);

        }

        break;

    case EMTPTypeReference:

        {

        RMTPType* chunk(static_cast<RMTPType*>(iChunks[info.iChunkId]));

        __ASSERT_DEBUG(chunk->Type() == EMTPTypeINT16, Panic(EMTPTypeIdMismatch)); 

        static_cast<TMTPTypeInt16&>(chunk->Data()).Set(aData);

        }

        break;

    case EMTPTypeINT16:

        {

        TMTPTypeInt16* chunk(static_cast<TMTPTypeInt16*>(iChunks[info.iChunkId]));

        chunk->Set(aData);

        }

        break;

    default:

        Panic(EMTPTypeIdMismatch);

        break;

        }

    }

/**

Updates the specified element.

@param aElementId The identifier of the element to update.

@param aData The source data.

@leave KErrNotSupported, if the element is not writeable.

@leave One of the system wide error code, if a processing error occurs. 

@panic MTPDataTypes 3, if the source data type does not match the requested 

element.

*/    

EXPORT_C void CMTPTypeCompoundBase::SetInt32L(TInt aElementId, TInt32 aData)

    {

    if (!WriteableElementL(aElementId))

        {

        User::Leave(KErrNotSupported);            

        }

    const TElementInfo& info(ElementInfo(aElementId));

    switch (info.iType)

        {

    case EMTPTypeFlat:

        {

        RMTPTypeCompoundFlatChunk* chunk(static_cast<RMTPTypeCompoundFlatChunk*>(iChunks[info.iChunkId]));

        chunk->SetInt32(aElementId, aData);

        }

        break;

    case EMTPTypeReference:

        {

        RMTPType* chunk(static_cast<RMTPType*>(iChunks[info.iChunkId]));

        __ASSERT_DEBUG(chunk->Type() == EMTPTypeINT32, Panic(EMTPTypeIdMismatch)); 

        static_cast<TMTPTypeInt32&>(chunk->Data()).Set(aData);

        }

        break;

    case EMTPTypeINT32:

        {

        TMTPTypeInt32* chunk(static_cast<TMTPTypeInt32*>(iChunks[info.iChunkId]));

        chunk->Set(aData);

        }

        break;

    default:

        Panic(EMTPTypeIdMismatch);

        break;

        }

    }

/**

Updates the specified element.

@param aElementId The identifier of the element to update.

@param aData The source data.

@leave KErrNotSupported, if the element is not writeable.

@leave One of the system wide error code, if a processing error occurs. 

@panic MTPDataTypes 3, if the source data type does not match the requested 

element.

*/    

EXPORT_C void CMTPTypeCompoundBase::SetInt64L(TInt aElementId, TInt64 aData)

    {

    if (!WriteableElementL(aElementId))

        {

        User::Leave(KErrNotSupported);            

        }

    const TElementInfo& info(ElementInfo(aElementId));

    switch (info.iType)

        {

    case EMTPTypeFlat:

        {

        RMTPTypeCompoundFlatChunk* chunk(static_cast<RMTPTypeCompoundFlatChunk*>(iChunks[info.iChunkId]));

        chunk->SetInt64(aElementId, aData);

        }

        break;

    case EMTPTypeReference:

        {

        RMTPType* chunk(static_cast<RMTPType*>(iChunks[info.iChunkId]));

        __ASSERT_DEBUG(chunk->Type() == EMTPTypeINT64, Panic(EMTPTypeIdMismatch)); 

        static_cast<TMTPTypeInt64&>(chunk->Data()).Set(aData);

        }

        break;

    case EMTPTypeINT64:

        {

        TMTPTypeInt64* chunk(static_cast<TMTPTypeInt64*>(iChunks[info.iChunkId]));

        chunk->Set(aData);

        }

        break;

    default:

        Panic(EMTPTypeIdMismatch);

        break;

        }

    }

/**

Updates the specified element.

@param aElementId The identifier of the element to update.

@param aData The source data.

@leave KErrNotSupported, if the element is not writeable.

@leave One of the system wide error code, if a processing error occurs. 

@panic MTPDataTypes 3, if the source data type does not match the requested 

element.

*/    

EXPORT_C void CMTPTypeCompoundBase::SetUint8L(TInt aElementId, TUint8 aData)

    {

    if (!WriteableElementL(aElementId))

        {

        User::Leave(KErrNotSupported);            

        }

    const TElementInfo& info(ElementInfo(aElementId));

    switch (info.iType)

        {

    case EMTPTypeFlat:

        {

        RMTPTypeCompoundFlatChunk* chunk(static_cast<RMTPTypeCompoundFlatChunk*>(iChunks[info.iChunkId]));

        chunk->SetUint8(aElementId, aData);

        }

        break;

    case EMTPTypeReference:

        {

        RMTPType* chunk(static_cast<RMTPType*>(iChunks[info.iChunkId]));

        __ASSERT_DEBUG(chunk->Type() == EMTPTypeUINT8, Panic(EMTPTypeIdMismatch)); 

        static_cast<TMTPTypeUint8&>(chunk->Data()).Set(aData);

        }

        break;

    case EMTPTypeUINT8:

        {

        TMTPTypeUint8* chunk(static_cast<TMTPTypeUint8*>(iChunks[info.iChunkId]));

        chunk->Set(aData);

        }

        break;

    default:

        Panic(EMTPTypeIdMismatch);

        break;

        }

    }

/**

Updates the specified element.

@param aElementId The identifier of the element to update.

@param aData The source data.

@leave KErrNotSupported, if the element is not writeable.

@leave One of the system wide error code, if a processing error occurs. 

@panic MTPDataTypes 3, if the source data type does not match the requested 

element.

*/    

EXPORT_C void CMTPTypeCompoundBase::SetUint16L(TInt aElementId, TUint16 aData)

    {

    if (!WriteableElementL(aElementId))

        {

        User::Leave(KErrNotSupported);            

        }

    const TElementInfo& info(ElementInfo(aElementId));

    switch (info.iType)

        {

    case EMTPTypeFlat:

        {

        RMTPTypeCompoundFlatChunk* chunk(static_cast<RMTPTypeCompoundFlatChunk*>(iChunks[info.iChunkId]));

        chunk->SetUint16(aElementId, aData);

        }

        break;

    case EMTPTypeReference:

        {

        RMTPType* chunk(static_cast<RMTPType*>(iChunks[info.iChunkId]));

        __ASSERT_DEBUG(chunk->Type() == EMTPTypeUINT16, Panic(EMTPTypeIdMismatch)); 

        static_cast<TMTPTypeUint16&>(chunk->Data()).Set(aData);

        }

        break;

    case EMTPTypeUINT16:

        {

        TMTPTypeUint16* chunk(static_cast<TMTPTypeUint16*>(iChunks[info.iChunkId]));

        chunk->Set(aData);

        }

        break;

    default:

        Panic(EMTPTypeIdMismatch);

        break;

        }

    }

/**

Updates the specified element.

@param aElementId The identifier of the element to update.

@param aData The source data.

@leave KErrNotSupported, if the element is not writeable.

@leave One of the system wide error code, if a processing error occurs. 

@panic MTPDataTypes 3, if the source data type does not match the requested 

element.

*/    

EXPORT_C void CMTPTypeCompoundBase::SetUint32L(TInt aElementId, TUint32 aData)

    {

    if (!WriteableElementL(aElementId))

        {

        User::Leave(KErrNotSupported);            

        }

    const TElementInfo& info(ElementInfo(aElementId));

    switch (info.iType)

        {

    case EMTPTypeFlat:

        {

        RMTPTypeCompoundFlatChunk* chunk(static_cast<RMTPTypeCompoundFlatChunk*>(iChunks[info.iChunkId]));

        chunk->SetUint32(aElementId, aData);

        }

        break;

    case EMTPTypeReference:

        {

        RMTPType* chunk(static_cast<RMTPType*>(iChunks[info.iChunkId]));

        __ASSERT_DEBUG(chunk->Type() == EMTPTypeUINT32, Panic(EMTPTypeIdMismatch)); 

        static_cast<TMTPTypeUint32&>(chunk->Data()).Set(aData);

        }

        break;

    case EMTPTypeUINT32:

        {

        TMTPTypeUint32* chunk(static_cast<TMTPTypeUint32*>(iChunks[info.iChunkId]));

        chunk->Set(aData);

        }

        break;

    default:

        Panic(EMTPTypeIdMismatch);

        break;

        }

    }

/**

Updates the specified element.

@param aElementId The identifier of the element to update.

@param aData The source data.

@leave KErrNotSupported, if the element is not writeable.

@leave One of the system wide error code, if a processing error occurs. 

@panic MTPDataTypes 3, if the source data type does not match the requested 

element.

*/    

EXPORT_C void CMTPTypeCompoundBase::SetUint64L(TInt aElementId, TUint64 aData)

    {

    if (!WriteableElementL(aElementId))

        {

        User::Leave(KErrNotSupported);            

        }

    const TElementInfo& info(ElementInfo(aElementId));

    switch (info.iType)

        {

    case EMTPTypeFlat:

        {

        RMTPTypeCompoundFlatChunk* chunk(static_cast<RMTPTypeCompoundFlatChunk*>(iChunks[info.iChunkId]));

        chunk->SetUint64(aElementId, aData);

        }

        break;

    case EMTPTypeReference:

        {

        RMTPType* chunk(static_cast<RMTPType*>(iChunks[info.iChunkId]));

        __ASSERT_DEBUG(chunk->Type() == EMTPTypeUINT64, Panic(EMTPTypeIdMismatch)); 

        static_cast<TMTPTypeUint64&>(chunk->Data()).Set(aData);

        }

        break;

    case EMTPTypeUINT64:

        {

        TMTPTypeUint64* chunk(static_cast<TMTPTypeUint64*>(iChunks[info.iChunkId]));

        chunk->Set(aData);

        }

        break;

    default:

        Panic(EMTPTypeIdMismatch);

        break;

        }

    }

/**

Updates the specified element.

@param aElementId The identifier of the element to update.

@param aString The source data.

@leave KErrNotSupported, if the element is not writeable.

@leave One of the system wide error code, if a processing error occurs. 

@panic MTPDataTypes 3, if the source data type does not match the requested 

element.

*/    

EXPORT_C void CMTPTypeCompoundBase::SetStringL(TInt aElementId, const TDesC& aString)

    {

    if (!WriteableElementL(aElementId))

        {

        User::Leave(KErrNotSupported);            

        }

    const TElementInfo& info(ElementInfo(aElementId));

    switch (info.iType)

        {

    case EMTPTypeReference:

        {

        RMTPType* chunk(static_cast<RMTPType*>(iChunks[info.iChunkId]));

        __ASSERT_DEBUG(chunk->Type() == EMTPTypeString, Panic(EMTPTypeIdMismatch)); 

        static_cast<CMTPTypeString&>(chunk->Data()).SetL(aString);

        }

        break;

    case EMTPTypeString:

        {

        CMTPTypeString* chunk(static_cast<CMTPTypeString*>(iChunks[info.iChunkId]));

        chunk->SetL(aString);

        }

        break;

    default:

        Panic(EMTPTypeIdMismatch);

        break;

        }

    }

/**

Provides the value of the specified element.

@param aElementId The identifier of the requested element.

@return The value of the element.

@leave KErrNotSupported, if the element is not readable.

@leave One of the system wide error code, if a processing error occurs. 

@panic MTPDataTypes 3, if the source buffer type does not match the requested 

element.

*/

EXPORT_C TInt8 CMTPTypeCompoundBase::Int8L(TInt aElementId) const

    {

    if (!ReadableElementL(aElementId))

        {

        User::Leave(KErrNotSupported);            

        }

    TInt8 ret(0);

    const TElementInfo& info(ElementInfo(aElementId));

    switch (info.iType)

        {

    case EMTPTypeFlat: