package multierror

import "github.com/hashicorp/go-multierror"

Index ¶

• func Flatten(err error) error
• func ListFormatFunc(es []error) string
• func Prefix(err error, prefix string) error
• type Error
• func Append(err error, errs ...error) *Error
• func (e *Error) Error() string
• func (e *Error) ErrorOrNil() error
• func (e *Error) GoString() string
• func (err Error) Len() int
• func (err Error) Less(i, j int) bool
• func (err Error) Swap(i, j int)
• func (e *Error) Unwrap() error
• func (e *Error) WrappedErrors() []error
• type ErrorFormatFunc
• type Group
• func (g *Group) Go(f func() error)
• func (g *Group) Wait() *Error

Functions ¶

func Flatten ¶

func Flatten(err error) error

Flatten flattens the given error, merging any *Errors together into a single *Error.

func ListFormatFunc ¶

func ListFormatFunc(es []error) string

ListFormatFunc is a basic formatter that outputs the number of errors that occurred along with a bullet point list of the errors.

func Prefix ¶

func Prefix(err error, prefix string) error

Prefix is a helper function that will prefix some text to the given error. If the error is a multierror.Error, then it will be prefixed to each wrapped error.

This is useful to use when appending multiple multierrors together in order to give better scoping.

Types ¶

type Error ¶

type Error struct {
	Errors      []error
	ErrorFormat ErrorFormatFunc
}

Error is an error type to track multiple errors. This is used to accumulate errors in cases and return them as a single "error".

func Append ¶

func Append(err error, errs ...error) *Error

Append is a helper function that will append more errors onto an Error in order to create a larger multi-error.

If err is not a multierror.Error, then it will be turned into one. If any of the errs are multierr.Error, they will be flattened one level into err.

func (*Error) Error ¶

func (e *Error) Error() string

func (*Error) ErrorOrNil ¶

func (e *Error) ErrorOrNil() error

ErrorOrNil returns an error interface if this Error represents a list of errors, or returns nil if the list of errors is empty. This function is useful at the end of accumulation to make sure that the value returned represents the existence of errors.

func (*Error) GoString ¶

func (e *Error) GoString() string

func (Error) Len ¶

func (err Error) Len() int

Len implements sort.Interface function for length

func (Error) Less ¶

func (err Error) Less(i, j int) bool

Less implements sort.Interface function for determining order

func (Error) Swap ¶

func (err Error) Swap(i, j int)

Swap implements sort.Interface function for swapping elements

func (*Error) Unwrap ¶

func (e *Error) Unwrap() error

Unwrap returns an error from Error (or nil if there are no errors). This error returned will further support Unwrap to get the next error, etc. The order will match the order of Errors in the multierror.Error at the time of calling.

The resulting error supports errors.As/Is/Unwrap so you can continue to use the stdlib errors package to introspect further.

This will perform a shallow copy of the errors slice. Any errors appended to this error after calling Unwrap will not be available until a new Unwrap is called on the multierror.Error.

func (*Error) WrappedErrors ¶

func (e *Error) WrappedErrors() []error

WrappedErrors returns the list of errors that this Error is wrapping. It is an implementation of the errwrap.Wrapper interface so that multierror.Error can be used with that library.

This method is not safe to be called concurrently and is no different than accessing the Errors field directly. It is implemented only to satisfy the errwrap.Wrapper interface.

type ErrorFormatFunc ¶

type ErrorFormatFunc func([]error) string

ErrorFormatFunc is a function callback that is called by Error to turn the list of errors into a string.

type Group ¶

type Group struct {
	// contains filtered or unexported fields
}

Group is a collection of goroutines which return errors that need to be coalesced.

func (*Group) Go ¶

func (g *Group) Go(f func() error)

Go calls the given function in a new goroutine.

If the function returns an error it is added to the group multierror which is returned by Wait.

func (*Group) Wait ¶

func (g *Group) Wait() *Error

Wait blocks until all function calls from the Go method have returned, then returns the multierror.

Source Files ¶

append.go flatten.go format.go group.go multierror.go prefix.go sort.go