// ------------------------------------------------------------------------------------------------
// CNSmlDPInformation::ExternalizeL
// ------------------------------------------------------------------------------------------------
EXPORT_C void CNSmlDPInformation::ExternalizeL( RWriteStream& aStream ) const
{
TPckgC<TSmlDataProviderId> id( iInfo->iId );
aStream.WriteL( id );
//version
aStream.WriteInt32L( iInfo->iVersion.iMajor );
aStream.WriteInt32L( iInfo->iVersion.iMinor );
aStream.WriteInt32L( iInfo->iVersion.iBuild );
aStream.WriteInt32L( iInfo->iProtocolVer );
aStream.WriteUint32L( iInfo->iDisplayName->Length() );
aStream << *iInfo->iDisplayName;
TInt mimetypesCount( iInfo->iMimeTypes->Count() );
aStream.WriteUint32L( mimetypesCount );
for (TInt i = 0; i < mimetypesCount; i++ )
{
const TDesC8& mimetype = (*iInfo->iMimeTypes)[i];
aStream.WriteUint32L( mimetype.Length() );
aStream << mimetype;
}
TInt mimeversCount( iInfo->iMimeVersions->Count() );
aStream.WriteUint32L( mimeversCount );
for (TInt i = 0; i < mimeversCount; i++ )
{
const TDesC8& mimever = (*iInfo->iMimeVersions)[i];
aStream.WriteUint32L( mimever.Length() );
aStream << mimever;
}
}
// ------------------------------------------------------------------------------------------------
// CSmlDataField::ExternalizeL()
// Puts the class contents to the write stream
// ------------------------------------------------------------------------------------------------
EXPORT_C void CSmlDataField::ExternalizeL(RWriteStream& aStream) const
{
if ( iDisplayName )
{
aStream.WriteUint32L( iDisplayName->Length() );
aStream << *iDisplayName;
}
else
{
aStream.WriteInt32L( 0 );
aStream << KNullDesC;
}
aStream.WriteUint32L( iName.DesC().Length() );
aStream << iName.DesC();
aStream.WriteUint32L( iDataType.DesC().Length() );
aStream << iDataType.DesC();
aStream.WriteInt16L( iEnumValues.Count() );
for ( TInt index = 0; index < iEnumValues.Count() ; index++ )
{
aStream.WriteUint32L( iEnumValues[index].DesC().Length() );
aStream << iEnumValues[index].DesC();
}
}
void CPosLmNameIndex::CIndexItem::ExternalizeL( RWriteStream& aOut ) const
{
aOut.WriteUint32L( iId );
aOut.WriteUint32L( Name().Length() );
aOut.WriteL( Name() );
// state is not stored, it is used only for index verification
}
EXPORT_C void CSDClientResultSet::ExternalizeL(RWriteStream& aStream) const
{
aStream.WriteUint32L(iMaxResults);
aStream.WriteUint32L(iResultCount);
for (TInt i=0;i<iMaxResults;i++)
iResultArray[i]->ExternalizeL(aStream);
}
// -----------------------------------------------------------------------------
void CPresenceCacheBuddyInfo::ExternalizeL( RWriteStream& aStream ) const
{
aStream.WriteInt32L( iAvailability );
ExternalizeFieldL( BuddyId(), aStream );
// externalize expiry time
TUint32 time_high = I64HIGH( iExpiryTime );
TUint32 time_low = I64LOW( iExpiryTime );
aStream.WriteUint32L(time_high);
aStream.WriteUint32L(time_low);
TInt count = iIds.Count();
aStream.WriteInt32L( count );
for ( TInt i=0; i < count; i++ )
{
if ( iIds[i] )
{
TPtrC key = iIds[i]->Des();
TPtrC8 value = iValues[i] ? iValues[i]->Des() : TPtrC8();
ExternalizeFieldL( key, aStream );
ExternalizeFieldL( value, aStream );
}
else
{
// nothing to insert, special case if replacement has been failed earlier
}
}
}
// -----------------------------------------------------------------------------
// CHttpCacheEntry::Externalize
//
// -----------------------------------------------------------------------------
//
void CHttpCacheEntry::ExternalizeL( RWriteStream& aWriteStream, const TDesC& aDirectory )
{
// check directory matches filename
ASSERT(aDirectory.CompareF(iFileName->Left(aDirectory.Length())) == 0);
// url length
aWriteStream.WriteInt32L( iUrl->Length() );
// url
aWriteStream.WriteL( iUrl->Des() );
// filename
// know that filenames are 8 chars and no extension. Can reconstruct on
// import from directory and last char. See HttpCacheUtil::GenerateNameLC.
aWriteStream.WriteL( iFileName->Des().Right( KFilenameLength ) );
// la
aWriteStream.WriteReal64L( iLastAccessed );
// ref
aWriteStream.WriteUint32L( iRef );
// size
aWriteStream.WriteUint32L( iBodySize );
// size
aWriteStream.WriteUint32L( iHeaderSize );
// protected
aWriteStream.WriteInt32L( iProtected );
// header data length
aWriteStream.WriteInt32L( iHeaderBuffer->Length() );
// header data
aWriteStream.WriteL( iHeaderBuffer->Des() );
}
void CDeploymentComponentData::SerializedFormL(RWriteStream &aBuffer) const
{
aBuffer.WriteUint32L(iDataFileName.Length() );
aBuffer.WriteL(iDataFileName);
aBuffer.WriteUint32L(iMimeType.Length() );
aBuffer.WriteL(iMimeType);
}
// -----------------------------------------------------------------------------
// CMceComRtpSource::ExternalizeFlatL
// -----------------------------------------------------------------------------
//
void CMceComRtpSource::ExternalizeFlatL( RWriteStream& aWriteStream )
{
CMceComMediaSource::ExternalizeFlatL( aWriteStream );
aWriteStream.WriteUint32L( iInactivityTimer );
aWriteStream.WriteUint32L( iBufferLength );
aWriteStream.WriteUint32L( iBufferTreshold );
MceSerial::EncodeL( iTalkBurstIndicator, aWriteStream );
MceSerial::EncodeL( iIdentity, aWriteStream );
}
// ---------------------------------------------------------------------------
// CCaInnerIconDescription::ExternalizeL
// ---------------------------------------------------------------------------
//
void CCaInnerIconDescription::ExternalizeL( RWriteStream& aStream ) const
{
aStream.WriteInt32L( iId );
aStream.WriteUint32L( iFileName.Length() );
aStream.WriteL( iFileName, iFileName.Length() );
aStream.WriteUint32L( iSkinId.Length() );
aStream.WriteL( iSkinId, iSkinId.Length() );
aStream.WriteUint32L( iApplicationId.Length() );
aStream.WriteL( iApplicationId, iApplicationId.Length() );
aStream.CommitL();
}
EXPORT_C void TImEmailTransformingInfo::ExternalizeL( RWriteStream& aWriteStream ) const
{
aWriteStream.WriteUint8L( SendMethod() );
aWriteStream.WriteUint8L( HeaderEncoding() );
aWriteStream.WriteUint8L( BodyTextEncoding());
aWriteStream.WriteUint8L( HTMLEncoding() );
aWriteStream.WriteUint8L( AttachmentEncoding() );
aWriteStream.WriteUint32L( HeaderCharset() );
aWriteStream.WriteUint32L( BodyTextCharset() );
aWriteStream.WriteUint32L( HTMLCharset() );
}
void CClassB::ExternalizeL(RWriteStream& aStream) const
{
aStream << iFixBuffer;
aStream.WriteInt32L(iIntValue);
aStream.WriteUint32L(iUintValue);
aStream.WriteReal64L(iRealValue);
}
// ---------------------------------------------------------
// CDownloadDataClient::ExternalizeL()
// ---------------------------------------------------------
//
void CDownloadDataClient::ExternalizeL(RWriteStream& aStream) const
{
// iName
if (iName)
aStream << *iName;
else
aStream << KNullDesC;
// iSize
aStream.WriteUint32L(iSize);
// iIcon
if (iIcon)
aStream << *iIcon;
else
aStream << KNullDesC;
// iUpdatedDDUri
if (iUpdatedDDUri)
aStream << *iUpdatedDDUri;
else
aStream << KNullDesC;
// iMediaArray elements
TInt count = iMediaArray.Count();
aStream.WriteInt32L(count);
for (TInt index = 0; index < count; ++index)
iMediaArray[index]->ExternalizeL(aStream);
}
// ---------------------------------------------------------------------------
// ?implementation_description
// ---------------------------------------------------------------------------
//
void TNcdSendableProgress::ExternalizeL( RWriteStream& aStream ) const
{
aStream.WriteUint32L( iState );
aStream.WriteInt32L( iOperationId );
aStream.WriteInt32L( iProgress );
aStream.WriteInt32L( iMaxProgress );
}
EXPORT_C void CXzePicture::ExternalizeL(RWriteStream& aStream)const
// Save this picture.
// Typically called from the base class StoreL();
//
{
aStream.WriteUint32L(iLabel);
}
void CClassA::ExternalizeL(RWriteStream& aStream) const
{
aStream.WriteInt32L(iVarBuffer->Des().MaxLength());
aStream << *iVarBuffer;
aStream.WriteInt32L(iIntValue);
aStream.WriteUint32L(iUintValue);
}
// -----------------------------------------------------------------------------
// CExtensionDescrParam::ExternalizeL
// -----------------------------------------------------------------------------
//
void CExtensionDescrParam::ExternalizeL(RWriteStream& aWriteStream) const
{
__ASSERT_ALWAYS(iValue != NULL, User::Leave(KErrNotFound));
aWriteStream.WriteUint32L(iID);
aWriteStream.WriteInt32L(iValue->Length());
aWriteStream.WriteL(*iValue);
}
// ----------------------------------------------------------------------------
// 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);
}
}
// -----------------------------------------------------------------------------
// CSIPParamContainerBase::ExternalizeL
// -----------------------------------------------------------------------------
//
void CSIPParamContainerBase::ExternalizeL (RWriteStream& aWriteStream)
{
aWriteStream.WriteUint32L (iParams.Count());
for (TInt i=0; i < iParams.Count(); i++)
{
iParams[i]->ExternalizeL(aWriteStream);
}
}
void CAgnAttachmentIndexItem::ExternalizeL(RWriteStream& aWriteStream) const
{
aWriteStream.WriteInt32L(iSize);
TInt64 time64 = iLastModifiedDateUtc.Int64();
aWriteStream << time64;
aWriteStream << *iFileName;
TUint32 count = iEntries.Count();
aWriteStream.WriteUint32L(count);
for (TUint32 i=0; i < count; ++i)
{
aWriteStream.WriteUint32L(iEntries[i]);
}
aWriteStream.WriteUint32L(iUid);
}
// ----------------------------------------------------------------------------
// CSIPSubscriptionStateHeader::ExternalizeValueL
// From CSIPHeaderBase:
// ----------------------------------------------------------------------------
//
void CSIPSubscriptionStateHeader::ExternalizeValueL(
RWriteStream& aWriteStream) const
{
aWriteStream.WriteUint32L (iSubStateValue->Length());
if (iSubStateValue->Length() > 0)
{
aWriteStream.WriteL (SubStateValue());
}
iParams->ExternalizeL (aWriteStream);
}
// -----------------------------------------------------------------------------
// CSdpRepeatField::ExternalizeL
// Externalizes the object to stream
// -----------------------------------------------------------------------------
//
void CSdpRepeatField::ExternalizeL(RWriteStream& aStream) const
{
iRepeatInterval.ExternalizeL(aStream);
iActiveDuration.ExternalizeL(aStream);
aStream.WriteUint32L(iTimeOffsets.Count());
for (TInt i = 0; i < iTimeOffsets.Count(); i++)
{
(iTimeOffsets)[i].ExternalizeL(aStream);
}
}
// ----------------------------------------------------------------------------
// Externalize an array of itemids to stream
// ----------------------------------------------------------------------------
//
EXPORT_C void MPXUser::ExternalizeL(const TArray<TMPXItemId>& aArray, RWriteStream& aStream)
{
TInt n=aArray.Count();
aStream.WriteInt32L(n);
for (TInt i=0;i<n;++i)
{
aStream.WriteUint32L(aArray[i].iId1);
aStream.WriteUint32L(aArray[i].iId2);
}
}
void CAgnAttachmentIndex::ExternalizeL(RWriteStream& aWriteStream) const
{
TUint32 count = iIndex.Count();
aWriteStream.WriteUint32L(count);
for (TUint32 i=0; i < count; ++i)
{
iIndex[i]->ExternalizeL(aWriteStream);
}
}
/**
Externalises the configuration of the BIC
@param aWriteStream A write stream to write BIC data to
*/
void CCmdPublishSwp::ExternalizeL(RWriteStream& aWriteStream) const
{
aWriteStream.WriteInt16L(iSeverity);
aWriteStream.WriteUint8L(iExecutionBehaviour);
aWriteStream.WriteUint32L(iSwpInfo.Key());
aWriteStream.WriteInt32L(iSwpInfo.Value());
#ifdef SYMBIAN_SSM_FLEXIBLE_MERGE
aWriteStream.WriteUint16L(iPriority);
#endif
}
// -----------------------------------------------------------------------------
// CSdpConnectionField::ExternalizeL
// Externalizes the object to stream
// -----------------------------------------------------------------------------
//
void CSdpConnectionField::ExternalizeL(
RWriteStream& aStream ) const
{
__TEST_INVARIANT;
// Address
aStream.WriteUint32L( iAddress->Des().Length() );
aStream.WriteL( iAddress->Des(), iAddress->Des().Length() );
// TTL
aStream.WriteInt32L( iTTL );
// Number of addresses
aStream.WriteInt32L( iNumOfAddress );
// <network type>
aStream.WriteUint32L( iNetType.DesC().Length() );
aStream.WriteL( iNetType.DesC() );
// <address type>
aStream.WriteUint32L( iAddressType.DesC().Length() );
aStream.WriteL( iAddressType.DesC() );
}
void CAgnAttachment::ExternalizeL(RWriteStream& aStream) const
{
aStream.WriteUint8L(Type());
aStream << MimeType();
aStream.WriteUint32L(iUid);
aStream.WriteUint16L(iAttributes);
aStream.WriteUint16L(iFlags);
aStream.WriteInt32L(iSize);
aStream << Label();
}
// -----------------------------------------------------------------------------
// CSdpOriginField::ExternalizeL
// Externalizes the field back to string
// -----------------------------------------------------------------------------
//
void CSdpOriginField::ExternalizeL(
RWriteStream& aStream ) const
{
__TEST_INVARIANT;
// <username>
aStream.WriteUint32L( UserName().Length() );
aStream.WriteL( UserName(), UserName().Length() );
// <session id>
aStream.WriteUint32L( OriginFieldPtrs().SessionId().Length() );
aStream.WriteL( OriginFieldPtrs().SessionId(),
OriginFieldPtrs().SessionId().Length() );
// <version>
aStream.WriteUint32L( OriginFieldPtrs().SessionVersion().Length() );
aStream.WriteL( OriginFieldPtrs().SessionVersion(),
OriginFieldPtrs().SessionVersion().Length() );
// <network type>
aStream.WriteUint32L( iNetType.DesC().Length() );
aStream.WriteL( iNetType.DesC() );
// <address type>
aStream.WriteUint32L( iAddressType.DesC().Length() );
aStream.WriteL( iAddressType.DesC() );
// <address>
aStream.WriteUint32L( iAddress.Length() );
aStream.WriteL( iAddress );
}
// -----------------------------------------------------------------------------
// 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);
}
// ---------------------------------------------------------------------------
// CCmBaseListItem::ExternalizeL
// ---------------------------------------------------------------------------
//
EXPORT_C void CCmBaseListItem::ExternalizeL( RWriteStream& aStream ) const
{
aStream.WriteInt32L( iPrimaryText->Length() );
if ( iPrimaryText )
{
aStream << *iPrimaryText;
}
else
{
aStream << KNullDesC();
}
aStream.WriteInt32L( iSecondaryText->Length() );
if ( iSecondaryText )
{
aStream << *iSecondaryText;
}
else
{
aStream << KNullDesC();
}
aStream.WriteInt32L( iPath->Length() );
if ( iPath )
{
aStream << *iPath;
}
else
{
aStream << KNullDesC();
}
aStream.WriteInt32L( iSize );
aStream.WriteUint32L( iDate.Int64() );
aStream.WriteInt32L( iStatus );
aStream.WriteUint32L( iId );
aStream.WriteUint32L( iRefId );
aStream.WriteInt32L( iMediaType );
}
// ---------------------------------------------------------------------------
// CAccPolHdmiAudioFormat::ExternalizeL()
// ---------------------------------------------------------------------------
//
void CAccPolHdmiAudioFormat::ExternalizeL( RWriteStream& aStream ) const
{
API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiAudioFormat::ExternalizeL() - Enter" );
//Add object type at the beginning
aStream.WriteUint8L( ObjectType() );
aStream.WriteInt32L( iAudioFormat.iUid );
aStream.WriteUint32L( iMaxChannelCount );
aStream.WriteUint32L( iBitResolution );
aStream.WriteUint32L( iMaxBitResolution );
aStream.WriteUint32L( iSamFreq );
aStream.WriteUint32L( iFormateDependentValue );
API_TRACE_1( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiAudioFormat::ExternalizeL - Object Type = %d", ObjectType() );
API_TRACE_1( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiAudioFormat::ExternalizeL - AudioFormat Uid = %d", iAudioFormat.iUid );
API_TRACE_1( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiAudioFormat::ExternalizeL - Channel count = %d", iMaxChannelCount );
API_TRACE_1( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiAudioFormat::ExternalizeL - Bit Resolution = %d", iBitResolution );
API_TRACE_1( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiAudioFormat::ExternalizeL - Maximum Bit Resolution = %d", iMaxBitResolution );
API_TRACE_1( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiAudioFormat::ExternalizeL - Sam Freq = %d", iSamFreq );
API_TRACE_1( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiAudioFormat::ExternalizeL - Format Dependen tValue = %d", iFormateDependentValue );
API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiAudioFormat::ExternalizeL - Return" );
}
