--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/mtpfws/mtpfw/datatypes/src/cmtptypelist.cpp	Tue Feb 02 01:11:40 2010 +0200
@@ -0,0 +1,259 @@
+// 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();
+    }
+