// 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:
//

#if !defined(__U32PERM_H__)
#define __U32PERM_H__
#if !defined(__S32STD_H__)
#include <s32std.h>
#endif
#if !defined(__U32FRAME_H__)
#include "U32FRAME.H"
#endif

#if defined(_DEBUG)&&!defined(__SMALL_BUNDLE)
//#define __SMALL_BUNDLE
#endif

//Forward declaratons
class RPermanentFileStoreIter;
class TDriveInfo;

//The offset of the header of a permanent file store.
//Since all permanent file store operations work in their own coordinate system, where physical file offset 32 is
//logical offset 0, KPermanentStoreHeaderOffset is set with -16, which means that the physical file offset is 32 - 16 = 16.
const TInt KPermanentStoreHeaderOffset=-16;

//Permanent file store header length: sizeof(backup TOC ref) + sizeof(handle) + sizeof(TOC ref) + sizeof(crc) = 4 + 4 + 4 + 2 = 14
const TInt KPermanentStoreHeaderLength=14;

//Backup TOC ref length - 4 bytes
const TInt KPermanentStoreBackupLength=4;

//
const TInt KMaskHandleHash=0xff000000;
const TInt KHandleInvalid=0x80000000;
const TInt KHandleTocBase=0x40000000;
const TInt KMaskHandleClear=0x30000000;
const TInt KMaskHandleGen=0x0f000000;
const TInt KIncHandleGen=0x01000000;
//
const TInt KMaxHandleIndex=0x00ffffff;
const TInt KMaskHandleIndex=0x00ffffff;
const TInt KSizeHandleIndex=3;
//
const TInt KTocDeltaCap = 64;		//up to 64 entries in a delta TOC
const TInt KTocDeltaMagic = 2;
const TInt KMaxTocDeltaMagic = KMaxTUint16;
const TInt KTocDelta=KHandleInvalid;
//
const TInt KOffsetTocHeader=-12;
const TInt KSizeTocEntry=5;		//base toc entry size is 5 bytes (when stored in the file, 8 bytes when presented in memory)
const TInt KSizeTocDeltaEntry=8;//delta toc entry size is 8 bytes
const TInt KSizeTocDeltaExtra=7;
const TInt KElementsTocBuf=48;
const TInt KBackTocBuf=20*KSizeTocEntry;
const TInt KSizeTocBuf=KElementsTocBuf*KSizeTocEntry;

//TPermanentStoreHeader class.
//
//Represents the data kept in the permanent store file header.
//Data members:
// - iBackup - "backup TOC reference", 32-bits integer, which keeps the 31-bit file offset of the backup TOC.
//             Plays important role in the "store commit" procedure.
//             The LSB is a "dirty" bit. If during the store opening phase the dirty bit is found to be set,
//             then it means - the previous "store commit" operation has not been completed successfully and
//             the backup TOC shall be used instead of the TOC;
// - iHandle - 32-bit stream handle (MSB - invalid/deleted, 3 bits - unused, 4 bits - generation counter, 24 bits - stream handle).
//             Plays important role in the "stream relocation" procedure during store compaction.
//             iHandle keeps the handle of the stream being relocated, so if the commit phase fails, the original stream entry
//             can be restored at the moment when the store is reopened;
// - iRef    - Current "TOC reference". Represents a file offset, where the current TOC is;
// - iCrc    - 16-bit CRC, protecting iBackup, iHandle, iRef;
class TPermanentStoreHeader
	{
public:
	TPermanentStoreHeader() {}
	inline TUint8* Ptr();
	inline const TUint8* Ptr() const;
	TBool IsValid() const;
//
	inline TPermanentStoreHeader(TInt aToc);
	inline TPermanentStoreHeader(TInt aBackupToc,TInt aHandle,TInt aReference);
//
	inline TBool IsDirty() const;
	inline void MarkDirty();
	inline void SetBackupToc(TInt aBackupToc);
	inline TInt BackupToc() const;
//
	inline TInt Handle() const;
	inline TInt Reference() const;
private:
	void Set(TInt aBackupToc,TInt aHandle,TInt aReference);
private:
	TUint32 iBackup;
	TInt32 iHandle;
	TInt32 iRef;
	TUint16 iCrc;
	};
	
