Returns a TupleErrorList for this field. This overloaded method adds additional error lists
        to the errors as detected by the form validator.
517534
def errors(self):
        
        if not hasattr(self, '_errors_cache'):
            self._errors_cache = self.form.get_field_errors(self)
        return self._errors_cache
1106314
public final List<String> getActionErrors() {
    Flash flash = getFlash();
    ActionMessages messages = (ActionMessages) flash.get(Flash.MESSAGES);
    if (null == messages) return Collections.emptyList();
    else return messages.getErrors();
  }
808391
public String validationErrors() {

        List<String> errors = new ArrayList<>();
        for (File config : getConfigFiles()) {
            String filename = config.getName();
            try (FileInputStream stream = new FileInputStream(config)) {
                CmsXmlUtils.unmarshalHelper(CmsFileUtil.readFully(stream, false), new CmsXmlEntityResolver(null), true);
            } catch (CmsXmlException e) {
                errors.add(filename + ":" + e.getCause().getMessage());
            } catch (Exception e) {
                errors.add(filename + ":" + e.getMessage());
            }
        }
        if (errors.size() == 0) {
            return null;
        }
        String errString = CmsStringUtil.listAsString(errors, "\n");
        JSONObject obj = new JSONObject();
        try {
            obj.put("err", errString);
        } catch (JSONException e) {

        }
        return obj.toString();
    }
990140
protected function getRawErrors() {
        foreach ($this->errors as $field => $errors) {
            foreach ($errors as $error) {
                yield $field => $error;
            }
        }
    }
1208636
def errors(self):
        
        ret_errs = list()
        errors = self.get('error').get('errors', None) or list()
        assert isinstance(errors, list)
        for err in errors:
            when = parse_datetime(err.get('when', None))
            msg = err.get('message', '')
            e = ErrorEvent(when, msg)
            ret_errs.append(e)
        return ret_errs
1320186
public ClassDoc[] errors() {
        ListBuffer<ClassDocImpl> ret = new ListBuffer<>();
        for (ClassDocImpl c : getClasses(true)) {
            if (c.isError()) {
                ret.append(c);
            }
        }
        return ret.toArray(new ClassDocImpl[ret.length()]);
    }
974394
private void makeErrorList( final DRLParser parser ) {
        for ( final DroolsParserException recogErr : lexer.getErrors() ) {
            final ParserError err = new ParserError( resource,
                                                     recogErr.getMessage(),
                                                     recogErr.getLineNumber(),
                                                     recogErr.getColumn() );
            this.results.add( err );
        }
        for ( final DroolsParserException recogErr : parser.getErrors() ) {
            final ParserError err = new ParserError( resource,
                                                     recogErr.getMessage(),
                                                     recogErr.getLineNumber(),
                                                     recogErr.getColumn() );
            this.results.add( err );
        }
    }
385392
def get_errors(audit_results):
        
        errors = []
        if audit_results:
            if audit_results.errors:
                errors.extend(audit_results.errors)
        return errors
1294097
def format_error(self, error, args=None):
        
        if type(args) is dict:
            return error.format(**args)
        if type(args) is list or type(args) is tuple:
            return error.format(*args)

        return error
768056
public List<String> getMessages() {
        List<String> errorMessages = new ArrayList<>();
        for (ValidationError error : errors) {
            errorMessages.add(error.getMessage());
        }
        return errorMessages;
    }
946139
def report_error(self, read_tuple_name, error_name, wrong="", message="", warning=False):
        
        if (not self.report_only_first) or (error_name not in self.reported_errors):
            print("\t".join(["error" if warning == False else "warning", read_tuple_name, error_name, wrong, message]))
        self.reported_errors.add(error_name)
        if warning:
            self.warning_has_been_reported = True
        else:
            self.error_has_been_reported = True
564149
def get_errors(self):
        
        result = []
        while not self.errors.empty():  # pragma: no cover
            try:
                e = self.errors.get(False)
                result.append(e)
            except self.errors.Empty:
                continue
            self.errors.task_done()
        return result
8196
def get_field_errors(self, field):
        
        identifier = format_html('{0}[\'{1}\']', self.form_name, field.name)
        errors = self.errors.get(field.html_name, [])
        return self.error_class([SafeTuple(
            (identifier, self.field_error_css_classes, '$pristine', '$pristine', 'invalid', e)) for e in errors])
