public void Schedule(IScheduledItem item) { if (item == null) { return; } ScheduledItem scheduledItem = item as ScheduledItem; if (scheduledItem == null) { throw new NotSupportedException("Scheduled Item type is not supported by this scheduler"); } if (m_TransactionMode) { m_ScheduleTransactions.Add(scheduledItem); } else { if (m_ScheduledItems.Contains(scheduledItem)) { throw new ArgumentException(string.Concat("Cannot schedule function ", scheduledItem, " more than once")); } else { m_ScheduledItems.Add(scheduledItem); } } }
public void UpdateScheduledEvents() { try { this.m_TransactionMode = true; long num = Panel.TimeSinceStartupMs(); int count = this.m_ScheduledItems.Count; long num2 = num + 20L; int num3 = this.m_LastUpdatedIndex + 1; if (num3 >= count) { num3 = 0; } for (int i = 0; i < count; i++) { num = Panel.TimeSinceStartupMs(); if (!this.disableThrottling && num >= num2) { break; } int num4 = num3 + i; if (num4 >= count) { num4 -= count; } ScheduledItem scheduledItem = this.m_ScheduledItems[num4]; if (num - scheduledItem.delayMs >= scheduledItem.startMs) { TimerState state = new TimerState { start = scheduledItem.startMs, now = num }; scheduledItem.PerformTimerUpdate(state); scheduledItem.startMs = num; scheduledItem.delayMs = scheduledItem.intervalMs; if (scheduledItem.ShouldUnschedule()) { this.Unschedule(scheduledItem); } } this.m_LastUpdatedIndex = num4; } } finally { this.m_TransactionMode = false; for (int j = 0; j < this.m_UnscheduleTransactions.Count; j++) { this.Unschedule(this.m_UnscheduleTransactions[j]); } this.m_UnscheduleTransactions.Clear(); for (int k = 0; k < this.m_ScheduleTransactions.Count; k++) { this.Schedule(this.m_ScheduleTransactions[k]); } this.m_ScheduleTransactions.Clear(); } }
public ScheduleBuilder Until(Func <bool> condition) { if (this.m_ScheduledItem != null) { ScheduledItem expr_12 = this.m_ScheduledItem; expr_12.timerUpdateStopCondition = (Func <bool>)Delegate.Combine(expr_12.timerUpdateStopCondition, condition); } return(this); }
public static bool Matches(ScheduledItem item, ActionType updateEvent) { VisualElementScheduledItem <ActionType> vItem = item as VisualElementScheduledItem <ActionType>; if (vItem != null) { return(EqualityComparer <ActionType> .Default.Equals(vItem.updateEvent, updateEvent)); } return(false); }
private void Schedule(ScheduledItem scheduleItem) { if (this.m_ScheduledItems.Contains(scheduleItem)) { Debug.LogError("Cannot schedule function " + scheduleItem.timerUpdateEvent + " more than once"); } else { this.m_ScheduledItems.Add(scheduleItem); } }
public void UpdateScheduledEvents() { try { this.m_TransactionMode = true; long num = (long)(Time.realtimeSinceStartup * 1000f); int count = this.m_ScheduledItems.Count; int num2 = this.m_LastUpdatedIndex + 1; if (num2 >= count) { num2 = 0; } for (int i = 0; i < count; i++) { int num3 = num2 + i; if (num3 >= count) { num3 -= count; } ScheduledItem scheduledItem = this.m_ScheduledItems[num3]; if (num - scheduledItem.delayMs >= scheduledItem.startMs) { TimerState state = new TimerState { start = scheduledItem.startMs, now = num }; scheduledItem.PerformTimerUpdate(state); scheduledItem.startMs = num; scheduledItem.delayMs = scheduledItem.intervalMs; if (scheduledItem.ShouldUnschedule()) { this.Unschedule(scheduledItem); } } this.m_LastUpdatedIndex = num3; } } finally { this.m_TransactionMode = false; for (int j = 0; j < this.m_UnscheduleTransactions.Count; j++) { this.Unschedule(this.m_UnscheduleTransactions[j]); } this.m_UnscheduleTransactions.Clear(); for (int k = 0; k < this.m_ScheduleTransactions.Count; k++) { this.Schedule(this.m_ScheduleTransactions[k]); } this.m_ScheduleTransactions.Clear(); } }
public void UpdateScheduledEvents() { try { this.m_TransactionMode = true; long num = (long)(Time.realtimeSinceStartup * 1000f); for (int i = 0; i < this.m_ScheduledItems.Count; i++) { ScheduledItem scheduledItem = this.m_ScheduledItems[i]; if (scheduledItem.handler.panel == null) { Debug.Log("Will unschedule action of " + scheduledItem.handler + " because it has no panel"); this.Unschedule(scheduledItem.timerUpdateEvent); } else if (scheduledItem.IsUpdatable()) { TimerState obj = new TimerState { start = scheduledItem.start, now = num }; if (num - scheduledItem.delay > scheduledItem.start) { if (scheduledItem.timerUpdateEvent != null) { scheduledItem.timerUpdateEvent(obj); } scheduledItem.start = num; scheduledItem.delay = scheduledItem.interval; if (scheduledItem.timerUpdateStopCondition != null && scheduledItem.timerUpdateStopCondition()) { this.Unschedule(scheduledItem.timerUpdateEvent); } } } } } finally { this.m_TransactionMode = false; for (int j = 0; j < this.m_UnscheduleTransactions.Count; j++) { this.Unschedule(this.m_UnscheduleTransactions[j]); } this.m_UnscheduleTransactions.Clear(); for (int k = 0; k < this.m_ScheduleTansactions.Count; k++) { this.Schedule(this.m_ScheduleTansactions[k]); } this.m_ScheduleTansactions.Clear(); } }
public ScheduleBuilder Schedule(Action <TimerState> timerUpdateEvent, IEventHandler handler) { ScheduledItem scheduledItem = new ScheduledItem(timerUpdateEvent, handler); if (this.m_TransactionMode) { this.m_ScheduleTansactions.Add(scheduledItem); } else { this.Schedule(scheduledItem); } return(new ScheduleBuilder(scheduledItem)); }
public void Unschedule(IScheduledItem item) { ScheduledItem scheduledItem = item as ScheduledItem; if (scheduledItem != null) { if (this.m_TransactionMode) { this.m_UnscheduleTransactions.Add(scheduledItem); } else if (!this.RemovedScheduledItemAt(this.m_ScheduledItems.IndexOf(scheduledItem))) { throw new ArgumentException("Cannot unschedule unknown scheduled function " + scheduledItem); } } }
private bool RemovedScheduledItemAt(int index) { bool result; if (index >= 0) { ScheduledItem scheduledItem = this.m_ScheduledItems[index]; this.m_ScheduledItems.RemoveAt(index); scheduledItem.OnItemUnscheduled(); result = true; } else { result = false; } return(result); }
public void Unschedule(Action <TimerState> timerUpdateEvent) { if (this.m_TransactionMode) { this.m_UnscheduleTransactions.Add(timerUpdateEvent); } else { ScheduledItem scheduledItem = this.m_ScheduledItems.Find((ScheduledItem t) => t.timerUpdateEvent == timerUpdateEvent); if (scheduledItem != null) { this.m_ScheduledItems.Remove(scheduledItem); } else { Debug.LogError("Cannot unschedule unknown scheduled function " + timerUpdateEvent); } } }
public void Unschedule(IScheduledItem item) { ScheduledItem sItem = item as ScheduledItem; if (sItem != null) { if (m_TransactionMode) { m_UnscheduleTransactions.Add(sItem); //TODO: optimize this, we lose the item and need to re-search } else { if (!RemovedScheduledItemAt(m_ScheduledItems.IndexOf(sItem))) { throw new ArgumentException("Cannot unschedule unknown scheduled function " + sItem); } } } }
public void Unschedule(IScheduledItem item) { ScheduledItem sItem = item as ScheduledItem; if (sItem != null) { if (m_TransactionMode) { if (m_UnscheduleTransactions.Contains(sItem)) { throw new ArgumentException("Cannot unschedule scheduled function twice" + sItem); } else if (m_ScheduleTransactions.Remove(sItem)) { // A item has been scheduled then unscheduled in the same transaction. which is valid. } else if (m_ScheduledItems.Contains(sItem)) { // Only add it to m_UnscheduleTransactions if it is in m_ScheduledItems. // if it was successfully removed from m_ScheduleTransaction we are fine. m_UnscheduleTransactions.Add(sItem); } else { throw new ArgumentException("Cannot unschedule unknown scheduled function " + sItem); } } else { if (!PrivateUnSchedule(sItem)) { throw new ArgumentException("Cannot unschedule unknown scheduled function " + sItem); } } sItem.OnItemUnscheduled(); // Call OnItemUnscheduled immediately after successful removal even if we are in transaction mode } }
public void Schedule(IScheduledItem item) { if (item != null) { ScheduledItem scheduledItem = item as ScheduledItem; if (scheduledItem == null) { throw new NotSupportedException("Scheduled Item type is not supported by this scheduler"); } if (this.m_TransactionMode) { this.m_ScheduleTransactions.Add(scheduledItem); } else { if (this.m_ScheduledItems.Contains(scheduledItem)) { throw new ArgumentException("Cannot schedule function " + scheduledItem + " more than once"); } this.m_ScheduledItems.Add(scheduledItem); } } }
internal ScheduleBuilder(ScheduledItem scheduledItem) { this.m_ScheduledItem = scheduledItem; }
public void UpdateScheduledEvents() { try { m_TransactionMode = true; // TODO: On a GAME Panel game time should be per frame and not change during a frame. // TODO: On an Editor Panel time should be real time long currentTime = Panel.TimeSinceStartupMs(); int itemsCount = m_ScheduledItems.Count; const long maxMsPerUpdate = 20; long maxTime = currentTime + maxMsPerUpdate; int startIndex = m_LastUpdatedIndex + 1; if (startIndex >= itemsCount) { startIndex = 0; } for (int i = 0; i < itemsCount; i++) { currentTime = Panel.TimeSinceStartupMs(); if (!disableThrottling && currentTime >= maxTime) { //We spent too much time on this frame updating items, we break for now, we'll resume next frame break; } int index = startIndex + i; if (index >= itemsCount) { index -= itemsCount; } ScheduledItem scheduledItem = m_ScheduledItems[index]; if (currentTime - scheduledItem.delayMs >= scheduledItem.startMs) { TimerState timerState = new TimerState { start = scheduledItem.startMs, now = currentTime }; if (!m_UnscheduleTransactions.Contains(scheduledItem)) // Don't execute items that have been amrker for future removal { scheduledItem.PerformTimerUpdate(timerState); } scheduledItem.startMs = currentTime; scheduledItem.delayMs = scheduledItem.intervalMs; if (scheduledItem.ShouldUnschedule() && !m_UnscheduleTransactions.Contains(scheduledItem)) // if the scheduledItem has been unscheduled explicitly in PerformTimerUpdate then it will be in m_UnscheduleTransactions and we shouldn't // unschedule it again { Unschedule(scheduledItem); } } m_LastUpdatedIndex = index; } } finally { m_TransactionMode = false; // Rule: remove unscheduled transactions first foreach (var item in m_UnscheduleTransactions) { PrivateUnSchedule(item); } m_UnscheduleTransactions.Clear(); // Then add scheduled transactions foreach (var item in m_ScheduleTransactions) { Schedule(item); } m_ScheduleTransactions.Clear(); } }
bool PrivateUnSchedule(ScheduledItem sItem) { return(m_ScheduleTransactions.Remove(sItem) || RemovedScheduledItemAt(m_ScheduledItems.IndexOf(sItem))); }
public void UpdateScheduledEvents() { try { m_TransactionMode = true; // TODO: On a GAME Panel game time should be per frame and not change during a frame. // TODO: On an Editor Panel time should be real time long currentTime = Panel.TimeSinceStartupMs(); int itemsCount = m_ScheduledItems.Count; const long maxMsPerUpdate = 20; long maxTime = currentTime + maxMsPerUpdate; int startIndex = m_LastUpdatedIndex + 1; if (startIndex >= itemsCount) { startIndex = 0; } for (int i = 0; i < itemsCount; i++) { currentTime = Panel.TimeSinceStartupMs(); if (!disableThrottling && currentTime >= maxTime) { //We spent too much time on this frame updating items, we break for now, we'll resume next frame break; } int index = startIndex + i; if (index >= itemsCount) { index -= itemsCount; } ScheduledItem scheduledItem = m_ScheduledItems[index]; if (currentTime - scheduledItem.delayMs >= scheduledItem.startMs) { TimerState timerState = new TimerState { start = scheduledItem.startMs, now = currentTime }; scheduledItem.PerformTimerUpdate(timerState); scheduledItem.startMs = currentTime; scheduledItem.delayMs = scheduledItem.intervalMs; if (scheduledItem.ShouldUnschedule()) { Unschedule(scheduledItem); } } m_LastUpdatedIndex = index; } } finally { m_TransactionMode = false; // Rule: remove unscheduled transactions first for (int s = 0; s < m_UnscheduleTransactions.Count; s++) { Unschedule(m_UnscheduleTransactions[s]); } m_UnscheduleTransactions.Clear(); // Then add scheduled transactions for (int s = 0; s < m_ScheduleTransactions.Count; s++) { Schedule(m_ScheduleTransactions[s]); } m_ScheduleTransactions.Clear(); } }