Add missing dependency to the vendor tree

vendor/github.com/antihax/optional/LICENSE

@@ -0,0 +1,8 @@
+The MIT License (MIT)
+Copyright (c) 2016 Adam Hintz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

vendor/github.com/antihax/optional/bool.go

@@ -0,0 +1,36 @@
+package optional
+
+type Bool struct {
+	isSet bool
+	value bool
+}
+
+func NewBool(value bool) Bool {
+	return Bool{
+		true,
+		value,
+	}
+}
+
+// EmptyBool returns a new Bool that does not have a value set.
+func EmptyBool() Bool {
+	return Bool{
+		false,
+		false,
+	}
+}
+
+func (b Bool) IsSet() bool {
+	return b.isSet
+}
+
+func (b Bool) Value() bool {
+	return b.value
+}
+
+func (b Bool) Default(defaultValue bool) bool {
+	if b.isSet {
+		return b.value
+	}
+	return defaultValue
+}

vendor/github.com/antihax/optional/byte.go

@@ -0,0 +1,36 @@
+package optional
+
+type Byte struct {
+	isSet bool
+	value byte
+}
+
+func NewByte(value byte) Byte {
+	return Byte{
+		true,
+		value,
+	}
+}
+
+// EmptyByte returns a new Byte that does not have a value set.
+func EmptyByte() Byte {
+	return Byte{
+		false,
+		0,
+	}
+}
+
+func (b Byte) IsSet() bool {
+	return b.isSet
+}
+
+func (b Byte) Value() byte {
+	return b.value
+}
+
+func (b Byte) Default(defaultValue byte) byte {
+	if b.isSet {
+		return b.value
+	}
+	return defaultValue
+}

vendor/github.com/antihax/optional/complex128.go

@@ -0,0 +1,36 @@
+package optional
+
+type Complex128 struct {
+	isSet bool
+	value complex128
+}
+
+func NewComplex128(value complex128) Complex128 {
+	return Complex128{
+		true,
+		value,
+	}
+}
+
+// EmptyComplex128 returns a new Complex128 that does not have a value set.
+func EmptyComplex128() Complex128 {
+	return Complex128{
+		false,
+		0,
+	}
+}
+
+func (i Complex128) IsSet() bool {
+	return i.isSet
+}
+
+func (i Complex128) Value() complex128 {
+	return i.value
+}
+
+func (i Complex128) Default(defaultValue complex128) complex128 {
+	if i.isSet {
+		return i.value
+	}
+	return defaultValue
+}

vendor/github.com/antihax/optional/complex64.go

@@ -0,0 +1,36 @@
+package optional
+
+type Complex64 struct {
+	isSet bool
+	value complex64
+}
+
+func NewComplex64(value complex64) Complex64 {
+	return Complex64{
+		true,
+		value,
+	}
+}
+
+// EmptyComplex64 returns a new Complex64 that does not have a value set.
+func EmptyComplex64() Complex64 {
+	return Complex64{
+		false,
+		0,
+	}
+}
+
+func (i Complex64) IsSet() bool {
+	return i.isSet
+}
+
+func (i Complex64) Value() complex64 {
+	return i.value
+}
+
+func (i Complex64) Default(defaultValue complex64) complex64 {
+	if i.isSet {
+		return i.value
+	}
+	return defaultValue
+}

vendor/github.com/antihax/optional/float32.go

@@ -0,0 +1,36 @@
+package optional
+
+type Float32 struct {
+	isSet bool
+	value float32
+}
+
+func NewFloat32(value float32) Float32 {
+	return Float32{
+		true,
+		value,
+	}
+}
+
+// EmptyFloat32 returns a new Float32 that does not have a value set.
+func EmptyFloat32() Float32 {
+	return Float32{
+		false,
+		0,
+	}
+}
+
+func (i Float32) IsSet() bool {
+	return i.isSet
+}
+
+func (i Float32) Value() float32 {
+	return i.value
+}
+
+func (i Float32) Default(defaultValue float32) float32 {
+	if i.isSet {
+		return i.value
+	}
+	return defaultValue
+}

