README.md

Rx.VirtualTimeScheduler class

Base class for providing scheduling in virtual time. This inherits from the Rx.Scheduler class.

Usage

The following shows an example of using the Rx.VirtualTimeScheduler. In order for this to work, you must implement the add, toDateTimeOffset and toRelative methods as described below.

/* Comparer required for scheduling priority */
function comparer (x, y) {
    if (x > y) { return 1; }
    if (x < y) { return -1; }
    return 0;
}

var scheduler = new Rx.VirtualTimeScheduler(0, comparer);

/**
 * Adds a relative time value to an absolute time value.
 * @param {Any} absolute Absolute virtual time value.
 * @param {Any} relative Relative virtual time value to add.
 * @return {Any} Resulting absolute virtual time sum value.
 */
scheduler.add = function (absolute, relative) {
    return absolute + relative;
};

/**
 * Converts an absolute time to a number
 * @param {Number} The absolute time in ms
 * @returns {Number} The absolute time in ms
 */
scheduler.toDateTimeOffset = function (absolute) {
    return new Date(absolute).getTime();
};

/**
 * Converts the time span number/Date to a relative virtual time value.
 * @param {Number} timeSpan TimeSpan value to convert.
 * @return {Number} Corresponding relative virtual time value.
 */
scheduler.toRelative = function (timeSpan) {
    return timeSpan;
};

// Schedule some time
scheduler.scheduleAbsolute(1, function () { console.log('foo'); });
scheduler.scheduleAbsolute(2, function () { console.log('bar'); });
scheduler.scheduleAbsolute(3, function () { scheduler.stop(); });

// Start the scheduler
scheduler.start();

// => foo
// => bar

// Check the clock once stopped
console.log(scheduler.now());
// => 3

console.log(scheduler.clock);
// => 3

Location

• rx.virtualtime.js

VirtualTimeScheduler Constructor

• constructor

VirtualTimeScheduler Instance Methods

• advanceBy
• advanceTo
• scheduleAbsolute
• scheduleAbsoluteWithState
• scheduleRelative
• scheduleRelativeWithState
• sleep
• start
• stop

VirtualTimeScheduler Instance Properties

• isEnabled

VirtualTimeScheduler Protected Abstract Methods

• add
• toDateTimeOffset
• toRelative

VirtualTimeScheduler Protected Methods

• getNext

Inherited Classes

• Rx.Scheduler

VirtualTimeScheduler Constructor

Rx.VirtualTimeScheduler(initialClock, comparer)

# Ⓢ

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

Arguments

1. initialClock (Function): Initial value for the clock.
2. comparer (Function): Comparer to determine causality of events based on absolute time.

Example

function comparer (x, y) {
    if (x > y) { return 1; }
    if (x < y) { return -1; }
    return 0;
}

var scheduler = new Rx.VirtualTimeScheduler(
    0,          /* initial clock of 0 */
    comparer    /* comparer for determining order */
);

Location

• rx.virtualtime.js

---

VirtualTimeScheduler Instance Methods

Rx.VirtualTimeScheduler.prototype.advanceBy(time)

# Ⓢ

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

Arguments

1. time (Any): Relative time to advance the scheduler's clock by.

Example

var scheduler = new MyVirtualScheduler(
    200 /* initial time */
);

scheduler.scheduleAbsolute(250, function () {
    console.log('hello');
});

scheduler.advanceBy(300);
// => hello

console.log(scheduler.clock);
// => 500

Location

• rx.virtualtime.js

---

Rx.VirtualTimeScheduler.prototype.advanceTo(time)

# Ⓢ

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

Arguments

1. time (Any): Absolute time to advance the scheduler's clock to.

Example

var scheduler = new MyVirtualScheduler(
    0 /* initial time */
);

scheduler.scheduleAbsolute(100, function () {
    console.log('hello');
});

scheduler.scheduleAbsolute(200, function () {
    console.log('world');
});

scheduler.advanceBy(300);
// => hello
// => world

console.log(scheduler.clock);
// => 300

Location

• rx.virtualtime.js

---

Rx.VirtualTimeScheduler.prototype.scheduleAbsolute(dueTime, action)

# Ⓢ

Schedules an action to be executed at dueTime.

Arguments

1. dueTime (Any): Absolute time at which to execute the action.
2. action (Function): Action to be executed.

Returns

(Disposable): The disposable object used to cancel the scheduled action (best effort).

Example

var scheduler = new MyVirtualScheduler(
    0 /* initial time */
);

scheduler.scheduleAbsolute(100, function () {
    console.log('hello');
});

scheduler.scheduleAbsolute(200, function () {
    console.log('world');
});

scheduler.advanceBy(300);
// => hello
// => world

console.log(scheduler.clock);
// => 300

Location

• rx.virtualtime.js

---

Rx.VirtualTimeScheduler.prototype.scheduleAbsoluteWithState(state, dueTime, action)

# Ⓢ

Schedules an action to be executed at dueTime.

Arguments

1. state: (Any): State passed to the action to be executed.
2. dueTime (Any): Absolute time at which to execute the action.
3. action (Function): Action to be executed.

Returns

