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

// SCHSTORE

// 

//

#ifndef __SCHSTORE_H__

#define __SCHSTORE_H__

// System includes

#include <s32file.h>

// Classes referenced

class CSchScheduleIndex;

class CSchClientIndex;

class CClientProxy;

class CSchLogManager;

class CSchedule;

/**

@internalComponent

*/

class SchBackupManagerUtils

	{

public:

	enum TSchStorePanic

		{

		ESchBackupManagerScheduleStreamToReplaceNotFound,

		ESchBackupManagerScheduleStreamToDeleteNotFound,

		//

		ESchBackupManagerLast

		};

public:

	static void Panic(TSchStorePanic aPanic);

	};

/**

Schedule server backup file name.

@internalComponent

*/

_LIT(KSchsvrBackupFileName, "_:\\Private\\10005399\\SchedulesBackup.dat");

/**

Buffer descriptor to hold complete backup file name.

@internalComponent

*/

typedef TBuf<40> TBackupFileName;

/**

@internalComponent

*/

NONSHARABLE_CLASS(CSchBackupManager) : public CActive

	{

public:

	enum TSchBackupOperation

		{

		ESchBackupOperationAdd,

		ESchBackupOperationEdit,

		ESchBackupOperationDelete

		};

public:

	CSchBackupManager(RFs& aFsSession);

	~CSchBackupManager();

	void ConstructL();

public:

	void RestoreL(TPriQue<CClientProxy>& aClients, 

				TSglQue<CSchedule>& aTimeSchedules,

				CSchLogManager& aSchLogManager,TBool aBUR=EFalse);

	void CreateEmptyBackupL();

	//

	void PerformStoreOperationL(TSchBackupOperation aAction, const CSchedule& aSchedule);

	void PerformStoreOperationL(TSchBackupOperation aAction, const CClientProxy& aClient);

private:

	// The backup manager need to compact the store every now and then. It does

	// this as an idle operation and therefore needs to be CActive-based.

	void RunL();

	void DoCancel();

	void DoCreateEmptyBackupL();

private:

	void StoreChangedL();

	inline TInt RecordStoreChange() { return ++iStoreChangeCount; }

	inline void ResetStoreChanges() { iStoreChangeCount = 0; }

private:

	CPermanentFileStore* OpenBackupStoreLC();

	CPermanentFileStore* OpenOrCreateBackupStoreLC();

	//

	void CleanupRevertPushLC(CStreamStore& aStore);

	static void RevertStore(TAny* aStore);

	//

	void WriteRootStreamL(CStreamStore& aStore);

private:

	RFs& iFsSession;

	// The number of times the store has changed since it was last

	// compacted.

	TInt iStoreChangeCount;

	// Used to compact the store.

	RStoreReclaim iStoreReclaimer;

	// Used internally by the reclaimer to judge how much work is left to do.

	TPckgBuf<TInt> iStoreReclaimerCount;

	// A pointer to the store that has been opened for compaction purposes.

	// During normal operation of the backup manager, this pointer will

	// be NULL. However, when performing compaction, the store must be

	// open at all times and since processing is carried out as a series of

	// active object steps, we need to anchor it to the class.

	CStreamStore* iStoreOpenForCompaction;

	// The index to the schedule stream

	TStreamId iIndexStreamSchedules;

	// The index to the client stream

	TStreamId iIndexStreamClients;

	// The two pseudo-dictionary classes that manage mappings between

	// (clients and streams) and (schedules and streams).

	CSchClientIndex* iClientIndex;

	CSchScheduleIndex* iScheduleIndex;

	// backup file name

	TBackupFileName iBackupFileName;

	};

/**

@internalComponent

*/

