cancel this request
@member KISSY.IO
@param {String} [statusText=abort] error reason as current request object's statusText
@chainable
171866
function (statusText) {
            var self = this;
            statusText = statusText || 'abort';
            if (self.transport) {
                self.transport.abort(statusText);
            }
            self._ioReady(0, statusText);
            return self;
        }
576436
function ContentDialog_cancelDismissalPromise(newSignal) {
                    var dismissedSignal = this._dismissedSignal;
                    var newDismissedSignal = this._dismissedSignal = newSignal;
                    dismissedSignal.cancel();
                    return newDismissedSignal;
                }
174851
public void cancel(final String msg) {
    JobState js = msg == null ? JobState.CANCELLED : JobState.FAILED;
    cancel(msg, js);
  }
728059
public final void cancelRequest(long tick)
  {
    Long objTick = Long.valueOf(tick);

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "cancelRequest", objTick);

    ArrayList<AORequestedTick> satisfiedTicks = null;
    
    try
    {
      this.lock();
      try
      {
        // it is possible that this event occurs after this object is closed.
        // it is safe to ignore it since we must have already transitioned the tick to its final state
        if (closed)
        {
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "cancelRequest");
  
          return;
        }
        AORequestedTick requestedTick =
          (AORequestedTick) tableOfRequests.get(objTick);
        
        if (requestedTick != null)
        {
          boolean transitionOccured = cancelRequestInternal(requestedTick, false);
        
          // If we expired the request and have more then process those
          // requests now
          if (transitionOccured && !listOfRequests.isEmpty())
            satisfiedTicks = processQueuedMsgs(null);
        }
  
      }
      finally
      {
        this.unlock();
      }
    }
    catch(SINotPossibleInCurrentConfigurationException e)
    {
      // No FFDC code needed
      notifyException(e);
    }
    
    if (satisfiedTicks != null)
    {
      // inform parent about satisfied ticks - outside lock
      int length = satisfiedTicks.size();
      for (int i = 0; i < length; i++)
      {
        AORequestedTick aotick = (AORequestedTick) satisfiedTicks.get(i);
        parent.satisfiedRequest(aotick.tick, aotick.getMessage());
      }
    }

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "cancelRequest");
  }
870087
function  (options, status) {
  this.name = ''
  this.error = options.error || 'invalid_request'
  this.error_description = options.error_description
  this.redirect_uri = options.redirect_uri
  this.statusCode = options.statusCode || 400
}
212669
function _abortAllRequests() {
        var req;
        while (this._requests.length > 0) {
            req = this._requests.pop();
            req.abort = true;
            req.xhr.abort();
            // jslint complains, but this is fine. setting to empty func
            // is necessary for IE6
            req.xhr.onreadystatechange = function () {}; // jshint ignore:line
        }
    }
329957
def abort
      line = "ABOR" + CRLF
      print "put: ABOR\n" if @debug_mode
      @sock.send(line, Socket::MSG_OOB)
      resp = getmultiline
      unless ["426", "226", "225"].include?(resp[0, 3])
        raise FTPProtoError, resp
      end
      return resp
    end
894979
function stopWithHelp(...msgs) {
  utils.header()
  utils.error(...msgs)
  commands.help.forCommand(commands.build)
  utils.die()
}
508144
def status(reason = false)
      case @status_code
      when SUCCESS      then 'success'
      when ERROR        then 'error' + (reason ? " (#{truncated_error})" : "")
      when CONTINUE     then 'continue'
      when RETRY        then 'retry' + (reason ? " (#{@content})" : "")
      when NON_DELIVERY then 'non-delivery' + (reason ? " (#{@content})" : "")
      when MULTICAST    then 'multicast'
      when CANCEL       then 'cancel' + (reason ? " (#{@content})" : "")
      end
    end
1017941
def cancel_if_pending(self):
        
        if self.state == tds_base.TDS_IDLE:
            return
        if not self.in_cancel:
            self.put_cancel()
        self.process_cancel()
176038
def abort(code, error=None, message=None):
    
    if error is None:
        flask_abort(code)
    elif isinstance(error, Response):
        error.status_code = code
        flask_abort(code, response=error)
    else:
        body = {
            "status": code,
            "error": error,
            "message": message
        }
        flask_abort(code, response=export(body, code))
362687
private void abortWithError(Element element, String msg, Object... args) throws AbortProcessingException {
        error(element, msg, args);
        throw new AbortProcessingException();
    }
228003
function abort() {
    var event,
        me = this,
        resetting = calledBy.reset;

    if (me.running) {
      event = Event('abort');
      me.emit(event);
      if (!event.cancelled || resetting) {
        // avoid infinite recursion
        calledBy.abort = true;
        me.reset();
        delete calledBy.abort;

        if (support.timeout) {
          clearTimeout(me._timerId);
          delete me._timerId;
        }
        if (!resetting) {
          me.aborted = true;
          me.running = false;
        }
      }
    }
    return me;
  }
617617
def stop(id, reason = '')
      params = { :id => id }
      requires params
      params[:reason] = reason
      DataSift.request(:POST, 'historics/stop', @config, params)
    end
527465
public void cancel(String[] protocol, int[] reasonCode, String[] reasonText) {
		if(ackReceived) 
			throw new IllegalStateException("There has been an ACK received. Can not cancel more brnaches, the INVITE tx has finished.");
		cancelAllExcept(null, protocol, reasonCode, reasonText, true);
	}
1197609
@Override
  public void cancel(final Status reason) {
    checkNotNull(reason, "reason");
    boolean delegateToRealStream = true;
    ClientStreamListener listenerToClose = null;
    synchronized (this) {
      // If realStream != null, then either setStream() or cancel() has been called
      if (realStream == null) {
        realStream = NoopClientStream.INSTANCE;
        delegateToRealStream = false;

        // If listener == null, then start() will later call listener with 'error'
        listenerToClose = listener;
        error = reason;
      }
    }
    if (delegateToRealStream) {
      delayOrExecute(new Runnable() {
        @Override
        public void run() {
          realStream.cancel(reason);
        }
      });
    } else {
      if (listenerToClose != null) {
        listenerToClose.closed(reason, new Metadata());
      }
      drainPendingCalls();
    }
  }
278984
function (reason, offendingMessage) {
    var self = this;
    var msg = {msg: 'error', reason: reason};
    if (offendingMessage)
      msg.offendingMessage = offendingMessage;
    self.send(msg);
  }