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

#include "mtpdatatypespanic.h"

#include <mtp/tmtptypedatapair.h>

const TUint CMTPTypeList::KChunkNumberofElements(0);

const TUint CMTPTypeList::KChunckNumberOfHeader(1);

EXPORT_C CMTPTypeList* CMTPTypeList::NewL(TMTPTypeIds aListType, TMTPTypeIds aElementType)

    {

    CMTPTypeList* self = CMTPTypeList::NewLC(aListType, aElementType); 

    CleanupStack::Pop(self);

    return self;  

    }

EXPORT_C CMTPTypeList* CMTPTypeList::NewLC(TMTPTypeIds aListType, TMTPTypeIds aElementType)

    {

    CMTPTypeList* self = new(ELeave) CMTPTypeList(aListType, aElementType);

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

EXPORT_C  CMTPTypeList::~CMTPTypeList()

    {

    ResetAndDestroy();

    }

CMTPTypeList::CMTPTypeList(TInt aListType, TInt aElementType):

    CMTPTypeCompoundBase(KJustInTimeConstruction, KVariableChunkCount),

    iListType(aListType),

    iElementType(aElementType),

    iChunkNumberOfElements(KChunkNumberofElements)

    {

    const CMTPTypeCompoundBase::TElementInfo KDefaultInfo = {0, EMTPTypeUndefined, {EMTPTypeUndefined, KMTPNotApplicable,  KMTPNotApplicable}};

    iInfoNumberOfElements       = KDefaultInfo; 

    iInfoNumberOfElements.iType = EMTPTypeUINT32;

    iInfoElement                = KDefaultInfo; 

    iInfoElement.iType          = aElementType;

    }

void CMTPTypeList::InitListL()

    {

    ChunkAppendL(iChunkNumberOfElements);

    }

void CMTPTypeList::ConstructL()

    {

    InitListL();

    }

EXPORT_C void CMTPTypeList::AppendL(const MMTPType* aElement)

    {

    if (aElement == NULL)

        {

        User::Leave(KMTPDataTypeInvalid);

        }

    // Append the element.

    AppendElementChunkL(aElement);

    // Increment NumberOfElements.

    const TUint index(iChunkNumberOfElements.Value());

    iChunkNumberOfElements.Set(index + 1);

    }

EXPORT_C void CMTPTypeList::Remove(const TInt aIndex)

    {

    MMTPType* tmp = iChunksElement[aIndex];

    iChunksElement.Remove(aIndex);

    ChunkRemove(aIndex + 1);

    RMTPType::Destroy(iElementType,tmp );

    const TUint index(iChunkNumberOfElements.Value());

    iChunkNumberOfElements.Set(index - 1);

    }

EXPORT_C TInt CMTPTypeList::ElementType() const

    {

    return iElementType;

    }

EXPORT_C TUint32 CMTPTypeList::NumberOfElements() const

    {

    return iChunkNumberOfElements.Value();

    }

EXPORT_C MMTPType& CMTPTypeList::ElementL(const TInt aIndex) const

	{

	__ASSERT_ALWAYS(( aIndex < NumberOfElements() ), User::Leave(EMTPTypeBoundsError));

	return *iChunksElement[aIndex];

	}

EXPORT_C TInt CMTPTypeList::FirstWriteChunk(TPtr8& aChunk)

    {

    ResetAndDestroy();

    // Setup the write chunk pointer.

    TInt err(UpdateWriteSequenceErr(CMTPTypeCompoundBase::FirstWriteChunk(aChunk)));

    switch (err)

        {

    case KMTPChunkSequenceCompletion:

        err = KErrNone;

        // Don't break, fall through to set the write sequence state.

    case KErrNone:

        // Set the write sequence state.

        iWriteSequenceState = EElementChunks;

        break;

    default:

        break;

        }

    return  err;

    }

EXPORT_C TInt CMTPTypeList::NextWriteChunk(TPtr8& aChunk)

    {

    TInt err(KMTPChunkSequenceCompletion);

    if (iWriteSequenceState != EIdle)

        {

        err = UpdateWriteSequenceErr(CMTPTypeCompoundBase::NextWriteChunk(aChunk));

        if ((iWriteSequenceErr == KMTPChunkSequenceCompletion) && (iWriteSequenceState != EIdle))

            {

            err = KErrNone;

            }   

        }    

    return err;

    }

EXPORT_C TInt CMTPTypeList::NextWriteChunk(TPtr8& aChunk, TUint /*aDataLength*/)

	{

	return NextWriteChunk(aChunk);

	}

EXPORT_C TUint CMTPTypeList::Type() const

    {

    return iListType;

    }

EXPORT_C TBool CMTPTypeList::CommitRequired() const

    {

    return ETrue;

    }

EXPORT_C MMTPType* CMTPTypeList::CommitChunkL(TPtr8& aChunk)

    {

    if (iWriteSequenceErr == KMTPChunkSequenceCompletion)

        {

        switch (iWriteSequenceState)

            {

        case EElementChunks:

            if ((iChunkNumberOfElements.Value()) && 

                (iChunksElement.Count() < iChunkNumberOfElements.Value()))

                {

                MMTPType* element = RMTPType::AllocL(iElementType);

                CleanupStack::PushL(element);

                AppendElementChunkL(element);

                CleanupStack::Pop(element); 

                }

            else

                {

                iWriteSequenceState = EIdle;

                }

            break;

        case EIdle:

            // Completing the last chunk in the write sequence.

            break;

        default:

            Panic(EMTPTypeBadStorage);

            break;

            }

        }

    if (CMTPTypeCompoundBase::CommitRequired())

        {

        CMTPTypeCompoundBase::CommitChunkL(aChunk);

        }     

    return NULL;

    }

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

    {

    if (aElementId == KChunkNumberofElements)

        {

        return iInfoNumberOfElements;

        }

    else

        {

        __ASSERT_ALWAYS(((aElementId - KChunckNumberOfHeader) < iChunkNumberOfElements.Value()), Panic(EMTPTypeBoundsError));

        iInfoElement.iChunkId = aElementId;

        return iInfoElement; 

        }

    }

TInt CMTPTypeList::ValidateChunkCount() const

    {

    if (NumberOfElements() != (ChunkCount() - 1))

        {

        return KMTPDataTypeInvalid;

        }

    return KErrNone;

    }

TInt CMTPTypeList::UpdateWriteSequenceErr(TInt aErr)

    {

    iWriteSequenceErr = aErr;

    return iWriteSequenceErr;        

    }

void CMTPTypeList::AppendElementChunkL(const MMTPType* aElement)

    {

    iChunksElement.AppendL(aElement);

    ChunkAppendL(*aElement);

    }

EXPORT_C void CMTPTypeList::ResetAndDestroy()

    {

    const TUint num = iChunksElement.Count();

    for(TInt i = num -1  ; i  >= 0 ; i-- )

        {

        Remove(i);

        }

    iChunksElement.Close();

    }