opt_gen.go

// Code generated by opt-gen. DO NOT EDIT.

package opt

// --- Bool --------------------------------------------------------------------

// Bool is an optional type that wraps a bool.
type Bool struct {
	isSet bool
	val   bool
}

// MakeBool creates a new Bool with the specified value.
func MakeBool(v bool) Bool {
	return Bool{isSet: true, val: v}
}

// IsSet returns a value indicating whether the optional type's value is set.
func (p Bool) IsSet() bool {
	return p.isSet
}

// Set sets the optional type's value.
func (p *Bool) Set(v bool) {
	p.val = v
	p.isSet = true
}

// Get returns the underlying value wrapped by the optional type. If IsSet returns
// false, then Get's return value will be the zero value for the underlying type.
func (p Bool) Get() bool {
	return p.val
}

// --- Byte --------------------------------------------------------------------

// Byte is an optional type that wraps a byte.
type Byte struct {
	isSet bool
	val   byte
}

// MakeByte creates a new Byte with the specified value.
func MakeByte(v byte) Byte {
	return Byte{isSet: true, val: v}
}

// IsSet returns a value indicating whether the optional type's value is set.
func (p Byte) IsSet() bool {
	return p.isSet
}

// Set sets the optional type's value.
func (p *Byte) Set(v byte) {
	p.val = v
	p.isSet = true
}

// Get returns the underlying value wrapped by the optional type. If IsSet returns
// false, then Get's return value will be the zero value for the underlying type.
func (p Byte) Get() byte {
	return p.val
}

// --- Complex64 ---------------------------------------------------------------

// Complex64 is an optional type that wraps a complex64.
type Complex64 struct {
	isSet bool
	val   complex64
}

// MakeComplex64 creates a new Complex64 with the specified value.
func MakeComplex64(v complex64) Complex64 {
	return Complex64{isSet: true, val: v}
}

// IsSet returns a value indicating whether the optional type's value is set.
func (p Complex64) IsSet() bool {
	return p.isSet
}

// Set sets the optional type's value.
func (p *Complex64) Set(v complex64) {
	p.val = v
	p.isSet = true
}

// Get returns the underlying value wrapped by the optional type. If IsSet returns
// false, then Get's return value will be the zero value for the underlying type.
func (p Complex64) Get() complex64 {
	return p.val
}

// --- Complex128 --------------------------------------------------------------

// Complex128 is an optional type that wraps a complex128.
type Complex128 struct {
	isSet bool
	val   complex128
}

// MakeComplex128 creates a new Complex128 with the specified value.
func MakeComplex128(v complex128) Complex128 {
	return Complex128{isSet: true, val: v}
}

// IsSet returns a value indicating whether the optional type's value is set.
func (p Complex128) IsSet() bool {
	return p.isSet
}

// Set sets the optional type's value.
func (p *Complex128) Set(v complex128) {
	p.val = v
	p.isSet = true
}

// Get returns the underlying value wrapped by the optional type. If IsSet returns
// false, then Get's return value will be the zero value for the underlying type.
func (p Complex128) Get() complex128 {
	return p.val
}

// --- Float32 -----------------------------------------------------------------

// Float32 is an optional type that wraps a float32.
type Float32 struct {
	isSet bool
	val   float32
}

// MakeFloat32 creates a new Float32 with the specified value.
func MakeFloat32(v float32) Float32 {
	return Float32{isSet: true, val: v}
}

// IsSet returns a value indicating whether the optional type's value is set.
func (p Float32) IsSet() bool {
	return p.isSet
}

// Set sets the optional type's value.
func (p *Float32) Set(v float32) {
	p.val = v
	p.isSet = true
}

// Get returns the underlying value wrapped by the optional type. If IsSet returns
// false, then Get's return value will be the zero value for the underlying type.
func (p Float32) Get() float32 {
	return p.val
}

// --- Float64 -----------------------------------------------------------------

// Float64 is an optional type that wraps a float64.
type Float64 struct {
	isSet bool
	val   float64
}

// MakeFloat64 creates a new Float64 with the specified value.
func MakeFloat64(v float64) Float64 {
	return Float64{isSet: true, val: v}
}

// IsSet returns a value indicating whether the optional type's value is set.
func (p Float64) IsSet() bool {
	return p.isSet
}

// Set sets the optional type's value.
func (p *Float64) Set(v float64) {
	p.val = v
	p.isSet = true
}

