/**
Initialise this object with the contents of RReadStream aStream
The descriptor contains an externalised version of an object.
This method is typically used to obtain a CProcessInfo object from 
the core dump server.
Any modifications to this method should be synchronised with ExternalizeL().
Also note that the methods used from RReadStream (>> or ReadUint32L) 
can behave differently, especially for descriptors.
@param aStream Stream with streamed object
@see ExternalizeL
@see RReadStream
@pre Call Externalise to obtain the stream containing an externalised 
version of this object.
*/
EXPORT_C void CProcessInfo::InternalizeL( RReadStream & aStream )
	{

	TUint32 idLow = aStream.ReadUint32L(); 

	TUint32 idHigh = aStream.ReadUint32L(); 
	iId = MAKE_TUINT64( idHigh, idLow );

	// Read the number of character elements in the name. 
	TUint32 nameLength = aStream.ReadUint32L(); 

	if( NULL != iName )
		{
		LOG_MSG( " iName != NULL\n" );
		delete iName;
		iName = NULL;
		}

	if ( nameLength > 0 )
		{
		iName  = HBufC::NewL( aStream, nameLength ); 
		}
	else
		{
		iName  = NULL;
		}

	iObserved = static_cast<TBool>(aStream.ReadUint32L());

	iSize = aStream.ReadUint32L() ;
	}
// -----------------------------------------------------------------------------
// TExtensionIntParam::InternalizeL
// -----------------------------------------------------------------------------
//
TExtensionIntParam TExtensionIntParam::InternalizeL(RReadStream& aReadStream)
	{
	TUint32 id = aReadStream.ReadUint32L();
	TUint32 value = aReadStream.ReadUint32L();

	return TExtensionIntParam(id, value);
	}
// ---------------------------------------------------------------------------
// CCmBaseListItem::InternalizeL
// ---------------------------------------------------------------------------
//
EXPORT_C void CCmBaseListItem::InternalizeL( RReadStream& aStream )
    {
    // Content
    delete iPrimaryText;
    iPrimaryText = NULL;

    TInt bufLength = aStream.ReadInt32L();    
    iPrimaryText = HBufC::NewL( aStream, bufLength ); 

    delete iSecondaryText;
    iSecondaryText = NULL;

    bufLength = aStream.ReadInt32L();    
    iSecondaryText = HBufC::NewL( aStream, bufLength );

    delete iPath;
    iPath = NULL;

    bufLength = aStream.ReadInt32L();    
    iPath = HBufC::NewL( aStream, bufLength );    
    iSize = aStream.ReadInt32L();
    iDate = aStream.ReadUint32L();
    iStatus = (TCmListItemStatus)aStream.ReadInt32L();
    iId = aStream.ReadUint32L();
    iRefId = aStream.ReadUint32L();     
    iMediaType = static_cast<TCmMediaType>( aStream.ReadInt32L() );
    }
// -----------------------------------------------------------------------------
void CPresenceCacheBuddyInfo::InternalizeL( RReadStream& aStream )
    {
    iAvailability = (MPresenceBuddyInfo2::TAvailabilityValues)aStream.ReadInt32L( ); 
    
    HBufC* temp  = InternalizeFieldL( aStream );
    iBuddyId = temp;
       
    iIds.ResetAndDestroy();
    iValues.ResetAndDestroy();
    
    HBufC* key = NULL;
    HBufC8* value = NULL;

    // internalize expiry time
    TUint32 time_high = aStream.ReadUint32L();
    TUint32 time_low = aStream.ReadUint32L();
    iExpiryTime = MAKE_TINT64( time_high, time_low );
    
    TInt count = aStream.ReadInt32L( );    
    for ( TInt i=0; i < count; i++ )
        {
        key = InternalizeFieldL( aStream ); 
        
        CleanupStack::PushL( key );
        value = InternalizeField8L( aStream );
        CleanupStack::Pop( key );          
        // This takes ownership anyway.
        SetAnyFieldPtrL( key, value );                       
        }      
    } 
