// ---------------------------------------------------------------------------
// CAccPolObjectBase::ExternalizeBaseLd
// ---------------------------------------------------------------------------
//
EXPORT_C void CAccPolAudioUnitBase::ExternalizeAudioUnitBaseL(
    RWriteStream& aStream ) const
    {
    API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolAudioUnitBase::ExternalizeAudioUnitBaseL() - Enter" );
    TInt count( KErrNone );
    //Add data
    aStream.WriteUint8L( iUnitId );
    count = iSourceId.Count();
    aStream.WriteInt8L( iSourceId.Count() );
    for( TInt i = 0; i < count; i++ )
        {
        aStream.WriteUint8L( ( TUint8 )iSourceId.operator[]( i ) );
        }
    count = iAudioControls.Count();
    aStream.WriteInt8L( count );

    API_TRACE_1( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolAudioUnitBase::ExternalizeAudioUnitBaseL - Unit id         = %d", iUnitId );
    API_TRACE_1( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolAudioUnitBase::ExternalizeAudioUnitBaseL - Source id count = %d", iSourceId.Count() );
    API_TRACE_1( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolAudioUnitBase::ExternalizeAudioUnitBaseL - Audio controls count = %d", iAudioControls.Count() );

    for( TInt i = 0; i < iAudioControls.Count(); i++ )
        {
        iAudioControls[i]->ExternalizeL( aStream );
        }
    API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolAudioUnitBase::ExternalizeBaseL - Return" );
    }
// ---------------------------------------------------------------------------
// CLbtTriggerInfo::SetTriggerEntry()
//
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//  
EXPORT_C void CLbtTriggerInfo::ExternalizeL( RWriteStream& aStream ) const
    {
	CLbtTriggerEntry::TType trigType=iEntry->Type();
	if(trigType==CLbtTriggerEntry::ETypeSession)
		aStream.WriteInt8L(1);
	
	else
		aStream.WriteInt8L(2);
	iEntry->ExternalizeL(aStream);
	
	TLbtTriggerDynamicInfo::TLbtTriggerValidity trigValidity=iDynInfo->iValidity;
	switch(trigValidity)
	    {
		case TLbtTriggerDynamicInfo::EInvalid:aStream.WriteInt8L(1);
				 break;
		case TLbtTriggerDynamicInfo::EValid: aStream.WriteInt8L(2);
					break;
		default:
			aStream.WriteInt8L(0);
			break;
	    }
	
	
	aStream.WriteReal32L(iDynInfo->iDistanceToLatestLocation);
    }
// -----------------------------------------------------------------------------
// 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 ); 
    
    };
// -----------------------------------------------------------------------------
// 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();
    }
Esempio n. 5
0
void TWordUiData::ExternalizeL(RWriteStream& aStream) const
	{
	const TCardinality version=KVersionAppConfigurationData;
	version.ExternalizeL(aStream);

	aStream.WriteUint8L((TUint8)iNpcVisibility);
	aStream.WriteUint8L((TUint8)iPicturePrefs);
	aStream.WriteInt8L(iToolbandVisibility);
	aStream.WriteInt8L(iToolbarVisibility);
	aStream.WriteInt8L(iWysiwygOn);

	aStream.WriteInt32L(iCursorPos);
	aStream.WriteInt32L(iZoomFactor);
	}
// ---------------------------------------------------------------------------
// CXIMPContextStateEventImp::ExternalizeL()
// ---------------------------------------------------------------------------
//
void CXIMPContextStateEventImp::ExternalizeL( RWriteStream& aStream ) const
    {
    iState->ExternalizeL( aStream );

    if( iStateChangeReason )
        {
        aStream.WriteInt8L( EHasStatusObject );
        iStateChangeReason->ExternalizeL( aStream );
        }
    else
        {
        aStream.WriteInt8L( ENoStatusObject );
        }
    }
Esempio n. 7
0
// ---------------------------------------------------------------------------
// CCmFillRule::ExternalizeL
// ---------------------------------------------------------------------------
//
void CCmFillRule::ExternalizeL( RWriteStream& aStream ) const
    {
    aStream.WriteInt32L( iName->Length() );
    if ( iName )
        {
        aStream << *iName;
        }
    else
        {
        aStream << KNullDesC8();
        }      
    aStream.WriteInt32L( iAmount );
    aStream.WriteInt32L( iRealSize );
    aStream.WriteInt32L( iRealCount );
    aStream.WriteInt16L( (TInt)iLimitType );
    aStream.WriteInt16L( (TInt)iMethod );
    aStream.WriteInt16L( (TInt)iMediaType );
    aStream.WriteInt16L((TInt)iSelected );
    aStream.WriteInt16L((TInt)iStatus );
    aStream.WriteInt8L(iPriority);
    aStream.WriteInt8L( iTemplateId );
    aStream.WriteInt32L( iId );
    
    aStream.WriteInt16L( iRuleArray.Count() );
    for ( TInt index(0); index < iRuleArray.Count(); index++ )
        {
        iRuleArray[index]->ExternalizeL( aStream );
        }
        
    aStream.WriteInt16L( iMediaServerArray.Count() );
    for ( TInt index(0); index < iMediaServerArray.Count(); index++ )
        {
        iMediaServerArray[index]->ExternalizeL( aStream );
        }

    aStream.WriteInt16L( iExcAlbums->Count() );
    for ( TInt index(0); index < iExcAlbums->Count(); index++ )
        {
        aStream.WriteInt32L( iExcAlbums[index].Length() );
        aStream << iExcAlbums->MdcaPoint(index);
        }
        
    aStream.WriteInt16L( iExcPlayLists->Count() );
    for ( TInt index(0); index < iExcPlayLists->Count(); index++ )
        {
        aStream.WriteInt32L( iExcPlayLists[index].Length() );
        aStream << iExcPlayLists->MdcaPoint(index);
        }             
    }
Esempio n. 8
0
EXPORT_C void CHeaderFooter::ExternalizeL(RWriteStream& aStream) const
/** Externalises this object's text content and global format layers to a write 
stream. 

The object's components are not externalised. The presence of this function 
means that the standard templated operator<<() (defined in s32strm.h) is available 
to externalise objects of this class.

This function does not store any fields, pictures or rich text-specific formatting, 
so may need to be accompanied by a call to StoreComponentsL().

@param aStream Stream to which the object should be externalised. */
	{
	TUint flags=0x00;
	if (iText) 
		flags |= ETextExists;
	aStream.WriteInt8L(flags);
	aStream.WriteInt32L(iFirstPageToPrintTo);
	// stream the text if it exists
	if (iText)
		{
		aStream<< *iParaLayer;
		aStream<< *iCharLayer;
		aStream<< *iText;
		}
	}
/**
Intended Usage	: Stream out the internal state to aStream.	

Error Condition	: Leave with the error code.
@leave  		KErrNoMemory.
@leave  		@see RWriteStream.
@since			7.0
@param			aClientSide a boolean indicating whether the streaming is to performed in client/server side
@param			aStream The stream to store the data in.
@pre 			CImplementationInformation is fully constructed and initialized
*/
void CImplementationInformation::ExternalizeL(TBool aClientSide,RWriteStream& aStream) const
	{
	aStream.WriteInt32L(iImplementationUid.iUid);
	aStream.WriteInt32L(iVersion);
	if(iDisplayName)
		{
		TPtr outputBuf = iDisplayName->Des();
		aStream.WriteInt32L(outputBuf.Length());
		aStream.WriteL(outputBuf);
		}
	else
		{
		aStream.WriteInt32L(0);
		}

	if(iData)
		{
		TPtr8 outputBuf = iData->Des();
		aStream.WriteInt32L(outputBuf.Length());
		aStream.WriteL(outputBuf);
		}
	else
		{
		aStream.WriteInt32L(0);
		}

	if(iOpaqueData)
		{
		TPtr8 outputBuf = iOpaqueData->Des();
		aStream.WriteInt32L(outputBuf.Length());
		aStream.WriteL(outputBuf);
		}
	else
		{
		aStream.WriteInt32L(0);
		}
	if (aClientSide)
		{
		aStream.WriteInt32L(iDrive);		
		aStream.WriteInt32L(iVid.iId);		
		}
	TInt additionalImplInfo=iRomOnly;
	additionalImplInfo|=iRomBased<<1;
	additionalImplInfo|=iDisabled<<2;
	aStream.WriteInt8L(additionalImplInfo);
	
	if (iExtendedInterfaceList != NULL)
		{
		TInt count = iExtendedInterfaceList->Count();
		aStream.WriteInt32L(count);
		for(TInt i = 0; i < count; ++i)
			{
	   		aStream.WriteInt32L((*iExtendedInterfaceList)[i].iUid);
			}
		}
	else
		{
		aStream.WriteInt32L(KNoneExtendedInterface);
		}
	}
Esempio n. 10
0
// ---------------------------------------------------------------------------
// CLbtGeoHybrid::DoExternalizeL()
//
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
void CLbtGeoHybrid::DoExternalizeL( RWriteStream& aStream ) const
    {
    aStream.WriteInt8L( iHybridArea.Count() );
    for( TInt i=0;i<iHybridArea.Count();i++ )
        {
        CLbtGeoAreaBase::TGeoAreaType areaType= iHybridArea[i]->Type();
        switch( areaType )
            {
            case CLbtGeoAreaBase::ECircle:
                aStream.WriteInt8L(1);
                break;
            case CLbtGeoAreaBase::ERectangular:
                aStream.WriteInt8L(2);
                break;
            case CLbtGeoAreaBase::ECellular:    
                aStream.WriteInt8L(3);
                break;
            }
        iHybridArea[i]->ExternalizeL( aStream );
        }
    }    
Esempio n. 11
0
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
void CWlanSsidList::ExternalizeL(
    RWriteStream& aStream) const
    {
    aStream.WriteInt32L( iSsidList.Count() );
    for( TInt idx( 0 ); idx < iSsidList.Count(); ++idx )
        {
        aStream.WriteInt8L(
            iSsidList[idx].Length() );
        aStream.WriteL(
            iSsidList[idx] );        
        }        
    }
Esempio n. 12
0
EXPORT_C void CEikAlignedControl::WriteInternalStateL(RWriteStream& aWriteStream) const
	{
	_LIT(KEikLitAlignCtlSt,"<CEikAlignedControl>");
	_LIT(KEikLitAlignCtlEnd,"<\\CEikAlignedControl>");
	_LIT(KEikLitAlignCtlMargins,"<iMargin>");
	_LIT(KEikLitAlignCtlMarginsEnd,"<\\iMargin>");
	_LIT(KEikLitAlignCtlAlign,"<iAlignment>");
	_LIT(KEikLitAlignCtlAlignEnd,"<\\iAlignment>");

	aWriteStream << KEikLitAlignCtlSt;
	aWriteStream << KEikLitAlignCtlMargins;
	aWriteStream.WriteInt8L(iMargin.iLeft);
	aWriteStream.WriteInt8L(iMargin.iRight);
	aWriteStream.WriteInt8L(iMargin.iTop);
	aWriteStream.WriteInt8L(iMargin.iBottom);
	aWriteStream << KEikLitAlignCtlMarginsEnd;
	aWriteStream << KEikLitAlignCtlAlign;
	aWriteStream.WriteInt32L((TInt)iAlignment);
	aWriteStream << KEikLitAlignCtlAlignEnd;
	CCoeControl::WriteInternalStateL(aWriteStream);
	aWriteStream << KEikLitAlignCtlEnd;
	}
Esempio n. 13
0
void CBTHidDevice::ExternalizeL(RWriteStream& aStream) const
    {
    // NOTE!! When changing this function, also check DiskSize

    // Write the version number
    aStream.WriteInt32L(KVersionNumber);

    // Write all member variables to the stream.
    // Leave if we get any error
    aStream.WriteL(iAddress.Des());
    aStream.WriteUint32L(iDeviceReleaseNumber);
    aStream.WriteUint32L(iDeviceSubClass);
    aStream.WriteUint32L(iCountryCode);
    aStream.WriteInt8L(iVirtuallyCabled ? 1 : 0);
    aStream.WriteInt8L(iReconnectInit ? 1 : 0);
    aStream.WriteInt8L(iNormallyConnectable ? 1 : 0);
    aStream.WriteUint32L(iProfileVersion);
    aStream.WriteUint32L(iVendorID);
    aStream.WriteUint32L(iProductID);
    aStream.WriteInt8L(iUseSecurity ? 1 : 0);
    aStream << iDeviceName;
    aStream << iDeviceClass;
    aStream << *iDescList;
    }
Esempio n. 14
0
void CNcdNodeFolder::ExternalizeL( RWriteStream& aStream )
    {
    DLTRACEIN(("this: %X, children: %d", this, iChildren.Count() ));

    // First use the parent to externalize the general data
    CNcdNode::ExternalizeL( aStream );

    ExternalizeChildArrayL( aStream );
    
    aStream.WriteInt8L( iChildrenPreviouslyLoaded );
    DLTRACE((_L("node id: %S"), &Identifier().NodeId() ));
    DLTRACE(("wrote iChildrenPreviouslyLoaded: %d",iChildrenPreviouslyLoaded ));

    DLTRACEOUT((""));
    }
// -----------------------------------------------------------------------------
// 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);
    };
