*************************************************************************************************
@class HttpError
@description HttpError class description
@memberof http-errors
491978
function HttpError(message, code, description, response, captureStackTrace) {
  Error.call(this)

  // capture stack trace unless passed false
  if (captureStackTrace !== false) {
    Error.captureStackTrace(this, arguments.callee)
  }

  /*****************************************************************************
   * @property {xxx} code -- xxx
   */
  this.code = code || 500

  /*****************************************************************************
   * @property {string} description -- xxx
   */
  this.description = description || "InternalServiceError"

  /*****************************************************************************
   * @property {xxx} message -- xxx
   */
  this.message = message

  /*****************************************************************************
   * @property {xxx} response -- xxx
   */

  this.response = response
}
202318
function RETSError(ReplyCode, ReplyText) {
    Error.call(this);
    // Strict mode doesn't like arguments.callee
    Error.captureStackTrace(this);
    this.codes = require('./codes');
    this.code = ReplyCode || null;
    this.name = 'RETSError';
    this.message = '';
    this.ReplyText = ReplyText || null;
    this.wrapper = {
        start: " - [ReplyText: ",
        end: "]"
    };
    if (typeof this.codes[this.code] !== 'undefined') {
        if (typeof this.codes[this.code][0] !== 'undefined') {
            this.message = this.codes[this.code][0];
        }
        if (this.ReplyText !== null) {
            this.message += this.wrapper.start + this.ReplyText + this.wrapper.end;
        }
    }
    this.description = this.message;
}
1090918
function(errors) {	
		var i,k;
		if(YAHOO.lang.isArray(errors)) {
			for(i = 0 ; i < errors.length ; i++) {
				k = errors[i][0];
				value = errors[i][1];
				if(this.inputsNames[k]) {
					if(this.inputsNames[k].options.showMsg) {
						this.inputsNames[k].displayMessage(value);
						Dom.replaceClass(this.inputsNames[k].divEl, "inputEx-valid", "inputEx-invalid" );
					}
				}
			}
		}
		else if(YAHOO.lang.isObject(errors)) {
			for(k in errors) {
				if(errors.hasOwnProperty(k)) {
					if(this.inputsNames[k]) {
						if(this.inputsNames[k].options.showMsg) {
							this.inputsNames[k].displayMessage(errors[k]);
							Dom.replaceClass(this.inputsNames[k].divEl, "inputEx-valid", "inputEx-invalid" );
						}
					}
				}
			}
		}
	}
309824
function APIError(message, type, field) {
  Error.call(this);
  Error.captureStackTrace(this, arguments.callee);
  this.name = 'APIError';
  this.message = message;
  this.type = type;
  this.field = field;
}
742210
function () {
				if (typeof global.onerror !== "undefined") {
					var self = this;
					global.onerror = function (msg, url, line) {
						self.error("[" + msg + " on line " + line + " of " + url + "]", 0);
					};
					return true;
				} else {
					return false;
				}
			}
1307990
function HTTPError(statusCode, message) {
    if (!(this instanceof HTTPError)) {
      return new HTTPError(statusCode, message);
    }

    assert(statusCode >= 400, 'Not a valid HTTP error code');

    this.statusCode = statusCode;
    this.code = statusCode;
    this.message = message || defaultMessage;
  }
709344
function() {
  let args = Array.prototype.slice.call(arguments),
    ErrorClass = args[0];

  if (_.isObject(ErrorClass)) {
    args.shift();
  } else {
    ErrorClass = errors.RuntimeError;
  }

  args.unshift(null);   // the this arg for the .bind() call

  throw new (Function.prototype.bind.apply(ErrorClass, args));
}
284861
static function object($value, &$error, $args)
    {
        $class = isset($args[0])? $args[0] : null;
        if (is_object($value) && (empty($class) || $value instanceof $class)){
            return $value;
        }
        $error = new Error(['Должен быть объектом класса "%s"', $class], 'object');
        return null;
    }
507725
function rethrowPostcssError(error: Object): WrappedError {
  error.message = `${chalk.yellow('PostCSS error:')} ${error.message}`;
  if (error.name === 'CssSyntaxError') {
    error.message = error.message + '\n' + error.showSourceCode();
  }
  const typedError = wrapError(error, errorTypes.CssCompilationError);
  throw typedError;
}
366390
function apiError(err) {
	var f = testProbe ? testProbe : anomaly.anomaly
	f.apply(this, Array.prototype.slice.call(arguments))
}
216878
function httpResponse (response) {
  if (!response) {
    throw new Error('Unable to parse response.')
  }
  const errorAttrs = response.Chyba && response.Chyba.attributes
  if (errorAttrs) {
    throw new Error(`${response.Chyba.$value} (${errorAttrs.kod})`)
  }
  const body = response.Potvrzeni && response.Potvrzeni.attributes
  const header = response.Hlavicka && response.Hlavicka.attributes
  if (!body || !header) {
    throw new Error('Unable to read response.')
  }
}
912908
function WError(options)
{
	Error.call(this);

	var args, cause, ctor;
	if (typeof (options) === 'object') {
		args = Array.prototype.slice.call(arguments, 1);
	} else {
		args = Array.prototype.slice.call(arguments, 0);
		options = undefined;
	}

	if (args.length > 0) {
		this.message = mod_extsprintf.sprintf.apply(null, args);
	} else {
		this.message = '';
	}

	if (options) {
		if (options instanceof Error) {
			cause = options;
		} else {
			cause = options.cause;
			ctor = options.constructorOpt;
		}
	}

	Error.captureStackTrace(this, ctor || this.constructor);
	if (cause)
		this.cause(cause);

}
261039
public void sendError(HttpResponse response,int code,String msg)
    	throws IOException
    {
        Object wrapper = response.getWrapper();
        if (wrapper!=null && wrapper instanceof HttpServletResponse)
            ((HttpServletResponse)wrapper).sendError(code,msg);
        else
            super.sendError(response,code,msg);
    }
700013
function RequestError(err, url) {
	VError.call(this, err, 'for url %s', url);
	this.name = RequestError.name;
}
602892
function error() {

                        this.httpRequest.upload.onerror = function onError() {

                            $scope.$apply(function apply() {

                                $scope.finishedUploading();
                                $scope.isError = true;

                                var response = $scope.options.parserFn(this.httpRequest.responseText);
                                $rootScope.$broadcast('$dropletError', response);
                                $scope.onError({ response: response });
                                this.deferred.reject(response);

                            }.bind(this));

                        }.bind(this);

                    }
614312
function ApiError(type, message, data) {
        this.name = 'ApiError';
        this.type = type;
        this.message = message;
        this.data = data;

        if (Error.captureStackTrace) {
            Error.captureStackTrace(this, this.constructor);
        }
    }
853896
function DummyError() {
  var code = arguments[0]
    , args = Array.prototype.slice.call(arguments, 1)
    , msgi = (typeof args[0] === 'object') ? 1 : 0
  ;
  // Apply code to error message composed by parent class.
  args[msgi] = code + ', ' + args[msgi];
  // Construct parent.
  VError.apply(this, args);
  // Define DummyError specific attributes.
  this.name = 'DummyError';
  this.code = code || 'DEFAULT';
  this.errno = DUMMY_ERRNOS[this.code];
}