DelayedAgent prototype.
This agent uses the eve.system.timer. This timer can be configured to run
in real time, discrete time, or hyper time.
@param {String} id
@constructor
@extend eve.Agent
518951
function PlanningAgent(id) {
  // execute super constructor
  eve.Agent.call(this, id);

  // connect to all transports configured by the system
  this.connect(eve.system.transports.getAll());
}
1186845
def pause(self, id, when=None): # pylint: disable=invalid-name,redefined-builtin
        
        return self.service.post(self.base+str(id)+'/pause/', params={'when': when})
1347925
function(id) {
            if (!Crafty.support.audio) return;
            var c;
            for (var i in this.channels) {
                c = this.channels[i];
                if ((!id && c.active) || c._is(id)) {
                    c.active = false;
                    c.obj.pause();
                }
            }
            return;
        }
583741
protected void setId(String id) {
		if (!StringUtils.hasText(id)) {
			id = null;
		}
		this.id = id;
	}
354442
function(id) {
      var self = this;
      var duration = self._duration;

      // If we pass an ID, get the sound and return the sprite length.
      var sound = self._soundById(id);
      if (sound) {
        duration = self._sprite[sound._sprite][1] / 1000;
      }

      return duration;
    }
893030
public void setId(String id) {
        logger.entering(id);
        this.id = id;
        logger.exiting();
    }
346360
@Override
	public <T> Component getAgent(String id) {

		if (agentComponents.containsKey(id)) {
			return agentComponents.get(id);
		}
		return createAgent(id);
	}
350826
function get($id = null)
        {
            # get the current microtime
            $now = microtime(true);

            # if no $id name is given for the interval
            if ($id == null) {
                # give it a counter interval name
                $cnt = count($this->intervals) ;
                $cnt++;
                $id = "~interval $cnt";
            }

            # if starting the stop watch
            if ($this->startTime == false) {
                # set start time interval to zero
                $incr = 0;
                # note the starting time
                $this->startTime = $now;
            } else {
                # compute time since the prior interval
                $incr = $now - $this->lastInterval;

                # if calling for microseconds round the time to microseconds otherwise to milliseconds
                $incr = ($this->microsec)
                    ? round($incr, 6)
                    : round($incr, 3);
            }

            # add it to the interval array
            $this->addInterval($id, $incr);

            # update the last interval time
            $this->lastInterval  = $now;

        }
1328948
public void ping(long id, long timeout, PingCallback callback) {
        pingCallbacks.put(id, callback);
        scheduller.postMessage(new MTPing(id), false, timeout);
        actionsActor.send(new PingTimeout(id), timeout);
    }
1144165
public final void setId(final ID id) {
    Assert.notNull(id, "The identifier for Rule ({0}) cannot be null!", getClass().getName());
    this.id = id;
  }
185614
function(id) {
			var cleared = running[id] != null;
			if (cleared) {
				running[id] = null;
			}

			return cleared;
		}
410515
function() {
			clearTimeout(this._delayedCallId);

			// if interval is active and there are registered listeners
			var bHasListeners = this._oEventBus._defaultChannel.hasListeners(_EVENT_ID);
			if (this._iInterval > 0 && bHasListeners) {
				this._oEventBus.publish(_EVENT_ID);

				this._delayedCallId = setTimeout(this._trigger, this._iInterval);
			}
		}
520757
function(id) {
		if (this.current_id != id) {
			this.current_id = id;
			this._timenav.goToId(this.current_id);
			this._storyslider.goToId(this.current_id, false, true);
			this.fire("change", {unique_id: this.current_id}, this);
		}
	}
1180865
function run (task, runId)
{
	if (task._runId !== runId)
		return;
	
	var delay = Math.max(0, task.nextEvent.getTime() - Date.now());
	task._timeout = setTimeout(executeTask, delay, task, runId);
	if (task._unref)
		task._timeout.unref();
}
1304881
function (id) {
        // Stop javascript timer & remove from timer list
        if (id && timers[id]) {
            window.clearInterval(timers[id].timer);
            removeListeners(timers[id].listeners);
            delete timers[id];

            if (eventTimerId && Object.keys(timers).length === 0) {
                // No more watchers, so stop firing 'devicemotion' events
                window.clearInterval(eventTimerId);
                eventTimerId = null;
            }
        }
    }
1273628
function pause(id) {
  if (!timers[id]) return start(id);

  timers[id].elapsed += msDiff(process.hrtime(), timers[id].start);
}
995658
function( time, callback ) {
		var self = this, timeid;

		// Can only delay an active module
		self.requireState( munit.ASSERT_STATE_ACTIVE, self.delay );

		// Time parameter is required
		if ( ! munit.isNumber( time ) ) {
			throw new munit.AssertionError( "Time parameter not passed to assert.delay", self.delay );
		}

		// Module has yet to complete the callback cycle,
		// Start async extension now
		if ( ! self.isAsync ) {
			self.isAsync = true;
			self.options.timeout = time;
			self._timerStart = Date.now();
			self._timeid = timeid = setTimeout(function(){
				if ( munit.isFunction( callback ) ) {
					callback( self );
				}

				if ( timeid === self._timeid && self.state < munit.ASSERT_STATE_TEARDOWN ) {
					self.close();
				}
			}, time );
		}
		// Only extend current timeout if it is less then requested delay
		else if ( ( self._timerStart + self.options.timeout ) < ( Date.now() + time ) ) {
			if ( self._timeid ) {
				self._timeid = clearTimeout( self._timeid );
			}

			self.isAsync = true;
			self._timerStart = Date.now();
			self._timeid = timeid = setTimeout(function(){
				if ( munit.isFunction( callback ) ) {
					callback( self );
				}

				if ( timeid === self._timeid && self.state < munit.ASSERT_STATE_TEARDOWN ) {
					self.close();
				}
			}, time );
		}
		// Force block any delay that does not extend longer than current timeout
		else {
			throw new munit.AssertionError( "delay time doesn't extend further than the current timeout", self.delay );
		}
	}