// Copyright (c) 2006-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:
// Core activity mutex policies
// 
//

/**
 @file
 @publishedPartner
 @released
*/

#ifndef SYMBIAN_MM_MUTEXPOLICIES_H
#define SYMBIAN_MM_MUTEXPOLICIES_H

#include <elements/mm_context.h>

namespace MeshMachine
{

/**
Template to aggregate two mutexes with an logical AND operator

@code
typedef TAggregatedMutex_AND<THasDataClientsMutex, TNodeIsStartedMutex> THasDataClientsAndNodeIsStartedMutex;
@endcode

@param TMUTEX1 First mutex to test
@param TMUTEX2 Second mutex to test
*/
template <class TMUTEX1, class TMUTEX2>
class TAggregatedMutex_AND
	{
public:
	/**
	@param aContext context in which to evaluate the mutexes
	@return ETrue if both mutex conditions have been met, EFalse otherwise
	*/
    inline static TBool IsBlocked(const MeshMachine::TNodeContextBase& aContext)
    	{
#ifdef __GCCXML__
		return EFalse;
#else
		return TMUTEX1::IsBlocked(aContext) && TMUTEX2::IsBlocked(aContext);
#endif
    	}
	};

/**
Template to aggregate two mutexes with an logical OR operator

@code
typedef TAggregatedMutex_OR<THaveDataClientsMutex, THaveControlClientsMutex> THaveDataClientsOrControlClientsMutex;
@endcode

@param TMUTEX1 First mutex to test
@param TMUTEX2 Second mutex to test
*/
template <class TMUTEX1, class TMUTEX2>
class TAggregatedMutex_OR
	{
public:
	/**
	@param aContext context in which to evaluate the mutexes
	@return ETrue if operation should be blocked, EFalse if neither mutex condition has been met
	*/
    inline static TBool IsBlocked(const MeshMachine::TNodeContextBase& aContext)
    	{
#ifdef __GCCXML__
		return EFalse;
#else
		return TMUTEX1::IsBlocked(aContext) || TMUTEX2::IsBlocked(aContext);
#endif
    	}
	};


/**
Template to block if an activity is running
@param ACTIVITYID activity to test for
*/
template <TInt ACTIVITYID>
class TActivityIdMutex
	{
public:
	/**
	@param aContext context in which to evaluate the mutexes
	@return ETrue if operation should be blocked, EFalse if mutex condition has been met
	*/
    inline static TBool IsBlocked(const MeshMachine::TNodeContextBase& aContext)
    	{
		TInt count = aContext.iNode.CountActivities(ACTIVITYID);
		MESH_LOG((KMeshMachineSubTag, _L8("TActivityIdMutex: Node [%08x] Activity [%08x]: Number of actid (%d) = %d"), aContext.NodeId().Ptr(), aContext.iNodeActivity,
				 ACTIVITYID, count));

		return count != 0;
    	}
	};
	
/**
Template to block if there is an activity on a node in a non waiting state
@param ACTIVITYID id of activities to search for
 */
template <TInt ACTIVITYID>
class TNonWaitingActivityIdMutex
	{
public:
	/**
	@param aContext context in which to evaluate the mutexes
	@return ETrue if there exists activities with specified id, which are not in a waiting state.
	*/
    inline static TBool IsBlocked(const MeshMachine::TNodeContextBase& aContext)
    	{
		const RPointerArray<CNodeActivityBase>& activities = aContext.iNode.Activities();
		TInt i = activities.Count();
		while (i>0)
			{
			CNodeActivityBase* a = activities[--i];
			if (ACTIVITYID == a->ActivitySigId())
				{
				AActivitySemaphore* as = static_cast<AActivitySemaphore*>(a->FetchExtInterface(AActivitySemaphore::KInterfaceId));
				if (as && !as->IsWaiting())
					{
					return ETrue;
					}
				}
			}
		return EFalse;
    	}
	};

/**
Mutex checking multiple non waiting activities
@param ACTIVITYID1 First activity to check for
@param ACTIVITYID2 Second activity to check for
@param ACTIVITYID3 Third activity to check for, defaults to 0 in which case the parameter is ignored
@param ACTIVITYID4 Fourth activity to check for, defaults to 0 in which case the parameter is ignored
@param ACTIVITYID5 Fifth activity to check for, defaults to 0 in which case the parameter is ignored
*/
template <TInt ACTIVITYID1, TInt ACTIVITYID2, TInt ACTIVITYID3 = 0, TInt ACTIVITYID4 = 0, TInt ACTIVITYID5 = 0>
class TNonWaitingActivitiesIdMutex
	{
public:
	/**
	@param aContext context in which to evaluate the mutexes
	@return ETrue if there exists all the activities with the specified ids, which are not in a waiting state.
	*/
    inline static TBool IsBlocked(const MeshMachine::TNodeContextBase& aContext)
    	{
		const RPointerArray<CNodeActivityBase>& activities = aContext.iNode.Activities();
		TInt i = activities.Count();
		while (i>0)
			{
			CNodeActivityBase* a = activities[--i];
			TInt sigId = a->ActivitySigId();
			
			if (ACTIVITYID1 == sigId || ACTIVITYID2 == sigId || ACTIVITYID3 == sigId || ACTIVITYID4 == sigId || ACTIVITYID5 == sigId)
				{
				AActivitySemaphore* as = static_cast<AActivitySemaphore*>(a->FetchExtInterface(AActivitySemaphore::KInterfaceId));
				if (as && !as->IsWaiting())
					{
					return ETrue;
					}
				}
			}
		return EFalse;
    	}
	};

/**
Mutex checking multiple incompatible activities ids
@param ACTIVITYID1 First activity to check for
@param ACTIVITYID2 Second activity to check for
@param ACTIVITYID3 Third activity to check for, defaults to 0 in which case the parameter is ignored
@param ACTIVITYID4 Fourth activity to check for, defaults to 0 in which case the parameter is ignored
@param ACTIVITYID5 Fifth activity to check for, defaults to 0 in which case the parameter is ignored
*/
template <TInt ACTIVITYID1, TInt ACTIVITYID2, TInt ACTIVITYID3 = 0, TInt ACTIVITYID4 = 0, TInt ACTIVITYID5 = 0>
class TActivitiesIdMutex
	{
public:
	/**
	@param aContext context in which to evaluate the mutexes
	@return ETrue if there exists all the activities with the specified ids, EFalse otherwise
	*/
    inline static TBool IsBlocked(const MeshMachine::TNodeContextBase& aContext)
    	{

		MESH_LOG((KMeshMachineSubTag, _L8("TActivitiesIdMutex: Node [%08x] Activity [%08x]: [2] Number of actid (%d) = %d"), aContext.NodeId().Ptr(), aContext.iNodeActivity,
				ACTIVITYID2, aContext.iNode.CountActivities(ACTIVITYID2)));
		if (ACTIVITYID3)
			{
			MESH_LOG((KMeshMachineSubTag, _L8("TActivitiesIdMutex: Node [%08x] Activity [%08x]: [3] Number of actid (%d) = %d"), aContext.NodeId().Ptr(), aContext.iNodeActivity,
					ACTIVITYID3, aContext.iNode.CountActivities(ACTIVITYID3)));
			if (ACTIVITYID4)
				{
				MESH_LOG((KMeshMachineSubTag, _L8("TActivitiesIdMutex: Node [%08x] Activity [%08x]: [4] Number of actid (%d) = %d"), aContext.NodeId().Ptr(), aContext.iNodeActivity,
						ACTIVITYID4, aContext.iNode.CountActivities(ACTIVITYID4)));
				if (ACTIVITYID5)
					{
					MESH_LOG((KMeshMachineSubTag, _L8("TActivitiesIdMutex: Node [%08x] Activity [%08x]: [5] Number of actid (%d) = %d"), aContext.NodeId().Ptr(), aContext.iNodeActivity,
							ACTIVITYID5, aContext.iNode.CountActivities(ACTIVITYID5)));
					}
				}
			}
		TInt count = 0;
		count = aContext.iNode.CountActivities(ACTIVITYID1);
		MESH_LOG((KMeshMachineSubTag, _L8("TActivitiesIdMutex: Node [%08x] Activity [%08x]: [1] Number of actid (%d) = %d"), aContext.NodeId().Ptr(), aContext.iNodeActivity, ACTIVITYID1, count));
    	TBool isBlocked = (count != 0);

		count = aContext.iNode.CountActivities(ACTIVITYID2);
		MESH_LOG((KMeshMachineSubTag, _L8("TActivitiesIdMutex: Node [%08x] Activity [%08x]: [2] Number of actid (%d) = %d"), aContext.NodeId().Ptr(), aContext.iNodeActivity, ACTIVITYID2, count));
    	isBlocked |= (count != 0);
		
		if (ACTIVITYID3)
			{
			count = aContext.iNode.CountActivities(ACTIVITYID3);
			MESH_LOG((KMeshMachineSubTag, _L8("TActivitiesIdMutex: Node [%08x] Activity [%08x]: [3] Number of actid (%d) = %d"), aContext.NodeId().Ptr(), aContext.iNodeActivity, ACTIVITYID3, count));
			isBlocked |= (count != 0);

			if (ACTIVITYID4)
				{
				count = aContext.iNode.CountActivities(ACTIVITYID4);
				MESH_LOG((KMeshMachineSubTag, _L8("TActivitiesIdMutex: Node [%08x] Activity [%08x]: [4] Number of actid (%d) = %d"), aContext.NodeId().Ptr(), aContext.iNodeActivity, ACTIVITYID4, count));
				isBlocked |= (count != 0);

				if (ACTIVITYID5)
					{
					count = aContext.iNode.CountActivities(ACTIVITYID5);
					MESH_LOG((KMeshMachineSubTag, _L8("TActivitiesIdMutex: Node [%08x] Activity [%08x]: [5] Number of actid (%d) = %d"), aContext.NodeId().Ptr(), aContext.iNodeActivity, ACTIVITYID5, count));
					isBlocked |= (count != 0);
					}
				}
			}
		
		return isBlocked;
    	}
	};

/**
Mutex checking all activities
*/
class TAllActivitiesMutex
	{
public:
	/**
	@param aContext context in which to evaluate the mutexes
	@return ETrue if there are any activities running, EFalse otherwise
	*/
    inline static TBool IsBlocked(const MeshMachine::TNodeContextBase& aContext)
    	{
		TInt count = aContext.iNode.CountAllActivities();
		MESH_LOG((KMeshMachineSubTag, _L8("Node [%08x] Activity [%08x]: Count all activities %d"), aContext.NodeId().Ptr(), aContext.iNodeActivity, count));
    	return count != 0;
    	}
	};

/**
Mutex checking presence of a particular client
@param TMATCHPOLICY Match policy
@param TYPE Type to match against
@param FLAGS Flags to match against

@see ANodeBase::CountClients
*/
template <class TMATCHPOLICY, TInt TYPE, TInt FLAGS = 0>
class TClientMutex
	{
public:
	/**
	@param aContext context in which to evaluate the mutexes
	@return ETrue if a client exists which matches the criteria. EFalse otherwise
	*/
    inline static TBool IsBlocked(const MeshMachine::TNodeContextBase& aContext)
    	{
#ifdef __GCCXML__
		return EFalse;
#else
		TInt count = aContext.iNode.CountClients<TMATCHPOLICY>(Messages::TClientType(TYPE,FLAGS));
		MESH_LOG((KMeshMachineSubTag, _L8("TClientMutex Node [%08x] Activity [%08x]: Count Clients (%x, %x) = %d"), aContext.NodeId().Ptr(), aContext.iNodeActivity, TYPE, FLAGS, count));
		return count != 0;
#endif
    	}
	};

/**
Mutex checking lack of presence of a particular client
@param TMATCHPOLICY Match policy
@param TYPE Type to match against
@param FLAGS Flags to match against

@see ANodeBase::CountClients
*/
template <class TMATCHPOLICY, TInt TYPE, TInt FLAGS = 0>
class TNoClientMutex
	{
public:
	/**
	@param aContext context in which to evaluate the mutexes
	@return ETrue if a client does not exist which matches the criteria. EFalse otherwise
	*/
    inline static TBool IsBlocked(const MeshMachine::TNodeContextBase& aContext)
    	{
#ifdef __GCCXML__
		return EFalse;
#else
		TInt count = aContext.iNode.CountClients<TMATCHPOLICY>(Messages::TClientType(TYPE,FLAGS));
		MESH_LOG((KMeshMachineSubTag, _L8("TNoClientMutex Node [%08x] Activity [%08x]: Count Clients (%x, %x) = %d"), aContext.NodeId().Ptr(), aContext.iNodeActivity, TYPE, FLAGS, count));
		return count == 0;
#endif
    	}
	};

} //namespace MeshMachine

#endif
	//SYMBIAN_MM_MUTEXPOLICIES_H