/// <summary> /// Removes the given item from the collection /// </summary> /// <returns>True, if the item was removed, otherwise False</returns> /// <param name="item">The item that should be removed</param> public override bool Remove(IModelElement item) { if ((this._parent.Status == item)) { this._parent.Status = null; return true; } IScheduledEvent scheduledEventItem = item.As<IScheduledEvent>(); if (((scheduledEventItem != null) && this._parent.ScheduledEvents.Remove(scheduledEventItem))) { return true; } if ((this._parent.Window == item)) { this._parent.Window = null; return true; } if ((this._parent.TimeSchedule == item)) { this._parent.TimeSchedule = null; return true; } return false; }
/// <summary> /// Adds the given element to the collection /// </summary> /// <param name="item">The item to add</param> public override void Add(IModelElement item) { if ((this._parent.Status == null)) { IStatus statusCasted = item.As<IStatus>(); if ((statusCasted != null)) { this._parent.Status = statusCasted; return; } } IScheduledEvent scheduledEventsCasted = item.As<IScheduledEvent>(); if ((scheduledEventsCasted != null)) { this._parent.ScheduledEvents.Add(scheduledEventsCasted); } if ((this._parent.Window == null)) { IDateTimeInterval windowCasted = item.As<IDateTimeInterval>(); if ((windowCasted != null)) { this._parent.Window = windowCasted; return; } } if ((this._parent.TimeSchedule == null)) { ITimeSchedule timeScheduleCasted = item.As<ITimeSchedule>(); if ((timeScheduleCasted != null)) { this._parent.TimeSchedule = timeScheduleCasted; return; } } }
public void ScheduleEvent(int source, IScheduledEvent @event) { // The resolution of our scheduler (Task.Delay) is approximately 15ms (on Windows), which should be sufficient for our purposes Task.Delay(@event.ScheduledPeriod) .ContinueWith(t => RaiseEvent(source, @event)) .ContinueWith(t => ScheduleEvent(source, @event), TaskContinuationOptions.ExecuteSynchronously); }
/// <summary> /// Cancel a previously scheduled event. /// </summary> /// <param name="evt">The event to cancel</param> /// <returns>Returns true if the given event was successfully removed form the event queue</returns> public bool CancelEvent(IScheduledEvent evt) { if (_eventQueue.Remove(evt)) { Console.WriteLine($"{DateTime.Now} : Cancelled {evt.GetType().Name} previously scheduled @ {evt.ScheduledTime}"); return(true); } return(false); }
public void ScheduleEvent(int source, IScheduledEvent @event) { var token = _cancellationTokenSource.Token; // The resolution of our scheduler (Task.Delay) is approximately 15ms (on Windows), which should be sufficient for our purposes Task.Delay(@event.ScheduledPeriod, token) .ContinueWith(t => RaiseEvent(source, @event), token) .ContinueWith(t => ScheduleEvent(source, @event), token, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Current); }
public void Unschedule <T>(IScheduledEvent <T> args) where T : IEvent { if (args == null) { throw new ArgumentNullException(nameof(args)); } this.app.GetScheduledEventHub().Unschedule(args); }
/// <summary> /// Schedule a new event by adding it to the event queue. /// </summary> /// <param name="evt">The event to schedule</param> /// <exception cref="InvalidOperationException">thrown if evt is in the past</exception> public void Schedule(IScheduledEvent evt) { if (evt.ScheduledTime <= DateTime.Now) { throw new InvalidOperationException("A passed event cannot be scheduled."); } _eventQueue.Enqueue(evt); Console.WriteLine($"{DateTime.Now} : Scheduled new {evt.GetType().Name} @ {evt.ScheduledTime}"); }
public void Remove <T>(IScheduledEvent <T> args) where T : IEvent { for (int i = this.queue.Count - 1; i >= 0; i--) { if (object.ReferenceEquals(this.queue[i].ScheduledEvent, args)) { this.RemoveAt(i); return; } } }
/// <summary> /// Called when update interval is elapsed. /// Check the queue to trigger the next event if required. /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void OnTimerElapsed(object sender, ElapsedEventArgs e) { // While there is event that should be triggered at this time while (_eventQueue.Peek()?.ScheduledTime <= e.SignalTime) { IScheduledEvent evt = _eventQueue.Dequeue(); Console.WriteLine($"{DateTime.Now} : {evt.GetType().Name} triggered"); evt.Trigger(this); } }
public void Unschedule <T>(IScheduledEvent <T> args) where T : IEvent { if (args == null) { throw new ArgumentNullException(nameof(args)); } lock (this.queue) { this.queue.Remove(args); } }
/// <summary> /// Adds the given element to the collection /// </summary> /// <param name="item">The item to add</param> public override void Add(IModelElement item) { IScheduledEvent scheduledEventsCasted = item.As <IScheduledEvent>(); if ((scheduledEventsCasted != null)) { this._parent.ScheduledEvents.Add(scheduledEventsCasted); } if ((this._parent.RequestedWindow == null)) { IDateTimeInterval requestedWindowCasted = item.As <IDateTimeInterval>(); if ((requestedWindowCasted != null)) { this._parent.RequestedWindow = requestedWindowCasted; return; } } if ((this._parent.ForInspectionDataSet == null)) { IInspectionDataSet forInspectionDataSetCasted = item.As <IInspectionDataSet>(); if ((forInspectionDataSetCasted != null)) { this._parent.ForInspectionDataSet = forInspectionDataSetCasted; return; } } if ((this._parent.EstimatedWindow == null)) { IDateTimeInterval estimatedWindowCasted = item.As <IDateTimeInterval>(); if ((estimatedWindowCasted != null)) { this._parent.EstimatedWindow = estimatedWindowCasted; return; } } IDocument documentsCasted = item.As <IDocument>(); if ((documentsCasted != null)) { this._parent.Documents.Add(documentsCasted); } if ((this._parent.Status == null)) { IStatus statusCasted = item.As <IStatus>(); if ((statusCasted != null)) { this._parent.Status = statusCasted; return; } } }
public void Schedule <T>(IScheduledEvent <T> args) where T : IEvent { if (args == null) { throw new ArgumentNullException(nameof(args)); } var now = this.app.GetTime(); var item = new PriorityQueueItem <T>(this.app, args); item.MoveToNextOccurrence(now); if (now < item.Occurrence) { lock (this.queue) { this.queue.Push(item); } } }
public void Add_AddsScheduledEventThatIsCalledOnTimePeriod() { IScheduledEvent event1 = NewMock <IScheduledEvent>(); IScheduledEvent event2 = NewMock <IScheduledEvent>(); Expect.Once.On(eventFactory).Method("Create").WithAnyArguments().Will(Return.Value(event1)); Expect.Once.On(eventFactory).Method("Create").WithAnyArguments().Will(Return.Value(event2)); DateTime now = DateTime.Now; Expect.Once.On(clock).GetProperty("Now").Will(Return.Value(now)); Expect.Once.On(clock).GetProperty("Now").Will(Return.Value(now)); scheduler.Add(onScheduledEvent, TimeSpan.FromSeconds(3)); scheduler.Add(onScheduledEvent, TimeSpan.FromSeconds(3)); Assert.AreEqual(0, tickCount); // TODO }
/// <summary> /// Removes the given item from the collection /// </summary> /// <returns>True, if the item was removed, otherwise False</returns> /// <param name="item">The item that should be removed</param> public override bool Remove(IModelElement item) { IScheduledEvent scheduledEventItem = item.As <IScheduledEvent>(); if (((scheduledEventItem != null) && this._parent.ScheduledEvents.Remove(scheduledEventItem))) { return(true); } if ((this._parent.RequestedWindow == item)) { this._parent.RequestedWindow = null; return(true); } if ((this._parent.ForInspectionDataSet == item)) { this._parent.ForInspectionDataSet = null; return(true); } if ((this._parent.EstimatedWindow == item)) { this._parent.EstimatedWindow = null; return(true); } IDocument documentItem = item.As <IDocument>(); if (((documentItem != null) && this._parent.Documents.Remove(documentItem))) { return(true); } if ((this._parent.Status == item)) { this._parent.Status = null; return(true); } return(false); }
// Including the 'source' value as an argument here is an explicit design decision. // Section 9.5.3.1 specifies that this should be passed at the entropy provider level for security reasons, but because all sources are // to be used from within the same Application Domain (and hence same shared memory), this is an acceptable risk. private void RaiseEvent(int source, IScheduledEvent @event) { EntropyAvailable?.Invoke(source, @event.EventCallback()); }
public bool Exists(IScheduledEvent scheduledEvent) => scheduler.Exists(scheduledEvent);
public void Remove(IScheduledEvent scheduledEvent) => scheduler.Remove(scheduledEvent);
public void Add(IScheduledEvent scheduledEvent) => scheduler.Add(scheduledEvent);
public int CompareTo(IScheduledEvent other) { return(ScheduledTime.CompareTo(other.ScheduledTime)); }