diff -r 000000000000 -r d0791faffa3f mtpfws/mtpfw/datatypes/src/rmtptype.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/mtpfws/mtpfw/datatypes/src/rmtptype.cpp	Tue Feb 02 01:11:40 2010 +0200
@@ -0,0 +1,461 @@
+// 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/mtpdatatypeconstants.h>
+#include <mtp/mtptypescomplex.h>
+#include <mtp/mtptypessimple.h>
+#include <mtp/rmtptype.h>
+#include <mtp/tmtptypedatapair.h>
+#include <mtp/cmtptypeobjectpropdesc.h>
+#include <mtp/cmtptypeserviceprop.h>
+#include <mtp/cmtptypeserviceformat.h>
+#include <mtp/cmtptypeservicemethod.h>
+#include <mtp/cmtptypeserviceevent.h>
+#include <mtp/cmtptypeservicepropdesclist.h>
+#include <mtp/cmtptypeservicecapabilitylist.h>
+
+#include "mtpdatatypespanic.h"
+
+
+/**
+Constructor.
+*/
+EXPORT_C RMTPType::RMTPType() :
+    iData(NULL)
+    {
+
+    }
+
+/**
+Destructor
+*/
+EXPORT_C RMTPType::~RMTPType()
+    {
+    Close();
+    }
+    
+/**
+Pushes a cleanup item for the managed data type onto the cleanup stack. The effect 
+of which is to cause Close() to be called on the managed data type when 
+CleanupStack::PopAndDestroy() is called at some later time.
+
+@code
+...
+RMTPType x;
+...
+x.OpenL(EMTPTypeAUINT32);
+x.CleanupClosePushL();
+...
+CleanupStack::PopAndDestroy();
+...
+@endcode
+@see RMTPType::Close()
+*/
+EXPORT_C void RMTPType::CleanupClosePushL()
+    {
+    ::CleanupClosePushL(*this);
+    }
+
+/**
+Releases the storage assigned to the data type.
+@panic MTPDataTypes 5, if the type's data type identifier datacode is 
+not supported.
+*/
+EXPORT_C void RMTPType::Close()
+    {
+    if (iData)
+        {
+        switch (iData->Type())
+            {
+        case EMTPTypeINT8:
+            delete static_cast<TMTPTypeInt8*> (iData);
+            break;
+
+        case EMTPTypeUINT8:
+            delete static_cast<TMTPTypeUint8*> (iData);
+            break;
+            
+        case EMTPTypeINT16:
+            delete static_cast<TMTPTypeInt16*> (iData);
+            break;
+            
+        case EMTPTypeUINT16:
+            delete static_cast<TMTPTypeUint16*> (iData);
+            break;
+            
+        case EMTPTypeINT32:
+            delete static_cast<TMTPTypeInt32*> (iData);
+            break;
+            
+        case EMTPTypeUINT32:
+            delete static_cast<TMTPTypeUint32*> (iData);
+            break;
+            
+        case EMTPTypeINT64:
+            delete static_cast<TMTPTypeInt64*> (iData);
+            break;
+            
+        case EMTPTypeUINT64:
+            delete static_cast<TMTPTypeUint64*> (iData);
+            break;
+            
+        case EMTPTypeINT128:
+            delete static_cast<TMTPTypeInt128*> (iData);
+            break;
+            
+        case EMTPTypeUINT128:
+            delete static_cast<TMTPTypeUint128*> (iData);
+            break;
+            
+        case EMTPTypeAINT8:
+        case EMTPTypeAUINT8:
+        case EMTPTypeAINT16:
+        case EMTPTypeAUINT16:
+        case EMTPTypeAINT32:
+        case EMTPTypeAUINT32:
+        case EMTPTypeAINT64:
+        case EMTPTypeAUINT64:
+        case EMTPTypeAINT128:
+        case EMTPTypeAUINT128:
+            delete static_cast<CMTPTypeArray*> (iData);
+            break;
+            
+        case EMTPTypeString:
+            delete static_cast<CMTPTypeString*> (iData);
+            break;
+            
+        default: 
+            Destroy(iData);
+            break;
+            }
+            
+        iData = NULL;
+        }
+    }
+
+/**
+Allocates storage for the data type. By default all MTP simple (signed and 
+unsigned integer), array (signed and unsigned integer), and string types are 
+supported. Support for any other data types must be provided by a derived 
+subclass which implements suitable CreateL and Destroy methods. This method 
+will release any pre-existing allocated storage.
+@param aDataType The type's data type identifier datacode.
+@leave One of the system wide error codes, if a processing failure occurs.
+@panic MTPDataTypes 5, if the type's data type identifier datacode is 
+not supported.
+@see CreateL
+@see Destroy
+*/
+EXPORT_C void RMTPType::OpenL(TUint aDataType)
+    {
+    if (iData)
+        {
+        Close();
+        }
+        
+    iData = AllocL(aDataType);
+    if (!iData)
+        {
+        // Type is not supported. Pass to the derived class (if any).
+        iData = CreateL(aDataType);
+        }
+    }
+    
+EXPORT_C MMTPType& RMTPType::Data()
+    {
+    __ASSERT_ALWAYS(iData, Panic(EMTPTypeBadStorage));
+    return *iData;
+    }
+    
+EXPORT_C TInt RMTPType::FirstReadChunk(TPtrC8& aChunk) const
+    {
+    __ASSERT_ALWAYS(iData, Panic(EMTPTypeBadStorage));
+    return iData->FirstReadChunk(aChunk);
+    }
+
+EXPORT_C TInt RMTPType::NextReadChunk(TPtrC8& aChunk) const
+    {
+    __ASSERT_ALWAYS(iData, Panic(EMTPTypeBadStorage));
+    return iData->NextReadChunk(aChunk);
+    }
+
+EXPORT_C TInt RMTPType::FirstWriteChunk(TPtr8& aChunk)
+    {
+    __ASSERT_ALWAYS(iData, Panic(EMTPTypeBadStorage));
+    return iData->FirstWriteChunk(aChunk);
+    }
+    
+EXPORT_C TInt RMTPType::NextWriteChunk(TPtr8& aChunk)
+    {
+    __ASSERT_ALWAYS(iData, Panic(EMTPTypeBadStorage));
+    return iData->NextWriteChunk(aChunk);
+    }
+
+EXPORT_C TUint64 RMTPType::Size() const
+    {
+    __ASSERT_ALWAYS(iData, Panic(EMTPTypeBadStorage));
+    return iData->Size();
+    }
+
+EXPORT_C TUint RMTPType::Type() const
+    {
+    __ASSERT_ALWAYS(iData, Panic(EMTPTypeBadStorage));
+    return iData->Type();
+    }
+
+EXPORT_C TBool RMTPType::CommitRequired() const
+    {
+    __ASSERT_ALWAYS(iData, Panic(EMTPTypeBadStorage));
+    return iData->CommitRequired();
+    }
+
+EXPORT_C MMTPType* RMTPType::CommitChunkL(TPtr8& aChunk)
+    {
+    __ASSERT_ALWAYS(iData, Panic(EMTPTypeBadStorage));
+    return iData->CommitChunkL(aChunk);
+    }
+    
+EXPORT_C TInt RMTPType::Validate() const
+    {
+    TInt ret(KMTPDataTypeInvalid);
+    if (iData)
+        {
+        ret = iData->Validate();
+        }
+    return ret;
+    }
+    
+/**
+Allocates storage for non-default data types. Non-default data types can be 
+supported by a derived class which overides both this and the Destroy methods.
+@param aDataType The type's data type identifier datacode.
+@return A pointer to the allocated data type storage. Ownership IS transferred.
+@leave KMTPDataTypeInvalid, if the type's data type identifier datacode is 
+not supported.
+@leave One of the system wide error codes, if a processing failure occurs.
+@see Destroy
+*/
+EXPORT_C MMTPType* RMTPType::CreateL(TUint aDataType)
+    {
+    MMTPType* type(AllocL(aDataType));
+    if (!type)
+        {
+        User::Leave(KMTPDataTypeInvalid);   
+        }
+
+    return type;  
+    }
+
+/**
+Releases the storage assigned to the data type. Non-default data types can be 
+supported by a derived class which overides both this and the CreateL methods.
+@panic MTPDataTypes 5, if the type's data type identifier datacode is 
+not supported.
+@see CreateL
+*/
+EXPORT_C void RMTPType::Destroy(MMTPType* /*aType*/)
+    {
+    Panic(EMTPTypeNotSupported);
+    }
+    
+MMTPType* RMTPType::AllocL(const TUint aDataType)
+    {
+    MMTPType* type(0);
+    switch (aDataType)
+        {
+    case EMTPTypeINT8:
+        type = new(ELeave) TMTPTypeInt8();
+        break;
+        
+    case EMTPTypeUINT8:
+        type = new(ELeave) TMTPTypeUint8();
+        break;
+        
+    case EMTPTypeINT16:
+        type = new(ELeave) TMTPTypeInt16();
+        break;
+        
+    case EMTPTypeUINT16:
+        type = new(ELeave) TMTPTypeUint16();
+        break;
+        
+    case EMTPTypeINT32:
+        type = new(ELeave) TMTPTypeInt32();
+        break;
+        
+    case EMTPTypeUINT32:
+        type = new(ELeave) TMTPTypeUint32();
+        break;
+        
+    case EMTPTypeINT64:
+        type = new(ELeave) TMTPTypeInt64();
+        break;
+        
+    case EMTPTypeUINT64:
+        type = new(ELeave) TMTPTypeUint64();
+        break;
+        
+    case EMTPTypeINT128:
+        type = new(ELeave) TMTPTypeInt128();
+        break;
+        
+    case EMTPTypeUINT128:
+        type = new(ELeave) TMTPTypeUint128();
+        break;
+        
+    case EMTPTypeAINT8:
+    case EMTPTypeAUINT8:
+    case EMTPTypeAINT16:
+    case EMTPTypeAUINT16:
+    case EMTPTypeAINT32:
+    case EMTPTypeAUINT32:
+    case EMTPTypeAINT64:
+    case EMTPTypeAUINT64:
+    case EMTPTypeAINT128:
+    case EMTPTypeAUINT128:
+        type = CMTPTypeArray::NewL(aDataType);
+        break;
+        
+    case EMTPTypeString:
+        type = CMTPTypeString::NewL();
+        break;
+    case EMTPTypeDataPair:
+        {
+        type = new(ELeave) TMTPTypeDataPair();
+        }
+        break;
+    case EMTPTypeObjectPropDescDataset:
+    	type = CMTPTypeObjectPropDesc::NewL();
+    	break;
+    case EMTPTypeFormatCapabilityDataset:
+    	type = CMTPTypeFormatCapability::NewL();
+    	break;
+    case EMTPTypeServicePropDesc:
+    	type = CMTPTypeServicePropDesc::NewL();
+    	break;
+    case EMTPTypeServicePropertyElementDataset:
+    	type = CMTPTypeServicePropertyElement::NewL();
+    	break;
+    case EMTPTypeServiceFormatElementDataset:
+    	type = CMTPTypeServiceFormatElement::NewL();
+    	break;
+    case EMTPTypeServiceMethodElementDataset:
+    	type = CMTPTypeServiceMethodElement::NewL();
+    	break;
+    case EMTPTypeServiceEventElementDataset:
+    	type = CMTPTypeServiceEventElement::NewL();
+    	break; 
+    default: 
+        break;
+        }
+        
+    return type;
+    }
+
+void RMTPType::Destroy(const TUint aDataType, MMTPType* aData)
+    {
+    switch ( aDataType )
+        {
+    case EMTPTypeINT8:
+        delete static_cast<TMTPTypeInt8*> (aData);
+        break;
+
+    case EMTPTypeUINT8:
+        delete static_cast<TMTPTypeUint8*> (aData);
+        break;
+        
+    case EMTPTypeINT16:
+        delete static_cast<TMTPTypeInt16*> (aData);
+        break;
+        
+    case EMTPTypeUINT16:
+        delete static_cast<TMTPTypeUint16*> (aData);
+        break;
+        
+    case EMTPTypeINT32:
+        delete static_cast<TMTPTypeInt32*> (aData);
+        break;
+        
+    case EMTPTypeUINT32:
+        delete static_cast<TMTPTypeUint32*> (aData);
+        break;
+        
+    case EMTPTypeINT64:
+        delete static_cast<TMTPTypeInt64*> (aData);
+        break;
+        
+    case EMTPTypeUINT64:
+        delete static_cast<TMTPTypeUint64*> (aData);
+        break;
+        
+    case EMTPTypeINT128:
+        delete static_cast<TMTPTypeInt128*> (aData);
+        break;
+        
+    case EMTPTypeUINT128:
+        delete static_cast<TMTPTypeUint128*> (aData);
+        break;
+        
+    case EMTPTypeAINT8:
+    case EMTPTypeAUINT8:
+    case EMTPTypeAINT16:
+    case EMTPTypeAUINT16:
+    case EMTPTypeAINT32:
+    case EMTPTypeAUINT32:
+    case EMTPTypeAINT64:
+    case EMTPTypeAUINT64:
+    case EMTPTypeAINT128:
+    case EMTPTypeAUINT128:
+        delete static_cast<CMTPTypeArray*> (aData);
+        break;
+    case EMTPTypeString:
+        delete static_cast<CMTPTypeString*> (aData);
+        break;
+    case EMTPTypeDataPair:
+        delete static_cast<TMTPTypeDataPair*>(aData);
+        break;
+    case EMTPTypeObjectPropDescDataset:
+        delete static_cast<CMTPTypeObjectPropDesc*> (aData);
+        break;
+    case EMTPTypeFormatCapabilityDataset:
+        delete static_cast<CMTPTypeFormatCapability*> (aData);
+        break;
+    case EMTPTypeServicePropDesc:
+        delete static_cast<CMTPTypeServicePropDesc*> (aData);
+        break;
+    case EMTPTypeServicePropertyElementDataset:
+        delete static_cast<CMTPTypeServicePropertyElement*> (aData);
+        break;
+    case EMTPTypeServiceFormatElementDataset:
+        delete static_cast<CMTPTypeServiceFormatElement*> (aData);
+        break;
+    case EMTPTypeServiceMethodElementDataset:
+        delete static_cast<CMTPTypeServiceMethodElement*> (aData);
+        break;
+    case EMTPTypeServiceEventElementDataset:
+        delete static_cast<CMTPTypeServiceEventElement*> (aData);
+        break;     
+            
+    default: 
+        Panic(EMTPTypeNotSupported);
+        break;
+        }
+
+    }