From 54d3d47daf9190275bbdaf8703b84969a4593451 Mon Sep 17 00:00:00 2001
From: Corey Hulen <corey@hulen.com>
Date: Fri, 24 Mar 2017 23:31:34 -0700
Subject: PLT-6076 Adding viper libs for config file changes (#5871)

* Adding viper libs for config file changes

* Removing the old fsnotify lib

* updating some missing libs
---
 vendor/golang.org/x/text/internal/tag/tag.go      | 100 ++++++++++++++++++++++
 vendor/golang.org/x/text/internal/tag/tag_test.go |  67 +++++++++++++++
 2 files changed, 167 insertions(+)
 create mode 100644 vendor/golang.org/x/text/internal/tag/tag.go
 create mode 100644 vendor/golang.org/x/text/internal/tag/tag_test.go

(limited to 'vendor/golang.org/x/text/internal/tag')

diff --git a/vendor/golang.org/x/text/internal/tag/tag.go b/vendor/golang.org/x/text/internal/tag/tag.go
new file mode 100644
index 000000000..b5d348891
--- /dev/null
+++ b/vendor/golang.org/x/text/internal/tag/tag.go
@@ -0,0 +1,100 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package tag contains functionality handling tags and related data.
+package tag // import "golang.org/x/text/internal/tag"
+
+import "sort"
+
+// An Index converts tags to a compact numeric value.
+//
+// All elements are of size 4. Tags may be up to 4 bytes long. Excess bytes can
+// be used to store additional information about the tag.
+type Index string
+
+// Elem returns the element data at the given index.
+func (s Index) Elem(x int) string {
+	return string(s[x*4 : x*4+4])
+}
+
+// Index reports the index of the given key or -1 if it could not be found.
+// Only the first len(key) bytes from the start of the 4-byte entries will be
+// considered for the search and the first match in Index will be returned.
+func (s Index) Index(key []byte) int {
+	n := len(key)
+	// search the index of the first entry with an equal or higher value than
+	// key in s.
+	index := sort.Search(len(s)/4, func(i int) bool {
+		return cmp(s[i*4:i*4+n], key) != -1
+	})
+	i := index * 4
+	if cmp(s[i:i+len(key)], key) != 0 {
+		return -1
+	}
+	return index
+}
+
+// Next finds the next occurrence of key after index x, which must have been
+// obtained from a call to Index using the same key. It returns x+1 or -1.
+func (s Index) Next(key []byte, x int) int {
+	if x++; x*4 < len(s) && cmp(s[x*4:x*4+len(key)], key) == 0 {
+		return x
+	}
+	return -1
+}
+
+// cmp returns an integer comparing a and b lexicographically.
+func cmp(a Index, b []byte) int {
+	n := len(a)
+	if len(b) < n {
+		n = len(b)
+	}
+	for i, c := range b[:n] {
+		switch {
+		case a[i] > c:
+			return 1
+		case a[i] < c:
+			return -1
+		}
+	}
+	switch {
+	case len(a) < len(b):
+		return -1
+	case len(a) > len(b):
+		return 1
+	}
+	return 0
+}
+
+// Compare returns an integer comparing a and b lexicographically.
+func Compare(a string, b []byte) int {
+	return cmp(Index(a), b)
+}
+
+// FixCase reformats b to the same pattern of cases as form.
+// If returns false if string b is malformed.
+func FixCase(form string, b []byte) bool {
+	if len(form) != len(b) {
+		return false
+	}
+	for i, c := range b {
+		if form[i] <= 'Z' {
+			if c >= 'a' {
+				c -= 'z' - 'Z'
+			}
+			if c < 'A' || 'Z' < c {
+				return false
+			}
+		} else {
+			if c <= 'Z' {
+				c += 'z' - 'Z'
+			}
+			if c < 'a' || 'z' < c {
+				return false
+			}
+		}
+		b[i] = c
+	}
+	return true
+}
diff --git a/vendor/golang.org/x/text/internal/tag/tag_test.go b/vendor/golang.org/x/text/internal/tag/tag_test.go
new file mode 100644
index 000000000..da174a24c
--- /dev/null
+++ b/vendor/golang.org/x/text/internal/tag/tag_test.go
@@ -0,0 +1,67 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package tag
+
+import (
+	"strings"
+	"testing"
+)
+
+var strdata = []string{
+	"aa  ",
+	"aaa ",
+	"aaaa",
+	"aaab",
+	"aab ",
+	"ab  ",
+	"ba  ",
+	"xxxx",
+	"\xff\xff\xff\xff",
+}
+
+var testCases = map[string]int{
+	"a":    0,
+	"aa":   0,
+	"aaa":  1,
+	"aa ":  0,
+	"aaaa": 2,
+	"aaab": 3,
+	"b":    6,
+	"ba":   6,
+	"    ": -1,
+	"aaax": -1,
+	"bbbb": -1,
+	"zzzz": -1,
+}
+
+func TestIndex(t *testing.T) {
+	index := Index(strings.Join(strdata, ""))
+	for k, v := range testCases {
+		if i := index.Index([]byte(k)); i != v {
+			t.Errorf("%s: got %d; want %d", k, i, v)
+		}
+	}
+}
+
+func TestFixCase(t *testing.T) {
+	tests := []string{
+		"aaaa", "AbCD", "abcd",
+		"Zzzz", "AbCD", "Abcd",
+		"Zzzz", "AbC", "",
+		"XXX", "ab ", "",
+		"XXX", "usd", "USD",
+		"cmn", "AB ", "",
+		"gsw", "CMN", "cmn",
+	}
+	for tc := tests; len(tc) > 0; tc = tc[3:] {
+		b := []byte(tc[1])
+		if !FixCase(tc[0], b) {
+			b = nil
+		}
+		if string(b) != tc[2] {
+			t.Errorf("FixCase(%q, %q) = %q; want %q", tc[0], tc[1], b, tc[2])
+		}
+	}
+}
-- 
cgit v1.2.3-1-g7c22