diff -r 000000000000 -r e4d67989cc36 genericservices/taskscheduler/SCHSVR/SCHSTORE.H
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/genericservices/taskscheduler/SCHSVR/SCHSTORE.H	Tue Feb 02 02:01:42 2010 +0200
@@ -0,0 +1,311 @@
+// 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