[chore] remove vendor

1 files changed, 0 insertions, 327 deletions

diff --git a/vendor/github.com/go-openapi/strfmt/format.go b/vendor/github.com/go-openapi/strfmt/format.go
deleted file mode 100644
index 888e107c3..000000000
--- a/vendor/github.com/go-openapi/strfmt/format.go
+++ /dev/null
@@ -1,327 +0,0 @@
-// Copyright 2015 go-swagger maintainers
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//    http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package strfmt
-
-import (
-	"encoding"
-	stderrors "errors"
-	"fmt"
-	"reflect"
-	"strings"
-	"sync"
-	"time"
-
-	"github.com/go-openapi/errors"
-	"github.com/mitchellh/mapstructure"
-)
-
-// Default is the default formats registry
-var Default = NewSeededFormats(nil, nil)
-
-// Validator represents a validator for a string format.
-type Validator func(string) bool
-
-// Format represents a string format.
-//
-// All implementations of Format provide a string representation and text
-// marshaling/unmarshaling interface to be used by encoders (e.g. encoding/json).
-type Format interface {
-	String() string
-	encoding.TextMarshaler
-	encoding.TextUnmarshaler
-}
-
-// Registry is a registry of string formats, with a validation method.
-type Registry interface {
-	Add(string, Format, Validator) bool
-	DelByName(string) bool
-	GetType(string) (reflect.Type, bool)
-	ContainsName(string) bool
-	Validates(string, string) bool
-	Parse(string, string) (interface{}, error)
-	MapStructureHookFunc() mapstructure.DecodeHookFunc
-}
-
-type knownFormat struct {
-	Name      string
-	OrigName  string
-	Type      reflect.Type
-	Validator Validator
-}
-
-// NameNormalizer is a function that normalizes a format name.
-type NameNormalizer func(string) string
-
-// DefaultNameNormalizer removes all dashes
-func DefaultNameNormalizer(name string) string {
-	return strings.ReplaceAll(name, "-", "")
-}
-
-type defaultFormats struct {
-	sync.Mutex
-	data          []knownFormat
-	normalizeName NameNormalizer
-}
-
-// NewFormats creates a new formats registry seeded with the values from the default
-func NewFormats() Registry {
-	//nolint:forcetypeassert
-	return NewSeededFormats(Default.(*defaultFormats).data, nil)
-}
-
-// NewSeededFormats creates a new formats registry
-func NewSeededFormats(seeds []knownFormat, normalizer NameNormalizer) Registry {
-	if normalizer == nil {
-		normalizer = DefaultNameNormalizer
-	}
-	// copy here, don't modify original
-	d := append([]knownFormat(nil), seeds...)
-	return &defaultFormats{
-		data:          d,
-		normalizeName: normalizer,
-	}
-}
-
-// MapStructureHookFunc is a decode hook function for mapstructure
-func (f *defaultFormats) MapStructureHookFunc() mapstructure.DecodeHookFunc {
-	return func(from reflect.Type, to reflect.Type, obj interface{}) (interface{}, error) {
-		if from.Kind() != reflect.String {
-			return obj, nil
-		}
-		data, ok := obj.(string)
-		if !ok {
-			return nil, fmt.Errorf("failed to cast %+v to string", obj)
-		}
-
-		for _, v := range f.data {
-			tpe, _ := f.GetType(v.Name)
-			if to == tpe {
-				switch v.Name {
-				case "date":
-					d, err := time.ParseInLocation(RFC3339FullDate, data, DefaultTimeLocation)
-					if err != nil {
-						return nil, err
-					}
-					return Date(d), nil
-				case "datetime":
-					input := data
-					if len(input) == 0 {
-						return nil, stderrors.New("empty string is an invalid datetime format")
-					}
-					return ParseDateTime(input)
-				case "duration":
-					dur, err := ParseDuration(data)
-					if err != nil {
-						return nil, err
-					}
-					return Duration(dur), nil
-				case "uri":
-					return URI(data), nil
-				case "email":
-					return Email(data), nil
-				case "uuid":
-					return UUID(data), nil
-				case "uuid3":
-					return UUID3(data), nil
-				case "uuid4":
-					return UUID4(data), nil
-				case "uuid5":
-					return UUID5(data), nil
-				case "hostname":
-					return Hostname(data), nil
-				case "ipv4":
-					return IPv4(data), nil
-				case "ipv6":
-					return IPv6(data), nil
-				case "cidr":
-					return CIDR(data), nil
-				case "mac":
-					return MAC(data), nil
-				case "isbn":
-					return ISBN(data), nil
-				case "isbn10":
-					return ISBN10(data), nil
-				case "isbn13":
-					return ISBN13(data), nil
-				case "creditcard":
-					return CreditCard(data), nil
-				case "ssn":
-					return SSN(data), nil
-				case "hexcolor":
-					return HexColor(data), nil
-				case "rgbcolor":
-					return RGBColor(data), nil
-				case "byte":
-					return Base64(data), nil
-				case "password":
-					return Password(data), nil
-				case "ulid":
-					ulid, err := ParseULID(data)
-					if err != nil {
-						return nil, err
-					}
-					return ulid, nil
-				default:
-					return nil, errors.InvalidTypeName(v.Name)
-				}
-			}
-		}
-		return data, nil
-	}
-}
-
-// Add adds a new format, return true if this was a new item instead of a replacement
-func (f *defaultFormats) Add(name string, strfmt Format, validator Validator) bool {
-	f.Lock()
-	defer f.Unlock()
-
-	nme := f.normalizeName(name)
-
-	tpe := reflect.TypeOf(strfmt)
-	if tpe.Kind() == reflect.Ptr {
-		tpe = tpe.Elem()
-	}
-
-	for i := range f.data {
-		v := &f.data[i]
-		if v.Name == nme {
-			v.Type = tpe
-			v.Validator = validator
-			return false
-		}
-	}
-
-	// turns out it's new after all
-	f.data = append(f.data, knownFormat{Name: nme, OrigName: name, Type: tpe, Validator: validator})
-	return true
-}
-
-// GetType gets the type for the specified name
-func (f *defaultFormats) GetType(name string) (reflect.Type, bool) {
-	f.Lock()
-	defer f.Unlock()
-	nme := f.normalizeName(name)
-	for _, v := range f.data {
-		if v.Name == nme {
-			return v.Type, true
-		}
-	}
-	return nil, false
-}
-
-// DelByName removes the format by the specified name, returns true when an item was actually removed
-func (f *defaultFormats) DelByName(name string) bool {
-	f.Lock()
-	defer f.Unlock()
-
-	nme := f.normalizeName(name)
-
-	for i, v := range f.data {
-		if v.Name == nme {
-			f.data[i] = knownFormat{} // release
-			f.data = append(f.data[:i], f.data[i+1:]...)
-			return true
-		}
-	}
-	return false
-}
-
-// DelByFormat removes the specified format, returns true when an item was actually removed
-func (f *defaultFormats) DelByFormat(strfmt Format) bool {
-	f.Lock()
-	defer f.Unlock()
-
-	tpe := reflect.TypeOf(strfmt)
-	if tpe.Kind() == reflect.Ptr {
-		tpe = tpe.Elem()
-	}
-
-	for i, v := range f.data {
-		if v.Type == tpe {
-			f.data[i] = knownFormat{} // release
-			f.data = append(f.data[:i], f.data[i+1:]...)
-			return true
-		}
-	}
-	return false
-}
-
-// ContainsName returns true if this registry contains the specified name
-func (f *defaultFormats) ContainsName(name string) bool {
-	f.Lock()
-	defer f.Unlock()
-	nme := f.normalizeName(name)
-	for _, v := range f.data {
-		if v.Name == nme {
-			return true
-		}
-	}
-	return false
-}
-
-// ContainsFormat returns true if this registry contains the specified format
-func (f *defaultFormats) ContainsFormat(strfmt Format) bool {
-	f.Lock()
-	defer f.Unlock()
-	tpe := reflect.TypeOf(strfmt)
-	if tpe.Kind() == reflect.Ptr {
-		tpe = tpe.Elem()
-	}
-
-	for _, v := range f.data {
-		if v.Type == tpe {
-			return true
-		}
-	}
-	return false
-}
-
-// Validates passed data against format.
-//
-// Note that the format name is automatically normalized, e.g. one may
-// use "date-time" to use the "datetime" format validator.
-func (f *defaultFormats) Validates(name, data string) bool {
-	f.Lock()
-	defer f.Unlock()
-	nme := f.normalizeName(name)
-	for _, v := range f.data {
-		if v.Name == nme {
-			return v.Validator(data)
-		}
-	}
-	return false
-}
-
-// Parse a string into the appropriate format representation type.
-//
-// E.g. parsing a string a "date" will return a Date type.
-func (f *defaultFormats) Parse(name, data string) (interface{}, error) {
-	f.Lock()
-	defer f.Unlock()
-	nme := f.normalizeName(name)
-	for _, v := range f.data {
-		if v.Name == nme {
-			nw := reflect.New(v.Type).Interface()
-			if dec, ok := nw.(encoding.TextUnmarshaler); ok {
-				if err := dec.UnmarshalText([]byte(data)); err != nil {
-					return nil, err
-				}
-				return nw, nil
-			}
-			return nil, errors.InvalidTypeName(name)
-		}
-	}
-	return nil, errors.InvalidTypeName(name)
-}