// -----------------------------------------------------------------------------
// 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);
	}
Exemplo n.º 3
0
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;
		}
	}
Exemplo n.º 5
0
	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 ); 
    
    };
Exemplo n.º 7
0
void CX520AttributeTypeAndValue::ExternalizeL(RWriteStream& aStream) const
	{
	aStream.WriteInt32L(iType->Des().Length());
	aStream << *iType;
	aStream.WriteInt32L(iValue->Des().Length());
	aStream << *iValue;
	}
Exemplo n.º 8
0
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
            }
        }
    } 
Exemplo n.º 11
0
EXPORT_C void TATParam::ExternalizeL(RWriteStream& aStream) const
    {
    aStream << iValue;
    aStream.WriteInt32L(KStreamVersion1);
    aStream.WriteInt32L(iValueInt);
    aStream.WriteInt32L(iType);
    }
Exemplo n.º 12
0
void TPlayer::ExternalizeL(RWriteStream& aStream)
{
    aStream.WriteInt32L(iNo);
    aStream.WriteInt32L(iName->Des().MaxLength());
    aStream << *iName;
    aStream.WriteInt32L(iScore);
}
Exemplo n.º 13
0
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);
		
	}
Exemplo n.º 14
0
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((""));
    }
Exemplo n.º 15
0
// -----------------------------------------------------------------------------
// 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 );
    }
Exemplo n.º 18
0
// ---------------------------------------------------------
// 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 ] );
    }
}
Exemplo n.º 19
0
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
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 );
                
    }
Exemplo n.º 22
0
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;
	}
Exemplo n.º 23
0
// -----------------------------------------------------------------------------
// 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);
		}
	}
Exemplo n.º 25
0
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"));
    }
Exemplo n.º 27
0
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);
	}
Exemplo n.º 28
0
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 );
    }
Exemplo n.º 30
0
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);
	}