// ---------------------------------------------------------------------------
// 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);
}
}
