1 /*

     2 * Copyright (c) 2005 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:  Sources

    15 *

    16 */

    17 

    18 

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

    20 // Includes

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

    22 #include <badesca.h>

    23 

    24 #include <nsmldebug.h>

    25 #include "nsmldbcaps.h"

    26 #include "smldevinfdtd.h"

    27 #include "smlmetinfdtd.h"

    28 #include "smldevinftags.h"

    29 

    30 

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

    32 // CNSmlDbCaps

    33 // ------------------------------------------------------------------------------------------------

    34 EXPORT_C CNSmlDbCaps* CNSmlDbCaps::NewL()

    35 	{

    36 	//_DBG_FILE("CNSmlDbCaps::NewL(): begin");

    37 	CNSmlDbCaps* self = CNSmlDbCaps::NewLC();

    38 	CleanupStack::Pop(); // self

    39 	//_DBG_FILE("CNSmlDbCaps::NewL(): end");

    40 	return self;

    41 	}

    42 

    43 // ------------------------------------------------------------------------------------------------

    44 // 

    45 // ------------------------------------------------------------------------------------------------

    46 EXPORT_C CNSmlDbCaps* CNSmlDbCaps::NewLC()

    47 	{

    48 	//_DBG_FILE("CNSmlDbCaps::NewLC(): begin");

    49 	CNSmlDbCaps* self = new (ELeave) CNSmlDbCaps();

    50 	CleanupStack::PushL(self);

    51 	self->ConstructL();

    52 	//_DBG_FILE("CNSmlDbCaps::NewLC(): end");

    53 	return self;

    54 	}

    55 

    56 // ------------------------------------------------------------------------------------------------

    57 //

    58 // ------------------------------------------------------------------------------------------------

    59 CNSmlDbCaps::CNSmlDbCaps()

    60 	{

    61 	//_DBG_FILE("CNSmlDbCaps::CNSmlDbCaps(): begin");

    62 	//_DBG_FILE("CNSmlDbCaps::CNSmlDbCaps(): end");

    63 	}

    64 

    65 // ------------------------------------------------------------------------------------------------

    66 //

    67 // ------------------------------------------------------------------------------------------------

    68 void CNSmlDbCaps::ConstructL()

    69 	{

    70 	//_DBG_FILE("CNSmlDbCaps::ConstructL(): begin");

    71 	iDatastore = new (ELeave) sml_devinf_datastore_s();

    72 	//_DBG_FILE("CNSmlDbCaps::ConstructL(): end");

    73 	}

    74 

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

    76 //

    77 // ------------------------------------------------------------------------------------------------

    78 EXPORT_C CNSmlDbCaps::~CNSmlDbCaps()

    79 	{

    80 	//_DBG_FILE("CNSmlDbCaps::~CNSmlDbCaps(): begin");

    81 	delete iDatastore;

    82 //	delete iCtCaps;

    83     delete iFilterCaps;

    84 	//_DBG_FILE("CNSmlDbCaps::~CNSmlDbCaps(): end");

    85 	}

    86 

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

    88 //

    89 // ------------------------------------------------------------------------------------------------

    90 EXPORT_C SmlDevInfDatastorePtr_t CNSmlDbCaps::DatastoreL() const

    91 	{

    92 	//_DBG_FILE("CNSmlDbCaps::Datastore(): begin");

    93 	//_DBG_FILE("CNSmlDbCaps::Datastore(): end");

    94 	SmlDevInfDatastorePtr_t temp = iDatastore;

    95 	iDatastore = new (ELeave) sml_devinf_datastore_s();

    96 	return temp;

    97 	}

    98 

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

   100 //

   101 // ------------------------------------------------------------------------------------------------

   102 EXPORT_C SmlDevInfCtCapListPtr_t CNSmlDbCaps::CtCaps() const

   103 	{

   104 	//_DBG_FILE("CNSmlDbCaps::CtCaps(): begin");

   105 	//_DBG_FILE("CNSmlDbCaps::CtCaps(): end");

   106 	SmlDevInfCtCapListPtr_t temp = iDatastore->ctcap;

   107 	iDatastore->ctcap = 0;

   108 	return temp;

   109 	}

   110 

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

   112 //

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

   114 EXPORT_C SmlDevInfFilterCapListPtr_t CNSmlDbCaps::FilterCaps() const

   115 	{

   116 	SmlDevInfFilterCapListPtr_t temp = iFilterCaps;

   117 	iFilterCaps = 0;

   118 	return temp;

   119 	}

   120 

   121 // ------------------------------------------------------------------------------------------------

   122 //

   123 // ------------------------------------------------------------------------------------------------

   124 EXPORT_C void CNSmlDbCaps::SetRxPrefL( const TDesC8& aCtType, const TDesC8& aVerCt )

   125 	{

   126 	//_DBG_FILE("CNSmlDbCaps::SetRxPrefL(): begin");

   127 	if( !iDatastore->rxpref )

   128 		{

   129 		iDatastore->rxpref = CreateXmitL(aCtType, aVerCt);

   130 		}

   131 	else

   132 		{

   133 		iDatastore->rxpref->cttype->SetDataL(aCtType);

   134 		iDatastore->rxpref->verct->SetDataL(aVerCt);

   135 		}

   136 	//_DBG_FILE("CNSmlDbCaps::SetRxPrefL(): end");

   137 	}

   138 

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

   140 //

   141 // ------------------------------------------------------------------------------------------------

   142 EXPORT_C void CNSmlDbCaps::AddRxL( const TDesC8& aCtType, const TDesC8& aVerCt )

   143 	{

   144 	//_DBG_FILE("CNSmlDbCaps::AddRxL(): begin");

   145 	SmlDevInfXmitListPtr_t node = new (ELeave) SmlDevInfXmitList_t();

   146 	CleanupStack::PushL(node);

   147 	node->data = CreateXmitL(aCtType, aVerCt);

   148 	GenericListAddL(&iDatastore->rx, node);

   149 	CleanupStack::Pop(); // node

   150 	//_DBG_FILE("CNSmlDbCaps::AddRxL(): end");

   151 	}

   152 

   153 // ------------------------------------------------------------------------------------------------

   154 //

   155 // ------------------------------------------------------------------------------------------------

   156 EXPORT_C void CNSmlDbCaps::SetTxPrefL( const TDesC8& aCtType, const TDesC8& aVerCt )

   157 	{

   158 	//_DBG_FILE("CNSmlDbCaps::SetTxPrefL(): begin");

   159 	if( !iDatastore->txpref )

   160 		{

   161 		iDatastore->txpref = CreateXmitL(aCtType, aVerCt);

   162 		}

   163 	else

   164 		{

   165 		iDatastore->txpref->cttype->SetDataL(aCtType);

   166 		iDatastore->txpref->verct->SetDataL(aVerCt);

   167 		}

   168 	//_DBG_FILE("CNSmlDbCaps::SetTxPrefL(): end");

   169 	}

   170 

   171 // ------------------------------------------------------------------------------------------------

   172 //

   173 // ------------------------------------------------------------------------------------------------

   174 EXPORT_C void CNSmlDbCaps::AddTxL( const TDesC8& aCtType, const TDesC8& aVerCt )

   175 	{

   176 	//_DBG_FILE("CNSmlDbCaps::AddTxL(): begin");

   177 	SmlDevInfXmitListPtr_t node = new (ELeave) SmlDevInfXmitList_t();

   178 	CleanupStack::PushL(node);

   179 	node->data = CreateXmitL(aCtType, aVerCt);

   180 	GenericListAddL(&iDatastore->tx, node);

   181 	CleanupStack::Pop(); // node

   182 	//_DBG_FILE("CNSmlDbCaps::AddTxL(): end");

   183 	}

   184 

   185 // ------------------------------------------------------------------------------------------------

   186 //

   187 // ------------------------------------------------------------------------------------------------

   188 EXPORT_C void CNSmlDbCaps::SetSyncType( ENSmlSyncTypes aType )

   189 	{

   190 	//_DBG_FILE("CNSmlDbCaps::SetSyncType(): begin");

   191 	if( aType == EAllTypes )

   192 		{

   193 		iSyncTypes = 0xffffffff;

   194 		}

   195 	else

   196 		{

   197 		iSyncTypes |= (1<<aType);

   198 		}

   199 	//_DBG_FILE("CNSmlDbCaps::SetSyncType(): end");

   200 	}

   201 

   202 // ------------------------------------------------------------------------------------------------

   203 //

   204 // ------------------------------------------------------------------------------------------------

   205 EXPORT_C TBool CNSmlDbCaps::SupportsSyncType( ENSmlSyncTypes aType ) const

   206 	{

   207 	//_DBG_FILE("CNSmlDbCaps::SupportsSyncType(): begin");

   208 	//_DBG_FILE("CNSmlDbCaps::SupportsSyncType(): end");

   209 	return (((1<<aType)&iSyncTypes) != 0);

   210 	}

   211 

   212 // ------------------------------------------------------------------------------------------------

   213 //

   214 // ------------------------------------------------------------------------------------------------

   215 EXPORT_C CNSmlCtCapsHandler* CNSmlDbCaps::CreateHandlerL() const

   216 	{

   217 	//_DBG_FILE("CNSmlDbCaps::CreateHandlerL(): begin");

   218 	//_DBG_FILE("CNSmlDbCaps::CreateHandlerL(): end");

   219 	return new (ELeave) CNSmlCtCapsHandler(iDatastore->ctcap);

   220 	}

   221 

   222 // ------------------------------------------------------------------------------------------------

   223 //

   224 // ------------------------------------------------------------------------------------------------

   225 

   226 EXPORT_C void CNSmlDbCaps::AddFilterRxL( const TDesC8& aCtType, const TDesC8& aVerCt )

   227     {

   228 	SmlDevInfXmitListPtr_t filter = new (ELeave) SmlDevInfXmitList_t();

   229 	CleanupStack::PushL(filter);

   230 	filter->data = CreateXmitL(aCtType, aVerCt);

   231 	GenericListAddL(&iDatastore->filterrx, filter);    

   232 	CleanupStack::Pop(); // filter

   233     }

   234 

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

   236 //

   237 // ------------------------------------------------------------------------------------------------

   238 

   239 EXPORT_C CNSmlFilterCap* CNSmlDbCaps::AddFilterCapLC( const TDesC8& aCtType, const TDesC8& aVerCt )                                        

   240     {

   241     SmlDevInfFilterCapListPtr_t filtercap = new (ELeave) SmlDevInfFilterCapList_t();

   242     CleanupStack::PushL(filtercap);

   243     GenericListAddL(&iFilterCaps, filtercap);

   244     CleanupStack::Pop(); // filtercap

   245 

   246     filtercap->data = new (ELeave) SmlDevInfFilterCap_t();

   247     filtercap->data->cttype = new (ELeave) SmlPcdata_t();

   248     filtercap->data->cttype->SetDataL(aCtType);

   249     filtercap->data->verct = new (ELeave) SmlPcdata_t();

   250     filtercap->data->verct->SetDataL(aVerCt);

   251 

   252     CNSmlFilterCap* f = new (ELeave) CNSmlFilterCap(filtercap->data);

   253     CleanupStack::PushL(f);

   254     return f;

   255     }

   256 

   257 // ------------------------------------------------------------------------------------------------

   258 //

   259 // ------------------------------------------------------------------------------------------------

   260 

   261 EXPORT_C void CNSmlDbCaps::SetSupportHierarchicalSyncL()

   262     {

   263     if ( !iDatastore->supportHierarchicalSync )

   264         {

   265         iDatastore->supportHierarchicalSync = new (ELeave) SmlPcdata_t();

   266         }

   267     iDatastore->supportHierarchicalSync->SetDataL(TPtrC8());

   268     }

   269 

   270 // ------------------------------------------------------------------------------------------------

   271 //

   272 // ------------------------------------------------------------------------------------------------

   273 

   274 EXPORT_C void CNSmlDbCaps::SetSourceRefL( const TDesC8& aSourceRef )

   275     {

   276     if ( !iDatastore->sourceref )

   277         {

   278         iDatastore->sourceref = new (ELeave) SmlPcdata_t();

   279         }

   280 	iDatastore->sourceref->SetDataL(aSourceRef);

   281     }

   282 

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

   284 //

   285 // ------------------------------------------------------------------------------------------------

   286 

   287 EXPORT_C void CNSmlDbCaps::SetDisplayNameL( const TDesC8& aDispName )

   288     {

   289     if ( !iDatastore->displayname )

   290         {

   291         iDatastore->displayname = new (ELeave) SmlPcdata_t();

   292         }

   293     iDatastore->displayname->SetDataL(aDispName);

   294     }

   295 

   296 // ------------------------------------------------------------------------------------------------

   297 //

   298 // ------------------------------------------------------------------------------------------------

   299 

   300 EXPORT_C void CNSmlDbCaps::SetMaxGuidSizeL( const TDesC8& aMaxGuid )

   301     {

   302     if ( !iDatastore->maxguidsize )

   303         {

   304         iDatastore->maxguidsize = new (ELeave) SmlPcdata_t();

   305         }

   306 	iDatastore->maxguidsize->SetDataL(aMaxGuid);

   307     }

   308 

   309 // ------------------------------------------------------------------------------------------------

   310 //

   311 // ------------------------------------------------------------------------------------------------

   312 EXPORT_C CNSmlCtCap* CNSmlDbCaps::AddCtCapLC()

   313 	{

   314 	//_DBG_FILE("CNSmlDbCaps::AddCtCapL(): begin");

   315 	SmlDevInfCtCapListPtr_t cpcapptr = new (ELeave) SmlDevInfCtCapList_t();

   316 	CleanupStack::PushL(cpcapptr);

   317 	GenericListAddL(&iDatastore->ctcap, cpcapptr);

   318 	CleanupStack::Pop(); // cpcapptr

   319 	cpcapptr->data = new (ELeave) SmlDevInfCtCap_t();

   320 	CNSmlCtCap* c = new (ELeave) CNSmlCtCap(cpcapptr->data);

   321 	CleanupStack::PushL(c);

   322 	//_DBG_FILE("CNSmlDbCaps::AddCtCapL(): end");

   323 	return c;

   324 	}

   325 

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

   327 //

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

   329 SmlPcdataPtr_t CNSmlDbCaps::CreatePcdataL( const TDesC8& aData )

   330 	{

   331 	//_DBG_FILE("CNSmlDbCaps::CreatePcdataL(): begin");

   332 	SmlPcdataPtr_t temp = new (ELeave) SmlPcdata_t();	

   333 	CleanupStack::PushL(temp);

   334 	temp->SetDataL(aData);

   335 	CleanupStack::Pop(); // temp

   336 	//_DBG_FILE("CNSmlDbCaps::CreatePcdataL(): end");

   337 	return temp;

   338 	}

   339 

   340 // ------------------------------------------------------------------------------------------------

   341 //

   342 // ------------------------------------------------------------------------------------------------

   343 SmlDevInfXmitPtr_t CNSmlDbCaps::CreateXmitL( const TDesC8& aCtType, const TDesC8& aVerCt )

   344 	{

   345 	//_DBG_FILE("CNSmlDbCaps::CreateXmitL(): begin");

   346 	SmlDevInfXmitPtr_t temp = new (ELeave) SmlDevInfXmit_t();

   347 	CleanupStack::PushL(temp);

   348 	temp->cttype = CreatePcdataL(aCtType);

   349 	temp->verct = CreatePcdataL(aVerCt);

   350 	CleanupStack::Pop(); // temp

   351 	//_DBG_FILE("CNSmlDbCaps::CreateXmitL(): end");

   352 	return temp;

   353 	}

   354 

   355 // ------------------------------------------------------------------------------------------------

   356 //

   357 // ------------------------------------------------------------------------------------------------

   358 EXPORT_C TInt CNSmlDbCaps::ConvertDeviceInfoL( sml_devinf_devinf_s* aDeviceInfo)

   359 	{

   360 

   361 	SmlDevInfCtCapListPtr_t target = new (ELeave) SmlDevInfCtCapList_t();

   362 	CleanupStack::PushL(target);

   363 	target =0;

   364 

   365 	TPtrC8 ver;

   366 	ver.Set(aDeviceInfo->verdtd->Data());

   367 

   368 	if ( ver.FindC(_L8("1.2")) != KErrNone ) 

   369 		{

   370 		CleanupStack::PopAndDestroy(); // target

   371 		return KErrNotSupported;

   372 		} 

   373 

   374 	aDeviceInfo->verdtd->SetDataL( _L8("1.1"));

   375 

   376 	for ( SmlDevInfDatastoreListPtr_t datastorePtr = aDeviceInfo->datastore; datastorePtr && datastorePtr->data; datastorePtr = datastorePtr->next )

   377 		{	

   378 	for ( SmlDevInfCtCapListPtr_t ctcapPtr = datastorePtr->data->ctcap; ctcapPtr && ctcapPtr->data; ctcapPtr = ctcapPtr->next )

   379 			{

   380 			SmlDevInfCtCapListPtr_t ctcaps = new (ELeave) SmlDevInfCtCapList_t();

   381 			CleanupStack::PushL( ctcaps);

   382 			GenericListAddL(&target, ctcaps);

   383 			CleanupStack::Pop(); // ctcaps

   384 			ctcaps->data = new (ELeave) SmlDevInfCtCap_t();

   385 			ctcaps->data->cttype = new (ELeave) SmlPcdata_t();

   386 			ctcaps->data->cttype->SetDataL ( ctcapPtr->data->cttype->Data() );

   387 			for ( SmlDevInfPropertyListPtr_t propPtr = ctcapPtr->data->property; propPtr && propPtr->data; propPtr = propPtr->next)

   388 				{

   389 				SmlDevInfCTDataPropListPtr_t props = new (ELeave) SmlDevInfCTDataPropList_t();

   390 				CleanupStack::PushL( props );

   391 				GenericListAddL(&ctcaps->data->prop, props);

   392 				CleanupStack::Pop(); // props

   393 				props->data = new (ELeave) SmlDevInfCTDataProp_t();

   394 				props->data->prop = new (ELeave) SmlDevInfCTData_t();

   395 				props->data->prop->name = new (ELeave) SmlPcdata_t();

   396 				props->data->prop->name->SetDataL ( propPtr->data->propname->Data() );

   397 				if ( propPtr->data->datatype )

   398 					{

   399 					props->data->prop->datatype = new (ELeave) SmlPcdata_t();

   400 					props->data->prop->datatype->SetDataL ( propPtr->data->datatype->Data() );

   401 					}

   402 				if ( propPtr->data->displayname)

   403 					{

   404 					props->data->prop->dname = new (ELeave) SmlPcdata_t();

   405 					props->data->prop->dname->SetDataL ( propPtr->data->displayname->Data() );

   406 					}

   407 				if ( propPtr->data->maxsize)

   408 					{

   409 					props->data->prop->size = new (ELeave) SmlPcdata_t();

   410 					props->data->prop->size->SetDataL ( propPtr->data->maxsize->Data() );

   411 					}

   412 		for ( SmlPcdataListPtr_t valenumPtr = propPtr->data->valenum; valenumPtr && valenumPtr->data; valenumPtr = valenumPtr->next)

   413 					{

   414 					SmlPcdataListPtr_t valenum = new (ELeave) SmlPcdataList_t();

   415 					CleanupStack::PushL(valenum);

   416 					GenericListAddL(&props->data->prop->valenum, valenum);

   417 					CleanupStack::Pop(); // valenum

   418 					valenum->data=new (ELeave) SmlPcdata_t();

   419 					valenum->data->SetDataL ( valenumPtr->data->Data());

   420 					}

   421 			for ( SmlDevInfPropParamListPtr_t paramPtr = propPtr->data->propparam; paramPtr && paramPtr->data; paramPtr = paramPtr->next )

   422 					{

   423 					SmlDevInfCTDataListPtr_t param = new (ELeave) SmlDevInfCTDataList_t();

   424 					CleanupStack::PushL(param);

   425 					GenericListAddL(&props->data->param, param);

   426 					CleanupStack::Pop(); // param

   427 					param->data = new (ELeave) SmlDevInfCTData_t();

   428 					param->data->name = new (ELeave) SmlPcdata_t();

   429 					param->data->name->SetDataL (paramPtr->data->paramname->Data() );

   430 					if ( paramPtr->data->displayname )

   431 						{

   432 						param->data->dname = new (ELeave) SmlPcdata_t();

   433 						param->data->dname->SetDataL (paramPtr->data->displayname->Data() );

   434 						}

   435 					if ( paramPtr->data->datatype)

   436 						{

   437 						param->data->datatype = new (ELeave) SmlPcdata_t();

   438 						param->data->datatype->SetDataL ( paramPtr->data->datatype->Data() );

   439 						}

   440 					for (SmlPcdataListPtr_t valenumPtr = paramPtr->data->valenum; valenumPtr && valenumPtr->data; valenumPtr = valenumPtr->next )

   441 						{

   442 						SmlPcdataListPtr_t valenum = new (ELeave) SmlPcdataList_t();

   443 						CleanupStack::PushL(valenum);

   444 						GenericListAddL(&param->data->valenum, valenum);

   445 						CleanupStack::Pop(); // valenum

   446 						valenum->data = new (ELeave) SmlPcdata_t();

   447 						valenum->data->SetDataL ( valenumPtr->data->Data() );

   448 						}

   449 					}

   450 				}

   451 			}

   452 		}

   453 	aDeviceInfo->ctcap = target;

   454 

   455 	CleanupStack::PopAndDestroy(); // target

   456 

   457 	return KErrNone;

   458 	};

   459 	

   460 // ------------------------------------------------------------------------------------------------

   461 // CNSmlDbCaps::SetMaxItemsL

   462 // Sets maxitems element. Same as: iDatastore->dsmem->maxid

   463 // ------------------------------------------------------------------------------------------------

   464 void CNSmlDbCaps::SetMaxItemsL( const TDesC8& aMaxItems )

   465 	{

   466 	if ( !iDatastore->dsmem )

   467 		{

   468 		iDatastore->dsmem = new (ELeave) SmlDevInfDSMem_t();

   469 		}

   470 	if ( !iDatastore->dsmem->maxid )

   471         {

   472         iDatastore->dsmem->maxid = new (ELeave) SmlPcdata_t();

   473         }

   474 	iDatastore->dsmem->maxid->SetDataL( aMaxItems );

   475 	}

   476 

   477 // ------------------------------------------------------------------------------------------------

   478 // CNSmlDbCaps::SetMaxSizeL

   479 // sets maxsize element. Same as: iDatastore->dsmem->maxmem

   480 // ------------------------------------------------------------------------------------------------

   481 void CNSmlDbCaps::SetMaxSizeL( const TDesC8& aMaxSize )

   482 	{

   483 	if ( !iDatastore->dsmem )

   484 		{

   485 		iDatastore->dsmem = new (ELeave) SmlDevInfDSMem_t();

   486 		}

   487 	if ( !iDatastore->dsmem->maxmem )

   488         {

   489         iDatastore->dsmem->maxmem = new (ELeave) SmlPcdata_t();

   490         }

   491 	iDatastore->dsmem->maxmem->SetDataL( aMaxSize );

   492 	}

   493 

   494 // ------------------------------------------------------------------------------------------------

   495 // CNSmlDbCaps::Datastore

   496 // Returns datastore structure.

   497 // ------------------------------------------------------------------------------------------------

   498 const sml_devinf_datastore_s* CNSmlDbCaps::Datastore() const

   499 	{

   500 	return iDatastore;

   501 	}

   502 	

   503 // ------------------------------------------------------------------------------------------------

   504 // CNSmlDbCaps::FilterCapsList

   505 // Returns pointer to filtercap structure.

   506 // ------------------------------------------------------------------------------------------------

   507 const sml_devinf_filtercaplist_s* CNSmlDbCaps::FilterCapsList() const

   508 	{

   509 	return iFilterCaps;

   510 	}

   511 

   512 // ------------------------------------------------------------------------------------------------

   513 // 

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

   515 EXPORT_C CNSmlFilterCapsHandler* CNSmlDbCaps::CreateFilterCapsHandlerL() const

   516 	{

   517 	//_DBG_FILE("CNSmlDbCaps::CreateHandlerL(): begin");

   518 	//_DBG_FILE("CNSmlDbCaps::CreateHandlerL(): end");

   519 	return new (ELeave) CNSmlFilterCapsHandler(iFilterCaps);

   520 	}

   521 

   522 // End of File