// ----------------------------------------------------------------------------
// CSdpMediaField::DoInternalizeL
// ----------------------------------------------------------------------------
//
void CSdpMediaField::DoInternalizeL(RReadStream& aStream)
{
    RStringF media = iPool.OpenFStringL(GetTokenFromStreamL(aStream));
    CleanupClosePushL(media);
    SetMediaL(media);
    CleanupStack::Pop();//media
    media.Close();
    TUint32 port = aStream.ReadUint32L();
    //SetPortL(aStream.ReadUint32L());
    TUint flag = aStream.ReadUint8L();
    if(flag)
    {
        SetPortCountL(aStream.ReadUint32L());
    }
    RStringF protocol =iPool.OpenFStringL(GetTokenFromStreamL(aStream));
    CleanupClosePushL(protocol);
    SetProtocolL(protocol);
    CleanupStack::Pop();//protocol
    protocol.Close();
    SetPortL(port);
    SetFormatListL(GetTokenFromStreamL(aStream));
    SetInfoL(GetTokenFromStreamL(aStream));
    SdpCodecTemplate<CSdpConnectionField>::InternalizeArrayL(*iConnectionFields,
            aStream);
    SdpCodecTemplate<CSdpBandwidthField>::InternalizeArrayL(*iBandwidthFields,
            aStream);
    if(aStream.ReadUint8L())
    {
        SetKey(CSdpKeyField::InternalizeL(aStream));
    }
    SdpCodecTemplate<CSdpAttributeField>::InternalizeArrayL(*iAttributeFields,
            aStream);
    SdpCodecTemplate<CSdpFmtAttributeField>::InternalizeArrayL(*iFmtAttrFields,
            aStream);
}
void CDeploymentComponentData::ConstructLoadL(RReadStream &aStream)
    {
    TUint32 len(aStream.ReadUint32L() );
    aStream.ReadL(iDataFileName, len);

    len = aStream.ReadUint32L();
    aStream.ReadL(iMimeType, len);
    }
// -----------------------------------------------------------------------------
// TSdpTypedTime::InternalizeL
// Internalizes typed time from stream
// -----------------------------------------------------------------------------
//
TSdpTypedTime TSdpTypedTime::InternalizeL(RReadStream& aStream)
    {
    TUint32 high = aStream.ReadUint32L();
    TUint32 low = aStream.ReadUint32L();
    TInt64 value = MAKE_TINT64( high, low );
    TUnit unit = static_cast<TUnit>(aStream.ReadInt16L());
    TSdpTypedTime typedTime(value, unit);
    return typedTime;
    }
// -----------------------------------------------------------------------------
// CMceComRtpSource::InternalizeFlatL
// -----------------------------------------------------------------------------
//
void CMceComRtpSource::InternalizeFlatL( RReadStream& aReadStream )
    {
    CMceComMediaSource::InternalizeFlatL( aReadStream );
    
    iInactivityTimer = aReadStream.ReadUint32L();
	iBufferLength = aReadStream.ReadUint32L();
	iBufferTreshold = aReadStream.ReadUint32L();
    MceSerial::DecodeL( iTalkBurstIndicator, aReadStream ); 
    MceSerial::DecodeL( iIdentity, aReadStream ); 
    }
