--- /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