/**
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
}
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" );
}
// ----------------------------------------------------------------------------
// 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);
}
//
// 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)