//CPermanentStoreToc class.
//
//Represents the data kept in the permanent file store TOC (Table Of Content).
//Each TOC consists of:
// - TOC header         - CPermanentStoreToc::STocHead structure;
// - set of TOC entries - CPermanentStoreToc::TEntry structure;
//
//Each TOC entry consists of:
// - A stream handle (32 bits: MSB - invalid/deleted, 3 bits - unused, 4 bits - generation counter, 24 bits - stream handle);
// - A stream ref - the offset of the stream data in the permannet file store;
NONSHARABLE_CLASS(CPermanentStoreToc) : public CBase
	{
public:
	struct TEntry
		{
		TInt handle;
		TInt ref;
		static TInt Compare(const TEntry&, const TEntry&);
		};
	struct STocHead
		{
		TInt32 primary;
		TInt32 avail;
		TUint32 count;
		};
	enum TPut {EWrite,ETestBeforeWrite};
public:
	static CPermanentStoreToc* NewL(TStreamPos aBase,TStreamExchange& aHost,TInt aToc,TInt aBaseReloc);
	~CPermanentStoreToc();
//
	inline TInt Extent() const;
	void Move(TInt aToc,TInt anExtent);
//
	inline TBool IsVirtual() const;
	TInt RealizeL(TInt aPrimary,TInt anExtent) const;
	void Adopt(TInt aToc,TInt aPrimary);
//
	inline TInt Primary() const;
	inline void Changed();
//
	TInt AllocL(TInt anOffset);
	TInt AllocL();
	void Cancel(TInt aHandle);
	void FreeL(TInt aHandle);
	TInt AtL(TInt aHandle) const;
	void PutL(TInt aHandle,TInt anOffset,TPut aCheck);
	TInt GetL(TInt aHandle);
	TInt Set(TInt aHandle,TInt anOffset);
//
	CPermanentStoreToc(TStreamPos aBase,TStreamExchange& aHost);
	void ConstructL(TInt aToc,TInt aBaseReloc);
	
	TInt RefSpan(TInt aHandle,TInt& aLength);
	
private:
	inline TStreamPos Base() const;
	inline TStreamExchange& Host() const;
	inline const TEntry* Entry(TInt aHandle) const;
	TEntry* Entry(TInt aHandle);
	TEntry& FetchL(TInt aHandle);
	TEntry& DoAllocL();
	TInt DoAtL(TInt aHandle) const;
	void PutBaseL(TInt aHandle, TInt aReference);
	void PutDeltaL(TInt aPos, TInt aHandle, TInt aReference);
	void PutTocL(TInt aTocBase, TPut aCheck);
	inline TBool HasDelta() const;
	TBool IsDelta() const;
	TInt InternalizeL(RReadStream& aIn, TInt aBaseReloc);
	TInt DeltaL(RFrame16Buf& aBuf,TInt aExtent,const STocHead& aHead) const;
	TInt RewriteL(RFrame16Buf& aBuf,TInt aExtent,const STocHead& aHead) const;
	TInt SmallTocL(RFrame16Buf& aBuf,TInt aExtent,const STocHead& aHead) const;
private:
	TInt iPrimary;
	TInt iAvail;
	TInt iCount;
	RArray<TEntry> iEntries;
//
	TStreamPos iBase;
	TStreamExchange* iHost;
	TInt iMagic;
	TInt iOff;
	TInt iExt;
	TInt iTocOff;
	TInt iTocExt;
	__MUTABLE TInt iWindow;
	__MUTABLE TUint8 iBuf[KSizeTocBuf];
private:
	friend class RPermanentStoreTocIter;
	};

