merror

func As ¶

func As(err error, target any) bool

As searches for the first error in the chain of errors that matches `target`. If found, it sets `target` to the error value and returns true.

The error chain consists of `err` itself, followed by the error sequence obtained by repeatedly calling `Unwrap`.

If the specific value of the error can be assigned to the value pointed to by `target`, or the error has a method `As(interface{}) bool` so that `As(target)` returns true, then the error matches target. In the latter case, the As method is responsible for setting target.

If target is not a pointer to a type that implements the error interface or any interface type, As will panic. If err is nil, As returns false.

func Cause ¶

func Cause(err error) error

Cause returns the root cause of `err`.

func Code ¶

func Code(err error) mcode.Code

Code gets the error code of the error. If there is no error code, and the error does not implement the ICode interface, it returns CodeNil.

func Current ¶

func Current(err error) error

Current creates and returns the current level error. If the current level error is nil, it returns nil.

func Equal ¶

func Equal(err, target error) bool

Equal reports whether `err` is equal to `target`. Note that in the default comparison logic of `Error`, if the `code` and `text` of the two errors are the same, it is considered that they are the same.

func HasStack ¶

func HasStack(err error) bool

HasStack checks and reports whether `err` implements the `gerror.IStack` interface.

func Is ¶

func Is(err, target error) bool

Is reports whether `err` is in the chain of errors. There is a similar function `HasError`, it is designed and implemented before the `errors.Is` function of the go standard library. Now it is an alias of the `errors.Is` function of the go standard library, to ensure the same performance as the go standard library.

func New ¶

func New(text string) error

New creates a new error. Example: err := merror.New("username cannot be empty")

func NewCode ¶

func NewCode(code mcode.Code, text ...string) error

NewCode creates a new error with the specified error code. Example: err := merror.NewCode(mcode.ValidationError)

func NewCodef ¶

func NewCodef(code mcode.Code, format string, args ...any) error

NewCodef creates a new error with the specified error code. Example: err := merror.NewCodef(mcode.ValidationError, "username %s cannot be empty", admin)

func Newf ¶

func Newf(format string, a ...any) error

Newf creates a new error. Example: err := merror.Newf("username %s cannot be empty", admin)

func Stack ¶

func Stack(err error) string

Stack returns the string of the stack caller information. If `err` does not support stack, it will return the error string directly.

func Unwrap ¶

func Unwrap(err error) error

Unwrap returns the next level error. If the current level error or the next level error is nil, it returns nil.

func Wrap ¶

func Wrap(err error, text string) error

Wrap wraps an error. Example: err := merror.Wrap(err, "username cannot be empty")

func WrapCode ¶

func WrapCode(err error, code mcode.Code, text ...string) error

WrapCode wraps an error and appends the specified error code. Example: err := merror.WrapCode(err, mcode.ValidationError)

func WrapCodef ¶

func WrapCodef(err error, code mcode.Code, format string, args ...any) error

WrapCodef wraps an error and appends the specified error code and formatted text. Example: err := merror.WrapCodef(err, mcode.ValidationError, "username %s cannot be empty", admin)

func Wrapf ¶

func Wrapf(err error, format string, a ...any) error

Wrapf wraps an error. Example: err := merror.Wrapf(err, "username %s cannot be empty", admin)