Shows error message for particular field.

@method $setError(name, msg)
@param {string} name name of field
@param {string} msg error message
@memberOf editable-form
424431
function(name, msg) {
      angular.forEach(this.$editables, function(editable) {
        if(!name || editable.name === name) {
          editable.setError(msg);
        }
      });
    }
613320
public void setErrorMessage(String message) {

        m_messageText.setInnerHTML(message);
        addStyleName(formCss().hasError());
        m_hasError = true;
    }
1144789
private static void showError(Component parent, String title, String msg) {
    JOptionPane.showMessageDialog(parent, msg, title, JOptionPane.ERROR_MESSAGE);
  }
71866
public function setError($msg, Exception $cause = null)
    {
        if ($this->errmsg === null) {
            $this->errmsg = $msg;
            $this->cause = $cause;
        }
    }
1171483
function error(msg) {
    if (topWindow.console) {
      if (topWindow.console.error) {
        topWindow.console.error(msg);
      } else if (topWindow.console.log) {
        topWindow.console.log(msg);
      }
    }
  }
137178
private function addError(string $msg, ?string $field = null): void
    {
        if (!$field) {
            $field = 'all';
        }

        if (!($this->errors[$field] ?? [])) {
            $this->errors[$field] = [];
        }

        $this->errors[$field][] = $msg;
    }
325988
function (error) {
        var message = 'ERROR';
        if (error.code) {
          message += ' - ' + error.code;
        }
        if (error.message) {
          message += ' - ' + error.message.toString();
        }
        if (error.stack) {
          message += ' - ' + error.stack.toString();
        }
        this.send({
          ok: false,
          error: message
        });
      }
606326
function (field, error) {

                if (field instanceof Object) {
                    this.$errors.set(field);
                } else {
                    this.$errors.set(field, error);
                }

                this.trigger('isValidChanged');
            }
595360
function setFieldErrors (error) {
    // skip if no error object
    if (!error) {
        return
    }
    // if error is string then add as generic error
    if (typeof error === 'string') {
        this.errors.push(error)
    }
    // if error is object then should be error object from AJV
    else if (typeof error === 'object') {
        // validation errors are set as array on error data - it this is not
        // set then only add generic error
        if (!Array.isArray(error.data)) {
            // create message
            var message = typeof error.message === 'string'
                ? error.message
                : 'An error occurred'
            // add message to errors
            this.errors.push(message)
            // skip further processing
            return
        }
        // add validation errors to fields and clear values for fields with errors
        _.each(error.data, error => this.setFieldError(error))
    }
}
107418
function ParseError(msg) {
  this.name = 'ParseError';
  this.message = msg;
  if (Error.captureStackTrace) {
    Error.captureStackTrace(this, ParseError);
  }
}
179507
def add_error(self, property_name, message):
    """"""
    if property_name not in self.errors:
      self.errors[property_name] = []
    self.errors[property_name].append(message)
124587
function (msg) {
		var i = this.msgs.length;

		this.msgs.push('ERROR: ' + msg);
		if ((i + 1) !== this.msgs.length) {
			return false;
		}
		return true;
	}
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;
}
1230909
function error(code, msg) {
    var err = new Error(msg);
    err.errno = code;
    return err;
}
339731
protected function SetRequired($name, $errorPrefix = '')
    {
        $field = $this->GetElement($name);
        if (!$field instanceof FormField)
        {
            throw new \InvalidArgumentException("$name is not a field in the form elements");
        }
        if (!$errorPrefix)
        {
            $errorPrefix = $this->ErrorPrefix($name);
        }
        $field->SetRequired($errorPrefix);
    }
691988
protected function setError(string $msg)
    {
        $this->error = $msg;
        $lastError = error_get_last();
        if ($lastError !== null) {
            $this->errorDetail = sprintf(
                "'%s' in %s on line %s",
                $lastError['message'],
                $lastError['file'],
                $lastError['line']
            );
        }
    }
1265954
function _onError(event, error, msgData) {
        var message;

        // Sometimes error.message is undefined
        if (!error.message) {
            console.warn("Expected a non-empty string in error.message, got this instead:", error.message);
            message = JSON.stringify(error);
        } else {
            message = error.message;
        }

        // Remove "Uncaught" from the beginning to avoid the inspector popping up
        if (message && message.substr(0, 8) === "Uncaught") {
            message = message.substr(9);
        }

        // Additional information, like exactly which parameter could not be processed.
        var data = error.data;
        if (Array.isArray(data)) {
            message += "\n" + data.join("\n");
        }

        // Show the message, but include the error object for further information (e.g. error code)
        console.error(message, error, msgData);
    }