// Get returns the underlying value wrapped by the optional type. If IsSet returns
// false, then Get's return value will be the zero value for the underlying type.
func (p Float64) Get() float64 {
	return p.val
}

// --- Int ---------------------------------------------------------------------

// Int is an optional type that wraps a int.
type Int struct {
	isSet bool
	val   int
}

// MakeInt creates a new Int with the specified value.
func MakeInt(v int) Int {
	return Int{isSet: true, val: v}
}

// IsSet returns a value indicating whether the optional type's value is set.
func (p Int) IsSet() bool {
	return p.isSet
}

// Set sets the optional type's value.
func (p *Int) Set(v int) {
	p.val = v
	p.isSet = true
}

// Get returns the underlying value wrapped by the optional type. If IsSet returns
// false, then Get's return value will be the zero value for the underlying type.
func (p Int) Get() int {
	return p.val
}

// --- Int8 --------------------------------------------------------------------

// Int8 is an optional type that wraps a int8.
type Int8 struct {
	isSet bool
	val   int8
}

// MakeInt8 creates a new Int8 with the specified value.
func MakeInt8(v int8) Int8 {
	return Int8{isSet: true, val: v}
}

// IsSet returns a value indicating whether the optional type's value is set.
func (p Int8) IsSet() bool {
	return p.isSet
}

// Set sets the optional type's value.
func (p *Int8) Set(v int8) {
	p.val = v
	p.isSet = true
}

// Get returns the underlying value wrapped by the optional type. If IsSet returns
// false, then Get's return value will be the zero value for the underlying type.
func (p Int8) Get() int8 {
	return p.val
}

// --- Int16 -------------------------------------------------------------------

// Int16 is an optional type that wraps a int16.
type Int16 struct {
	isSet bool
	val   int16
}

// MakeInt16 creates a new Int16 with the specified value.
func MakeInt16(v int16) Int16 {
	return Int16{isSet: true, val: v}
}

// IsSet returns a value indicating whether the optional type's value is set.
func (p Int16) IsSet() bool {
	return p.isSet
}

// Set sets the optional type's value.
func (p *Int16) Set(v int16) {
	p.val = v
	p.isSet = true
}

// Get returns the underlying value wrapped by the optional type. If IsSet returns
// false, then Get's return value will be the zero value for the underlying type.
func (p Int16) Get() int16 {
	return p.val
}

// --- Int32 -------------------------------------------------------------------

// Int32 is an optional type that wraps a int32.
type Int32 struct {
	isSet bool
	val   int32
}

// MakeInt32 creates a new Int32 with the specified value.
func MakeInt32(v int32) Int32 {
	return Int32{isSet: true, val: v}
}

// IsSet returns a value indicating whether the optional type's value is set.
func (p Int32) IsSet() bool {
	return p.isSet
}

// Set sets the optional type's value.
func (p *Int32) Set(v int32) {
	p.val = v
	p.isSet = true
}

// Get returns the underlying value wrapped by the optional type. If IsSet returns
// false, then Get's return value will be the zero value for the underlying type.
func (p Int32) Get() int32 {
	return p.val
}

// --- Int64 -------------------------------------------------------------------

// Int64 is an optional type that wraps a int64.
type Int64 struct {
	isSet bool
	val   int64
}

// MakeInt64 creates a new Int64 with the specified value.
func MakeInt64(v int64) Int64 {
	return Int64{isSet: true, val: v}
}

// IsSet returns a value indicating whether the optional type's value is set.
func (p Int64) IsSet() bool {
	return p.isSet
}

// Set sets the optional type's value.
func (p *Int64) Set(v int64) {
	p.val = v
	p.isSet = true
}

// Get returns the underlying value wrapped by the optional type. If IsSet returns
// false, then Get's return value will be the zero value for the underlying type.
func (p Int64) Get() int64 {
	return p.val
}

// --- Rune --------------------------------------------------------------------

// Rune is an optional type that wraps a rune.
type Rune struct {
	isSet bool
	val   rune
}

// MakeRune creates a new Rune with the specified value.
func MakeRune(v rune) Rune {
	return Rune{isSet: true, val: v}
}

// IsSet returns a value indicating whether the optional type's value is set.
func (p Rune) IsSet() bool {
	return p.isSet
}

// Set sets the optional type's value.
func (p *Rune) Set(v rune) {
	p.val = v
	p.isSet = true
}

// Get returns the underlying value wrapped by the optional type. If IsSet returns
// false, then Get's return value will be the zero value for the underlying type.
func (p Rune) Get() rune {
	return p.val
}

