CoreObject clean-up

dream/simulation/ConditionalBuffer.py

@@ -162,8 +162,7 @@ class ConditionalBuffer(QueueManagedJob):
     #===========================================================================
     def canEntityProceed(self, entity=None):
         activeObject=self.getActiveObject()
-        activeObjectQueue=activeObject.getActiveObjectQueue()
-        assert entity in activeObjectQueue, entity.id +' not in the internalQueue of'+ activeObject.id
+        assert activeObject.isInActiveQueue(entity), entity.id +' not in the internalQueue of'+ activeObject.id
         activeEntity=entity
         
         # for entities of type OrderComponent, if they reside at a conditionalBuffer, 

dream/simulation/CoreObject.py

@@ -587,45 +587,6 @@ class CoreObject(Process):
     # =======================================================================    
     def getReceiverObjectQueue(self):
         return self.getReceiverObject().getActiveObjectQueue()
-    
-#     # =======================================================================
-# 	# get the giver object queue in a getEntity transaction. 
-#     # =======================================================================    
-#     def updateGiverObject(self):
-#         activeObject=self
-#         # dummy variables that help prioritize the objects requesting to give objects to the Machine (activeObject)
-#         maxTimeWaiting=0                                            # dummy variable counting the time a predecessor is blocked
-#         giver=None
-#         
-#         # loop through the possible givers to see which have to dispose and which is the one blocked for longer
-#         for object in activeObject.previous:
-#             if(object.haveToDispose(activeObject) and object.receiver==self):
-#                 if(object.downTimeInTryingToReleaseCurrentEntity>0):# and the predecessor has been down while trying to give away the Entity
-#                     timeWaiting=now()-object.timeLastFailureEnded   # the timeWaiting dummy variable counts the time end of the last failure of the giver object
-#                 else:
-#                     timeWaiting=now()-object.timeLastEntityEnded    # in any other case, it holds the time since the end of the Entity processing
-#                 
-#                 #if more than one predecessor have to dispose take the part from the one that is blocked longer
-#                 if(timeWaiting>=maxTimeWaiting): 
-#                     giver=object                 # the object to deliver the Entity to the activeObject is set to the ith member of the previous list
-#                     maxTimeWaiting=timeWaiting    
-#         return giver
-    
-#     # =======================================================================
-#     # get the receiver object 
-#     # =======================================================================
-#     def updateReceiverObject(self):
-#         activeObject=self
-#         # dummy variables that help prioritize the objects requesting to give objects to the Machine (activeObject)
-#         maxTimeWaiting=0                                            # dummy variable counting the time a successor is waiting
-#         receiver=None
-#         for object in activeObject.next:
-#             if(object.canAccept(activeObject)):                     # if a successor can accept an object
-#                 timeWaiting=now()-object.timeLastEntityLeft         # the time it has been waiting is updated and stored in dummy variable timeWaiting
-#                 if(timeWaiting>maxTimeWaiting or maxTimeWaiting==0):# if the timeWaiting is the maximum among the ones of the successors 
-#                     maxTimeWaiting=timeWaiting
-#                     receiver=object                    # set the receiver as the longest waiting possible receiver
-#         return receiver
 	
     # =======================================================================
     # calculates the processing time
@@ -699,13 +660,13 @@ class CoreObject(Process):
     def activeQueueIsEmpty(self):
         return len(self.Res.activeQ)==0
     
-    # =======================================================================
-    # checks if the object is ready to receive an Entity
-    # =======================================================================    
-    def isReadyToGet(self):
-        return True     # set to true since this control was not needed until now. 
-                        # to return canAcceptAndIsRequested() would be more logical, but also computationally expensive
-        #return self.canAcceptAndIsRequested()
+#     # =======================================================================
+#     # checks if the object is ready to receive an Entity
+#     # =======================================================================    
+#     def isReadyToGet(self):
+#         return True     # set to true since this control was not needed until now. 
+#                         # to return canAcceptAndIsRequested() would be more logical, but also computationally expensive
+#         #return self.canAcceptAndIsRequested()
         
     # =======================================================================
     # actions to be carried out when the processing of an Entity ends

dream/simulation/Machine.py

@@ -803,8 +803,7 @@ class Machine(CoreObject):
     #===========================================================================
     def canEntityProceed(self, entity=None):
         activeObject=self.getActiveObject()
-        activeObjectQueue=activeObject.getActiveObjectQueue()
-        assert entity in activeObjectQueue, entity.id +' not in the internalQueue of'+ activeObject.id
+        assert activeObject.isInActiveQueue(entity), entity.id +' not in the internalQueue of'+ activeObject.id
         activeEntity=entity
         
         from Globals import G

dream/simulation/MouldAssemblyBuffer.py

@@ -186,8 +186,7 @@ class MouldAssemblyBuffer(QueueManagedJob):
     #===========================================================================
     def canEntityProceed(self, entity=None):
         activeObject=self.getActiveObject()
-        activeObjectQueue=activeObject.getActiveObjectQueue()
-        assert entity in activeObjectQueue, entity.id +' not in the internalQueue of'+ activeObject.id
+        assert activeObject.isInActiveQueue(entity), entity.id +' not in the internalQueue of'+ activeObject.id
         activeEntity=entity
         
         # unassembled components of a mould must wait at a MouldAssemblyBuffer till the componentsReadyForAssembly flag is raised 

dream/simulation/Queue.py

@@ -203,8 +203,7 @@ class Queue(CoreObject):
     #===========================================================================
     def canEntityProceed(self, entity=None):
         activeObject=self.getActiveObject()
-        activeObjectQueue=activeObject.getActiveObjectQueue()
-        assert entity in activeObjectQueue, entity.id +' not in the internalQueue of'+ activeObject.id
+        assert activeObject.isInActiveQueue(entity), entity.id +' not in the internalQueue of'+ activeObject.id
         activeEntity=entity
         
         mayProceed=False