826478
public java.util.List<? extends org.tensorflow.framework.OpDef.AttrDefOrBuilder> 
      getAttrOrBuilderList() {
    return attr_;
  }
526118
def get_context_query_errors(self):
    
    if self._context_query_errors:  return self._context_query_errors
    if len(self._query_errors) < 3: return {}
    nts = ['A','C','G','T']
    poss = ['A','C','G','T','-']
    r = {}
    for i in nts:
      if i not in r:  r[i] = {}
      for j in nts:
        if j not in r[i]: r[i][j] = {}
        for k in poss:
          if k not in r[i][j]: 
            r[i][j][k] = {}
            r[i][j][k]['types'] = {}
            r[i][j][k]['total'] = 0
          for l in poss:
            if l not in r[i][j][k]['types']: r[i][j][k]['types'][l] = 0
    # now r is initialized
    for i in range(1,len(self._query_errors)-1):

      tobs = self._query_errors[i].get_observable()
      tunobs = self._query_errors[i].get_unobservable()
      otype = tobs.get_type()
      op = tobs.get_error_probability()
      before = tunobs.get_before_type()
      bp = tunobs.get_before_probability()
      after = tunobs.get_after_type()
      ap = tunobs.get_after_probability()
      if otype[2][0][0] == 'N': continue
      if otype[2][1][0] == 'N': continue
      if before:
        if before[2][0][0] == 'N': continue
        if before[2][1][0] == 'N': continue
      if after:
        if after[2][0][0] == 'N': continue
        if after[2][1][0] == 'N': continue

      tbefore = self._query_errors[i-1].get_base()
      t = self._query_errors[i].get_base()
      tafter = self._query_errors[i+1].get_base()

      if tbefore == 'N' or tafter == 'N' or t == 'N': continue
      r[tbefore][t]['-']['total'] += 0.5
      r[t][tafter]['-']['total'] += 0.5
      r[tbefore][tafter][t]['total'] += 1

      # We know we made an observation
      if otype[0] == 'mismatch':
        tb = otype[2][0][0]
        qb = otype[2][1][0]
        r[tbefore][tafter][t]['types'][tb] += op
      elif otype[0] == 'match':
        tb = otype[2][0][0]
        qb = otype[2][1][0]
        r[tbefore][tafter][t]['types'][tb] += float(1)
      elif otype[0] == 'insertion':
        tb = otype[2][0][0]
        qb = otype[2][1][0]
        r[tbefore][tafter][t]['types']['-'] += op
        r[tbefore][tafter][t]['types'][tb] += (1-op)
      # make sure our deletion can't be bigger than 1
      hp_deletion_before = 0
      hp_deletion_after = 0
      if otype[0] == 'deletion':
        tb = otype[2][0][0]
        qb = otype[2][1][0]
        r[tbefore][tb]['-']['types'][tb] += op/2
        r[tb][tafter]['-']['types'][tb] += op/2
        #homopolymer ... so we do have the correct base
        r[tbefore][tafter][t]['types'][tb] += 1

      # now take care of total deletions
      if before:
        tb = before[2][0][0]
        r[tbefore][t]['-']['types'][tb] += bp
      if after:
        tb = after[2][0][0]
        r[t][tafter]['-']['types'][tb] += ap

      ##type = self._target_errors[i].get_type()
      #p = self._target_errors[i].get_error_probability()
      #if p > 0:
      #  if type[0] not in r[tbefore][t][tafter]['types']:
      #    r[tbefore][t][tafter]['types'][type[0]] = 0
      #  r[tbefore][t][tafter]['types'][type[0]] += p
      #r[tbefore][t][tafter]['total']+=1
    for b in r:
      for a in r:
        val = sum([r[b][a]['-']['types'][q] for q in nts])
        r[b][a]['-']['types']['-'] = r[b][a]['-']['total'] - val
    return r
1040173
public List<Throwable> getErrors() {
        List<Throwable> list = new ArrayList<>();
        list.addAll(errors);
        for (PathWrapper ar : pathWrappers) {
            list.addAll(ar.getErrors());
        }
        return list;
    }
722605
public List<FieldError> getFieldErrors() {
        return errors.stream()
                .filter(e -> e instanceof FieldError)
                .map(e -> (FieldError)e)
                .collect(Collectors.toList());
        
    }