// -----------------------------------------------------------------------------
// CHttpCacheEntry::InternalizeL
//
// -----------------------------------------------------------------------------
//
void CHttpCacheEntry::InternalizeL( RReadStream& aReadStream, const TDesC& aDirectory )
    {
    // url length
    TInt len;
    len = aReadStream.ReadInt32L();
    delete iUrl;
    iUrl=NULL;
    iUrl = HBufC8::NewL( len );
    TPtr8 ptr8( iUrl->Des() );
    // url
    aReadStream.ReadL( ptr8, len );

    // calculate full path and filename length
    // aDirectory/ + "x/xxxxxxxx" : note aDirectory has trailing '/'
    len = aDirectory.Length() + KSubdirNameLength + KFilenameLength;
    HBufC* filename = HBufC::NewLC( len );
    TPtr ptr( filename->Des() );

    // Read max char length of filename.
    // NOTE: The filename and filename length is calculated by the code in
    // HttpCacheUtil::GenerateNameLC. The sub directory is the same as the
    // last char of the filename, e.g. ..\A\0123DCBA
    TBuf<KFilenameLength> uniqueFilename;
    aReadStream.ReadL( uniqueFilename , KFilenameLength );
    TPtrC uniqueSubDir = uniqueFilename.Right(1);

    // assemble path and filename
    ptr.Format(_L("%S%S\\%S"), &aDirectory, &uniqueSubDir, &uniqueFilename);
    //
    SetFileNameL( filename->Des() );
    //
    CleanupStack::PopAndDestroy(); // filename
    // la
    TReal64 la;
    la = aReadStream.ReadReal64L();
    iLastAccessed = la;
    // ref
    iRef = aReadStream.ReadUint32L();
    // size
    iBodySize = aReadStream.ReadUint32L( );
    // size
    iHeaderSize = aReadStream.ReadUint32L( );
    // protected
    iProtected = aReadStream.ReadInt32L();
    // header data
    delete iHeaderBuffer;
    iHeaderBuffer = NULL;
    len = aReadStream.ReadInt32L();
    iHeaderBuffer = HBufC8::NewL(len);
    TPtr8 header_ptr( iHeaderBuffer->Des() );
    aReadStream.ReadL( header_ptr, len );
    //
    SetState( ECacheComplete );
    }
// ---------------------------------------------------------------------------
// ?description_if_needed
// ---------------------------------------------------------------------------
//
EXPORT_C void CXIMPTestFileSrvMsg::InternalizeL( RReadStream& aStream )
    {
    iSrvMsgId = aStream.ReadUint32L();
    TInt len = aStream.ReadUint32L();

    HBufC8* buffer = HBufC8::NewLC( len );
    TPtr8 ptr = buffer->Des();
    aStream.ReadL( ptr, len );

    delete iPayload;
    CleanupStack::Pop( buffer );
    iPayload = buffer;   
    }
EXPORT_C void CSDClientResultSet::InternalizeL(RReadStream& aStream)
	{
	iResultArray.ResetAndDestroy();
	iMaxResults = aStream.ReadUint32L();
	iResultCount = aStream.ReadUint32L();
	for (TInt i=0;i<iMaxResults;i++)
		{
		CSDClientResult* clientResult = CSDClientResult::NewLC();
		clientResult->InternalizeL(aStream);
		User::LeaveIfError(iResultArray.Append(clientResult));
		CleanupStack::Pop(clientResult);
		}
	}
EXPORT_C void TImEmailTransformingInfo::InternalizeL( RReadStream& aReadStream )
	{
	SetSendMethod( static_cast<TImSendMethod> (aReadStream.ReadUint8L()) );

	SetHeaderEncoding( static_cast<TImEncodingType> (aReadStream.ReadUint8L()));
	iBodyEncoding= static_cast<TImEncodingType> (aReadStream.ReadUint8L());
	SetHTMLEncoding(  static_cast<TImEncodingType> (aReadStream.ReadUint8L()) );
	SetAttachmentEncoding(  static_cast<TImEncodingType> (aReadStream.ReadUint8L()) );

	SetHeaderCharset( aReadStream.ReadUint32L());
	SetBodyTextCharset( aReadStream.ReadUint32L());
	SetHTMLCharset( aReadStream.ReadUint32L());
	}
