void ut_remotepartyinfo::TestInternalizeExternalizeEmptyInfoL() { HBufC8* data = HBufC8::NewLC( 1024 ); TPtr8 ptr = data->Des(); RDesWriteStream stream( ptr ); ExternalizeL( stream, *iInfo ); CCallRemotePartyInfo* info = CCallRemotePartyInfo::NewLC(); RDesReadStream readStream( ptr ); InternalizeL( readStream, *info ); EUNIT_ASSERT( iInfo->MatchedName().Length() == 0 ); EUNIT_ASSERT( iInfo->NameFromNetwork().Length() == 0 ); EUNIT_ASSERT( iInfo->CompanyName().Length() == 0 ); EUNIT_ASSERT( iInfo->Address().Length() == 0 ); EUNIT_ASSERT( iInfo->CallIndex() == -1 ); EUNIT_ASSERT( iInfo->RemoteIdentity() == MCallRemotePartyInfo::ERemoteIdentityUnknown ); EUNIT_ASSERT( iInfo->SATCall() == EFalse ); CleanupStack::PopAndDestroy( info ); CleanupStack::PopAndDestroy( data ); }
/** * Internalize (non-leaving) the contents of the Alarm Server backup * from the backup file. */ TInt CASSrvAlarmStore::Internalize(CASSrvAlarmQueue::TStoreOperation aInternalizeOperation) { TInt error = KErrNone; DEBUG_PRINT1(_L("> Alarm Store Internalize ()")); // tell Alarm Queue what type of Internalize to perform error = ServerWideData().Queue().StartAlarmStoreOperation(aInternalizeOperation); if (!error) { // don't watch for change notifications during Internalize iFlags.Set(EIsInternalizing); TRAP(error, InternalizeL()); // tell alarm queue that Internalize is complete ServerWideData().Queue().EndAlarmStoreOperation(error); // Finished Internalize, Look for notifications again, etc... iFlags.Clear(EIsInternalizing); } DEBUG_PRINT2(_L("< Alarm Store Internalize - error %i"), error); return error; }
void ut_remotepartyinfo::TestInternalizeExternalizeInfoL() { _LIT( KMatchedName, "Mr Smith" ); _LIT( KNameFromNetwork, "John Smith" ); _LIT( KCompanyName, "Nokia" ); _LIT( KAddress, "555555" ); iInfo->SetMatchedNameL( KMatchedName ); iInfo->SetNameFromNetworkL(KNameFromNetwork); iInfo->SetCompanyNameL(KCompanyName); iInfo->SetAddressL( KAddress ); iInfo->SetCallIndex( 2 ); iInfo->SetRemoteIdentity( MCallRemotePartyInfo::ERemoteIdentityAvailable ); iInfo->SetSATCall( ETrue ); HBufC8* data = HBufC8::NewLC( 1024 ); TPtr8 ptr = data->Des(); RDesWriteStream stream( ptr ); ExternalizeL( stream, *iInfo ); CCallRemotePartyInfo* info = CCallRemotePartyInfo::NewLC(); RDesReadStream readStream( ptr ); InternalizeL( readStream, *info ); EUNIT_ASSERT( info->MatchedName().Match( KMatchedName ) == KErrNone ); EUNIT_ASSERT( info->NameFromNetwork().Match( KNameFromNetwork ) == KErrNone ); EUNIT_ASSERT( info->CompanyName().Match( KCompanyName ) == KErrNone ); EUNIT_ASSERT( info->Address().Match( KAddress ) == KErrNone ); EUNIT_ASSERT( info->CallIndex() == 2 ); EUNIT_ASSERT( iInfo->RemoteIdentity() == MCallRemotePartyInfo::ERemoteIdentityAvailable ); EUNIT_ASSERT( iInfo->SATCall() == ETrue ); CleanupStack::PopAndDestroy( 2, data ); // info, data }
void THighscoreHolder::RestoreL(const CStreamStore& aStore, TStreamId aStreamId) { RStoreReadStream stream; stream.OpenLC(aStore, aStreamId); InternalizeL(stream); CleanupStack::PopAndDestroy(); }
EXPORT_C void CImSSmtpSettings::RestoreL( CMsvStore& aMessageStore ) { RMsvReadStream in; in.OpenLC( aMessageStore, KUidMsvServiceEntry ); // pushes 'in' to the stack InternalizeL(in); CleanupStack::PopAndDestroy(); }
void CRTPermGrantMessage::ConstructL(const TDesC8& aBuf) { RDesReadStream stream(aBuf); CleanupClosePushL (stream); InternalizeL (stream); CleanupStack::PopAndDestroy (&stream); }
void CCFContextSubscriptionImpl::ConstructL( RReadStream& aStream ) { FUNC_LOG; ConstructL(); InternalizeL( aStream ); }
void CCompound::RestoreL() { RStoreReadStream stream; stream.OpenLC(iStore,iId); InternalizeL(stream); CleanupStack::PopAndDestroy(); }
void CCompound::RestoreL(CStreamStore& aStore,TStreamId anId) { RStoreReadStream instream; instream.OpenLC(aStore,anId); InternalizeL(instream); // Cleanup the stream object. CleanupStack::PopAndDestroy(); }
/** Restores the object to the specified message store. The function can leave with the standard stream leave codes. @param aStore Store to which to write */ EXPORT_C void TImEmailTransformingInfo::RestoreL( CMsvStore& aStore ) { RMsvReadStream in; in.OpenLC( aStore, KUidMsgFileTransformingInfo ); // pushes 'in' to the stack InternalizeL(in); in.Close();// make sure we close the stream CleanupStack::PopAndDestroy(); }
// ----------------------------------------------------------------------------- // CWPPushMessage::RestoreL // ----------------------------------------------------------------------------- // EXPORT_C void CWPPushMessage::RestoreL( CMsvStore& aStore ) { RMsvReadStream stream; stream.OpenLC( aStore, TUid::Uid( KProvisioningMessageStreamUid ) ); InternalizeL( stream ); CleanupStack::PopAndDestroy(); // stream ParseHeaderL(); }
EXPORT_C void CImOffLineArrayStore::RestoreL(const CMsvStore& aMessageStore ) { if (aMessageStore.IsPresentL(KUidImQueuedOperationList)) { RMsvReadStream in; in.OpenLC( aMessageStore, KUidImQueuedOperationList ); // pushes 'in' to the stack InternalizeL(in); CleanupStack::PopAndDestroy(); } }
void CNcdNodeContentInfoProxy::ConstructL() { DLTRACEIN(("")); // Register the interface MNcdNodeContentInfo* interface( this ); AddInterfaceL( CCatalogsInterfaceIdentifier::NewL( interface, this, MNcdNodeContentInfo::KInterfaceUid ) ); InternalizeL(); }
void CNcdNodeFolderProxy::OperationComplete( MNcdLoadNodeOperation& /*aOperation*/, TInt aError ) { DLTRACEIN(( "Error: %d", aError )); if ( aError == KErrNone || aError == KNcdErrorSomeCatalogsFailedToLoad ) { // update proxy's status from the server TRAP_IGNORE( InternalizeL() ); } }
// ---------------------------------------------------------------------------- // Helper funciton to create descriptor array from buffer // ---------------------------------------------------------------------------- // EXPORT_C void MPXUser::CreateFromBufferL( const CBufBase &aBuf, CDesCArray*& aArray) { delete aArray; aArray = NULL; RBufReadStream rs(aBuf); CleanupClosePushL(rs); InternalizeL(aArray, rs); CleanupStack::PopAndDestroy(&rs); }
void CNcdRootNodeProxy::OperationComplete( MNcdLoadNodeOperation& /*aOperation*/, TInt aError ) { DLTRACEIN(("")); // Should all the error code checks be removed and always internalize root node? if( aError == KErrNone || aError == KNcdErrorSomeCatalogsFailedToLoad || aError == KErrCancel ) { // Because operation went ok. Update the node data. TRAP_IGNORE( InternalizeL() ); } DLTRACEOUT(("")); }
void CNcdNodeProxy::ConstructL( ) { DLTRACEIN(("this-ptr as MNcdNode: %X", static_cast<MNcdNode*>( this ))); // Register the interfaces of this object MNcdNode* node( this ); AddInterfaceL( CCatalogsInterfaceIdentifier::NewL( node, this, MNcdNode::KInterfaceUid ) ); // Make sure that at least some values are inserted to the link descriptors. // So, the references returned from functions of this class will contain at // least something. iTimestamp = KNullDesC().AllocL(); iCatalogSourceName = KNullDesC().AllocL(); iExpiredTime = 0; // Get the data from the server side. // It may be possible that actually not much is received // because the node may be in uninitialized state. // But at least the namespace and id information should be gotten. TRAPD( trapError, InternalizeL() ); // This node can not exist if the identifier data is not set. // So, if node identifier is not set this should leave and // prevent the creation of the node. if ( iNodeIdentifier == NULL ) { User::LeaveIfError( trapError ); } // Also make sure that parent identifier is set at least to empty value if ( iParentIdentifier == NULL ) { // If we have to set the parent identifier here, it means that // the node link was not set yet. // If node link was set, then the parent id was also set to correct value. // And, then this value should not be set here. iParentIdentifier = CNcdNodeIdentifier::NewL(); } if ( iRealParentIdentifier == NULL ) { iRealParentIdentifier = CNcdNodeIdentifier::NewL(); } DLTRACEOUT(("")); }
EXPORT_C void CHeaderFooter::RestoreL(const CStreamStore& aStore,TStreamId aStreamId,MPictureFactory* aFactory) /** Restores this object and all associated components from a stream store. Components include fields and pictures. @param aStore Stream store from which to restore the CHeaderFooter. @param aStreamId ID of the stream containing the external representation of the CHeaderFooter object. @param aFactory Picture factory. Must be supplied if the header or footer contains pictures which should be restored. */ { // retrieve the headstream from the store RStoreReadStream stream; stream.OpenLC(aStore,aStreamId); // internalize the headstream, then fetch the components from their own streams InternalizeL(stream); CleanupStack::PopAndDestroy(); // stream RestoreComponentsL(aStore,aFactory); }
// ----------------------------------------------------------------------------- // CDRMHelperServer::RestoreL(). // This function restore internal list from data file // ----------------------------------------------------------------------------- // void CDRMHelperServer::RestoreL() { #ifdef _DRM_TESTING WriteL(_L8("RestoreL")); #endif TInt err = 0; RFileReadStream file; RFile test; err = test.Open( iFs , DataFileL(iFs).FullName() , EFileRead ); if ( !err ) { CleanupClosePushL(test); TInt size = 0; err = test.Size(size); User::LeaveIfError(err); CleanupStack::PopAndDestroy(&test); //test if (size == 0) { StoreL(); } } else if ( err == KErrNotFound ) { StoreL(); } else { User::Leave(err); } User::LeaveIfError(file.Open( iFs , DataFileL(iFs).FullName() , EFileRead )); file.PushL(); InternalizeL(file); CleanupStack::PopAndDestroy(&file); //file #ifdef _DRM_TESTING WriteL(_L8("RestoreL->End")); #endif }
// ----------------------------------------------------------------------------- // CIAUpdateBGFirstTimeHandler::ReadDataL // // ----------------------------------------------------------------------------- // void CIAUpdateBGFirstTimeHandler::ReadDataL() { RFile file; TInt err = file.Open( iFsSession, iPath, EFileRead|EFileShareAny ); if ( err == KErrNotFound ) { iAgreementAccepted = EFalse; iAutomaticUpdateChecksAsked = EFalse; } else { User::LeaveIfError( err ); CleanupClosePushL( file ); RFileReadStream stream( file, 0 ); CleanupClosePushL( stream ); InternalizeL( stream ); CleanupStack::PopAndDestroy( &stream ); CleanupStack::PopAndDestroy( &file ); } }
// --------------------------------------------------------------------------- // Sets display bqckground items // --------------------------------------------------------------------------- // void CAlfSrvDisplaySubSession::SetBackgroundItemsL( const RMessage2& aMessage ) { CAlfAppSrvSession& session = static_cast<CAlfAppSrvSession&>(Session()); // Parse parameters HBufC8* buffer = HBufC8::NewLC(aMessage.GetDesLength(1)); TPtr8 ptr = buffer->Des(); aMessage.Read(1, ptr); RArray<TAlfDisplayBackgroundItem> array; CleanupClosePushL( array ); InternalizeL(*buffer, array); // Store value for this client iBackgroundItems.Reset(); for(TInt i = 0; i < array.Count(); ++i) { TAlfDisplayBackgroundItem alfItem = array[i]; THuiDisplayBackgroundItem* huiItem = (THuiDisplayBackgroundItem*)&alfItem; iBackgroundItems.Append(*huiItem); } CleanupStack::PopAndDestroy( &array ); // Reset full background to none iDisplayClearBackground = CHuiDisplay::EClearNone; // Update value if the client is on focus if ( session.IsFocused() ) { // Set use background items Display().SetBackgroundItemsL(iBackgroundItems); } CleanupStack::PopAndDestroy( buffer ); // Complete aMessage.Complete( KErrNone ); }
// ----------------------------------------------------------------------------- // CIAUpdatePendingNodesFile::ReadDataL // // ----------------------------------------------------------------------------- // EXPORT_C TBool CIAUpdatePendingNodesFile::ReadDataL() { IAUPDATE_TRACE("[IAUPDATE] CIAUpdatePendingNodesFile::ReadDataL begin"); RFile file; TInt err( file.Open( iFsSession, iPath, EFileRead ) ); User::LeaveIfError( err ); CleanupClosePushL( file ); RFileReadStream stream( file, 0 ); CleanupClosePushL( stream ); InternalizeL( stream ); CleanupStack::PopAndDestroy( &stream ); CleanupStack::PopAndDestroy( &file ); IAUPDATE_TRACE("[IAUPDATE] CIAUpdatePendingNodesFile::ReadDataL end"); return ETrue; }
EXPORT_C void CPrintSetup::RestoreL(const CStreamStore& aStore,TStreamId aStreamId,const MFieldFileNameInfo* aFileNameInfo,const MFieldNumPagesInfo* aNumPagesInfo,MPictureFactory* aFactory) /** Restores a CPrintSetup object, including its components from a stream store. @param aStore Store from which to restore the CPrintSetup object @param aStreamId ID of the stream containing the external representation of the CPrintSetup object @param aFileNameInfo An optional object implementing the MFieldFileNameInfo interface. This provides the file name for insertion into a field in the header or footer. @param aNumPagesInfo An optional object implementing the MFieldNumPagesInfo interface. This provides the total number of pages for insertion into a field in the header or footer. @param aFactory Picture factory. Must be supplied if the header or footer contains pictures which should be restored. */ { // retrieve the headstream from the store RStoreReadStream stream; stream.OpenLC(aStore,aStreamId); // internalize the headstream, then fetch the components from their own streams InternalizeL(stream); CleanupStack::PopAndDestroy(); // stream RestoreComponentsL(aStore,aFileNameInfo,aNumPagesInfo,aFactory); }
// ----------------------------------------------------------------------------- // CIAUpdateBGControllerFile::ReadControllerDataL // // ----------------------------------------------------------------------------- // TBool CIAUpdateBGControllerFile::ReadControllerDataL() { RFile file; TInt err = file.Open( iFsSession, iPath, EFileRead ); if ( err == KErrNotFound ) { // File did not exist. // So, nothing to do here anymore. return EFalse; } User::LeaveIfError( err ); CleanupClosePushL( file ); RFileReadStream stream( file, 0 ); CleanupClosePushL( stream ); InternalizeL( stream ); CleanupStack::PopAndDestroy( &stream ); CleanupStack::PopAndDestroy( &file ); return ETrue; }
/** Constructs the object through read stream. @param aReadStream A read stream containing BIC data */ void CCmdPersistHalAttributes::ConstructL(RReadStream& aReadStream) { InternalizeL(aReadStream); }
//-------------------------------------------------------------------- //-------------------------------------------------------------------- // void CPosLmNameIndex::LoadL() { // Skip index loading for empty databases TInt numLandmarks = PosLmServerUtility::TotalLandmarkCountL( iDbAccess ); if ( numLandmarks == 0 ) { iTimeStamp.UniversalTime(); iStatus = KErrNone; return; } RDbTable table; TInt err = table.Open( iDatabase, KPosLmIndexTable, RDbRowSet::EReadOnly ); if ( err ) { LOG("NameIndex::LoadL: index table not found"); User::Leave( err ); } CleanupClosePushL( table ); table.FirstL(); if ( table.AtEnd() ) { LOG("NameIndex::LoadL: index not found"); User::Leave( KErrNotFound ); } table.GetL(); // verify that index is valid for current language if ( !table.IsColNull( EPosLmIncLanguageCol ) ) { TLanguage lang = (TLanguage) table.ColInt32( EPosLmIncLanguageCol ); if ( User::Language() != lang ) { LOG2("NameIndex::LoadL: index not valid, lang %d, current lang %d", lang, User::Language() ); User::Leave( KErrCorrupt ); } } else { LOG("NameIndex::LoadL: index lang not found"); User::Leave( KErrCorrupt ); } // read the index if ( !table.IsColNull( EPosLmIncIndexDataCol ) ) { RDbColReadStream readStream; readStream.OpenL( table, EPosLmIncIndexDataCol ); CleanupClosePushL( readStream ); InternalizeL( readStream ); CleanupStack::PopAndDestroy( &readStream ); // basic check for the index if ( Count() != numLandmarks ) { LOG2("NameIndex::LoadL: index not valid, count %d, landmarks in db %d", Count(), numLandmarks ); User::Leave( KErrCorrupt ); } } else { LOG("NameIndex::LoadL: index data not found"); User::Leave( KErrCorrupt ); } // read the time stamp iTimeStamp.UniversalTime(); if ( !table.IsColNull( EPosLmIncTimestampCol ) ) { iTimeStamp = table.ColTime( EPosLmIncTimestampCol ); } else { LOG("NameIndex::LoadL: index timestamp not found"); User::Leave( KErrCorrupt ); } CleanupStack::PopAndDestroy ( &table ); // index is valid iStatus = KErrNone; }
void CCellTowerDataSimulation::ConstructL() { iTimer = CCustomTimer::NewL(this); InternalizeL(); }
/** Constructs the object through read stream. @param aReadStream A read stream containing BIC data */ void CCmdPublishSwp::ConstructL(RReadStream& aReadStream) { InternalizeL(aReadStream); ValidateL(); }
// --------------------------------------------------------------------------- // CSearchKeysEventImp::ConstructL() // --------------------------------------------------------------------------- // void CSearchKeysEventImp::ConstructL( RReadStream& aStream ) { iInfoArray = new ( ELeave) RSearchKeyInfoImpArray; InternalizeL( aStream ); }
// ----------------------------------------------------------------------------- // CHttpCacheEntry::Internalize // // ----------------------------------------------------------------------------- // TInt CHttpCacheEntry::Internalize( RReadStream& aReadStream, const TDesC& aDirectory ) { TRAPD( err, InternalizeL( aReadStream, aDirectory ) ); return err; }