This method is stops the timer

@param 	callback  A function that is called once the timer is destroyed
@return	void
12571
function(callback) {
			this.factory.running = false;
			this._clearInterval(callback);
			this.callback(this.callbacks.stop);
			this.callback(callback);
		}
601208
function finish(e) {
      if (e && e.target !== node) {
        return;
      }

      clearTimeout(timer);
      if (removeListeners) removeListeners();

      (0, _removeClass2.default)(node, className);
      (0, _removeClass2.default)(node, activeClassName);

      if (removeListeners) removeListeners();

      // Usually this optional callback is used for informing an owner of
      // a leave animation and telling it to remove the child.
      if (finishCallback) {
        finishCallback();
      }
    }
1021134
function(callback) {
            callback = callback || function() {};
            
            var that = this;
            this.post("disable", {}, function(err, response) {
                if (err) {
                    callback(err);
                }
                else {
                    callback(null, that);
                }
            });
        }
715648
protected function clearTimeout()
    {
        if ($this->timeoutTimer !== null) {
            $this->loop->cancelTimer($this->timeoutTimer);
            $this->timeoutTimer = null;
        }
    }
1178788
public function cancel()
    {
        $this->cb = null;
        $this->context = null;
        if ($this->timer !== null) {
            Timer::remove($this->timer);
            $this->timer = null;
        }
    }
555961
function () {
            this._handler = $B.bind(function (e) {
                ++this._count;
                this.dispatch( 'timer', {target: this, currentCount: this._count, data: this._data} );
                if ( this._repeatCount > 0 && this._repeatCount == this._count ) {
                    this.stop();
                    this.dispatch( 'complete', {target: this, currentCount: this._count, data: this._data} );
                }
            }, this);
        }
1196372
@Override
	public void removeCallback(Callback callback) {
		callbacks.remove(callback);
		if (manager != null) {
			callback.cleanup();
		}
	}
1037775
public void close(final AVIMClientCallback callback) {
    final AVIMClientCallback internalCallback = new AVIMClientCallback() {
      @Override
      public void done(AVIMClient client, AVIMException e) {
        if (null == e) {
          AVIMClient.this.localClose();
        }
        if (null != callback) {
          callback.done(client, e);
        }
      }
    };
    InternalConfiguration.getOperationTube().closeClient(this.clientId, internalCallback);
  }
877132
@Override
    public void setCallback(SourceCallback callback) {
        try {
            mCallbackLock.lock();
            mCallback = callback;
            mCallbackChanged.signal();
        } finally {
            mCallbackLock.unlock();
        }
    }
563126
def remove_callback(self, callback):
        """"""
        if callback in self.callbacks:
            self.callbacks.remove(callback)
376002
public static function stop($name = "default")
  {
    if(!array_key_exists($name, self::$timers))
    {
      self::init($name);
    }

    self::$timers[$name]->stop();
  }
233779
public function block($timeout, $callback = null)
    {
        $starting = time();

        $id = Str::random(20);

        while (! $slot = $this->acquire($id)) {
            if (time() - $timeout >= $starting) {
                throw new LimiterTimeoutException;
            }

            usleep(250 * 1000);
        }

        if (is_callable($callback)) {
            try {
                return tap($callback(), function () use ($slot, $id) {
                    $this->release($slot, $id);
                });
            } catch (Exception $exception) {
                $this->release($slot, $id);

                throw $exception;
            }
        }

        return true;
    }
437607
public void cancel(ResponseCallback responseCallback) {
    // To avoid creating an extra message, we adopt the convention that writing the callback
    // directly means cancellation
    writeCoalescer.writeAndFlush(channel, responseCallback).addListener(UncaughtExceptions::log);
  }
1018661
public function stop()
    {
        if ($this->stopTimer) {
            $this->eventLoop->cancelTimer($this->stopTimer);
            $this->stopTimer = null;
        }

        $this->eventLoop->stop();
    }
360213
public static Timer setTimeout(int milliseconds, TimerCallback callback) {
		TimeoutTimer timeout = new TimeoutTimer(); 
		timeout.setId(nativeSetTimeout(milliseconds, callback, timeout));
		return timeout;
	}
388347
protected function armTimeoutMonitor($timeout, callable $callback)
    {
        $timer = $this->loop->addTimer($timeout, function ($timer) {
            list($connection, $callback) = $timer->getData();

            $connection->disconnect();
            call_user_func($callback, $connection, new ConnectionException($connection, 'Connection timed out'));
        });

        $timer->setData([$this, $callback]);

        return $timer;
    }
827238
public function stop()
	{
		if($this->_started)
		{
			$this->onStop();
			foreach($this->plugins() as $plugin) $plugin->stop();
		}
	}