// Copyright (c) 2004-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:
//
 
#ifndef OBSRVR_H
#define OBSRVR_H

#include <e32base.h>

class CSharedRepository;
class CServerRepository;
class CRepositoryTransactor;

#include "inifile.h"

#ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS
class CHeapRepository;
/**
This simple T class is used to store information regarding
the keyspace entry in the rofs list with respect to the
extension used and the mount id order
*/
class TRofsFlag
{
public:
	TRofsFlag(const TDesC& aExt,TUint8 aMountId):iFlag(aMountId)
		{
		if (aExt.Compare(_L("txt"))==0)
			{
			iFlag |=0x80000000;
			}
		}

	static TInt CompareFlag(const TRofsFlag& aFlag1, const TRofsFlag& aFlag2)
		{
		return (aFlag1.iFlag & 0xFF)-(aFlag2.iFlag & 0xFF);
		}

public:
	//the 16 bit flag in format of |8bit cre/txt flag|8bit mount_id|
	//obviously this is assuming the format of the mangled file
	//granulatiry currently set to default of 8 which is reasonable
	//MSB=1 indicates this is txt
	TUint32 iFlag;	
};

/**
This class is used to store information about potentially multiple
files(in diffeernt rofs) used for a centrep keyspace
*/
class TMultiRofsList
	{
public:
	TMultiRofsList(TUid aUid):iRepUid(aUid){}
	
public:
	//repository uid
	TUid iRepUid;
	//list of the mount ids together with the extension(cre/txt)
	RArray<TRofsFlag> iMountFlagList;		
	};
#endif	

class MObserver
	{
public:
	virtual void Notify(TUint32 aId) = 0;
	};

class CObservable : public CBase
	{
public:
	static CObservable* NewLC();
	
	~CObservable();

	void AddObserverL(TUid aUid, CServerRepository* aRepositoryPointer);
	void RemoveObserver(TUid aUid, CServerRepository* aRepositoryPointer, TInt aInMemoryIndex);

	void Notify(TUid aUid, TUint32 aVal) const;
	
	void ReleaseTransactionLock(CRepositoryTransactor& aTransactor,TUid aRepositoryUid);
	void CancelTransaction(CRepositoryTransactor& aTransactor,TUid aRepositoryUid);	
	TInt FindOpenRepository(TUid aUid) const;
	void RemoveOpenRepository(CSharedRepository* aRepository);
	
	inline CSharedRepository*& GetOpenRepository(TInt aIndex) 
		{
		ASSERT((aIndex>=0)&&(aIndex<iOpenRepositories.Count()));
		return iOpenRepositories[aIndex];
		}
	inline void AddOpenRepositoryL(CSharedRepository* aRepository)
		{
		iOpenRepositories.AppendL(aRepository);
		}
	
	TInt FindConnectedRepository(TUid aUid) const;
			
#ifdef CACHE_OOM_TESTABILITY
	void CloseiOpenRepositories();
	void CloseiRepositoryInfo();
	void Reset();
	TBool iTrapOOMOnOpen;
#endif	
	
	CSharedRepository* AccessL(TUid aUid, TBool aFailIfNotFound = ETrue);
	void LoadRepositoryLC(TUid aUid, TBool aFailIfNotFound, CSharedRepository*& aRepository, CIniFileIn::TIniFileOpenMode aIniFileOpenMode);

	/**
	@internalTechnology
	This is the class/structure which keeps shared non-persisted repository data 
	*/
	class TSharedRepositoryInfo
		{
	public:
		TSharedRepositoryInfo(TUid aUid);
		TUid iRepositoryUid;
		// all transactors in the order added
		TSglQue<CRepositoryTransactor> iTransactors;
		// combined read/write lock for pessimistic transactions.
		// -1 if in EReadWriteTransaction, otherwise non-negative number of EReadTransactions.
		TInt iPessimisticTransactionLockCount;
		// count of active concurrent read/write transactions:
		TInt iNumActiveConcurrentReadWriteTransactions;
		

		};

	TSharedRepositoryInfo* SharedRepositoryInfo(TUid aUid);		
	void AddSharedRepositoryInfoL(TUid aUid);
	void RemoveSharedRepositoryInfo(TUid aUid);
	TInt CreateRepositoryL(CSharedRepository* aRepository, TCentRepLocation aLocation);
#ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS	
	void ProcessMultiRofsListL(const CDir& aList);	
	static TInt CompareUid(const TMultiRofsList& aUid1, const TMultiRofsList& aUid2);		
	RArray<TMultiRofsList>& GetMultiRofsList()
		{
		return iMultiRofsUidList;	
		}
#endif		
	
	/**
	@internalTechnology
	This is the class/structure which keeps notification-related data 
	*/
	class TRepositoryObserverInfo
		{
	public:
		TUid iRepositoryUid;
		CServerRepository* iRepositoryPointer; 
		};
	RArray<TRepositoryObserverInfo> iObservers;		
private:
	static TInt ObserverSortOrder(const TRepositoryObserverInfo &aRepository1, const TRepositoryObserverInfo &aRepository2);
	static TInt InfoSortOrder(const TSharedRepositoryInfo &aRepository1, const TSharedRepositoryInfo &aRepository2);
	static TInt CompareTUidValues(TInt aUid1, TInt aUid2);
	
	TInt ReadIniFileL(CSharedRepository*& aRepository,TCentRepLocation aLocation);
	TInt CreateRepositoryL(CSharedRepository*& aRepository, CIniFileIn::TIniFileOpenMode aIniFileOpenMode);
	TInt ReadSettingsL(CIniFileIn* aIniFileIn, CSharedRepository* aRep);

	TInt FindRepositoryInfo(TUid aUid);
	void RefreshTransactorAccessPolicies(CSharedRepository* aRepository, const TInt offset);
#ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS	
	//Multi ROFS stuff
	void ConstructL();
	void OverrideSettingL(TServerSetting& aBaseSetting,const TServerSetting& aOvSetting,CSharedRepository* aCoreRepository,TBool aNewOv,TBool aNewOvIndivPolicy);	
	void MergeRepositoryL(CSharedRepository* aCoreRepository,CHeapRepository* aOverrideRepository);
	void MergeMultiRofsL(TBool aCoreInitialized,CSharedRepository* aCoreRepository,const RArray<TRofsFlag>& aOverridingFileList);
#endif
	
private:
	enum {KGranularity=8};	
	RPointerArray<CSharedRepository> iOpenRepositories;	
	RPointerArray<TSharedRepositoryInfo> iRepositoryInfo;
#ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS	
	RArray<TMultiRofsList> iMultiRofsUidList;
#endif		
	};

#endif // OBSRVR_H