// Copyright (c) 1998-2010 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 <s32file.h>

#include "UT_STD.H"

//The default media block size, used in the computations, if the file system guarantees atomic "block write" file operations.

const TInt KDefaultMediaBlockSize = 512;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/////////////////////              TPermanentStoreHeader               /////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

//Returns false, if:

// - the dirty bit is set (indicates commit phase #2 or #3 is not complete);

// - the CRC check fails ("backup TOC ref", "handle" and "TOC ref" are protected by 16-bit CRC in the permanent store file header);

TBool TPermanentStoreHeader::IsValid() const

	{

	if (IsDirty())

		return EFalse;

//

	TUint16 crc=0;

	Mem::Crc(crc,Ptr(),_FOFF(TPermanentStoreHeader,iCrc));

	return crc==iCrc;

	}

//Sets the "backup TOC ref", "handle" and "TOC ref" in current TPermanentStoreHeader object.

//16-bit CRC is calculated, based on the values of the input parameters, and stored together with them in the 

//TPermanentStoreHeader object.

void TPermanentStoreHeader::Set(TInt aBackupToc,TInt aHandle,TInt aReference)

	{

	iBackup=TUint32(aBackupToc)<<1;

	iHandle=aHandle;

	iRef=aReference;

	iCrc=0;

	Mem::Crc(iCrc,Ptr(),_FOFF(TPermanentStoreHeader,iCrc));

	__ASSERT_DEBUG(IsValid(),User::Invariant());

	}

const TInt KTocGranularity=12;

struct STocEntry

	{

	TInt32 handle;

	TInt32 ref;

	};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/////////////////////              CPermanentStoreToc               ////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

TInt CPermanentStoreToc::TEntry::Compare(const TEntry& aLeft, const TEntry& aRight)

//

// Ordering for Stream handles, return <0,0,>0 depending on comparison

// The index part of the handle is only 24 bits, so just subtract the handles for result

//

	{

	return (aLeft.handle&KMaskHandleIndex) - (aRight.handle&KMaskHandleIndex);

	}

CPermanentStoreToc* CPermanentStoreToc::NewL(TStreamPos aBase,TStreamExchange& aHost,TInt aToc,TInt aBaseReloc)

	{

	CPermanentStoreToc* table=new(ELeave) CPermanentStoreToc(aBase,aHost);

	CleanupStack::PushL(table);

	table->ConstructL(aToc,aBaseReloc);

	CleanupStack::Pop();

	return table;

	}

TBool CPermanentStoreToc::IsDelta() const

//

// Report whether the current TOC should be written as a delta, or a base TOC

//

	{

	TInt delta = iEntries.Count();

	if (delta >= KTocDeltaCap)

		return EFalse;

	TInt magic = iMagic + delta;

	if (magic > KMaxTocDeltaMagic)

		return EFalse;

	return magic*KSizeTocDeltaEntry <= iCount*KSizeTocEntry - KSizeTocDeltaExtra;

	}

void CPermanentStoreToc::Move(TInt aToc,TInt anExtent)

//

// Final stage of compaction, update to address new TOC

//

	{

	__ASSERT_DEBUG(anExtent<=iOff&&anExtent>=aToc&&anExtent-(aToc+KOffsetTocHeader)==iExt-iOff,User::Invariant());

	if (!HasDelta())

		{

		// Base-toc only, update the base toc position as well

		TInt window=iWindow-iTocExt;

		iTocOff=aToc+KOffsetTocHeader;

		iTocExt=anExtent;

		iWindow=anExtent+window;

		}

	iOff = aToc+KOffsetTocHeader;

	iExt = anExtent;

	}

TInt CPermanentStoreToc::RealizeL(TInt aPrimary,TInt anExtent) const

	{

	__ASSERT_DEBUG(IsVirtual(),User::Invariant());

	RFrame16Buf buf(Base());

	buf.PushL();

	const TBool delta = IsDelta();

	aPrimary &= KMaskStreamIdValue;

	if (delta)

		aPrimary |= KTocDelta;

	STocHead h;

	h.primary=TInt32(aPrimary);

	h.avail=TInt32(iAvail);

	h.count=TUint32(iCount);

//

	TInt off;

	if (delta)

		off=DeltaL(buf,anExtent,h);

	else

		off=RewriteL(buf,anExtent,h);

//

	buf.SynchL();

	CleanupStack::PopAndDestroy(&buf);

	return off-KOffsetTocHeader;

	}

void CPermanentStoreToc::Adopt(TInt aToc,TInt aPrimary)

//

// Final stage of Commit - all file changes have been successful

// Record the new Toc location and reset the changed flag

