// ------------------------------------------------------------------------------------------------
// 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.º 2
0
// ------------------------------------------------------------------------------------------------
// 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);

    }
Exemplo n.º 8
0
// -----------------------------------------------------------------------------
// 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();
    }
Exemplo n.º 10
0
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() );
	}
Exemplo n.º 11
0
void CClassB::ExternalizeL(RWriteStream& aStream) const
	{
	aStream << iFixBuffer;
	aStream.WriteInt32L(iIntValue);
	aStream.WriteUint32L(iUintValue);
	aStream.WriteReal64L(iRealValue);
	}  
Exemplo n.º 12
0
// ---------------------------------------------------------
// 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 );
    }
Exemplo n.º 14
0
EXPORT_C void CXzePicture::ExternalizeL(RWriteStream& aStream)const
// Save this picture.
// Typically called from the base class StoreL();
//
{
    aStream.WriteUint32L(iLabel);
}
Exemplo n.º 15
0
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);
	}
Exemplo n.º 17
0
// ----------------------------------------------------------------------------
// 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);
	}
Exemplo n.º 21
0
// -----------------------------------------------------------------------------
// 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);
        }
    }
Exemplo n.º 22
0
// ----------------------------------------------------------------------------
// 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);
		}
		
	}
Exemplo n.º 24
0
/**
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
	}
Exemplo n.º 25
0
// -----------------------------------------------------------------------------
// 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() );
    }
Exemplo n.º 26
0
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();
	}
Exemplo n.º 27
0
// -----------------------------------------------------------------------------
// 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);
	}
Exemplo n.º 29
0
// ---------------------------------------------------------------------------
// 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" );
    }