vendor/github.com/antihax/optional/float64.go

@@ -0,0 +1,36 @@
+package optional
+
+type Float64 struct {
+	isSet bool
+	value float64
+}
+
+func NewFloat64(value float64) Float64 {
+	return Float64{
+		true,
+		value,
+	}
+}
+
+// EmptyFloat64 returns a new Float64 that does not have a value set.
+func EmptyFloat64() Float64 {
+	return Float64{
+		false,
+		0,
+	}
+}
+
+func (i Float64) IsSet() bool {
+	return i.isSet
+}
+
+func (i Float64) Value() float64 {
+	return i.value
+}
+
+func (i Float64) Default(defaultValue float64) float64 {
+	if i.isSet {
+		return i.value
+	}
+	return defaultValue
+}

vendor/github.com/antihax/optional/int.go

@@ -0,0 +1,36 @@
+package optional
+
+type Int struct {
+	isSet bool
+	value int
+}
+
+func NewInt(value int) Int {
+	return Int{
+		true,
+		value,
+	}
+}
+
+// EmptyInt returns a new Int that does not have a value set.
+func EmptyInt() Int {
+	return Int{
+		false,
+		0,
+	}
+}
+
+func (i Int) IsSet() bool {
+	return i.isSet
+}
+
+func (i Int) Value() int {
+	return i.value
+}
+
+func (i Int) Default(defaultValue int) int {
+	if i.isSet {
+		return i.value
+	}
+	return defaultValue
+}

vendor/github.com/antihax/optional/int16.go

@@ -0,0 +1,36 @@
+package optional
+
+type Int16 struct {
+	isSet bool
+	value int16
+}
+
+func NewInt16(value int16) Int16 {
+	return Int16{
+		true,
+		value,
+	}
+}
+
+// EmptyInt16 returns a new Int16 that does not have a value set.
+func EmptyInt16() Int16 {
+	return Int16{
+		false,
+		0,
+	}
+}
+
+func (i Int16) IsSet() bool {
+	return i.isSet
+}
+
+func (i Int16) Value() int16 {
+	return i.value
+}
+
+func (i Int16) Default(defaultValue int16) int16 {
+	if i.isSet {
+		return i.value
+	}
+	return defaultValue
+}

vendor/github.com/antihax/optional/int32.go

@@ -0,0 +1,36 @@
+package optional
+
+type Int32 struct {
+	isSet bool
+	value int32
+}
+
+func NewInt32(value int32) Int32 {
+	return Int32{
+		true,
+		value,
+	}
+}
+
+// EmptyInt32 returns a new Int32 that does not have a value set.
+func EmptyInt32() Int32 {
+	return Int32{
+		false,
+		0,
+	}
+}
+
+func (i Int32) IsSet() bool {
+	return i.isSet
+}
+
+func (i Int32) Value() int32 {
+	return i.value
+}
+
+func (i Int32) Default(defaultValue int32) int32 {
+	if i.isSet {
+		return i.value
+	}
+	return defaultValue
+}

vendor/github.com/antihax/optional/int64.go

@@ -0,0 +1,36 @@
+package optional
+
+type Int64 struct {
+	isSet bool
+	value int64
+}
+
+func NewInt64(value int64) Int64 {
+	return Int64{
+		true,
+		value,
+	}
+}
+
+// EmptyInt64 returns a new Int64 that does not have a value set.
+func EmptyInt64() Int64 {
+	return Int64{
+		false,
+		0,
+	}
+}
+
+func (i Int64) IsSet() bool {
+	return i.isSet
+}
+
+func (i Int64) Value() int64 {
+	return i.value
+}
+
+func (i Int64) Default(defaultValue int64) int64 {
+	if i.isSet {
+		return i.value
+	}
+	return defaultValue
+}

vendor/github.com/antihax/optional/int8.go