//

	{

	__ASSERT_DEBUG(aToc+KOffsetTocHeader>=iExt,User::Invariant());

	if (IsDelta())

		{

		// Adjust the TOC-delta location

		TInt c = iEntries.Count();

		iOff=aToc+KOffsetTocHeader;

		iExt=aToc + KSizeTocDeltaExtra + KSizeTocDeltaEntry*c;

		if (c > KTocDeltaMagic)

			iMagic += c - KTocDeltaMagic;

		}

	else

		{

		// Adjust all the TOC data and reset the delta-set

		TInt window = iTocOff>=0 ? iWindow-iTocOff : -KOffsetTocHeader;

		iTocOff=iOff=aToc+KOffsetTocHeader;

		iTocExt=iExt=aToc+KSizeTocEntry*iCount;

		iWindow = iTocOff + window;

		iEntries.Reset();

		iMagic = 0;

		}

	iPrimary=aPrimary;

	__ASSERT_DEBUG(!IsVirtual(),User::Invariant());

	}

TInt CPermanentStoreToc::AllocL(TInt anOffset)

	{

	TEntry& entry=DoAllocL();

	entry.ref=anOffset;

	return entry.handle;

	}

TInt CPermanentStoreToc::AllocL()

	{

	TEntry& entry=DoAllocL();

	entry.ref=KFrameNonexistent16;

	return entry.handle|=KHandleInvalid;

	}

void CPermanentStoreToc::Cancel(TInt aHandle)

	{

	__ASSERT_DEBUG(aHandle<0&&IsVirtual(),User::Invariant());

	TEntry* entry=Entry(aHandle);

	__ASSERT_DEBUG((entry!=NULL) && (entry->handle==aHandle),User::Invariant());

	entry->ref=iAvail;

	iAvail=aHandle;

	}

void CPermanentStoreToc::FreeL(TInt aHandle)

	{

	__ASSERT_DEBUG(aHandle>0,User::Invariant());

	TEntry& entry=FetchL(aHandle);

	aHandle|=KHandleInvalid;

	entry.handle=aHandle;

	entry.ref=iAvail;

	iAvail=aHandle;

	Changed();

	}

TInt CPermanentStoreToc::AtL(TInt aHandle) const

	{

	__ASSERT_DEBUG(aHandle>0,User::Invariant());

	// check the delta table

	const TEntry* entry=Entry(aHandle);

	if (entry!=NULL )

		{

		// if there is an entry in the delta table, but its

		// not an exact match leave with KErrNotFound

		// This happens when the delta indicates it's been deleted

		if (entry->handle!=aHandle)

			User::Leave(KErrNotFound);

		return entry->ref;

		}

//

	// if it's not in the delta table check the base TOC

	return DoAtL(aHandle);

	}

void CPermanentStoreToc::PutL(TInt aHandle, TInt anOffset, TPut aCheck)

//

// Used by compaction to update a single stream reference IN-PLACE in the TOC

// We need to check in which TOC to make the update

//

	{

	__ASSERT_DEBUG(!IsVirtual(),User::Invariant());

	__ASSERT_DEBUG(aHandle>0,User::Invariant());

	__ASSERT_DEBUG(aHandle!=KHandleTocBase || HasDelta(),User::Invariant());

	if (aHandle == KHandleTocBase)

		{

		// update the TOC-base link

		PutTocL(anOffset - KOffsetTocHeader, aCheck);

		if (iTocOff != anOffset)

			{

			TInt size = iTocExt - iTocOff;

			TInt window = iWindow - iTocOff;

			iTocOff = anOffset;

			iTocExt = anOffset + size;

			iWindow = anOffset + window;

			}

		return;

		}

	TEntry e;

	e.handle=aHandle;

	TInt i;

	if (iEntries.FindInOrder(e,i,&TEntry::Compare)==0)

		{

		// update TOC-delta entry

		TEntry& entry=iEntries[i];

		if (entry.handle==aHandle && entry.ref != anOffset)

			{

			PutDeltaL(i,aHandle,anOffset);

			entry.ref=anOffset;

			}

		return;

		}

	// update TOC-base entry

	if (aCheck==EWrite || DoAtL(aHandle)!=anOffset)

		PutBaseL(aHandle,anOffset);

	}

TInt CPermanentStoreToc::GetL(TInt aHandle)

	{

	__ASSERT_DEBUG(aHandle>0,User::Invariant());

	TEntry& entry=FetchL(aHandle);

	return entry.ref;

	}

TInt CPermanentStoreToc::Set(TInt aHandle,TInt anOffset)

	{

	__ASSERT_DEBUG(aHandle!=0,User::Invariant());

	TEntry* entry=Entry(aHandle);

	__ASSERT_DEBUG((entry!=NULL) && (entry->handle==aHandle),User::Invariant());

	aHandle&=KMaskStreamIdValue;

	entry->handle=aHandle;

	entry->ref=anOffset;

	Changed();

	return aHandle;

	}

