update get-transaction

[bytom/shuttle.git] / vendor / github.com / gin-gonic / gin / errors.go

diff --git a/vendor/github.com/gin-gonic/gin/errors.go b/vendor/github.com/gin-gonic/gin/errors.go
new file mode 100644 (file)
index 0000000..dbfccd8
--- /dev/null
+++ b/vendor/github.com/gin-gonic/gin/errors.go
@@ -0,0 +1,157 @@
+// Copyright 2014 Manu Martinez-Almeida.  All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package gin
+
+import (
+       "bytes"
+       "fmt"
+       "reflect"
+
+       "github.com/gin-gonic/gin/json"
+)
+
+type ErrorType uint64
+
+const (
+       ErrorTypeBind    ErrorType = 1 << 63 // used when c.Bind() fails
+       ErrorTypeRender  ErrorType = 1 << 62 // used when c.Render() fails
+       ErrorTypePrivate ErrorType = 1 << 0
+       ErrorTypePublic  ErrorType = 1 << 1
+
+       ErrorTypeAny ErrorType = 1<<64 - 1
+       ErrorTypeNu            = 2
+)
+
+type Error struct {
+       Err  error
+       Type ErrorType
+       Meta interface{}
+}
+
+type errorMsgs []*Error
+
+var _ error = &Error{}
+
+func (msg *Error) SetType(flags ErrorType) *Error {
+       msg.Type = flags
+       return msg
+}
+
+func (msg *Error) SetMeta(data interface{}) *Error {
+       msg.Meta = data
+       return msg
+}
+
+func (msg *Error) JSON() interface{} {
+       json := H{}
+       if msg.Meta != nil {
+               value := reflect.ValueOf(msg.Meta)
+               switch value.Kind() {
+               case reflect.Struct:
+                       return msg.Meta
+               case reflect.Map:
+                       for _, key := range value.MapKeys() {
+                               json[key.String()] = value.MapIndex(key).Interface()
+                       }
+               default:
+                       json["meta"] = msg.Meta
+               }
+       }
+       if _, ok := json["error"]; !ok {
+               json["error"] = msg.Error()
+       }
+       return json
+}
+
+// MarshalJSON implements the json.Marshaller interface.
+func (msg *Error) MarshalJSON() ([]byte, error) {
+       return json.Marshal(msg.JSON())
+}
+
+// Error implements the error interface
+func (msg Error) Error() string {
+       return msg.Err.Error()
+}
+
+func (msg *Error) IsType(flags ErrorType) bool {
+       return (msg.Type & flags) > 0
+}
+
+// ByType returns a readonly copy filtered the byte.
+// ie ByType(gin.ErrorTypePublic) returns a slice of errors with type=ErrorTypePublic.
+func (a errorMsgs) ByType(typ ErrorType) errorMsgs {
+       if len(a) == 0 {
+               return nil
+       }
+       if typ == ErrorTypeAny {
+               return a
+       }
+       var result errorMsgs
+       for _, msg := range a {
+               if msg.IsType(typ) {
+                       result = append(result, msg)
+               }
+       }
+       return result
+}
+
+// Last returns the last error in the slice. It returns nil if the array is empty.
+// Shortcut for errors[len(errors)-1].
+func (a errorMsgs) Last() *Error {
+       if length := len(a); length > 0 {
+               return a[length-1]
+       }
+       return nil
+}
+
+// Errors returns an array will all the error messages.
+// Example:
+//             c.Error(errors.New("first"))
+//             c.Error(errors.New("second"))
+//             c.Error(errors.New("third"))
+//             c.Errors.Errors() // == []string{"first", "second", "third"}
+func (a errorMsgs) Errors() []string {
+       if len(a) == 0 {
+               return nil
+       }
+       errorStrings := make([]string, len(a))
+       for i, err := range a {
+               errorStrings[i] = err.Error()
+       }
+       return errorStrings
+}
+
+func (a errorMsgs) JSON() interface{} {
+       switch len(a) {
+       case 0:
+               return nil
+       case 1:
+               return a.Last().JSON()
+       default:
+               json := make([]interface{}, len(a))
+               for i, err := range a {
+                       json[i] = err.JSON()
+               }
+               return json
+       }
+}
+
+func (a errorMsgs) MarshalJSON() ([]byte, error) {
+       return json.Marshal(a.JSON())
+}
+
+func (a errorMsgs) String() string {
+       if len(a) == 0 {
+               return ""
+       }
+       var buffer bytes.Buffer
+       for i, msg := range a {
+               fmt.Fprintf(&buffer, "Error #%02d: %s\n", i+1, msg.Err)
+               if msg.Meta != nil {
+                       fmt.Fprintf(&buffer, "     Meta: %v\n", msg.Meta)
+               }
+       }
+       return buffer.String()
+}