commsfwsupport/commselements/meshmachine/inc/mm_mutexpolicies.h
changeset 22 592244873960
parent 0 dfb7c4ff071f
equal deleted inserted replaced
5:68ef71f0cd72 22:592244873960
    98 	@param aContext context in which to evaluate the mutexes
    98 	@param aContext context in which to evaluate the mutexes
    99 	@return ETrue if operation should be blocked, EFalse if mutex condition has been met
    99 	@return ETrue if operation should be blocked, EFalse if mutex condition has been met
   100 	*/
   100 	*/
   101     inline static TBool IsBlocked(const MeshMachine::TNodeContextBase& aContext)
   101     inline static TBool IsBlocked(const MeshMachine::TNodeContextBase& aContext)
   102     	{
   102     	{
   103 		return aContext.iNode.CountActivities(ACTIVITYID) != 0;
   103 		TInt count = aContext.iNode.CountActivities(ACTIVITYID);
       
   104 		MESH_LOG((KMeshMachineSubTag, _L8("TActivityIdMutex: Node [%08x] Activity [%08x]: Number of actid (%d) = %d"), aContext.NodeId().Ptr(), aContext.iNodeActivity,
       
   105 				 ACTIVITYID, count));
       
   106 
       
   107 		return count != 0;
   104     	}
   108     	}
   105 	};
   109 	};
   106 	
   110 	
   107 /**
   111 /**
   108 Template to block if there is an activity on a node in a non waiting state
   112 Template to block if there is an activity on a node in a non waiting state
   190 	@param aContext context in which to evaluate the mutexes
   194 	@param aContext context in which to evaluate the mutexes
   191 	@return ETrue if there exists all the activities with the specified ids, EFalse otherwise
   195 	@return ETrue if there exists all the activities with the specified ids, EFalse otherwise
   192 	*/
   196 	*/
   193     inline static TBool IsBlocked(const MeshMachine::TNodeContextBase& aContext)
   197     inline static TBool IsBlocked(const MeshMachine::TNodeContextBase& aContext)
   194     	{
   198     	{
   195     	TBool isBlocked = aContext.iNode.CountActivities(ACTIVITYID1) != 0;
   199 
   196     	isBlocked |= aContext.iNode.CountActivities(ACTIVITYID2) != 0;
   200 		MESH_LOG((KMeshMachineSubTag, _L8("TActivitiesIdMutex: Node [%08x] Activity [%08x]: [2] Number of actid (%d) = %d"), aContext.NodeId().Ptr(), aContext.iNodeActivity,
   197     	isBlocked |= (ACTIVITYID3)? aContext.iNode.CountActivities(ACTIVITYID3) != 0 : EFalse;
   201 				ACTIVITYID2, aContext.iNode.CountActivities(ACTIVITYID2)));
   198     	isBlocked |= (ACTIVITYID4)? aContext.iNode.CountActivities(ACTIVITYID4) != 0 : EFalse;
   202 		if (ACTIVITYID3)
   199     	isBlocked |= (ACTIVITYID5)? aContext.iNode.CountActivities(ACTIVITYID5) != 0 : EFalse;
   203 			{
       
   204 			MESH_LOG((KMeshMachineSubTag, _L8("TActivitiesIdMutex: Node [%08x] Activity [%08x]: [3] Number of actid (%d) = %d"), aContext.NodeId().Ptr(), aContext.iNodeActivity,
       
   205 					ACTIVITYID3, aContext.iNode.CountActivities(ACTIVITYID3)));
       
   206 			if (ACTIVITYID4)
       
   207 				{
       
   208 				MESH_LOG((KMeshMachineSubTag, _L8("TActivitiesIdMutex: Node [%08x] Activity [%08x]: [4] Number of actid (%d) = %d"), aContext.NodeId().Ptr(), aContext.iNodeActivity,
       
   209 						ACTIVITYID4, aContext.iNode.CountActivities(ACTIVITYID4)));
       
   210 				if (ACTIVITYID5)
       
   211 					{
       
   212 					MESH_LOG((KMeshMachineSubTag, _L8("TActivitiesIdMutex: Node [%08x] Activity [%08x]: [5] Number of actid (%d) = %d"), aContext.NodeId().Ptr(), aContext.iNodeActivity,
       
   213 							ACTIVITYID5, aContext.iNode.CountActivities(ACTIVITYID5)));
       
   214 					}
       
   215 				}
       
   216 			}
       
   217 		TInt count = 0;
       
   218 		count = aContext.iNode.CountActivities(ACTIVITYID1);
       
   219 		MESH_LOG((KMeshMachineSubTag, _L8("TActivitiesIdMutex: Node [%08x] Activity [%08x]: [1] Number of actid (%d) = %d"), aContext.NodeId().Ptr(), aContext.iNodeActivity, ACTIVITYID1, count));
       
   220     	TBool isBlocked = (count != 0);
       
   221 
       
   222 		count = aContext.iNode.CountActivities(ACTIVITYID2);
       
   223 		MESH_LOG((KMeshMachineSubTag, _L8("TActivitiesIdMutex: Node [%08x] Activity [%08x]: [2] Number of actid (%d) = %d"), aContext.NodeId().Ptr(), aContext.iNodeActivity, ACTIVITYID2, count));
       
   224     	isBlocked |= (count != 0);
       
   225 		
       
   226 		if (ACTIVITYID3)
       
   227 			{
       
   228 			count = aContext.iNode.CountActivities(ACTIVITYID3);
       
   229 			MESH_LOG((KMeshMachineSubTag, _L8("TActivitiesIdMutex: Node [%08x] Activity [%08x]: [3] Number of actid (%d) = %d"), aContext.NodeId().Ptr(), aContext.iNodeActivity, ACTIVITYID3, count));
       
   230 			isBlocked |= (count != 0);
       
   231 
       
   232 			if (ACTIVITYID4)
       
   233 				{
       
   234 				count = aContext.iNode.CountActivities(ACTIVITYID4);
       
   235 				MESH_LOG((KMeshMachineSubTag, _L8("TActivitiesIdMutex: Node [%08x] Activity [%08x]: [4] Number of actid (%d) = %d"), aContext.NodeId().Ptr(), aContext.iNodeActivity, ACTIVITYID4, count));
       
   236 				isBlocked |= (count != 0);
       
   237 
       
   238 				if (ACTIVITYID5)
       
   239 					{
       
   240 					count = aContext.iNode.CountActivities(ACTIVITYID5);
       
   241 					MESH_LOG((KMeshMachineSubTag, _L8("TActivitiesIdMutex: Node [%08x] Activity [%08x]: [5] Number of actid (%d) = %d"), aContext.NodeId().Ptr(), aContext.iNodeActivity, ACTIVITYID5, count));
       
   242 					isBlocked |= (count != 0);
       
   243 					}
       
   244 				}
       
   245 			}
       
   246 		
   200 		return isBlocked;
   247 		return isBlocked;
   201     	}
   248     	}
   202 	};
   249 	};
   203 
   250 
   204 /**
   251 /**
   211 	@param aContext context in which to evaluate the mutexes
   258 	@param aContext context in which to evaluate the mutexes
   212 	@return ETrue if there are any activities running, EFalse otherwise
   259 	@return ETrue if there are any activities running, EFalse otherwise
   213 	*/
   260 	*/
   214     inline static TBool IsBlocked(const MeshMachine::TNodeContextBase& aContext)
   261     inline static TBool IsBlocked(const MeshMachine::TNodeContextBase& aContext)
   215     	{
   262     	{
   216     	return aContext.iNode.CountAllActivities() != 0;
   263 		TInt count = aContext.iNode.CountAllActivities();
       
   264 		MESH_LOG((KMeshMachineSubTag, _L8("Node [%08x] Activity [%08x]: Count all activities %d"), aContext.NodeId().Ptr(), aContext.iNodeActivity, count));
       
   265     	return count != 0;
   217     	}
   266     	}
   218 	};
   267 	};
   219 
   268 
   220 /**
   269 /**
   221 Mutex checking presence of a particular client
   270 Mutex checking presence of a particular client
   236     inline static TBool IsBlocked(const MeshMachine::TNodeContextBase& aContext)
   285     inline static TBool IsBlocked(const MeshMachine::TNodeContextBase& aContext)
   237     	{
   286     	{
   238 #ifdef __GCCXML__
   287 #ifdef __GCCXML__
   239 		return EFalse;
   288 		return EFalse;
   240 #else
   289 #else
   241 		return aContext.iNode.CountClients<TMATCHPOLICY>(Messages::TClientType(TYPE,FLAGS)) != 0;
   290 		TInt count = aContext.iNode.CountClients<TMATCHPOLICY>(Messages::TClientType(TYPE,FLAGS));
       
   291 		MESH_LOG((KMeshMachineSubTag, _L8("TClientMutex Node [%08x] Activity [%08x]: Count Clients (%x, %x) = %d"), aContext.NodeId().Ptr(), aContext.iNodeActivity, TYPE, FLAGS, count));
       
   292 		return count != 0;
   242 #endif
   293 #endif
   243     	}
   294     	}
   244 	};
   295 	};
   245 
   296 
   246 /**
   297 /**
   262     inline static TBool IsBlocked(const MeshMachine::TNodeContextBase& aContext)
   313     inline static TBool IsBlocked(const MeshMachine::TNodeContextBase& aContext)
   263     	{
   314     	{
   264 #ifdef __GCCXML__
   315 #ifdef __GCCXML__
   265 		return EFalse;
   316 		return EFalse;
   266 #else
   317 #else
   267 		return aContext.iNode.CountClients<TMATCHPOLICY>(Messages::TClientType(TYPE,FLAGS)) == 0;
   318 		TInt count = aContext.iNode.CountClients<TMATCHPOLICY>(Messages::TClientType(TYPE,FLAGS));
       
   319 		MESH_LOG((KMeshMachineSubTag, _L8("TNoClientMutex Node [%08x] Activity [%08x]: Count Clients (%x, %x) = %d"), aContext.NodeId().Ptr(), aContext.iNodeActivity, TYPE, FLAGS, count));
       
   320 		return count == 0;
   268 #endif
   321 #endif
   269     	}
   322     	}
   270 	};
   323 	};
   271 
   324 
   272 } //namespace MeshMachine
   325 } //namespace MeshMachine