CPermanentStoreToc::CPermanentStoreToc(TStreamPos aBase,TStreamExchange& aHost)

	: /*iPrimary(0),iAvail(0),iCount(0),*/iEntries(KTocGranularity),

		iBase(aBase),iHost(&aHost),iOff(KFrameNonexistent16)/*,iExt(0)*/,

		iTocOff(KFrameNonexistent16)/*,iTocExt(0),iWindow(0)*/

	{}

CPermanentStoreToc::~CPermanentStoreToc()

	{

	iEntries.Close();

	}

void CPermanentStoreToc::ConstructL(TInt aToc,TInt aBaseReloc)

//

// Read and validate the TOC header at aToc.

// aBaseReloc may contain a relocated TOC-base offset, which should override the one in a TOC-delta

//

	{

	if (aToc==0)

		return;

	__ASSERT_DEBUG(aToc>0&&iEntries.Count()==0,User::Invariant());

	RFrame16Buf buf(Base());

	aToc+=KOffsetTocHeader;

	buf.OpenL(Host(),aToc,EFrameDescriptive16|buf.ERead);

	buf.PushL();

	RReadStream stream(&buf);

	STocHead h;

	stream.ReadL((TUint8*)&h,sizeof(STocHead)); // platform dependency

	if ((h.primary&~(KMaskStreamIdValue|static_cast<TUint>(KTocDelta)))!=0||

		h.avail>0||(h.avail&KMaskHandleClear)!=0||(h.count&~KMaskHandleIndex)!=0)

		__LEAVE(KErrCorrupt);

//

	iPrimary=TInt(h.primary) & ~KTocDelta;

	iAvail=TInt(h.avail);

	iCount=TInt(h.count);

	iOff = aToc;

//

	if (h.primary & KTocDelta)

		{

		// This is a TOC-delta

		aToc = InternalizeL(stream, aBaseReloc) + KOffsetTocHeader;

		// Now locate and validate the base TOC

		buf.Release();

		buf.OpenL(Host(),aToc,EFrameDescriptive16|buf.ERead);

		stream.ReadL((TUint8*)&h,sizeof(STocHead)); // platform dependency

		if ((h.primary&~KMaskStreamIdValue)!=0||(h.count&~KMaskHandleIndex)!=0||

			h.avail>0||(h.avail&KMaskHandleClear)!=0||TInt(h.count)>iCount)

			__LEAVE(KErrCorrupt);

		}

	TInt size = KSizeTocEntry*TInt(h.count);

// Eagerly load the first few TOC entries into the cache

// This is good as it almost certainly lies in the file buffer already

	if (size>0)

		stream.ReadL(&iBuf[0],Min(size,TInt(KSizeTocBuf)));

	size-=KOffsetTocHeader;

	if (buf.SizeL()!=size)

		__LEAVE(KErrCorrupt);

	iTocOff=aToc;

	iWindow=aToc-KOffsetTocHeader;

	iTocExt=aToc+size;

	if (iExt == 0)

		iExt = iTocExt;		// set extent for non-delta TOC

//

	CleanupStack::PopAndDestroy(&buf);

	}

TInt CPermanentStoreToc::InternalizeL(RReadStream& aIn, TInt aBaseReloc)

//

// Load and validate the delta-toc table

//

	{

	TInt tocoff = aIn.ReadInt32L();

	if (aBaseReloc != KFrameNonexistent16)

		tocoff = aBaseReloc - KOffsetTocHeader;

	if (tocoff<0||tocoff>=iOff)

		__LEAVE(KErrCorrupt);

	iMagic = aIn.ReadUint16L();

	if (!IsDelta())

		__LEAVE(KErrCorrupt);

	TInt n = aIn.ReadUint8L();

	TInt size = -KOffsetTocHeader + KSizeTocDeltaExtra + KSizeTocDeltaEntry * n;

	if (aIn.Source()->SizeL()!=size)

		__LEAVE(KErrCorrupt);

	iExt = iOff + size;

	TInt last = 0;

	while (--n >= 0)

		{

		STocEntry e;

		aIn.ReadL((TUint8*)&e,KSizeTocDeltaEntry);	// platform dependency

		if ((e.handle&KMaskHandleClear)!=0||e.handle>=0&&(e.ref<KFrameNonexistent16)||

			e.handle<0&&(e.ref>0||(e.ref&KMaskHandleClear)!=0))

			__LEAVE(KErrCorrupt);

		TInt i = e.handle&KMaskHandleIndex;

		if (i <= last || i > iCount)

			__LEAVE(KErrCorrupt);

		last = i;

		TEntry entry;

		entry.handle = TInt(e.handle);

		entry.ref = TInt(e.ref);

		User::LeaveIfError(iEntries.Append(entry));

		}

	return tocoff;

	}

