// Copyright (c) 1998-2009 Nokia Corporation and/or its subsidiary(-ies).

 // All rights reserved.

 // This component and the accompanying materials are made available

 // under the terms of "Eclipse Public License v1.0"

 // which accompanies this distribution, and is available

 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

 //

 // Initial Contributors:

 // Nokia Corporation - initial contribution.

 //

 // Contributors:

 //

 // Description:

 //

 #include "US_STD.H"

 // Class CDbStoreRecords::TIteratorC

 class CDbStoreRecords::TIteratorC

 	{

 	friend class CDbStoreRecords;

 public:

 	inline TDbRecordId Current() const;

 private:

 	TClusterDes iDes;

 	TDbRecordId iCurrent;

 	};

 inline TDbRecordId CDbStoreRecords::TIteratorC::Current() const

 	{return iCurrent;}

 // Class CDbStoreRecords::CIter

 NONSHARABLE_CLASS(CDbStoreRecords::CIter) : public CDbRecordIter

 	{

 public:

 	CIter(CDbStoreRecords& aRecords);

 private:

 	inline CDbStoreRecords& Records() const;

 //

 	TInt Count() const;

 	TDbRecordId CurrentL();

 	TBool GotoL(TDbPosition aPosition);

 	TBool GotoL(TDbRecordId aRecordId,RDbTableRow& aBuffer);

 	TBool SeekL(const TDbLookupKey& aKey,RDbTable::TComparison aComparison);

 	TDeleted DoDeletedL(TDbPosition aPosition,TDbRecordId aRecordId,const RDbTableRow* aRow);

 private:

 	CDbStoreRecords::TIteratorC iIter;

 	};

 CDbStoreRecords::CIter::CIter(CDbStoreRecords& aRecords)

 	: CDbRecordIter(aRecords)

 	{}

 inline CDbStoreRecords& CDbStoreRecords::CIter::Records() const

 	{return STATIC_CAST(CDbStoreRecords&,Host());}

 TInt CDbStoreRecords::CIter::Count() const

 	{

 	return Records().Count();

 	}

 TDbRecordId CDbStoreRecords::CIter::CurrentL()

 	{

 	return iIter.Current();

 	}

 TBool CDbStoreRecords::CIter::GotoL(TDbPosition aPosition)

 	{

 	return Records().GotoL(aPosition,iIter);

 	}

 TBool CDbStoreRecords::CIter::GotoL(TDbRecordId aRecordId,RDbTableRow&)

 	{

 	return Records().GotoL(aRecordId,iIter);

 	}

 TBool CDbStoreRecords::CIter::SeekL(const TDbLookupKey&,RDbTable::TComparison)

 //

 // Cannot do this on a table iterator

 //

 	{

 	Panic(EDbCannotSeek);

 	return EFalse;

 	}

 CDbStoreRecords::CIter::TDeleted CDbStoreRecords::CIter::DoDeletedL(TDbPosition aPosition,TDbRecordId,const RDbTableRow*)

 //

 // reposition to next after a record is deleted

 // Previous only required for reversed (index) iterators

 //

 	{

 	return Records().DeletedL(aPosition,iIter) ? EAtRow : ENoRow;

 	}

 // Class CDbStoreRecords::TToken

 void CDbStoreRecords::TToken::ExternalizeL(RWriteStream& aStream) const

 	{

 	aStream<<iHead<<iNext.Value()<<TCardinality(iCount)<<TUint32(iAutoIncrement);

 	}

 void CDbStoreRecords::TToken::InternalizeL(RReadStream& aStream)

 	{

 	aStream>>iHead;

 	iNext=aStream.ReadUint32L();

 	TCardinality card;

 	aStream>>card;

 	iCount=card;

 	iAutoIncrement=aStream.ReadUint32L();

 	}

 // Class CDbStoreRecords

 CDbStoreRecords::CDbStoreRecords(CClusterCache& aCache)

 	: iCache(aCache)

 	{}

 CDbStoreRecords::~CDbStoreRecords()

 	{

 	iMap.Close();

 	}

 TStreamId CDbStoreRecords::CreateL(CClusterCache& aCache)

 //

 // Create a new record space in the store, do not create a records object

 //

 	{

 	TToken token;

 	token.iHead=ClusterId(aCache.Store().ExtendL());

 	aCache.ClusterL().Create(token.iHead);

 	token.iNext=RecordId(token.iHead,0);

 	token.iCount=0;

 	token.iAutoIncrement=0;

 	RStoreWriteStream strm;

 	TStreamId id=strm.CreateLC(aCache.Store());

 	strm<<token;

 	strm.CommitL();

 	CleanupStack::PopAndDestroy();

 	return id;

 	}

 CDbStoreRecords* CDbStoreRecords::NewL(CClusterCache& aCache,const CDbStoreDef& aDef)

 //

 // Create a record space

 //

 	{

 	CDbStoreRecords* self=new(ELeave) CDbStoreRecords(aCache);

 	CleanupStack::PushL(self);

 	self->iClustering=aDef.Clustering();

 	self->iTokenId=aDef.TokenId();

 	CleanupStack::Pop();

 	return self;

 	}

 TBool CDbStoreRecords::RestoreL()

 //

 // Restore an existing record space from the store

 //

 	{

 	RStoreReadStream strm;

 	strm.OpenLC(iCache.Store(),iTokenId);

 	strm>>iToken;

 	CleanupStack::PopAndDestroy();

 	iLinks.Invalidate();

 	iMap.ResetL(iToken.iHead);

 	return EFalse;

 	}

 void CDbStoreRecords::DestroyL()

 //

 // Destroy the record space

 //

 	{

 	iCache.Store().DeleteL(iTokenId);

 	}

 TInt CDbStoreRecords::CardinalityL(CStreamStore& aStore,const CDbStoreDef& aDef)

 //

 // Return the record count without constructing the entire table

 //

 	{

 	RStoreReadStream strm;

 	strm.OpenLC(aStore,aDef.TokenId());

 	TToken token;

 	strm>>token;

 	CleanupStack::PopAndDestroy();

 	return token.iCount;

 	}

 void CDbStoreRecords::SynchL()

 //

 // write persistent token to the store

 //

 	{

 	RStoreWriteStream strm;

 	strm.ReplaceLC(iCache.Store(),iTokenId);

 	strm<<iToken;

 	strm.CommitL();

 	CleanupStack::PopAndDestroy();

 	}

 TInt CDbStoreRecords::DiscardL(TClusterId& aCluster)

 //

 // discard the cluster as part of the incremental drop

 // aCluster is updated to the next cluster, the number of records contained is returned

 //

 	{

 	TClusterDes des;

 	DesL(des,aCluster);

 	CCluster* cluster=iCache.Cluster(aCluster);

 	if (cluster)

 		cluster->Discard();

 	iCache.Store().DeleteL(aCluster);

 	aCluster=des.iNext;

 	TInt records=0;

 	for (TUint members=des.iMembership;members;members&=members-1)

 		++records;

 	return records;

 	}

 TClusterId CDbStoreRecords::AlterL(TClusterId aCluster,CCluster::MAlter& aAlterer)

 	{

 	CCluster& cluster=iCache.ClusterL(aCluster);

 	cluster.AlterL(aAlterer);

 	return cluster.Des().iNext;

 	}

 TPtrC8 CDbStoreRecords::ReadL(TDbRecordId aRecordId) const

 	{

 	return iCache.ClusterL(ClusterId(aRecordId)).RecordL(RecordIndex(aRecordId));

 	}

 TUint CDbStoreRecords::AutoIncrementL()

 //

 // Provide the next value for an auto-increment column

 //

 	{

 	return iToken.iAutoIncrement++;

 	}

 TUint8* CDbStoreRecords::UpdateRecordL(TDbRecordId aRecordId,TInt aNewSize)

 //

 // read the cluster and return a writable descriptor over the new record data

 //

 	{

 	return iCache.ClusterL(ClusterId(aRecordId)).UpdateL(RecordIndex(aRecordId),aNewSize);

 	}

 TUint8* CDbStoreRecords::DoNewL(TInt aRecordSize)

 //

 // Phase 1 of appending a records

 //

 	{

 	return UpdateRecordL(iToken.iNext,aRecordSize);

 	}

 TDbRecordId CDbStoreRecords::AppendL()

 //

 // Phase 2 of appending a record

 //

 	{

 	TDbRecordId id=iToken.iNext;

 	TClusterId clusterId=ClusterId(id);

 	CCluster* cluster=iCache.Cluster(clusterId);

 	__ASSERT(cluster);

 	TInt nextIndex=RecordIndex(id)+1;

 	if (nextIndex>=iClustering || cluster->IsFull())

 		{

 		TClusterId newcluster=ClusterId(iCache.Store().ExtendL());

 		cluster->Relink(newcluster);

 		cluster->FlushL();

 		cluster->Create(newcluster);

 		iMap.BindL(clusterId,newcluster);

 		iLinks.Bind(clusterId,newcluster,iMap);

 		iToken.iNext=RecordId(newcluster,0);

 		}

 	else

 		iToken.iNext=RecordId(clusterId,nextIndex);

 	++iToken.iCount;

 	return id;

 	}

 TUint8* CDbStoreRecords::DoReplaceL(TDbRecordId aRecordId,TInt aRecordSize)

 	{

 	return UpdateRecordL(aRecordId,aRecordSize);

 	}

 void CDbStoreRecords::DoEraseL(TDbRecordId aRecordId)

 	{

 	TClusterId clusterId=ClusterId(aRecordId);

 	CCluster& cluster=iCache.ClusterL(clusterId);

 	if (!cluster.DeleteL(RecordIndex(aRecordId)) && clusterId!=ClusterId(iToken.iNext))

 		{	// cluster is now empty, but don't drop the last cluster, coz it hasn't all been used!

 		TClusterDes des;

 		TClusterId prev=PreviousClusterL(des,clusterId);

 		TClusterId next=cluster.Des().iNext;	// next cluster

 		cluster.Discard();						// discard the cluster

 		iCache.Store().DeleteL(clusterId);

 		if (prev!=KNullClusterId)

 			iCache.ClusterL(prev).Relink(next);

 		else

 			iToken.iHead=next;

 		iLinks.Drop(clusterId,next);

 		iMap.DropL(clusterId,next);

 		}

 	--iToken.iCount;

 	}

 CDbRecordIter* CDbStoreRecords::IteratorL()

 	{

 	return new(ELeave) CIter(*this);

 	}

 void CDbStoreRecords::CompleteMapL()

 	{

 	TClusterId cluster=iMap.LastBound();

 	TClusterDes des;

 	DesL(des,cluster);

 	do cluster=NextClusterL(des,cluster); while (cluster!=KNullClusterId);

 	}

 void CDbStoreRecords::DesL(TClusterDes& aDes,TClusterId aCluster)

 //

 // Read just the cluster descriptor

 //

 	{

 	CCluster* cluster=iCache.Cluster(aCluster);

 	if (cluster)

 		aDes=cluster->Des();

 	else

 		{

 		RStoreReadStream stream;

 		stream.OpenLC(iCache.Store(),aCluster);

 		stream>>aDes;

 		CleanupStack::PopAndDestroy();

 		}

 	}

 TClusterId CDbStoreRecords::NextClusterL(TClusterDes& aDes,TClusterId aCluster)

 	{

 	TClusterId next=aDes.iNext;

 	if (next==KNullClusterId)

 		iMap.Complete(aCluster);

 	else

 		{

 		iMap.BindL(aCluster,next);

 		iLinks.Bind(aCluster,next,iMap);

 		DesL(aDes,next);

 		}

 	return next;

 	}

 TBool CDbStoreRecords::LocateL(TClusterId aCluster)

 //

 // Locate the cluster in the table. If not present return EFalse

 // If present fill up the cluster link cache with the loop

 // containing the predecessor to aCluster

 // aDes will have the previous cluster des

 //

 	{

 	TClusterId cluster=aCluster;

 	__ASSERT(aCluster!=iToken.iHead);

 	__ASSERT(!iLinks.At(aCluster,cluster));

 //

 	if (!iMap.IsComplete())

 		CompleteMapL();

 //

 	TClusterDes des;

 	TClusterId links[RClusterMap::ESeparation];

 	TClusterId* p=links;

 	for (TInt n=RClusterMap::ESeparation;n>0;--n)

 		{

 		*p++=cluster;

 		TBool r=iMap.At(cluster,cluster);

 		DesL(des,cluster);

 		if (r)

 			{

 			__ASSERT(cluster!=KNullClusterId);	// only iHead->Null

 			iLinks.Reset(cluster);

 			while (aCluster!=des.iNext)

 				cluster=NextClusterL(des,cluster);

 			iLinks.Add(links,p);

 			return ETrue;

 			}

 		cluster=des.iNext;

 		}

 	return EFalse;	// not in this table!

 	}

 TClusterId CDbStoreRecords::PreviousClusterL(TClusterDes& aDes,TClusterId aCluster)

 	{

 	if (aCluster==iToken.iHead)

 		return KNullClusterId;

 	if (!iLinks.At(aCluster,aCluster))

 		{

 		__DEBUG(TBool dbgchk=) LocateL(aCluster);

 		__ASSERT(dbgchk);

 		__DEBUG(dbgchk=) iLinks.At(aCluster,aCluster);

 		__ASSERT(dbgchk);

 		}

 	DesL(aDes,aCluster);

 	return aCluster;

 	}

 TBool CDbStoreRecords::GotoL(TDbPosition aPosition,TIteratorC& anIterator)

 	{

 	TClusterId cluster=ClusterId(anIterator.iCurrent);

 	TInt index=RecordIndex(anIterator.iCurrent);

 	switch (aPosition)

 		{

 	default:

 		__ASSERT(0);

 	case EDbFirst:

 		DesL(anIterator.iDes,cluster=iToken.iHead);

 		iLinks.Reset(cluster);

 		index=-1;

 		// drop through to next

 	case EDbNext:

 		for (;;)

 			{

 			TUint membership=anIterator.iDes.iMembership;

 			while (++index<KMaxClustering)

 				{

 				if ((membership>>index)&1)

 					{

 					__ASSERT(cluster!=ClusterId(iToken.iNext)||index<RecordIndex(iToken.iNext));

 					anIterator.iCurrent=RecordId(cluster,index);

 					return ETrue;

 					}

 				}

 			cluster=NextClusterL(anIterator.iDes,cluster);

 			if (cluster==KNullClusterId)

 				return EFalse;	// ran out of data

 			index=-1;

 			}

 	case EDbLast:

 		DesL(anIterator.iDes,cluster=ClusterId(iToken.iNext));

 		index=KMaxClustering;

 		// drop through to previous

 	case EDbPrevious:

 		for (;;)

 			{

 			TUint membership=anIterator.iDes.iMembership;

 			while (--index>=0)

 				{

 				if ((membership>>index)&1)

 					{

 					anIterator.iCurrent=RecordId(cluster,index);

 					return ETrue;

 					}

 				}

 			__ASSERT(index==-1);

 			cluster=PreviousClusterL(anIterator.iDes,cluster);

 			if (cluster==KNullClusterId)

 				return EFalse;	// ran out of data

 			index=KMaxClustering;

 			}

 		}

 	}

 TBool CDbStoreRecords::DeletedL(TDbPosition aPosition,TIteratorC& anIterator)

 //

 // Record has been deleted

 //

 	{

 	anIterator.iDes.iMembership&=~(1<<RecordIndex(anIterator.iCurrent));

 	return GotoL(aPosition,anIterator);

 	}

 TBool CDbStoreRecords::GotoL(TDbRecordId aRecordId,TIteratorC& anIterator)

 //

 // Set the iterator to the record id, return false if the record is not present

 //

 	{

 	TClusterId cluster=ClusterId(aRecordId);

 	if (cluster!=iToken.iHead && !iLinks.Has(cluster) && !LocateL(cluster))

 		return EFalse;

 	anIterator.iCurrent=aRecordId;

 	DesL(anIterator.iDes,cluster);

 	return (anIterator.iDes.iMembership>>RecordIndex(aRecordId))&1;

 	}

 TBool CDbStoreRecords::ExistsL(TDbRecordId aRecordId)

 //

 // Ensure that the record is in this table

 //

 	{

 	TIteratorC iter;

 	return GotoL(aRecordId,iter);

 	}

 // Class HUnicodeCompressor

 NONSHARABLE_CLASS(HUnicodeCompressor) : public TStreamFilter

 	{

 public:

 	HUnicodeCompressor(MStreamBuf* aSink);

 private:

 	void DoRelease();

 	void DoSynchL();

 	TInt Capacity(TInt aMaxLength);

 	TInt FilterL(TAny* aPtr,TInt aMaxLength,const TUint8*& aFrom,const TUint8* anEnd);

 private:

 	enum {EFlushBufferSize=16};

 private:

 	TUnicodeCompressor iCompressor;

 	};

 HUnicodeCompressor::HUnicodeCompressor(MStreamBuf* aSink)

 	{

 	Set(aSink,EAttached|EWrite);

 	}

 void HUnicodeCompressor::DoRelease()

 	{

 	TStreamFilter::DoRelease();

 	delete this;

 	}

 TInt HUnicodeCompressor::Capacity(TInt aMaxLength)

 //

 // Return the maximum guaranteed input used for aMaxLength output.

 // SUC at worst expands n chars to 3n bytes

 //

 	{

 	aMaxLength=(aMaxLength+2)/3;	// # chars input guaranteed

 	return aMaxLength*2;			// # bytes

 	}

 TInt HUnicodeCompressor::FilterL(TAny* aPtr,TInt aMaxLength,const TUint8*& aFrom,const TUint8* aEnd)

 	{

 	TMemoryUnicodeSource source(reinterpret_cast<const TUint16*>(aFrom));

 	TInt used;

 	iCompressor.CompressL(reinterpret_cast<TUint8*>(aPtr),source,aMaxLength,(aEnd-aFrom)>>1,&aMaxLength,&used);

 	aFrom+=used<<1;

 	return aMaxLength;

 	}

 void HUnicodeCompressor::DoSynchL()

 	{

 	if (IsCommitted())

 		return;

 //

 	TUint8 buf[EFlushBufferSize];

 	TInt emit;

 	iCompressor.FlushL(buf,EFlushBufferSize,emit);

 	if (emit)

 		EmitL(buf,emit);

 //

 	TStreamFilter::DoSynchL();

 	Committed();

 	}

 // Class HUnicodeExander

 NONSHARABLE_CLASS(HUnicodeExpander) : public TStreamFilter

 	{

 public:

 	HUnicodeExpander(MStreamBuf* aSource);

 private:

 	void DoRelease();

 //	void DoSynchL();

 	TInt Capacity(TInt aMaxLength);

 	TInt FilterL(TAny* aPtr,TInt aMaxLength,const TUint8*& aFrom,const TUint8* anEnd);

 private:

 	enum {EFlushBufferSize=16};

 private:

 	TUnicodeExpander iExpander;

 	};

 HUnicodeExpander::HUnicodeExpander(MStreamBuf* aSource)

 	{

 	Set(aSource,EAttached|ERead);

 	}

 void HUnicodeExpander::DoRelease()

 	{

 	TStreamFilter::DoRelease();

 	delete this;

 	}

 TInt HUnicodeExpander::Capacity(TInt aMaxLength)

 //

 // Return the maximum guaranteed input used for aMaxLength output.

 // SUC at worst expands n chars to 3n bytes

 //

 	{

 	return aMaxLength>>1;			// best expansion from ASCII chars

 	}

 TInt HUnicodeExpander::FilterL(TAny* aPtr,TInt aMaxLength,const TUint8*& aFrom,const TUint8* aEnd)

 	{

 	TMemoryUnicodeSink sink(reinterpret_cast<TUint16*>(aPtr));

 	TInt used;

 	iExpander.ExpandL(sink,aFrom,aMaxLength>>1,aEnd-aFrom,&aMaxLength,&used);

 	aFrom+=used;

 	return aMaxLength<<1;

 	}

 /*

 void HUnicodeExpander::DoSynchL()

 	{

 	if (IsCommitted())

 		return;

 //

 //	TUint8 buf[EFlushBufferSize];

 //	TInt emit;

 //	iCompressor.FlushL(buf,EFlushBufferSize,&emit);

 //	if (emit)

 //		EmitL(buf,emit);

 //

 	TStreamFilter::DoSynchL();

 	Committed();

 	}

 */

 // Class CDbStoreBlobs

 CDbStoreBlobs::CDbStoreBlobs(CDbStoreDatabase& aDatabase,TInt aInlineLimit)

 	: iDatabase(aDatabase)

 	{

 	SetInlineLimit(aInlineLimit);

 	}

 MStreamBuf* CDbStoreBlobs::DoCreateL(TDbBlobId& aBlobId,TDbColType aType)

 	{

 	__ASSERT(TDbCol::IsLong(aType));

 //

 	RDbStoreWriteStream strm(iDatabase);

 	aBlobId=strm.CreateLC(iDatabase.Store()).Value();

 	strm.FilterL(aType!=EDbColLongBinary?strm.EText:strm.EBinary,aBlobId);

 	MStreamBuf* blob=strm.Sink();

 	if (aType==EDbColLongText16)

 		blob=new(ELeave) HUnicodeCompressor(blob);

 	CleanupStack::Pop();

 	return blob;

 	}

 MStreamBuf* CDbStoreBlobs::ReadL(TDbBlobId aBlobId,TDbColType aType) const

 	{

 	__ASSERT(TDbCol::IsLong(aType));

 //

 	RDbStoreReadStream strm(iDatabase);

 	strm.OpenLC(iDatabase.Store(),aBlobId);

 	strm.FilterL(aType!=EDbColLongBinary?strm.EText:strm.EBinary,aBlobId);

 	MStreamBuf* blob=strm.Source();

 	if (aType==EDbColLongText16)

 		blob=new(ELeave) HUnicodeExpander(blob);

 	CleanupStack::Pop();

 	return blob;

 	}

 void CDbStoreBlobs::DoDeleteL(TDbBlobId aBlobId)

 	{

 	iDatabase.Store().DeleteL(TStreamId(aBlobId));

 	}