Notifies all subscribed observers about the exception.
@param {Mixed} error The exception to send to all observers.
541007
function (error) {
        checkDisposed(this);
        if (this.isStopped) { return; }
        this.isStopped = true;
        this.error = error;
        this.hasError = true;
        var now = this.scheduler.now();
        this._trim(now);
        for (var i = 0, os = cloneArray(this.observers), len = os.length; i < len; i++) {
          var observer = os[i];
          observer.onError(error);
          observer.ensureActive();
        }
        this.observers.length = 0;
      }
923560
function onError( error ) {
        logger.error( error.stack || error );
        process.exit( EXIT_FAILURE );
    }
1214078
protected synchronized boolean reject(JoynrException error) {
        if (isSettled()) {
            return false;
        }
        state = State.REJECTED;
        this.error = error;
        notifyListeners();
        return true;
    }
638170
function unsubscribeError(message, exceptionMessage, exceptionType) {
		reply(proto.writeUnsubscribeException(
			message.id, exceptionMessage, exceptionType));
		dequeueSubUnsubRequest(message.itemName);
		fireFirstSubUnsubEvent(message.itemName);
	}
421180
function Subject() {
    __super__.call(this, subscribe);
    this.isDisposed = false,
    this.isStopped = false,
    this.observers = [];
    this.hasError = false;
  }
889153
function onError(err) {
    // jshint validthis: true
    notifier.notify({
        title: err.plugin + ' Error',
        message: err.message
    });
    $.util.log(err.toString());
    $.util.beep();
    if (isWatching) {
        this.emit('end');
    } else {
        process.exit(1);
    }
}
1001643
function(error) {
			if (error) {
				console.error(error.toString());
			}
			process.exit(cfg.ERROR_EXIT);
		}
701404
protected void showError(String error) {

        if (null == error) {
            m_errorLabel.setText("");
        } else {
            m_errorLabel.setText(error);
        }
    }
807701
function ValidationError(message, errors) {
	Error.call(this, message);

	if (Error.captureStackTrace) {
		Error.captureStackTrace(this, ValidationError);
	}

	this.message = message;
	this.errors = errors;
}
1071437
function reporter(error, file) {

    // _JS Hint_ can sometimes call the reporter function with no error. This is
    // simply ignored.

    if (!error) {
        return;
    }

    if (!(error.code in errors)) {
        errors[error.code] = { reason: error.raw, count: 0 };
    }

    errors[error.code].count++;
    totalErrors++;

    console.log(getChalk(error.code)('%s: line %d, col %d, %s'),
        file, error.line, error.character, error.reason);

    if (error.evidence !== undefined) {
        var evidence = error.evidence.trim();
        console.log(chalk.grey('    %s'), evidence);
    }
}
920417
function track (error) {
  if (window.trackJs) {
    try {
      var message = error ? error.message + ' - code: ' + error.errorCode : JSON.stringify(error);
      window.trackJs.track(new Error(message));
    } catch (exc) {
      // Swallow
    }
  }
}
147706
function IntercomError(message, errors) {
  AbstractError.apply(this, arguments);
  this.name = 'IntercomError';
  this.message = message;
  this.errors = errors;
}
24803
function handleError(call, error) {
  var statusMetadata = new Metadata();
  var status = {
    code: constants.status.UNKNOWN,
    details: 'Unknown Error'
  };
  if (error.hasOwnProperty('message')) {
    status.details = error.message;
  }
  if (error.hasOwnProperty('code') && Number.isInteger(error.code)) {
    status.code = error.code;
    if (error.hasOwnProperty('details')) {
      status.details = error.details;
    }
  }
  if (error.hasOwnProperty('metadata')) {
    statusMetadata = error.metadata;
  }
  status.metadata = statusMetadata._getCoreRepresentation();
  var error_batch = {};
  if (!call.metadataSent) {
    error_batch[grpc.opType.SEND_INITIAL_METADATA] =
        (new Metadata())._getCoreRepresentation();
  }
  error_batch[grpc.opType.SEND_STATUS_FROM_SERVER] = status;
  call.startBatch(error_batch, function(){});
}
638381
function(error) {
		if (this.resolved) {
			throw new Error('Future resolved more than once');
		} else if (!error) {
			throw new Error('Must throw non-empty error');
		}
		this.error = error;
		this.resolved = true;

		var callbacks = this.callbacks;
		if (callbacks) {
			delete this.callbacks;
			for (var ii = 0; ii < callbacks.length; ++ii) {
				try {
					var ref = callbacks[ii];
					if (ref[1]) {
						ref[0].throw(error);
					} else {
						ref[0](error);
					}
				} catch(ex) {
					// console.log('Resolve cb threw', String(ex.stack || ex.message || ex));
					process.nextTick(function() {
						throw(ex);
					});
				}
			}
		}
	}
1239646
protected final void notifyError(@NonNull final Throwable e) {
        //noinspection ThrowableResultOfMethodCallIgnored
        checkNotNull(e, "e");
        runOnUiThread(new Runnable() {
            @Override
            public void run() {
                mErrorObservable.notifyError(e);
            }
        });
    }
859202
function _onError(error) {
        if (_connectDeferred) {
            _connectDeferred.reject();
            _connectDeferred = null;
        }
        exports.trigger("error", error);
    }
583042
function(err)
  {
    // we're done loading
    self._isLoading = false;

    // emit an event to notify subscribers
    self.emit('loadcomplete', err, self);

    // invoke the callback if one was specified
    if (Util.isFunction(callback))
    {
      callback(err, self);
    }
  }