| package errdefs // import "github.com/docker/docker/errdefs" |
| |
| import "context" |
| |
| type errNotFound struct{ error } |
| |
| func (errNotFound) NotFound() {} |
| |
| func (e errNotFound) Cause() error { |
| return e.error |
| } |
| |
| // NotFound is a helper to create an error of the class with the same name from any error type |
| func NotFound(err error) error { |
| if err == nil || IsNotFound(err) { |
| return err |
| } |
| return errNotFound{err} |
| } |
| |
| type errInvalidParameter struct{ error } |
| |
| func (errInvalidParameter) InvalidParameter() {} |
| |
| func (e errInvalidParameter) Cause() error { |
| return e.error |
| } |
| |
| // InvalidParameter is a helper to create an error of the class with the same name from any error type |
| func InvalidParameter(err error) error { |
| if err == nil || IsInvalidParameter(err) { |
| return err |
| } |
| return errInvalidParameter{err} |
| } |
| |
| type errConflict struct{ error } |
| |
| func (errConflict) Conflict() {} |
| |
| func (e errConflict) Cause() error { |
| return e.error |
| } |
| |
| // Conflict is a helper to create an error of the class with the same name from any error type |
| func Conflict(err error) error { |
| if err == nil || IsConflict(err) { |
| return err |
| } |
| return errConflict{err} |
| } |
| |
| type errUnauthorized struct{ error } |
| |
| func (errUnauthorized) Unauthorized() {} |
| |
| func (e errUnauthorized) Cause() error { |
| return e.error |
| } |
| |
| // Unauthorized is a helper to create an error of the class with the same name from any error type |
| func Unauthorized(err error) error { |
| if err == nil || IsUnauthorized(err) { |
| return err |
| } |
| return errUnauthorized{err} |
| } |
| |
| type errUnavailable struct{ error } |
| |
| func (errUnavailable) Unavailable() {} |
| |
| func (e errUnavailable) Cause() error { |
| return e.error |
| } |
| |
| // Unavailable is a helper to create an error of the class with the same name from any error type |
| func Unavailable(err error) error { |
| if err == nil || IsUnavailable(err) { |
| return err |
| } |
| return errUnavailable{err} |
| } |
| |
| type errForbidden struct{ error } |
| |
| func (errForbidden) Forbidden() {} |
| |
| func (e errForbidden) Cause() error { |
| return e.error |
| } |
| |
| // Forbidden is a helper to create an error of the class with the same name from any error type |
| func Forbidden(err error) error { |
| if err == nil || IsForbidden(err) { |
| return err |
| } |
| return errForbidden{err} |
| } |
| |
| type errSystem struct{ error } |
| |
| func (errSystem) System() {} |
| |
| func (e errSystem) Cause() error { |
| return e.error |
| } |
| |
| // System is a helper to create an error of the class with the same name from any error type |
| func System(err error) error { |
| if err == nil || IsSystem(err) { |
| return err |
| } |
| return errSystem{err} |
| } |
| |
| type errNotModified struct{ error } |
| |
| func (errNotModified) NotModified() {} |
| |
| func (e errNotModified) Cause() error { |
| return e.error |
| } |
| |
| // NotModified is a helper to create an error of the class with the same name from any error type |
| func NotModified(err error) error { |
| if err == nil || IsNotModified(err) { |
| return err |
| } |
| return errNotModified{err} |
| } |
| |
| type errNotImplemented struct{ error } |
| |
| func (errNotImplemented) NotImplemented() {} |
| |
| func (e errNotImplemented) Cause() error { |
| return e.error |
| } |
| |
| // NotImplemented is a helper to create an error of the class with the same name from any error type |
| func NotImplemented(err error) error { |
| if err == nil || IsNotImplemented(err) { |
| return err |
| } |
| return errNotImplemented{err} |
| } |
| |
| type errUnknown struct{ error } |
| |
| func (errUnknown) Unknown() {} |
| |
| func (e errUnknown) Cause() error { |
| return e.error |
| } |
| |
| // Unknown is a helper to create an error of the class with the same name from any error type |
| func Unknown(err error) error { |
| if err == nil || IsUnknown(err) { |
| return err |
| } |
| return errUnknown{err} |
| } |
| |
| type errCancelled struct{ error } |
| |
| func (errCancelled) Cancelled() {} |
| |
| func (e errCancelled) Cause() error { |
| return e.error |
| } |
| |
| // Cancelled is a helper to create an error of the class with the same name from any error type |
| func Cancelled(err error) error { |
| if err == nil || IsCancelled(err) { |
| return err |
| } |
| return errCancelled{err} |
| } |
| |
| type errDeadline struct{ error } |
| |
| func (errDeadline) DeadlineExceeded() {} |
| |
| func (e errDeadline) Cause() error { |
| return e.error |
| } |
| |
| // Deadline is a helper to create an error of the class with the same name from any error type |
| func Deadline(err error) error { |
| if err == nil || IsDeadline(err) { |
| return err |
| } |
| return errDeadline{err} |
| } |
| |
| type errDataLoss struct{ error } |
| |
| func (errDataLoss) DataLoss() {} |
| |
| func (e errDataLoss) Cause() error { |
| return e.error |
| } |
| |
| // DataLoss is a helper to create an error of the class with the same name from any error type |
| func DataLoss(err error) error { |
| if err == nil || IsDataLoss(err) { |
| return err |
| } |
| return errDataLoss{err} |
| } |
| |
| // FromContext returns the error class from the passed in context |
| func FromContext(ctx context.Context) error { |
| e := ctx.Err() |
| if e == nil { |
| return nil |
| } |
| |
| if e == context.Canceled { |
| return Cancelled(e) |
| } |
| if e == context.DeadlineExceeded { |
| return Deadline(e) |
| } |
| return Unknown(e) |
| } |