// --------------------------------------------------------------------------- --
// CDRMEventModify::Internalize
// Reads the data of the object from the given stream
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
EXPORT_C void CDRMEventModify::InternalizeL(
    RReadStream& aInput) 
    {
    TInt inputLength = 0;

    MDRMEvent::InternalizeL(aInput);

    // Read the length of the HBufC8*
    inputLength = aInput.ReadInt32L();

    // Reserve the HBufC8*
    if( !iContentID )
        {
        iContentID = HBufC8::NewL(inputLength);
        }
    else 
        {
        iContentID->ReAllocL(inputLength);
        }

    // Read the HBufC8*
    TPtr8 inRead(iContentID->Des());
    aInput.ReadL(inRead,inputLength); 

    // this implementation may need to be changed if the size of the enum changes
    iUniqueID = aInput.ReadUint32L();
    };
// ---------------------------------------------------------------------------
// ?implementation_description
// ---------------------------------------------------------------------------
//
void TNcdSendableProgress::InternalizeL( RReadStream& aStream )
    {
    iState = aStream.ReadUint32L();
    iOperationId = aStream.ReadInt32L();
    iProgress = aStream.ReadInt32L();
    iMaxProgress = aStream.ReadInt32L();
    }
EXPORT_C void CPromptData::InternalizeL(RReadStream& aStream)
/**
 Internalizes the prompt data from the specified stream/
 @param aStream The read stream
*/
	{
	Reset();
	iClientName.CreateL(aStream, KMaskDesLength16);
	iVendorName.CreateL(aStream, KMaskDesLength16);
	aStream >> iClientSid.iId;
	aStream >> iServerSid.iId;
	aStream >> iServiceId.iUid;
	iDestination.CreateL(aStream, KMaskDesLength16);
	iOpaqueData.CreateL(aStream, KMaskDesLength8);
	
	TInt32 count = aStream.ReadUint32L();
		
	for (TInt i = 0; i < count; ++i)
		{
		TInt32 l = aStream.ReadInt32L();
		HBufC* d = HBufC::NewMaxLC(l);
		TPtr wptr = d->Des();
		aStream.ReadL(wptr, l);
		iDescriptions.AppendL(d);
		CleanupStack::Pop(d);
		}
	aStream >> iOptions;
	aStream >> iFlags;
	}
// ------------------------------------------------------------------------------------------------
// CNSmlDPInformation::InternalizeL
// ------------------------------------------------------------------------------------------------
EXPORT_C void CNSmlDPInformation::InternalizeL( RReadStream& aStream )
	{
	TPckg<TSmlDataProviderId> id( iInfo->iId );
	aStream.ReadL( id );
	
	iInfo->iVersion.iMajor = aStream.ReadInt32L();
	iInfo->iVersion.iMinor = aStream.ReadInt32L();
	iInfo->iVersion.iBuild = aStream.ReadInt32L();
	
	iInfo->iProtocolVer = static_cast<TSmlProtocolVersion>( aStream.ReadInt32L() );
	
	delete iInfo->iDisplayName;
	iInfo->iDisplayName = NULL;
	iInfo->iDisplayName = HBufC::NewL( aStream, aStream.ReadUint32L() );
	
	delete iInfo->iMimeTypes;
	iInfo->iMimeTypes = NULL;
	TInt mimetypesCount = aStream.ReadUint32L();
	CDesC8Array* mimetypes = new (ELeave) CDesC8ArrayFlat( Max<TInt>( 2, mimetypesCount ) );
	CleanupStack::PushL( mimetypes );
	
	for (TInt i = 0 ; i < mimetypesCount; i++ )
		{
		HBufC8* tempBuf8 = HBufC8::NewLC( aStream, aStream.ReadUint32L() );
		mimetypes->AppendL( *tempBuf8 );
		CleanupStack::PopAndDestroy(); // tempBuf8
		}
	
	delete iInfo->iMimeVersions;
	iInfo->iMimeVersions = NULL;
	TInt mimeversCount = aStream.ReadUint32L();
	CDesC8Array* mimevers = new (ELeave) CDesC8ArrayFlat( Max<TInt>( 2, mimeversCount ) );
	CleanupStack::PushL( mimevers );
	
	for (TInt i = 0 ; i < mimeversCount; i++ )
		{
		HBufC8* tempBuf8 = HBufC8::NewLC( aStream, aStream.ReadUint32L() );
		mimevers->AppendL( *tempBuf8 );
		CleanupStack::PopAndDestroy(); // tempBuf8
		}
		
	iInfo->iMimeTypes = mimetypes;
	iInfo->iMimeVersions = mimevers;
	
	CleanupStack::Pop(2); // mimetypes, mimevers
	}
