syncmlfw/ds/dsutils/dbcaps/src/NSmldbcapsSerializer.cpp
changeset 0 b497e44ab2fc
child 11 06f47423ecee
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/syncmlfw/ds/dsutils/dbcaps/src/NSmldbcapsSerializer.cpp	Thu Dec 17 09:07:52 2009 +0200
@@ -0,0 +1,880 @@
+/*
+* Copyright (c) 2005 Nokia Corporation and/or its subsidiary(-ies). 
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:  for dbcaps streaming and converting to CSmlDataStoreFormat.
+*
+*/
+
+
+#include <stringpool.h>
+#include <s32strm.h>
+
+#include <nsmlunicodeconverter.h>
+#include "nsmldbcaps.h"
+#include "smldevinfdtd.h"
+#include "smlmetinfdtd.h"
+#include "smldevinftags.h"
+#include "NSmldbcapsSerializer.h"
+
+// ------------------------------------------------------------------------------------------------
+// Constants
+// ------------------------------------------------------------------------------------------------
+_LIT8( KNSmlFolderType, "application/vnd.omads-folder+xml" );
+_LIT8( KNSmlFolderVersion, "1.2" );
+
+const TInt KNSml32BitNumLength = 12;
+
+// ------------------------------------------------------------------------------------------------
+// TNSmlDbCapsSerializer::CNSmlFilterCapabilityData::NewLC()
+// constructs CNSmlFilterCapabilityData
+// ------------------------------------------------------------------------------------------------
+TNSmlDbCapsSerializer::CNSmlFilterCapabilityData* TNSmlDbCapsSerializer::CNSmlFilterCapabilityData::NewLC()
+	{
+	CNSmlFilterCapabilityData* self = new ( ELeave ) CNSmlFilterCapabilityData();
+	CleanupDeletePushL( self );
+	return self;
+	}
+
+// ------------------------------------------------------------------------------------------------
+// TNSmlDbCapsSerializer::CNSmlFilterCapabilityData::~CNSmlFilterCapabilityData()
+// C++ destructor
+// ------------------------------------------------------------------------------------------------	
+TNSmlDbCapsSerializer::CNSmlFilterCapabilityData::~CNSmlFilterCapabilityData()
+	{
+	iFilterCapabilities.ResetAndDestroy();
+	iMimeVersion.Close();
+	iMimeType.Close();
+	
+	for (TInt i = 0; i < iKeywordList.Count(); i++ )
+		{
+		iKeywordList[i].Close();
+		}
+	iKeywordList.Reset();
+	
+	for (TInt i = 0; i < iPropertyList.Count(); i++)
+		{
+		iPropertyList[i].Close();
+		}
+	iPropertyList.Reset();
+	}
+
+// ------------------------------------------------------------------------------------------------
+// TNSmlDbCapsSerializer::CNSmlFilterCapabilityData::MakeL()
+// C++ destructor
+// ------------------------------------------------------------------------------------------------		
+void TNSmlDbCapsSerializer::CNSmlFilterCapabilityData::MakeL( 
+	const RStringPool& aStringPool, const CArrayFix<TNSmlFilterCapData>& aFilterInfoArr )
+	{
+	
+	if ( &aFilterInfoArr == NULL )
+		{
+		return;
+		}
+	
+	for( TInt i = 0 ; i < aFilterInfoArr.Count(); i++ )
+		{
+		const TNSmlFilterCapData& fcd = aFilterInfoArr[i];
+		switch( fcd.iTag )
+			{
+			case TNSmlFilterCapData::ECtType:
+				iMimeType = aStringPool.OpenFStringL( fcd.iValue );
+				break;
+			case TNSmlFilterCapData::EVerCt:
+				iMimeVersion = aStringPool.OpenFStringL( fcd.iValue );
+				break;
+			case TNSmlFilterCapData::EFilterKeyword:
+				{
+				RString tmprstr( aStringPool.OpenStringL( fcd.iValue ) );
+				CleanupClosePushL( tmprstr );
+				iKeywordList.AppendL( tmprstr );
+				CleanupStack::Pop(); //tmprstr
+				}
+				break;
+			case TNSmlFilterCapData::EPropName:
+				{
+				RString tmprstr( aStringPool.OpenStringL( fcd.iValue ) );
+				CleanupClosePushL( tmprstr );
+				iPropertyList.AppendL( tmprstr );
+				CleanupStack::Pop(); //tmprstr
+				}
+				break;
+			default:
+				User::Leave( KErrArgument );
+			}
+		}
+	CSmlFilterCapability* fc = CSmlFilterCapability::NewLC();
+	
+	fc->SetMimeTypeL( iMimeType );
+	fc->SetMimeVersionL( iMimeVersion );
+	fc->SetPropertiesListL( iPropertyList );
+	fc->SetKeyWordListL( iKeywordList );
+	
+	iFilterCapabilities.AppendL( fc );
+	CleanupStack::Pop( fc );
+	}
+// ------------------------------------------------------------------------------------------------
+// TNSmlDbCapsSerializer::CSmlDataFieldFromDbCaps::NewLC()
+// constructs CSmlDataField from parameters
+// ------------------------------------------------------------------------------------------------
+CSmlDataField* TNSmlDbCapsSerializer::CNSmlDataFieldFromDbCaps::NewLC(
+														const RStringPool& aStringPool,
+														const TPtrC8& aDisplayName, 
+														const TPtrC8& aPropName,
+														const TPtrC8& aDataType,
+														const sml_pcdata_list_s* aValEnums )
+	{
+	CNSmlDataFieldFromDbCaps* self = new ( ELeave ) CNSmlDataFieldFromDbCaps();
+	CleanupStack::PushL( self );
+	
+	//display name
+	NSmlUnicodeConverter::HBufC16InUnicodeLC( aDisplayName, self->iDisplayName );
+	CleanupStack::Pop( self->iDisplayName ); // self->iDisplayName
+	
+	//name
+	self->iName = aStringPool.OpenStringL( aPropName );
+	
+	//data type
+	self->iDataType = aStringPool.OpenStringL( aDataType );
+	
+	//value enums
+	for ( ; aValEnums; aValEnums = aValEnums->next )
+		{
+		const SmlPcdataPtr_t val = aValEnums->data;
+		if ( val )
+			{
+			RString tmprstr( aStringPool.OpenStringL( TNSmlDbCapsSerializer::SafePtr( val ) ) );
+			CleanupClosePushL( tmprstr );
+			self->iEnumValues.AppendL( tmprstr );
+			CleanupStack::Pop(); // tmprstr
+			}
+		}
+	
+	return self;
+	}
+														
+// ------------------------------------------------------------------------------------------------
+// TNSmlDbCapsSerializer::CSmlDataPropertyParamFromDbCaps::NewLC()
+// constructs CSmlDataPropertyParam from parameters
+// ------------------------------------------------------------------------------------------------
+CSmlDataPropertyParam* TNSmlDbCapsSerializer::CNSmlDataPropertyParamFromDbCaps::NewLC(
+														const RStringPool& aStringPool,
+														const sml_devinf_propparam_s* aDipp )
+	{
+	CNSmlDataPropertyParamFromDbCaps* self = new ( ELeave ) CNSmlDataPropertyParamFromDbCaps();
+	CleanupStack::PushL( self );
+	
+	//diplay name, property name, datatype, value enums -> iField
+	self->iField = CNSmlDataFieldFromDbCaps::NewLC( aStringPool, 
+		TNSmlDbCapsSerializer::SafePtr( aDipp->displayname ), 
+		TNSmlDbCapsSerializer::SafePtr( aDipp->paramname ),
+		TNSmlDbCapsSerializer::SafePtr( aDipp->datatype ), 
+		aDipp->valenum );
+		
+	CleanupStack::Pop( self->iField ); // self->iField
+
+	return self;
+	}
+	
+// ------------------------------------------------------------------------------------------------
+// TNSmlDbCapsSerializer::CSmlDataPropertyFromDbCaps::NewLC()
+// constructs CSmlDataProperty from parameters
+// ------------------------------------------------------------------------------------------------
+CSmlDataProperty* TNSmlDbCapsSerializer::CNSmlDataPropertyFromDbCaps::NewLC(
+														const RStringPool& aStringPool,
+														const sml_devinf_property_s* aDip )
+	{
+	CNSmlDataPropertyFromDbCaps* self = new ( ELeave ) CNSmlDataPropertyFromDbCaps();
+	CleanupStack::PushL( self );
+	
+	//max occur
+	if( aDip->maxoccur )
+		{
+		TLex8 lex( aDip->maxoccur->Data() );
+		User::LeaveIfError( lex.Val( self->iMaxOccur, EDecimal ) );
+		self->iFlags |= KSmlDataProperty_HasMaxOccur;
+		}
+	
+	//max size
+	if ( aDip->maxsize )
+		{
+		TLex8 lex( aDip->maxsize->Data() );
+		User::LeaveIfError( lex.Val( self->iMaxSize, EDecimal ) );
+		self->iFlags |= KSmlDataProperty_HasMaxSize;
+		}
+	
+	//options
+	if ( aDip->notruncate )
+		{
+		self->iFlags |= KSmlDataProperty_NoTruncate;
+		}
+	
+	//diplay name, property name, datatype, value enums -> iField
+	self->iField = CNSmlDataFieldFromDbCaps::NewLC( aStringPool, 
+		TNSmlDbCapsSerializer::SafePtr( aDip->displayname ), 
+		TNSmlDbCapsSerializer::SafePtr( aDip->propname ),
+		TNSmlDbCapsSerializer::SafePtr( aDip->datatype ), 
+		aDip->valenum );
+		
+	CleanupStack::Pop( self->iField ); // self->iField
+		
+	SmlDevInfPropParamListPtr_t dippl = aDip->propparam;
+
+	for ( ; dippl; dippl = dippl->next )
+		{
+		SmlDevInfPropParamPtr_t dipp = dippl->data;
+		if ( dipp )
+			{
+			CSmlDataPropertyParam* temppoint = CNSmlDataPropertyParamFromDbCaps::NewLC( aStringPool, dipp );
+			self->iParams.AppendL( temppoint );
+			CleanupStack::Pop(); // temppoint
+			}
+		}
+	
+	return self;
+	}
+
+// ------------------------------------------------------------------------------------------------
+// TNSmlDbCapsSerializer::CSmlFilterCapabilityFromDbCaps::NewLC()
+// constructs CSmlFilterCapability from parameters
+// ------------------------------------------------------------------------------------------------
+CSmlFilterCapability* TNSmlDbCapsSerializer::CNSmlFilterCapabilityFromDbCaps::NewLC( 
+														const RStringPool& aStringPool, 
+														const sml_devinf_filtercap_s* aFtCap )
+	{
+	CNSmlFilterCapabilityFromDbCaps* self = new ( ELeave ) CNSmlFilterCapabilityFromDbCaps();
+	CleanupStack::PushL( self );
+	
+	//mime type
+	self->iMimeType = aStringPool.OpenFStringL( TNSmlDbCapsSerializer::SafePtr( aFtCap->cttype ) );
+	
+	//mime version
+	self->iMimeVersion = aStringPool.OpenFStringL( TNSmlDbCapsSerializer::SafePtr( aFtCap->verct ) );
+	
+	//keywords
+	SmlPcdataListPtr_t keys = aFtCap->filterkeyword;
+	for( ; keys; keys = keys->next )
+		{
+		if ( keys->data )
+			{
+			const TDesC8& key = keys->data->Data();
+			RString rkey( aStringPool.OpenStringL( key ) );
+			CleanupClosePushL( rkey );
+			self->iKeywordList.AppendL( rkey );
+			CleanupStack::Pop(); // rkey
+			}
+		}
+	
+	//properties
+	SmlPcdataListPtr_t props = aFtCap->propname;
+	for( ; props; props = props->next )
+		{
+		if ( props->data )
+			{
+			const TDesC8& prop = props->data->Data();
+			RString rprop( aStringPool.OpenStringL( prop ) );
+			CleanupClosePushL( rprop );
+			self->iPropertyList.AppendL( rprop );
+			CleanupStack::Pop(); // rkey
+			}
+		}
+	
+	return self;
+	}
+	
+// ------------------------------------------------------------------------------------------------
+// TNSmlDbCapsSerializer::CSmlMimeFormatFromDbCaps::NewLC()
+// constructs CSmlMimeFormat from parameters
+// ------------------------------------------------------------------------------------------------
+CSmlMimeFormat* TNSmlDbCapsSerializer::CNSmlMimeFormatFromDbCaps::NewLC( 
+														const RStringPool& aStringPool, 
+														const sml_devinf_ctcap_s& aDic )
+	{
+	CNSmlMimeFormatFromDbCaps* self = new ( ELeave ) CNSmlMimeFormatFromDbCaps();
+	CleanupStack::PushL( self );
+	
+	//mime type
+	self->iMimeType = aStringPool.OpenFStringL( TNSmlDbCapsSerializer::SafePtr( aDic.cttype ) );
+	
+	//mime version
+	self->iMimeVersion = aStringPool.OpenFStringL( TNSmlDbCapsSerializer::SafePtr( aDic.verct ) );
+	
+	//field level
+	self->iFieldLevel = EFalse;
+	if ( aDic.fieldlevel )
+		{
+		self->iFieldLevel = ETrue;
+		}
+		
+	//properties
+	SmlDevInfPropertyListPtr_t dipl = aDic.property;
+	for ( ; dipl; dipl = dipl->next )
+		{
+		const SmlDevInfPropertyPtr_t dip = dipl->data;
+		if ( dip )
+			{
+			CSmlDataProperty *temppoint = CNSmlDataPropertyFromDbCaps::NewLC( aStringPool, dip );
+			self->iProperties.AppendL( temppoint );
+			CleanupStack::Pop(); // temppoint
+			}
+		}
+		
+	return self;
+	}
+	
+// ------------------------------------------------------------------------------------------------
+// TNSmlDbCapsSerializer::CSmlDataStoreFormatFromDbCaps::NewLC()
+// constructs CSmlDataStoreFormat from parameters
+// ------------------------------------------------------------------------------------------------
+CSmlDataStoreFormat* TNSmlDbCapsSerializer::CNSmlDataStoreFormatFromDbCaps::NewLC(
+														const RStringPool& aStringPool,
+														const CNSmlDbCaps& aDbCaps )
+	{
+	CNSmlDataStoreFormatFromDbCaps* self = new ( ELeave ) CNSmlDataStoreFormatFromDbCaps();
+	CleanupStack::PushL( self );
+	const sml_devinf_datastore_s* dds = aDbCaps.Datastore();
+	
+	//display name
+	NSmlUnicodeConverter::HBufC16InUnicodeLC( 
+		TNSmlDbCapsSerializer::SafePtr( dds->displayname ), self->iDisplayName );
+	CleanupStack::Pop( self->iDisplayName ); // self->iDisplayName
+	
+	//sync types
+	TSmlSyncTypeMask& synctype( self->iSyncTypeMask );
+			
+	if ( aDbCaps.SupportsSyncType( CNSmlDbCaps::ETwoWaySync ) )
+		{
+		synctype.SetSupported( ESmlTwoWay );
+		}
+	else
+		{
+		synctype.SetNotSupported( ESmlTwoWay );
+		}
+	
+	if ( aDbCaps.SupportsSyncType( CNSmlDbCaps::EOneWaySyncFromServer ) )
+		{
+		synctype.SetSupported( ESmlOneWayFromServer );
+		}
+	else
+		{
+		synctype.SetNotSupported( ESmlOneWayFromServer );
+		}
+	
+	if ( aDbCaps.SupportsSyncType( CNSmlDbCaps::EOneWaySyncFromClient ) )
+		{
+		synctype.SetSupported( ESmlOneWayFromClient );
+		}
+	else
+		{
+		synctype.SetNotSupported( ESmlOneWayFromClient );
+		}
+	
+	if ( aDbCaps.SupportsSyncType( CNSmlDbCaps::ESlowTwoWaySync ) ) 
+		{
+		synctype.SetSupported( ESmlSlowSync );
+		}
+	else
+		{
+		synctype.SetNotSupported( ESmlSlowSync );
+		}
+	
+	if ( aDbCaps.SupportsSyncType( CNSmlDbCaps::ERefreshSyncFromServer ) )
+		{
+		synctype.SetSupported( ESmlRefreshFromServer );	
+		}
+	else
+		{
+		synctype.SetNotSupported( ESmlRefreshFromServer );
+		}
+	
+	if ( aDbCaps.SupportsSyncType( CNSmlDbCaps::ERefreshSyncFromClient ) ) 
+		{
+		synctype.SetSupported( ESmlRefreshFromClient );
+		}
+	else
+		{
+		synctype.SetNotSupported( ESmlRefreshFromClient );
+		}
+	
+	if ( dds->dsmem )
+		{
+		//max size
+		if ( dds->dsmem->maxmem )
+			{
+			TLex8 lex( dds->dsmem->maxmem->Data() );
+			User::LeaveIfError( lex.Val( self->iMaxSize, EDecimal ) );
+			self->iFlags |= KSmlDataStore_HasMaxSize;
+			}
+		
+		//max items
+		if ( dds->dsmem->maxid )
+			{
+			TLex8 lex( dds->dsmem->maxid->Data() );
+			User::LeaveIfError( lex.Val( self->iMaxItems, EDecimal ) );
+			self->iFlags |= KSmlDataStore_HasMaxItems;
+			}
+		}
+	
+	//options
+	if ( dds->supportHierarchicalSync )
+		{
+		self->iFlags |= KSmlDataStore_Hierarchical;
+		}
+	
+	//filter caps
+	const sml_devinf_filtercaplist_s* filterList = aDbCaps.FilterCapsList();
+	
+	for ( ; filterList; filterList = filterList->next )
+		{
+		const SmlDevInfFilterCapPtr_t ft = filterList->data;
+		if (ft)
+			{
+			CSmlFilterCapability* fc = CNSmlFilterCapabilityFromDbCaps::NewLC( aStringPool, ft );
+			self->iFilterCapabilities.AppendL( fc );
+			CleanupStack::Pop(); // fc
+			}
+		}
+	
+	// CSmlMimeFormat
+	RPointerArray<CSmlMimeFormat> mimeFormatArray;
+	CleanupClosePushL( mimeFormatArray );
+	// First search all mime types that server supports at receiving
+	// RX-pref
+	CSmlMimeFormat* tempFormatRX = CSmlMimeFormat::NewLC();
+	const TPtrC8& ctTypeRX = TNSmlDbCapsSerializer::SafePtr( dds->rxpref->cttype );
+	const TPtrC8& verCtRX = TNSmlDbCapsSerializer::SafePtr( dds->rxpref->verct );
+	if ( ctTypeRX.Compare( KNullDesC8 ) != 0 && verCtRX.Compare( KNullDesC8 ) != 0 )
+		{
+		RStringF mimeFormatRX = aStringPool.OpenFStringL( ctTypeRX );
+		RStringF mimeVersionRX = aStringPool.OpenFStringL( verCtRX );
+		tempFormatRX->SetMimeTypeL( mimeFormatRX );
+		tempFormatRX->SetMimeVersionL( mimeVersionRX );
+		mimeFormatArray.AppendL( tempFormatRX );
+		CleanupStack::Pop(); // tempFormatRX
+		}
+	else
+		{
+		CleanupStack::PopAndDestroy(); // tempFormatRX
+		}
+	// RXs
+	if ( dds )
+		{
+		SmlDevInfXmitListPtr_t rx = dds->rx;
+		for ( ; rx ; rx = rx->next )
+			{
+			CSmlMimeFormat* tempFormat = CSmlMimeFormat::NewLC();
+			const TPtrC8& ctType = TNSmlDbCapsSerializer::SafePtr( rx->data->cttype );
+			const TPtrC8& verCt = TNSmlDbCapsSerializer::SafePtr( rx->data->verct );
+			if ( ctType.Compare( KNullDesC8 ) != 0 && verCt.Compare( KNullDesC8 ) != 0 )
+				{
+				RStringF mimeFormat = aStringPool.OpenFStringL( ctType );
+				RStringF mimeVersion = aStringPool.OpenFStringL( verCt );
+				tempFormat->SetMimeTypeL( mimeFormat );
+				tempFormat->SetMimeVersionL( mimeVersion );
+				mimeFormatArray.AppendL( tempFormat );
+				CleanupStack::Pop(); // tempFormat
+				}
+			else
+				{
+				CleanupStack::PopAndDestroy(); // tempFormat
+				}
+			}
+		}
+	
+	const sml_devinf_ctcaplist_s*  ctCapList = dds->ctcap;
+	if ( ctCapList == 0 )
+		{
+		ctCapList = aDbCaps.CtCaps();
+		}
+	// Then add CTCaps to correct mime types
+	if ( ctCapList != 0 )
+	    {    
+        for (; ctCapList; ctCapList = ctCapList->next )
+    		{
+    		const SmlDevInfCtCapPtr_t ctCap = ctCapList->data;
+    		if ( ctCap->cttype->Data() == KNSmlFolderType )
+    			{
+    			SmlDevInfPropertyListPtr_t dipl = ctCap->property;
+    			for ( ; dipl; dipl = dipl->next )
+    				{
+    				const SmlDevInfPropertyPtr_t dip = dipl->data;
+    				if ( dip )
+    					{
+    					CSmlDataProperty *temppoint = CNSmlDataPropertyFromDbCaps::NewLC( aStringPool, dip );
+    					self->iFolderProperties.AppendL( temppoint );
+    					CleanupStack::Pop(); //  temppoint
+    					}
+    				}
+    			}
+    		else
+    			{
+    			for ( TInt j(0); j < mimeFormatArray.Count(); j++ )
+    			    {
+    			    if ( mimeFormatArray[j]->MimeType().DesC().Compare( ctCap->cttype->Data() ) == 0 )
+    			        {
+    			        // Mime version is only in rx-pref or in rx so it must be copied to new mime format
+    			        CSmlMimeFormat* temppoint = CNSmlMimeFormatFromDbCaps::NewLC( aStringPool, *ctCap );
+    			        RStringF newMimeVersion = aStringPool.OpenFStringL( mimeFormatArray[j]->MimeVersion().DesC() );
+    			        temppoint->SetMimeVersionL( newMimeVersion );
+    			        delete mimeFormatArray[j];
+    			        mimeFormatArray[j] = NULL;
+    			        mimeFormatArray[j] = temppoint;
+    			        CleanupStack::Pop(); //  temppoint
+    			        }
+    			    }
+    			}
+    		}
+	    }
+	self->SetMimeFormatsL( mimeFormatArray );
+	mimeFormatArray.ResetAndDestroy();
+	CleanupStack::PopAndDestroy(); // mimeFormatArray
+	return self;
+	}
+
+// ------------------------------------------------------------------------------------------------
+// TNSmlDbCapsSerializer::TNSmlDbCapsSerializer()
+// C++ constructor
+// ------------------------------------------------------------------------------------------------	
+EXPORT_C TNSmlDbCapsSerializer::TNSmlDbCapsSerializer()
+	{
+	}
+
+// ------------------------------------------------------------------------------------------------
+// TNSmlDbCapsSerializer::InternalizeL( RReadStream& aDataStoreFormatStream )
+// Internalizes from data store stream to dbcaps instance.
+// ------------------------------------------------------------------------------------------------
+EXPORT_C CNSmlDbCaps* TNSmlDbCapsSerializer::InternalizeL( RReadStream& aDataStoreFormatStream ) const
+	{
+	CNSmlDbCaps* dbcaps = CNSmlDbCaps::NewLC();
+	
+	RStringPool pool;
+	pool.OpenL();
+	CleanupClosePushL( pool );
+	const CSmlDataStoreFormat* dsf = CSmlDataStoreFormat::NewLC( pool, aDataStoreFormatStream );
+	SetFromL( *dsf, *dbcaps );
+	
+	CleanupStack::PopAndDestroy( 2 ); //dsf, pool
+	CleanupStack::Pop(); // dbcaps
+	return dbcaps;
+	}
+
+// ------------------------------------------------------------------------------------------------
+// TNSmlDbCapsSerializer::ExternalizeL()
+// externalizes from dbcaps to data store stream
+// ------------------------------------------------------------------------------------------------
+EXPORT_C void TNSmlDbCapsSerializer::ExternalizeL( const CNSmlDbCaps& aDbCaps, RWriteStream& aDataStoreFormatStream ) const
+	{
+	RStringPool pool;
+	pool.OpenL();
+	CleanupClosePushL( pool );
+	CSmlDataStoreFormat* dsf = CNSmlDataStoreFormatFromDbCaps::NewLC( pool, aDbCaps );
+	dsf->ExternalizeL( aDataStoreFormatStream );
+	CleanupStack::PopAndDestroy( 2 ); //dsf, pool
+	}
+
+// ------------------------------------------------------------------------------------------------
+// TNSmlDbCapsSerializer::ExternalizeL()
+// externalizes from dbcaps to data store stream
+// ------------------------------------------------------------------------------------------------
+EXPORT_C void TNSmlDbCapsSerializer::ExternalizeL( const CNSmlDbCaps& aDbCaps, const CArrayFix<TNSmlFilterCapData>& aFilterInfoArr, RWriteStream& aDataStoreFormatStream ) const
+	{
+	RStringPool pool;
+	pool.OpenL();
+	CleanupClosePushL( pool );
+	CSmlDataStoreFormat* dsf = CNSmlDataStoreFormatFromDbCaps::NewLC( pool, aDbCaps );
+	CNSmlFilterCapabilityData* fcd = CNSmlFilterCapabilityData::NewLC();
+	
+	fcd->MakeL( pool, aFilterInfoArr );
+	dsf->SetFilterCapabilitiesL( fcd->iFilterCapabilities );
+	dsf->ExternalizeL( aDataStoreFormatStream );
+	
+	CleanupStack::PopAndDestroy( 3 ); //fcd, dsf, pool
+	}
+
+// ------------------------------------------------------------------------------------------------
+// TNSmlDbCapsSerializer::SafePtr()
+// checks for null before returning data pointer
+// ------------------------------------------------------------------------------------------------	
+TPtrC8 TNSmlDbCapsSerializer::SafePtr( sml_pcdata_s* aPcdata )
+	{
+	if ( aPcdata == NULL )
+		{
+		return TPtrC8( NULL, 0 );
+		}
+	else
+		{
+		return aPcdata->Data();
+		}
+	}
+
+// ------------------------------------------------------------------------------------------------
+// TNSmlDbCapsSerializer::SetFromL( const CSmlDataStoreFormat& aFrom, CNSmlDbCaps& aTo )
+// copies and converts data from aFrom to aTo
+// ------------------------------------------------------------------------------------------------
+void TNSmlDbCapsSerializer::SetFromL( const CSmlDataStoreFormat& aFrom, CNSmlDbCaps& aTo ) const
+	{
+	const TDesC& dispName( aFrom.DisplayName() );
+	HBufC8* dispName8 = NULL;
+	NSmlUnicodeConverter::HBufC8InUTF8LC( dispName, dispName8 );
+	aTo.SetDisplayNameL( *dispName8 ); // display name
+	CleanupStack::PopAndDestroy(); // dispName8
+	
+	//max size
+	_LIT8( KNSmlMaxGuidSize, "8" );
+	aTo.SetMaxGuidSizeL( KNSmlMaxGuidSize );
+	
+	if ( aFrom.IsSupported( CSmlDataStoreFormat::EOptionHasMaxSize ) )
+		{
+		TBuf8<KNSml32BitNumLength> maxSizeDes;
+		maxSizeDes.Num( aFrom.MaxSize() );
+		aTo.SetMaxSizeL( maxSizeDes );
+		}
+	
+	if ( aFrom.IsSupported( CSmlDataStoreFormat::EOptionHasMaxItems ) )
+		{
+		TBuf8<KNSml32BitNumLength> maxItemsDes;
+		maxItemsDes.Num( aFrom.MaxItems() );
+		aTo.SetMaxItemsL( maxItemsDes );
+		}
+	
+	//sync types
+	TSmlSyncTypeMask synctypes( aFrom.SyncTypes() );
+	
+	if ( synctypes.IsSupported( ESmlTwoWay ) )
+		{
+		aTo.SetSyncType( CNSmlDbCaps::ETwoWaySync );
+		}
+	if ( synctypes.IsSupported( ESmlOneWayFromServer ) )
+		{
+		aTo.SetSyncType( CNSmlDbCaps::EOneWaySyncFromServer );
+		}
+	if ( synctypes.IsSupported( ESmlOneWayFromClient ) )
+		{
+		aTo.SetSyncType( CNSmlDbCaps::EOneWaySyncFromClient );
+		}
+	if ( synctypes.IsSupported( ESmlSlowSync ) )
+		{
+		aTo.SetSyncType( CNSmlDbCaps::ESlowTwoWaySync );
+		}
+	if ( synctypes.IsSupported( ESmlRefreshFromServer ) )
+		{
+		aTo.SetSyncType( CNSmlDbCaps::ERefreshSyncFromServer );
+		}
+	if ( synctypes.IsSupported( ESmlRefreshFromClient ) )
+		{
+		aTo.SetSyncType( CNSmlDbCaps::ERefreshSyncFromClient );
+		}
+	
+	//options
+	if ( aFrom.IsSupported( CSmlDataStoreFormat::EOptionHierarchial ) )
+		{
+		aTo.SetSupportHierarchicalSyncL();
+		}		
+	
+	//CNSmlCtCap / CSmlMimeFormat
+	TInt rxPref( aFrom.MimeFormatRxPref() );
+	TInt txPref( aFrom.MimeFormatTxPref() );
+	
+	for( TInt i = 0; i < aFrom.MimeFormatCount(); i++ )
+		{
+		const CSmlMimeFormat& mf = aFrom.MimeFormat( i );
+		CNSmlCtCap* ctcap = aTo.AddCtCapLC();
+		SetFromL( mf, *ctcap );
+		CleanupStack::PopAndDestroy(); // ctcap
+		
+		const TDesC8& ctType = mf.MimeType().DesC();
+		const TDesC8& verCt = mf.MimeVersion().DesC();
+		
+		if ( i == rxPref && i == txPref )
+			{
+			aTo.SetRxPrefL( ctType, verCt );
+			aTo.SetTxPrefL( ctType, verCt );
+			}
+		else if ( i == txPref )
+			{
+			aTo.SetTxPrefL( ctType, verCt );
+			aTo.AddRxL( ctType, verCt );
+			}
+		else if ( i == rxPref )
+			{
+			aTo.SetRxPrefL( ctType, verCt );
+			aTo.AddTxL( ctType, verCt );
+			}
+		else
+			{
+			aTo.AddRxL( ctType, verCt );
+			aTo.AddTxL( ctType, verCt );
+			}
+		}
+	
+	// CNSmlCtCap / CSmlDataProperty
+	// folder properties
+	if ( aFrom.FolderPropertyCount() > 0 )
+		{
+		aTo.AddRxL( KNSmlFolderType, KNSmlFolderVersion );
+		aTo.AddTxL( KNSmlFolderType, KNSmlFolderVersion );
+			
+		CNSmlCtCap* ctcap = aTo.AddCtCapLC();
+		ctcap->SetCtTypeL( KNSmlFolderType );
+		ctcap->SetVerCtL( KNSmlFolderVersion );
+		
+		for( TInt i = 0; i < aFrom.FolderPropertyCount(); i++ )
+			{
+			const CSmlDataProperty& fp = aFrom.FolderProperty( i );
+			
+			CNSmlDevInfProp* dip = ctcap->AddDevInfPropLC( fp.Field().Name().DesC() );
+			SetFromL( fp, *dip );
+			CleanupStack::PopAndDestroy(); // dip
+			}
+		CleanupStack::PopAndDestroy(); // ctcap
+		}
+	
+	// CNSmlFilterCap / CSmlFilterCapability
+	for( TInt i = 0; i < aFrom.FilterCapabilityCount(); i++ )
+		{
+		const CSmlFilterCapability& fc = aFrom.FilterCapability( i );
+		const TDesC8& ctType = fc.MimeType().DesC();
+		const TDesC8& verCt = fc.MimeVersion().DesC();
+		CNSmlFilterCap* fcSet = aTo.AddFilterCapLC( ctType, verCt );
+		SetFromL( fc, *fcSet );
+		CleanupStack::PopAndDestroy(); // fcSet
+		
+		aTo.AddFilterRxL( ctType, verCt );
+		}	
+	}
+	
+// ------------------------------------------------------------------------------------------------
+// TNSmlDbCapsSerializer::SetFromL( const CSmlDataPropertyParam& aFrom, CNSmlPropParam& aTo )
+// copies and converts data from aFrom to aTo
+// ------------------------------------------------------------------------------------------------
+void TNSmlDbCapsSerializer::SetFromL( const CSmlDataPropertyParam& aFrom, CNSmlPropParam& aTo ) const
+	{
+	const CSmlDataField& field = aFrom.Field();
+	
+	const TDesC& dispName( field.DisplayName() );
+	HBufC8* dispName8 = NULL;
+	NSmlUnicodeConverter::HBufC8InUTF8LC( dispName, dispName8 );
+	aTo.SetDisplayNameL( *dispName8 ); // display name
+	CleanupStack::PopAndDestroy(); // dispName8
+	
+	//data type
+	aTo.SetDataTypeL( field.DataType().DesC() );
+	
+	//enum values
+	for ( TInt i(0); i < field.EnumValueCount(); i++ )
+		{
+		aTo.AddValEnumL( field.EnumValue( i ).DesC() );
+		}
+	}
+
+// ------------------------------------------------------------------------------------------------
+// TNSmlDbCapsSerializer::SetFromL( const CSmlDataProperty& aFrom, CNSmlDevInfProp& aTo )
+// copies and converts data from aFrom to aTo
+// ------------------------------------------------------------------------------------------------
+EXPORT_C void TNSmlDbCapsSerializer::SetFromL( const CSmlDataProperty& aFrom, CNSmlDevInfProp& aTo ) const
+	{
+	const CSmlDataField& field = aFrom.Field();
+	TBuf8<KNSml32BitNumLength> tdes;
+	
+	//max occur
+	if ( aFrom.MaxOccur() != 0 )
+		{
+		tdes.Num( aFrom.MaxOccur() );
+		aTo.SetMaxOccurL( tdes );
+		}
+	
+	//max size
+	if ( aFrom.MaxSize() != 0 )
+		{
+		tdes.Num( aFrom.MaxSize() );
+		aTo.SetMaxSizeL( tdes );
+		}
+	
+	//display name
+	const TDesC& dispName( field.DisplayName() );
+	HBufC8* dispName8 = NULL;
+	NSmlUnicodeConverter::HBufC8InUTF8LC( dispName, dispName8 );
+	aTo.SetDisplayNameL( *dispName8 ); // display name
+	CleanupStack::PopAndDestroy(); // dispName8
+	
+	//data type
+	aTo.SetDataTypeL( field.DataType().DesC() );
+	
+	//options
+	if ( aFrom.IsSupported( CSmlDataProperty::EOptionNoTruncate ) )
+		{
+		aTo.SetNoTruncateL();		
+		}
+	
+	//param values
+	for ( TInt i(0) ; i < aFrom.ParamCount(); i++ )
+		{
+		const CSmlDataPropertyParam& dpp = aFrom.Param(i);
+		CNSmlPropParam* pp = aTo.AddParamLC( dpp.Field().Name().DesC() );
+		SetFromL( dpp, *pp );
+		CleanupStack::PopAndDestroy(); // pp
+		}
+		
+	//enum values
+	for ( TInt i(0) ; i < field.EnumValueCount(); i++ )
+		{
+		aTo.AddValEnumL( field.EnumValue( i ).DesC() );
+		}
+	}
+
+// ------------------------------------------------------------------------------------------------
+// TNSmlDbCapsSerializer::SetFromL( const CSmlMimeFormat& aFrom, CNSmlCtCap& aTo )
+// copies and converts data from aFrom to aTo
+// ------------------------------------------------------------------------------------------------
+void TNSmlDbCapsSerializer::SetFromL( const CSmlMimeFormat& aFrom, CNSmlCtCap& aTo ) const
+	{
+	//mime type
+	aTo.SetCtTypeL( aFrom.MimeType().DesC() );
+	
+	//mime version
+	aTo.SetVerCtL( aFrom.MimeVersion().DesC() );
+	
+	//field level
+	if ( aFrom.FieldLevel() )
+		{
+		aTo.SetFieldLevelL();
+		}
+		
+	//properties
+	for ( TInt i(0);i < aFrom.PropertyCount(); i++ )
+		{
+		const CSmlDataProperty& dp = aFrom.Property( i );
+		CNSmlDevInfProp* dip = aTo.AddDevInfPropLC( dp.Field().Name().DesC() );
+		SetFromL( dp, *dip );
+		CleanupStack::PopAndDestroy(); // dip
+		}
+	}
+// ------------------------------------------------------------------------------------------------
+// TNSmlDbCapsSerializer::SetFromL( const CSmlFilterCapability& aFrom, CNSmlFilterCap& aTo )
+// copies and converts data from aFrom to aTo
+// ------------------------------------------------------------------------------------------------
+void TNSmlDbCapsSerializer::SetFromL( const CSmlFilterCapability& aFrom, CNSmlFilterCap& aTo ) const
+	{
+	//keywords
+	for ( TInt i = 0; i < aFrom.KeywordCount(); i++ )
+		{
+		aTo.AddFilterKeywordL( aFrom.Keyword(i).DesC() );
+		}
+	
+	//properties
+	for ( TInt i = 0; i < aFrom.PropertyCount(); i++ )
+		{
+		aTo.AddPropNameL( aFrom.PropertyName(i).DesC() );
+		}
+	}
+	
+// End of File