From 8c12c6939aab9106db14ec2d11d983bc5b29fb2c Mon Sep 17 00:00:00 2001
From: Niall Sheridan <nsheridan@gmail.com>
Date: Sun, 7 Jul 2019 21:33:44 +0100
Subject: Switch to modules

---
 .../hashicorp/vault/helper/parseutil/parseutil.go  | 163 ---------------------
 1 file changed, 163 deletions(-)
 delete mode 100644 vendor/github.com/hashicorp/vault/helper/parseutil/parseutil.go

(limited to 'vendor/github.com/hashicorp/vault/helper/parseutil/parseutil.go')

diff --git a/vendor/github.com/hashicorp/vault/helper/parseutil/parseutil.go b/vendor/github.com/hashicorp/vault/helper/parseutil/parseutil.go
deleted file mode 100644
index 9b32bf7..0000000
--- a/vendor/github.com/hashicorp/vault/helper/parseutil/parseutil.go
+++ /dev/null
@@ -1,163 +0,0 @@
-package parseutil
-
-import (
-	"encoding/json"
-	"errors"
-	"fmt"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/hashicorp/errwrap"
-	sockaddr "github.com/hashicorp/go-sockaddr"
-	"github.com/hashicorp/vault/helper/strutil"
-	"github.com/mitchellh/mapstructure"
-)
-
-func ParseDurationSecond(in interface{}) (time.Duration, error) {
-	var dur time.Duration
-	jsonIn, ok := in.(json.Number)
-	if ok {
-		in = jsonIn.String()
-	}
-	switch in.(type) {
-	case string:
-		inp := in.(string)
-		if inp == "" {
-			return time.Duration(0), nil
-		}
-		var err error
-		// Look for a suffix otherwise its a plain second value
-		if strings.HasSuffix(inp, "s") || strings.HasSuffix(inp, "m") || strings.HasSuffix(inp, "h") || strings.HasSuffix(inp, "ms") {
-			dur, err = time.ParseDuration(inp)
-			if err != nil {
-				return dur, err
-			}
-		} else {
-			// Plain integer
-			secs, err := strconv.ParseInt(inp, 10, 64)
-			if err != nil {
-				return dur, err
-			}
-			dur = time.Duration(secs) * time.Second
-		}
-	case int:
-		dur = time.Duration(in.(int)) * time.Second
-	case int32:
-		dur = time.Duration(in.(int32)) * time.Second
-	case int64:
-		dur = time.Duration(in.(int64)) * time.Second
-	case uint:
-		dur = time.Duration(in.(uint)) * time.Second
-	case uint32:
-		dur = time.Duration(in.(uint32)) * time.Second
-	case uint64:
-		dur = time.Duration(in.(uint64)) * time.Second
-	default:
-		return 0, errors.New("could not parse duration from input")
-	}
-
-	return dur, nil
-}
-
-func ParseInt(in interface{}) (int64, error) {
-	var ret int64
-	jsonIn, ok := in.(json.Number)
-	if ok {
-		in = jsonIn.String()
-	}
-	switch in.(type) {
-	case string:
-		inp := in.(string)
-		if inp == "" {
-			return 0, nil
-		}
-		var err error
-		left, err := strconv.ParseInt(inp, 10, 64)
-		if err != nil {
-			return ret, err
-		}
-		ret = left
-	case int:
-		ret = int64(in.(int))
-	case int32:
-		ret = int64(in.(int32))
-	case int64:
-		ret = in.(int64)
-	case uint:
-		ret = int64(in.(uint))
-	case uint32:
-		ret = int64(in.(uint32))
-	case uint64:
-		ret = int64(in.(uint64))
-	default:
-		return 0, errors.New("could not parse value from input")
-	}
-
-	return ret, nil
-}
-
-func ParseBool(in interface{}) (bool, error) {
-	var result bool
-	if err := mapstructure.WeakDecode(in, &result); err != nil {
-		return false, err
-	}
-	return result, nil
-}
-
-func ParseCommaStringSlice(in interface{}) ([]string, error) {
-	var result []string
-	config := &mapstructure.DecoderConfig{
-		Result:           &result,
-		WeaklyTypedInput: true,
-		DecodeHook:       mapstructure.StringToSliceHookFunc(","),
-	}
-	decoder, err := mapstructure.NewDecoder(config)
-	if err != nil {
-		return nil, err
-	}
-	if err := decoder.Decode(in); err != nil {
-		return nil, err
-	}
-	return strutil.TrimStrings(result), nil
-}
-
-func ParseAddrs(addrs interface{}) ([]*sockaddr.SockAddrMarshaler, error) {
-	out := make([]*sockaddr.SockAddrMarshaler, 0)
-	stringAddrs := make([]string, 0)
-
-	switch addrs.(type) {
-	case string:
-		stringAddrs = strutil.ParseArbitraryStringSlice(addrs.(string), ",")
-		if len(stringAddrs) == 0 {
-			return nil, fmt.Errorf("unable to parse addresses from %v", addrs)
-		}
-
-	case []string:
-		stringAddrs = addrs.([]string)
-
-	case []interface{}:
-		for _, v := range addrs.([]interface{}) {
-			stringAddr, ok := v.(string)
-			if !ok {
-				return nil, fmt.Errorf("error parsing %v as string", v)
-			}
-			stringAddrs = append(stringAddrs, stringAddr)
-		}
-
-	default:
-		return nil, fmt.Errorf("unknown address input type %T", addrs)
-	}
-
-	for _, addr := range stringAddrs {
-		sa, err := sockaddr.NewSockAddr(addr)
-		if err != nil {
-			return nil, errwrap.Wrapf(fmt.Sprintf("error parsing address %q: {{err}}", addr), err)
-		}
-		out = append(out, &sockaddr.SockAddrMarshaler{
-			SockAddr: sa,
-		})
-	}
-
-	return out, nil
-}
-- 
cgit v1.2.3