TInt CPermanentStoreToc::DeltaL(RFrame16Buf& aBuf,TInt aExtent,const STocHead& aHead) const

//

// Write the TOC-delta

//

	{

	TInt off=aBuf.ExtendL(Host(),aExtent,EFrameDescriptive16|aBuf.EWrite);

	RWriteStream out(&aBuf);

	out.WriteL((TUint8*)&aHead,sizeof(STocHead)); // platform dependency

	out.WriteInt32L(iTocOff - KOffsetTocHeader);

	TInt n = iEntries.Count();

	TInt magic = iMagic;

	if (n > KTocDeltaMagic)

		magic += n - KTocDeltaMagic;

	__ASSERT_DEBUG(magic <= KMaxTocDeltaMagic,User::Invariant());

	__ASSERT_DEBUG(n <= (TInt)KMaxTUint8, User::Invariant());

	out.WriteUint16L(magic);

	out.WriteUint8L(n);

	for (int i = 0; i < n; ++i)

		{

		const TEntry& entry = iEntries[i];

		STocEntry e;

		e.handle=TInt32(entry.handle);

		e.ref=TInt32(entry.ref);

		out.WriteL((TUint8*)&e,KSizeTocDeltaEntry); // platform dependency

		}

	return off;

	}

TInt CPermanentStoreToc::RewriteL(RFrame16Buf& aBuf,TInt aExtent,const STocHead& aHead) const

//

// Write the TOC-base

//

	{

	const TInt KElementsRewrite=304;

	const TInt KSizeRewriteBuf=KElementsRewrite*KSizeTocEntry;

	TUint8 toc[KSizeRewriteBuf];

	RFrame16Buf buf(Base());

	buf.PushL();

	TInt oldsize = 0;

	TInt window = 0;

	if (iTocOff>=0)

		{

		oldsize = iTocExt-iTocOff+KOffsetTocHeader;

		window = iWindow + KOffsetTocHeader - iTocOff;

		if (oldsize <= Min(KSizeTocBuf,KSizeRewriteBuf) && window == 0)

			{

			// the old TOC is already in the toc-base cache, no need to read it

			Mem::Copy(&toc[0],&iBuf[0],oldsize);

			oldsize = 0;	// this prevents the read request

			}

		else

			{

			buf.Set(Host(),iTocOff,iTocExt,EFrameDescriptive16|buf.ERead);

			buf.SeekL(buf.ERead,TStreamPos(-KOffsetTocHeader));

			}

		}

	RReadStream in(&buf);

	// defer the initialisation of the write in roder to improve file buffering performance

	RWriteStream out(&aBuf);

	TInt off=-1;

	TInt size=iCount*KSizeTocEntry;

	for (TInt base=0,delta=0;base<size;base+=KSizeRewriteBuf)

		{

		// fill buffer with old TOC data

		if (base < oldsize)

			in.ReadL(&toc[0],Min(KSizeRewriteBuf,oldsize-base));

		// apply changes to this block

		for (TInt n=iEntries.Count();delta<n;++delta)

			{

			const TEntry& entry=iEntries[delta];

			TInt pos = (entry.handle&KMaskHandleIndex)*KSizeTocEntry - KSizeTocEntry - base;

			__ASSERT_DEBUG(pos>=0,User::Invariant());

			if (pos>=KSizeRewriteBuf)

				break;

			STocEntry e;

			e.handle=TInt32(entry.handle);

			e.ref=TInt32(entry.ref);

			Mem::Copy(&toc[pos],(const TUint8*)&e+KSizeHandleIndex,KSizeTocEntry);

			pos += base - window;

			if (TUint(pos) < TUint(KSizeTocBuf))

				Mem::Copy(MUTABLE_CAST(TUint8*,&iBuf[pos]),(const TUint8*)&e+KSizeHandleIndex,KSizeTocEntry);

			}

		// write buffer to file

		if (off == -1)

			{

			// initialise writing

			off=aBuf.ExtendL(Host(),aExtent,EFrameDescriptive16|aBuf.EWrite);

			out.WriteL((TUint8*)&aHead,sizeof(STocHead)); // platform dependency

			}

		out.WriteL(&toc[0],Min(KSizeRewriteBuf,size-base));

		}

//

	CleanupStack::PopAndDestroy(&buf);

	return off;

	}