@@ -0,0 +1,36 @@
+package optional
+
+type Int8 struct {
+	isSet bool
+	value int8
+}
+
+func NewInt8(value int8) Int8 {
+	return Int8{
+		true,
+		value,
+	}
+}
+
+// EmptyInt8 returns a new Int8 that does not have a value set.
+func EmptyInt8() Int8 {
+	return Int8{
+		false,
+		0,
+	}
+}
+
+func (i Int8) IsSet() bool {
+	return i.isSet
+}
+
+func (i Int8) Value() int8 {
+	return i.value
+}
+
+func (i Int8) Default(defaultValue int8) int8 {
+	if i.isSet {
+		return i.value
+	}
+	return defaultValue
+}

vendor/github.com/antihax/optional/interface.go

@@ -0,0 +1,37 @@
+package optional
+
+// Optional represents a generic optional type, stored as an interface{}.
+type Interface struct {
+	isSet bool
+	value interface{}
+}
+
+func NewInterface(value interface{}) Interface {
+	return Interface{
+		true,
+		value,
+	}
+}
+
+// EmptyInterface returns a new Interface that does not have a value set.
+func EmptyInterface() Interface {
+	return Interface{
+		false,
+		nil,
+	}
+}
+
+func (b Interface) IsSet() bool {
+	return b.isSet
+}
+
+func (b Interface) Value() interface{} {
+	return b.value
+}
+
+func (b Interface) Default(defaultValue interface{}) interface{} {
+	if b.isSet {
+		return b.value
+	}
+	return defaultValue
+}

vendor/github.com/antihax/optional/rune.go

@@ -0,0 +1,36 @@
+package optional
+
+type Rune struct {
+	isSet bool
+	value rune
+}
+
+func NewRune(value rune) Rune {
+	return Rune{
+		true,
+		value,
+	}
+}
+
+// EmptyRune returns a new Rune that does not have a value set.
+func EmptyRune() Rune {
+	return Rune{
+		false,
+		0,
+	}
+}
+
+func (b Rune) IsSet() bool {
+	return b.isSet
+}
+
+func (b Rune) Value() rune {
+	return b.value
+}
+
+func (b Rune) Default(defaultValue rune) rune {
+	if b.isSet {
+		return b.value
+	}
+	return defaultValue
+}

vendor/github.com/antihax/optional/string.go

@@ -0,0 +1,36 @@
+package optional
+
+type String struct {
+	isSet bool
+	value string
+}
+
+func NewString(value string) String {
+	return String{
+		true,
+		value,
+	}
+}
+
+// EmptyString returns a new String that does not have a value set.
+func EmptyString() String {
+	return String{
+		false,
+		"",
+	}
+}
+
+func (b String) IsSet() bool {
+	return b.isSet
+}
+
+func (b String) Value() string {
+	return b.value
+}
+
+func (b String) Default(defaultValue string) string {
+	if b.isSet {
+		return b.value
+	}
+	return defaultValue
+}

vendor/github.com/antihax/optional/time.go

@@ -0,0 +1,38 @@
+package optional
+
+import "time"
+
+type Time struct {
+	isSet bool
+	value time.Time
+}
+
+func NewTime(value time.Time) Time {
+	return Time{
+		true,
+		value,
+	}
+}
+
+// EmptyTime returns a new Time that does not have a value set.
+func EmptyTime() Time {
+	return Time{
+		false,
+		time.Time{},
+	}
+}
+
+func (b Time) IsSet() bool {
+	return b.isSet
+}
+
+func (b Time) Value() time.Time {
+	return b.value
+}
+
+func (b Time) Default(defaultValue time.Time) time.Time {
+	if b.isSet {
+		return b.value
+	}
+	return defaultValue
+}

vendor/github.com/antihax/optional/uint.go

@@ -0,0 +1,36 @@
+package optional
+
+type Uint struct {
+	isSet bool
+	value uint
+}
+
+func NewUint(value uint) Uint {
+	return Uint{
+		true,
+		value,
+	}
+}
+
+// EmptyUint returns a new Uint that does not have a value set.
+func EmptyUint() Uint {
+	return Uint{
+		false,
+		0,
+	}
+}
+
+func (i Uint) IsSet() bool {
+	return i.isSet
+}
+
+func (i Uint) Value() uint {
+	return i.value
+}
+
+func (i Uint) Default(defaultValue uint) uint {
+	if i.isSet {
+		return i.value
+	}
+	return defaultValue
+}

