// 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/tmtptypeflatbase.h>

#include <mtp/cmtptypeobjectpropdesc.h>

#include <mtp/cmtptypeinterdependentpropdesc.h>

#include <mtp/cmtptypeservicecapabilitylist.h>

#include "mtpdatatypespanic.h"

// Dataset constants

const TUint KMTPChunk0Size = 2;

// Dataset element metadata.

const CMTPTypeCompoundBase::TElementInfo CMTPTypeFormatCapability::iElementMetaData[CMTPTypeFormatCapability::ENumElements] = 

    {

        {EIdFlatChunk,                          EMTPTypeFlat,                          {EMTPTypeUINT16,    0,                  KMTPTypeUINT16Size}},   // EFormatCode

   };

EXPORT_C CMTPTypeServiceCapabilityList* CMTPTypeServiceCapabilityList::NewL()

    {

    CMTPTypeServiceCapabilityList* self = CMTPTypeServiceCapabilityList::NewLC(); 

    CleanupStack::Pop(self);

    return self;  

    }

EXPORT_C CMTPTypeServiceCapabilityList* CMTPTypeServiceCapabilityList::NewLC()

    {

    CMTPTypeServiceCapabilityList* self = new(ELeave) CMTPTypeServiceCapabilityList();

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

EXPORT_C CMTPTypeServiceCapabilityList::~CMTPTypeServiceCapabilityList()

    {

    }

EXPORT_C void CMTPTypeServiceCapabilityList::AppendL(CMTPTypeFormatCapability* aElement)

    {

    CMTPTypeList::AppendL(aElement);

    }

EXPORT_C CMTPTypeFormatCapability& CMTPTypeServiceCapabilityList::ElementL(TUint aIndex) const

	{

	return static_cast<CMTPTypeFormatCapability&>( CMTPTypeList::ElementL(aIndex) );

	}

CMTPTypeServiceCapabilityList::CMTPTypeServiceCapabilityList():

	CMTPTypeList(EMTPTypeServiceCapabilityListDataset,EMTPTypeFormatCapabilityDataset)

    {

    }

void CMTPTypeServiceCapabilityList::ConstructL()

    {

    InitListL();

    }

EXPORT_C CMTPTypeFormatCapability* CMTPTypeFormatCapability::NewL()

    {

    CMTPTypeFormatCapability* self = CMTPTypeFormatCapability::NewLC(); 

    CleanupStack::Pop(self);

    return self; 

    }

EXPORT_C CMTPTypeFormatCapability* CMTPTypeFormatCapability::NewLC()

    {

    CMTPTypeFormatCapability* self = new (ELeave) CMTPTypeFormatCapability( NULL ); 

    CleanupStack::PushL(self); 

    self->ConstructL();

    return self;    

    }

EXPORT_C CMTPTypeFormatCapability* CMTPTypeFormatCapability::NewL(const TUint16 aFormatCode, CMTPTypeInterdependentPropDesc* aInterDependentPropDesc )

    {

    CMTPTypeFormatCapability* self = CMTPTypeFormatCapability::NewLC( aFormatCode, aInterDependentPropDesc ); 

    CleanupStack::Pop(self);

    return self; 

    }

EXPORT_C CMTPTypeFormatCapability* CMTPTypeFormatCapability::NewLC(const TUint16 aFormatCode, CMTPTypeInterdependentPropDesc* aInterDependentPropDesc )

    {

    CMTPTypeFormatCapability* self = new (ELeave) CMTPTypeFormatCapability( aInterDependentPropDesc ); 

    CleanupStack::PushL(self); 

    self->ConstructL( aFormatCode );

    return self;    

    }

EXPORT_C CMTPTypeFormatCapability::~CMTPTypeFormatCapability()

    {    

    iChunkFlat.Close();

    delete iObjectPropDescList;

    delete iInterdependentPropDesc;

    }

EXPORT_C void CMTPTypeFormatCapability::AppendL(CMTPTypeObjectPropDesc* aElement)

    {

    __ASSERT_DEBUG(aElement, User::Invariant());

    iObjectPropDescList->AppendL( static_cast<MMTPType*>(aElement));

    }

EXPORT_C TUint32 CMTPTypeFormatCapability::NumberOfPropDescs() const

    {

    return iObjectPropDescList->NumberOfElements();

    }

EXPORT_C CMTPTypeObjectPropDesc& CMTPTypeFormatCapability::ObjectPropDescL(TUint aIndex) const

    {

     return static_cast<CMTPTypeObjectPropDesc&>(iObjectPropDescList->ElementL( aIndex ));

    }

EXPORT_C CMTPTypeInterdependentPropDesc& CMTPTypeFormatCapability::InterdependentPropDesc() const

    {

    return *iInterdependentPropDesc;

    }

EXPORT_C TUint CMTPTypeFormatCapability::Type() const

    {

    return EMTPTypeFormatCapabilityDataset;

    }

EXPORT_C TBool CMTPTypeFormatCapability::ReadableElementL(TInt aElementId) const

    {

    if( aElementId == EFormatCode)

        {

        return ETrue;

        }

    else

        {

        return EFalse;

        }

    }

EXPORT_C TBool CMTPTypeFormatCapability::WriteableElementL(TInt aElementId ) const

    {

    if( aElementId == EFormatCode)

           {

           return ETrue;

           }

       else

           {

           return EFalse;

           } 

    }

const CMTPTypeCompoundBase::TElementInfo& CMTPTypeFormatCapability::ElementInfo(TInt aElementId) const

    {

    return iElementInfo[aElementId];

    }

CMTPTypeFormatCapability::CMTPTypeFormatCapability( CMTPTypeInterdependentPropDesc* aInterDependentPropDesc) : 

    CMTPTypeCompoundBase((!KJustInTimeConstruction), EIdNumChunks), 

    iElementInfo(iElementMetaData, ENumElements),

    iChunkFlat(KMTPChunk0Size, *this),

    iInterdependentPropDesc(aInterDependentPropDesc)

    {

    }

void CMTPTypeFormatCapability::ConstructL()

    {

    for (TUint i(0); (i < ENumElements); i++)

        {

        const TElementInfo& info(iElementInfo[i]);

        if (ChunkCount() <= info.iChunkId)

            {

            MMTPType* chunk(NULL);

            switch (info.iType)

                {

            case EMTPTypeFlat:

                chunk = NewFlatChunkL();

                break;  

            default:

                break;

                }

            __ASSERT_DEBUG(chunk, User::Invariant());

            ChunkAppendL(*chunk);

            }

        }

    iObjectPropDescList = CMTPTypeList::NewL(EMTPTypeFormatCapabilityDataset,EMTPTypeObjectPropDescDataset);

    if( NULL == iInterdependentPropDesc )

        {

        iInterdependentPropDesc = CMTPTypeInterdependentPropDesc::NewL();

        }

    ChunkAppendL(*iObjectPropDescList);

    ChunkAppendL(*iInterdependentPropDesc);

    }

MMTPType* CMTPTypeFormatCapability::NewFlatChunkL()

    {

    MMTPType* chunk(NULL);

    iChunkFlat.OpenL();

    chunk = &iChunkFlat;

    __ASSERT_DEBUG(chunk, User::Invariant());

    return chunk;

    }

void CMTPTypeFormatCapability::ConstructL(const TUint16 aFormatCode)

    {

    ConstructL();

    // Set mandatory construction values.

    SetUint16L(EFormatCode, aFormatCode);

    }