Function decodeLeaf

errbase/decode.go:35–98

(ctx context.Context, enc *errorspb.EncodedErrorLeaf)

}

func decodeLeaf(ctx context.Context, enc *errorspb.EncodedErrorLeaf) error {
	// In case there is a detailed payload, decode it.
	var payload proto.Message
	if enc.Details.FullDetails != nil {
		var d types.DynamicAny
		err := types.UnmarshalAny(enc.Details.FullDetails, &d)
		if err != nil {
			// It's OK if we can't decode. We'll use
			// the opaque type below.
			warningFn(ctx, "error while unmarshalling error: %+v", err)
		} else {
			payload = d.Message
		}
	}

	// Do we have a leaf decoder for this type?
	typeKey := TypeKey(enc.Details.ErrorTypeMark.FamilyName)
	if decoder, ok := leafDecoders[typeKey]; ok {
		// Yes, use it.
		genErr := decoder(ctx, enc.Message, enc.Details.ReportablePayload, payload)
		if genErr != nil {
			// Decoding succeeded. Use this.
			return genErr
		}
		// Decoding failed, we'll drop through to opaqueLeaf{} below.
	} else if decoder, ok := multiCauseDecoders[typeKey]; ok {
		causes := make([]error, len(enc.MultierrorCauses))
		for i, e := range enc.MultierrorCauses {
			causes[i] = DecodeError(ctx, *e)
		}
		genErr := decoder(ctx, causes, enc.Message, enc.Details.ReportablePayload, payload)
		if genErr != nil {
			return genErr
		}
	} else {
		// Shortcut for non-registered proto-encodable error types:
		// if it already implements `error`, it's good to go.
		if e, ok := payload.(error); ok {
			// yes: we're done!
			return e
		}
	}

	if len(enc.MultierrorCauses) > 0 {
		causes := make([]error, len(enc.MultierrorCauses))
		for i, e := range enc.MultierrorCauses {
			causes[i] = DecodeError(ctx, *e)
		}
		leaf := &opaqueLeafCauses{
			causes: causes,
		}
		leaf.msg = enc.Message
		leaf.details = enc.Details
		return leaf
	}

	// No decoder and no error type: we'll keep what we received and
	// make it ready to re-encode exactly (if the error leaves over the