Thrown when a data object operation is denied
@param {string=} message - The error message
@param {string=} innerMessage - The error inner message
@param {string=} model - The target model
@constructor
@extends DataError
3894
function AccessDeniedError(message, innerMessage, model) {
    AccessDeniedError.super_.bind(this)('EACCESS', ('Access Denied' || message) , innerMessage, model);
    this.statusCode = 401;
}
1284534
function MIDINotSupportedError(message) {
    Error.call(this);
    Error.captureStackTrace(this, this.constructor);

    this.name = this.constructor.name;
    this.message = message;
}
69943
function DatabaseError( code, message ) {
  Error.captureStackTrace( this, DatabaseError )
  this.name = DatabaseError.name
  this.code = code
  this.message = message
}
437667
function message (id, language, data) {
  var genericMessage = 'GenericError'
  var self = this || message
  var str, key, subtag

  if (!self.hasOwnProperty(language)) {
    subtag = language && language.match(/.+?(?=-)/)
    if (subtag) subtag = subtag[0]
    if (self.hasOwnProperty(subtag)) language = subtag
    else language = self.defaultLanguage
  }

  str = self[language].hasOwnProperty(id) ?
    self[language][id] :
    self[language][genericMessage] || self.en[genericMessage]

  if (typeof str === 'string')
    for (key in data)
      str = str.replace('{' + key + '}', data[key])

  if (typeof str === 'function')
    str = str(data)

  return str
}
1229333
private Observable<ChatResult> handleMessageError(MessageProcessor mp, Throwable t) {
        return persistenceController.updateStoreForSentError(mp.getConversationId(), mp.getTempId(), mp.getSender())
                .map(success -> new ChatResult(false, new ChatResult.Error(0, t)));
    }
675257
function getErrorMessage (error) {
    // get schema from model
    var schema = this.model && this.model.schemaData && this.model.schemaData.properties
    // error message
    var message
    // get custom error message from schema if defined
    if (schema) {
        // if there is a base property get nested property
        if (error.baseProperty) {
            message = schema[error.baseProperty].items
                && schema[error.baseProperty].items.properties
                && schema[error.baseProperty].items.properties[error.property]
                && schema[error.baseProperty].items.properties[error.property].errors 
                && schema[error.baseProperty].items.properties[error.property].errors[error.keyword]
        }
        // get custom error message if any
        else {
            message = schema[error.property]
                && schema[error.property].errors
                && schema[error.property].errors[error.keyword]
        }
    }
    // if there is custom error message return it
    if (message) {
        return message
    }
    // default missing property error
    if (error.params && error.params.missingProperty) {
        return error.property+' required'
    }
    // default validation error
    else {
        return error.message
    }
}
944347
private ModelAndView buildError(String errorMsg, ErrorCode errorCode) {

        JsonObjectBase jsonObject = JsonObjectUtils.buildGlobalError(errorMsg, errorCode);
        return JsonObjectUtils.JsonObjectError2ModelView((JsonObjectError) jsonObject);
    }
861657
protected DatatypeException newDatatypeException(String message, boolean warning) {
        return new Html5DatatypeException(this.getClass(), this.getName(), message, warning);
    }
950011
function(message, index) {
			var error = new Error(message + ' at character ' + index);
			error.index = index;
			error.description = message;
			throw error;
		}
612800
function MethodNotAllowed(message, code_id) {
    Error.call(this);
    this.message = message || "method not allowed";
    this.code_id = code_id || null;
    this.statusCode = 405;
}
142819
function showErrorMessage(message) {
        var analyticsDescriptionMessage = "";

        switch (message) {
        case _nodeErrorMessages.UPDATEDIR_READ_FAILED:
            analyticsDescriptionMessage = "Update directory could not be read.";
            break;
        case _nodeErrorMessages.UPDATEDIR_CLEAN_FAILED:
            analyticsDescriptionMessage = "Update directory could not be cleaned.";
            break;
        }
        console.log("AutoUpdate : Clean-up failed! Reason : " + analyticsDescriptionMessage + ".\n");
        HealthLogger.sendAnalyticsData(
                autoUpdateEventNames.AUTOUPDATE_CLEANUP_FAILED,
                "autoUpdate",
                "cleanUp",
                "fail",
                analyticsDescriptionMessage
        );
    }
1166967
function handleIncomingMessage(data) {
		var message;
		reader.parse(data, initPending);
		initPending = false;
		while (!reader.isEmpty()) {
			message = reader.pop();
			// console.log("IN MESSAGE: " + inspect(message));
			handlers[message.verb](message);
		}
	}
1373002
function internalError(response, message, body) {
  var content = errorContent(ErrorType.server, message, body);
  send(response, content, StatusCode.internalServerError);
}
373773
function NameError(message) {
  Error.call(this);
  Error.captureStackTrace(this, arguments.callee);
  this.name = 'Middleware Name Error';
  this.message = message || 'The argument must be a named function or supply a name';
}
397789
function MIDIInvalidEventError(message) {
    Error.call(this);
    Error.captureStackTrace(this, this.constructor);

    this.name = this.constructor.name;
    this.message = message;
}
112470
function L10nError (message, id, loc) {
        this.name = 'L10nError';
        this.message = message;
        this.id = id;
        this.loc = loc;
    }
1003396
function StoreError(type, message) {
  this.name = StoreError.name;
  Error.call(this);
  type = type || ERR;
  message = type + ' ' + (message || 'unknown internal error');
  if(arguments.length > 2) {
    var args = [message].concat([].slice.call(arguments, 2));
    message = util.format.apply(util, args);
  }
  this.message = message;
}