1 /*

     2 * Copyright (c) 2005-2008 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

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

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  ConML parser/generator

    15 *

    16 */

    17 

    18 

    19 #include "sconconmldtd.h"

    20 #include "sconconmltags.h"

    21 #include "sconconmlhandler.h"

    22 #include "sconconmlhandlererror.h"

    23 #include "debug.h"

    24 

    25 // -----------------------------------------------------------------------------

    26 // Macros

    27 // -----------------------------------------------------------------------------

    28 #define CHECK_NO_DUPLICATE(a) if( a ) { User::Leave( KWBXMLParserErrorinvalidDocument ); }

    29 

    30 // -----------------------------------------------------------------------------

    31 // pcdata_s

    32 // -----------------------------------------------------------------------------

    33 pcdata_s::pcdata_s( const pcdataType_t aType, const pcdataExtension_t aExt )

    34 	: contentType(aType), extension(aExt)

    35     {

    36     }

    37 

    38 pcdata_s::pcdata_s() : contentType(SML_PCDATA_OPAQUE), 

    39                        extension(SML_EXT_UNDEFINED)

    40     {

    41     }

    42 

    43 pcdata_s::~pcdata_s()

    44     {

    45     FreeContent();

    46     }

    47 

    48 void pcdata_s::FreeContent()

    49     {

    50     User::Free(content);

    51     content = 0;

    52     }

    53 

    54 void pcdata_s::SetDataL( const TDesC8& aData )

    55     {

    56     FreeContent();

    57     length = aData.Length();

    58     content = User::AllocL(length);

    59     Mem::Copy(content, aData.Ptr(), length);

    60     }

    61 

    62 TPtrC8 pcdata_s::Data() const

    63     {

    64     return TPtrC8((TUint8*)content, length);

    65     }

    66 

    67 void pcdata_s::TruncateL( TInt aConsumed )

    68     {

    69     HBufC8* buffer = TPtrC8((TUint8*)content + aConsumed, 

    70                              length - aConsumed).AllocLC();

    71     SetDataL(*buffer);

    72     CleanupStack::PopAndDestroy(); // buffer

    73     }

    74 

    75 pcdata_list_s::pcdata_list_s()

    76     {

    77     }

    78 

    79 pcdata_list_s::~pcdata_list_s()

    80     {

    81     delete data;

    82     delete next;

    83     }

    84 

    85 // -----------------------------------------------------------------------------

    86 // AddDriveL

    87 // -----------------------------------------------------------------------------

    88 CXMLElement* AddDriveL(  ConML_DriveListPtr_t* aList )

    89     {

    90     ConML_DriveListPtr_t itemL = new ( ELeave ) ConML_DriveList_t();

    91     CleanupStack::PushL( itemL );

    92     itemL->data = new ( ELeave ) ConML_Drive_t();

    93     GenericListAddL(aList, itemL);

    94     CleanupStack::Pop(); // itemL

    95     return itemL->data;

    96     }

    97 

    98 // -----------------------------------------------------------------------------

    99 // AddSIDL

   100 // -----------------------------------------------------------------------------

   101 CXMLElement* AddSIDL( ConML_SIDListPtr_t * aList )

   102     {

   103     ConML_SIDListPtr_t itemL = new ( ELeave ) ConML_SIDList_t();

   104     CleanupStack::PushL( itemL );

   105     itemL->data = new ( ELeave ) ConML_SID_t();

   106     GenericListAddL(aList, itemL);

   107     CleanupStack::Pop(); // itemL

   108     return itemL->data;

   109     }

   110 		

   111 // -----------------------------------------------------------------------------

   112 // AddFileL

   113 // -----------------------------------------------------------------------------

   114 CXMLElement* AddFileL( ConML_FileListPtr_t * aList )

   115     {

   116     ConML_FileListPtr_t itemL = new ( ELeave ) ConML_FileList_t();

   117     CleanupStack::PushL( itemL );

   118     itemL->data = new ( ELeave ) ConML_File_t();

   119     GenericListAddL(aList, itemL);

   120     CleanupStack::Pop(); // itemL

   121     return itemL->data;

   122     }

   123 

   124 // -----------------------------------------------------------------------------

   125 // AddApplicationL

   126 // -----------------------------------------------------------------------------

   127 CXMLElement* AddApplicationL( ConML_ApplicationListPtr_t * aList )

   128     {   

   129     ConML_ApplicationListPtr_t itemL = new ( ELeave ) ConML_ApplicationList_t();

   130     CleanupStack::PushL( itemL );

   131     itemL->data = new ( ELeave ) ConML_Application_t();

   132     GenericListAddL(aList, itemL);

   133     CleanupStack::Pop(); // itemL

   134     return itemL->data;

   135     }

   136 

   137 // -----------------------------------------------------------------------------

   138 // AddTaskL

   139 // -----------------------------------------------------------------------------

   140 CXMLElement* AddTaskL( ConML_TaskListPtr_t * aList )

   141     {

   142     ConML_TaskListPtr_t itemL = new ( ELeave ) ConML_TaskList_t();

   143     CleanupStack::PushL( itemL );

   144     itemL->data = new ( ELeave ) ConML_Task_t();

   145     GenericListAddL(aList, itemL);

   146     CleanupStack::Pop(); // itemL

   147     return itemL->data;

   148     }

   149 	

   150 // -----------------------------------------------------------------------------

   151 // AddParamL

   152 // -----------------------------------------------------------------------------

   153 CXMLElement* AddParamL( ConML_ParamListPtr_t * aList )

   154     {

   155     ConML_ParamListPtr_t itemL = new ( ELeave ) ConML_ParamList_t();

   156     CleanupStack::PushL( itemL );

   157     itemL->data = new ( ELeave ) ConML_Param_t();

   158     GenericListAddL(aList, itemL);

   159     CleanupStack::Pop(); // itemL

   160     return itemL->data;

   161     }

   162 	

   163 // -----------------------------------------------------------------------------

   164 // ConML_Drive_s

   165 // -----------------------------------------------------------------------------

   166 ConML_Drive_s::ConML_Drive_s()

   167     {

   168     }

   169 

   170 ConML_Drive_s::~ConML_Drive_s()

   171     {

   172     delete name;

   173     }

   174 

   175 CXMLElement* ConML_Drive_s::BeginElementL( 

   176     TUint8 aTag, const TXMLElementParams& /*aParams*/ )

   177     {

   178     switch ( aTag )

   179         {

   180         case EConMLName:

   181             CHECK_NO_DUPLICATE ( name );

   182             name = new ( ELeave ) pcdata_t();

   183             return name;

   184 				

   185         default:

   186             LOGGER_WRITE_1( "ConML_Drive_s::BeginElement() : Unknown element  %02x", aTag );

   187             User::Leave( KWBXMLParserErrorInvalidTag );

   188         }

   189     return KErrNone;

   190     }

   191 

   192 // -----------------------------------------------------------------------------

   193 // ConML_DriveList_s

   194 // -----------------------------------------------------------------------------

   195 ConML_DriveList_s::ConML_DriveList_s()	

   196     {

   197     }

   198 

   199 ConML_DriveList_s::~ConML_DriveList_s()	

   200     {

   201     delete data;

   202     delete next;

   203     }

   204 

   205 // -----------------------------------------------------------------------------

   206 // ConML_Drives_s

   207 // -----------------------------------------------------------------------------

   208 ConML_Drives_s::ConML_Drives_s()

   209     {

   210     }

   211 	

   212 ConML_Drives_s::~ConML_Drives_s()

   213     {

   214     delete drive;

   215     }

   216 	

   217 CXMLElement* ConML_Drives_s::BeginElementL( 

   218     TUint8 aTag, const TXMLElementParams& /*aParams*/ )

   219     {

   220     switch ( aTag )

   221         {

   222         case EConMLDrive:

   223             return AddDriveL ( &drive );

   224 	

   225         default:

   226             LOGGER_WRITE_1( "ConML_Drives_s::BeginElement()\

   227              : Unknown element  %02x ", aTag );

   228             User::Leave( KWBXMLParserErrorInvalidTag );

   229         }

   230     return KErrNone;

   231     }

   232 	

   233 // -----------------------------------------------------------------------------

   234 // ConML_BUROptions_s

   235 // -----------------------------------------------------------------------------

   236 ConML_BUROptions_s::ConML_BUROptions_s()

   237     {

   238     }

   239 

   240 ConML_BUROptions_s::~ConML_BUROptions_s()

   241     {

   242     delete requiresReboot;

   243     delete hasFiles;

   244     delete supportsInc;

   245     delete delayToPrepareData;

   246     }

   247 

   248 CXMLElement* ConML_BUROptions_s::BeginElementL ( 

   249         TUint8 aTag, const TXMLElementParams& /*aParams*/ )

   250     {

   251     switch ( aTag )

   252         {

   253         case EConMLRequiresReboot:

   254             CHECK_NO_DUPLICATE ( requiresReboot );

   255             requiresReboot = new ( ELeave ) pcdata_t();

   256             return requiresReboot;

   257 		

   258         case EConMLHasFiles:

   259             CHECK_NO_DUPLICATE ( hasFiles );

   260             hasFiles = new ( ELeave ) pcdata_t();

   261             return hasFiles;

   262 			

   263         case EConMLSupportsInc:

   264             CHECK_NO_DUPLICATE ( supportsInc );

   265             supportsInc = new ( ELeave ) pcdata_t();

   266             return supportsInc;

   267 		

   268         case EConMLDelayToPrepareData:

   269             CHECK_NO_DUPLICATE ( delayToPrepareData );

   270             delayToPrepareData = new ( ELeave ) pcdata_t();

   271             return delayToPrepareData;

   272 				

   273         default:

   274             LOGGER_WRITE_1( "ConML_BUROptions_s::BeginElement()\

   275              : Unknown element  %02x ", aTag );

   276             User::Leave( KWBXMLParserErrorInvalidTag );

   277         }

   278     return KErrNone;

   279     }

   280 

   281 // -----------------------------------------------------------------------------

   282 // ConML_PackageInfo_s

   283 // -----------------------------------------------------------------------------

   284 ConML_PackageInfo_s::ConML_PackageInfo_s()

   285     {

   286     }

   287 

   288 ConML_PackageInfo_s::~ConML_PackageInfo_s()

   289     {

   290     delete name;

   291     }

   292 

   293 CXMLElement* ConML_PackageInfo_s::BeginElementL( 

   294     TUint8 aTag, const TXMLElementParams& /*aParams*/ )	

   295     {

   296     switch ( aTag )

   297         {

   298         case EConMLName:

   299             CHECK_NO_DUPLICATE ( name )

   300             name = new ( ELeave ) pcdata_t();

   301             return name;

   302 								

   303         default:

   304             LOGGER_WRITE_1( "ConML_PackageInfo_s::BeginElement()\

   305              : Unknown element  %02x ", aTag );

   306             User::Leave( KWBXMLParserErrorInvalidTag );

   307         }

   308     return KErrNone;

   309     }

   310 

   311 

   312 // -----------------------------------------------------------------------------

   313 // ConML_SID_s

   314 // -----------------------------------------------------------------------------

   315 ConML_SID_s::ConML_SID_s()

   316     {

   317     }

   318 

   319 ConML_SID_s::~ConML_SID_s()

   320     {

   321     delete type;

   322     delete uid;

   323     delete drives;

   324     delete packageInfo;

   325     delete burOptions;

   326     delete size;

   327     delete transferDataType;

   328     delete data;

   329     delete moreData;

   330     delete dataOwnerStatus;

   331     }

   332 

   333 CXMLElement* ConML_SID_s::BeginElementL( 

   334     TUint8 aTag, const TXMLElementParams& /*aParams*/ )	

   335     {

   336     switch ( aTag )

   337         {

   338         case EConMLType:

   339             CHECK_NO_DUPLICATE ( type );

   340             type = new ( ELeave ) pcdata_t();

   341             return type;

   342 		

   343         case EConMLUID:

   344             CHECK_NO_DUPLICATE ( uid )

   345             uid = new ( ELeave ) pcdata_t();

   346             return uid;

   347 		

   348         case EConMLDrives:

   349             drives = new ( ELeave ) ConML_Drives_t();

   350             return drives;

   351 		

   352         case EConMLPackageInfo:

   353             CHECK_NO_DUPLICATE ( packageInfo );

   354             packageInfo = new ( ELeave ) ConML_PackageInfo_t();

   355             return packageInfo;

   356 		

   357         case EConMLBUROptions:

   358             CHECK_NO_DUPLICATE ( burOptions )

   359             burOptions = new ( ELeave )	ConML_BUROptions_t();

   360             return burOptions;

   361 			

   362         case EConMLSize:

   363             CHECK_NO_DUPLICATE ( size );

   364             size = new ( ELeave ) pcdata_t();

   365             return size;

   366 		

   367         case EConMLTransferDataType:

   368             CHECK_NO_DUPLICATE ( transferDataType );

   369             transferDataType = new ( ELeave ) pcdata_t();

   370             return transferDataType;

   371 		

   372         case EConMLData:

   373             CHECK_NO_DUPLICATE ( data );

   374             data = new ( ELeave ) pcdata_t();

   375             return data;

   376 		

   377         case EConMLMoreData:

   378             CHECK_NO_DUPLICATE ( moreData );

   379             moreData = new ( ELeave ) pcdata_t();

   380             return moreData;

   381 		

   382         case EConMLDataOwnerStatus:

   383             CHECK_NO_DUPLICATE ( dataOwnerStatus );

   384             dataOwnerStatus = new ( ELeave ) pcdata_t();

   385             return dataOwnerStatus;

   386 		

   387         default:

   388             LOGGER_WRITE_1( "ConML_SID_s::BeginElement()\

   389              : Unknown element  %02x ", aTag );

   390             User::Leave( KWBXMLParserErrorInvalidTag );

   391         }

   392     return KErrNone;

   393     }

   394 	

   395 // -----------------------------------------------------------------------------

   396 // ConML_SIDList_s

   397 // -----------------------------------------------------------------------------

   398 ConML_SIDList_s::ConML_SIDList_s()

   399     {

   400     }

   401 	

   402 ConML_SIDList_s::~ConML_SIDList_s()

   403     {

   404     delete data;

   405     delete next;

   406     }

   407 	

   408 // -----------------------------------------------------------------------------

   409 // ConML_DataOwners_s

   410 // -----------------------------------------------------------------------------

   411 ConML_DataOwners_s::ConML_DataOwners_s()

   412     {

   413     }

   414 

   415 ConML_DataOwners_s::~ConML_DataOwners_s()

   416     {

   417     delete sid;

   418     }

   419 

   420 CXMLElement* ConML_DataOwners_s::BeginElementL(

   421     TUint8 aTag, const TXMLElementParams& /*aParams*/ )	

   422     {

   423     switch ( aTag )

   424         {

   425         case EConMLSID:

   426             return AddSIDL( &sid );

   427 				

   428         default:

   429             LOGGER_WRITE_1( "ConML_DataOwners_s::BeginElement()\

   430              : Unknown element  %02x ", aTag);

   431             User::Leave( KWBXMLParserErrorInvalidTag );

   432         }

   433     return KErrNone;

   434     }

   435 

   436 // -----------------------------------------------------------------------------

   437 // ConML_Application_s

   438 // -----------------------------------------------------------------------------

   439 ConML_Application_s::ConML_Application_s()

   440     {

   441     }

   442 	

   443 ConML_Application_s::~ConML_Application_s()

   444     {

   445     delete name;

   446     delete uid;

   447     }

   448 

   449 CXMLElement* ConML_Application_s::BeginElementL( 

   450     TUint8 aTag, const TXMLElementParams& /*aParams*/ )	

   451     {

   452     switch ( aTag )

   453     	{

   454     	case EConMLName:

   455             CHECK_NO_DUPLICATE ( name );

   456             name = new ( ELeave ) pcdata_t();

   457             return name;

   458 		

   459         case EConMLUID:

   460             CHECK_NO_DUPLICATE ( uid );

   461             uid = new ( ELeave ) pcdata_t();

   462             return uid;

   463 		

   464         default:

   465             LOGGER_WRITE_1( "ConML_Application_s::BeginElement()\

   466              : Unknown element  %02x ", aTag );

   467             User::Leave( KWBXMLParserErrorInvalidTag );

   468         }

   469     return KErrNone;

   470     }

   471 

   472 // -----------------------------------------------------------------------------

   473 // ConML_ApplicationList_s

   474 // -----------------------------------------------------------------------------

   475 ConML_ApplicationList_s::ConML_ApplicationList_s()

   476     {

   477     }

   478 

   479 ConML_ApplicationList_s::~ConML_ApplicationList_s()

   480     {

   481     delete data;

   482     delete next;

   483     }

   484 	

   485 // -----------------------------------------------------------------------------

   486 // ConML_Applications_s

   487 // -----------------------------------------------------------------------------

   488 ConML_Applications_s::ConML_Applications_s()	

   489     {

   490     }

   491 

   492 ConML_Applications_s::~ConML_Applications_s()	

   493     {

   494     delete application;

   495     }

   496 	

   497 CXMLElement* ConML_Applications_s::BeginElementL(

   498     TUint8 aTag, const TXMLElementParams& /*aParams*/ )	

   499     {

   500     switch ( aTag )

   501         {

   502         case EConMLApplication:

   503             return AddApplicationL( &application );

   504 				

   505         default:

   506             LOGGER_WRITE_1( "ConML_DataOwners_s::BeginElement()\

   507              : Unknown element  %02x ", aTag );

   508             User::Leave( KWBXMLParserErrorInvalidTag );

   509         }

   510     return KErrNone;

   511     }

   512 	

   513 // -----------------------------------------------------------------------------

   514 // ConML_SupportedMethod_s

   515 // -----------------------------------------------------------------------------

   516 ConML_SupportedMethods_s::ConML_SupportedMethods_s()

   517     {

   518     }

   519 

   520 ConML_SupportedMethods_s::~ConML_SupportedMethods_s()

   521     {

   522     delete install;

   523     delete unInstall;

   524     delete setInstParams;

   525     delete listInstalledApps;

   526     delete listDataOwners;

   527     delete setBurMode;

   528     delete getDataSize;

   529     delete requestData;

   530     delete supplyData;

   531     delete reboot;

   532     }

   533 

   534 CXMLElement* ConML_SupportedMethods_s::BeginElementL(

   535     TUint8 aTag, const TXMLElementParams& /*aParams*/ )

   536     {

   537     switch ( aTag )

   538         {

   539         case EConMLInstall:

   540             CHECK_NO_DUPLICATE ( install );

   541             install = new ( ELeave ) pcdata_t();

   542             return install;

   543 		

   544         case EConMLUnInstall:

   545             CHECK_NO_DUPLICATE ( unInstall );

   546             unInstall = new ( ELeave ) pcdata_t();

   547             return unInstall;

   548 	

   549         case EConMLListInstalledApps:

   550             CHECK_NO_DUPLICATE ( listInstalledApps );

   551             listInstalledApps = new ( ELeave ) pcdata_t();

   552             return listInstalledApps;

   553 		

   554         case EConMLListDataOwners:

   555             CHECK_NO_DUPLICATE ( listDataOwners );

   556             listDataOwners = new ( ELeave ) pcdata_t();

   557             return listDataOwners;

   558 		

   559         case EConMLSetBURMode:

   560             CHECK_NO_DUPLICATE ( setBurMode );

   561             setBurMode = new ( ELeave ) pcdata_t();

   562             return setBurMode;

   563 		

   564         case EConMLGetDataSize:

   565             CHECK_NO_DUPLICATE ( getDataSize );

   566             getDataSize = new ( ELeave ) pcdata_t();

   567             return getDataSize;

   568 		

   569         case EConMLRequestData:

   570             CHECK_NO_DUPLICATE ( requestData );

   571             requestData = new ( ELeave ) pcdata_t();

   572             return requestData;

   573 		

   574         case EConMLSupplyData:

   575             CHECK_NO_DUPLICATE (supplyData );

   576             supplyData = new ( ELeave ) pcdata_t();

   577             return supplyData;

   578 		

   579         case EConMLReboot:

   580             CHECK_NO_DUPLICATE ( reboot );

   581             reboot = new ( ELeave ) pcdata_t();

   582             return reboot;

   583 		

   584         default:

   585             LOGGER_WRITE_1( "ConML_SupportedMethods_s::\

   586             BeginElement() : Unknown element  %02x ", aTag );

   587             User::Leave( KWBXMLParserErrorInvalidTag );

   588         }

   589     return KErrNone;

   590     }

   591 

   592 // -----------------------------------------------------------------------------

   593 // ConML_DeviceInfo_s

   594 // -----------------------------------------------------------------------------

   595 ConML_DeviceInfo_s::ConML_DeviceInfo_s()

   596     {

   597     }

   598 

   599 ConML_DeviceInfo_s::~ConML_DeviceInfo_s()

   600     {

   601     delete version;

   602     delete supportedMethods;

   603     delete maxObjectSize;

   604     }

   605 

   606 CXMLElement* ConML_DeviceInfo_s::BeginElementL(

   607     TUint8 aTag, const TXMLElementParams& /*aParams*/ )	

   608     {

   609     switch ( aTag )

   610         {

   611         case EConMLVersion:

   612             CHECK_NO_DUPLICATE (version);

   613             version = new ( ELeave ) pcdata_t();

   614             return version;

   615 		

   616         case EConMLSupportedMethods:

   617             CHECK_NO_DUPLICATE ( supportedMethods);

   618             supportedMethods = new ( ELeave ) ConML_SupportedMethods_t();

   619             return supportedMethods;

   620 		

   621         case EConMLMaxObjectSize:

   622             CHECK_NO_DUPLICATE ( maxObjectSize );

   623             maxObjectSize = new ( ELeave ) pcdata_t();

   624             return maxObjectSize;

   625 		

   626         default:

   627             LOGGER_WRITE_1( "ConML_DeviceInfo_s::BeginElement()\

   628              : Unknown element %d", aTag );

   629             User::Leave( KWBXMLParserErrorInvalidTag );

   630         }

   631     return KErrNone;

   632     }

   633 

   634 // -----------------------------------------------------------------------------

   635 // ConML_DeviceInfo_s

   636 // -----------------------------------------------------------------------------

   637 ConML_File_s::ConML_File_s()	

   638     {

   639     }

   640 

   641 ConML_File_s::~ConML_File_s()	

   642     {

   643     delete name;

   644     delete modified;

   645     delete size;

   646     delete userPerm;

   647     }

   648 

   649 CXMLElement* ConML_File_s::BeginElementL( 

   650     TUint8 aTag, const TXMLElementParams& /*aParams*/ )	

   651     {

   652     switch ( aTag )

   653         {

   654         case EConMLName:

   655             CHECK_NO_DUPLICATE ( name );

   656             name = new ( ELeave ) pcdata_t();

   657             return name;

   658 		

   659         case EConMLModified:

   660             CHECK_NO_DUPLICATE ( modified );

   661             modified = new ( ELeave ) pcdata_t();

   662             return modified;

   663 		

   664         case EConMLSize:

   665             CHECK_NO_DUPLICATE ( size );

   666             size = new ( ELeave ) pcdata_t();

   667             return size;

   668 		

   669         case EConMLUserPerm:

   670             CHECK_NO_DUPLICATE ( userPerm );

   671             userPerm = new ( ELeave ) pcdata_t();

   672             return userPerm;

   673 		

   674         default:

   675             LOGGER_WRITE_1( "ConML_File_s::BeginElement()\

   676              : Unknown element %d", aTag );

   677             User::Leave( KWBXMLParserErrorInvalidTag );

   678         }

   679     return KErrNone;

   680     }

   681 

   682 // -----------------------------------------------------------------------------

   683 // ConML_FileList_s

   684 // -----------------------------------------------------------------------------

   685 ConML_FileList_s::ConML_FileList_s()

   686     {

   687     }

   688 	

   689 ConML_FileList_s::~ConML_FileList_s()

   690     {

   691     delete data;

   692     delete next;

   693     }	

   694 

   695 // -----------------------------------------------------------------------------

   696 // ConML_Files_s

   697 // -----------------------------------------------------------------------------

   698 ConML_Files_s::ConML_Files_s()

   699     {

   700     }

   701 

   702 ConML_Files_s::~ConML_Files_s()

   703     {

   704     delete file;

   705     }

   706 

   707 CXMLElement* ConML_Files_s::BeginElementL( 

   708     TUint8 aTag, const TXMLElementParams& /*aParams*/ )	

   709     {

   710     switch ( aTag )

   711         {

   712         case EConMLFile:

   713             return AddFileL( &file );

   714 		

   715         default:

   716             LOGGER_WRITE_1( "ConML_File_s::BeginElement()\

   717              : Unknown element  %02x ", aTag );

   718             User::Leave( KWBXMLParserErrorInvalidTag );

   719         }

   720     return KErrNone;

   721     }

   722 

   723 // -----------------------------------------------------------------------------

   724 // ConML_Progress_s

   725 // -----------------------------------------------------------------------------

   726 ConML_Progress_s::ConML_Progress_s()

   727     {

   728     }

   729 	

   730 // -----------------------------------------------------------------------------

   731 // ~ConML_Progress_s

   732 // -----------------------------------------------------------------------------

   733 ConML_Progress_s::~ConML_Progress_s()

   734     {

   735     delete value;

   736     }

   737 	

   738 CXMLElement* ConML_Progress_s::BeginElementL( 

   739     TUint8 aTag, const TXMLElementParams& /*aParams*/ )	

   740     {

   741     switch ( aTag )

   742         {

   743         case EConMLValue:

   744             CHECK_NO_DUPLICATE ( value );

   745             value = new ( ELeave ) pcdata_t();

   746             return value;

   747 		

   748         default:

   749             LOGGER_WRITE_1( "ConML_Progress_s::BeginElement()\

   750              : Unknown element  %02x ", aTag );

   751             User::Leave( KWBXMLParserErrorInvalidTag );

   752         }

   753     return KErrNone;

   754     }

   755 	

   756 // -----------------------------------------------------------------------------

   757 // ConML_Results_s

   758 // -----------------------------------------------------------------------------

   759 ConML_Results_s::ConML_Results_s()

   760     {

   761     }

   762 

   763 ConML_Results_s::~ConML_Results_s()

   764     {

   765     delete complete;

   766     delete progress;

   767     delete applications;

   768     delete dataOwners;

   769     delete filename;

   770     delete moreData;

   771     delete data;

   772     delete deviceInfo;

   773     delete files;

   774     }

   775 

   776 CXMLElement* ConML_Results_s::BeginElementL( 

   777     TUint8 aTag, const TXMLElementParams& /*aParams*/ )	

   778     {

   779     switch ( aTag )

   780     {

   781         case EConMLComplete:

   782             CHECK_NO_DUPLICATE ( complete );

   783             complete = new ( ELeave ) pcdata_t();

   784             return complete;

   785 		

   786         case EConMLProgress:

   787             CHECK_NO_DUPLICATE ( progress );

   788             progress = new ( ELeave ) ConML_Progress_t();

   789             return progress;

   790 		

   791         case EConMLApplications:

   792             CHECK_NO_DUPLICATE ( applications );

   793             applications = new ( ELeave ) ConML_Applications_t();

   794             return applications;

   795 		

   796         case EConMLDataOwners:

   797             CHECK_NO_DUPLICATE ( dataOwners );

   798             dataOwners = new ( ELeave ) ConML_DataOwners_t();

   799             return dataOwners;

   800 		

   801         case EConMLMoreData:

   802             CHECK_NO_DUPLICATE ( moreData );

   803             moreData = new ( ELeave ) pcdata_t();

   804             return moreData;

   805 		

   806         case EConMLData:

   807             CHECK_NO_DUPLICATE ( data );

   808             data = new ( ELeave ) pcdata_t();

   809             return data;

   810 		

   811         case EConMLDeviceInfo:

   812             CHECK_NO_DUPLICATE ( deviceInfo )

   813             deviceInfo = new ( ELeave ) ConML_DeviceInfo_t();

   814             return deviceInfo;

   815 		

   816         case EConMLFiles:

   817             CHECK_NO_DUPLICATE ( files )

   818             files = new ( ELeave ) ConML_Files_t();

   819             return files;

   820 		

   821         default:

   822             LOGGER_WRITE_1( "ConML_Results_s::BeginElement()\

   823              : Unknown element  %02x ", aTag);

   824             User::Leave( KWBXMLParserErrorInvalidTag );

   825         }

   826     return KErrNone;

   827     }

   828 

   829 // -----------------------------------------------------------------------------

   830 // ConML_Param_s

   831 // -----------------------------------------------------------------------------

   832 ConML_Param_s::ConML_Param_s()

   833     {

   834     }

   835 	

   836 ConML_Param_s::~ConML_Param_s()

   837     {

   838     delete name;

   839     delete value;

   840     }

   841 	

   842 CXMLElement* ConML_Param_s::BeginElementL( 

   843     TUint8 aTag, const TXMLElementParams& /*aParams*/ )	

   844     {

   845     switch ( aTag )

   846         {

   847         case EConMLName:

   848             CHECK_NO_DUPLICATE ( name );

   849             name = new ( ELeave ) pcdata_t();

   850             return name;

   851 		

   852         case EConMLValue:

   853             CHECK_NO_DUPLICATE ( value );

   854             value = new ( ELeave ) pcdata_t();

   855             return value;

   856 		

   857         default:

   858             LOGGER_WRITE_1( "ConML_Param_s::BeginElement()\

   859              : Unknown element  %02x ", aTag );

   860             User::Leave( KWBXMLParserErrorInvalidTag );

   861         }

   862     return KErrNone;

   863     }

   864 

   865 // -----------------------------------------------------------------------------

   866 // ConML_ParamList_s

   867 // -----------------------------------------------------------------------------

   868 ConML_ParamList_s::ConML_ParamList_s()

   869     {

   870     }

   871 

   872 ConML_ParamList_s::~ConML_ParamList_s()

   873     {

   874     delete data;

   875     delete next;

   876     }

   877 	

   878 // -----------------------------------------------------------------------------

   879 // ConML_InstParams_s

   880 // -----------------------------------------------------------------------------

   881 ConML_InstParams_s::ConML_InstParams_s()

   882     {

   883     }

   884 

   885 ConML_InstParams_s::~ConML_InstParams_s()

   886     {

   887     delete param;

   888     }

   889 	

   890 CXMLElement* ConML_InstParams_s::BeginElementL( 

   891     TUint8 aTag, const TXMLElementParams& /*aParams*/ )	

   892     {

   893     switch ( aTag )

   894         {

   895         case EConMLParam:

   896             return AddParamL( &param );

   897 			

   898         default:

   899             LOGGER_WRITE_1( "ConML_InstParams_s::BeginElement()\

   900              : Unknown element  %02x ", aTag);

   901             User::Leave( KWBXMLParserErrorInvalidTag );

   902         }

   903     return KErrNone;

   904     }

   905 

   906 // -----------------------------------------------------------------------------

   907 // ConML_UnInstall_s

   908 // -----------------------------------------------------------------------------

   909 ConML_UnInstall_s::ConML_UnInstall_s()

   910     {

   911     }

   912 

   913 ConML_UnInstall_s::~ConML_UnInstall_s()

   914     {

   915     delete applications;

   916     delete instParams;

   917     delete results;

   918     }

   919 

   920 CXMLElement* ConML_UnInstall_s::BeginElementL( 

   921     TUint8 aTag, const TXMLElementParams& /*aParams*/ )	

   922     {

   923     switch ( aTag )

   924         {

   925         case EConMLApplications:

   926             CHECK_NO_DUPLICATE ( applications );

   927             applications = new ( ELeave ) ConML_Applications_t();

   928             return applications;

   929 		

   930         case EConMLInstParams:

   931             CHECK_NO_DUPLICATE ( instParams );

   932             instParams = new ( ELeave ) ConML_InstParams_t();

   933             return instParams;

   934 				

   935         case EConMLResults:

   936             CHECK_NO_DUPLICATE ( results );

   937             results = new ( ELeave ) ConML_Results_t();

   938             return results;

   939 		

   940         default:

   941             LOGGER_WRITE_1( "ConML_UnInstall_s::BeginElement()\

   942              : Unknown element  %02x ", aTag);

   943             User::Leave( KWBXMLParserErrorInvalidTag );

   944         }

   945     return KErrNone;

   946     }

   947 

   948 

   949 // -----------------------------------------------------------------------------

   950 // ConML_ListDataOwners_s

   951 // -----------------------------------------------------------------------------

   952 ConML_ListDataOwners_s::ConML_ListDataOwners_s()

   953     {

   954     }

   955 

   956 ConML_ListDataOwners_s::~ConML_ListDataOwners_s()

   957     {

   958     delete results;

   959     }

   960 

   961 CXMLElement* ConML_ListDataOwners_s::BeginElementL(

   962     TUint8 aTag, const TXMLElementParams& /*aParams*/ )	

   963     {

   964     switch ( aTag )

   965         {

   966         case EConMLResults:

   967             CHECK_NO_DUPLICATE ( results );

   968             results = new ( ELeave ) ConML_Results_t();

   969             return results;

   970 		

   971         default:

   972             LOGGER_WRITE_1( "ConML_ListDataOwners_s::BeginElement()\

   973              : Unknown element  %02x ", aTag );

   974             User::Leave( KWBXMLParserErrorInvalidTag );

   975         }

   976     return KErrNone;

   977     }

   978 

   979 // -----------------------------------------------------------------------------

   980 // ConML_Install_s

   981 // -----------------------------------------------------------------------------

   982 ConML_Install_s::ConML_Install_s()

   983     {

   984     }

   985 

   986 ConML_Install_s::~ConML_Install_s()

   987     {

   988     delete name;

   989     delete instParams;

   990     delete results;

   991     }

   992 

   993 CXMLElement* ConML_Install_s::BeginElementL( 

   994     TUint8 aTag, const TXMLElementParams& /*aParams*/ )	

   995     {

   996     switch ( aTag )

   997         {

   998         case EConMLName:

   999             CHECK_NO_DUPLICATE ( name );

  1000             name = new ( ELeave ) pcdata_t();

  1001             return name;

  1002 			

  1003         case EConMLInstParams:

  1004             CHECK_NO_DUPLICATE ( instParams );

  1005             instParams = new ( ELeave ) ConML_InstParams_t();

  1006             return instParams;

  1007 		

  1008         case EConMLResults:

  1009             CHECK_NO_DUPLICATE ( results );

  1010             results = new ( ELeave ) ConML_Results_t();

  1011             return results;

  1012 		

  1013         default:

  1014             LOGGER_WRITE_1( "ConML_Install_s::BeginElement()\

  1015              : Unknown element  %02x ", aTag );

  1016             User::Leave( KWBXMLParserErrorInvalidTag );

  1017         }

  1018     return KErrNone;

  1019     }

  1020 

  1021 // -----------------------------------------------------------------------------

  1022 // ConML_ListInstalledApps

  1023 // -----------------------------------------------------------------------------

  1024 ConML_ListInstalledApps_s::ConML_ListInstalledApps_s()

  1025     {

  1026     }

  1027 

  1028 ConML_ListInstalledApps_s::~ConML_ListInstalledApps_s()

  1029     {

  1030     delete drives;

  1031     delete all;

  1032     delete results;

  1033     }

  1034 

  1035 CXMLElement* ConML_ListInstalledApps_s::BeginElementL(

  1036     TUint8 aTag, const TXMLElementParams& /*aParams*/ )	

  1037     {

  1038     switch ( aTag )

  1039         {

  1040         case EConMLDrives:

  1041             CHECK_NO_DUPLICATE ( drives );

  1042             drives = new ( ELeave ) ConML_Drives_t();

  1043             return drives;

  1044 		

  1045         case EConMLAll:

  1046             CHECK_NO_DUPLICATE ( all );

  1047             all = new ( ELeave ) pcdata_t();

  1048             return all;

  1049 		

  1050         case EConMLResults:

  1051             CHECK_NO_DUPLICATE ( results );

  1052             results = new ( ELeave ) ConML_Results_t();

  1053             return results;

  1054 		

  1055         default:

  1056             LOGGER_WRITE_1( "ConML_ListInstalledApps_s::\

  1057             BeginElement() : Unknown element  %02x ", aTag );

  1058             User::Leave( KWBXMLParserErrorInvalidTag );

  1059         }

  1060     return KErrNone;

  1061     }

  1062 	

  1063 // -----------------------------------------------------------------------------

  1064 // ConML_SetBURMode_s

  1065 // -----------------------------------------------------------------------------

  1066 ConML_SetBURMode_s::ConML_SetBURMode_s()

  1067     {

  1068     }

  1069 

  1070 ConML_SetBURMode_s::~ConML_SetBURMode_s()

  1071     {

  1072     delete drives;

  1073     delete partialType;

  1074     delete incType;

  1075     delete results;

  1076     }

  1077 

  1078 CXMLElement* ConML_SetBURMode_s::BeginElementL(

  1079     TUint8 aTag, const TXMLElementParams& /*aParams*/ )	

  1080     {

  1081     switch ( aTag )

  1082         {

  1083         case EConMLDrives:

  1084             drives = new ( ELeave ) ConML_Drives_t();

  1085             return drives;

  1086 		

  1087         case EConMLPartialType:

  1088             CHECK_NO_DUPLICATE ( partialType );

  1089             partialType = new ( ELeave ) pcdata_t();

  1090             return partialType;

  1091 		

  1092         case EConMLIncType:

  1093             CHECK_NO_DUPLICATE ( incType );

  1094             incType = new ( ELeave ) pcdata_t();

  1095             return incType;

  1096 		

  1097         case EConMLResults:

  1098             CHECK_NO_DUPLICATE ( results );

  1099             results = new ( ELeave ) ConML_Results_t();

  1100             return results;

  1101 		

  1102         default:

  1103             LOGGER_WRITE_1( "ConML_SetBURMode_s::BeginElement()\

  1104              : Unknown element  %02x ", aTag );

  1105             User::Leave( KWBXMLParserErrorInvalidTag );

  1106             }

  1107     return KErrNone;

  1108     }

  1109 

  1110 // -----------------------------------------------------------------------------

  1111 // ConML_GetDataSize_s

  1112 // -----------------------------------------------------------------------------

  1113 ConML_GetDataSize_s::ConML_GetDataSize_s()

  1114     {

  1115     }

  1116 

  1117 ConML_GetDataSize_s::~ConML_GetDataSize_s()

  1118     {

  1119     delete dataOwners;

  1120     delete results;

  1121     }

  1122 

  1123 CXMLElement* ConML_GetDataSize_s::BeginElementL(

  1124     TUint8 aTag, const TXMLElementParams& /*aParams*/ )	

  1125     {

  1126     switch ( aTag )

  1127         {

  1128         case EConMLDataOwners:

  1129             CHECK_NO_DUPLICATE ( dataOwners );

  1130             dataOwners = new ( ELeave ) ConML_DataOwners_t();

  1131             return dataOwners;

  1132 		

  1133         case EConMLResults:

  1134             CHECK_NO_DUPLICATE ( results );