Added vendor lock on depsHEADmaster

1 files changed, 123 insertions, 0 deletions

diff --git a/vendor/github.com/alexflint/go-arg/sequence.go b/vendor/github.com/alexflint/go-arg/sequence.go
new file mode 100644
index 0000000..35a3614
--- /dev/null
+++ b/vendor/github.com/alexflint/go-arg/sequence.go
@@ -0,0 +1,123 @@
+package arg
+
+import (
+        "fmt"
+        "reflect"
+        "strings"
+
+        scalar "github.com/alexflint/go-scalar"
+)
+
+// setSliceOrMap parses a sequence of strings into a slice or map. If clear is
+// true then any values already in the slice or map are first removed.
+func setSliceOrMap(dest reflect.Value, values []string, clear bool) error {
+        if !dest.CanSet() {
+                return fmt.Errorf("field is not writable")
+        }
+
+        t := dest.Type()
+        if t.Kind() == reflect.Ptr {
+                dest = dest.Elem()
+                t = t.Elem()
+        }
+
+        switch t.Kind() {
+        case reflect.Slice:
+                return setSlice(dest, values, clear)
+        case reflect.Map:
+                return setMap(dest, values, clear)
+        default:
+                return fmt.Errorf("setSliceOrMap cannot insert values into a %v", t)
+        }
+}
+
+// setSlice parses a sequence of strings and inserts them into a slice. If clear
+// is true then any values already in the slice are removed.
+func setSlice(dest reflect.Value, values []string, clear bool) error {
+        var ptr bool
+        elem := dest.Type().Elem()
+        if elem.Kind() == reflect.Ptr && !elem.Implements(textUnmarshalerType) {
+                ptr = true
+                elem = elem.Elem()
+        }
+
+        // clear the slice in case default values exist
+        if clear && !dest.IsNil() {
+                dest.SetLen(0)
+        }
+
+        // parse the values one-by-one
+        for _, s := range values {
+                v := reflect.New(elem)
+                if err := scalar.ParseValue(v.Elem(), s); err != nil {
+                        return err
+                }
+                if !ptr {
+                        v = v.Elem()
+                }
+                dest.Set(reflect.Append(dest, v))
+        }
+        return nil
+}
+
+// setMap parses a sequence of name=value strings and inserts them into a map.
+// If clear is true then any values already in the map are removed.
+func setMap(dest reflect.Value, values []string, clear bool) error {
+        // determine the key and value type
+        var keyIsPtr bool
+        keyType := dest.Type().Key()
+        if keyType.Kind() == reflect.Ptr && !keyType.Implements(textUnmarshalerType) {
+                keyIsPtr = true
+                keyType = keyType.Elem()
+        }
+
+        var valIsPtr bool
+        valType := dest.Type().Elem()
+        if valType.Kind() == reflect.Ptr && !valType.Implements(textUnmarshalerType) {
+                valIsPtr = true
+                valType = valType.Elem()
+        }
+
+        // clear the slice in case default values exist
+        if clear && !dest.IsNil() {
+                for _, k := range dest.MapKeys() {
+                        dest.SetMapIndex(k, reflect.Value{})
+                }
+        }
+
+        // allocate the map if it is not allocated
+        if dest.IsNil() {
+                dest.Set(reflect.MakeMap(dest.Type()))
+        }
+
+        // parse the values one-by-one
+        for _, s := range values {
+                // split at the first equals sign
+                pos := strings.Index(s, "=")
+                if pos == -1 {
+                        return fmt.Errorf("cannot parse %q into a map, expected format key=value", s)
+                }
+
+                // parse the key
+                k := reflect.New(keyType)
+                if err := scalar.ParseValue(k.Elem(), s[:pos]); err != nil {
+                        return err
+                }
+                if !keyIsPtr {
+                        k = k.Elem()
+                }
+
+                // parse the value
+                v := reflect.New(valType)
+                if err := scalar.ParseValue(v.Elem(), s[pos+1:]); err != nil {
+                        return err
+                }
+                if !valIsPtr {
+                        v = v.Elem()
+                }
+
+                // add it to the map
+                dest.SetMapIndex(k, v)
+        }
+        return nil
+}