1 // Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 /**

    17  @file

    18  @publishedPartner

    19 */

    20 

    21 #include <mtp/mtpdatatypeconstants.h>

    22 #include <mtp/mtptypescomplex.h>

    23 #include <mtp/mtptypessimple.h>

    24 #include <mtp/rmtptype.h>

    25 #include <mtp/tmtptypedatapair.h>

    26 #include <mtp/cmtptypeobjectpropdesc.h>

    27 #include <mtp/cmtptypeserviceprop.h>

    28 #include <mtp/cmtptypeserviceformat.h>

    29 #include <mtp/cmtptypeservicemethod.h>

    30 #include <mtp/cmtptypeserviceevent.h>

    31 #include <mtp/cmtptypeservicepropdesclist.h>

    32 #include <mtp/cmtptypeservicecapabilitylist.h>

    33 

    34 #include "mtpdatatypespanic.h"

    35 

    36 

    37 /**

    38 Constructor.

    39 */

    40 EXPORT_C RMTPType::RMTPType() :

    41     iData(NULL)

    42     {

    43 

    44     }

    45 

    46 /**

    47 Destructor

    48 */

    49 EXPORT_C RMTPType::~RMTPType()

    50     {

    51     Close();

    52     }

    53     

    54 /**

    55 Pushes a cleanup item for the managed data type onto the cleanup stack. The effect 

    56 of which is to cause Close() to be called on the managed data type when 

    57 CleanupStack::PopAndDestroy() is called at some later time.

    58 

    59 @code

    60 ...

    61 RMTPType x;

    62 ...

    63 x.OpenL(EMTPTypeAUINT32);

    64 x.CleanupClosePushL();

    65 ...

    66 CleanupStack::PopAndDestroy();

    67 ...

    68 @endcode

    69 @see RMTPType::Close()

    70 */

    71 EXPORT_C void RMTPType::CleanupClosePushL()

    72     {

    73     ::CleanupClosePushL(*this);

    74     }

    75 

    76 /**

    77 Releases the storage assigned to the data type.

    78 @panic MTPDataTypes 5, if the type's data type identifier datacode is 

    79 not supported.

    80 */

    81 EXPORT_C void RMTPType::Close()

    82     {

    83     if (iData)

    84         {

    85         switch (iData->Type())

    86             {

    87         case EMTPTypeINT8:

    88             delete static_cast<TMTPTypeInt8*> (iData);

    89             break;

    90 

    91         case EMTPTypeUINT8:

    92             delete static_cast<TMTPTypeUint8*> (iData);

    93             break;

    94             

    95         case EMTPTypeINT16:

    96             delete static_cast<TMTPTypeInt16*> (iData);

    97             break;

    98             

    99         case EMTPTypeUINT16:

   100             delete static_cast<TMTPTypeUint16*> (iData);

   101             break;

   102             

   103         case EMTPTypeINT32:

   104             delete static_cast<TMTPTypeInt32*> (iData);

   105             break;

   106             

   107         case EMTPTypeUINT32:

   108             delete static_cast<TMTPTypeUint32*> (iData);

   109             break;

   110             

   111         case EMTPTypeINT64:

   112             delete static_cast<TMTPTypeInt64*> (iData);

   113             break;

   114             

   115         case EMTPTypeUINT64:

   116             delete static_cast<TMTPTypeUint64*> (iData);

   117             break;

   118             

   119         case EMTPTypeINT128:

   120             delete static_cast<TMTPTypeInt128*> (iData);

   121             break;

   122             

   123         case EMTPTypeUINT128:

   124             delete static_cast<TMTPTypeUint128*> (iData);

   125             break;

   126             

   127         case EMTPTypeAINT8:

   128         case EMTPTypeAUINT8:

   129         case EMTPTypeAINT16:

   130         case EMTPTypeAUINT16:

   131         case EMTPTypeAINT32:

   132         case EMTPTypeAUINT32:

   133         case EMTPTypeAINT64:

   134         case EMTPTypeAUINT64:

   135         case EMTPTypeAINT128:

   136         case EMTPTypeAUINT128:

   137             delete static_cast<CMTPTypeArray*> (iData);

   138             break;

   139             

   140         case EMTPTypeString:

   141             delete static_cast<CMTPTypeString*> (iData);

   142             break;

   143             

   144         default: 

   145             Destroy(iData);

   146             break;

   147             }

   148             

   149         iData = NULL;

   150         }

   151     }

   152 

   153 /**

   154 Allocates storage for the data type. By default all MTP simple (signed and 

   155 unsigned integer), array (signed and unsigned integer), and string types are 

   156 supported. Support for any other data types must be provided by a derived 

   157 subclass which implements suitable CreateL and Destroy methods. This method 

   158 will release any pre-existing allocated storage.

   159 @param aDataType The type's data type identifier datacode.

   160 @leave One of the system wide error codes, if a processing failure occurs.

   161 @panic MTPDataTypes 5, if the type's data type identifier datacode is 

   162 not supported.

   163 @see CreateL

   164 @see Destroy

   165 */

   166 EXPORT_C void RMTPType::OpenL(TUint aDataType)

   167     {

   168     if (iData)

   169         {

   170         Close();

   171         }

   172         

   173     iData = AllocL(aDataType);

   174     if (!iData)

   175         {

   176         // Type is not supported. Pass to the derived class (if any).

   177         iData = CreateL(aDataType);

   178         }

   179     }

   180     

   181 EXPORT_C MMTPType& RMTPType::Data()

   182     {

   183     __ASSERT_ALWAYS(iData, Panic(EMTPTypeBadStorage));

   184     return *iData;

   185     }

   186     

   187 EXPORT_C TInt RMTPType::FirstReadChunk(TPtrC8& aChunk) const

   188     {

   189     __ASSERT_ALWAYS(iData, Panic(EMTPTypeBadStorage));

   190     return iData->FirstReadChunk(aChunk);

   191     }

   192 

   193 EXPORT_C TInt RMTPType::NextReadChunk(TPtrC8& aChunk) const

   194     {

   195     __ASSERT_ALWAYS(iData, Panic(EMTPTypeBadStorage));

   196     return iData->NextReadChunk(aChunk);

   197     }

   198 

   199 EXPORT_C TInt RMTPType::FirstWriteChunk(TPtr8& aChunk)

   200     {

   201     __ASSERT_ALWAYS(iData, Panic(EMTPTypeBadStorage));

   202     return iData->FirstWriteChunk(aChunk);

   203     }

   204     

   205 EXPORT_C TInt RMTPType::NextWriteChunk(TPtr8& aChunk)

   206     {

   207     __ASSERT_ALWAYS(iData, Panic(EMTPTypeBadStorage));

   208     return iData->NextWriteChunk(aChunk);

   209     }

   210 

   211 EXPORT_C TUint64 RMTPType::Size() const

   212     {

   213     __ASSERT_ALWAYS(iData, Panic(EMTPTypeBadStorage));

   214     return iData->Size();

   215     }

   216 

   217 EXPORT_C TUint RMTPType::Type() const

   218     {

   219     __ASSERT_ALWAYS(iData, Panic(EMTPTypeBadStorage));

   220     return iData->Type();

   221     }

   222 

   223 EXPORT_C TBool RMTPType::CommitRequired() const

   224     {

   225     __ASSERT_ALWAYS(iData, Panic(EMTPTypeBadStorage));

   226     return iData->CommitRequired();

   227     }

   228 

   229 EXPORT_C MMTPType* RMTPType::CommitChunkL(TPtr8& aChunk)

   230     {

   231     __ASSERT_ALWAYS(iData, Panic(EMTPTypeBadStorage));

   232     return iData->CommitChunkL(aChunk);

   233     }

   234     

   235 EXPORT_C TInt RMTPType::Validate() const

   236     {

   237     TInt ret(KMTPDataTypeInvalid);

   238     if (iData)

   239         {

   240         ret = iData->Validate();

   241         }

   242     return ret;

   243     }

   244     

   245 /**

   246 Allocates storage for non-default data types. Non-default data types can be 

   247 supported by a derived class which overides both this and the Destroy methods.

   248 @param aDataType The type's data type identifier datacode.

   249 @return A pointer to the allocated data type storage. Ownership IS transferred.

   250 @leave KMTPDataTypeInvalid, if the type's data type identifier datacode is 

   251 not supported.

   252 @leave One of the system wide error codes, if a processing failure occurs.

   253 @see Destroy

   254 */

   255 EXPORT_C MMTPType* RMTPType::CreateL(TUint aDataType)

   256     {

   257     MMTPType* type(AllocL(aDataType));

   258     if (!type)

   259         {

   260         User::Leave(KMTPDataTypeInvalid);   

   261         }

   262 

   263     return type;  

   264     }

   265 

   266 /**

   267 Releases the storage assigned to the data type. Non-default data types can be 

   268 supported by a derived class which overides both this and the CreateL methods.

   269 @panic MTPDataTypes 5, if the type's data type identifier datacode is 

   270 not supported.

   271 @see CreateL

   272 */

   273 EXPORT_C void RMTPType::Destroy(MMTPType* /*aType*/)

   274     {

   275     Panic(EMTPTypeNotSupported);

   276     }

   277     

   278 MMTPType* RMTPType::AllocL(const TUint aDataType)

   279     {

   280     MMTPType* type(0);

   281     switch (aDataType)

   282         {

   283     case EMTPTypeINT8:

   284         type = new(ELeave) TMTPTypeInt8();

   285         break;

   286         

   287     case EMTPTypeUINT8:

   288         type = new(ELeave) TMTPTypeUint8();

   289         break;

   290         

   291     case EMTPTypeINT16:

   292         type = new(ELeave) TMTPTypeInt16();

   293         break;

   294         

   295     case EMTPTypeUINT16:

   296         type = new(ELeave) TMTPTypeUint16();

   297         break;

   298         

   299     case EMTPTypeINT32:

   300         type = new(ELeave) TMTPTypeInt32();

   301         break;

   302         

   303     case EMTPTypeUINT32:

   304         type = new(ELeave) TMTPTypeUint32();

   305         break;

   306         

   307     case EMTPTypeINT64:

   308         type = new(ELeave) TMTPTypeInt64();

   309         break;

   310         

   311     case EMTPTypeUINT64:

   312         type = new(ELeave) TMTPTypeUint64();

   313         break;

   314         

   315     case EMTPTypeINT128:

   316         type = new(ELeave) TMTPTypeInt128();

   317         break;

   318         

   319     case EMTPTypeUINT128:

   320         type = new(ELeave) TMTPTypeUint128();

   321         break;

   322         

   323     case EMTPTypeAINT8:

   324     case EMTPTypeAUINT8:

   325     case EMTPTypeAINT16:

   326     case EMTPTypeAUINT16:

   327     case EMTPTypeAINT32:

   328     case EMTPTypeAUINT32:

   329     case EMTPTypeAINT64:

   330     case EMTPTypeAUINT64:

   331     case EMTPTypeAINT128:

   332     case EMTPTypeAUINT128:

   333         type = CMTPTypeArray::NewL(aDataType);

   334         break;

   335         

   336     case EMTPTypeString:

   337         type = CMTPTypeString::NewL();

   338         break;

   339     case EMTPTypeDataPair:

   340         {

   341         type = new(ELeave) TMTPTypeDataPair();

   342         }

   343         break;

   344     case EMTPTypeObjectPropDescDataset:

   345     	type = CMTPTypeObjectPropDesc::NewL();

   346     	break;

   347     case EMTPTypeFormatCapabilityDataset:

   348     	type = CMTPTypeFormatCapability::NewL();

   349     	break;

   350     case EMTPTypeServicePropDesc:

   351     	type = CMTPTypeServicePropDesc::NewL();

   352     	break;

   353     case EMTPTypeServicePropertyElementDataset:

   354     	type = CMTPTypeServicePropertyElement::NewL();

   355     	break;

   356     case EMTPTypeServiceFormatElementDataset:

   357     	type = CMTPTypeServiceFormatElement::NewL();

   358     	break;

   359     case EMTPTypeServiceMethodElementDataset:

   360     	type = CMTPTypeServiceMethodElement::NewL();

   361     	break;

   362     case EMTPTypeServiceEventElementDataset:

   363     	type = CMTPTypeServiceEventElement::NewL();

   364     	break; 

   365     default: 

   366         break;

   367         }

   368         

   369     return type;

   370     }

   371 

   372 void RMTPType::Destroy(const TUint aDataType, MMTPType* aData)

   373     {

   374     switch ( aDataType )

   375         {

   376     case EMTPTypeINT8:

   377         delete static_cast<TMTPTypeInt8*> (aData);

   378         break;

   379 

   380     case EMTPTypeUINT8:

   381         delete static_cast<TMTPTypeUint8*> (aData);

   382         break;

   383         

   384     case EMTPTypeINT16:

   385         delete static_cast<TMTPTypeInt16*> (aData);

   386         break;

   387         

   388     case EMTPTypeUINT16:

   389         delete static_cast<TMTPTypeUint16*> (aData);

   390         break;

   391         

   392     case EMTPTypeINT32:

   393         delete static_cast<TMTPTypeInt32*> (aData);

   394         break;

   395         

   396     case EMTPTypeUINT32:

   397         delete static_cast<TMTPTypeUint32*> (aData);

   398         break;

   399         

   400     case EMTPTypeINT64:

   401         delete static_cast<TMTPTypeInt64*> (aData);

   402         break;

   403         

   404     case EMTPTypeUINT64:

   405         delete static_cast<TMTPTypeUint64*> (aData);

   406         break;

   407         

   408     case EMTPTypeINT128:

   409         delete static_cast<TMTPTypeInt128*> (aData);

   410         break;

   411         

   412     case EMTPTypeUINT128:

   413         delete static_cast<TMTPTypeUint128*> (aData);

   414         break;

   415         

   416     case EMTPTypeAINT8:

   417     case EMTPTypeAUINT8:

   418     case EMTPTypeAINT16:

   419     case EMTPTypeAUINT16:

   420     case EMTPTypeAINT32:

   421     case EMTPTypeAUINT32:

   422     case EMTPTypeAINT64:

   423     case EMTPTypeAUINT64:

   424     case EMTPTypeAINT128:

   425     case EMTPTypeAUINT128:

   426         delete static_cast<CMTPTypeArray*> (aData);

   427         break;

   428     case EMTPTypeString:

   429         delete static_cast<CMTPTypeString*> (aData);

   430         break;

   431     case EMTPTypeDataPair:

   432         delete static_cast<TMTPTypeDataPair*>(aData);

   433         break;

   434     case EMTPTypeObjectPropDescDataset:

   435         delete static_cast<CMTPTypeObjectPropDesc*> (aData);

   436         break;

   437     case EMTPTypeFormatCapabilityDataset:

   438         delete static_cast<CMTPTypeFormatCapability*> (aData);

   439         break;

   440     case EMTPTypeServicePropDesc:

   441         delete static_cast<CMTPTypeServicePropDesc*> (aData);

   442         break;

   443     case EMTPTypeServicePropertyElementDataset:

   444         delete static_cast<CMTPTypeServicePropertyElement*> (aData);

   445         break;

   446     case EMTPTypeServiceFormatElementDataset:

   447         delete static_cast<CMTPTypeServiceFormatElement*> (aData);

   448         break;

   449     case EMTPTypeServiceMethodElementDataset:

   450         delete static_cast<CMTPTypeServiceMethodElement*> (aData);

   451         break;

   452     case EMTPTypeServiceEventElementDataset:

   453         delete static_cast<CMTPTypeServiceEventElement*> (aData);

   454         break;     

   455             

   456     default: 

   457         Panic(EMTPTypeNotSupported);

   458         break;

   459         }

   460 

   461     }