// ---------------------------------------------------------------------------
// 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();
}
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 );
}
}
// ---------------------------------------------------------------------------
// 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);
}
}
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);
}
}
// ---------------------------------------------------------------------------
// 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 );
}
}
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
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] );
}
}
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;
}
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;
}
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);
};
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);
}
// -----------------------------------------------------------------------------
// 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 );
}
// -----------------------------------------------------------------------------
// 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);
}