vendor/github.com/antihax/optional/uint16.go

@@ -0,0 +1,36 @@
+package optional
+
+type Uint16 struct {
+	isSet bool
+	value uint16
+}
+
+func NewUint16(value uint16) Uint16 {
+	return Uint16{
+		true,
+		value,
+	}
+}
+
+// EmptyUint16 returns a new Uint16 that does not have a value set.
+func EmptyUint16() Uint16 {
+	return Uint16{
+		false,
+		0,
+	}
+}
+
+func (i Uint16) IsSet() bool {
+	return i.isSet
+}
+
+func (i Uint16) Value() uint16 {
+	return i.value
+}
+
+func (i Uint16) Default(defaultValue uint16) uint16 {
+	if i.isSet {
+		return i.value
+	}
+	return defaultValue
+}

vendor/github.com/antihax/optional/uint32.go

@@ -0,0 +1,36 @@
+package optional
+
+type Uint32 struct {
+	isSet bool
+	value uint32
+}
+
+func NewUint32(value uint32) Uint32 {
+	return Uint32{
+		true,
+		value,
+	}
+}
+
+// EmptyUint32 returns a new Uint32 that does not have a value set.
+func EmptyUint32() Uint32 {
+	return Uint32{
+		false,
+		0,
+	}
+}
+
+func (i Uint32) IsSet() bool {
+	return i.isSet
+}
+
+func (i Uint32) Value() uint32 {
+	return i.value
+}
+
+func (i Uint32) Default(defaultValue uint32) uint32 {
+	if i.isSet {
+		return i.value
+	}
+	return defaultValue
+}

vendor/github.com/antihax/optional/uint64.go

@@ -0,0 +1,36 @@
+package optional
+
+type Uint64 struct {
+	isSet bool
+	value uint64
+}
+
+func NewUint64(value uint64) Uint64 {
+	return Uint64{
+		true,
+		value,
+	}
+}
+
+// EmptyUint64 returns a new Uint64 that does not have a value set.
+func EmptyUint64() Uint64 {
+	return Uint64{
+		false,
+		0,
+	}
+}
+
+func (i Uint64) IsSet() bool {
+	return i.isSet
+}
+
+func (i Uint64) Value() uint64 {
+	return i.value
+}
+
+func (i Uint64) Default(defaultValue uint64) uint64 {
+	if i.isSet {
+		return i.value
+	}
+	return defaultValue
+}

vendor/github.com/antihax/optional/uint8.go

@@ -0,0 +1,36 @@
+package optional
+
+type Uint8 struct {
+	isSet bool
+	value uint8
+}
+
+func NewUint8(value uint8) Uint8 {
+	return Uint8{
+		true,
+		value,
+	}
+}
+
+// EmptyUint8 returns a new Uint8 that does not have a value set.
+func EmptyUint8() Uint8 {
+	return Uint8{
+		false,
+		0,
+	}
+}
+
+func (i Uint8) IsSet() bool {
+	return i.isSet
+}
+
+func (i Uint8) Value() uint8 {
+	return i.value
+}
+
+func (i Uint8) Default(defaultValue uint8) uint8 {
+	if i.isSet {
+		return i.value
+	}
+	return defaultValue
+}

vendor/github.com/antihax/optional/uintptr.go

@@ -0,0 +1,36 @@
+package optional
+
+type Uintptr struct {
+	isSet bool
+	value uintptr
+}
+
+func NewUintptr(value uintptr) Uintptr {
+	return Uintptr{
+		true,
+		value,
+	}
+}
+
+// EmptyUintptr returns a new Uintptr that does not have a value set.
+func EmptyUintptr() Uintptr {
+	return Uintptr{
+		false,
+		0,
+	}
+}
+
+func (i Uintptr) IsSet() bool {
+	return i.isSet
+}
+
+func (i Uintptr) Value() uintptr {
+	return i.value
+}
+
+func (i Uintptr) Default(defaultValue uintptr) uintptr {
+	if i.isSet {
+		return i.value
+	}
+	return defaultValue
+}