//	
class RPermanentStoreTocIter
	{
public:
	typedef CPermanentStoreToc::TEntry TEntry;
	typedef CPermanentStoreToc::STocHead STocHead;
public:
	RPermanentStoreTocIter(const CPermanentStoreToc& aTable);
	inline void Close();
	void Release();
//
	void ResetL();
	TBool NextL(TEntry& anEntry);
private:
	const CPermanentStoreToc& iTable;
	RFrame16Buf iBuf;
	TInt iIndex;
	TInt iCount;
	TInt iNext;
	const TEntry* iDelta;
	const TEntry* iDeltaEnd;
	};
	
//
class TPermanentStoreCache
	{
public:
	struct TItem {TInt handle;TInt offset;TInt extent;};
public:
	inline TPermanentStoreCache();
	const TItem* At(TInt aHandle) const;
	void Relocated(TInt aHandle,TInt anOffset);
	void Put(const TItem* anItem,TInt anOffset,TInt anExtent);
	void Add(TInt aHandle,TInt anOffset,TInt anExtent);
	void Remove(TInt aHandle);
	void Invalidate();
private:
	enum {EItems=2*16-1};
private:
	TItem iItems[EItems];
	};
	
//
NONSHARABLE_CLASS(CPermanentStoreCoord) : public CBase
	{
private:
	enum {EReady,EBackup=0x1,EClip=0x2};
	enum TFileQoS 
		{
		EUnknown,		//
		ESimple,		//File, "write byte" is an atomic operation
		EBlockAtomic,	//File, "block write" is an atomic operation
		ETransactional	//Transactional file system.
		};
	typedef TPermanentStoreCache::TItem TItem;
public:
	inline TBool IsTrim() const;
	TStreamPos LimitL();
	inline void Clipped();
//
	TStreamId PrimaryL();
	void ChangedL();
	TBool CommitL(TStreamId aPrimary);
	TBool RevertL(TStreamId& aPrimary);
//
	TStreamId ExtendL();
	void DeleteL(TStreamId anId);
//
 	CPermanentStoreCoord(TStreamPos aBase,TStreamExchange& aHost);
	void InternalizeL(RReadStream& aStream);
	~CPermanentStoreCoord();
private:
	void CanExtendL();
	TInt DoCreateL();
	void DoReplaceL(TInt aHandle);
	TInt DoOpenL(TInt& anOffset,TInt aHandle);
	void DoRelease(TInt aHandle,TInt anOffset,TInt anExtent);
	TInt DoCommit(TInt aHandle,TInt anOffset,TInt anExtent);
//
	inline TStreamPos Base() const;
	inline TStreamExchange& Host() const;
	inline TInt Toc() const;
	inline CPermanentStoreToc& Table() const;
	CPermanentStoreToc& TableL();
	CPermanentStoreToc& ConsolidateL();
	void RelocateL(TInt aHandle,TInt anOffset);
	void MoveL(TInt aToc,TInt anExtent);
	inline TUint Generation() const;
	inline void Inc();
	inline void Dec();
	inline TBool Accessed() const;
	TFileQoS FileQoSL();
	TBool IsBlockAtomicL(TInt aDriveNo) const;
//
	MStreamBuf* BeginL(TPermanentStoreHeader& aHeader);
private:
	TStreamPos iBase;
	TStreamExchange *iHost;
	TInt iToc;
	CPermanentStoreToc* iTable;
	TInt iReloc;
	TInt iTarget;
	TPermanentStoreCache iCache;
//
	TUint iGen;
	TInt iRefs;
	TInt iAccess;
	TInt iExtend;
	TInt iState;
	TInt iExt;
	TFileQoS iFileQos;
private:
	friend class HPermanentStoreBuf;
	friend class CPermanentStoreCollector;
	friend class RPermanentFileStoreIter;
	};
