Initial commit

vendor/github.com/cockroachdb/errors/markers/markers.go

@@ -0,0 +1,271 @@
+// Copyright 2019 The Cockroach Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+// implied. See the License for the specific language governing
+// permissions and limitations under the License.
+
+package markers
+
+import (
+	"context"
+	"fmt"
+	"reflect"
+
+	"github.com/cockroachdb/errors/errbase"
+	"github.com/cockroachdb/errors/errorspb"
+	"github.com/cockroachdb/redact"
+	"github.com/gogo/protobuf/proto"
+)
+
+// Is determines whether one of the causes of the given error or any
+// of its causes is equivalent to some reference error.
+//
+// Note: if any of the error types has been migrated from a previous
+// package location or a different type, ensure that
+// RegisterTypeMigration() was called prior to Is().
+func Is(err, reference error) bool {
+	if reference == nil {
+		return err == reference
+	}
+
+	// Direct reference comparison is the fastest, and most
+	// likely to be true, so do this first.
+	for c := err; c != nil; c = errbase.UnwrapOnce(c) {
+		if c == reference {
+			return true
+		}
+	}
+
+	if err == nil {
+		// Err is nil and reference is non-nil, so it cannot match. We
+		// want to short-circuit the loop below in this case, otherwise
+		// we're paying the expense of getMark() without need.
+		return false
+	}
+
+	// Not directly equal. Try harder, using error marks. We don't this
+	// during the loop above as it may be more expensive.
+	//
+	// Note: there is a more effective recursive algorithm that ensures
+	// that any pair of string only gets compared once. Should the
+	// following code become a performance bottleneck, that algorithm
+	// can be considered instead.
+	refMark := getMark(reference)
+	for c := err; c != nil; c = errbase.UnwrapOnce(c) {
+		if equalMarks(getMark(c), refMark) {
+			return true
+		}
+	}
+	return false
+}
+
+// HasType returns true iff err contains an error whose concrete type
+// matches that of referenceType.
+func HasType(err error, referenceType error) bool {
+	typ := reflect.TypeOf(referenceType)
+	_, isType := If(err, func(err error) (interface{}, bool) {
+		return nil, reflect.TypeOf(err) == typ
+	})
+	return isType
+}
+
+// HasInterface returns true if err contains an error which implements the
+// interface pointed to by referenceInterface. The type of referenceInterface
+// must be a pointer to an interface type. If referenceInterface is not a
+// pointer to an interface, this function will panic.
+func HasInterface(err error, referenceInterface interface{}) bool {
+	iface := getInterfaceType("HasInterface", referenceInterface)
+	_, isType := If(err, func(err error) (interface{}, bool) {
+		return nil, reflect.TypeOf(err).Implements(iface)
+	})
+	return isType
+}
+
+func getInterfaceType(context string, referenceInterface interface{}) reflect.Type {
+	typ := reflect.TypeOf(referenceInterface)
+	if typ == nil || typ.Kind() != reflect.Ptr || typ.Elem().Kind() != reflect.Interface {
+		panic(fmt.Errorf("errors.%s: referenceInterface must be a pointer to an interface, "+
+			"found %T", context, referenceInterface))
+	}
+	return typ.Elem()
+}
+
+// If iterates on the error's causal chain and returns a predicate's
+// return value the first time the predicate returns true.
+//
+// Note: if any of the error types has been migrated from a previous
+// package location or a different type, ensure that
+// RegisterTypeMigration() was called prior to If().
+func If(err error, pred func(err error) (interface{}, bool)) (interface{}, bool) {
+	for c := err; c != nil; c = errbase.UnwrapOnce(c) {
+		if v, ok := pred(c); ok {
+			return v, ok
+		}
+	}
+	return nil, false
+}
+
+// IsAny is like Is except that multiple references are compared.
+//
+// Note: if any of the error types has been migrated from a previous
+// package location or a different type, ensure that
+// RegisterTypeMigration() was called prior to IsAny().
+func IsAny(err error, references ...error) bool {
+	// First try using direct reference comparison.
+	for c := err; ; c = errbase.UnwrapOnce(c) {
+		for _, refErr := range references {
+			if c == refErr {
+				return true
+			}
+		}
+		if c == nil {
+			// This special case is to support a comparison to a nil
+			// reference.
+			break
+		}
+	}
+
+	if err == nil {
+		// The mark-based comparison below will never match anything if
+		// the error is nil, so don't bother with computing the marks in
+		// that case. This avoids the computational expense of computing
+		// the reference marks upfront.
+		return false
+	}
+
+	// Try harder with marks.
+	// Note: there is a more effective recursive algorithm that ensures
+	// that any pair of string only gets compared once. Should this
+	// become a performance bottleneck, that algorithm can be considered
+	// instead.
+	refMarks := make([]errorMark, 0, len(references))
+	for _, refErr := range references {
+		if refErr == nil {
+			continue
+		}
+		refMarks = append(refMarks, getMark(refErr))
+	}
+	for c := err; c != nil; c = errbase.UnwrapOnce(c) {
+		errMark := getMark(c)
+		for _, refMark := range refMarks {
+			if equalMarks(errMark, refMark) {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+type errorMark struct {
+	msg   string
+	types []errorspb.ErrorTypeMark
+}
+
+// equalMarks compares two error markers.
+func equalMarks(m1, m2 errorMark) bool {
+	if m1.msg != m2.msg {
+		return false
+	}
+	for i, t := range m1.types {
+		if !t.Equals(m2.types[i]) {
+			return false
+		}
+	}
+	return true
+}
+
+// getMark computes a marker for the given error.
+func getMark(err error) errorMark {
+	if m, ok := err.(*withMark); ok {
+		return m.mark
+	}
+	m := errorMark{msg: safeGetErrMsg(err), types: []errorspb.ErrorTypeMark{errbase.GetTypeMark(err)}}
+	for c := errbase.UnwrapOnce(err); c != nil; c = errbase.UnwrapOnce(c) {
+		m.types = append(m.types, errbase.GetTypeMark(c))
+	}
+	return m
+}
+
+// safeGetErrMsg extracts an error's Error() but tolerates panics.
+func safeGetErrMsg(err error) (result string) {
+	defer func() {
+		if r := recover(); r != nil {
+			result = fmt.Sprintf("(%p).Error() panic: %v", err, r)
+		}
+	}()
+	result = err.Error()
+	return
+}
+
+// Mark creates an explicit mark for the given error, using
+// the same mark as some reference error.
+//
+// Note: if any of the error types has been migrated from a previous
+// package location or a different type, ensure that
+// RegisterTypeMigration() was called prior to Mark().
+func Mark(err error, reference error) error {
+	if err == nil {
+		return nil
+	}
+	refMark := getMark(reference)
+	return &withMark{cause: err, mark: refMark}
+}
+
+// withMark carries an explicit mark.
+type withMark struct {
+	cause error
+	mark  errorMark
+}
+
+var _ error = (*withMark)(nil)
+var _ fmt.Formatter = (*withMark)(nil)
+var _ errbase.SafeFormatter = (*withMark)(nil)
+
+func (m *withMark) Error() string { return m.cause.Error() }
+func (m *withMark) Cause() error  { return m.cause }
+func (m *withMark) Unwrap() error { return m.cause }
+
+func (m *withMark) Format(s fmt.State, verb rune) { errbase.FormatError(m, s, verb) }
+
+func (m *withMark) SafeFormatError(p errbase.Printer) error {
+	if p.Detail() {
+		p.Printf("forced error mark\n")
+		p.Printf("%q\n%s::%s",
+			m.mark.msg,
+			redact.Safe(m.mark.types[0].FamilyName),
+			redact.Safe(m.mark.types[0].Extension),
+		)
+	}
+	return m.cause
+}
+
+func encodeMark(_ context.Context, err error) (msg string, _ []string, payload proto.Message) {
+	m := err.(*withMark)
+	payload = &errorspb.MarkPayload{Msg: m.mark.msg, Types: m.mark.types}
+	return "", nil, payload
+}
+
+func decodeMark(_ context.Context, cause error, _ string, _ []string, payload proto.Message) error {
+	m, ok := payload.(*errorspb.MarkPayload)
+	if !ok {
+		// If this ever happens, this means some version of the library
+		// (presumably future) changed the payload type, and we're
+		// receiving this here. In this case, give up and let
+		// DecodeError use the opaque type.
+		return nil
+	}
+	return &withMark{cause: cause, mark: errorMark{msg: m.Msg, types: m.Types}}
+}
+
+func init() {
+	errbase.RegisterWrapperEncoder(errbase.GetTypeKey((*withMark)(nil)), encodeMark)
+	errbase.RegisterWrapperDecoder(errbase.GetTypeKey((*withMark)(nil)), decodeMark)
+}