Source: Scheduler.js

  1. const EventEmitter = require('events').EventEmitter
  2. , absMethod = 'Abstract method'
  3. , { Observable, fromEvent } = require('rxjs')
  4. , { filter } = require('rxjs/operators')
  5. , { Schedule, ScheduleEvent, PreliminaryScheduleEvent } = require('./Schedule');
  8. /**
  9.  * Generic scheduler class that can emit events of type T. The purpose
  10.  * of this scheduler is to notify when an event occurs or something should
  11.  * be executed. It shall be used as base-class to other schedulers. It is
  12.  * not to be used for executing jobs, use an appropriate queue for that.
  13.  * Although providing Observables, Schedulers never error or complete.
  14.  * 
  15.  * @author Sebastian Hönel <development@hoenel.net>
  16.  * @extends {EventEmitter}
  17.  * @template T
  18.  */
  19. class Scheduler extends EventEmitter {
  20. 	/**
  21. 	 * @param {Symbol} schedulerSymbol The symbol that is used for emitting
  22. 	 * events from this Scheduler.
  23. 	 */
  24. 	constructor(schedulerSymbol) {
  25. 		super();
  26. 		/** @protected */
  27. 		this._symbol = schedulerSymbol;
  28. 		/**
  29. 		 * @protected
  30. 		 * @type {Observable<T>}
  31. 		 */
  32. 		this._observable = fromEvent(this, schedulerSymbol);
  33. 	};
  35. 	/**
  36. 	 * Returns the same Observable<T> to every subscriber. Note that this Observable
  37. 	 * never errors or drains. You will need to observe a particular Schedule to get
  38. 	 * its errors or completion. The Observable never errors or completes.
  39. 	 * 
  40. 	 * @template T Must be of type ScheduleEvent or more derived.
  41. 	 * @type {Observable<T|ScheduleEvent>}
  42. 	 */
  43. 	get observable() {
  44. 		return this._observable;
  45. 	};
  47. 	/**
  48. 	 * @template T Must be of type ScheduleEvent or more derived.
  49. 	 * @param {T|Schedule} schedule
  50. 	 * @returns {Observable<T|ScheduleEvent>} An Observable for the designated schedule.
  51. 	 */
  52. 	getObservableForSchedule(schedule) {
  53. 		return this.observable.pipe(filter(evt => evt.schedule === schedule));
  54. 	};
  56. 	/**
  57. 	 * Add a Schedule to this scheduler. This is an abstract method.
  58. 	 * 
  59. 	 * @param {Schedule} schedule
  60. 	 * @returns {this}
  61. 	 */
  62. 	addSchedule(schedule) {
  63. 		throw new Error(absMethod);
  64. 	};
  66. 	/**
  67. 	 * Remove a Schedule from this scheduler. This is an abstract method.
  68. 	 * 
  69. 	 * @param {Schedule} schedule
  70. 	 * @returns {this}
  71. 	 */
  72. 	removeSchedule(schedule) {
  73. 		throw new Error(absMethod);
  74. 	};
  76. 	/**
  77. 	 * Removes all Schedules from this scheduler. This is an abstract methdod.
  78. 	 * 
  79. 	 * @returns {Array<Schedule>} All Schedules as array.
  80. 	 */
  81. 	removeAllSchedules() {
  82. 		throw new Error(absMethod);
  83. 	};
  85. 	/**
  86. 	 * Returns a value indicating whether this Scheduler has the given
  87. 	 * Schedule. This is an abstract method.
  88. 	 * 
  89. 	 * @param {Schedule} schedule
  90. 	 * @returns {this}
  91. 	 */
  92. 	hasSchedule(schedule) {
  93. 		throw new Error(absMethod);
  94. 	};
  96. 	/**
  97. 	 * A generator that supposedly yields all schedules' preliminary events.
  98. 	 * 
  99. 	 * @template T Must be of type PreliminaryScheduleEvent or more derived.
  100. 	 * @param {Date} [after] Optional. Defaults to undefined.
  101. 	 * @param {Date} [before] Optional. Defaults to undefined.
  102. 	 * @returns {IterableIterator<PreliminaryScheduleEvent<T|Schedule, any>>}
  103. 	 */
  104. 	*preliminaryEvents(after, before) {
  105. 	};
  106. };
  108. module.exports = Object.freeze({
  109. 	Scheduler
  110. });