Esempio n. 16
0
void CSettingsManager::WriteIndexL(RWriteStream& aStream,
								  const TUid& aUid,
								  TStreamId& aStreamId)
	{
	TBool bNewPlugin = aStreamId.Value();
	TUint8 uchExistingPluginCnt = iControllerCnt;
	//write root index
	aStream << iGenSettingsId;
	
	if(bNewPlugin)
		{
		iControllerCnt++;		
		}
	
	aStream.WriteInt8L(iControllerCnt);
	
	//write the uid-streamid for existing plugins
	for(TUint8 i = 0; i < uchExistingPluginCnt; i++)
		{
		aStream.WriteInt32L(iArrUid[i].iUid); //write uid
		aStream << 	iArrStreamId[i];	 //write streamid
		}
	
	if(!bNewPlugin)
		{
		aStream.CommitL();
		return;	
		}
	
	//write uid-streamId for new plugin
	aStream.WriteInt32L(aUid.iUid); //write uid
	aStream << aStreamId;			//write streamid
		
	iArrUid.AppendL(aUid);
	iArrStreamId.AppendL(aStreamId);	
	aStream.CommitL();		
	}
void TCharacteristicsDll::ExternalizeL(RWriteStream& aStream)
{
    const TCommonCharacteristics* common=reinterpret_cast<const TCommonCharacteristics*>(iCharacteristics);
    switch (common->iInterfaceUID)
    {
    case KHashInterface:
    case KAsyncHashInterface:
    {
        const THashCharacteristics* characteristics=reinterpret_cast<const THashCharacteristics*>(iCharacteristics);
        characteristics->ExternalizeL(aStream);
    }
    break;
    case KRandomInterface:
    case KAsyncRandomInterface:
    {
        const TRandomCharacteristics* characteristics=reinterpret_cast<const TRandomCharacteristics*>(iCharacteristics);
        characteristics->ExternalizeL(aStream);
    }
    break;

    case KSymmetricCipherInterface:
    case KAsyncSymmetricCipherInterface:
    {
        const TSymmetricCipherCharacteristics* characteristics=reinterpret_cast<const TSymmetricCipherCharacteristics*>(iCharacteristics);
        characteristics->ExternalizeL(aStream);
    }
    break;

    case KAsymmetricCipherInterface:
    case KAsyncAsymmetricCipherInterface:
    {
        const TAsymmetricCipherCharacteristics* characteristics=reinterpret_cast<const TAsymmetricCipherCharacteristics*>(iCharacteristics);
        characteristics->ExternalizeL(aStream);
    }
    break;

    case KSignerInterface:
    case KVerifierInterface:
    case KAsyncSignerInterface:
    case KAsyncVerifierInterface:
    {
        const TAsymmetricSignatureCharacteristics* characteristics=reinterpret_cast<const TAsymmetricSignatureCharacteristics*>(iCharacteristics);
        characteristics->ExternalizeL(aStream);
    }
    break;

    case KKeyAgreementInterface:
    case KAsyncKeyAgreementInterface:
    {
        const TKeyAgreementCharacteristics* characteristics=reinterpret_cast<const TKeyAgreementCharacteristics*>(iCharacteristics);
        characteristics->ExternalizeL(aStream);
    }
    break;

    case KKeypairGeneratorInterface:
    case KAsyncKeypairGeneratorInterface:
    {
        const TAsymmetricKeypairGeneratorCharacteristics* characteristics=reinterpret_cast<const TAsymmetricKeypairGeneratorCharacteristics*>(iCharacteristics);
        characteristics->ExternalizeL(aStream);
    }
    break;
#ifdef SYMBIAN_SDP_IPSEC_VOIP_SUPPORT
    case KMacInterface:
    case KAsyncMacInterface:
    {
        const TMacCharacteristics* characteristics=reinterpret_cast<const TMacCharacteristics*>(iCharacteristics);
        characteristics->ExternalizeL(aStream);
    }
    break;
#endif
    default:
        User::Leave(KErrNotSupported);
    }

    aStream.WriteInt8L(iDllIndex);
}
Esempio n. 18
0
// -----------------------------------------------------------------------------
// CGuiEngineAppView::ExternalizeL()
// Externalizes BrushShapeType (write)
// -----------------------------------------------------------------------------
//
void CGuiEngineAppView::ExternalizeL( RWriteStream& aStream ) const
    {
    aStream.WriteInt8L( static_cast<TInt8>( iBrushShapeType ) );
    }
