/ajax/libs/rxjs/2.4.1/rx.virtualtime.js

// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.



;(function (factory) {

    var objectTypes = {

        'boolean': false,

        'function': true,

        'object': true,

        'number': false,

        'string': false,

        'undefined': false

    };



    var root = (objectTypes[typeof window] && window) || this,

        freeExports = objectTypes[typeof exports] && exports && !exports.nodeType && exports,

        freeModule = objectTypes[typeof module] && module && !module.nodeType && module,

        moduleExports = freeModule && freeModule.exports === freeExports && freeExports,

        freeGlobal = objectTypes[typeof global] && global;



    if (freeGlobal && (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal)) {

        root = freeGlobal;

    }



    // Because of build optimizers

    if (typeof define === 'function' && define.amd) {

        define(['rx'], function (Rx, exports) {

            return factory(root, exports, Rx);

        });

    } else if (typeof module === 'object' && module && module.exports === freeExports) {

        module.exports = factory(root, module.exports, require('./rx'));

    } else {

        root.Rx = factory(root, {}, root.Rx);

    }

}.call(this, function (root, exp, Rx, undefined) {



	// Aliases

	var Scheduler = Rx.Scheduler,

		PriorityQueue = Rx.internals.PriorityQueue,

		ScheduledItem = Rx.internals.ScheduledItem,

		SchedulePeriodicRecursive  = Rx.internals.SchedulePeriodicRecursive,

		disposableEmpty = Rx.Disposable.empty,

		inherits = Rx.internals.inherits,

    defaultSubComparer = Rx.helpers.defaultSubComparer,

		notImplemented = Rx.helpers.notImplemented;



  /** Provides a set of extension methods for virtual time scheduling. */

  Rx.VirtualTimeScheduler = (function (__super__) {



    function localNow() {

      return this.toDateTimeOffset(this.clock);

    }



    function scheduleNow(state, action) {

      return this.scheduleAbsoluteWithState(state, this.clock, action);

    }



    function scheduleRelative(state, dueTime, action) {

      return this.scheduleRelativeWithState(state, this.toRelative(dueTime), action);

    }



    function scheduleAbsolute(state, dueTime, action) {

      return this.scheduleRelativeWithState(state, this.toRelative(dueTime - this.now()), action);

    }



    function invokeAction(scheduler, action) {

      action();

      return disposableEmpty;

    }



    inherits(VirtualTimeScheduler, __super__);



    /**

     * Creates a new virtual time scheduler with the specified initial clock value and absolute time comparer.

     *

     * @constructor

     * @param {Number} initialClock Initial value for the clock.

     * @param {Function} comparer Comparer to determine causality of events based on absolute time.

     */

    function VirtualTimeScheduler(initialClock, comparer) {

      this.clock = initialClock;

      this.comparer = comparer;

      this.isEnabled = false;

      this.queue = new PriorityQueue(1024);

      __super__.call(this, localNow, scheduleNow, scheduleRelative, scheduleAbsolute);

    }



    var VirtualTimeSchedulerPrototype = VirtualTimeScheduler.prototype;



    /**

     * Adds a relative time value to an absolute time value.

     * @param {Number} absolute Absolute virtual time value.

     * @param {Number} relative Relative virtual time value to add.

     * @return {Number} Resulting absolute virtual time sum value.

     */

    VirtualTimeSchedulerPrototype.add = notImplemented;



    /**

     * Converts an absolute time to a number

     * @param {Any} The absolute time.

     * @returns {Number} The absolute time in ms

     */

    VirtualTimeSchedulerPrototype.toDateTimeOffset = notImplemented;



    /**

     * Converts the TimeSpan value to a relative virtual time value.

     * @param {Number} timeSpan TimeSpan value to convert.

     * @return {Number} Corresponding relative virtual time value.

     */

    VirtualTimeSchedulerPrototype.toRelative = notImplemented;



    /**

     * Schedules a periodic piece of work by dynamically discovering the scheduler's capabilities. The periodic task will be emulated using recursive scheduling.

     * @param {Mixed} state Initial state passed to the action upon the first iteration.

     * @param {Number} period Period for running the work periodically.

     * @param {Function} action Action to be executed, potentially updating the state.

     * @returns {Disposable} The disposable object used to cancel the scheduled recurring action (best effort).

     */

    VirtualTimeSchedulerPrototype.schedulePeriodicWithState = function (state, period, action) {

      var s = new SchedulePeriodicRecursive(this, state, period, action);

      return s.start();

    };



    /**

     * Schedules an action to be executed after dueTime.

     * @param {Mixed} state State passed to the action to be executed.

     * @param {Number} dueTime Relative time after which to execute the action.

     * @param {Function} action Action to be executed.

     * @returns {Disposable} The disposable object used to cancel the scheduled action (best effort).

     */

    VirtualTimeSchedulerPrototype.scheduleRelativeWithState = function (state, dueTime, action) {

      var runAt = this.add(this.clock, dueTime);

      return this.scheduleAbsoluteWithState(state, runAt, action);

    };



    /**

     * Schedules an action to be executed at dueTime.

     * @param {Number} dueTime Relative time after which to execute the action.

     * @param {Function} action Action to be executed.

     * @returns {Disposable} The disposable object used to cancel the scheduled action (best effort).

     */

    VirtualTimeSchedulerPrototype.scheduleRelative = function (dueTime, action) {

      return this.scheduleRelativeWithState(action, dueTime, invokeAction);

    };



    /**

     * Starts the virtual time scheduler.

     */

    VirtualTimeSchedulerPrototype.start = function () {

      if (!this.isEnabled) {

        this.isEnabled = true;

        do {

          var next = this.getNext();

          if (next !== null) {

            this.comparer(next.dueTime, this.clock) > 0 && (this.clock = next.dueTime);

            next.invoke();

          } else {

            this.isEnabled = false;

          }

        } while (this.isEnabled);

      }

    };



    /**

     * Stops the virtual time scheduler.

     */

    VirtualTimeSchedulerPrototype.stop = function () {

      this.isEnabled = false;

    };



    /**

     * Advances the scheduler's clock to the specified time, running all work till that point.

     * @param {Number} time Absolute time to advance the scheduler's clock to.

     */

    VirtualTimeSchedulerPrototype.advanceTo = function (time) {

      var dueToClock = this.comparer(this.clock, time);

      if (this.comparer(this.clock, time) > 0) { throw new ArgumentOutOfRangeError(); }

      if (dueToClock === 0) { return; }

      if (!this.isEnabled) {

        this.isEnabled = true;

        do {

          var next = this.getNext();

          if (next !== null && this.comparer(next.dueTime, time) <= 0) {

            this.comparer(next.dueTime, this.clock) > 0 && (this.clock = next.dueTime);

            next.invoke();

          } else {

            this.isEnabled = false;

          }

        } while (this.isEnabled);

        this.clock = time;

      }

    };



    /**

     * Advances the scheduler's clock by the specified relative time, running all work scheduled for that timespan.

     * @param {Number} time Relative time to advance the scheduler's clock by.

     */

    VirtualTimeSchedulerPrototype.advanceBy = function (time) {

      var dt = this.add(this.clock, time),

          dueToClock = this.comparer(this.clock, dt);

      if (dueToClock > 0) { throw new ArgumentOutOfRangeError(); }

      if (dueToClock === 0) {  return; }



      this.advanceTo(dt);

    };



    /**

     * Advances the scheduler's clock by the specified relative time.

     * @param {Number} time Relative time to advance the scheduler's clock by.

     */

    VirtualTimeSchedulerPrototype.sleep = function (time) {

      var dt = this.add(this.clock, time);

      if (this.comparer(this.clock, dt) >= 0) { throw new ArgumentOutOfRangeError(); }



      this.clock = dt;

    };



    /**

     * Gets the next scheduled item to be executed.

     * @returns {ScheduledItem} The next scheduled item.

     */

    VirtualTimeSchedulerPrototype.getNext = function () {

      while (this.queue.length > 0) {

        var next = this.queue.peek();

        if (next.isCancelled()) {

          this.queue.dequeue();

        } else {

          return next;

        }

      }

      return null;

    };



    /**

     * Schedules an action to be executed at dueTime.

     * @param {Scheduler} scheduler Scheduler to execute the action on.

     * @param {Number} dueTime Absolute time at which to execute the action.

     * @param {Function} action Action to be executed.

     * @returns {Disposable} The disposable object used to cancel the scheduled action (best effort).

     */

    VirtualTimeSchedulerPrototype.scheduleAbsolute = function (dueTime, action) {

      return this.scheduleAbsoluteWithState(action, dueTime, invokeAction);

    };



    /**

     * Schedules an action to be executed at dueTime.

     * @param {Mixed} state State passed to the action to be executed.

     * @param {Number} dueTime Absolute time at which to execute the action.

     * @param {Function} action Action to be executed.

     * @returns {Disposable} The disposable object used to cancel the scheduled action (best effort).

     */

    VirtualTimeSchedulerPrototype.scheduleAbsoluteWithState = function (state, dueTime, action) {

      var self = this;



      function run(scheduler, state1) {

        self.queue.remove(si);

        return action(scheduler, state1);

      }



      var si = new ScheduledItem(this, state, run, dueTime, this.comparer);

      this.queue.enqueue(si);



      return si.disposable;

    };



    return VirtualTimeScheduler;

  }(Scheduler));



  /** Provides a virtual time scheduler that uses Date for absolute time and number for relative time. */

  Rx.HistoricalScheduler = (function (__super__) {

    inherits(HistoricalScheduler, __super__);



    /**

     * Creates a new historical scheduler with the specified initial clock value.

     * @constructor

     * @param {Number} initialClock Initial value for the clock.

     * @param {Function} comparer Comparer to determine causality of events based on absolute time.

     */

    function HistoricalScheduler(initialClock, comparer) {

      var clock = initialClock == null ? 0 : initialClock;

      var cmp = comparer || defaultSubComparer;

      __super__.call(this, clock, cmp);

    }



    var HistoricalSchedulerProto = HistoricalScheduler.prototype;



    /**

     * Adds a relative time value to an absolute time value.

     * @param {Number} absolute Absolute virtual time value.

     * @param {Number} relative Relative virtual time value to add.

     * @return {Number} Resulting absolute virtual time sum value.

     */

    HistoricalSchedulerProto.add = function (absolute, relative) {

      return absolute + relative;

    };



    HistoricalSchedulerProto.toDateTimeOffset = function (absolute) {

      return new Date(absolute).getTime();

    };



    /**

     * Converts the TimeSpan value to a relative virtual time value.

     * @memberOf HistoricalScheduler

     * @param {Number} timeSpan TimeSpan value to convert.

     * @return {Number} Corresponding relative virtual time value.

     */

    HistoricalSchedulerProto.toRelative = function (timeSpan) {

      return timeSpan;

    };



    return HistoricalScheduler;

  }(Rx.VirtualTimeScheduler));



    return Rx;

}));