//
NONSHARABLE_CLASS(HPermanentStoreBuf) : public RFrame16Buf
	{
public:
	static HPermanentStoreBuf* CreateL(CPermanentStoreCoord& aCoord,TStreamId& anId,TInt aMode=ERead|EWrite);
	static HPermanentStoreBuf* ReplaceL(CPermanentStoreCoord& aCoord,TStreamId anId,TInt aMode=ERead|EWrite);
	static HPermanentStoreBuf* OpenL(CPermanentStoreCoord& aCoord,TStreamId anId,TInt aMode=ERead|EWrite);
//
	virtual ~HPermanentStoreBuf();
private:
	static HPermanentStoreBuf* NewLC(CPermanentStoreCoord& aCoord);
	static HPermanentStoreBuf* ExtendLC(CPermanentStoreCoord& aCoord,TInt aMode);
	inline HPermanentStoreBuf(CPermanentStoreCoord& aCoord);
	inline CPermanentStoreCoord& Coord() const;
//
	void DoRelease();
	void DoSynchL();
private:
	CPermanentStoreCoord* iCoord;
	TInt iHandle;
	};
//
class TPermanentStoreStreamIter
	{
#if defined(__SMALL_BUNDLE)
	enum {EBundleSize=8-1};
#else
	enum {EBundleSize=64-1};
#endif
public:
	void Reset();
	TInt FillL(CPermanentStoreToc& aToc);
	TInt Next();
//
	void Relocated(TInt aStream);
private:
	static void Push(TInt* aHeap,TInt* aHole,TInt aValue);
	static TInt PopPush(TInt* aHeap,TInt* anEnd,TInt aValue);
private:
	TInt* iNext;
	const TInt* iFinish;
	TInt iMore;
	TInt iPos;
	TInt iTable[EBundleSize];
	};

class TPermanentStoreRelocator;
NONSHARABLE_CLASS(CPermanentStoreCollector) : public CBase,public MIncrementalCollector
	{
	enum TState
		{
		EGetFree,ESkip,EInitRelocator,EFillRelocator,EEvalRelocator,EScanRelocator,ERelocateStream,ERelocateToc,
		EFastSort,EFastExtent,EFastRelocate
		};
	enum {EGranularity = 64};
	enum {EExtentStep = 64};
public:
	struct TEntry
		{
		TInt len;
		RPermanentStoreTocIter::TEntry entry;
		};
public:
	static CPermanentStoreCollector* CompactorL(CPermanentStoreCoord& aCoord);
	static CPermanentStoreCollector* ReclaimerL(CPermanentStoreCoord& aCoord);
protected:
	CPermanentStoreCollector(CPermanentStoreCoord& aCoord);
	~CPermanentStoreCollector();
private:
	void DoRelease();
	void DoResetL(TInt& aCount);
	void DoNextL(TInt& aStep,TInt& aTotal);
//
	TInt GetFreeL();
	TInt SkipL(TInt& aTotal);
	TInt InitRelocator();
	TInt FillRelocatorL();
	TInt EvalRelocatorL();
	TInt ScanRelocator();
	TInt RelocateStreamL();
	TBool HaveEnoughSpace() const;
	TInt ExtentL(TInt aStream);
//
// fast compaction
	TInt FastResetL();
	void FastSort();
	void FastExtentL(TInt& aTotal);
	void FastRelocateL(TInt& aTotal);
	TEntry* BestFit(TInt aPos, TInt aExt, TEntry* aFirst, TEntry* aLast);
//
// common utilities
	void RelocateTocL(TInt& aTotal);
	void RelocateStreamL(const TEntry& aReloc, TInt aExtent);
	TInt RelocateL(TInt aStream, TInt aLength, TFrameType16 aType, TInt aExtent);
//
	inline TBool Compacting() const;
	inline CPermanentStoreCoord& Coord() const;
	inline TStreamExchange& Host() const;
private:
	CPermanentStoreCoord* iCoord;
	TUint iCoordGen;
	TStreamExchange* iHost;
	TStreamMark iMark;
	TState iState;
	TInt iFree;
	TInt iEnd;
	TEntry* iNext;
	TEntry* iLast;
	RArray<TEntry> iStreams;
	TPermanentStoreRelocator* iReloc;
	TPermanentStoreStreamIter iIter;
	};

#include "U32PERM.INL"
#endif