CPermanentStoreToc::TEntry* CPermanentStoreToc::Entry(TInt aHandle)

	{

	TEntry e;

	e.handle=aHandle;

	TInt i;

	if (iEntries.FindInOrder(e,i,&TEntry::Compare)!=0)

		return NULL;

//

	TEntry& entry=iEntries[i];

	// allow entry to return a pointer even if not an exact match

	return &entry;

	}

CPermanentStoreToc::TEntry& CPermanentStoreToc::FetchL(TInt aHandle)

	{

	TEntry e;

	e.handle=aHandle;

	TInt i;

	if (iEntries.FindInOrder(e,i,&TEntry::Compare)!=0)

		{

		e.ref=DoAtL(aHandle);

		User::LeaveIfError(iEntries.Insert(e,i));

		}

	TEntry& entry=iEntries[i];

	if (entry.handle!=aHandle)

		__LEAVE(KErrNotFound);

//

	return entry;

	}

CPermanentStoreToc::TEntry& CPermanentStoreToc::DoAllocL()

	{

	TInt handle=iAvail;

	TEntry* entry;

	if (handle==0)

		{

		__ASSERT_DEBUG(iEntries.Count()==0||(iEntries[iEntries.Count()-1].handle&KMaskHandleIndex)<=iCount,User::Invariant());

		User::LeaveIfError(iEntries.Append(TEntry()));

		entry=&iEntries[iEntries.Count()-1];

		handle=++iCount;

		}

	else

		{

		entry=&FetchL(handle);

		handle=(handle+KIncHandleGen)&KMaskStreamIdValue;

//

		TInt avail=entry->ref;

		if (avail>0||(avail&KMaskHandleClear)!=0)

			__LEAVE(KErrCorrupt);

//

		iAvail=avail;

		}

	entry->handle=handle;

	Changed();

	return *entry;

	}

TInt CPermanentStoreToc::DoAtL(TInt aHandle) const

	{

	TInt off=iTocOff;

	if (off<0)

		__LEAVE(KErrNotFound);

//

	off+=-KOffsetTocHeader-KSizeTocEntry+KSizeTocEntry*(aHandle&KMaskHandleIndex);

	__ASSERT_DEBUG(off>=iTocOff-KOffsetTocHeader,User::Invariant());

	if (off>=iTocExt)

		__LEAVE(KErrNotFound);

//

	TInt window=iWindow;

	if (off-window<0||off-window>=KSizeTocBuf)

		{

		TInt len=iTocOff-KOffsetTocHeader;

		window=Max(len,Min(off-KBackTocBuf,iTocExt-KSizeTocBuf));

		len=Min(iTocExt-len,TInt(KSizeTocBuf));

//

		RFrame16Buf buf(Base());

		buf.Set(Host(),iTocOff,iTocExt,EFrameDescriptive16|buf.ERead);

		buf.PushL();

		buf.SeekL(buf.ERead,TStreamPos(window-iTocOff));

		RReadStream stream(&buf);

		MUTABLE_CAST(TInt&,iWindow)=iTocExt;

		stream.ReadL(MUTABLE_CAST(TUint8*,&iBuf[0]),1); // assume half decent read-ahead buffering

		stream.ReadL(MUTABLE_CAST(TUint8*,&iBuf[1]),len-1);

		MUTABLE_CAST(TInt&,iWindow)=window;

		CleanupStack::PopAndDestroy();

		}

	STocEntry e;

	e.handle=aHandle;

	Mem::Copy((TUint8*)&e+KSizeHandleIndex,&iBuf[off-window],KSizeTocEntry); // platform dependency

	if ((e.handle&KMaskHandleClear)!=0||e.handle>=0&&(e.ref<KFrameNonexistent16)||

		e.handle<0&&(e.ref>0||(e.ref&KMaskHandleClear)!=0))

		__LEAVE(KErrCorrupt);

//

	if (TInt(e.handle)!=aHandle)

		__LEAVE(KErrNotFound);

//

	return TInt(e.ref);

	}

void CPermanentStoreToc::PutBaseL(TInt aHandle,TInt aReference)

//

// Update a TOC-base entry

//

	{

	__ASSERT_DEBUG(iTocOff>=0,User::Invariant());

	TInt pos=-KOffsetTocHeader-KSizeTocEntry+KSizeTocEntry*(aHandle&KMaskHandleIndex);

	RFrame16Buf buf(Base());

	buf.Set(Host(),iTocOff,iTocExt,EFrameDescriptive16|buf.EWrite);

	buf.PushL();

	buf.SeekL(buf.EWrite,TStreamPos(pos));

	RWriteStream stream(&buf);

	STocEntry e;

	e.handle=aHandle;

	e.ref=aReference;

	stream.WriteL((TUint8*)&e+KSizeHandleIndex,KSizeTocEntry); // platform dependency

	CleanupStack::PopAndDestroy();

	TInt off=pos+iTocOff-iWindow;

	if (off>=0&&off<KSizeTocBuf)

		Mem::Copy(&iBuf[off],(const TUint8*)&e+KSizeHandleIndex,KSizeTocEntry); // platform dependency

	}

