// -----------------------------------------------------------------------------
// 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() );
}
/** implementation of inherited externalization function */
void CLbsTransmitLocationLogEvent::DoExternalizeL(RWriteStream& aWriteStream) const
{
aWriteStream.WriteInt32L(iX3PApp.iUid);
aWriteStream.WriteInt32L(iDestination.Length());
aWriteStream.WriteL(iDestination.Ptr(), iDestination.Length());
WritePosInfo(aWriteStream, iPosInfo);
}
void CClassA::ExternalizeL(RWriteStream& aStream) const
{
aStream.WriteInt32L(iVarBuffer->Des().MaxLength());
aStream << *iVarBuffer;
aStream.WriteInt32L(iIntValue);
aStream.WriteUint32L(iUintValue);
}
// ------------------------------------------------------------------------------------------------
// 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;
}
}
void ExternalizeInt64L(const TInt64& aInt, RWriteStream& aStream)
{
TInt32 low = I64LOW( aInt );
TInt32 high = I64HIGH( aInt );
aStream.WriteInt32L(low);
aStream.WriteInt32L(high);
}
// -----------------------------------------------------------------------------
// CDRMEventTimeChange::ExternalizeL
// Writes the data of the object into the given stream
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
EXPORT_C void CDRMEventTimeChange::ExternalizeL(
RWriteStream& aOutput)
{
TInt8 securityLevel = 0;
MDRMEvent::ExternalizeL(aOutput);
// output the old time
WriteInt64L( iOldTime.Int64(), aOutput );
// output the new time
WriteInt64L( iNewTime.Int64(), aOutput );
// output the old timezone
aOutput.WriteInt32L( iOldTimeZone );
// output the new timezone
aOutput.WriteInt32L( iNewTimeZone );
// output the old security level
securityLevel = iOldSecurityLevel;
aOutput.WriteInt8L( securityLevel );
// output the new security level
securityLevel = iNewSecurityLevel;
aOutput.WriteInt8L( securityLevel );
};
void CX520AttributeTypeAndValue::ExternalizeL(RWriteStream& aStream) const
{
aStream.WriteInt32L(iType->Des().Length());
aStream << *iType;
aStream.WriteInt32L(iValue->Des().Length());
aStream << *iValue;
}
void CCntFilter::ExternalizeL(RWriteStream& aStream) const
/** Externalises a CCntFilter object to a write stream.
@param aStream Stream to which the object should be externalised. */
{
// CContactIdArray* iIds;
if(iIds)
{
aStream.WriteInt32L(1);
iIds->ExternalizeL(aStream);
}
else
{
aStream.WriteInt32L(0); // Empty array
}
// TTime iSinceDateTime;
aStream << iSinceDateTime.Int64();
// TInclude iInclude;
aStream.WriteInt32L(iInclude);
// TInt32 iContactType;
aStream.WriteInt32L(iContactType);
// TAny* iReserved1;
// TAny* iReserved2;
}
// ---------------------------------------------------------------------------
// ?implementation_description
// ---------------------------------------------------------------------------
//
void TNcdSendableProgress::ExternalizeL( RWriteStream& aStream ) const
{
aStream.WriteUint32L( iState );
aStream.WriteInt32L( iOperationId );
aStream.WriteInt32L( iProgress );
aStream.WriteInt32L( iMaxProgress );
}
// -----------------------------------------------------------------------------
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
}
}
}
EXPORT_C void TATParam::ExternalizeL(RWriteStream& aStream) const
{
aStream << iValue;
aStream.WriteInt32L(KStreamVersion1);
aStream.WriteInt32L(iValueInt);
aStream.WriteInt32L(iType);
}
void TPlayer::ExternalizeL(RWriteStream& aStream)
{
aStream.WriteInt32L(iNo);
aStream.WriteInt32L(iName->Des().MaxLength());
aStream << *iName;
aStream.WriteInt32L(iScore);
}
void TTcSettings::doStoreL( RWriteStream& aStream )
{
aStream.WriteInt16L( KTcSettingsVersion );
// Write bearer selection
aStream.WriteInt32L( iBearerType );
// Write autoconnect selection
aStream.WriteInt16L( iAutoConnect );
// Write TCP port selection
aStream.WriteInt16L( iTCPPort );
// Write IAP iD
aStream.WriteInt16L( iIAPId );
// Write CSY name
aStream.WriteInt32L( iCSYName );
// Write comms port name
aStream.WriteInt32L( iCommPort );
// Write baudrate of comms
aStream.WriteInt32L( iBaudrate );
// Write first run flag
aStream.WriteInt16L( iIsFirstRun );
// Write remote tcp address as string
TBuf<40> buf;
iTCPRemoteAddr.Output(buf);
//write length first
aStream.WriteInt16L( buf.Length() );
aStream.WriteL(buf);
}
void CNcdNodeDisclaimer::ExternalizeL( RWriteStream& aStream )
{
DLTRACEIN((""));
// Set all the membervariable values to the stream. So,
// that the stream may be used later to create a new
// object.
// First insert data that the creator of this class object will use to
// create this class object. Class id informs what class object
// will be created.
aStream.WriteInt32L( iClassId );
// Write the data that will be used when internalize function
// is called. catalogsutils.h contains good internalize and
// externalize functions.
// Make sure that this matches to the order that is used
// when this stream is internalized.
ExternalizeDesL( *iTitle, aStream );
ExternalizeDesL( *iBodyText, aStream );
aStream.WriteInt32L( iOptional );
aStream.WriteInt32L( iSemantics );
DLTRACEOUT((""));
}
// -----------------------------------------------------------------------------
// 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();
}
void TMMCScBkupArchiveVector::ExternalizeL(RWriteStream& aStream) const
{
aStream.WriteInt32L( EStreamFormatVersion1 );
aStream.WriteInt32L( Offset() );
aStream.WriteInt32L( Length() );
aStream.WriteInt32L( 0 ); // Spare1
aStream.WriteInt32L( 0 ); // Spare2
}
// ---------------------------------------------------------
// CMsgAddressControlEditorField::ExternalizeL
//
//
// ---------------------------------------------------------
//
void CMsgAddressControlEditorField::ExternalizeL( RWriteStream& aStream ) const
{
aStream << iEntryString->Des();
aStream << iName->Des();
aStream << iAddress->Des();
aStream.WriteInt32L( iVerified );
aStream.WriteInt32L( iValidated );
}
// ---------------------------------------------------------
// FavouritesUtil::ExternalizeL
// ---------------------------------------------------------
//
void FavouritesUtil::ExternalizeL
( const CArrayFix<TInt>& aArray, RWriteStream& aStream )
{
aStream.WriteInt32L( aArray.Count() );
for ( TInt i = 0; i < aArray.Count(); i++ )
{
aStream.WriteInt32L( aArray[ i ] );
}
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
EXPORT_C void RCaIdsArray::ExternalizeL( RWriteStream& aStream ) const
{
aStream.WriteInt32L( Count() );
for( TInt i = 0; i < Count(); i++ )
{
aStream.WriteInt32L( operator[]( i ) );
}
aStream.CommitL();
}
// ---------------------------------------------------------------------------
// TMMCScBkupArchiveDriveAndVector::ExternalizeL()
//
//
// ---------------------------------------------------------------------------
void TMMCScBkupArchiveDriveAndVector::ExternalizeL( RWriteStream& aStream ) const
{
aStream.WriteInt32L( EStreamFormatVersion1 );
aStream.WriteInt32L( 0 ); // spare1
aStream.WriteInt32L( 0 ); // spare2
aStream.WriteInt32L( 0 ); // spare3
//
aStream.WriteUint8L( iDrive );
aStream << iVector;
}
// -----------------------------------------------------------------------------
// CUpnpFileTransferEvent::ExternalizeL
// -----------------------------------------------------------------------------
//
EXPORT_C void CUpnpFileTransferEvent::ExternalizeL( RWriteStream& aStream ) const
{
aStream << *iFilePath;
aStream.WriteInt32L( iProgress );
aStream.WriteInt32L( iDirection );
aStream.WriteInt32L( iContentDirectoryObjectId );
aStream.WriteInt32L( iTransferId );
aStream.WriteInt32L( iErrorCode );
}
EXPORT_C void CEikListBoxTextEditor::WriteInternalStateL(RWriteStream& aWriteStream) const
{
_LIT(KEikLitLbxEdCtlStart,"<CEikListBoxTextEditor>");
_LIT(KEikLitLbxEdCtlEnd,"<\\CEikListBoxTextEditor>");
_LIT(KEikLitLbxEdObs,"<iEditorObserver>");
_LIT(KEikLitLbxEdObsEnd,"<\\iEditorObserver>");
_LIT(KEikLitLbxEdMdl,"<iModel>");
_LIT(KEikLitLbxEdMdlEnd,"<\\iModel>");
_LIT(KEikLitLbxEdEdr,"<iEditor>");
_LIT(KEikLitLbxEdEdrEnd,"<\\iEditor>");
_LIT(KEikLitLbxEdIndx,"<iItemIndex>");
_LIT(KEikLitLbxEdIndxEnd,"<\\iItemIndex>");
_LIT(KEikLitLbxEdFont,"<iFont>");
_LIT(KEikLitLbxEdFontEnd,"<\\iFont>");
_LIT(KEikLitLbxEdItemPos,"<iItemPos>");
_LIT(KEikLitLbxEdItemPosEnd,"<\\iItemPos>");
_LIT(KEikLitLbxEdItemLen,"<iItemLen>");
_LIT(KEikLitLbxEdItemLenEnd,"<\\iItemLen>");
_LIT(KEikLitLbxEdParaLay,"<iParaFormatLayer>");
_LIT(KEikLitLbxEdParaLayEnd,"<\\iParaFormatLayer>");
_LIT(KEikLitLbxEdCharLay,"<iCharFormatLayer>");
_LIT(KEikLitLbxEdCharLayEnd,"<\\iCharFormatLayer>");
aWriteStream << KEikLitLbxEdCtlStart;
aWriteStream << KEikLitLbxEdObs;
aWriteStream.WriteInt32L((TInt)iEditorObserver);
aWriteStream << KEikLitLbxEdObsEnd;
aWriteStream << KEikLitLbxEdMdl;
aWriteStream.WriteInt32L((TInt)iModel);
aWriteStream << KEikLitLbxEdMdlEnd;
aWriteStream << KEikLitLbxEdEdr;
iEditor->WriteInternalStateL(aWriteStream); // won't be done as a component
aWriteStream << KEikLitLbxEdEdrEnd;
aWriteStream << KEikLitLbxEdIndx;
aWriteStream.WriteInt32L(iItemIndex);
aWriteStream << KEikLitLbxEdIndxEnd;
aWriteStream << KEikLitLbxEdFont;
const TFontSpec& spec=iFont->FontSpecInTwips();
aWriteStream << spec;
aWriteStream << KEikLitLbxEdFontEnd;
aWriteStream << KEikLitLbxEdItemPos;
aWriteStream.WriteInt32L(iItemPos);
aWriteStream << KEikLitLbxEdItemPosEnd;
aWriteStream << KEikLitLbxEdItemLen;
aWriteStream.WriteInt32L(iItemLen);
aWriteStream << KEikLitLbxEdItemLenEnd;
aWriteStream << KEikLitLbxEdParaLay;
aWriteStream << *iParaFormatLayer;
aWriteStream << KEikLitLbxEdParaLayEnd;
aWriteStream << KEikLitLbxEdCharLay;
aWriteStream << *iCharFormatLayer;
aWriteStream << KEikLitLbxEdCharLayEnd;
CCoeControl::WriteInternalStateL(aWriteStream);
aWriteStream << KEikLitLbxEdCtlEnd;
}
// -----------------------------------------------------------------------------
// CWPRoot::ExternalizeL
// -----------------------------------------------------------------------------
//
void CWPRoot::ExternalizeL(RWriteStream& aStream) const
{
aStream.WriteInt32L( iContents->Count() );
for( TInt i( 0 ); i < iContents->Count(); i++ )
{
CWPCharacteristic* current = iContents->At( i );
aStream.WriteInt32L( current->Type() );
current->ExternalizeL( aStream );
}
}
EXPORT_C void CPrinterProperty::ExternalizeL(RWriteStream& aStream) const
{
aStream.WriteInt32L(iPrinterId);
aStream.WriteInt32L(iApplicationId);
TInt count = iPropertyItems.Count();
aStream.WriteInt32L(count);
for (TInt i=0; i<count; i++)
{
iPropertyItems[i].ExternalizeL(aStream);
}
}
void CRTPermGrantMessage::ExternalizeL(RWriteStream& aSink)
{
aSink.WriteInt32L(iScriptId);
TInt cnt = iAllowedProviders.Count();
aSink.WriteInt32L(cnt);
for(TInt i(0); i < iAllowedProviders.Count(); i++)
aSink.WriteInt32L(iAllowedProviders[i].iUid);
cnt = iDeniedProviders.Count();
aSink.WriteInt32L(cnt);
for(TInt i(0); i < iDeniedProviders.Count(); i++)
aSink.WriteInt32L(iDeniedProviders[i].iUid);
}
void CNcdExtendedInstallInfo::ExternalizeL( RWriteStream& aStream )
{
DLTRACEIN((""));
CNcdPurchaseInstallInfo::ExternalizeL( aStream );
ExternalizeDesL( *iMimeType, aStream );
aStream.WriteInt32L( iLaunchable );
ExternalizeDesL( *iParameter, aStream );
ExternalizeEnumL( iContentType, aStream );
ExternalizeEnumL( iInstalledStatus, aStream );
aStream.WriteInt32L( iUriExists );
DLTRACEOUT(("Externalization successful"));
}
EXPORT_C void TTaskInfo::ExternalizeL(RWriteStream& aWriteStream) const
/** Externalises an object of this class to a write stream.
The presence of this function means that the standard templated operator<<()
can be used to externalise objects of this class.
@param aStream Stream to which the object should be externalised. */
{
aWriteStream << iName;
aWriteStream.WriteInt32L(iTaskId);
aWriteStream.WriteInt32L(iRepeat);
aWriteStream.WriteInt32L(iPriority);
}
EXPORT_C void CContactItemViewDef::ExternalizeL(RWriteStream& aStream) const
/** Externalises the item view definition to a write stream. The presence of this
function means that the standard templated operator<<() (defined in s32strm.h)
is available to externalise objects of this class.
@param aStream Stream to which the item view definition should be externalised. */
{
aStream.WriteInt32L(iUse);
TInt count=Count();
aStream.WriteInt32L(count);
for(TInt ii=0;ii<count;ii++)
aStream << iFieldTypes[ii];
}
// -----------------------------------------------------------------------------
// CIAUpdateBGControllerFile::ExternalizeL
//
// -----------------------------------------------------------------------------
//
void CIAUpdateBGControllerFile::ExternalizeL( RWriteStream& aStream )
{
// If you make changes here,
// remember to update InternalizeL accordingly!!!
aStream.WriteInt32L( KVersion );
TInt64 refreshTime( RefreshTime().Int64() );
aStream << refreshTime;
TInt language( Language() );
aStream.WriteInt32L( language );
}
EXPORT_C void CMobilePhoneListBase::ExternalizeL(RWriteStream& aStream) const
/** This member function externalizes the list contents into a stream.
@param aStream The write stream to which to write the list.
@capability None
*/
{
aStream.WriteInt32L(iMaxNumber);
TInt count=iList.Count();
aStream.WriteInt32L(count);
for (TInt ii=0;ii<count;++ii)
ExternalizeEntryL(iList.At(ii),aStream);
}