Return the error serializer being used for gruf

 @return [Gruf::Serializers::Errors::Base]
183665
def serializer_class
      if Gruf.error_serializer
        Gruf.error_serializer.is_a?(Class) ? Gruf.error_serializer : Gruf.error_serializer.to_s.constantize
      else
        Gruf::Serializers::Errors::Json
      end
    end
970997
function(errors) {
      var ret = {};
      errors.forEach(function(error) {
        var list = ret[error.attribute];
        if (list) {
          list.push(error);
        } else {
          ret[error.attribute] = [error];
        }
      });
      return ret;
    }
785536
def rest_error(self):
    
    error_json = self.__format_error('errors')
    return json.dumps(error_json, indent=1, sort_keys=True)
628306
def get_serializer(
            self,
            action_kwargs: Dict=None,
            *args, **kwargs) -> Serializer:
        
        serializer_class = self.get_serializer_class(
            **action_kwargs
        )

        kwargs['context'] = self.get_serializer_context(
            **action_kwargs
        )

        return serializer_class(*args, **kwargs)
1241396
def getErrorInfoFromResponse
      if @responseXMLdoc
         errcode = getResponseValue( :errcode )
         @errcode = errcode ? errcode : ""
         errtext = getResponseValue( :errtext )
         @errtext = errtext ? errtext : ""
         errdetail = getResponseValue( :errdetail )
         @errdetail = errdetail ? errdetail : ""
         if @errcode != "0"
            @lastError = "Error code: #{@errcode} text: #{@errtext}: detail: #{@errdetail}"
         end
      end
      @lastError
   end
94056
def get_serializer(self, *args, **kwargs):
        
        serializer_class = self.get_serializer_class()
        kwargs['context'] = self.get_serializer_context()
        return serializer_class(*args, **kwargs)
1141487
def errors(wfid=nil)

      wfid, options = wfid.is_a?(Hash) ? [ nil, wfid ] : [ wfid, {} ]

      errs = wfid.nil? ?
        @context.storage.get_many('errors', nil, options) :
        @context.storage.get_many('errors', wfid)

      return errs if options[:count]

      errs.collect { |err| ProcessError.new(err) }
    end
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
    }
}
514732
function getNested (error) {
      return fp.pipe([
        fp.getOr({}, 'errors'),
        fp.toPairs,
        fp.map(fp.first),
        fp.filter(k => k.split('.').length > 1),
        fp.map(fp.pipe([fp.split('.'), fp.initial, fp.join('.')]))
      ])(error)
    }
168314
def definitions_errors(self):
        
        if not self.is_logic_error:
            return None

        result = defaultdict(list)
        for error in self.child_errors:
            i = error.schema_path[len(self.schema_path)]
            result[i].append(error)
        return result
423889
def build_errors(type, category = nil, row = nil, column = nil, content = nil, constraints = {})
      @errors << Csvlint::ErrorMessage.new(type, category, row, column, content, constraints)
    end
722605
public List<FieldError> getFieldErrors() {
        return errors.stream()
                .filter(e -> e instanceof FieldError)
                .map(e -> (FieldError)e)
                .collect(Collectors.toList());
        
    }
707870
def error_codes(self):
        
        request_url = "{}/api/0/error_codes".format(self.instance)
        return_value = self._call_api(request_url)
        return return_value
895508
def strip_errors(obj):
    
    rtn_obj = copy.deepcopy(obj)
    try:
        del rtn_obj["__error_keys__"]
    except KeyError:
        pass
    for key in obj.get('__error_keys__', []):
        rtn_obj[key] = rtn_obj[key]['value']
    return rtn_obj
389193
def get_error(self, error):
        
        error_type = type(error)
        if error.error_type == ET_CLIENT:
            error_type_name = 'Client'
        else:
            error_type_name = 'Server'
        return {
            'type': error_type_name,
            'name': error_type.__name__,
            'prefix': getattr(error_type, '__module__', ''),
            'message': unicode(error),
            'params': error.args,
        }
1167152
def serialize_base
      serialized = {}

      # set basic info
      serialized[:id] = id
      serialized[:title] = title
      serialized[:meta_language] = meta_language
      serialized[:meta_permalink] = meta_permalink

      # return serialized category
      serialized
    end
1352162
def _resolve_serializer(self, serializer):
        
        if isinstance(serializer, Serializer):
            return serializer

        if serializer in self._serializers:
            return self._serializers[serializer]

        raise RuntimeError('Unsupported serializer')