• index
• goog
• async
• search: Go

The goog.async.ConditionalDelay Class

goog.async.ConditionalDelay
> goog.Disposable

goog.async.ConditionalDelay(listener, opt_handler)

A ConditionalDelay object invokes the associated function after a specified interval delay and checks its return value. If the function returns {@code true} the conditional delay is cancelled and {@see #onSuccess} is called. Otherwise this object keeps to invoke the deferred function until either it returns {@code true} or the timeout is exceeded. In the latter case the {@see #onFailure} method will be called. The interval duration and timeout can be specified each time the delay is started. Calling start on an active delay will reset the timer.

listener {function():boolean}

Function to call when the delay completes. Should return a value that type-converts to {@code true} if the call succeeded and this delay should be stopped.

opt_handler {Object=}

The object scope to invoke the function in.

.addOnDisposeCallback(callback, opt_scope)

Inherited from goog.Disposable .

Invokes a callback function when this object is disposed. Callbacks are invoked in the order in which they were added.

callback {!Function}

The callback function.

opt_scope {Object=}

An optional scope to call the callback in.

.creationStack {string}

Inherited from goog.Disposable .

If monitoring the goog.Disposable instances is enabled, stores the creation stack trace of the Disposable instance.

.dispose()

Inherited from goog.Disposable .

Disposes of the object. If the object hasn't already been disposed of, calls {@link #disposeInternal}. Classes that extend {@code goog.Disposable} should override {@link #disposeInternal} in order to delete references to COM objects, DOM nodes, and other disposable objects. Reentrant.

returns {void}

Nothing.

   mypackage.MyClass = function() {
     goog.base(this);
     // Constructor logic specific to MyClass.
     ...
   };
   goog.inherits(mypackage.MyClass, goog.Disposable);

   mypackage.MyClass.prototype.disposeInternal = function() {
     goog.base(this, 'disposeInternal');
     // Dispose logic specific to MyClass.
     ...
   };
 

.isActive()

returns {boolean}

True if the delay is currently active, false otherwise.

.isDisposed()

Inherited from goog.Disposable .

returns {boolean}

Whether the object has been disposed of.

.isDone()

returns {boolean}

True if the listener has been executed and returned {@code true} since the last call to {@see #start}.

.onFailure()

Called when this delayed call is cancelled because the timeout has been exceeded, and the listener has never returned {@code true}. Designed for inheritance, should be overridden by subclasses or on the instances if they care.

.onSuccess()

Called when the listener has been successfully executed and returned {@code true}. The {@see #isDone} method should return {@code true} by now. Designed for inheritance, should be overridden by subclasses or on the instances if they care.

.registerDisposable(disposable)

Inherited from goog.Disposable .

Associates a disposable object with this object so that they will be disposed together.

disposable {goog.disposable.IDisposable}

that will be disposed when this object is disposed.

.start(opt_interval, opt_timeout)

Starts the delay timer. The provided listener function will be called repeatedly after the specified interval until the function returns {@code true} or the timeout is exceeded. Calling start on an active timer will stop the timer first.

opt_interval {number=}

The time interval between the function invocations (in milliseconds). Default is 0.

opt_timeout {number=}

The timeout interval (in milliseconds). Takes precedence over the {@code opt_interval}, i.e. if the timeout is less than the invocation interval, the function will be called when the timeout is exceeded. A negative value means no timeout. Default is 0.

.stop()

Stops the delay timer if it is active. No action is taken if the timer is not in use.

Documentation generated using JvJsDoc, version 0.5 on 2012-09-03.