diff -r 000000000000 -r b497e44ab2fc syncmlfw/ds/dsutils/dbcaps/src/NSmldbcapsSerializer.cpp --- /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 +#include + +#include +#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& 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 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& 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 maxSizeDes; + maxSizeDes.Num( aFrom.MaxSize() ); + aTo.SetMaxSizeL( maxSizeDes ); + } + + if ( aFrom.IsSupported( CSmlDataStoreFormat::EOptionHasMaxItems ) ) + { + TBuf8 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 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