--- /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;
+ }
+
+ }