// -----------------------------------------------------------------------------
// CSyncMLFilterProperty::ExternalizeL
// Externalizes filter property.
// -----------------------------------------------------------------------------
EXPORT_C void CSyncMLFilterProperty::ExternalizeL( RWriteStream& aStream ) const
	{
	
	if ( iDisplayName )
		{
		aStream.WriteUint32L( iDisplayName->Length() );
		aStream << iDisplayName->Des();
		}
	else
		{
		aStream.WriteUint32L( 0 );	
		}
	
	// data type for default values
	aStream.WriteInt8L( ( TInt8 )iDataTypeForDefaultValues );
	
	// data type for query value
	aStream.WriteInt8L( ( TInt8 )iDataTypeForQueryValue );
	
	// max text length
	aStream.WriteUint32L( iMaxTextLength );
	
	// default values
	switch( iDataTypeForDefaultValues )
		{
		case ESyncMLDataTypeBool:
		case ESyncMLDataTypeNumber:
			{
			aStream.WriteInt32L( iDefaultValueIntOrBoolList.Count() );
			for ( TInt i = 0; i < iDefaultValueIntOrBoolList.Count(); i++ )
				{
				aStream.WriteInt32L( iDefaultValueIntOrBoolList[i] );
				}
			break;
			}
		case ESyncMLDataTypeTime:	
		case ESyncMLDataTypeDate:
			{
			aStream.WriteInt32L( iDefaultValueDateOrTimeList.Count() );
			for ( TInt i = 0; i < iDefaultValueDateOrTimeList.Count(); i++ )
				{
				aStream.WriteReal64L( 
				                ( iDefaultValueDateOrTimeList[i] )->Int64() );
				}
			break;
			}
			
		case ESyncMLDataTypeText8:
			{
			aStream.WriteInt32L( iDefaultValueText8List.Count() );
			for ( TInt i = 0; i < iDefaultValueText8List.Count(); i++ )
				{
				if ( iDefaultValueText8List[i] )
					{
					aStream.WriteUint32L( 
					                iDefaultValueText8List[i]->Length() );
					aStream << *iDefaultValueText8List[i];
					}
				else
					{
					aStream.WriteInt32L( 0 );
					}
				}
			break;
			}
			
		case ESyncMLDataTypeText16:
			{
			aStream.WriteInt32L( iDefaultValueText16List.Count() );
			for ( TInt i = 0; i < iDefaultValueText16List.Count(); i++ )
				{
				if ( iDefaultValueText16List[i] )
					{
					aStream.WriteUint32L( 
					                iDefaultValueText16List[i]->Length() );
					aStream << *iDefaultValueText16List[i];
					}
				else
					{
					aStream.WriteInt32L( 0 );
					}
				}
			break;
			}
		default:
			{
			aStream.WriteInt32L( 0 );
			break;
			}
		}
		
	// default values and query values
	switch( iDataTypeForQueryValue )
		{
		case ESyncMLDataTypeBool:
		case ESyncMLDataTypeNumber:
			{
			aStream.WriteInt32L( iQueryValueIntOrBool );
			break;
			}
		case ESyncMLDataTypeTime:	
		case ESyncMLDataTypeDate:
			{
			aStream.WriteReal64L( iQueryValueDateOrTime.Int64() );
			break;
			}
			
		case ESyncMLDataTypeText8:
			{
			if ( iQueryValueText8 )
				{
				aStream.WriteUint32L( iQueryValueText8->Length() );
				aStream << iQueryValueText8->Des();
				}	
			else
				{
				aStream.WriteUint32L( 0 );
				}	
			break;
			}
			
		case ESyncMLDataTypeText16:
			{
			if ( iQueryValueText16 )
				{
				aStream.WriteUint32L( iQueryValueText16->Length() );	
				aStream << iQueryValueText16->Des();
				}
			else
				{
				aStream.WriteUint32L( 0 );
				}			
			break;
			}
		default:
			{
			aStream.WriteInt32L( 0 );
			break;
			}
		}
	
	// default value selection
	aStream.WriteInt32L( iDefaultValueSelected.Count() );
	for ( TInt i = 0; i < iDefaultValueSelected.Count(); i++ )
		{
		aStream.WriteInt32L( iDefaultValueSelected[i] );
		}
		
	// can use query value
	aStream.WriteInt8L( iCanUseQueryValue );
	
	// supports multiple selection
	aStream.WriteInt8L( iSupportsMultpleSelection );
	
	// supports empty selection
	aStream.WriteInt8L( iSupportsEmptySelection );
	
	// query value selected
	aStream.WriteInt8L( iQueryValueSelected );
	
	}