void CPermanentStoreToc::PutDeltaL(TInt aPos, TInt aHandle, TInt aReference)

//

// Update a single stream reference IN-PLACE in the TOC-delta

//

	{

	__ASSERT_DEBUG(HasDelta(),User::Invariant());

	__ASSERT_DEBUG(iOff>=0,User::Invariant());

	RFrame16Buf buf(Base());

	buf.Set(Host(),iOff,iExt,EFrameDescriptive16|buf.EWrite);

	buf.PushL();

	buf.SeekL(buf.EWrite,TStreamPos(-KOffsetTocHeader + KSizeTocDeltaExtra + KSizeTocDeltaEntry*aPos));

	RWriteStream stream(&buf);

	STocEntry e;

	e.handle=aHandle;

	e.ref=aReference;

	stream.WriteL((TUint8*)&e,KSizeTocDeltaEntry); // platform dependency

	CleanupStack::PopAndDestroy();

	}

void CPermanentStoreToc::PutTocL(TInt aTocBase, TPut aCheck)

//

// Update the base TOC link in the TOC-delta

//

	{

	__ASSERT_DEBUG(HasDelta(),User::Invariant());

	__ASSERT_DEBUG(iOff>=0,User::Invariant());

	RFrame16Buf buf(Base());

	buf.Set(Host(),iOff,iExt,EFrameDescriptive16|buf.EWrite|buf.ERead);

	buf.PushL();

	buf.SeekL(buf.EWrite|buf.ERead,TStreamPos(-KOffsetTocHeader));

	RReadStream in(&buf);

	if (aCheck==EWrite || in.ReadInt32L() != aTocBase)

		{

		RWriteStream out(&buf);

		out.WriteInt32L(aTocBase);

		}

	CleanupStack::PopAndDestroy();

	}

// Used prior to PutL to determine exactly where in the file the TOC update will be written.

// This may be used to eliminate the pre-put write of the relocation information in the file

// header in situations where the write is entirely within an atomic file block.

//

// The detailed numbers used to offset into the TOCs are dependant on the TOC formats, as

// implicated by other members of this class

TInt CPermanentStoreToc::RefSpan(TInt aHandle,TInt& aLength)

    {

    __ASSERT_DEBUG(!IsVirtual(),User::Invariant());

    __ASSERT_DEBUG(aHandle>0,User::Invariant());

    if (aHandle == KHandleTocBase)

        {    // locate the TOC-base link

        __ASSERT_DEBUG(HasDelta(),User::Invariant());

        __ASSERT_DEBUG(iOff>=0,User::Invariant());

        aLength = sizeof(TInt32);

        return RFrame16Buf::Position(Base(), iOff - KOffsetTocHeader).Offset();

        }

    TEntry e;

    e.handle=aHandle;

    TInt ix;

    if (iEntries.FindInOrder(e, ix, &TEntry::Compare) == 0)

        {    // locate TOC-delta entry

        TEntry& entry=iEntries[ix];

        if (entry.handle==aHandle)

            {

            __ASSERT_DEBUG(HasDelta(),User::Invariant());

            __ASSERT_DEBUG(iOff>=0,User::Invariant());

            aLength = KSizeTocDeltaEntry;

            return RFrame16Buf::Position(Base(),iOff - KOffsetTocHeader + KSizeTocDeltaExtra + KSizeTocDeltaEntry*ix).Offset();

            }

        }

    // locate the TOC-base entry

    __ASSERT_DEBUG(iTocOff>=0,User::Invariant());

    aLength = KSizeTocEntry;

    return RFrame16Buf::Position(Base(),iTocOff-KOffsetTocHeader-KSizeTocEntry+KSizeTocEntry*(aHandle&KMaskHandleIndex)).Offset();

    }

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/////////////////////              RPermanentStoreTocIter               ////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

RPermanentStoreTocIter::RPermanentStoreTocIter(const CPermanentStoreToc& aTable)

	: iTable(aTable), iBuf(aTable.Base()), iDelta(0), iDeltaEnd(0)

	{

	TInt off=aTable.iTocOff;

	__ASSERT_DEBUG(off>=KFrameNonexistent16,User::Invariant());

	TInt ext=off<0?off:aTable.iTocExt;

	iBuf.Set(aTable.Host(),off,ext,EFrameDescriptive16|iBuf.ERead);

	}