// --- String ------------------------------------------------------------------

// String is an optional type that wraps a string.
type String struct {
	isSet bool
	val   string
}

// MakeString creates a new String with the specified value.
func MakeString(v string) String {
	return String{isSet: true, val: v}
}

// IsSet returns a value indicating whether the optional type's value is set.
func (p String) IsSet() bool {
	return p.isSet
}

// Set sets the optional type's value.
func (p *String) Set(v string) {
	p.val = v
	p.isSet = true
}

// Get returns the underlying value wrapped by the optional type. If IsSet returns
// false, then Get's return value will be the zero value for the underlying type.
func (p String) Get() string {
	return p.val
}

// --- Uint --------------------------------------------------------------------

// Uint is an optional type that wraps a uint.
type Uint struct {
	isSet bool
	val   uint
}

// MakeUint creates a new Uint with the specified value.
func MakeUint(v uint) Uint {
	return Uint{isSet: true, val: v}
}

// IsSet returns a value indicating whether the optional type's value is set.
func (p Uint) IsSet() bool {
	return p.isSet
}

// Set sets the optional type's value.
func (p *Uint) Set(v uint) {
	p.val = v
	p.isSet = true
}

// Get returns the underlying value wrapped by the optional type. If IsSet returns
// false, then Get's return value will be the zero value for the underlying type.
func (p Uint) Get() uint {
	return p.val
}

// --- Uint8 -------------------------------------------------------------------

// Uint8 is an optional type that wraps a uint8.
type Uint8 struct {
	isSet bool
	val   uint8
}

// MakeUint8 creates a new Uint8 with the specified value.
func MakeUint8(v uint8) Uint8 {
	return Uint8{isSet: true, val: v}
}

// IsSet returns a value indicating whether the optional type's value is set.
func (p Uint8) IsSet() bool {
	return p.isSet
}

// Set sets the optional type's value.
func (p *Uint8) Set(v uint8) {
	p.val = v
	p.isSet = true
}

// Get returns the underlying value wrapped by the optional type. If IsSet returns
// false, then Get's return value will be the zero value for the underlying type.
func (p Uint8) Get() uint8 {
	return p.val
}

// --- Uint16 ------------------------------------------------------------------

// Uint16 is an optional type that wraps a uint16.
type Uint16 struct {
	isSet bool
	val   uint16
}

// MakeUint16 creates a new Uint16 with the specified value.
func MakeUint16(v uint16) Uint16 {
	return Uint16{isSet: true, val: v}
}

// IsSet returns a value indicating whether the optional type's value is set.
func (p Uint16) IsSet() bool {
	return p.isSet
}

// Set sets the optional type's value.
func (p *Uint16) Set(v uint16) {
	p.val = v
	p.isSet = true
}

// Get returns the underlying value wrapped by the optional type. If IsSet returns
// false, then Get's return value will be the zero value for the underlying type.
func (p Uint16) Get() uint16 {
	return p.val
}

// --- Uint32 ------------------------------------------------------------------

// Uint32 is an optional type that wraps a uint32.
type Uint32 struct {
	isSet bool
	val   uint32
}

// MakeUint32 creates a new Uint32 with the specified value.
func MakeUint32(v uint32) Uint32 {
	return Uint32{isSet: true, val: v}
}

// IsSet returns a value indicating whether the optional type's value is set.
func (p Uint32) IsSet() bool {
	return p.isSet
}

// Set sets the optional type's value.
func (p *Uint32) Set(v uint32) {
	p.val = v
	p.isSet = true
}

// Get returns the underlying value wrapped by the optional type. If IsSet returns
// false, then Get's return value will be the zero value for the underlying type.
func (p Uint32) Get() uint32 {
	return p.val
}

// --- Uint64 ------------------------------------------------------------------

// Uint64 is an optional type that wraps a uint64.
type Uint64 struct {
	isSet bool
	val   uint64
}

// MakeUint64 creates a new Uint64 with the specified value.
func MakeUint64(v uint64) Uint64 {
	return Uint64{isSet: true, val: v}
}

// IsSet returns a value indicating whether the optional type's value is set.
func (p Uint64) IsSet() bool {
	return p.isSet
}

// Set sets the optional type's value.
func (p *Uint64) Set(v uint64) {
	p.val = v
	p.isSet = true
}

// Get returns the underlying value wrapped by the optional type. If IsSet returns
// false, then Get's return value will be the zero value for the underlying type.
func (p Uint64) Get() uint64 {
	return p.val
}