// 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:
// The Store-Database
// 
//

#ifndef __D32STOR_H__
#define __D32STOR_H__
#ifndef __D32TABLE_H__
#include "D32TABLE.H"
#endif
#ifndef __S32STOR_H__
#include <s32stor.h>
#endif

// other classes referenced
class MDbStreamFilter;
class CDbStoreCompression;
class CClusterCache;

// classes defined
class CDbStoreDatabase;
class CDbFileStoreDatabase;

/**
@internalComponent
*/
enum TDbStoreVersion { EDbStoreVersion2=3,EDbStoreSecure,EDbStoreCompressed };

/**
@internalComponent
*/
class CDbStoreDatabase : public CDbTableDatabase
	{
public:
	enum TZipType {EDeflate,EInflate};
	
private:
	#ifndef PAGE_CACHE_SIZE
		#define PAGE_CACHE_SIZE 16
	#else
		#if PAGE_CACHE_SIZE < 8
			#error "PAGE_CACHE_SIZE macro value can't be less than 8"
		#endif
	#endif
	enum {EPageCachePages=PAGE_CACHE_SIZE};
	enum {EModified=0x1,EDamaged=0x2,ESharedStore=0x80000000};
	class CCompactor;
	
public:
// factory functions for pure StoreDatabase
	static CDbDatabase* CreateL(CStreamStore* aStore,TStreamId& aStreamId);
	static CDbSource* OpenL(CStreamStore* aStore,TStreamId aStreamId);
	static void CompressL(CStreamStore* aStore,TStreamId aStreamId,TZipType aZip);
// accessors
	inline CStreamStore& Store();
	inline MDbStreamFilter* Filter();
	CClusterCache& ClusterCacheL();
	MPagePool& PagePoolL();
// user-class's transaction protocol
	void MarkL();
	void IndexRecoveredL();
	
protected:
	IMPORT_C CDbStoreDatabase();
	IMPORT_C ~CDbStoreDatabase();
// phase 2 c'tors
	IMPORT_C TStreamId ConstructL();
// framework: authentication
	IMPORT_C void AuthenticateL();
	IMPORT_C void RestoreL(TStreamId aStreamId);
// framework: pure delegated functions
	IMPORT_C TInt Property(CDbDatabase::TProperty aProperty);
	IMPORT_C void DestroyL();
// framework: transaction protocol
	IMPORT_C void LoadSchemaL();
	IMPORT_C void SynchL(TDbLockType aLock);
	IMPORT_C void Revert(TDbLockType aLock);
	IMPORT_C void Idle();
// framework: object factory
	IMPORT_C CDbTableDef* CreateTableL(const TDesC& aName,const CDbColSet& aColSet,const CDbKey* aPrimaryKey);
	IMPORT_C CDbTableIndexDef* CreateIndexL(const CDbTableDef& aTable,const TDesC& aName,const CDbKey& aKey);
	IMPORT_C CDbTable* TableL(const CDbTableDef& aDef);
// framework: incremental factory
	IMPORT_C CStepper* TableAlterL(CDbTableDef& aTable,const HDbColumnSet& aNewSet,TInt& aStep);
	IMPORT_C CStepper* RecordDiscarderL(const CDbTableDef& aTable,TInt& aStep);
	IMPORT_C CStepper* IndexDiscarderL(const CDbTableDef& aTable,const CDbTableIndexDef& anIndex,TInt& aStep);
	IMPORT_C CStepper* UtilityL(CDbDatabase::TUtility aType,TInt& aStep);
	
private:
// framework: reserved
	IMPORT_C void Reserved_1();
	IMPORT_C void Reserved_2();
// implementationp functions
	static CDbStoreDatabase* NewLC(CStreamStore* aStore);
//
	void CompressTablesL();
	void CompressL(TStreamId aStreamId,TZipType aZip);
//
	void ReadHeaderL(RReadStream& aStream);
	void InitPagePoolL();
	void ReplaceSchemaL();
	void ReplaceTokenL(TUint aFlags);
	void SynchStoreL(TDbLockType aLock);
	CDbStoreCompression& CompressionL();
	CStepper* RecoverL(TInt& aStep);
	
protected:
	CStreamStore* iStore;
	TInt iReclaim;
	
private:
	TUint8 iVersion;
	TUint8 iFlags;
	TUint8 iSharedStore;
	TStreamId iSchemaId;
	TStreamId iTokenId;
	TStorePagePoolToken iPoolToken;
	RStorePagePool* iPagePool;
	CPageCache* iPageCache;
	CClusterCache* iClusterCache;
	MDbStreamFilter* iFilter;
	CDbStoreCompression* iCompression;
	
	};

/**
The general file-store database class
@internalComponent
*/
const TInt32 KDbmsFileDatabaseUidValue=0x10000EBE;
const TUid KDbmsFileDatabaseUid={KDbmsFileDatabaseUidValue};

/**
@internalComponent
*/
class CDbFileStoreDatabase : public CDbStoreDatabase
	{
public:
	IMPORT_C static CDbDatabase* CreateL(RFs& aFs, const TDesC& aName, TDbFormat::TCreate aMode,
                                         const TUidType& aType);
	IMPORT_C static CDbSource* OpenL(RFs& aFs,const TDesC& aName,TDbFormat::TOpen aMode);
	
protected:
	IMPORT_C CDbFileStoreDatabase(RFs& aFs);
	IMPORT_C ~CDbFileStoreDatabase();
//
	IMPORT_C void CreateL(const TDesC& aName, TDbFormat::TCreate aMode, const TUidType& aType);
	IMPORT_C virtual TStreamId CreateRootL(TStreamId aDatabaseId);
//
	IMPORT_C void OpenL(const TDesC& aName,TDbFormat::TOpen aMode);
	IMPORT_C virtual TStreamId DatabaseIdL(TStreamId aRootId);
// from CDbStoreDatabase
	IMPORT_C TInt Property(CDbDatabase::TProperty aProperty);
	IMPORT_C void DestroyL();
	
private:
	static CDbFileStoreDatabase* NewLC(RFs& aFs);
	
private:
	RFs& iFs;
	HBufC* iName;
	TBool iDelete;
	
	};

#endif