void RPermanentStoreTocIter::Release()

	{

	iBuf.Release();

	}

void RPermanentStoreTocIter::ResetL()

	{

	iNext = iIndex = 1;

	if (iBuf.Offset()<0)

		{

		iCount=0;

		return;

		}

//

	RReadStream stream(&iBuf);

	STocHead h;

	stream.ReadL((TUint8*)&h,sizeof(STocHead)); // platform dependency

	if (h.primary<0||(h.primary&~KMaskStreamIdValue)!=0||

		h.avail>0||(h.avail&KMaskHandleClear)!=0||(h.count&~KMaskHandleIndex)!=0)

		__LEAVE(KErrCorrupt);

//

	const CPermanentStoreToc& table=iTable;

	if (table.HasDelta())

		{

		TInt c = table.iEntries.Count();

		if (c)

			{

			iDelta = &table.iEntries[0];

			iDeltaEnd = iDelta + c;

			}

		iIndex = 0;

		}

	iCount = iTable.iCount;

	}

TBool RPermanentStoreTocIter::NextL(TEntry& anEntry)

	{

	TInt i=iIndex;

	__ASSERT_DEBUG(iCount>=0,User::Invariant());

	if (i == 0)

		{

		// report TOC-base as a 'stream'

		anEntry.handle = KHandleTocBase;

		anEntry.ref = iTable.iTocOff;

		iIndex = 1;

		return ETrue;

		}

	__ASSERT_DEBUG(i>0,User::Invariant());

	if (i>iCount)

		return EFalse;

//

	const TEntry* d = iDelta;

	if (d != iDeltaEnd && (d->handle&KMaskHandleIndex) == i)

		{

		anEntry = *d;

		iDelta = d+1;

		iIndex = i+1;

		return ETrue;

		}

//

	RReadStream stream(&iBuf);

	TInt skip = i - iNext;

	if (skip > 0)

		stream.ReadL(KSizeTocEntry * skip);

	STocEntry e;

	e.handle=i;

	stream.ReadL((TUint8*)&e+KSizeHandleIndex,KSizeTocEntry); // platform dependency

	if ((e.handle&KMaskHandleClear)!=0||e.handle>=0&&e.ref<KFrameNonexistent16||

		e.handle<0&&(e.ref>0||(e.ref&KMaskHandleClear)!=0))

		__LEAVE(KErrCorrupt);

//

	iNext = iIndex = i+1;

	anEntry.handle=TInt(e.handle);

	anEntry.ref=TInt(e.ref);

	return ETrue;

	}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/////////////////////              TPermanentStoreCache               //////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

const TPermanentStoreCache::TItem* TPermanentStoreCache::At(TInt aHandle) const

	{

	const TItem* item=&iItems[0];

	TInt i=1;

	TInt bit=1;

	while (item->handle!=aHandle)

		{

		__ASSERT_DEBUG(item==&iItems[i-1],User::Invariant());

		TInt step=(aHandle&bit)?i+1:i;

		bit<<=1;

		i+=step;

		if (i>EItems)

			return NULL;

//

		item+=step;

		}

	__ASSERT_DEBUG(item==&iItems[i-1],User::Invariant());

	return item;

	}

void TPermanentStoreCache::Relocated(TInt aHandle,TInt anOffset)

	{

	const TItem* item=At(aHandle);

	if (item)

		{

		// update the cache item with the new offset

		// As 'extent' may only be a partial extent of a fragmented frame

		// which is no longer fragmented, we cannot simply shift this by the same

		// amount as 'offset'. Simplest to reset this to 'unknown', i.e. 0

		const_cast<TItem*>(item)->offset = anOffset;

		const_cast<TItem*>(item)->extent = 0;

		}

	}

void TPermanentStoreCache::Put(const TItem* anItem,TInt anOffset,TInt anExtent)

	{

	TInt handle=anItem->handle;

	TItem* item=&iItems[0];

	TInt i=1;

	TInt bit=1;

	while (item != anItem)

		{

		__ASSERT_DEBUG(item==&iItems[i-1],User::Invariant());

		TInt step=(handle&bit)?i+1:i;

		bit<<=1;

		i+=step;

		__ASSERT_DEBUG(i<=EItems,User::Invariant());

		item+=step;

		}

	__ASSERT_DEBUG(item==&iItems[i-1],User::Invariant());

	for(;;)

		{

		__ASSERT_DEBUG(item==&iItems[i-1],User::Invariant());

		TInt step=(handle&bit)?i+1:i;

		bit<<=1;

		i+=step;

		if (i>EItems)

			break;

//

		TItem* hole=item;

		item+=step;

		*hole=*item;

		};

	item->handle=handle;

	item->offset=anOffset;

	item->extent=anExtent;

	__ASSERT_DEBUG(At(handle)==item,User::Invariant());

	}

