// --------------------------------------------------------------------------- // CAccPolAudioControlBase::ExternalizeAudioControlbaseL() // --------------------------------------------------------------------------- // EXPORT_C void CAccPolAudioControlBase::ExternalizeAudioControlbaseL( RWriteStream& aStream ) const { API_TRACE_( "[AccFW:ACCPOLAUDIODEVICETOPOLOGY] CAccPolAudioControlBase::ExternalizeAudioControlbaseL() - Enter" ); aStream.WriteUint8L( iUnitId ); aStream.WriteUint16L( iChannel ); API_TRACE_1( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolAudioControlBase::ExternalizeAudioControlbaseL() - Unit Id=%d", iUnitId ); API_TRACE_1( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolAudioControlBase::ExternalizeAudioControlbaseL() - Channel number=%d", iChannel ); API_TRACE_( "[AccFW:ACCPOLAUDIODEVICETOPOLOGY] CAccPolAudioControlBase::ExternalizeAudioControlbaseL - Return" ); }
EXPORT_C void CATBase::ExternalizeL(RWriteStream& aStream) const { aStream << iText; aStream.WriteInt32L(KStreamVersion1); aStream.WriteInt32L(iId); aStream.WriteInt32L(iType); TInt count = iParamList.Count(); aStream.WriteInt32L(count); for (TInt i = 0; i < count; i++) { aStream << iParamList[i]; } }
// ----------------------------------------------------------------------------- // CSIPRequestElements::ExternalizeL // ----------------------------------------------------------------------------- // void CSIPRequestElements::ExternalizeL(RWriteStream& aWriteStream) const { TPtrC8 method(iMethod.DesC()); // For outgoing requests in some cases the method is filled in ServerCore if (method.Length() > 0) { aWriteStream.WriteUint32L(method.Length()); aWriteStream.WriteL(method); } aWriteStream.WriteUint8L(1); // remote-URI always present iRemoteURI->ExternalizeL(aWriteStream); iMessageElements->ExternalizeL(aWriteStream); }
// --------------------------------------------------------------------------- // CXIMPContextStateEventImp::ExternalizeL() // --------------------------------------------------------------------------- // void CXIMPContextStateEventImp::ExternalizeL( RWriteStream& aStream ) const { iState->ExternalizeL( aStream ); if( iStateChangeReason ) { aStream.WriteInt8L( EHasStatusObject ); iStateChangeReason->ExternalizeL( aStream ); } else { aStream.WriteInt8L( ENoStatusObject ); } }
//----------------------------------------------------------------------------- // CCFActionIndicationImpl::ExternalizeL //----------------------------------------------------------------------------- // EXPORT_C void CCFActionIndicationImpl::ExternalizeL( RWriteStream& aStream ) { FUNC_LOG; // Identifier aStream.WriteInt16L( iIdentifier->Length() ); aStream.WriteL( *iIdentifier ); // Parameters TPtrC buf( KNullDesC ); TInt count = iParameters.Count(); aStream.WriteInt16L( count ); for( TInt i = 0; i < count; i++ ) { // Key length and data buf.Set( iParameters[i]->Key() ); aStream.WriteInt16L( buf.Length() ); aStream.WriteL( buf, buf.Length() ); // Value length and data buf.Set( iParameters[i]->Value() ); aStream.WriteInt16L( buf.Length() ); aStream.WriteL( buf, buf.Length() ); } // Commit stream aStream.CommitL(); }
//Testing RWriteStream performance. void StreamWriteTestL(RWriteStream& aStream, TUint32& aWriteFc, TUint32& aCommitFc) { TUint32 fc = User::FastCounter(); for(TInt i=0;i<KIterCnt;++i) { aStream.WriteL(KTestDes); } TUint32 fc2 = User::FastCounter(); aStream.CommitL(); TUint32 fc3 = User::FastCounter(); aWriteFc = CalcTickDiff(fc, fc2); aCommitFc = CalcTickDiff(fc2, fc3); }
// ----------------------------------------------------------------------------- // CWPPushMessage::ExternalizeL // ----------------------------------------------------------------------------- // EXPORT_C void CWPPushMessage::ExternalizeL( RWriteStream& aStream ) const { // Save version aStream.WriteInt32L( KProvisioningMsgVersion ); // Save the header aStream.WriteInt32L( iHeader->Response().Length() ); aStream << iHeader->Response(); aStream.WriteInt8L( iAuthenticated ); aStream.WriteInt8L( iSaved ); // Save the body aStream.WriteInt32L( iBody->Length() ); aStream << *iBody; // The sender if( iOriginator ) { aStream.WriteInt32L( iOriginator->Length() ); aStream << *iOriginator; } else { aStream.WriteInt32L( KNullDesC8().Length() ); } aStream.CommitL(); }
// ----------------------------------------------------------------------------- // CSdpRepeatField::EncodeL // Writes attributes in proper format to the stream // ----------------------------------------------------------------------------- // EXPORT_C void CSdpRepeatField::EncodeL(RWriteStream& aStream) const { const TDesC8& repeatName = iPool.StringF(SdpCodecStringConstants::ERepeat, SdpCodecStringConstants::Table).DesC(); aStream.WriteL(repeatName); iRepeatInterval.EncodeL(aStream); aStream.WriteL(KSPStr); iActiveDuration.EncodeL(aStream); for (TInt i = 0; i < iTimeOffsets.Count(); i++) { aStream.WriteL(KSPStr); (iTimeOffsets)[i].EncodeL(aStream); } aStream.WriteL(KCRLFStr); }
// --------------------------------------------------------------------------- // SdpUtil::EncodeBufferL // Encodes headername and a value to the stream // --------------------------------------------------------------------------- // void SdpUtil::EncodeBufferL( const TDesC8& aValue, TInt aIndex, RWriteStream& aStream ) { if( aValue.Length() != 0 ) { RStringPool pool = SdpCodecStringPool::StringPoolL(); RStringF headername = pool.StringF( aIndex, SdpCodecStringPool::StringTableL() ); aStream.WriteL( headername.DesC() ); aStream.WriteL( aValue ); aStream.WriteL( KCRLFStr ); } }
// --------------------------------------------------------------------------- // CCmStoreListItem::ExternalizeL // --------------------------------------------------------------------------- // EXPORT_C void CCmStoreListItem::ExternalizeL( RWriteStream& aStream ) const { aStream.WriteUint16L( iListId ); aStream.WriteUint16L( iDeviceIds.Count() ); for( TInt i = 0; i < iDeviceIds.Count(); i++ ) { aStream.WriteInt16L( iDeviceIds[i] ); } aStream.WriteInt16L( iStatusValues.Count() ); for( TInt i = 0; i < iStatusValues.Count(); i++ ) { aStream.WriteInt16L( iStatusValues[i] ); } CCmBaseListItem::ExternalizeL(aStream); }
void THighscoreHolder::ExternalizeL(RWriteStream& aStream) const { for ( TInt i = 0 ; i < iNumberOfItems ; i++ ) { aStream.WriteInt32L(iPointArray[i]); } }
// --------------------------------------------------------------------------- // // --------------------------------------------------------------------------- // void CRequestManager::ExternalizeL(RWriteStream& aStream) const { FLOG(_L("[IMAGEPRINTUI]<<< CEventManager;ExternalizeL ")); aStream << iVendorName; aStream << iProductName; aStream.CommitL(); }
/** A helper function, used in "RWriteStream& operator<<(RWriteStream& aStream,const CDbStrings& aStrings)". @internalComponent */ GLDEF_C void ExternalizeL(const CDbStrings& aStrings,RWriteStream& aStream) { TInt cc=aStrings.Count(); aStream.WriteInt32L(cc); for (TInt ii=0;ii<cc;++ii) aStream<<aStrings[ii]; }
GLDEF_C void ExternalizeL(const CDbColSet& aColSet,RWriteStream& aStream) { TInt cc=aColSet.Count(); aStream.WriteInt32L(cc); for (TInt ii=0;++ii<=cc;) aStream<<aColSet[ii]; }
EXPORT_C void CXzePicture::ExternalizeL(RWriteStream& aStream)const // Save this picture. // Typically called from the base class StoreL(); // { aStream.WriteUint32L(iLabel); }
// ----------------------------------------------------------------------------- // CPhCltEmergencyTelNumber::ExternalizeL // // ----------------------------------------------------------------------------- // EXPORT_C void CPhCltEmergencyTelNumber::ExternalizeL( RWriteStream& aStream ) const { aStream << *iTelNumber; aStream.WriteUint16L( iFieldMCC ); aStream.WriteUint16L( iFieldMNC ); }
// ----------------------------------------------------------------------------- // TSnapshotItem::ExternalizeL // Writes the contents of this class and it's base to stream // ----------------------------------------------------------------------------- void TSnapshotItem::ExternalizeL( RWriteStream& aStream ) const { TNSmlSnapshotItem::ExternalizeL( aStream ); aStream.WriteInt32L( iUnread ); TPckgBuf<TFolderName> nameBuf(iFolderName); aStream << nameBuf; }
void CIntent::ExternalizeL(RWriteStream& aStream) const { aStream.WriteInt32L(static_cast<TInt>(iIntent)); // number of criteria aStream.WriteInt32L(iCriteria.Count()); for(TInt i = 0; i < iCriteria.Count(); i++) { // Write criteria type aStream.WriteInt32L(static_cast<TInt>(iCriteria[i]->Type())); // write criteria object iCriteria[i]->ExternalizeL(aStream); } }
// ----------------------------------------------------------------------------- // CDRMXOma::WriteInt64L // ----------------------------------------------------------------------------- // void CDRMXOma::WriteInt64L( const TInt64& aWrite, RWriteStream& aStream ) const { TPtr8 output( reinterpret_cast<TUint8*>(const_cast<TInt64*>(&aWrite)), sizeof(TInt64), sizeof(TInt64) ); aStream.WriteL( output, sizeof(TInt64) ); }
// ----------------------------------------------------------------------------- // CSIPMessage::ExternalizeHeadersL // ----------------------------------------------------------------------------- // EXPORT_C void CSIPMessage::ExternalizeHeadersL (RWriteStream& aWriteStream) { const RPointerArray<CSIPHeaderBase>& headers = AllHeadersL(); const CSIPHeaderBase* header = 0; for (TInt i=0; i < headers.Count(); i++) { header = headers[i]; if (SIPHeaderLookup::IsAPIHeader(header->Name()) || header->IsExtensionHeader()) { aWriteStream.WriteUint8L(1); // more headers in the stream flag header->ExternalizeL(aWriteStream); } } aWriteStream.WriteUint8L(0); // no more headers in the stream flag }
// ----------------------------------------------------------------------------- // CIAUpdatePendingNodesFile::ExternalizeL // // ----------------------------------------------------------------------------- // void CIAUpdatePendingNodesFile::ExternalizeL( RWriteStream& aStream ) { // If you make changes here, // remember to update InternalizeL accordingly!!! aStream.WriteInt32L( KVersion ); TInt count( iPendingNodes.Count() ); aStream.WriteInt32L( count ); for( TInt i = 0; i < count; ++i ) { CIAUpdaterIdentifier* identifier( iPendingNodes[ i ] ); identifier->ExternalizeL( aStream ); } aStream.WriteInt32L( iIndex ); }
EXPORT_C void TAppInfo::ExternalizeL(RWriteStream& aStream) const { _LIT(KEmptyString, ""); aStream << (iAppName ? *iAppName : KEmptyString()); aStream << (iAppVendor ? *iAppVendor : KEmptyString()); aStream.WriteL(TPckgC<TVersion>(iAppVersion)); }
// ----------------------------------------------------------------------------- // CSIPParamContainerBase::ExternalizeL // ----------------------------------------------------------------------------- // void CSIPParamContainerBase::ExternalizeL (RWriteStream& aWriteStream) { aWriteStream.WriteUint32L (iParams.Count()); for (TInt i=0; i < iParams.Count(); i++) { iParams[i]->ExternalizeL(aWriteStream); } }
// --------------------------------------------------------------------------- // CXIMPContextEventFilter::ExternalizeL() // --------------------------------------------------------------------------- // EXPORT_C void CXIMPContextEventFilter::ExternalizeL( RWriteStream& aStream ) const { if( !iAcceptedEvents ) { aStream.WriteInt32L( 0 ); } else { TInt count = iAcceptedEvents->Count(); aStream.WriteInt32L( count ); for( TInt ix = 0; ix < count; ++ix ) { aStream.WriteInt32L( ( *iAcceptedEvents )[ ix ] ); } } }
//----------------------------------------------------------------------------- // CCFContextSubscriptionImpl::ExternalizeL //----------------------------------------------------------------------------- // EXPORT_C void CCFContextSubscriptionImpl::ExternalizeL( RWriteStream& aStream ) { FUNC_LOG; // Context query iContextQuery->ExternalizeL( aStream ); // Indicate only changes flag aStream.WriteInt16L( iOnlyChangesIndicated ); // Enable data object aStream.WriteInt16L( iDataObjectEnabled ); // Commit stream aStream.CommitL(); }
EXPORT_C void CXzeDoor::ExternalizeL(RWriteStream& aStream)const // Save this picture. // Typically called from the base class StoreL(); // { CXzePicture::ExternalizeL(aStream); aStream.WriteUint8L((TUint8)iAlwaysFailToDetach!=EFalse); }
// ----------------------------------------------------------------------------- // CDRMEventAddRemove::ExternalizeL // Writes the data of the object into the given stream // (other items were commented in a header). // ----------------------------------------------------------------------------- // EXPORT_C void CDRMEventAddRemove::ExternalizeL( RWriteStream& aOutput) { TInt outputLength = 0; MDRMEvent::ExternalizeL(aOutput); // get the output length of the HBufC8* outputLength = iContentID->Size(); aOutput.WriteInt32L(outputLength); // write out the HBufC8* aOutput.WriteL(*iContentID); // this implementation may need to be changed if the size of the enum changes aOutput.WriteInt8L(iStatus); };
// --------------------------------------------------------- // CFavouritesItemImplList::ExternalizeL // --------------------------------------------------------- // void CFavouritesItemImplList::ExternalizeL( RWriteStream& aStream ) const { aStream.WriteInt32L( Count() ); for ( TInt i = 0; i < Count(); i++ ) { At( i )->ExternalizeL( aStream ); } }
// ----------------------------------------------------------------------------- // TAccPolCapsSubblockNameArraySerial::ExternalizeL // Externalize name array data to the write stream. // (other items were commented in a header). // ----------------------------------------------------------------------------- // EXPORT_C void TAccPolCapsSubblockNameArraySerial::ExternalizeL( const CAccPolSubblockNameArray& aArray, RWriteStream& aStream ) { COM_TRACE_( "[AccFW: ACCPOLICY] TAccPolCapsSubblockNameArraySerial::ExternalizeL()" ); TUint16 count( TAccPolSubblockNameArrayAccessor::GetCount( aArray ) ); aStream.WriteUint16L( count ); for ( TInt16 i( 0 ); i < count; ++i ) { TUint32 name; TAccPolSubblockNameArrayAccessor::GetName( aArray, i, name ); aStream.WriteUint16L( name ); } COM_TRACE_( "[AccFW: ACCPOLICY] TAccPolCapsSubblockNameArraySerial::ExternalizeL() - return void" ); }
// ---------------------------------------------------------------------------- // CURIContainer::ExternalizeL // ---------------------------------------------------------------------------- // EXPORT_C void CURIContainer::ExternalizeL(RWriteStream& aWriteStream) const { if(IsSIPURI()) { HBufC8* tmp = iSIPURI->ToTextL(); CleanupStack::PushL(tmp); aWriteStream.WriteUint32L(tmp->Des().Length()); aWriteStream.WriteL(tmp->Des()); CleanupStack::PopAndDestroy(tmp); } else { TPtrC8 uri8(iUri8->Uri().UriDes()); aWriteStream.WriteUint32L(uri8.Length()); aWriteStream.WriteL(uri8); } }