Beispiel #17
0
EXPORT_C void CLogEvent::InternalizeL(RReadStream& aStream)
	{
	iId = (TLogId) aStream.ReadInt32L();
	iEventType.iUid = aStream.ReadInt32L();

	TInt64 time; 
	aStream >> time;
	iTime = time;

	iDurationType = (TLogDurationType) aStream.ReadInt8L();
	iDuration = (TLogDuration) aStream.ReadUint32L();
	iContact = (TLogContactItemId ) aStream.ReadInt32L();
	iLink = (TLogLink) aStream.ReadUint32L();
	iFlags = (TLogFlags) aStream.ReadUint8L();

	InternalizeBufL(aStream, iDescription);
	InternalizeBufL(aStream, iRemoteParty);
	InternalizeBufL(aStream, iDirection);
	InternalizeBufL(aStream, iStatus);
	InternalizeBufL(aStream, iSubject);
	InternalizeBufL(aStream, iNumber);

	TInt dataLen = aStream.ReadInt32L();
#ifdef SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM
	TUint dataVersion = 0;
	if(dataLen < 0)
		{
		//This is CLogEvent data version with dual SIM support.
		//The next property is the data length.
		dataVersion = (TUint)dataLen;
		dataLen = aStream.ReadInt32L();
		}
#endif
	HBufC8* temp = NULL;
	if(dataLen != 0)
		{
		temp = HBufC8::NewL(aStream, dataLen);
		}
	delete iData;
	iData = temp;
	
#ifdef SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM
	if(dataVersion >= KLogEventDataVersion)
		{
		aStream >> iSimId;
		}
void CClassA::InternalizeL(RReadStream& aStream)
	{
	TInt maxlen;
	maxlen     = aStream.ReadInt32L();
	iVarBuffer = HBufC::NewL(aStream,maxlen);
	iIntValue  = aStream.ReadInt32L();
	iUintValue = aStream.ReadUint32L();
	}  
// CAgnAttachmentIndex //
void CAgnAttachmentIndex::InternalizeL(RReadStream& aReadStream)
	{
	TUint32 count = aReadStream.ReadUint32L();
	for (TUint32 i=0; i < count; ++i)
		{
		CAgnAttachmentIndexItem* item = CAgnAttachmentIndexItem::NewL(aReadStream);
		iIndex.Append(item);
		}
	}
// ---------------------------------------------------------------------------
// CCaInnerIconDescription::InternalizeL
// ---------------------------------------------------------------------------
//
void CCaInnerIconDescription::InternalizeL( RReadStream& aStream )
    {
    iId = aStream.ReadInt32L();
    
    TUint length = aStream.ReadUint32L();
    iFileName.Close();
    iFileName.CreateL( length );
    aStream.ReadL( iFileName, length );

    length = aStream.ReadUint32L();
    iSkinId.Close();
    iSkinId.CreateL( length );
    aStream.ReadL( iSkinId, length );
    
    length = aStream.ReadUint32L();
    iApplicationId.Close();
    iApplicationId.CreateL( length );
    aStream.ReadL( iApplicationId, length );
    }
// -----------------------------------------------------------------------------
// CSIPParamContainerBase::DoInternalizeL
// -----------------------------------------------------------------------------
//
void CSIPParamContainerBase::DoInternalizeL (RReadStream& aReadStream)
	{
	TUint32 parameterCount = aReadStream.ReadUint32L();
	for (TUint32 i=0; i < parameterCount; i++)
		{
		CSIPParam* param = CSIPParam::InternalizeL(aReadStream);
		CleanupStack::PushL (param);
		SetParamL(param);
		CleanupStack::Pop(param);
		}
	}
void CAgnAttachmentIndexItem::InternalizeL(RReadStream& aReadStream)
	{
	iSize = aReadStream.ReadInt32L();
	
	TInt64 time64;
	aReadStream >> time64;
	TTime temptime(time64);
	iLastModifiedDateUtc = temptime;
	
	iFileName = HBufC::NewL(aReadStream, KMaxTInt);
	
	TUint32 count = aReadStream.ReadUint32L();
	for (TUint32 i = 0; i < count; ++i)
		{
		TCalLocalUid localid = static_cast<TCalLocalUid>(aReadStream.ReadUint32L());
		iEntries.Append(localid);
		}
		
	iUid = static_cast<TCalAttachmentUid>(aReadStream.ReadUint32L());
	}
// ---------------------------------------------------------------------------
// CAccPolHdmiAudioFormat::InternalizeL()
// ---------------------------------------------------------------------------
//
void CAccPolHdmiAudioFormat::InternalizeL( RReadStream& aStream )
    {
    API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiAudioFormat::InternalizeL() - Enter" );

    iAudioFormat.iUid = aStream.ReadInt32L();
    iMaxChannelCount = aStream.ReadUint32L();
    iBitResolution = aStream.ReadUint32L();
    iMaxBitResolution = aStream.ReadUint32L();
    iSamFreq = aStream.ReadUint32L();
    iFormateDependentValue = aStream.ReadUint32L();

    API_TRACE_1( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiAudioFormat::InternalizeL - Object Type            = %d", ObjectType() );
    API_TRACE_1( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiAudioFormat::InternalizeL - AudioFormat Uid        = %d", iAudioFormat.iUid );
    API_TRACE_1( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiAudioFormat::InternalizeL - Channel Count          = %d", iMaxChannelCount );
    API_TRACE_1( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiAudioFormat::InternalizeL - Bit Resolution         = %d", iBitResolution );
    API_TRACE_1( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiAudioFormat::InternalizeL - Maximum Bit Resolution = %d", iMaxBitResolution );
    API_TRACE_1( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiAudioFormat::InternalizeL - Sam Freq               = %d", iSamFreq );
    API_TRACE_1( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiAudioFormat::InternalizeL - Format Dependent Value = %d", iFormateDependentValue );

    API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiAudioFormat::InternalizeL - Return" );
    }
Beispiel #24
0
// ----------------------------------------------------------------------------
// Internalize an array of item ids from stream
// ----------------------------------------------------------------------------
//
EXPORT_C void MPXUser::InternalizeL(RArray<TMPXItemId>& aArray, RReadStream& aStream)
    {
    CleanupClosePushL(aArray);
    TInt n=aStream.ReadInt32L();
    for (TInt i=0;i<n;++i)
        {
        TUint32 id1(aStream.ReadUint32L());
        TUint32 id2(aStream.ReadUint32L());
        aArray.AppendL(TMPXItemId(id1,id2));
        }
    CleanupStack::Pop();
    }
/**
Configures the BIC using data contained in a ReadStream
 
@param aReadStream 	A read stream containing BIC data
*/
void CCmdPublishSwp::InternalizeL(RReadStream& aReadStream)
	{
	iSeverity = static_cast<TCmdErrorSeverity>(aReadStream.ReadInt16L());
	iExecutionBehaviour = static_cast<TSsmExecutionBehaviour>(aReadStream.ReadUint8L());
	const TUint key = aReadStream.ReadUint32L();
	const TInt value = aReadStream.ReadInt32L();	
#ifdef SYMBIAN_SSM_FLEXIBLE_MERGE
	iPriority = aReadStream.ReadUint16L();
#endif
	TSsmSwp swpInfo(key, value);
	iSwpInfo = swpInfo;
	}
void CBTHidDevice::InternalizeL(RReadStream& aStream)
    {
    // Read the version number
    // Ignored in this version.
    aStream.ReadInt32L();

    // Read all member variables from the stream
    // Leave if we get any error

    // Get a pointer to the address to fill
    TPtr8 addr = iAddress.Des();
    // Read the address in
    aStream.ReadL(addr);

    iDeviceReleaseNumber = aStream.ReadUint32L();
    iDeviceSubClass = aStream.ReadUint32L();
    iCountryCode = aStream.ReadUint32L();
    iVirtuallyCabled = aStream.ReadInt8L();
    iReconnectInit = aStream.ReadInt8L();
    iNormallyConnectable = aStream.ReadInt8L();
    iProfileVersion = aStream.ReadUint32L();
    iVendorID = aStream.ReadUint32L();
    iProductID = aStream.ReadUint32L();
    iUseSecurity = aStream.ReadInt8L();
    aStream >> iDeviceName;
    aStream >> iDeviceClass;
    aStream >> *iDescList;
    }
// -----------------------------------------------------------------------------
// CSIPMessage::ReadFromStreamL
// -----------------------------------------------------------------------------
//
RStringF CSIPMessage::ReadFromStreamL (RReadStream& aReadStream) const
	{
	TUint32 bufLength = aReadStream.ReadUint32L();
	HBufC8* buf = HBufC8::NewLC (bufLength);
	TPtr8 bufPtr(buf->Des());	
	if (bufLength > 0)
		{
		aReadStream.ReadL (bufPtr,bufLength);
		}
	RStringF str = SIPStrings::Pool().OpenFStringL(bufPtr);
	CleanupStack::PopAndDestroy(buf);	
	return str;
	}
EXPORT_C void CSisRegistryFileDescription::InternalizeL(RReadStream& aStream)
	{
	iTarget = HBufC::NewL(aStream, KMaxFileName);
	iMimeType = HBufC::NewL(aStream, KMaxTInt);
	iOperation = static_cast<Sis::TSISFileOperation>(aStream.ReadInt32L());
	iOperationOptions = static_cast<Sis::TSISFileOperationOptions>(aStream.ReadInt32L());
	iHash = CHashContainer::NewL(aStream);
	TInt32 low = aStream.ReadInt32L();
	TInt32 high = aStream.ReadInt32L();
	iUncompressedLength = MAKE_TINT64(high, low);
	iIndex = aStream.ReadUint32L();
	iSid.iUid = aStream.ReadInt32L();
	}
void CAgnAttachment::InternalizeL(RReadStream& aStream)
	{
	// don't read in type as assume already read
	HBufC8* mimeType = HBufC8::NewL(aStream, KCalAttachmentMaxMimeTypeLength);
	SetMimeType(mimeType);
	iUid = aStream.ReadUint32L();
	iAttributes = static_cast<CCalAttachment::TAttributes>(aStream.ReadUint16L());
	iFlags = aStream.ReadUint16L();
	iSize = aStream.ReadInt32L();
	delete iLabel;
	iLabel = NULL;
	iLabel = HBufC::NewL(aStream, KCalAttachmentMaxLabelLength);
	}
Beispiel #30
0
//
// Internalize the index statistics
// This must handle a stream externalized by builds before 052
//
void TDbStoreIndexStats::InternalizeL(RReadStream& aStream)
	{
	TCardinality c;
	aStream>>c;
	iCardinality=c;
	TUint refresh=aStream.ReadUint32L();
	iFlags=refresh&EFlagsMask;
	iRefresh=TInt(refresh>>ERefreshShift)+EInvalid;
//
// pre-build-052 data would run out here
// if there is no more data, mark the (non-cardinality) stats as invalid
//
	TRAPD(r,aStream>>iLower.iValue>>iUpper.iValue;)
	if (r==KErrEof)