github.com/pwn-term/docker@v0.0.0-20210616085119-6e977cce2565/moby/errdefs/helpers.go (about)

     1  package errdefs // import "github.com/docker/docker/errdefs"
     2  
     3  import "context"
     4  
     5  type errNotFound struct{ error }
     6  
     7  func (errNotFound) NotFound() {}
     8  
     9  func (e errNotFound) Cause() error {
    10  	return e.error
    11  }
    12  
    13  func (e errNotFound) Unwrap() error {
    14  	return e.error
    15  }
    16  
    17  // NotFound is a helper to create an error of the class with the same name from any error type
    18  func NotFound(err error) error {
    19  	if err == nil || IsNotFound(err) {
    20  		return err
    21  	}
    22  	return errNotFound{err}
    23  }
    24  
    25  type errInvalidParameter struct{ error }
    26  
    27  func (errInvalidParameter) InvalidParameter() {}
    28  
    29  func (e errInvalidParameter) Cause() error {
    30  	return e.error
    31  }
    32  
    33  func (e errInvalidParameter) Unwrap() error {
    34  	return e.error
    35  }
    36  
    37  // InvalidParameter is a helper to create an error of the class with the same name from any error type
    38  func InvalidParameter(err error) error {
    39  	if err == nil || IsInvalidParameter(err) {
    40  		return err
    41  	}
    42  	return errInvalidParameter{err}
    43  }
    44  
    45  type errConflict struct{ error }
    46  
    47  func (errConflict) Conflict() {}
    48  
    49  func (e errConflict) Cause() error {
    50  	return e.error
    51  }
    52  
    53  func (e errConflict) Unwrap() error {
    54  	return e.error
    55  }
    56  
    57  // Conflict is a helper to create an error of the class with the same name from any error type
    58  func Conflict(err error) error {
    59  	if err == nil || IsConflict(err) {
    60  		return err
    61  	}
    62  	return errConflict{err}
    63  }
    64  
    65  type errUnauthorized struct{ error }
    66  
    67  func (errUnauthorized) Unauthorized() {}
    68  
    69  func (e errUnauthorized) Cause() error {
    70  	return e.error
    71  }
    72  
    73  func (e errUnauthorized) Unwrap() error {
    74  	return e.error
    75  }
    76  
    77  // Unauthorized is a helper to create an error of the class with the same name from any error type
    78  func Unauthorized(err error) error {
    79  	if err == nil || IsUnauthorized(err) {
    80  		return err
    81  	}
    82  	return errUnauthorized{err}
    83  }
    84  
    85  type errUnavailable struct{ error }
    86  
    87  func (errUnavailable) Unavailable() {}
    88  
    89  func (e errUnavailable) Cause() error {
    90  	return e.error
    91  }
    92  
    93  func (e errUnavailable) Unwrap() error {
    94  	return e.error
    95  }
    96  
    97  // Unavailable is a helper to create an error of the class with the same name from any error type
    98  func Unavailable(err error) error {
    99  	if err == nil || IsUnavailable(err) {
   100  		return err
   101  	}
   102  	return errUnavailable{err}
   103  }
   104  
   105  type errForbidden struct{ error }
   106  
   107  func (errForbidden) Forbidden() {}
   108  
   109  func (e errForbidden) Cause() error {
   110  	return e.error
   111  }
   112  
   113  func (e errForbidden) Unwrap() error {
   114  	return e.error
   115  }
   116  
   117  // Forbidden is a helper to create an error of the class with the same name from any error type
   118  func Forbidden(err error) error {
   119  	if err == nil || IsForbidden(err) {
   120  		return err
   121  	}
   122  	return errForbidden{err}
   123  }
   124  
   125  type errSystem struct{ error }
   126  
   127  func (errSystem) System() {}
   128  
   129  func (e errSystem) Cause() error {
   130  	return e.error
   131  }
   132  
   133  func (e errSystem) Unwrap() error {
   134  	return e.error
   135  }
   136  
   137  // System is a helper to create an error of the class with the same name from any error type
   138  func System(err error) error {
   139  	if err == nil || IsSystem(err) {
   140  		return err
   141  	}
   142  	return errSystem{err}
   143  }
   144  
   145  type errNotModified struct{ error }
   146  
   147  func (errNotModified) NotModified() {}
   148  
   149  func (e errNotModified) Cause() error {
   150  	return e.error
   151  }
   152  
   153  func (e errNotModified) Unwrap() error {
   154  	return e.error
   155  }
   156  
   157  // NotModified is a helper to create an error of the class with the same name from any error type
   158  func NotModified(err error) error {
   159  	if err == nil || IsNotModified(err) {
   160  		return err
   161  	}
   162  	return errNotModified{err}
   163  }
   164  
   165  type errNotImplemented struct{ error }
   166  
   167  func (errNotImplemented) NotImplemented() {}
   168  
   169  func (e errNotImplemented) Cause() error {
   170  	return e.error
   171  }
   172  
   173  func (e errNotImplemented) Unwrap() error {
   174  	return e.error
   175  }
   176  
   177  // NotImplemented is a helper to create an error of the class with the same name from any error type
   178  func NotImplemented(err error) error {
   179  	if err == nil || IsNotImplemented(err) {
   180  		return err
   181  	}
   182  	return errNotImplemented{err}
   183  }
   184  
   185  type errUnknown struct{ error }
   186  
   187  func (errUnknown) Unknown() {}
   188  
   189  func (e errUnknown) Cause() error {
   190  	return e.error
   191  }
   192  
   193  func (e errUnknown) Unwrap() error {
   194  	return e.error
   195  }
   196  
   197  // Unknown is a helper to create an error of the class with the same name from any error type
   198  func Unknown(err error) error {
   199  	if err == nil || IsUnknown(err) {
   200  		return err
   201  	}
   202  	return errUnknown{err}
   203  }
   204  
   205  type errCancelled struct{ error }
   206  
   207  func (errCancelled) Cancelled() {}
   208  
   209  func (e errCancelled) Cause() error {
   210  	return e.error
   211  }
   212  
   213  func (e errCancelled) Unwrap() error {
   214  	return e.error
   215  }
   216  
   217  // Cancelled is a helper to create an error of the class with the same name from any error type
   218  func Cancelled(err error) error {
   219  	if err == nil || IsCancelled(err) {
   220  		return err
   221  	}
   222  	return errCancelled{err}
   223  }
   224  
   225  type errDeadline struct{ error }
   226  
   227  func (errDeadline) DeadlineExceeded() {}
   228  
   229  func (e errDeadline) Cause() error {
   230  	return e.error
   231  }
   232  
   233  func (e errDeadline) Unwrap() error {
   234  	return e.error
   235  }
   236  
   237  // Deadline is a helper to create an error of the class with the same name from any error type
   238  func Deadline(err error) error {
   239  	if err == nil || IsDeadline(err) {
   240  		return err
   241  	}
   242  	return errDeadline{err}
   243  }
   244  
   245  type errDataLoss struct{ error }
   246  
   247  func (errDataLoss) DataLoss() {}
   248  
   249  func (e errDataLoss) Cause() error {
   250  	return e.error
   251  }
   252  
   253  func (e errDataLoss) Unwrap() error {
   254  	return e.error
   255  }
   256  
   257  // DataLoss is a helper to create an error of the class with the same name from any error type
   258  func DataLoss(err error) error {
   259  	if err == nil || IsDataLoss(err) {
   260  		return err
   261  	}
   262  	return errDataLoss{err}
   263  }
   264  
   265  // FromContext returns the error class from the passed in context
   266  func FromContext(ctx context.Context) error {
   267  	e := ctx.Err()
   268  	if e == nil {
   269  		return nil
   270  	}
   271  
   272  	if e == context.Canceled {
   273  		return Cancelled(e)
   274  	}
   275  	if e == context.DeadlineExceeded {
   276  		return Deadline(e)
   277  	}
   278  	return Unknown(e)
   279  }