// ------------------------------------------------------------------------------------------------
// CSmlDataPropertyParam::ExternalizeL()
// Puts the class contents to the write stream
// ------------------------------------------------------------------------------------------------
EXPORT_C void CSmlDataPropertyParam::ExternalizeL( RWriteStream& aStream ) const
	{
	aStream.WriteInt8L( KVersionValue ); // version
	iField->ExternalizeL( aStream );
	}
Esempio n. 21
0
// -----------------------------------------------------------------------------
// CDRMConstraint::ExternalizeL
// -----------------------------------------------------------------------------
//
EXPORT_C void CDRMConstraint::ExternalizeL( RWriteStream& aStream ) const
    {

    // used for the buffers
    TInt32 dataLength = 0;

    // write the synchronizing marker
    aStream.WriteInt32L( iSyncMark );

    // Write the version number
    aStream.WriteInt32L( iVersion );

    // Write the start time
    WriteInt64L( iStartTime.Int64(), aStream );

    // Write the end time
    WriteInt64L( iEndTime.Int64(), aStream );

    // Write the interval start time
    WriteInt64L( iIntervalStart.Int64(), aStream );

    // Write the interval
    aStream.WriteInt32L( iInterval.Int() );

    // Write the counter
    aStream.WriteInt32L( iCounter );

    // Write the original counter
    aStream.WriteInt32L( iOriginalCounter );

    // Write the timed counter
    aStream.WriteInt32L( iTimedCounter );

    // Write the timed interval
    aStream.WriteInt32L( iTimedInterval.Int() );

    // Write the accumulated time
    aStream.WriteInt32L( iAccumulatedTime.Int() );

    // Write the individual
    dataLength = 0;
    if ( iIndividual.Count() )
        {
        dataLength = CountArrayStoreSize( iIndividual );
        }
    aStream.WriteInt32L( dataLength );

    if ( dataLength )
        {
        WriteArrayToStreamL( aStream, iIndividual );
        }

    // Software Vendor Id
    aStream.WriteInt32L( iVendorId.iUid );

    // Secure Id of the allowed application
    aStream.WriteInt32L( iSecureId.iUid );

    // Active constraints
    aStream.WriteUint32L( iActiveConstraints );

    // Metering info
#ifdef RD_DRM_METERING
    dataLength = 0;
    if ( iDrmMeteringInfo )
        {
        dataLength = sizeof( TTimeIntervalSeconds ) + sizeof( TUint8 );
        }

    aStream.WriteInt32L( dataLength );

    if ( dataLength )
        {
        aStream.WriteInt32L( iDrmMeteringInfo->iGraceTime.Int() );
        aStream.WriteInt8L( iDrmMeteringInfo->iAllowUseWithoutMetering );
        }

#endif

    // Write the system
    dataLength = 0;
    if ( iSystem.Count() )
        {
        dataLength = CountArrayStoreSize( iSystem );
        }

    aStream.WriteInt32L( dataLength );

    if ( dataLength )
        {
        WriteArrayToStreamL( aStream, iSystem );
        }

    // write the original timed counter
    aStream.WriteInt32L( iOriginalTimedCounter );

    // For future use
    aStream.WriteInt32L( 0 );

    };
void TBidirectionalEndOfLineContext::ExternalizeL(RWriteStream& aDest)
	{
	aDest.WriteInt8L(iFirstCategory);
	aDest.WriteInt8L(iFirstStrongCategory);
	}