Esempio n. 1
0
        public static void insertAfter(EventQueue p_eventQueue, AEvent p_comparisonEvent, AEvent p_insertedEvent)
        {
            int l_index = p_eventQueue.Events.IndexOf(p_comparisonEvent);

            // If the event has been found in the EventQueue.
            if (l_index >= 0)
            {
                insertEventAt(p_eventQueue, l_index + 1, p_insertedEvent);
            }
        }
Esempio n. 2
0
 public static IEnumerator <EVENT> get_allEvents <EVENT>(EventQueue p_eventQueue) where EVENT : AEvent
 {
     for (int i = 0; i < p_eventQueue.Events.Count; i++)
     {
         AEvent l_event = p_eventQueue.Events[i];
         if (l_event is EVENT)
         {
             yield return(l_event as EVENT);
         }
     }
 }
Esempio n. 3
0
        public static void iterate(EventQueue p_eventQueue)
        {
            while (p_eventQueue.Events.Count > 0)
            {
                //Pop the first element
                AEvent l_firstEvent = p_eventQueue.Events[0];

                AAsyncEvent l_firstEventAsAsync = l_firstEvent as AAsyncEvent;
                if (l_firstEventAsAsync != null)
                {
                    if (!l_firstEventAsAsync.IsRunning && !l_firstEventAsAsync.IsCompleted())
                    {
                        l_firstEventAsAsync.IsRunning = true;
                        l_firstEventAsAsync.Execute(p_eventQueue);
                    }

                    if (l_firstEventAsAsync.IsRunning)
                    {
                        l_firstEventAsAsync.ExecuteEveryIteration();

                        if (l_firstEventAsAsync.IsCompleted())
                        {
                            p_eventQueue.Events.RemoveAt(0);
                            EventQueueListener.onEventExecuted(EventQueueListener.UniqueInstance, p_eventQueue, l_firstEvent);
                            l_firstEventAsAsync.IsRunning = false;
                            l_firstEventAsAsync.OnCompleted(p_eventQueue);
                            OnEventExecuted?.Invoke(l_firstEvent);
                        }
                        else
                        {
                            break;
                        }
                    }
                }
                else
                {
                    p_eventQueue.Events.RemoveAt(0);
                    l_firstEvent.Execute(p_eventQueue);
                    EventQueueListener.onEventExecuted(EventQueueListener.UniqueInstance, p_eventQueue, l_firstEvent);
                    OnEventExecuted?.Invoke(l_firstEvent);
                }
            }
        }
Esempio n. 4
0
 public void I_OnEventExecuted(EventQueue p_eventQueue, AEvent p_event)
 {
     OnEventExecuted(p_eventQueue, (EVENT)p_event);
 }
Esempio n. 5
0
        public static void onEventExecuted(EventQueueListener p_eventQueueListener, EventQueue p_eventQueue, AEvent p_event)
        {
            Type l_eventType = p_event.GetType();

            if (p_eventQueueListener.EventsListener.ContainsKey(l_eventType))
            {
                List <IEventListener> l_eventListeners = p_eventQueueListener.EventsListener[l_eventType];
                for (int i = l_eventListeners.Count - 1; i >= 0; i--)
                {
                    l_eventListeners[i].I_OnEventExecuted(p_eventQueue, p_event);
                }
            }
        }
Esempio n. 6
0
 public static void enqueueEvent(EventQueue p_eventQueue, AEvent p_event)
 {
     p_eventQueue.Events.Add(p_event);
 }
Esempio n. 7
0
 public static void insertEventAt(EventQueue p_eventQueue, int p_insersionIndex, AEvent p_insertedEvent)
 {
     p_eventQueue.Events.Insert(p_insersionIndex, p_insertedEvent);
 }