void TPermanentStoreCache::Add(TInt aHandle,TInt anOffset,TInt anExtent)

	{

	TItem* item=&iItems[0];

	TInt i=1;

	TInt bit=1;

	for(;;)

		{

		__ASSERT_DEBUG(item==&iItems[i-1]&&item->handle!=aHandle,User::Invariant());

		TInt step=(aHandle&bit)?i+1:i;

		bit<<=1;

		i+=step;

		if (i>EItems)

			break;

//

		TItem* hole=item;

		item+=step;

		*hole=*item;

		};

	item->handle=aHandle;

	item->offset=anOffset;

	item->extent=anExtent;

	__ASSERT_DEBUG(At(aHandle)==item,User::Invariant());

	}

void TPermanentStoreCache::Remove(TInt aHandle)

	{

	TItem* item=&iItems[0];

	TInt i=1;

	TInt bit=1;

	while (item->handle!=aHandle)

		{

		__ASSERT_DEBUG(item==&iItems[i-1],User::Invariant());

		TInt step=(aHandle&bit)?i+1:i;

		bit<<=1;

		i+=step;

		if (i>EItems)

			return;

//

		item+=step;

		}

	TItem* hole=item;

	TInt mask=bit-1;

	while (item!=&iItems[0])

		{

		__ASSERT_DEBUG(item==&iItems[i-1],User::Invariant());

		TInt step=i;

		bit>>=1;

		i>>=1;

		step-=i;

		item-=step;

//

		if (((aHandle^item->handle)&mask)==0)

			{

			*hole=*item;

			hole=item;

			mask=bit-1;

			}

		}

	hole->handle=0;

	__ASSERT_DEBUG(i==1&&At(aHandle)==NULL,User::Invariant());

	}

void TPermanentStoreCache::Invalidate()

	{

	for (TItem* item=&iItems[0],*end=item+EItems;item<end;++item)

		item->handle=0;

	}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/////////////////////              CPermanentStoreCoord               //////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

//Returns the file system type, according to what the "file write" operation guarantees.

//The return result could be one of:

// - ESimple        - "single byte write" operations are atomic;

// - EBlockAtomic   - "block/sector write" operations are atomic;

// - ETransactional - transactional file system;

CPermanentStoreCoord::TFileQoS CPermanentStoreCoord::FileQoSL()

	{

	//Uncomment, if you want FileQoSL() to return always EBlockAtomic/EBlockAtomic.

	//iFileQos = ETransactional;	

	//iFileQos = EBlockAtomic;	

	//return iFileQos;

	//

	if (iFileQos == EUnknown) //get the file sytem type, if iFileQos is not set yet

		{

		TStreamExchange &se = Host();

		RFileBuf *sb = static_cast<RFileBuf *>(se.HostL());

		RFile &f = sb->File();

		TInt dn;

		TDriveInfo di;

		User::LeaveIfError(f.Drive(dn, di));

		iFileQos = (di.iDriveAtt & KDriveAttTransaction) ? ETransactional : ESimple;

		if(iFileQos == ESimple && IsBlockAtomicL(dn))

			{

			iFileQos = EBlockAtomic;	

			}

		}

	return iFileQos;

	}

//The function returns true, if the file system guarantees atomic "block write" operations on aDriveNo.

//It is not the most effective implementation at the moment (creates/closes a file session), 

//probably TDriveInfo::iType can be used in a more effective implementation.

TBool CPermanentStoreCoord::IsBlockAtomicL(TInt aDriveNo) const

	{

	__ASSERT_DEBUG(aDriveNo >= EDriveA && aDriveNo <= EDriveZ, User::Invariant());

	RFs fs;

	CleanupClosePushL(fs);

	User::LeaveIfError(fs.Connect());

	TVolumeIOParamInfo volInfo;

	TInt err = fs.VolumeIOParam(aDriveNo, volInfo);

	CleanupStack::PopAndDestroy(&fs);

	//If VolumeIOParam() succeeds, the media block size is >= 512 bytes and the media block size is power of two - report

	//that the media supports atomic "block write" operations.

	return err == KErrNone && volInfo.iBlockSize >= KDefaultMediaBlockSize && (volInfo.iBlockSize & (volInfo.iBlockSize - 1)) == 0;

	}

TStreamPos CPermanentStoreCoord::LimitL()

	{

	TableL();

	return RFrame16Buf::Position(Base(),iExt);

	}

TStreamId CPermanentStoreCoord::PrimaryL()

	{

	return TStreamId(TableL().Primary());

	}

void CPermanentStoreCoord::ChangedL()

	{