mirror of
https://github.com/ceph/ceph-csi.git
synced 2024-11-10 08:20:23 +00:00
72 lines
2.3 KiB
Go
72 lines
2.3 KiB
Go
// +build go1.13
|
|
|
|
package errors
|
|
|
|
import (
|
|
stderrors "errors"
|
|
)
|
|
|
|
// Is reports whether any error in err's chain matches target.
|
|
//
|
|
// The chain consists of err itself followed by the sequence of errors obtained by
|
|
// repeatedly calling Unwrap.
|
|
//
|
|
// An error is considered to match a target if it is equal to that target or if
|
|
// it implements a method Is(error) bool such that Is(target) returns true.
|
|
func Is(err, target error) bool { return stderrors.Is(err, target) }
|
|
|
|
// As finds the first error in err's chain that matches target, and if so, sets
|
|
// target to that error value and returns true.
|
|
//
|
|
// The chain consists of err itself followed by the sequence of errors obtained by
|
|
// repeatedly calling Unwrap.
|
|
//
|
|
// An error matches target if the error's concrete value is assignable to the value
|
|
// pointed to by target, or if the error has a method As(interface{}) bool such that
|
|
// As(target) returns true. In the latter case, the As method is responsible for
|
|
// setting target.
|
|
//
|
|
// As will panic if target is not a non-nil pointer to either a type that implements
|
|
// error, or to any interface type. As returns false if err is nil.
|
|
func As(err error, target interface{}) bool { return stderrors.As(err, target) }
|
|
|
|
// Unwrap returns the result of calling the Unwrap method on err, if err's
|
|
// type contains an Unwrap method returning error.
|
|
// Otherwise, Unwrap returns nil.
|
|
func Unwrap(err error) error {
|
|
return stderrors.Unwrap(err)
|
|
}
|
|
|
|
// Cause recursively unwraps an error chain and returns the underlying cause of
|
|
// the error, if possible. There are two ways that an error value may provide a
|
|
// cause. First, the error may implement the following interface:
|
|
//
|
|
// type causer interface {
|
|
// Cause() error
|
|
// }
|
|
//
|
|
// Second, the error may return a non-nil value when passed as an argument to
|
|
// the Unwrap function. This makes Cause forwards-compatible with Go 1.13 error
|
|
// chains.
|
|
//
|
|
// If an error value satisfies both methods of unwrapping, Cause will use the
|
|
// causer interface.
|
|
//
|
|
// If the error is nil, nil will be returned without further investigation.
|
|
func Cause(err error) error {
|
|
type causer interface {
|
|
Cause() error
|
|
}
|
|
|
|
for err != nil {
|
|
if cause, ok := err.(causer); ok {
|
|
err = cause.Cause()
|
|
} else if unwrapped := Unwrap(err); unwrapped != nil {
|
|
err = unwrapped
|
|
} else {
|
|
break
|
|
}
|
|
}
|
|
return err
|
|
}
|