class CSchScheduleIndex : public CBase

	{

public:

	static CSchScheduleIndex* NewL();

private:

	CSchScheduleIndex();

public:

	void RestoreSchedulesL(TSglQue<CSchedule>& aTimeSchedules, 

						CStreamStore& aStore, 

						TStreamId aDictionaryStreamId);

	TStreamId CreateEmptyIndexL(CStreamStore& aStore) const;

	//

	void AddL(TStreamId aIndexStream, CStreamStore& aStore, const CSchedule& aSchedule);

	void EditL(TStreamId aIndexStream, CStreamStore& aStore, const CSchedule& aSchedule);

	void DeleteL(TStreamId aIndexStream, CStreamStore& aStore, const CSchedule& aSchedule);

public:

	class TSchScheduleMapplet

		{

	public:

		inline TSchScheduleMapplet() { }

		inline TSchScheduleMapplet(TInt aKey, TStreamId aStream) : iKey(aKey), iStream(aStream) { }

	public:

		void InternalizeL(RReadStream& aStream) { iKey = aStream.ReadInt32L(); aStream >> iStream; }

		void ExternalizeL(RWriteStream& aStream) const { aStream.WriteInt32L(iKey); aStream << iStream; }

	public:

		inline void SetStream(TStreamId aStream) { iStream = aStream; }

		inline TStreamId Stream() const { return iStream; }

	public:

		inline static TInt KeyOffset() { return _FOFF(TSchScheduleMapplet, iKey); }

	private:

		TInt iKey;

		TStreamId iStream;

		};

private:

	NONSHARABLE_CLASS(CSchScheduleDictionary) : public CBase

		{

	public:

		static CSchScheduleDictionary* NewLC();

		~CSchScheduleDictionary();

	private:

		CSchScheduleDictionary();

		void ConstructL();

	public:

		void AssignL(TInt aKey, TStreamId aId);

		void Remove(TInt aKey);

		TInt Count() const;

		//

		TStreamId At(TInt aKey) const;

		TStreamId AtIndex(TInt aIndex) const;

		//

		void InternalizeL(RReadStream& aStream);

		void ExternalizeL(RWriteStream& aStream) const;

	private:

		CArrayFix<TSchScheduleMapplet>* iMappings;

		};

private:

	CSchScheduleDictionary* DictionaryLC(CStreamStore& aStore, TStreamId aIndexStream);

	void StoreDictionaryL(CStreamStore& aStore, const CSchScheduleDictionary& aDictionary, TStreamId aStreamToReplace);

	};

/**

@internalComponent

*/

class CSchClientIndex : public CBase

	{

public:

	static CSchClientIndex* NewL(RFs& aFsSession);

private:

	CSchClientIndex(RFs& aFsSession);

public:

	void RestoreClientsL(TPriQue<CClientProxy>& aClients, 

							CStreamStore& aStore, 

							TStreamId aIndexStream,

							CSchLogManager& aSchLogManager,TBool aBUR=EFalse);

	TStreamId CreateEmptyIndexL(CStreamStore& aStore) const;

	void AppendClientToListL(TPriQue<CClientProxy>& aClients, CClientProxy* aClient);

public:

	void AddL(TStreamId aIndexStream, CStreamStore& aStore, const CClientProxy& aClient);

	void EditL(TStreamId aIndexStream, CStreamStore& aStore, const CClientProxy& aClient);

	void DeleteL(TStreamId aIndexStream, CStreamStore& aStore, const CClientProxy& aClient);

public:

	NONSHARABLE_CLASS(CSchClientMapplet) : public CBase

		{

	public:

		static CSchClientMapplet* NewLC(RReadStream& aStream);

		static CSchClientMapplet* NewLC(const TDesC& aKey, TStreamId aStream);

		~CSchClientMapplet();

	public:

		void InternalizeL(RReadStream& aStream);

		void ExternalizeL(RWriteStream& aStream) const;

	public:

		inline const TDesC& Key() const { return *iKey; }

		inline TStreamId Stream() const { return iStream; }

		//

		inline void SetStream(TStreamId aStream) { iStream = aStream; }

		//

		inline static TInt KeyOffset() { return _FOFF(CSchClientMapplet, iStream); }

	private:

		HBufC* iKey;

		TStreamId iStream;

		};

private:

	NONSHARABLE_CLASS(CSchClientDictionary) : public CBase

		{

	public:

		static CSchClientDictionary* NewLC();

		~CSchClientDictionary();

	private:

		CSchClientDictionary();

		void ConstructL();

	public:

		void AssignL(const TDesC& aKey, TStreamId aId);

		void RemoveL(const TDesC& aKey);

		TInt Count() const;

		TStreamId AtL(const TDesC& aKey) const;

		TStreamId AtIndex(TInt aIndex) const;

	public:

		void InternalizeL(RReadStream& aStream);

		void ExternalizeL(RWriteStream& aStream) const;

	private:

		CArrayPtr<CSchClientMapplet>* iMappings;

		};

private:

	CSchClientDictionary* DictionaryLC(CStreamStore& aStore, TStreamId aIndexStream);

	void StoreDictionaryL(CStreamStore& aStore, const CSchClientDictionary& aDictionary, TStreamId aStreamToReplace);

private:

	RFs& iFsSession;

	};

#endif