(Disposable): The disposable object used to cancel the scheduled action (best effort).

Example

var scheduler = new MyVirtualScheduler(
    0 /* initial time */
);

scheduler.scheduleAbsoluteWithState('world', 100, function (x) {
    console.log('hello ' + x);
});

scheduler.scheduleAbsoluteWithState(200, function () {
    console.log('goodnight ' + x);
}, 'moon');

scheduler.start();
// => hello world
// => goodnight moon

console.log(scheduler.clock);
// => 200

Location

• rx.virtualtime.js

---

Rx.VirtualTimeScheduler.prototype.scheduleRelative(dueTime, action)

# Ⓢ

Schedules an action to be executed at dueTime.

Arguments

1. dueTime (Any): Relative time after which to execute the action.
2. action (Function): Action to be executed.

Returns

(Disposable): The disposable object used to cancel the scheduled action (best effort).

Example

var scheduler = new MyVirtualScheduler(
    100 /* initial time */
);

scheduler.scheduleRelative(100, function () {
    console.log('hello');
});

scheduler.scheduleRelative(200, function () {
    console.log('world');
});

scheduler.start();
// => hello
// => world

console.log(scheduler.clock);
// => 400

Location

• rx.virtualtime.js

---

Rx.VirtualTimeScheduler.prototype.scheduleRelativeWithState(state, dueTime, action)

# Ⓢ

Schedules an action to be executed at dueTime.

Arguments

1. state: (Any): State passed to the action to be executed.
2. dueTime (Any): Relative time after which to execute the action.
3. action (Function): Action to be executed.

Returns

(Disposable): The disposable object used to cancel the scheduled action (best effort).

Example

var scheduler = new MyVirtualScheduler(
    0 /* initial time */
);

scheduler.scheduleRelativeWithState('world', 100, function (x) {
    console.log('hello ' + x);
});

scheduler.scheduleRelativeWithState('moon', 200, function () {
    console.log('goodnight ' + x);
});

scheduler.start();
// => hello world
// => goodnight moon

console.log(scheduler.clock);
// => 300

Location

• rx.virtualtime.js

---

Rx.VirtualTimeScheduler.prototype.sleep(time)

# Ⓢ

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

Arguments

1. time (Any): Relative time to advance the scheduler's clock by.

Example

var scheduler = new MyVirtualScheduler(
    0 /* initial time */
);

scheduler.sleep(400);

console.log(scheduler.clock);
// => 400

Location

• rx.virtualtime.js

---

Rx.VirtualTimeScheduler.prototype.start()

# Ⓢ

Starts the virtual time scheduler.

Example

var scheduler = new MyVirtualScheduler(
    0 /* initial time */
);

scheduler.scheduleRelativeWithState('world', 100, function (x) {
    console.log('hello ' + x);
});

scheduler.scheduleRelativeWithState('moon', 200, function () {
    console.log('goodnight ' + x);
});

scheduler.start();
// => hello world
// => goodnight moon

console.log(scheduler.clock);
// => 400

Location

• rx.virtualtime.js

---

Rx.VirtualTimeScheduler.prototype.stop()

# Ⓢ

Stops the virtual time scheduler.

Example

var scheduler = new MyVirtualScheduler(
    0 /* initial time */
);

scheduler.scheduleRelative(100, function () {
    console.log('hello world');
});

scheduler.scheduleRelative(100, function () {
    scheduler.stop();
});

scheduler.scheduleRelative(100, function () {
    console.log('hello world');
});

scheduler.start();
// => hello world

Location

• rx.virtualtime.js

---

VirtualTimeScheduler Abstract Protected Methods

Rx.VirtualTimeScheduler.prototype.add(absolute, relative)

# Ⓢ

Adds a relative time value to an absolute time value. This method is used in several methods including scheduleRelativeWithState, advanceBy and sleep.

Arguments

1. absolute (Any): Absolute virtual time value.
2. relative (Any): Relative virtual time value.

Returns

(Any): Resulting absolute virtual time sum value.

Example

One possible implementation could be as simple as the following:

scheduler.add = function (absolute, relative) {
    return absolute + relative;
};

Location

• rx.virtualtime.js

---

Rx.VirtualTimeScheduler.prototype.toDateTimeOffset(absolute)

# Ⓢ

Converts an absolute time to a number. This is used directly in the now method on the Rx.Scheduler

Arguments

1. absolute (Any): The absolute time to convert.

Returns

(Number): The absolute time in ms.

Example

One possible implementation could be as simple as the following:

// String -> Number
scheduler.toDateTimeOffset = function (absolute) {
    return return absolute.length;
};

Location

• rx.virtualtime.js

---

Rx.VirtualTimeScheduler.prototype.toRelative(timeSpan)

# Ⓢ

Converts the time span number/Date to a relative virtual time value.

Arguments

1. timeSpan (Any): The time span number value to convert. This is used directly in scheduleWithRelativeAndState and scheduleWithAbsoluteAndState.

Returns

(Number): Corresponding relative virtual time value.

Example

One possible implementation could be as simple as the following:

// Number -> Number
scheduler.toRelative = function (timeSpan) {
    return timeSpan;
};

Location

• rx.virtualtime.js

---