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