1 /*

     2 * Copyright (c) 2004 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:  Device information command struct implementations.

    15 *

    16 */

    17 

    18 

    19 // ------------------------------------------------------------------------------------------------

    20 // Includes

    21 // ------------------------------------------------------------------------------------------------

    22 

    23 #include "smldtd.h"

    24 #include "smldevinfdtd.h"

    25 #include "smldevinftags.h"

    26 #include "WBXMLDevInfParser.h"

    27 #include "WBXMLParserError.h"

    28 

    29 // ------------------------------------------------------------------------------------------------

    30 // External functions

    31 // ------------------------------------------------------------------------------------------------

    32 extern CXMLElement* AddPCDataL( SmlPcdataListPtr_t* aList );

    33 

    34 // ------------------------------------------------------------------------------------------------

    35 // Macros

    36 // ------------------------------------------------------------------------------------------------

    37 #define CHECK_NO_DUPLICATE(a) if( a ) { User::Leave(KErrParserErrorInvalidDocument); }

    38 

    39 // ------------------------------------------------------------------------------------------------

    40 // Helper functions

    41 // ------------------------------------------------------------------------------------------------

    42 CXMLElement* AddCTParamL(  SmlDevInfCTDataListPtr_t* aList )

    43 	{

    44 	SmlDevInfCTDataListPtr_t itemL = new (ELeave) SmlDevInfCTDataList_t();

    45 	CleanupStack::PushL(itemL);

    46 	itemL->data = new (ELeave) SmlDevInfCTData_t();

    47 	GenericListAddL(aList, itemL);

    48 	CleanupStack::Pop(); // itemL

    49 	return itemL->data;

    50 	}

    51 

    52 // ------------------------------------------------------------------------------------------------

    53 CXMLElement* AddCTPropL( SmlDevInfCTDataPropListPtr_t* aList )

    54 	{

    55 	SmlDevInfCTDataPropListPtr_t itemL = new (ELeave) SmlDevInfCTDataPropList_t();

    56 	CleanupStack::PushL(itemL);

    57 	itemL->data = new (ELeave) SmlDevInfCTDataProp_t();

    58 	GenericListAddL(aList, itemL);

    59 	CleanupStack::Pop(); // itemL

    60 	return itemL->data;

    61 	}

    62 

    63 // ------------------------------------------------------------------------------------------------

    64 CXMLElement* AddPropertyL( SmlDevInfPropertyListPtr_t* aList )

    65 	{

    66 	SmlDevInfPropertyListPtr_t itemL = new (ELeave) SmlDevInfPropertyList_t();

    67 	CleanupStack::PushL(itemL);

    68 	itemL->data = new (ELeave) SmlDevInfProperty_t();

    69 	GenericListAddL(aList, itemL);

    70 	CleanupStack::Pop(); // itemL

    71 	return itemL->data;

    72 	}

    73 

    74 // 1.2 CHANGES: new element PropParam

    75 // ------------------------------------------------------------------------------------------------

    76 CXMLElement* AddPropParamL( SmlDevInfPropParamListPtr_t* aList )

    77 	{

    78 	SmlDevInfPropParamListPtr_t itemL = new (ELeave) SmlDevInfPropParamList_t();

    79 	CleanupStack::PushL(itemL);

    80 	itemL->data = new (ELeave) SmlDevInfPropParam_t();

    81 	GenericListAddL(aList, itemL);

    82 	CleanupStack::Pop(); // itemL

    83 	return itemL->data;

    84 	}

    85 // Changes end

    86 

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

    88 CXMLElement* AddXmitL( SmlDevInfXmitListPtr_t* aList )

    89 	{

    90 	SmlDevInfXmitListPtr_t itemL = new (ELeave) SmlDevInfXmitList_t();

    91 	CleanupStack::PushL(itemL);

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

    93 	GenericListAddL(aList, itemL);

    94 	CleanupStack::Pop(); // itemL

    95 	return itemL->data;

    96 	}

    97 

    98 // 1.2 CHANGES: new element FilterCap

    99 // ------------------------------------------------------------------------------------------------

   100 CXMLElement* AddFilterCapL( SmlDevInfFilterCapListPtr_t* aList)

   101 	{

   102 	SmlDevInfFilterCapListPtr_t itemL = new (ELeave) SmlDevInfFilterCapList_t();

   103 	CleanupStack::PushL(itemL);

   104 	itemL->data = new (ELeave) SmlDevInfFilterCap_t();

   105 	GenericListAddL(aList, itemL);

   106 	CleanupStack::Pop(); //itemL

   107 	return itemL->data;

   108 	}

   109 // Changes end

   110 

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

   112 CXMLElement* AddCtCapL( SmlDevInfCtCapListPtr_t* aList, CXMLElement* aParent = 0 )

   113 	{

   114 	SmlDevInfCtCapListPtr_t itemL = new (ELeave) SmlDevInfCtCapList_t();

   115 	CleanupStack::PushL(itemL);

   116 	itemL->data = new (ELeave) SmlDevInfCtCap_t(aParent);

   117 	GenericListAddL(aList, itemL);

   118 	CleanupStack::Pop(); // itemL

   119 	return itemL->data;

   120 	}

   121 

   122 // ------------------------------------------------------------------------------------------------

   123 CXMLElement* AddDataStoreL( SmlDevInfDatastoreListPtr_t* aList )

   124 	{

   125 	SmlDevInfDatastoreListPtr_t itemL = new (ELeave) SmlDevInfDatastoreList_t();

   126 	CleanupStack::PushL(itemL);

   127 	itemL->data = new (ELeave) SmlDevInfDatastore_t();

   128 	GenericListAddL(aList, itemL);

   129 	CleanupStack::Pop(); // itemL

   130 	return itemL->data;

   131 	}

   132 

   133 // ------------------------------------------------------------------------------------------------

   134 CXMLElement* AddExtL( SmlDevInfExtListPtr_t* aList )

   135 	{

   136 	SmlDevInfExtListPtr_t itemL = new (ELeave) SmlDevInfExtList_t();

   137 	CleanupStack::PushL(itemL);

   138 	itemL->data = new (ELeave) SmlDevInfExt_t();

   139 	GenericListAddL(aList, itemL);

   140 	CleanupStack::Pop(); // itemL

   141 	return itemL->data;

   142 	}

   143 

   144 // ------------------------------------------------------------------------------------------------

   145 // sml_devinf_xmit_s

   146 // ------------------------------------------------------------------------------------------------

   147 EXPORT_C sml_devinf_xmit_s::sml_devinf_xmit_s()

   148 	{

   149 	}

   150 

   151 // ------------------------------------------------------------------------------------------------

   152 EXPORT_C sml_devinf_xmit_s::~sml_devinf_xmit_s()

   153 	{

   154 	delete cttype;

   155 	delete verct;

   156 	}

   157 

   158 // ------------------------------------------------------------------------------------------------

   159 CXMLElement* sml_devinf_xmit_s::BeginElementL( TUint8 aTag, const TXMLElementParams& /*aParams*/ )

   160 	{

   161 	switch( aTag )

   162 	{ 

   163 		case EDevCTType:

   164 			CHECK_NO_DUPLICATE(cttype);

   165 			cttype = new (ELeave) SmlPcdata_t();

   166 			return cttype;

   167 		

   168 		case EDevVerCT:

   169 			CHECK_NO_DUPLICATE(verct);

   170 			verct = new (ELeave) SmlPcdata_t();

   171 			return verct;

   172 

   173 		default:

   174 			User::Leave(KWBXMLParserErrorInvalidTag);

   175 		}

   176 	return 0;

   177 	}

   178 

   179 // ------------------------------------------------------------------------------------------------

   180 // sml_devinf_xmitlist_s

   181 // ------------------------------------------------------------------------------------------------

   182 EXPORT_C sml_devinf_xmitlist_s::sml_devinf_xmitlist_s()

   183 	{

   184 	}

   185 

   186 // ------------------------------------------------------------------------------------------------

   187 EXPORT_C sml_devinf_xmitlist_s::~sml_devinf_xmitlist_s()

   188 	{

   189 	delete data;

   190 	}

   191 

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

   193 // sml_devinf_ext_s

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

   195 EXPORT_C sml_devinf_ext_s::sml_devinf_ext_s()

   196 	{

   197 	}

   198 

   199 // ------------------------------------------------------------------------------------------------

   200 EXPORT_C sml_devinf_ext_s::~sml_devinf_ext_s()

   201 	{

   202     delete xnam;     

   203     GenericListDelete( xval );

   204 	}

   205 

   206 // ------------------------------------------------------------------------------------------------

   207 CXMLElement* sml_devinf_ext_s::BeginElementL( TUint8 aTag, const TXMLElementParams& /*aParams*/ )

   208 	{

   209 	switch( aTag )

   210 		{

   211 		case EDevXNam:

   212 			CHECK_NO_DUPLICATE(xnam);

   213 			xnam = new (ELeave) SmlPcdata_t();

   214 			return xnam;

   215 

   216 		case EDevXVal:

   217 			return AddPCDataL(&xval);

   218 

   219 		default:

   220 			User::Leave(KWBXMLParserErrorInvalidTag);

   221 		}

   222 	return 0;

   223 	}

   224 

   225 // ------------------------------------------------------------------------------------------------

   226 // sml_devinf_extlist_s

   227 // ------------------------------------------------------------------------------------------------

   228 EXPORT_C sml_devinf_extlist_s::sml_devinf_extlist_s()

   229 	{

   230 	}

   231 

   232 // ------------------------------------------------------------------------------------------------

   233 EXPORT_C sml_devinf_extlist_s::~sml_devinf_extlist_s()

   234 	{

   235 	delete data;	

   236 	}

   237 

   238 // 1.2 CHANGES: New element FilterCap

   239 // ------------------------------------------------------------------------------------------------

   240 // sml_devinf_filtercap_s

   241 // ------------------------------------------------------------------------------------------------

   242 EXPORT_C sml_devinf_filtercap_s::sml_devinf_filtercap_s()

   243 	{

   244 	}

   245 

   246 // ------------------------------------------------------------------------------------------------

   247 EXPORT_C sml_devinf_filtercap_s::~sml_devinf_filtercap_s()

   248 	{

   249     delete cttype;

   250     delete verct;

   251 	

   252 	GenericListDelete( filterkeyword ); /* optional */

   253 	GenericListDelete( propname ); /* optional */

   254 	}

   255 

   256 // ------------------------------------------------------------------------------------------------

   257 CXMLElement* sml_devinf_filtercap_s::BeginElementL( TUint8 aTag, const TXMLElementParams& /*aParams*/ )

   258 {

   259 

   260 	switch( aTag )

   261 		{

   262 		case EDevCTType:

   263 			CHECK_NO_DUPLICATE(cttype);

   264 			cttype = new (ELeave) SmlPcdata_t();

   265 			return cttype;

   266 

   267 		case EDevVerCT:

   268 			CHECK_NO_DUPLICATE(verct);

   269 			verct = new (ELeave) SmlPcdata_t();

   270 			return verct;

   271 

   272 		case EDevFilterKeyword:

   273 			return AddPCDataL(&filterkeyword);

   274 

   275 		case EDevPropName:

   276 			return AddPCDataL(&propname);

   277 

   278 		default:

   279 			User::Leave(KWBXMLParserErrorInvalidTag);

   280 		}

   281 	return 0;

   282 }

   283 

   284 // ------------------------------------------------------------------------------------------------

   285 // sml_devinf_filtercaplist_s

   286 // ------------------------------------------------------------------------------------------------

   287 EXPORT_C sml_devinf_filtercaplist_s::sml_devinf_filtercaplist_s()

   288 	{

   289 	}

   290 

   291 // ------------------------------------------------------------------------------------------------

   292 EXPORT_C sml_devinf_filtercaplist_s::~sml_devinf_filtercaplist_s()

   293 	{

   294 	delete data;	

   295 	}

   296 // Changes end

   297 

   298 

   299 // ------------------------------------------------------------------------------------------------

   300 // sml_devinf_synccap_s

   301 // ------------------------------------------------------------------------------------------------

   302 EXPORT_C sml_devinf_synccap_s::sml_devinf_synccap_s()

   303 	{

   304 	}

   305 

   306 // ------------------------------------------------------------------------------------------------

   307 EXPORT_C sml_devinf_synccap_s::~sml_devinf_synccap_s()

   308 	{    

   309     GenericListDelete( synctype );

   310 	}

   311 

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

   313 CXMLElement* sml_devinf_synccap_s::BeginElementL( TUint8 aTag, const TXMLElementParams& /*aParams*/ )

   314 	{

   315 	switch( aTag )

   316 		{

   317 		case EDevSyncType:

   318 			return AddPCDataL(&synctype);

   319 

   320 		default:

   321 			User::Leave(KWBXMLParserErrorInvalidTag);

   322 		}

   323 	return 0;

   324 	}

   325 

   326 // ------------------------------------------------------------------------------------------------

   327 // sml_devinf_dsmem_s

   328 // ------------------------------------------------------------------------------------------------

   329 EXPORT_C sml_devinf_dsmem_s::sml_devinf_dsmem_s()

   330 	{

   331 	}

   332 

   333 // ------------------------------------------------------------------------------------------------

   334 EXPORT_C sml_devinf_dsmem_s::~sml_devinf_dsmem_s()

   335 	{

   336     delete maxmem; /* optional */

   337     delete maxid;  /* optional */

   338 	delete shared; /* optional */

   339 	}

   340 

   341 // ------------------------------------------------------------------------------------------------

   342 CXMLElement* sml_devinf_dsmem_s::BeginElementL( TUint8 aTag, const TXMLElementParams& /*aParams*/ )

   343 	{

   344 	switch( aTag )

   345 		{

   346 		case EDevSharedMem:

   347 			CHECK_NO_DUPLICATE(shared);

   348 			shared = new (ELeave) SmlPcdata_t();

   349 			return shared;

   350 		

   351 		case EDevMaxMem:

   352 			CHECK_NO_DUPLICATE(maxmem);

   353 			maxmem = new (ELeave) SmlPcdata_t();

   354 			return maxmem;

   355 

   356 		case EDevMaxID:

   357 			CHECK_NO_DUPLICATE(maxid);

   358 			maxid = new (ELeave) SmlPcdata_t();

   359 			return maxid;

   360 

   361 		default:

   362 			User::Leave(KWBXMLParserErrorInvalidTag);

   363 		}

   364 	return 0;

   365 	}

   366 

   367 // 1.2 CHANGES: new elements PropParam and Property

   368 // ------------------------------------------------------------------------------------------------

   369 // sml_devinf_propparam_s

   370 // ------------------------------------------------------------------------------------------------

   371 EXPORT_C sml_devinf_propparam_s::sml_devinf_propparam_s()

   372 	{

   373 	}

   374 

   375 // ------------------------------------------------------------------------------------------------

   376 EXPORT_C sml_devinf_propparam_s::~sml_devinf_propparam_s()

   377 	{

   378 	delete datatype;

   379 	delete displayname;

   380 	delete paramname;	

   381 	GenericListDelete( valenum );

   382 	}

   383 

   384 // ------------------------------------------------------------------------------------------------

   385 CXMLElement* sml_devinf_propparam_s::BeginElementL(TUint8 aTag, const TXMLElementParams& /* aParams*/ )

   386 	{

   387 	switch (aTag)

   388 		{

   389 		case EDevParamName:

   390 			CHECK_NO_DUPLICATE(paramname);

   391 			paramname = new (ELeave) SmlPcdata_t();

   392 			return paramname;

   393 

   394 		case EDevDataType:

   395 			CHECK_NO_DUPLICATE(datatype);

   396 			datatype = new (ELeave) SmlPcdata_t();

   397 			return datatype;

   398 

   399 		case EDevValEnum:

   400 			return AddPCDataL(&valenum);

   401 

   402 		case EDevDisplayName:

   403 			CHECK_NO_DUPLICATE(displayname);

   404 			displayname = new (ELeave) SmlPcdata_t();

   405 			return displayname;

   406 

   407 		default:

   408 			User::Leave(KWBXMLParserErrorInvalidTag);

   409 		}

   410 	return 0;

   411 	}

   412 

   413 // ------------------------------------------------------------------------------------------------

   414 // sml_devinf_propparamlist_s

   415 // ------------------------------------------------------------------------------------------------

   416 EXPORT_C sml_devinf_propparamlist_s::sml_devinf_propparamlist_s()

   417 	{

   418 	};

   419 

   420 // ------------------------------------------------------------------------------------------------

   421 EXPORT_C sml_devinf_propparamlist_s::~sml_devinf_propparamlist_s()

   422 	{	

   423 	delete data;	

   424 	}

   425 

   426 // ------------------------------------------------------------------------------------------------

   427 // sml_devinf_property_s

   428 // ------------------------------------------------------------------------------------------------

   429 EXPORT_C sml_devinf_property_s::sml_devinf_property_s()

   430 	{

   431 	}

   432 

   433 // ------------------------------------------------------------------------------------------------

   434 EXPORT_C sml_devinf_property_s::~sml_devinf_property_s()

   435 	{

   436     delete datatype;

   437 	delete displayname;

   438 	delete maxoccur;

   439 	delete maxsize;

   440 	delete propname;	

   441 	GenericListDelete( propparam );	

   442 	GenericListDelete( valenum );	

   443 	delete notruncate;	

   444 	}

   445 

   446 // ------------------------------------------------------------------------------------------------

   447 CXMLElement* sml_devinf_property_s::BeginElementL( TUint8 aTag, const TXMLElementParams& /*aParams*/ )

   448 	{

   449 	switch( aTag )

   450 		{

   451 		case EDevPropName:

   452 			CHECK_NO_DUPLICATE(propname);

   453 			propname = new (ELeave) SmlPcdata_t();

   454 			return propname;

   455 

   456 		case EDevDataType:

   457 			CHECK_NO_DUPLICATE(datatype);

   458 			datatype = new (ELeave) SmlPcdata_t();

   459 			return datatype;

   460 			

   461 		case EDevMaxOccur:

   462 			CHECK_NO_DUPLICATE(maxoccur);

   463 			maxoccur = new (ELeave) SmlPcdata_t();

   464 			return maxoccur;

   465 

   466 		case EDevMaxSize:

   467 			CHECK_NO_DUPLICATE(maxsize);

   468 			maxsize = new (ELeave) SmlPcdata_t();

   469 			return maxsize;

   470 

   471 		case EDevNoTruncate:

   472 			CHECK_NO_DUPLICATE(notruncate);

   473 			notruncate = new(ELeave) SmlPcdata_t();

   474 			return notruncate;

   475 						

   476 		case EDevValEnum:

   477 			return AddPCDataL(&valenum);

   478 			

   479 		case EDevDisplayName:

   480 			CHECK_NO_DUPLICATE(displayname);

   481 			displayname = new (ELeave) SmlPcdata_t();

   482 			return displayname;

   483 

   484 		case EDevPropParam:

   485 			return AddPropParamL(&propparam);

   486 

   487 		default:

   488 			User::Leave(KWBXMLParserErrorInvalidTag);

   489 		}

   490 	return 0;

   491 	}

   492 

   493 // ------------------------------------------------------------------------------------------------

   494 // sml_devinf_propertylist_s

   495 // ------------------------------------------------------------------------------------------------

   496 EXPORT_C sml_devinf_propertylist_s::sml_devinf_propertylist_s()

   497 	{

   498 	}

   499 

   500 // ------------------------------------------------------------------------------------------------

   501 EXPORT_C sml_devinf_propertylist_s::~sml_devinf_propertylist_s()

   502 	{

   503 	delete data;	

   504 	}

   505 //Changes end

   506 

   507 // ------------------------------------------------------------------------------------------------

   508 // sml_devinf_ctdata_s

   509 // ------------------------------------------------------------------------------------------------

   510 EXPORT_C sml_devinf_ctdata_s::sml_devinf_ctdata_s()

   511 	{

   512 	}

   513 

   514 // ------------------------------------------------------------------------------------------------

   515 EXPORT_C sml_devinf_ctdata_s::~sml_devinf_ctdata_s()

   516 	{

   517     delete name; /* param OR prop name */

   518     delete dname; /* optional, display name */    

   519     GenericListDelete( valenum );

   520     delete datatype;

   521     delete size;

   522 	}

   523 

   524 // ------------------------------------------------------------------------------------------------

   525 CXMLElement* sml_devinf_ctdata_s::BeginElementL( TUint8 aTag, const TXMLElementParams& /*aParams*/ )

   526 	{

   527 	switch( aTag )

   528 		{

   529 		case EDevParamName:

   530 			CHECK_NO_DUPLICATE(name);

   531 			name = new (ELeave) SmlPcdata_t();

   532 			return name;

   533 

   534 		case EDevDisplayName:

   535 			CHECK_NO_DUPLICATE(dname);

   536 			dname = new (ELeave) SmlPcdata_t();

   537 			return dname;

   538 

   539 		case EDevValEnum:

   540 			return AddPCDataL(&valenum);

   541 

   542 		case EDevDataType:

   543 			CHECK_NO_DUPLICATE(datatype);

   544 			datatype = new (ELeave) SmlPcdata_t();

   545 			return datatype;

   546 

   547 		case EDevMaxSize:

   548 			CHECK_NO_DUPLICATE(size);

   549 			size = new (ELeave) SmlPcdata_t();

   550 			return size;

   551 

   552 		default:

   553 			User::Leave(KWBXMLParserErrorInvalidTag);

   554 		}

   555 	return 0;

   556 	}

   557 

   558 // ------------------------------------------------------------------------------------------------

   559 void sml_devinf_ctdata_s::SetDataL( const TDesC8& aData )

   560 	{

   561 	if( !name )

   562 		{

   563 		name = new (ELeave) SmlPcdata_t();

   564 		name->SetDataL(aData);

   565 		}

   566 	}

   567 

   568 // ------------------------------------------------------------------------------------------------

   569 // sml_devinf_ctdatalist_s

   570 // ------------------------------------------------------------------------------------------------

   571 EXPORT_C sml_devinf_ctdatalist_s::sml_devinf_ctdatalist_s()

   572 	{

   573 	}

   574 

   575 // ------------------------------------------------------------------------------------------------

   576 EXPORT_C sml_devinf_ctdatalist_s::~sml_devinf_ctdatalist_s()

   577 	{

   578 	delete data;	

   579 	}

   580 

   581 // ------------------------------------------------------------------------------------------------

   582 // sml_devinf_ctdataprop_s

   583 // ------------------------------------------------------------------------------------------------

   584 EXPORT_C sml_devinf_ctdataprop_s::sml_devinf_ctdataprop_s()

   585 	{

   586 	}

   587 

   588 // ------------------------------------------------------------------------------------------------

   589 EXPORT_C sml_devinf_ctdataprop_s::~sml_devinf_ctdataprop_s()

   590 	{

   591     delete prop;    

   592     GenericListDelete( param );    

   593 	}

   594 

   595 // ------------------------------------------------------------------------------------------------

   596 CXMLElement* sml_devinf_ctdataprop_s::BeginElementL( TUint8 aTag, const TXMLElementParams& /*aParams*/ )

   597 	{

   598 	switch( aTag )

   599 		{

   600 		case EDevDisplayName:

   601 			CHECK_NO_DUPLICATE(prop->dname);

   602 			prop->dname = new (ELeave) SmlPcdata_t();

   603 			return prop->dname;

   604 

   605 		case EDevValEnum:

   606 			return AddPCDataL(&prop->valenum);

   607 

   608 		case EDevDataType:

   609 			CHECK_NO_DUPLICATE(prop->datatype);

   610 			prop->datatype = new (ELeave) SmlPcdata_t();

   611 			return prop->datatype;

   612 

   613 		case EDevMaxSize:

   614 			CHECK_NO_DUPLICATE(prop->size);

   615 			prop->size = new (ELeave) SmlPcdata_t();

   616 			return prop->size;

   617 

   618 		case EDevParamName:

   619 			return AddCTParamL(&param);

   620 

   621 		default:

   622 			User::Leave(KWBXMLParserErrorInvalidTag);

   623 		}

   624 	return 0;

   625 	}

   626 

   627 // ------------------------------------------------------------------------------------------------

   628 void sml_devinf_ctdataprop_s::SetDataL( const TDesC8& aData )

   629 	{

   630 	if( !prop )

   631 		{

   632 		prop = new (ELeave) SmlDevInfCTData_t();

   633 		}

   634 	if( !prop->name )

   635 		{

   636 		prop->name = new (ELeave) SmlPcdata_t();

   637 		prop->name->SetDataL(aData);

   638 		}

   639 	}

   640 

   641 // ------------------------------------------------------------------------------------------------

   642 // sml_devinf_ctdataproplist_s

   643 // ------------------------------------------------------------------------------------------------

   644 EXPORT_C sml_devinf_ctdataproplist_s::sml_devinf_ctdataproplist_s()

   645 	{

   646 	}

   647 

   648 // ------------------------------------------------------------------------------------------------

   649 EXPORT_C sml_devinf_ctdataproplist_s::~sml_devinf_ctdataproplist_s()

   650 	{

   651 	delete data;

   652 	}

   653 

   654 // ------------------------------------------------------------------------------------------------

   655 // sml_devinf_ctcap_s

   656 // ------------------------------------------------------------------------------------------------

   657 EXPORT_C sml_devinf_ctcap_s::sml_devinf_ctcap_s()

   658 	{

   659 	}

   660 // ------------------------------------------------------------------------------------------------

   661 EXPORT_C sml_devinf_ctcap_s::sml_devinf_ctcap_s( CXMLElement* aParent ) : iParent(aParent)

   662 	{

   663 	}

   664 // ------------------------------------------------------------------------------------------------

   665 EXPORT_C sml_devinf_ctcap_s::~sml_devinf_ctcap_s()

   666 	{

   667     delete cttype;	

   668 	GenericListDelete( property );

   669 	delete verct;

   670 	delete fieldlevel;

   671 	GenericListDelete( prop );

   672 	//delete iParent;

   673 	}

   674 

   675 // ------------------------------------------------------------------------------------------------

   676 CXMLElement* sml_devinf_ctcap_s::GetPreviousElem() const

   677 	{

   678 	CXMLElement* e = 0;

   679 	if( prevelem == SML_PROPNAME )

   680 		{

   681 		SmlDevInfCTDataPropListPtr_t l;

   682 		for( l = prop; l && l->next; l = l->next )

   683 			;

   684 		if( l )

   685 			{

   686 			e = l->data;

   687 			}

   688 		}

   689 	else

   690 		{

   691 		SmlDevInfCTDataPropListPtr_t l;

   692 		for( l = prop; l && l->next; l = l->next )

   693 			;

   694 		if( l )

   695 			{

   696 			SmlDevInfCTDataListPtr_t l2;

   697 			for( l2 = l->data->param; l2 && l2->next; l2 = l2->next )

   698 				;

   699 			if( l2 )

   700 				{

   701 				e = l2->data;

   702 				}

   703 			}

   704 		}

   705 	return e;

   706 	}

   707 

   708 // ------------------------------------------------------------------------------------------------

   709 CXMLElement* sml_devinf_ctcap_s::BeginElementL( TUint8 aTag, const TXMLElementParams& aParams )

   710 	{

   711 	switch( aTag )

   712 		{

   713 		case EDevCTType:

   714 			if( !cttype )

   715 				{

   716 				CHECK_NO_DUPLICATE(cttype);

   717 				cttype = new (ELeave) SmlPcdata_t();

   718 				return cttype;

   719 				}

   720 			else if( iParent )

   721 				{

   722 				// Support for many CTTypes inside one CTCap - adds new CTCap element in the case of

   723 				// multiple CTTypes within one CTCap. I.e. all following CTTypes will be added into new CTCap elements.

   724 				CXMLElement::TAction action = this->EndElementL(aParams.Callbacks(), EDevCTCap);

   725 				if( action != CXMLElement::ENone )

   726 					{

   727 					CXMLElement* e = aParams.CmdStack()->Pop();

   728 					if( aParams.CleanupStack()->Top() == e )

   729 						{

   730 						aParams.CleanupStack()->Pop();

   731 						}

   732 					if( action == CXMLElement::EPopAndDestroy )

   733 						{

   734 						delete e;

   735 						}

   736 					}

   737 				CXMLElement* e = iParent->BeginElementL(EDevCTCap, aParams.Callbacks());

   738 				if( e )

   739 					{

   740 					aParams.CmdStack()->Push(e);

   741 					return e->BeginElementL(aTag, aParams.Callbacks());

   742 					}

   743 				}				

   744 				User::Leave(KErrGeneral);

   745 

   746 // 1.2 CHANGES - version 1.1 and 1.2 support 

   747 		case EDevVerCT:

   748 			CHECK_NO_DUPLICATE(verct);

   749 			verct = new (ELeave) SmlPcdata_t();

   750 			return verct;

   751 

   752 		case EDevFieldLevel:

   753 			CHECK_NO_DUPLICATE(fieldlevel);

   754 			fieldlevel = new (ELeave) SmlPcdata_t();

   755 			return fieldlevel;

   756 			

   757 		case EDevProperty:

   758 			return AddPropertyL(&property);

   759 // changes end

   760 			

   761 		case EDevPropName:

   762 			prevelem = SML_PROPNAME;

   763 			return AddCTPropL(&prop);

   764 

   765 		case EDevParamName:

   766 		case EDevDisplayName:

   767 		case EDevValEnum:

   768 		case EDevDataType:

   769 		case EDevMaxSize:

   770 			{

   771 			// paramname cannot be added into param -> switch prevelem

   772 			if( (aTag == EDevParamName) && (prevelem == SML_PARAMNAME) )

   773 				{

   774 				prevelem = SML_PROPNAME;

   775 				}

   776 

   777 			CXMLElement* e = GetPreviousElem();

   778 			

   779 			if( aTag == EDevParamName )

   780 				{

   781 				prevelem = SML_PARAMNAME;

   782 				}

   783 

   784 			return e->BeginElementL(aTag, aParams.Callbacks());

   785 			}

   786 

   787 		default:

   788 			User::Leave(KWBXMLParserErrorInvalidTag);

   789 		}

   790 	return 0;

   791 	}

   792 

   793 // ------------------------------------------------------------------------------------------------

   794 // sml_devinf_ctcaplist_s

   795 // ------------------------------------------------------------------------------------------------

   796 EXPORT_C sml_devinf_ctcaplist_s::sml_devinf_ctcaplist_s()

   797 	{

   798 	}

   799 

   800 // ------------------------------------------------------------------------------------------------

   801 EXPORT_C sml_devinf_ctcaplist_s::~sml_devinf_ctcaplist_s()

   802 	{

   803 	delete data;	

   804 	}

   805 

   806 // ------------------------------------------------------------------------------------------------

   807 // sml_devinf_datastore_s

   808 // ------------------------------------------------------------------------------------------------

   809 EXPORT_C sml_devinf_datastore_s::sml_devinf_datastore_s()

   810 	{

   811 	}

   812 

   813 // ------------------------------------------------------------------------------------------------

   814 EXPORT_C sml_devinf_datastore_s::~sml_devinf_datastore_s()

   815 	{

   816 	delete sourceref;    

   817     delete displayname;   /* optional */	

   818     delete maxguidsize;   /* optional */

   819     delete rxpref;        

   820     GenericListDelete( rx ); /* optional */    

   821     delete txpref;            

   822     GenericListDelete( tx ); /* optional */    

   823     delete dsmem;         /* optional */

   824     delete synccap;

   825 	// 1.2 CHANGES : new / moved elements

   826 	delete supportHierarchicalSync;		

   827     GenericListDelete( ctcap );		    	

   828 	GenericListDelete( filterrx ); /*optional*/ 	

   829 	GenericListDelete( filtercap ); /*optional*/	

   830 	// changes end	

   831 	}

   832 

   833 // ------------------------------------------------------------------------------------------------

   834 CXMLElement* sml_devinf_datastore_s::BeginElementL( TUint8 aTag, const TXMLElementParams& /*aParams*/ )

   835 	{

   836 	switch( aTag )

   837 		{

   838 		case EDevSourceRef:

   839 			CHECK_NO_DUPLICATE(sourceref);

   840 			sourceref = new (ELeave) SmlPcdata_t();

   841 			return sourceref;

   842 		

   843 		case EDevDisplayName:

   844 			CHECK_NO_DUPLICATE(displayname);

   845 			displayname = new (ELeave) SmlPcdata_t();

   846 			return displayname;

   847 		

   848 		case EDevMaxGUIDSize:

   849 			CHECK_NO_DUPLICATE(maxguidsize);

   850 			maxguidsize = new (ELeave) SmlPcdata_t();

   851 			return maxguidsize;

   852 		

   853 		case EDevRxPref:

   854 			CHECK_NO_DUPLICATE(rxpref);

   855 			rxpref = new (ELeave) SmlDevInfXmit_t();

   856 			return rxpref; 

   857 

   858 		case EDevRx:

   859 			return AddXmitL(&rx);

   860 

   861 		case EDevTxPref:

   862 			CHECK_NO_DUPLICATE(txpref);

   863 			txpref = new (ELeave) SmlDevInfXmit_t();

   864 			return txpref;

   865 		

   866 		case EDevTx:

   867 			return AddXmitL(&tx);

   868 

   869 //1.2 CHANGES: in version 1.2 CtCap inside DataStore -element 

   870 		case EDevCTCap:

   871 			return AddCtCapL(&ctcap);

   872 // Changes end

   873 

   874 		case EDevDSMem:

   875 			CHECK_NO_DUPLICATE(dsmem);

   876 			dsmem = new (ELeave) SmlDevInfDSMem_t();

   877 			return dsmem;

   878 

   879 		case EDevSupportHierarchicalSync:

   880 			CHECK_NO_DUPLICATE(supportHierarchicalSync);

   881 			supportHierarchicalSync = new (ELeave) SmlPcdata_t();

   882 			return supportHierarchicalSync;

   883 

   884 		case EDevSyncCap:

   885 			CHECK_NO_DUPLICATE(synccap);

   886 			synccap = new (ELeave) SmlDevInfSyncCap_t();

   887 			return synccap;

   888 

   889 //1.2 CHANGES: New elements added FilterRx and FilterCap

   890 		case EDevFilterRx:

   891 			return AddXmitL(&filterrx);

   892 

   893 		case EDevFilterCap:

   894 			return AddFilterCapL(&filtercap);

   895 // Changes end

   896 							

   897 		default:

   898 			User::Leave(KWBXMLParserErrorInvalidTag);

   899 		}

   900 	return 0;

   901 	}

   902 

   903 // ------------------------------------------------------------------------------------------------

   904 // sml_devinf_datastorelist_s

   905 // ------------------------------------------------------------------------------------------------

   906 EXPORT_C sml_devinf_datastorelist_s::sml_devinf_datastorelist_s()

   907 	{

   908 	}

   909 

   910 // ------------------------------------------------------------------------------------------------

   911 EXPORT_C sml_devinf_datastorelist_s::~sml_devinf_datastorelist_s()

   912 	{

   913 	delete data;	

   914 	}

   915 

   916 // ------------------------------------------------------------------------------------------------

   917 // sml_devinf_devinf_s

   918 // ------------------------------------------------------------------------------------------------

   919 EXPORT_C sml_devinf_devinf_s::sml_devinf_devinf_s()

   920 	{

   921 	}

   922 

   923 // ------------------------------------------------------------------------------------------------

   924 EXPORT_C sml_devinf_devinf_s::~sml_devinf_devinf_s()

   925 	{

   926     delete verdtd;

   927     delete man; /* optional */

   928     delete mod; /* optional */

   929     delete oem; /* optional */

   930     delete fwv; /* optional */

   931     delete swv; /* optional */

   932     delete hwv; /* optional */

   933     delete devid;

   934     delete devtyp;    

   935     GenericListDelete( datastore );	

   936 	GenericListDelete( ctcap );    

   937     GenericListDelete( ext );

   938 	}

   939 

   940 

   941 // ------------------------------------------------------------------------------------------------

   942 CXMLElement* sml_devinf_devinf_s::BeginElementL( TUint8 aTag, const TXMLElementParams& /*aParams*/ )

   943 	{

   944 	switch( aTag )

   945 		{

   946 		case EDevVerDTD:

   947 			CHECK_NO_DUPLICATE(verdtd);

   948 			verdtd = new (ELeave) SmlPcdata_t();

   949 			return verdtd;

   950 		

   951 		case EDevMan:

   952 			CHECK_NO_DUPLICATE(man);

   953 			man = new (ELeave) SmlPcdata_t();

   954 			return man;

   955 		

   956 		case EDevMod:

   957 			CHECK_NO_DUPLICATE(mod);

   958 			mod = new (ELeave) SmlPcdata_t();

   959 			return mod;

   960 

   961 		case EDevOEM:

   962 			CHECK_NO_DUPLICATE(oem);

   963 			oem = new (ELeave) SmlPcdata_t();

   964 			return oem;

   965 

   966 		case EDevFwV:

   967 			CHECK_NO_DUPLICATE(fwv);

   968 			fwv = new (ELeave) SmlPcdata_t();

   969 			return fwv;

   970 		

   971 		case EDevSwV:

   972 			CHECK_NO_DUPLICATE(swv);

   973 			swv = new (ELeave) SmlPcdata_t();

   974 			return swv;

   975 

   976 		case EDevHwV:

   977 			CHECK_NO_DUPLICATE(hwv);

   978 			hwv = new (ELeave) SmlPcdata_t();

   979 			return hwv;

   980 

   981 		case EDevDevID:

   982 			CHECK_NO_DUPLICATE(devid);

   983 			devid = new (ELeave) SmlPcdata_t();

   984 			return devid;

   985 

   986 		case EDevDevTyp:

   987 			CHECK_NO_DUPLICATE(devtyp);

   988 			devtyp = new (ELeave) SmlPcdata_t();

   989 			return devtyp;

   990 

   991 		case EDevUTC:

   992 			CHECK_NO_DUPLICATE(flags & SmlUTC_f);

   993 			flags |= SmlUTC_f;

   994 			break;

   995 

   996 		case EDevSupportNumberOfChanges:

   997 			CHECK_NO_DUPLICATE(flags & SmlSupportNumberOfChanges_f);

   998 			flags |= SmlSupportNumberOfChanges_f;

   999 			break;

  1000 		

  1001 		case EDevSupportLargeObjs:

  1002 			CHECK_NO_DUPLICATE(flags & SmlSupportLargeObjects_f);

  1003 			flags |= SmlSupportLargeObjects_f;

  1004 			break;

  1005 		

  1006 		case EDevDataStore:

  1007 			return AddDataStoreL(&datastore);

  1008 

  1009 		case EDevCTCap:

  1010 			return AddCtCapL(&ctcap, this);

  1011 				

  1012 		case EDevExt:

  1013 			return AddExtL(&ext);

  1014 

  1015 		default:

  1016 			User::Leave(KWBXMLParserErrorInvalidTag);

  1017 		}

  1018 	return 0;

  1019 	}

  1020 

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

  1022 CXMLElement::TAction sml_devinf_devinf_s::EndElementL( TAny* aCallbacks, TUint8 aTag )

  1023 	{

  1024 	switch( aTag )

  1025 		{

  1026 		case EDevDevInf:

  1027 			((MWBXMLDevInfCallbacks*)aCallbacks)->smlDeviceInfoL(this);

  1028 			return EPopAndDestroy;

  1029 

  1030 		case EDevUTC:

  1031 		case EDevSupportNumberOfChanges:

  1032 		case EDevSupportLargeObjs:

  1033 			return ENone;

  1034 

  1035 		default:

  1036 			User::Leave(KWBXMLParserErrorInvalidTag);

  1037 		}

  1038 

  1039 	return EPop;

  1040 	}

  1041 

  1042 // ------------------------------------------------------------------------------------------------

  1043 TBool sml_devinf_devinf_s::NeedsCleanup() const

  1044 	{

  1045 	return ETrue;

  1046 	}