maps

package
v0.0.0-...-cec8117 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jan 11, 2024 License: Apache-2.0 Imports: 2 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type ConMapBoolBool 

type ConMapBoolBool struct {
	// M is the underlying map[Bool]Bool.
	M map[bool]bool
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapBoolBool is a concurrent safe wrapper around a map[Bool]Bool.

func NewConMapBoolBool 

func NewConMapBoolBool() *ConMapBoolBool

NewConMapBoolBool creates a new concurrent safe map storing bool values, for bool keys.

func ToConMapBoolBool 

func ToConMapBoolBool(data map[bool]bool) *ConMapBoolBool

ToConMapBoolBool creates a new ConMapBoolBool prepopulated with the data from the specified map[Bool]Bool.

func (*ConMapBoolBool) Delete 

func (cm *ConMapBoolBool) Delete(k bool) (bool, bool)

Delete removes the specified bool key, returning its bool value and a bool indicating whether the delete occurred or not.

func (*ConMapBoolBool) Get 

func (cm *ConMapBoolBool) Get(k bool) bool

Get gets the bool value for the given bool key.

func (*ConMapBoolBool) GetOK 

func (cm *ConMapBoolBool) GetOK(k bool) (bool, bool)

GetOK gets the bool value for the given bool key, and a bool indicating whether the key was present or not.

func (*ConMapBoolBool) Len 

func (cm *ConMapBoolBool) Len() int

Get gets the bool value for the given bool key.

func (*ConMapBoolBool) Set 

func (cm *ConMapBoolBool) Set(k bool, v bool)

Set sets the bool value for the specified bool key.

type ConMapBoolByte 

type ConMapBoolByte struct {
	// M is the underlying map[Bool]Byte.
	M map[bool]byte
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapBoolByte is a concurrent safe wrapper around a map[Bool]Byte.

func NewConMapBoolByte 

func NewConMapBoolByte() *ConMapBoolByte

NewConMapBoolByte creates a new concurrent safe map storing byte values, for bool keys.

func ToConMapBoolByte 

func ToConMapBoolByte(data map[bool]byte) *ConMapBoolByte

ToConMapBoolByte creates a new ConMapBoolByte prepopulated with the data from the specified map[Bool]Byte.

func (*ConMapBoolByte) Delete 

func (cm *ConMapBoolByte) Delete(k bool) (byte, bool)

Delete removes the specified bool key, returning its byte value and a bool indicating whether the delete occurred or not.

func (*ConMapBoolByte) Get 

func (cm *ConMapBoolByte) Get(k bool) byte

Get gets the byte value for the given bool key.

func (*ConMapBoolByte) GetOK 

func (cm *ConMapBoolByte) GetOK(k bool) (byte, bool)

GetOK gets the byte value for the given bool key, and a bool indicating whether the key was present or not.

func (*ConMapBoolByte) Len 

func (cm *ConMapBoolByte) Len() int

Get gets the byte value for the given bool key.

func (*ConMapBoolByte) Set 

func (cm *ConMapBoolByte) Set(k bool, v byte)

Set sets the byte value for the specified bool key.

type ConMapBoolComplex128 

type ConMapBoolComplex128 struct {
	// M is the underlying map[Bool]Complex128.
	M map[bool]complex128
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapBoolComplex128 is a concurrent safe wrapper around a map[Bool]Complex128.

func NewConMapBoolComplex128 

func NewConMapBoolComplex128() *ConMapBoolComplex128

NewConMapBoolComplex128 creates a new concurrent safe map storing complex128 values, for bool keys.

func ToConMapBoolComplex128 

func ToConMapBoolComplex128(data map[bool]complex128) *ConMapBoolComplex128

ToConMapBoolComplex128 creates a new ConMapBoolComplex128 prepopulated with the data from the specified map[Bool]Complex128.

func (*ConMapBoolComplex128) Delete 

func (cm *ConMapBoolComplex128) Delete(k bool) (complex128, bool)

Delete removes the specified bool key, returning its complex128 value and a bool indicating whether the delete occurred or not.

func (*ConMapBoolComplex128) Get 

func (cm *ConMapBoolComplex128) Get(k bool) complex128

Get gets the complex128 value for the given bool key.

func (*ConMapBoolComplex128) GetOK 

func (cm *ConMapBoolComplex128) GetOK(k bool) (complex128, bool)

GetOK gets the complex128 value for the given bool key, and a bool indicating whether the key was present or not.

func (*ConMapBoolComplex128) Len 

func (cm *ConMapBoolComplex128) Len() int

Get gets the complex128 value for the given bool key.

func (*ConMapBoolComplex128) Set 

func (cm *ConMapBoolComplex128) Set(k bool, v complex128)

Set sets the complex128 value for the specified bool key.

type ConMapBoolComplex64 

type ConMapBoolComplex64 struct {
	// M is the underlying map[Bool]Complex64.
	M map[bool]complex64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapBoolComplex64 is a concurrent safe wrapper around a map[Bool]Complex64.

func NewConMapBoolComplex64 

func NewConMapBoolComplex64() *ConMapBoolComplex64

NewConMapBoolComplex64 creates a new concurrent safe map storing complex64 values, for bool keys.

func ToConMapBoolComplex64 

func ToConMapBoolComplex64(data map[bool]complex64) *ConMapBoolComplex64

ToConMapBoolComplex64 creates a new ConMapBoolComplex64 prepopulated with the data from the specified map[Bool]Complex64.

func (*ConMapBoolComplex64) Delete 

func (cm *ConMapBoolComplex64) Delete(k bool) (complex64, bool)

Delete removes the specified bool key, returning its complex64 value and a bool indicating whether the delete occurred or not.

func (*ConMapBoolComplex64) Get 

func (cm *ConMapBoolComplex64) Get(k bool) complex64

Get gets the complex64 value for the given bool key.

func (*ConMapBoolComplex64) GetOK 

func (cm *ConMapBoolComplex64) GetOK(k bool) (complex64, bool)

GetOK gets the complex64 value for the given bool key, and a bool indicating whether the key was present or not.

func (*ConMapBoolComplex64) Len 

func (cm *ConMapBoolComplex64) Len() int

Get gets the complex64 value for the given bool key.

func (*ConMapBoolComplex64) Set 

func (cm *ConMapBoolComplex64) Set(k bool, v complex64)

Set sets the complex64 value for the specified bool key.

type ConMapBoolError 

type ConMapBoolError struct {
	// M is the underlying map[Bool]Error.
	M map[bool]error
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapBoolError is a concurrent safe wrapper around a map[Bool]Error.

func NewConMapBoolError 

func NewConMapBoolError() *ConMapBoolError

NewConMapBoolError creates a new concurrent safe map storing error values, for bool keys.

func ToConMapBoolError 

func ToConMapBoolError(data map[bool]error) *ConMapBoolError

ToConMapBoolError creates a new ConMapBoolError prepopulated with the data from the specified map[Bool]Error.

func (*ConMapBoolError) Delete 

func (cm *ConMapBoolError) Delete(k bool) (error, bool)

Delete removes the specified bool key, returning its error value and a bool indicating whether the delete occurred or not.

func (*ConMapBoolError) Get 

func (cm *ConMapBoolError) Get(k bool) error

Get gets the error value for the given bool key.

func (*ConMapBoolError) GetOK 

func (cm *ConMapBoolError) GetOK(k bool) (error, bool)

GetOK gets the error value for the given bool key, and a bool indicating whether the key was present or not.

func (*ConMapBoolError) Len 

func (cm *ConMapBoolError) Len() int

Get gets the error value for the given bool key.

func (*ConMapBoolError) Set 

func (cm *ConMapBoolError) Set(k bool, v error)

Set sets the error value for the specified bool key.

type ConMapBoolFloat32 

type ConMapBoolFloat32 struct {
	// M is the underlying map[Bool]Float32.
	M map[bool]float32
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapBoolFloat32 is a concurrent safe wrapper around a map[Bool]Float32.

func NewConMapBoolFloat32 

func NewConMapBoolFloat32() *ConMapBoolFloat32

NewConMapBoolFloat32 creates a new concurrent safe map storing float32 values, for bool keys.

func ToConMapBoolFloat32 

func ToConMapBoolFloat32(data map[bool]float32) *ConMapBoolFloat32

ToConMapBoolFloat32 creates a new ConMapBoolFloat32 prepopulated with the data from the specified map[Bool]Float32.

func (*ConMapBoolFloat32) Delete 

func (cm *ConMapBoolFloat32) Delete(k bool) (float32, bool)

Delete removes the specified bool key, returning its float32 value and a bool indicating whether the delete occurred or not.

func (*ConMapBoolFloat32) Get 

func (cm *ConMapBoolFloat32) Get(k bool) float32

Get gets the float32 value for the given bool key.

func (*ConMapBoolFloat32) GetOK 

func (cm *ConMapBoolFloat32) GetOK(k bool) (float32, bool)

GetOK gets the float32 value for the given bool key, and a bool indicating whether the key was present or not.

func (*ConMapBoolFloat32) Len 

func (cm *ConMapBoolFloat32) Len() int

Get gets the float32 value for the given bool key.

func (*ConMapBoolFloat32) Set 

func (cm *ConMapBoolFloat32) Set(k bool, v float32)

Set sets the float32 value for the specified bool key.

type ConMapBoolFloat64 

type ConMapBoolFloat64 struct {
	// M is the underlying map[Bool]Float64.
	M map[bool]float64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapBoolFloat64 is a concurrent safe wrapper around a map[Bool]Float64.

func NewConMapBoolFloat64 

func NewConMapBoolFloat64() *ConMapBoolFloat64

NewConMapBoolFloat64 creates a new concurrent safe map storing float64 values, for bool keys.

func ToConMapBoolFloat64 

func ToConMapBoolFloat64(data map[bool]float64) *ConMapBoolFloat64

ToConMapBoolFloat64 creates a new ConMapBoolFloat64 prepopulated with the data from the specified map[Bool]Float64.

func (*ConMapBoolFloat64) Delete 

func (cm *ConMapBoolFloat64) Delete(k bool) (float64, bool)

Delete removes the specified bool key, returning its float64 value and a bool indicating whether the delete occurred or not.

func (*ConMapBoolFloat64) Get 

func (cm *ConMapBoolFloat64) Get(k bool) float64

Get gets the float64 value for the given bool key.

func (*ConMapBoolFloat64) GetOK 

func (cm *ConMapBoolFloat64) GetOK(k bool) (float64, bool)

GetOK gets the float64 value for the given bool key, and a bool indicating whether the key was present or not.

func (*ConMapBoolFloat64) Len 

func (cm *ConMapBoolFloat64) Len() int

Get gets the float64 value for the given bool key.

func (*ConMapBoolFloat64) Set 

func (cm *ConMapBoolFloat64) Set(k bool, v float64)

Set sets the float64 value for the specified bool key.

type ConMapBoolInt 

type ConMapBoolInt struct {
	// M is the underlying map[Bool]Int.
	M map[bool]int
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapBoolInt is a concurrent safe wrapper around a map[Bool]Int.

func NewConMapBoolInt 

func NewConMapBoolInt() *ConMapBoolInt

NewConMapBoolInt creates a new concurrent safe map storing int values, for bool keys.

func ToConMapBoolInt 

func ToConMapBoolInt(data map[bool]int) *ConMapBoolInt

ToConMapBoolInt creates a new ConMapBoolInt prepopulated with the data from the specified map[Bool]Int.

func (*ConMapBoolInt) Delete 

func (cm *ConMapBoolInt) Delete(k bool) (int, bool)

Delete removes the specified bool key, returning its int value and a bool indicating whether the delete occurred or not.

func (*ConMapBoolInt) Get 

func (cm *ConMapBoolInt) Get(k bool) int

Get gets the int value for the given bool key.

func (*ConMapBoolInt) GetOK 

func (cm *ConMapBoolInt) GetOK(k bool) (int, bool)

GetOK gets the int value for the given bool key, and a bool indicating whether the key was present or not.

func (*ConMapBoolInt) Len 

func (cm *ConMapBoolInt) Len() int

Get gets the int value for the given bool key.

func (*ConMapBoolInt) Set 

func (cm *ConMapBoolInt) Set(k bool, v int)

Set sets the int value for the specified bool key.

type ConMapBoolInt16 

type ConMapBoolInt16 struct {
	// M is the underlying map[Bool]Int16.
	M map[bool]int16
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapBoolInt16 is a concurrent safe wrapper around a map[Bool]Int16.

func NewConMapBoolInt16 

func NewConMapBoolInt16() *ConMapBoolInt16

NewConMapBoolInt16 creates a new concurrent safe map storing int16 values, for bool keys.

func ToConMapBoolInt16 

func ToConMapBoolInt16(data map[bool]int16) *ConMapBoolInt16

ToConMapBoolInt16 creates a new ConMapBoolInt16 prepopulated with the data from the specified map[Bool]Int16.

func (*ConMapBoolInt16) Delete 

func (cm *ConMapBoolInt16) Delete(k bool) (int16, bool)

Delete removes the specified bool key, returning its int16 value and a bool indicating whether the delete occurred or not.

func (*ConMapBoolInt16) Get 

func (cm *ConMapBoolInt16) Get(k bool) int16

Get gets the int16 value for the given bool key.

func (*ConMapBoolInt16) GetOK 

func (cm *ConMapBoolInt16) GetOK(k bool) (int16, bool)

GetOK gets the int16 value for the given bool key, and a bool indicating whether the key was present or not.

func (*ConMapBoolInt16) Len 

func (cm *ConMapBoolInt16) Len() int

Get gets the int16 value for the given bool key.

func (*ConMapBoolInt16) Set 

func (cm *ConMapBoolInt16) Set(k bool, v int16)

Set sets the int16 value for the specified bool key.

type ConMapBoolInt32 

type ConMapBoolInt32 struct {
	// M is the underlying map[Bool]Int32.
	M map[bool]int32
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapBoolInt32 is a concurrent safe wrapper around a map[Bool]Int32.

func NewConMapBoolInt32 

func NewConMapBoolInt32() *ConMapBoolInt32

NewConMapBoolInt32 creates a new concurrent safe map storing int32 values, for bool keys.

func ToConMapBoolInt32 

func ToConMapBoolInt32(data map[bool]int32) *ConMapBoolInt32

ToConMapBoolInt32 creates a new ConMapBoolInt32 prepopulated with the data from the specified map[Bool]Int32.

func (*ConMapBoolInt32) Delete 

func (cm *ConMapBoolInt32) Delete(k bool) (int32, bool)

Delete removes the specified bool key, returning its int32 value and a bool indicating whether the delete occurred or not.

func (*ConMapBoolInt32) Get 

func (cm *ConMapBoolInt32) Get(k bool) int32

Get gets the int32 value for the given bool key.

func (*ConMapBoolInt32) GetOK 

func (cm *ConMapBoolInt32) GetOK(k bool) (int32, bool)

GetOK gets the int32 value for the given bool key, and a bool indicating whether the key was present or not.

func (*ConMapBoolInt32) Len 

func (cm *ConMapBoolInt32) Len() int

Get gets the int32 value for the given bool key.

func (*ConMapBoolInt32) Set 

func (cm *ConMapBoolInt32) Set(k bool, v int32)

Set sets the int32 value for the specified bool key.

type ConMapBoolInt64 

type ConMapBoolInt64 struct {
	// M is the underlying map[Bool]Int64.
	M map[bool]int64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapBoolInt64 is a concurrent safe wrapper around a map[Bool]Int64.

func NewConMapBoolInt64 

func NewConMapBoolInt64() *ConMapBoolInt64

NewConMapBoolInt64 creates a new concurrent safe map storing int64 values, for bool keys.

func ToConMapBoolInt64 

func ToConMapBoolInt64(data map[bool]int64) *ConMapBoolInt64

ToConMapBoolInt64 creates a new ConMapBoolInt64 prepopulated with the data from the specified map[Bool]Int64.

func (*ConMapBoolInt64) Delete 

func (cm *ConMapBoolInt64) Delete(k bool) (int64, bool)

Delete removes the specified bool key, returning its int64 value and a bool indicating whether the delete occurred or not.

func (*ConMapBoolInt64) Get 

func (cm *ConMapBoolInt64) Get(k bool) int64

Get gets the int64 value for the given bool key.

func (*ConMapBoolInt64) GetOK 

func (cm *ConMapBoolInt64) GetOK(k bool) (int64, bool)

GetOK gets the int64 value for the given bool key, and a bool indicating whether the key was present or not.

func (*ConMapBoolInt64) Len 

func (cm *ConMapBoolInt64) Len() int

Get gets the int64 value for the given bool key.

func (*ConMapBoolInt64) Set 

func (cm *ConMapBoolInt64) Set(k bool, v int64)

Set sets the int64 value for the specified bool key.

type ConMapBoolInt8 

type ConMapBoolInt8 struct {
	// M is the underlying map[Bool]Int8.
	M map[bool]int8
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapBoolInt8 is a concurrent safe wrapper around a map[Bool]Int8.

func NewConMapBoolInt8 

func NewConMapBoolInt8() *ConMapBoolInt8

NewConMapBoolInt8 creates a new concurrent safe map storing int8 values, for bool keys.

func ToConMapBoolInt8 

func ToConMapBoolInt8(data map[bool]int8) *ConMapBoolInt8

ToConMapBoolInt8 creates a new ConMapBoolInt8 prepopulated with the data from the specified map[Bool]Int8.

func (*ConMapBoolInt8) Delete 

func (cm *ConMapBoolInt8) Delete(k bool) (int8, bool)

Delete removes the specified bool key, returning its int8 value and a bool indicating whether the delete occurred or not.

func (*ConMapBoolInt8) Get 

func (cm *ConMapBoolInt8) Get(k bool) int8

Get gets the int8 value for the given bool key.

func (*ConMapBoolInt8) GetOK 

func (cm *ConMapBoolInt8) GetOK(k bool) (int8, bool)

GetOK gets the int8 value for the given bool key, and a bool indicating whether the key was present or not.

func (*ConMapBoolInt8) Len 

func (cm *ConMapBoolInt8) Len() int

Get gets the int8 value for the given bool key.

func (*ConMapBoolInt8) Set 

func (cm *ConMapBoolInt8) Set(k bool, v int8)

Set sets the int8 value for the specified bool key.

type ConMapBoolRune 

type ConMapBoolRune struct {
	// M is the underlying map[Bool]Rune.
	M map[bool]rune
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapBoolRune is a concurrent safe wrapper around a map[Bool]Rune.

func NewConMapBoolRune 

func NewConMapBoolRune() *ConMapBoolRune

NewConMapBoolRune creates a new concurrent safe map storing rune values, for bool keys.

func ToConMapBoolRune 

func ToConMapBoolRune(data map[bool]rune) *ConMapBoolRune

ToConMapBoolRune creates a new ConMapBoolRune prepopulated with the data from the specified map[Bool]Rune.

func (*ConMapBoolRune) Delete 

func (cm *ConMapBoolRune) Delete(k bool) (rune, bool)

Delete removes the specified bool key, returning its rune value and a bool indicating whether the delete occurred or not.

func (*ConMapBoolRune) Get 

func (cm *ConMapBoolRune) Get(k bool) rune

Get gets the rune value for the given bool key.

func (*ConMapBoolRune) GetOK 

func (cm *ConMapBoolRune) GetOK(k bool) (rune, bool)

GetOK gets the rune value for the given bool key, and a bool indicating whether the key was present or not.

func (*ConMapBoolRune) Len 

func (cm *ConMapBoolRune) Len() int

Get gets the rune value for the given bool key.

func (*ConMapBoolRune) Set 

func (cm *ConMapBoolRune) Set(k bool, v rune)

Set sets the rune value for the specified bool key.

type ConMapBoolString 

type ConMapBoolString struct {
	// M is the underlying map[Bool]String.
	M map[bool]string
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapBoolString is a concurrent safe wrapper around a map[Bool]String.

func NewConMapBoolString 

func NewConMapBoolString() *ConMapBoolString

NewConMapBoolString creates a new concurrent safe map storing string values, for bool keys.

func ToConMapBoolString 

func ToConMapBoolString(data map[bool]string) *ConMapBoolString

ToConMapBoolString creates a new ConMapBoolString prepopulated with the data from the specified map[Bool]String.

func (*ConMapBoolString) Delete 

func (cm *ConMapBoolString) Delete(k bool) (string, bool)

Delete removes the specified bool key, returning its string value and a bool indicating whether the delete occurred or not.

func (*ConMapBoolString) Get 

func (cm *ConMapBoolString) Get(k bool) string

Get gets the string value for the given bool key.

func (*ConMapBoolString) GetOK 

func (cm *ConMapBoolString) GetOK(k bool) (string, bool)

GetOK gets the string value for the given bool key, and a bool indicating whether the key was present or not.

func (*ConMapBoolString) Len 

func (cm *ConMapBoolString) Len() int

Get gets the string value for the given bool key.

func (*ConMapBoolString) Set 

func (cm *ConMapBoolString) Set(k bool, v string)

Set sets the string value for the specified bool key.

type ConMapBoolUint 

type ConMapBoolUint struct {
	// M is the underlying map[Bool]Uint.
	M map[bool]uint
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapBoolUint is a concurrent safe wrapper around a map[Bool]Uint.

func NewConMapBoolUint 

func NewConMapBoolUint() *ConMapBoolUint

NewConMapBoolUint creates a new concurrent safe map storing uint values, for bool keys.

func ToConMapBoolUint 

func ToConMapBoolUint(data map[bool]uint) *ConMapBoolUint

ToConMapBoolUint creates a new ConMapBoolUint prepopulated with the data from the specified map[Bool]Uint.

func (*ConMapBoolUint) Delete 

func (cm *ConMapBoolUint) Delete(k bool) (uint, bool)

Delete removes the specified bool key, returning its uint value and a bool indicating whether the delete occurred or not.

func (*ConMapBoolUint) Get 

func (cm *ConMapBoolUint) Get(k bool) uint

Get gets the uint value for the given bool key.

func (*ConMapBoolUint) GetOK 

func (cm *ConMapBoolUint) GetOK(k bool) (uint, bool)

GetOK gets the uint value for the given bool key, and a bool indicating whether the key was present or not.

func (*ConMapBoolUint) Len 

func (cm *ConMapBoolUint) Len() int

Get gets the uint value for the given bool key.

func (*ConMapBoolUint) Set 

func (cm *ConMapBoolUint) Set(k bool, v uint)

Set sets the uint value for the specified bool key.

type ConMapBoolUint16 

type ConMapBoolUint16 struct {
	// M is the underlying map[Bool]Uint16.
	M map[bool]uint16
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapBoolUint16 is a concurrent safe wrapper around a map[Bool]Uint16.

func NewConMapBoolUint16 

func NewConMapBoolUint16() *ConMapBoolUint16

NewConMapBoolUint16 creates a new concurrent safe map storing uint16 values, for bool keys.

func ToConMapBoolUint16 

func ToConMapBoolUint16(data map[bool]uint16) *ConMapBoolUint16

ToConMapBoolUint16 creates a new ConMapBoolUint16 prepopulated with the data from the specified map[Bool]Uint16.

func (*ConMapBoolUint16) Delete 

func (cm *ConMapBoolUint16) Delete(k bool) (uint16, bool)

Delete removes the specified bool key, returning its uint16 value and a bool indicating whether the delete occurred or not.

func (*ConMapBoolUint16) Get 

func (cm *ConMapBoolUint16) Get(k bool) uint16

Get gets the uint16 value for the given bool key.

func (*ConMapBoolUint16) GetOK 

func (cm *ConMapBoolUint16) GetOK(k bool) (uint16, bool)

GetOK gets the uint16 value for the given bool key, and a bool indicating whether the key was present or not.

func (*ConMapBoolUint16) Len 

func (cm *ConMapBoolUint16) Len() int

Get gets the uint16 value for the given bool key.

func (*ConMapBoolUint16) Set 

func (cm *ConMapBoolUint16) Set(k bool, v uint16)

Set sets the uint16 value for the specified bool key.

type ConMapBoolUint32 

type ConMapBoolUint32 struct {
	// M is the underlying map[Bool]Uint32.
	M map[bool]uint32
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapBoolUint32 is a concurrent safe wrapper around a map[Bool]Uint32.

func NewConMapBoolUint32 

func NewConMapBoolUint32() *ConMapBoolUint32

NewConMapBoolUint32 creates a new concurrent safe map storing uint32 values, for bool keys.

func ToConMapBoolUint32 

func ToConMapBoolUint32(data map[bool]uint32) *ConMapBoolUint32

ToConMapBoolUint32 creates a new ConMapBoolUint32 prepopulated with the data from the specified map[Bool]Uint32.

func (*ConMapBoolUint32) Delete 

func (cm *ConMapBoolUint32) Delete(k bool) (uint32, bool)

Delete removes the specified bool key, returning its uint32 value and a bool indicating whether the delete occurred or not.

func (*ConMapBoolUint32) Get 

func (cm *ConMapBoolUint32) Get(k bool) uint32

Get gets the uint32 value for the given bool key.

func (*ConMapBoolUint32) GetOK 

func (cm *ConMapBoolUint32) GetOK(k bool) (uint32, bool)

GetOK gets the uint32 value for the given bool key, and a bool indicating whether the key was present or not.

func (*ConMapBoolUint32) Len 

func (cm *ConMapBoolUint32) Len() int

Get gets the uint32 value for the given bool key.

func (*ConMapBoolUint32) Set 

func (cm *ConMapBoolUint32) Set(k bool, v uint32)

Set sets the uint32 value for the specified bool key.

type ConMapBoolUint64 

type ConMapBoolUint64 struct {
	// M is the underlying map[Bool]Uint64.
	M map[bool]uint64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapBoolUint64 is a concurrent safe wrapper around a map[Bool]Uint64.

func NewConMapBoolUint64 

func NewConMapBoolUint64() *ConMapBoolUint64

NewConMapBoolUint64 creates a new concurrent safe map storing uint64 values, for bool keys.

func ToConMapBoolUint64 

func ToConMapBoolUint64(data map[bool]uint64) *ConMapBoolUint64

ToConMapBoolUint64 creates a new ConMapBoolUint64 prepopulated with the data from the specified map[Bool]Uint64.

func (*ConMapBoolUint64) Delete 

func (cm *ConMapBoolUint64) Delete(k bool) (uint64, bool)

Delete removes the specified bool key, returning its uint64 value and a bool indicating whether the delete occurred or not.

func (*ConMapBoolUint64) Get 

func (cm *ConMapBoolUint64) Get(k bool) uint64

Get gets the uint64 value for the given bool key.

func (*ConMapBoolUint64) GetOK 

func (cm *ConMapBoolUint64) GetOK(k bool) (uint64, bool)

GetOK gets the uint64 value for the given bool key, and a bool indicating whether the key was present or not.

func (*ConMapBoolUint64) Len 

func (cm *ConMapBoolUint64) Len() int

Get gets the uint64 value for the given bool key.

func (*ConMapBoolUint64) Set 

func (cm *ConMapBoolUint64) Set(k bool, v uint64)

Set sets the uint64 value for the specified bool key.

type ConMapBoolUint8 

type ConMapBoolUint8 struct {
	// M is the underlying map[Bool]Uint8.
	M map[bool]uint8
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapBoolUint8 is a concurrent safe wrapper around a map[Bool]Uint8.

func NewConMapBoolUint8 

func NewConMapBoolUint8() *ConMapBoolUint8

NewConMapBoolUint8 creates a new concurrent safe map storing uint8 values, for bool keys.

func ToConMapBoolUint8 

func ToConMapBoolUint8(data map[bool]uint8) *ConMapBoolUint8

ToConMapBoolUint8 creates a new ConMapBoolUint8 prepopulated with the data from the specified map[Bool]Uint8.

func (*ConMapBoolUint8) Delete 

func (cm *ConMapBoolUint8) Delete(k bool) (uint8, bool)

Delete removes the specified bool key, returning its uint8 value and a bool indicating whether the delete occurred or not.

func (*ConMapBoolUint8) Get 

func (cm *ConMapBoolUint8) Get(k bool) uint8

Get gets the uint8 value for the given bool key.

func (*ConMapBoolUint8) GetOK 

func (cm *ConMapBoolUint8) GetOK(k bool) (uint8, bool)

GetOK gets the uint8 value for the given bool key, and a bool indicating whether the key was present or not.

func (*ConMapBoolUint8) Len 

func (cm *ConMapBoolUint8) Len() int

Get gets the uint8 value for the given bool key.

func (*ConMapBoolUint8) Set 

func (cm *ConMapBoolUint8) Set(k bool, v uint8)

Set sets the uint8 value for the specified bool key.

type ConMapBoolUintptr 

type ConMapBoolUintptr struct {
	// M is the underlying map[Bool]Uintptr.
	M map[bool]uintptr
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapBoolUintptr is a concurrent safe wrapper around a map[Bool]Uintptr.

func NewConMapBoolUintptr 

func NewConMapBoolUintptr() *ConMapBoolUintptr

NewConMapBoolUintptr creates a new concurrent safe map storing uintptr values, for bool keys.

func ToConMapBoolUintptr 

func ToConMapBoolUintptr(data map[bool]uintptr) *ConMapBoolUintptr

ToConMapBoolUintptr creates a new ConMapBoolUintptr prepopulated with the data from the specified map[Bool]Uintptr.

func (*ConMapBoolUintptr) Delete 

func (cm *ConMapBoolUintptr) Delete(k bool) (uintptr, bool)

Delete removes the specified bool key, returning its uintptr value and a bool indicating whether the delete occurred or not.

func (*ConMapBoolUintptr) Get 

func (cm *ConMapBoolUintptr) Get(k bool) uintptr

Get gets the uintptr value for the given bool key.

func (*ConMapBoolUintptr) GetOK 

func (cm *ConMapBoolUintptr) GetOK(k bool) (uintptr, bool)

GetOK gets the uintptr value for the given bool key, and a bool indicating whether the key was present or not.

func (*ConMapBoolUintptr) Len 

func (cm *ConMapBoolUintptr) Len() int

Get gets the uintptr value for the given bool key.

func (*ConMapBoolUintptr) Set 

func (cm *ConMapBoolUintptr) Set(k bool, v uintptr)

Set sets the uintptr value for the specified bool key.

type ConMapByteBool 

type ConMapByteBool struct {
	// M is the underlying map[Byte]Bool.
	M map[byte]bool
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapByteBool is a concurrent safe wrapper around a map[Byte]Bool.

func NewConMapByteBool 

func NewConMapByteBool() *ConMapByteBool

NewConMapByteBool creates a new concurrent safe map storing bool values, for byte keys.

func ToConMapByteBool 

func ToConMapByteBool(data map[byte]bool) *ConMapByteBool

ToConMapByteBool creates a new ConMapByteBool prepopulated with the data from the specified map[Byte]Bool.

func (*ConMapByteBool) Delete 

func (cm *ConMapByteBool) Delete(k byte) (bool, bool)

Delete removes the specified byte key, returning its bool value and a bool indicating whether the delete occurred or not.

func (*ConMapByteBool) Get 

func (cm *ConMapByteBool) Get(k byte) bool

Get gets the bool value for the given byte key.

func (*ConMapByteBool) GetOK 

func (cm *ConMapByteBool) GetOK(k byte) (bool, bool)

GetOK gets the bool value for the given byte key, and a bool indicating whether the key was present or not.

func (*ConMapByteBool) Len 

func (cm *ConMapByteBool) Len() int

Get gets the bool value for the given byte key.

func (*ConMapByteBool) Set 

func (cm *ConMapByteBool) Set(k byte, v bool)

Set sets the bool value for the specified byte key.

type ConMapByteByte 

type ConMapByteByte struct {
	// M is the underlying map[Byte]Byte.
	M map[byte]byte
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapByteByte is a concurrent safe wrapper around a map[Byte]Byte.

func NewConMapByteByte 

func NewConMapByteByte() *ConMapByteByte

NewConMapByteByte creates a new concurrent safe map storing byte values, for byte keys.

func ToConMapByteByte 

func ToConMapByteByte(data map[byte]byte) *ConMapByteByte

ToConMapByteByte creates a new ConMapByteByte prepopulated with the data from the specified map[Byte]Byte.

func (*ConMapByteByte) Delete 

func (cm *ConMapByteByte) Delete(k byte) (byte, bool)

Delete removes the specified byte key, returning its byte value and a bool indicating whether the delete occurred or not.

func (*ConMapByteByte) Get 

func (cm *ConMapByteByte) Get(k byte) byte

Get gets the byte value for the given byte key.

func (*ConMapByteByte) GetOK 

func (cm *ConMapByteByte) GetOK(k byte) (byte, bool)

GetOK gets the byte value for the given byte key, and a bool indicating whether the key was present or not.

func (*ConMapByteByte) Len 

func (cm *ConMapByteByte) Len() int

Get gets the byte value for the given byte key.

func (*ConMapByteByte) Set 

func (cm *ConMapByteByte) Set(k byte, v byte)

Set sets the byte value for the specified byte key.

type ConMapByteComplex128 

type ConMapByteComplex128 struct {
	// M is the underlying map[Byte]Complex128.
	M map[byte]complex128
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapByteComplex128 is a concurrent safe wrapper around a map[Byte]Complex128.

func NewConMapByteComplex128 

func NewConMapByteComplex128() *ConMapByteComplex128

NewConMapByteComplex128 creates a new concurrent safe map storing complex128 values, for byte keys.

func ToConMapByteComplex128 

func ToConMapByteComplex128(data map[byte]complex128) *ConMapByteComplex128

ToConMapByteComplex128 creates a new ConMapByteComplex128 prepopulated with the data from the specified map[Byte]Complex128.

func (*ConMapByteComplex128) Delete 

func (cm *ConMapByteComplex128) Delete(k byte) (complex128, bool)

Delete removes the specified byte key, returning its complex128 value and a bool indicating whether the delete occurred or not.

func (*ConMapByteComplex128) Get 

func (cm *ConMapByteComplex128) Get(k byte) complex128

Get gets the complex128 value for the given byte key.

func (*ConMapByteComplex128) GetOK 

func (cm *ConMapByteComplex128) GetOK(k byte) (complex128, bool)

GetOK gets the complex128 value for the given byte key, and a bool indicating whether the key was present or not.

func (*ConMapByteComplex128) Len 

func (cm *ConMapByteComplex128) Len() int

Get gets the complex128 value for the given byte key.

func (*ConMapByteComplex128) Set 

func (cm *ConMapByteComplex128) Set(k byte, v complex128)

Set sets the complex128 value for the specified byte key.

type ConMapByteComplex64 

type ConMapByteComplex64 struct {
	// M is the underlying map[Byte]Complex64.
	M map[byte]complex64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapByteComplex64 is a concurrent safe wrapper around a map[Byte]Complex64.

func NewConMapByteComplex64 

func NewConMapByteComplex64() *ConMapByteComplex64

NewConMapByteComplex64 creates a new concurrent safe map storing complex64 values, for byte keys.

func ToConMapByteComplex64 

func ToConMapByteComplex64(data map[byte]complex64) *ConMapByteComplex64

ToConMapByteComplex64 creates a new ConMapByteComplex64 prepopulated with the data from the specified map[Byte]Complex64.

func (*ConMapByteComplex64) Delete 

func (cm *ConMapByteComplex64) Delete(k byte) (complex64, bool)

Delete removes the specified byte key, returning its complex64 value and a bool indicating whether the delete occurred or not.

func (*ConMapByteComplex64) Get 

func (cm *ConMapByteComplex64) Get(k byte) complex64

Get gets the complex64 value for the given byte key.

func (*ConMapByteComplex64) GetOK 

func (cm *ConMapByteComplex64) GetOK(k byte) (complex64, bool)

GetOK gets the complex64 value for the given byte key, and a bool indicating whether the key was present or not.

func (*ConMapByteComplex64) Len 

func (cm *ConMapByteComplex64) Len() int

Get gets the complex64 value for the given byte key.

func (*ConMapByteComplex64) Set 

func (cm *ConMapByteComplex64) Set(k byte, v complex64)

Set sets the complex64 value for the specified byte key.

type ConMapByteError 

type ConMapByteError struct {
	// M is the underlying map[Byte]Error.
	M map[byte]error
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapByteError is a concurrent safe wrapper around a map[Byte]Error.

func NewConMapByteError 

func NewConMapByteError() *ConMapByteError

NewConMapByteError creates a new concurrent safe map storing error values, for byte keys.

func ToConMapByteError 

func ToConMapByteError(data map[byte]error) *ConMapByteError

ToConMapByteError creates a new ConMapByteError prepopulated with the data from the specified map[Byte]Error.

func (*ConMapByteError) Delete 

func (cm *ConMapByteError) Delete(k byte) (error, bool)

Delete removes the specified byte key, returning its error value and a bool indicating whether the delete occurred or not.

func (*ConMapByteError) Get 

func (cm *ConMapByteError) Get(k byte) error

Get gets the error value for the given byte key.

func (*ConMapByteError) GetOK 

func (cm *ConMapByteError) GetOK(k byte) (error, bool)

GetOK gets the error value for the given byte key, and a bool indicating whether the key was present or not.

func (*ConMapByteError) Len 

func (cm *ConMapByteError) Len() int

Get gets the error value for the given byte key.

func (*ConMapByteError) Set 

func (cm *ConMapByteError) Set(k byte, v error)

Set sets the error value for the specified byte key.

type ConMapByteFloat32 

type ConMapByteFloat32 struct {
	// M is the underlying map[Byte]Float32.
	M map[byte]float32
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapByteFloat32 is a concurrent safe wrapper around a map[Byte]Float32.

func NewConMapByteFloat32 

func NewConMapByteFloat32() *ConMapByteFloat32

NewConMapByteFloat32 creates a new concurrent safe map storing float32 values, for byte keys.

func ToConMapByteFloat32 

func ToConMapByteFloat32(data map[byte]float32) *ConMapByteFloat32

ToConMapByteFloat32 creates a new ConMapByteFloat32 prepopulated with the data from the specified map[Byte]Float32.

func (*ConMapByteFloat32) Delete 

func (cm *ConMapByteFloat32) Delete(k byte) (float32, bool)

Delete removes the specified byte key, returning its float32 value and a bool indicating whether the delete occurred or not.

func (*ConMapByteFloat32) Get 

func (cm *ConMapByteFloat32) Get(k byte) float32

Get gets the float32 value for the given byte key.

func (*ConMapByteFloat32) GetOK 

func (cm *ConMapByteFloat32) GetOK(k byte) (float32, bool)

GetOK gets the float32 value for the given byte key, and a bool indicating whether the key was present or not.

func (*ConMapByteFloat32) Len 

func (cm *ConMapByteFloat32) Len() int

Get gets the float32 value for the given byte key.

func (*ConMapByteFloat32) Set 

func (cm *ConMapByteFloat32) Set(k byte, v float32)

Set sets the float32 value for the specified byte key.

type ConMapByteFloat64 

type ConMapByteFloat64 struct {
	// M is the underlying map[Byte]Float64.
	M map[byte]float64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapByteFloat64 is a concurrent safe wrapper around a map[Byte]Float64.

func NewConMapByteFloat64 

func NewConMapByteFloat64() *ConMapByteFloat64

NewConMapByteFloat64 creates a new concurrent safe map storing float64 values, for byte keys.

func ToConMapByteFloat64 

func ToConMapByteFloat64(data map[byte]float64) *ConMapByteFloat64

ToConMapByteFloat64 creates a new ConMapByteFloat64 prepopulated with the data from the specified map[Byte]Float64.

func (*ConMapByteFloat64) Delete 

func (cm *ConMapByteFloat64) Delete(k byte) (float64, bool)

Delete removes the specified byte key, returning its float64 value and a bool indicating whether the delete occurred or not.

func (*ConMapByteFloat64) Get 

func (cm *ConMapByteFloat64) Get(k byte) float64

Get gets the float64 value for the given byte key.

func (*ConMapByteFloat64) GetOK 

func (cm *ConMapByteFloat64) GetOK(k byte) (float64, bool)

GetOK gets the float64 value for the given byte key, and a bool indicating whether the key was present or not.

func (*ConMapByteFloat64) Len 

func (cm *ConMapByteFloat64) Len() int

Get gets the float64 value for the given byte key.

func (*ConMapByteFloat64) Set 

func (cm *ConMapByteFloat64) Set(k byte, v float64)

Set sets the float64 value for the specified byte key.

type ConMapByteInt 

type ConMapByteInt struct {
	// M is the underlying map[Byte]Int.
	M map[byte]int
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapByteInt is a concurrent safe wrapper around a map[Byte]Int.

func NewConMapByteInt 

func NewConMapByteInt() *ConMapByteInt

NewConMapByteInt creates a new concurrent safe map storing int values, for byte keys.

func ToConMapByteInt 

func ToConMapByteInt(data map[byte]int) *ConMapByteInt

ToConMapByteInt creates a new ConMapByteInt prepopulated with the data from the specified map[Byte]Int.

func (*ConMapByteInt) Delete 

func (cm *ConMapByteInt) Delete(k byte) (int, bool)

Delete removes the specified byte key, returning its int value and a bool indicating whether the delete occurred or not.

func (*ConMapByteInt) Get 

func (cm *ConMapByteInt) Get(k byte) int

Get gets the int value for the given byte key.

func (*ConMapByteInt) GetOK 

func (cm *ConMapByteInt) GetOK(k byte) (int, bool)

GetOK gets the int value for the given byte key, and a bool indicating whether the key was present or not.

func (*ConMapByteInt) Len 

func (cm *ConMapByteInt) Len() int

Get gets the int value for the given byte key.

func (*ConMapByteInt) Set 

func (cm *ConMapByteInt) Set(k byte, v int)

Set sets the int value for the specified byte key.

type ConMapByteInt16 

type ConMapByteInt16 struct {
	// M is the underlying map[Byte]Int16.
	M map[byte]int16
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapByteInt16 is a concurrent safe wrapper around a map[Byte]Int16.

func NewConMapByteInt16 

func NewConMapByteInt16() *ConMapByteInt16

NewConMapByteInt16 creates a new concurrent safe map storing int16 values, for byte keys.

func ToConMapByteInt16 

func ToConMapByteInt16(data map[byte]int16) *ConMapByteInt16

ToConMapByteInt16 creates a new ConMapByteInt16 prepopulated with the data from the specified map[Byte]Int16.

func (*ConMapByteInt16) Delete 

func (cm *ConMapByteInt16) Delete(k byte) (int16, bool)

Delete removes the specified byte key, returning its int16 value and a bool indicating whether the delete occurred or not.

func (*ConMapByteInt16) Get 

func (cm *ConMapByteInt16) Get(k byte) int16

Get gets the int16 value for the given byte key.

func (*ConMapByteInt16) GetOK 

func (cm *ConMapByteInt16) GetOK(k byte) (int16, bool)

GetOK gets the int16 value for the given byte key, and a bool indicating whether the key was present or not.

func (*ConMapByteInt16) Len 

func (cm *ConMapByteInt16) Len() int

Get gets the int16 value for the given byte key.

func (*ConMapByteInt16) Set 

func (cm *ConMapByteInt16) Set(k byte, v int16)

Set sets the int16 value for the specified byte key.

type ConMapByteInt32 

type ConMapByteInt32 struct {
	// M is the underlying map[Byte]Int32.
	M map[byte]int32
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapByteInt32 is a concurrent safe wrapper around a map[Byte]Int32.

func NewConMapByteInt32 

func NewConMapByteInt32() *ConMapByteInt32

NewConMapByteInt32 creates a new concurrent safe map storing int32 values, for byte keys.

func ToConMapByteInt32 

func ToConMapByteInt32(data map[byte]int32) *ConMapByteInt32

ToConMapByteInt32 creates a new ConMapByteInt32 prepopulated with the data from the specified map[Byte]Int32.

func (*ConMapByteInt32) Delete 

func (cm *ConMapByteInt32) Delete(k byte) (int32, bool)

Delete removes the specified byte key, returning its int32 value and a bool indicating whether the delete occurred or not.

func (*ConMapByteInt32) Get 

func (cm *ConMapByteInt32) Get(k byte) int32

Get gets the int32 value for the given byte key.

func (*ConMapByteInt32) GetOK 

func (cm *ConMapByteInt32) GetOK(k byte) (int32, bool)

GetOK gets the int32 value for the given byte key, and a bool indicating whether the key was present or not.

func (*ConMapByteInt32) Len 

func (cm *ConMapByteInt32) Len() int

Get gets the int32 value for the given byte key.

func (*ConMapByteInt32) Set 

func (cm *ConMapByteInt32) Set(k byte, v int32)

Set sets the int32 value for the specified byte key.

type ConMapByteInt64 

type ConMapByteInt64 struct {
	// M is the underlying map[Byte]Int64.
	M map[byte]int64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapByteInt64 is a concurrent safe wrapper around a map[Byte]Int64.

func NewConMapByteInt64 

func NewConMapByteInt64() *ConMapByteInt64

NewConMapByteInt64 creates a new concurrent safe map storing int64 values, for byte keys.

func ToConMapByteInt64 

func ToConMapByteInt64(data map[byte]int64) *ConMapByteInt64

ToConMapByteInt64 creates a new ConMapByteInt64 prepopulated with the data from the specified map[Byte]Int64.

func (*ConMapByteInt64) Delete 

func (cm *ConMapByteInt64) Delete(k byte) (int64, bool)

Delete removes the specified byte key, returning its int64 value and a bool indicating whether the delete occurred or not.

func (*ConMapByteInt64) Get 

func (cm *ConMapByteInt64) Get(k byte) int64

Get gets the int64 value for the given byte key.

func (*ConMapByteInt64) GetOK 

func (cm *ConMapByteInt64) GetOK(k byte) (int64, bool)

GetOK gets the int64 value for the given byte key, and a bool indicating whether the key was present or not.

func (*ConMapByteInt64) Len 

func (cm *ConMapByteInt64) Len() int

Get gets the int64 value for the given byte key.

func (*ConMapByteInt64) Set 

func (cm *ConMapByteInt64) Set(k byte, v int64)

Set sets the int64 value for the specified byte key.

type ConMapByteInt8 

type ConMapByteInt8 struct {
	// M is the underlying map[Byte]Int8.
	M map[byte]int8
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapByteInt8 is a concurrent safe wrapper around a map[Byte]Int8.

func NewConMapByteInt8 

func NewConMapByteInt8() *ConMapByteInt8

NewConMapByteInt8 creates a new concurrent safe map storing int8 values, for byte keys.

func ToConMapByteInt8 

func ToConMapByteInt8(data map[byte]int8) *ConMapByteInt8

ToConMapByteInt8 creates a new ConMapByteInt8 prepopulated with the data from the specified map[Byte]Int8.

func (*ConMapByteInt8) Delete 

func (cm *ConMapByteInt8) Delete(k byte) (int8, bool)

Delete removes the specified byte key, returning its int8 value and a bool indicating whether the delete occurred or not.

func (*ConMapByteInt8) Get 

func (cm *ConMapByteInt8) Get(k byte) int8

Get gets the int8 value for the given byte key.

func (*ConMapByteInt8) GetOK 

func (cm *ConMapByteInt8) GetOK(k byte) (int8, bool)

GetOK gets the int8 value for the given byte key, and a bool indicating whether the key was present or not.

func (*ConMapByteInt8) Len 

func (cm *ConMapByteInt8) Len() int

Get gets the int8 value for the given byte key.

func (*ConMapByteInt8) Set 

func (cm *ConMapByteInt8) Set(k byte, v int8)

Set sets the int8 value for the specified byte key.

type ConMapByteRune 

type ConMapByteRune struct {
	// M is the underlying map[Byte]Rune.
	M map[byte]rune
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapByteRune is a concurrent safe wrapper around a map[Byte]Rune.

func NewConMapByteRune 

func NewConMapByteRune() *ConMapByteRune

NewConMapByteRune creates a new concurrent safe map storing rune values, for byte keys.

func ToConMapByteRune 

func ToConMapByteRune(data map[byte]rune) *ConMapByteRune

ToConMapByteRune creates a new ConMapByteRune prepopulated with the data from the specified map[Byte]Rune.

func (*ConMapByteRune) Delete 

func (cm *ConMapByteRune) Delete(k byte) (rune, bool)

Delete removes the specified byte key, returning its rune value and a bool indicating whether the delete occurred or not.

func (*ConMapByteRune) Get 

func (cm *ConMapByteRune) Get(k byte) rune

Get gets the rune value for the given byte key.

func (*ConMapByteRune) GetOK 

func (cm *ConMapByteRune) GetOK(k byte) (rune, bool)

GetOK gets the rune value for the given byte key, and a bool indicating whether the key was present or not.

func (*ConMapByteRune) Len 

func (cm *ConMapByteRune) Len() int

Get gets the rune value for the given byte key.

func (*ConMapByteRune) Set 

func (cm *ConMapByteRune) Set(k byte, v rune)

Set sets the rune value for the specified byte key.

type ConMapByteString 

type ConMapByteString struct {
	// M is the underlying map[Byte]String.
	M map[byte]string
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapByteString is a concurrent safe wrapper around a map[Byte]String.

func NewConMapByteString 

func NewConMapByteString() *ConMapByteString

NewConMapByteString creates a new concurrent safe map storing string values, for byte keys.

func ToConMapByteString 

func ToConMapByteString(data map[byte]string) *ConMapByteString

ToConMapByteString creates a new ConMapByteString prepopulated with the data from the specified map[Byte]String.

func (*ConMapByteString) Delete 

func (cm *ConMapByteString) Delete(k byte) (string, bool)

Delete removes the specified byte key, returning its string value and a bool indicating whether the delete occurred or not.

func (*ConMapByteString) Get 

func (cm *ConMapByteString) Get(k byte) string

Get gets the string value for the given byte key.

func (*ConMapByteString) GetOK 

func (cm *ConMapByteString) GetOK(k byte) (string, bool)

GetOK gets the string value for the given byte key, and a bool indicating whether the key was present or not.

func (*ConMapByteString) Len 

func (cm *ConMapByteString) Len() int

Get gets the string value for the given byte key.

func (*ConMapByteString) Set 

func (cm *ConMapByteString) Set(k byte, v string)

Set sets the string value for the specified byte key.

type ConMapByteUint 

type ConMapByteUint struct {
	// M is the underlying map[Byte]Uint.
	M map[byte]uint
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapByteUint is a concurrent safe wrapper around a map[Byte]Uint.

func NewConMapByteUint 

func NewConMapByteUint() *ConMapByteUint

NewConMapByteUint creates a new concurrent safe map storing uint values, for byte keys.

func ToConMapByteUint 

func ToConMapByteUint(data map[byte]uint) *ConMapByteUint

ToConMapByteUint creates a new ConMapByteUint prepopulated with the data from the specified map[Byte]Uint.

func (*ConMapByteUint) Delete 

func (cm *ConMapByteUint) Delete(k byte) (uint, bool)

Delete removes the specified byte key, returning its uint value and a bool indicating whether the delete occurred or not.

func (*ConMapByteUint) Get 

func (cm *ConMapByteUint) Get(k byte) uint

Get gets the uint value for the given byte key.

func (*ConMapByteUint) GetOK 

func (cm *ConMapByteUint) GetOK(k byte) (uint, bool)

GetOK gets the uint value for the given byte key, and a bool indicating whether the key was present or not.

func (*ConMapByteUint) Len 

func (cm *ConMapByteUint) Len() int

Get gets the uint value for the given byte key.

func (*ConMapByteUint) Set 

func (cm *ConMapByteUint) Set(k byte, v uint)

Set sets the uint value for the specified byte key.

type ConMapByteUint16 

type ConMapByteUint16 struct {
	// M is the underlying map[Byte]Uint16.
	M map[byte]uint16
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapByteUint16 is a concurrent safe wrapper around a map[Byte]Uint16.

func NewConMapByteUint16 

func NewConMapByteUint16() *ConMapByteUint16

NewConMapByteUint16 creates a new concurrent safe map storing uint16 values, for byte keys.

func ToConMapByteUint16 

func ToConMapByteUint16(data map[byte]uint16) *ConMapByteUint16

ToConMapByteUint16 creates a new ConMapByteUint16 prepopulated with the data from the specified map[Byte]Uint16.

func (*ConMapByteUint16) Delete 

func (cm *ConMapByteUint16) Delete(k byte) (uint16, bool)

Delete removes the specified byte key, returning its uint16 value and a bool indicating whether the delete occurred or not.

func (*ConMapByteUint16) Get 

func (cm *ConMapByteUint16) Get(k byte) uint16

Get gets the uint16 value for the given byte key.

func (*ConMapByteUint16) GetOK 

func (cm *ConMapByteUint16) GetOK(k byte) (uint16, bool)

GetOK gets the uint16 value for the given byte key, and a bool indicating whether the key was present or not.

func (*ConMapByteUint16) Len 

func (cm *ConMapByteUint16) Len() int

Get gets the uint16 value for the given byte key.

func (*ConMapByteUint16) Set 

func (cm *ConMapByteUint16) Set(k byte, v uint16)

Set sets the uint16 value for the specified byte key.

type ConMapByteUint32 

type ConMapByteUint32 struct {
	// M is the underlying map[Byte]Uint32.
	M map[byte]uint32
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapByteUint32 is a concurrent safe wrapper around a map[Byte]Uint32.

func NewConMapByteUint32 

func NewConMapByteUint32() *ConMapByteUint32

NewConMapByteUint32 creates a new concurrent safe map storing uint32 values, for byte keys.

func ToConMapByteUint32 

func ToConMapByteUint32(data map[byte]uint32) *ConMapByteUint32

ToConMapByteUint32 creates a new ConMapByteUint32 prepopulated with the data from the specified map[Byte]Uint32.

func (*ConMapByteUint32) Delete 

func (cm *ConMapByteUint32) Delete(k byte) (uint32, bool)

Delete removes the specified byte key, returning its uint32 value and a bool indicating whether the delete occurred or not.

func (*ConMapByteUint32) Get 

func (cm *ConMapByteUint32) Get(k byte) uint32

Get gets the uint32 value for the given byte key.

func (*ConMapByteUint32) GetOK 

func (cm *ConMapByteUint32) GetOK(k byte) (uint32, bool)

GetOK gets the uint32 value for the given byte key, and a bool indicating whether the key was present or not.

func (*ConMapByteUint32) Len 

func (cm *ConMapByteUint32) Len() int

Get gets the uint32 value for the given byte key.

func (*ConMapByteUint32) Set 

func (cm *ConMapByteUint32) Set(k byte, v uint32)

Set sets the uint32 value for the specified byte key.

type ConMapByteUint64 

type ConMapByteUint64 struct {
	// M is the underlying map[Byte]Uint64.
	M map[byte]uint64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapByteUint64 is a concurrent safe wrapper around a map[Byte]Uint64.

func NewConMapByteUint64 

func NewConMapByteUint64() *ConMapByteUint64

NewConMapByteUint64 creates a new concurrent safe map storing uint64 values, for byte keys.

func ToConMapByteUint64 

func ToConMapByteUint64(data map[byte]uint64) *ConMapByteUint64

ToConMapByteUint64 creates a new ConMapByteUint64 prepopulated with the data from the specified map[Byte]Uint64.

func (*ConMapByteUint64) Delete 

func (cm *ConMapByteUint64) Delete(k byte) (uint64, bool)

Delete removes the specified byte key, returning its uint64 value and a bool indicating whether the delete occurred or not.

func (*ConMapByteUint64) Get 

func (cm *ConMapByteUint64) Get(k byte) uint64

Get gets the uint64 value for the given byte key.

func (*ConMapByteUint64) GetOK 

func (cm *ConMapByteUint64) GetOK(k byte) (uint64, bool)

GetOK gets the uint64 value for the given byte key, and a bool indicating whether the key was present or not.

func (*ConMapByteUint64) Len 

func (cm *ConMapByteUint64) Len() int

Get gets the uint64 value for the given byte key.

func (*ConMapByteUint64) Set 

func (cm *ConMapByteUint64) Set(k byte, v uint64)

Set sets the uint64 value for the specified byte key.

type ConMapByteUint8 

type ConMapByteUint8 struct {
	// M is the underlying map[Byte]Uint8.
	M map[byte]uint8
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapByteUint8 is a concurrent safe wrapper around a map[Byte]Uint8.

func NewConMapByteUint8 

func NewConMapByteUint8() *ConMapByteUint8

NewConMapByteUint8 creates a new concurrent safe map storing uint8 values, for byte keys.

func ToConMapByteUint8 

func ToConMapByteUint8(data map[byte]uint8) *ConMapByteUint8

ToConMapByteUint8 creates a new ConMapByteUint8 prepopulated with the data from the specified map[Byte]Uint8.

func (*ConMapByteUint8) Delete 

func (cm *ConMapByteUint8) Delete(k byte) (uint8, bool)

Delete removes the specified byte key, returning its uint8 value and a bool indicating whether the delete occurred or not.

func (*ConMapByteUint8) Get 

func (cm *ConMapByteUint8) Get(k byte) uint8

Get gets the uint8 value for the given byte key.

func (*ConMapByteUint8) GetOK 

func (cm *ConMapByteUint8) GetOK(k byte) (uint8, bool)

GetOK gets the uint8 value for the given byte key, and a bool indicating whether the key was present or not.

func (*ConMapByteUint8) Len 

func (cm *ConMapByteUint8) Len() int

Get gets the uint8 value for the given byte key.

func (*ConMapByteUint8) Set 

func (cm *ConMapByteUint8) Set(k byte, v uint8)

Set sets the uint8 value for the specified byte key.

type ConMapByteUintptr 

type ConMapByteUintptr struct {
	// M is the underlying map[Byte]Uintptr.
	M map[byte]uintptr
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapByteUintptr is a concurrent safe wrapper around a map[Byte]Uintptr.

func NewConMapByteUintptr 

func NewConMapByteUintptr() *ConMapByteUintptr

NewConMapByteUintptr creates a new concurrent safe map storing uintptr values, for byte keys.

func ToConMapByteUintptr 

func ToConMapByteUintptr(data map[byte]uintptr) *ConMapByteUintptr

ToConMapByteUintptr creates a new ConMapByteUintptr prepopulated with the data from the specified map[Byte]Uintptr.

func (*ConMapByteUintptr) Delete 

func (cm *ConMapByteUintptr) Delete(k byte) (uintptr, bool)

Delete removes the specified byte key, returning its uintptr value and a bool indicating whether the delete occurred or not.

func (*ConMapByteUintptr) Get 

func (cm *ConMapByteUintptr) Get(k byte) uintptr

Get gets the uintptr value for the given byte key.

func (*ConMapByteUintptr) GetOK 

func (cm *ConMapByteUintptr) GetOK(k byte) (uintptr, bool)

GetOK gets the uintptr value for the given byte key, and a bool indicating whether the key was present or not.

func (*ConMapByteUintptr) Len 

func (cm *ConMapByteUintptr) Len() int

Get gets the uintptr value for the given byte key.

func (*ConMapByteUintptr) Set 

func (cm *ConMapByteUintptr) Set(k byte, v uintptr)

Set sets the uintptr value for the specified byte key.

type ConMapComplex128Bool 

type ConMapComplex128Bool struct {
	// M is the underlying map[Complex128]Bool.
	M map[complex128]bool
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapComplex128Bool is a concurrent safe wrapper around a map[Complex128]Bool.

func NewConMapComplex128Bool 

func NewConMapComplex128Bool() *ConMapComplex128Bool

NewConMapComplex128Bool creates a new concurrent safe map storing bool values, for complex128 keys.

func ToConMapComplex128Bool 

func ToConMapComplex128Bool(data map[complex128]bool) *ConMapComplex128Bool

ToConMapComplex128Bool creates a new ConMapComplex128Bool prepopulated with the data from the specified map[Complex128]Bool.

func (*ConMapComplex128Bool) Delete 

func (cm *ConMapComplex128Bool) Delete(k complex128) (bool, bool)

Delete removes the specified complex128 key, returning its bool value and a bool indicating whether the delete occurred or not.

func (*ConMapComplex128Bool) Get 

func (cm *ConMapComplex128Bool) Get(k complex128) bool

Get gets the bool value for the given complex128 key.

func (*ConMapComplex128Bool) GetOK 

func (cm *ConMapComplex128Bool) GetOK(k complex128) (bool, bool)

GetOK gets the bool value for the given complex128 key, and a bool indicating whether the key was present or not.

func (*ConMapComplex128Bool) Len 

func (cm *ConMapComplex128Bool) Len() int

Get gets the bool value for the given complex128 key.

func (*ConMapComplex128Bool) Set 

func (cm *ConMapComplex128Bool) Set(k complex128, v bool)

Set sets the bool value for the specified complex128 key.

type ConMapComplex128Byte 

type ConMapComplex128Byte struct {
	// M is the underlying map[Complex128]Byte.
	M map[complex128]byte
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapComplex128Byte is a concurrent safe wrapper around a map[Complex128]Byte.

func NewConMapComplex128Byte 

func NewConMapComplex128Byte() *ConMapComplex128Byte

NewConMapComplex128Byte creates a new concurrent safe map storing byte values, for complex128 keys.

func ToConMapComplex128Byte 

func ToConMapComplex128Byte(data map[complex128]byte) *ConMapComplex128Byte

ToConMapComplex128Byte creates a new ConMapComplex128Byte prepopulated with the data from the specified map[Complex128]Byte.

func (*ConMapComplex128Byte) Delete 

func (cm *ConMapComplex128Byte) Delete(k complex128) (byte, bool)

Delete removes the specified complex128 key, returning its byte value and a bool indicating whether the delete occurred or not.

func (*ConMapComplex128Byte) Get 

func (cm *ConMapComplex128Byte) Get(k complex128) byte

Get gets the byte value for the given complex128 key.

func (*ConMapComplex128Byte) GetOK 

func (cm *ConMapComplex128Byte) GetOK(k complex128) (byte, bool)

GetOK gets the byte value for the given complex128 key, and a bool indicating whether the key was present or not.

func (*ConMapComplex128Byte) Len 

func (cm *ConMapComplex128Byte) Len() int

Get gets the byte value for the given complex128 key.

func (*ConMapComplex128Byte) Set 

func (cm *ConMapComplex128Byte) Set(k complex128, v byte)

Set sets the byte value for the specified complex128 key.

type ConMapComplex128Complex128 

type ConMapComplex128Complex128 struct {
	// M is the underlying map[Complex128]Complex128.
	M map[complex128]complex128
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapComplex128Complex128 is a concurrent safe wrapper around a map[Complex128]Complex128.

func NewConMapComplex128Complex128 

func NewConMapComplex128Complex128() *ConMapComplex128Complex128

NewConMapComplex128Complex128 creates a new concurrent safe map storing complex128 values, for complex128 keys.

func ToConMapComplex128Complex128 

func ToConMapComplex128Complex128(data map[complex128]complex128) *ConMapComplex128Complex128

ToConMapComplex128Complex128 creates a new ConMapComplex128Complex128 prepopulated with the data from the specified map[Complex128]Complex128.

func (*ConMapComplex128Complex128) Delete 

func (cm *ConMapComplex128Complex128) Delete(k complex128) (complex128, bool)

Delete removes the specified complex128 key, returning its complex128 value and a bool indicating whether the delete occurred or not.

func (*ConMapComplex128Complex128) Get 

func (cm *ConMapComplex128Complex128) Get(k complex128) complex128

Get gets the complex128 value for the given complex128 key.

func (*ConMapComplex128Complex128) GetOK 

func (cm *ConMapComplex128Complex128) GetOK(k complex128) (complex128, bool)

GetOK gets the complex128 value for the given complex128 key, and a bool indicating whether the key was present or not.

func (*ConMapComplex128Complex128) Len 

func (cm *ConMapComplex128Complex128) Len() int

Get gets the complex128 value for the given complex128 key.

func (*ConMapComplex128Complex128) Set 

func (cm *ConMapComplex128Complex128) Set(k complex128, v complex128)

Set sets the complex128 value for the specified complex128 key.

type ConMapComplex128Complex64 

type ConMapComplex128Complex64 struct {
	// M is the underlying map[Complex128]Complex64.
	M map[complex128]complex64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapComplex128Complex64 is a concurrent safe wrapper around a map[Complex128]Complex64.

func NewConMapComplex128Complex64 

func NewConMapComplex128Complex64() *ConMapComplex128Complex64

NewConMapComplex128Complex64 creates a new concurrent safe map storing complex64 values, for complex128 keys.

func ToConMapComplex128Complex64 

func ToConMapComplex128Complex64(data map[complex128]complex64) *ConMapComplex128Complex64

ToConMapComplex128Complex64 creates a new ConMapComplex128Complex64 prepopulated with the data from the specified map[Complex128]Complex64.

func (*ConMapComplex128Complex64) Delete 

func (cm *ConMapComplex128Complex64) Delete(k complex128) (complex64, bool)

Delete removes the specified complex128 key, returning its complex64 value and a bool indicating whether the delete occurred or not.

func (*ConMapComplex128Complex64) Get 

func (cm *ConMapComplex128Complex64) Get(k complex128) complex64

Get gets the complex64 value for the given complex128 key.

func (*ConMapComplex128Complex64) GetOK 

func (cm *ConMapComplex128Complex64) GetOK(k complex128) (complex64, bool)

GetOK gets the complex64 value for the given complex128 key, and a bool indicating whether the key was present or not.

func (*ConMapComplex128Complex64) Len 

func (cm *ConMapComplex128Complex64) Len() int

Get gets the complex64 value for the given complex128 key.

func (*ConMapComplex128Complex64) Set 

func (cm *ConMapComplex128Complex64) Set(k complex128, v complex64)

Set sets the complex64 value for the specified complex128 key.

type ConMapComplex128Error 

type ConMapComplex128Error struct {
	// M is the underlying map[Complex128]Error.
	M map[complex128]error
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapComplex128Error is a concurrent safe wrapper around a map[Complex128]Error.

func NewConMapComplex128Error 

func NewConMapComplex128Error() *ConMapComplex128Error

NewConMapComplex128Error creates a new concurrent safe map storing error values, for complex128 keys.

func ToConMapComplex128Error 

func ToConMapComplex128Error(data map[complex128]error) *ConMapComplex128Error

ToConMapComplex128Error creates a new ConMapComplex128Error prepopulated with the data from the specified map[Complex128]Error.

func (*ConMapComplex128Error) Delete 

func (cm *ConMapComplex128Error) Delete(k complex128) (error, bool)

Delete removes the specified complex128 key, returning its error value and a bool indicating whether the delete occurred or not.

func (*ConMapComplex128Error) Get 

func (cm *ConMapComplex128Error) Get(k complex128) error

Get gets the error value for the given complex128 key.

func (*ConMapComplex128Error) GetOK 

func (cm *ConMapComplex128Error) GetOK(k complex128) (error, bool)

GetOK gets the error value for the given complex128 key, and a bool indicating whether the key was present or not.

func (*ConMapComplex128Error) Len 

func (cm *ConMapComplex128Error) Len() int

Get gets the error value for the given complex128 key.

func (*ConMapComplex128Error) Set 

func (cm *ConMapComplex128Error) Set(k complex128, v error)

Set sets the error value for the specified complex128 key.

type ConMapComplex128Float32 

type ConMapComplex128Float32 struct {
	// M is the underlying map[Complex128]Float32.
	M map[complex128]float32
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapComplex128Float32 is a concurrent safe wrapper around a map[Complex128]Float32.

func NewConMapComplex128Float32 

func NewConMapComplex128Float32() *ConMapComplex128Float32

NewConMapComplex128Float32 creates a new concurrent safe map storing float32 values, for complex128 keys.

func ToConMapComplex128Float32 

func ToConMapComplex128Float32(data map[complex128]float32) *ConMapComplex128Float32

ToConMapComplex128Float32 creates a new ConMapComplex128Float32 prepopulated with the data from the specified map[Complex128]Float32.

func (*ConMapComplex128Float32) Delete 

func (cm *ConMapComplex128Float32) Delete(k complex128) (float32, bool)

Delete removes the specified complex128 key, returning its float32 value and a bool indicating whether the delete occurred or not.

func (*ConMapComplex128Float32) Get 

func (cm *ConMapComplex128Float32) Get(k complex128) float32

Get gets the float32 value for the given complex128 key.

func (*ConMapComplex128Float32) GetOK 

func (cm *ConMapComplex128Float32) GetOK(k complex128) (float32, bool)

GetOK gets the float32 value for the given complex128 key, and a bool indicating whether the key was present or not.

func (*ConMapComplex128Float32) Len 

func (cm *ConMapComplex128Float32) Len() int

Get gets the float32 value for the given complex128 key.

func (*ConMapComplex128Float32) Set 

func (cm *ConMapComplex128Float32) Set(k complex128, v float32)

Set sets the float32 value for the specified complex128 key.

type ConMapComplex128Float64 

type ConMapComplex128Float64 struct {
	// M is the underlying map[Complex128]Float64.
	M map[complex128]float64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapComplex128Float64 is a concurrent safe wrapper around a map[Complex128]Float64.

func NewConMapComplex128Float64 

func NewConMapComplex128Float64() *ConMapComplex128Float64

NewConMapComplex128Float64 creates a new concurrent safe map storing float64 values, for complex128 keys.

func ToConMapComplex128Float64 

func ToConMapComplex128Float64(data map[complex128]float64) *ConMapComplex128Float64

ToConMapComplex128Float64 creates a new ConMapComplex128Float64 prepopulated with the data from the specified map[Complex128]Float64.

func (*ConMapComplex128Float64) Delete 

func (cm *ConMapComplex128Float64) Delete(k complex128) (float64, bool)

Delete removes the specified complex128 key, returning its float64 value and a bool indicating whether the delete occurred or not.

func (*ConMapComplex128Float64) Get 

func (cm *ConMapComplex128Float64) Get(k complex128) float64

Get gets the float64 value for the given complex128 key.

func (*ConMapComplex128Float64) GetOK 

func (cm *ConMapComplex128Float64) GetOK(k complex128) (float64, bool)

GetOK gets the float64 value for the given complex128 key, and a bool indicating whether the key was present or not.

func (*ConMapComplex128Float64) Len 

func (cm *ConMapComplex128Float64) Len() int

Get gets the float64 value for the given complex128 key.

func (*ConMapComplex128Float64) Set 

func (cm *ConMapComplex128Float64) Set(k complex128, v float64)

Set sets the float64 value for the specified complex128 key.

type ConMapComplex128Int 

type ConMapComplex128Int struct {
	// M is the underlying map[Complex128]Int.
	M map[complex128]int
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapComplex128Int is a concurrent safe wrapper around a map[Complex128]Int.

func NewConMapComplex128Int 

func NewConMapComplex128Int() *ConMapComplex128Int

NewConMapComplex128Int creates a new concurrent safe map storing int values, for complex128 keys.

func ToConMapComplex128Int 

func ToConMapComplex128Int(data map[complex128]int) *ConMapComplex128Int

ToConMapComplex128Int creates a new ConMapComplex128Int prepopulated with the data from the specified map[Complex128]Int.

func (*ConMapComplex128Int) Delete 

func (cm *ConMapComplex128Int) Delete(k complex128) (int, bool)

Delete removes the specified complex128 key, returning its int value and a bool indicating whether the delete occurred or not.

func (*ConMapComplex128Int) Get 

func (cm *ConMapComplex128Int) Get(k complex128) int

Get gets the int value for the given complex128 key.

func (*ConMapComplex128Int) GetOK 

func (cm *ConMapComplex128Int) GetOK(k complex128) (int, bool)

GetOK gets the int value for the given complex128 key, and a bool indicating whether the key was present or not.

func (*ConMapComplex128Int) Len 

func (cm *ConMapComplex128Int) Len() int

Get gets the int value for the given complex128 key.

func (*ConMapComplex128Int) Set 

func (cm *ConMapComplex128Int) Set(k complex128, v int)

Set sets the int value for the specified complex128 key.

type ConMapComplex128Int16 

type ConMapComplex128Int16 struct {
	// M is the underlying map[Complex128]Int16.
	M map[complex128]int16
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapComplex128Int16 is a concurrent safe wrapper around a map[Complex128]Int16.

func NewConMapComplex128Int16 

func NewConMapComplex128Int16() *ConMapComplex128Int16

NewConMapComplex128Int16 creates a new concurrent safe map storing int16 values, for complex128 keys.

func ToConMapComplex128Int16 

func ToConMapComplex128Int16(data map[complex128]int16) *ConMapComplex128Int16

ToConMapComplex128Int16 creates a new ConMapComplex128Int16 prepopulated with the data from the specified map[Complex128]Int16.

func (*ConMapComplex128Int16) Delete 

func (cm *ConMapComplex128Int16) Delete(k complex128) (int16, bool)

Delete removes the specified complex128 key, returning its int16 value and a bool indicating whether the delete occurred or not.

func (*ConMapComplex128Int16) Get 

func (cm *ConMapComplex128Int16) Get(k complex128) int16

Get gets the int16 value for the given complex128 key.

func (*ConMapComplex128Int16) GetOK 

func (cm *ConMapComplex128Int16) GetOK(k complex128) (int16, bool)

GetOK gets the int16 value for the given complex128 key, and a bool indicating whether the key was present or not.

func (*ConMapComplex128Int16) Len 

func (cm *ConMapComplex128Int16) Len() int

Get gets the int16 value for the given complex128 key.

func (*ConMapComplex128Int16) Set 

func (cm *ConMapComplex128Int16) Set(k complex128, v int16)

Set sets the int16 value for the specified complex128 key.

type ConMapComplex128Int32 

type ConMapComplex128Int32 struct {
	// M is the underlying map[Complex128]Int32.
	M map[complex128]int32
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapComplex128Int32 is a concurrent safe wrapper around a map[Complex128]Int32.

func NewConMapComplex128Int32 

func NewConMapComplex128Int32() *ConMapComplex128Int32

NewConMapComplex128Int32 creates a new concurrent safe map storing int32 values, for complex128 keys.

func ToConMapComplex128Int32 

func ToConMapComplex128Int32(data map[complex128]int32) *ConMapComplex128Int32

ToConMapComplex128Int32 creates a new ConMapComplex128Int32 prepopulated with the data from the specified map[Complex128]Int32.

func (*ConMapComplex128Int32) Delete 

func (cm *ConMapComplex128Int32) Delete(k complex128) (int32, bool)

Delete removes the specified complex128 key, returning its int32 value and a bool indicating whether the delete occurred or not.

func (*ConMapComplex128Int32) Get 

func (cm *ConMapComplex128Int32) Get(k complex128) int32

Get gets the int32 value for the given complex128 key.

func (*ConMapComplex128Int32) GetOK 

func (cm *ConMapComplex128Int32) GetOK(k complex128) (int32, bool)

GetOK gets the int32 value for the given complex128 key, and a bool indicating whether the key was present or not.

func (*ConMapComplex128Int32) Len 

func (cm *ConMapComplex128Int32) Len() int

Get gets the int32 value for the given complex128 key.

func (*ConMapComplex128Int32) Set 

func (cm *ConMapComplex128Int32) Set(k complex128, v int32)

Set sets the int32 value for the specified complex128 key.

type ConMapComplex128Int64 

type ConMapComplex128Int64 struct {
	// M is the underlying map[Complex128]Int64.
	M map[complex128]int64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapComplex128Int64 is a concurrent safe wrapper around a map[Complex128]Int64.

func NewConMapComplex128Int64 

func NewConMapComplex128Int64() *ConMapComplex128Int64

NewConMapComplex128Int64 creates a new concurrent safe map storing int64 values, for complex128 keys.

func ToConMapComplex128Int64 

func ToConMapComplex128Int64(data map[complex128]int64) *ConMapComplex128Int64

ToConMapComplex128Int64 creates a new ConMapComplex128Int64 prepopulated with the data from the specified map[Complex128]Int64.

func (*ConMapComplex128Int64) Delete 

func (cm *ConMapComplex128Int64) Delete(k complex128) (int64, bool)

Delete removes the specified complex128 key, returning its int64 value and a bool indicating whether the delete occurred or not.

func (*ConMapComplex128Int64) Get 

func (cm *ConMapComplex128Int64) Get(k complex128) int64

Get gets the int64 value for the given complex128 key.

func (*ConMapComplex128Int64) GetOK 

func (cm *ConMapComplex128Int64) GetOK(k complex128) (int64, bool)

GetOK gets the int64 value for the given complex128 key, and a bool indicating whether the key was present or not.

func (*ConMapComplex128Int64) Len 

func (cm *ConMapComplex128Int64) Len() int

Get gets the int64 value for the given complex128 key.

func (*ConMapComplex128Int64) Set 

func (cm *ConMapComplex128Int64) Set(k complex128, v int64)

Set sets the int64 value for the specified complex128 key.

type ConMapComplex128Int8 

type ConMapComplex128Int8 struct {
	// M is the underlying map[Complex128]Int8.
	M map[complex128]int8
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapComplex128Int8 is a concurrent safe wrapper around a map[Complex128]Int8.

func NewConMapComplex128Int8 

func NewConMapComplex128Int8() *ConMapComplex128Int8

NewConMapComplex128Int8 creates a new concurrent safe map storing int8 values, for complex128 keys.

func ToConMapComplex128Int8 

func ToConMapComplex128Int8(data map[complex128]int8) *ConMapComplex128Int8

ToConMapComplex128Int8 creates a new ConMapComplex128Int8 prepopulated with the data from the specified map[Complex128]Int8.

func (*ConMapComplex128Int8) Delete 

func (cm *ConMapComplex128Int8) Delete(k complex128) (int8, bool)

Delete removes the specified complex128 key, returning its int8 value and a bool indicating whether the delete occurred or not.

func (*ConMapComplex128Int8) Get 

func (cm *ConMapComplex128Int8) Get(k complex128) int8

Get gets the int8 value for the given complex128 key.

func (*ConMapComplex128Int8) GetOK 

func (cm *ConMapComplex128Int8) GetOK(k complex128) (int8, bool)

GetOK gets the int8 value for the given complex128 key, and a bool indicating whether the key was present or not.

func (*ConMapComplex128Int8) Len 

func (cm *ConMapComplex128Int8) Len() int

Get gets the int8 value for the given complex128 key.

func (*ConMapComplex128Int8) Set 

func (cm *ConMapComplex128Int8) Set(k complex128, v int8)

Set sets the int8 value for the specified complex128 key.

type ConMapComplex128Rune 

type ConMapComplex128Rune struct {
	// M is the underlying map[Complex128]Rune.
	M map[complex128]rune
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapComplex128Rune is a concurrent safe wrapper around a map[Complex128]Rune.

func NewConMapComplex128Rune 

func NewConMapComplex128Rune() *ConMapComplex128Rune

NewConMapComplex128Rune creates a new concurrent safe map storing rune values, for complex128 keys.

func ToConMapComplex128Rune 

func ToConMapComplex128Rune(data map[complex128]rune) *ConMapComplex128Rune

ToConMapComplex128Rune creates a new ConMapComplex128Rune prepopulated with the data from the specified map[Complex128]Rune.

func (*ConMapComplex128Rune) Delete 

func (cm *ConMapComplex128Rune) Delete(k complex128) (rune, bool)

Delete removes the specified complex128 key, returning its rune value and a bool indicating whether the delete occurred or not.

func (*ConMapComplex128Rune) Get 

func (cm *ConMapComplex128Rune) Get(k complex128) rune

Get gets the rune value for the given complex128 key.

func (*ConMapComplex128Rune) GetOK 

func (cm *ConMapComplex128Rune) GetOK(k complex128) (rune, bool)

GetOK gets the rune value for the given complex128 key, and a bool indicating whether the key was present or not.

func (*ConMapComplex128Rune) Len 

func (cm *ConMapComplex128Rune) Len() int

Get gets the rune value for the given complex128 key.

func (*ConMapComplex128Rune) Set 

func (cm *ConMapComplex128Rune) Set(k complex128, v rune)

Set sets the rune value for the specified complex128 key.

type ConMapComplex128String 

type ConMapComplex128String struct {
	// M is the underlying map[Complex128]String.
	M map[complex128]string
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapComplex128String is a concurrent safe wrapper around a map[Complex128]String.

func NewConMapComplex128String 

func NewConMapComplex128String() *ConMapComplex128String

NewConMapComplex128String creates a new concurrent safe map storing string values, for complex128 keys.

func ToConMapComplex128String 

func ToConMapComplex128String(data map[complex128]string) *ConMapComplex128String

ToConMapComplex128String creates a new ConMapComplex128String prepopulated with the data from the specified map[Complex128]String.

func (*ConMapComplex128String) Delete 

func (cm *ConMapComplex128String) Delete(k complex128) (string, bool)

Delete removes the specified complex128 key, returning its string value and a bool indicating whether the delete occurred or not.

func (*ConMapComplex128String) Get 

func (cm *ConMapComplex128String) Get(k complex128) string

Get gets the string value for the given complex128 key.

func (*ConMapComplex128String) GetOK 

func (cm *ConMapComplex128String) GetOK(k complex128) (string, bool)

GetOK gets the string value for the given complex128 key, and a bool indicating whether the key was present or not.

func (*ConMapComplex128String) Len 

func (cm *ConMapComplex128String) Len() int

Get gets the string value for the given complex128 key.

func (*ConMapComplex128String) Set 

func (cm *ConMapComplex128String) Set(k complex128, v string)

Set sets the string value for the specified complex128 key.

type ConMapComplex128Uint 

type ConMapComplex128Uint struct {
	// M is the underlying map[Complex128]Uint.
	M map[complex128]uint
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapComplex128Uint is a concurrent safe wrapper around a map[Complex128]Uint.

func NewConMapComplex128Uint 

func NewConMapComplex128Uint() *ConMapComplex128Uint

NewConMapComplex128Uint creates a new concurrent safe map storing uint values, for complex128 keys.

func ToConMapComplex128Uint 

func ToConMapComplex128Uint(data map[complex128]uint) *ConMapComplex128Uint

ToConMapComplex128Uint creates a new ConMapComplex128Uint prepopulated with the data from the specified map[Complex128]Uint.

func (*ConMapComplex128Uint) Delete 

func (cm *ConMapComplex128Uint) Delete(k complex128) (uint, bool)

Delete removes the specified complex128 key, returning its uint value and a bool indicating whether the delete occurred or not.

func (*ConMapComplex128Uint) Get 

func (cm *ConMapComplex128Uint) Get(k complex128) uint

Get gets the uint value for the given complex128 key.

func (*ConMapComplex128Uint) GetOK 

func (cm *ConMapComplex128Uint) GetOK(k complex128) (uint, bool)

GetOK gets the uint value for the given complex128 key, and a bool indicating whether the key was present or not.

func (*ConMapComplex128Uint) Len 

func (cm *ConMapComplex128Uint) Len() int

Get gets the uint value for the given complex128 key.

func (*ConMapComplex128Uint) Set 

func (cm *ConMapComplex128Uint) Set(k complex128, v uint)

Set sets the uint value for the specified complex128 key.

type ConMapComplex128Uint16 

type ConMapComplex128Uint16 struct {
	// M is the underlying map[Complex128]Uint16.
	M map[complex128]uint16
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapComplex128Uint16 is a concurrent safe wrapper around a map[Complex128]Uint16.

func NewConMapComplex128Uint16 

func NewConMapComplex128Uint16() *ConMapComplex128Uint16

NewConMapComplex128Uint16 creates a new concurrent safe map storing uint16 values, for complex128 keys.

func ToConMapComplex128Uint16 

func ToConMapComplex128Uint16(data map[complex128]uint16) *ConMapComplex128Uint16

ToConMapComplex128Uint16 creates a new ConMapComplex128Uint16 prepopulated with the data from the specified map[Complex128]Uint16.

func (*ConMapComplex128Uint16) Delete 

func (cm *ConMapComplex128Uint16) Delete(k complex128) (uint16, bool)

Delete removes the specified complex128 key, returning its uint16 value and a bool indicating whether the delete occurred or not.

func (*ConMapComplex128Uint16) Get 

func (cm *ConMapComplex128Uint16) Get(k complex128) uint16

Get gets the uint16 value for the given complex128 key.

func (*ConMapComplex128Uint16) GetOK 

func (cm *ConMapComplex128Uint16) GetOK(k complex128) (uint16, bool)

GetOK gets the uint16 value for the given complex128 key, and a bool indicating whether the key was present or not.

func (*ConMapComplex128Uint16) Len 

func (cm *ConMapComplex128Uint16) Len() int

Get gets the uint16 value for the given complex128 key.

func (*ConMapComplex128Uint16) Set 

func (cm *ConMapComplex128Uint16) Set(k complex128, v uint16)

Set sets the uint16 value for the specified complex128 key.

type ConMapComplex128Uint32 

type ConMapComplex128Uint32 struct {
	// M is the underlying map[Complex128]Uint32.
	M map[complex128]uint32
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapComplex128Uint32 is a concurrent safe wrapper around a map[Complex128]Uint32.

func NewConMapComplex128Uint32 

func NewConMapComplex128Uint32() *ConMapComplex128Uint32

NewConMapComplex128Uint32 creates a new concurrent safe map storing uint32 values, for complex128 keys.

func ToConMapComplex128Uint32 

func ToConMapComplex128Uint32(data map[complex128]uint32) *ConMapComplex128Uint32

ToConMapComplex128Uint32 creates a new ConMapComplex128Uint32 prepopulated with the data from the specified map[Complex128]Uint32.

func (*ConMapComplex128Uint32) Delete 

func (cm *ConMapComplex128Uint32) Delete(k complex128) (uint32, bool)

Delete removes the specified complex128 key, returning its uint32 value and a bool indicating whether the delete occurred or not.

func (*ConMapComplex128Uint32) Get 

func (cm *ConMapComplex128Uint32) Get(k complex128) uint32

Get gets the uint32 value for the given complex128 key.

func (*ConMapComplex128Uint32) GetOK 

func (cm *ConMapComplex128Uint32) GetOK(k complex128) (uint32, bool)

GetOK gets the uint32 value for the given complex128 key, and a bool indicating whether the key was present or not.

func (*ConMapComplex128Uint32) Len 

func (cm *ConMapComplex128Uint32) Len() int

Get gets the uint32 value for the given complex128 key.

func (*ConMapComplex128Uint32) Set 

func (cm *ConMapComplex128Uint32) Set(k complex128, v uint32)

Set sets the uint32 value for the specified complex128 key.

type ConMapComplex128Uint64 

type ConMapComplex128Uint64 struct {
	// M is the underlying map[Complex128]Uint64.
	M map[complex128]uint64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapComplex128Uint64 is a concurrent safe wrapper around a map[Complex128]Uint64.

func NewConMapComplex128Uint64 

func NewConMapComplex128Uint64() *ConMapComplex128Uint64

NewConMapComplex128Uint64 creates a new concurrent safe map storing uint64 values, for complex128 keys.

func ToConMapComplex128Uint64 

func ToConMapComplex128Uint64(data map[complex128]uint64) *ConMapComplex128Uint64

ToConMapComplex128Uint64 creates a new ConMapComplex128Uint64 prepopulated with the data from the specified map[Complex128]Uint64.

func (*ConMapComplex128Uint64) Delete 

func (cm *ConMapComplex128Uint64) Delete(k complex128) (uint64, bool)

Delete removes the specified complex128 key, returning its uint64 value and a bool indicating whether the delete occurred or not.

func (*ConMapComplex128Uint64) Get 

func (cm *ConMapComplex128Uint64) Get(k complex128) uint64

Get gets the uint64 value for the given complex128 key.

func (*ConMapComplex128Uint64) GetOK 

func (cm *ConMapComplex128Uint64) GetOK(k complex128) (uint64, bool)

GetOK gets the uint64 value for the given complex128 key, and a bool indicating whether the key was present or not.

func (*ConMapComplex128Uint64) Len 

func (cm *ConMapComplex128Uint64) Len() int

Get gets the uint64 value for the given complex128 key.

func (*ConMapComplex128Uint64) Set 

func (cm *ConMapComplex128Uint64) Set(k complex128, v uint64)

Set sets the uint64 value for the specified complex128 key.

type ConMapComplex128Uint8 

type ConMapComplex128Uint8 struct {
	// M is the underlying map[Complex128]Uint8.
	M map[complex128]uint8
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapComplex128Uint8 is a concurrent safe wrapper around a map[Complex128]Uint8.

func NewConMapComplex128Uint8 

func NewConMapComplex128Uint8() *ConMapComplex128Uint8

NewConMapComplex128Uint8 creates a new concurrent safe map storing uint8 values, for complex128 keys.

func ToConMapComplex128Uint8 

func ToConMapComplex128Uint8(data map[complex128]uint8) *ConMapComplex128Uint8

ToConMapComplex128Uint8 creates a new ConMapComplex128Uint8 prepopulated with the data from the specified map[Complex128]Uint8.

func (*ConMapComplex128Uint8) Delete 

func (cm *ConMapComplex128Uint8) Delete(k complex128) (uint8, bool)

Delete removes the specified complex128 key, returning its uint8 value and a bool indicating whether the delete occurred or not.

func (*ConMapComplex128Uint8) Get 

func (cm *ConMapComplex128Uint8) Get(k complex128) uint8

Get gets the uint8 value for the given complex128 key.

func (*ConMapComplex128Uint8) GetOK 

func (cm *ConMapComplex128Uint8) GetOK(k complex128) (uint8, bool)

GetOK gets the uint8 value for the given complex128 key, and a bool indicating whether the key was present or not.

func (*ConMapComplex128Uint8) Len 

func (cm *ConMapComplex128Uint8) Len() int

Get gets the uint8 value for the given complex128 key.

func (*ConMapComplex128Uint8) Set 

func (cm *ConMapComplex128Uint8) Set(k complex128, v uint8)

Set sets the uint8 value for the specified complex128 key.

type ConMapComplex128Uintptr 

type ConMapComplex128Uintptr struct {
	// M is the underlying map[Complex128]Uintptr.
	M map[complex128]uintptr
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapComplex128Uintptr is a concurrent safe wrapper around a map[Complex128]Uintptr.

func NewConMapComplex128Uintptr 

func NewConMapComplex128Uintptr() *ConMapComplex128Uintptr

NewConMapComplex128Uintptr creates a new concurrent safe map storing uintptr values, for complex128 keys.

func ToConMapComplex128Uintptr 

func ToConMapComplex128Uintptr(data map[complex128]uintptr) *ConMapComplex128Uintptr

ToConMapComplex128Uintptr creates a new ConMapComplex128Uintptr prepopulated with the data from the specified map[Complex128]Uintptr.

func (*ConMapComplex128Uintptr) Delete 

func (cm *ConMapComplex128Uintptr) Delete(k complex128) (uintptr, bool)

Delete removes the specified complex128 key, returning its uintptr value and a bool indicating whether the delete occurred or not.

func (*ConMapComplex128Uintptr) Get 

func (cm *ConMapComplex128Uintptr) Get(k complex128) uintptr

Get gets the uintptr value for the given complex128 key.

func (*ConMapComplex128Uintptr) GetOK 

func (cm *ConMapComplex128Uintptr) GetOK(k complex128) (uintptr, bool)

GetOK gets the uintptr value for the given complex128 key, and a bool indicating whether the key was present or not.

func (*ConMapComplex128Uintptr) Len 

func (cm *ConMapComplex128Uintptr) Len() int

Get gets the uintptr value for the given complex128 key.

func (*ConMapComplex128Uintptr) Set 

func (cm *ConMapComplex128Uintptr) Set(k complex128, v uintptr)

Set sets the uintptr value for the specified complex128 key.

type ConMapComplex64Bool 

type ConMapComplex64Bool struct {
	// M is the underlying map[Complex64]Bool.
	M map[complex64]bool
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapComplex64Bool is a concurrent safe wrapper around a map[Complex64]Bool.

func NewConMapComplex64Bool 

func NewConMapComplex64Bool() *ConMapComplex64Bool

NewConMapComplex64Bool creates a new concurrent safe map storing bool values, for complex64 keys.

func ToConMapComplex64Bool 

func ToConMapComplex64Bool(data map[complex64]bool) *ConMapComplex64Bool

ToConMapComplex64Bool creates a new ConMapComplex64Bool prepopulated with the data from the specified map[Complex64]Bool.

func (*ConMapComplex64Bool) Delete 

func (cm *ConMapComplex64Bool) Delete(k complex64) (bool, bool)

Delete removes the specified complex64 key, returning its bool value and a bool indicating whether the delete occurred or not.

func (*ConMapComplex64Bool) Get 

func (cm *ConMapComplex64Bool) Get(k complex64) bool

Get gets the bool value for the given complex64 key.

func (*ConMapComplex64Bool) GetOK 

func (cm *ConMapComplex64Bool) GetOK(k complex64) (bool, bool)

GetOK gets the bool value for the given complex64 key, and a bool indicating whether the key was present or not.

func (*ConMapComplex64Bool) Len 

func (cm *ConMapComplex64Bool) Len() int

Get gets the bool value for the given complex64 key.

func (*ConMapComplex64Bool) Set 

func (cm *ConMapComplex64Bool) Set(k complex64, v bool)

Set sets the bool value for the specified complex64 key.

type ConMapComplex64Byte 

type ConMapComplex64Byte struct {
	// M is the underlying map[Complex64]Byte.
	M map[complex64]byte
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapComplex64Byte is a concurrent safe wrapper around a map[Complex64]Byte.

func NewConMapComplex64Byte 

func NewConMapComplex64Byte() *ConMapComplex64Byte

NewConMapComplex64Byte creates a new concurrent safe map storing byte values, for complex64 keys.

func ToConMapComplex64Byte 

func ToConMapComplex64Byte(data map[complex64]byte) *ConMapComplex64Byte

ToConMapComplex64Byte creates a new ConMapComplex64Byte prepopulated with the data from the specified map[Complex64]Byte.

func (*ConMapComplex64Byte) Delete 

func (cm *ConMapComplex64Byte) Delete(k complex64) (byte, bool)

Delete removes the specified complex64 key, returning its byte value and a bool indicating whether the delete occurred or not.

func (*ConMapComplex64Byte) Get 

func (cm *ConMapComplex64Byte) Get(k complex64) byte

Get gets the byte value for the given complex64 key.

func (*ConMapComplex64Byte) GetOK 

func (cm *ConMapComplex64Byte) GetOK(k complex64) (byte, bool)

GetOK gets the byte value for the given complex64 key, and a bool indicating whether the key was present or not.

func (*ConMapComplex64Byte) Len 

func (cm *ConMapComplex64Byte) Len() int

Get gets the byte value for the given complex64 key.

func (*ConMapComplex64Byte) Set 

func (cm *ConMapComplex64Byte) Set(k complex64, v byte)

Set sets the byte value for the specified complex64 key.

type ConMapComplex64Complex128 

type ConMapComplex64Complex128 struct {
	// M is the underlying map[Complex64]Complex128.
	M map[complex64]complex128
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapComplex64Complex128 is a concurrent safe wrapper around a map[Complex64]Complex128.

func NewConMapComplex64Complex128 

func NewConMapComplex64Complex128() *ConMapComplex64Complex128

NewConMapComplex64Complex128 creates a new concurrent safe map storing complex128 values, for complex64 keys.

func ToConMapComplex64Complex128 

func ToConMapComplex64Complex128(data map[complex64]complex128) *ConMapComplex64Complex128

ToConMapComplex64Complex128 creates a new ConMapComplex64Complex128 prepopulated with the data from the specified map[Complex64]Complex128.

func (*ConMapComplex64Complex128) Delete 

func (cm *ConMapComplex64Complex128) Delete(k complex64) (complex128, bool)

Delete removes the specified complex64 key, returning its complex128 value and a bool indicating whether the delete occurred or not.

func (*ConMapComplex64Complex128) Get 

func (cm *ConMapComplex64Complex128) Get(k complex64) complex128

Get gets the complex128 value for the given complex64 key.

func (*ConMapComplex64Complex128) GetOK 

func (cm *ConMapComplex64Complex128) GetOK(k complex64) (complex128, bool)

GetOK gets the complex128 value for the given complex64 key, and a bool indicating whether the key was present or not.

func (*ConMapComplex64Complex128) Len 

func (cm *ConMapComplex64Complex128) Len() int

Get gets the complex128 value for the given complex64 key.

func (*ConMapComplex64Complex128) Set 

func (cm *ConMapComplex64Complex128) Set(k complex64, v complex128)

Set sets the complex128 value for the specified complex64 key.

type ConMapComplex64Complex64 

type ConMapComplex64Complex64 struct {
	// M is the underlying map[Complex64]Complex64.
	M map[complex64]complex64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapComplex64Complex64 is a concurrent safe wrapper around a map[Complex64]Complex64.

func NewConMapComplex64Complex64 

func NewConMapComplex64Complex64() *ConMapComplex64Complex64

NewConMapComplex64Complex64 creates a new concurrent safe map storing complex64 values, for complex64 keys.

func ToConMapComplex64Complex64 

func ToConMapComplex64Complex64(data map[complex64]complex64) *ConMapComplex64Complex64

ToConMapComplex64Complex64 creates a new ConMapComplex64Complex64 prepopulated with the data from the specified map[Complex64]Complex64.

func (*ConMapComplex64Complex64) Delete 

func (cm *ConMapComplex64Complex64) Delete(k complex64) (complex64, bool)

Delete removes the specified complex64 key, returning its complex64 value and a bool indicating whether the delete occurred or not.

func (*ConMapComplex64Complex64) Get 

func (cm *ConMapComplex64Complex64) Get(k complex64) complex64

Get gets the complex64 value for the given complex64 key.

func (*ConMapComplex64Complex64) GetOK 

func (cm *ConMapComplex64Complex64) GetOK(k complex64) (complex64, bool)

GetOK gets the complex64 value for the given complex64 key, and a bool indicating whether the key was present or not.

func (*ConMapComplex64Complex64) Len 

func (cm *ConMapComplex64Complex64) Len() int

Get gets the complex64 value for the given complex64 key.

func (*ConMapComplex64Complex64) Set 

func (cm *ConMapComplex64Complex64) Set(k complex64, v complex64)

Set sets the complex64 value for the specified complex64 key.

type ConMapComplex64Error 

type ConMapComplex64Error struct {
	// M is the underlying map[Complex64]Error.
	M map[complex64]error
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapComplex64Error is a concurrent safe wrapper around a map[Complex64]Error.

func NewConMapComplex64Error 

func NewConMapComplex64Error() *ConMapComplex64Error

NewConMapComplex64Error creates a new concurrent safe map storing error values, for complex64 keys.

func ToConMapComplex64Error 

func ToConMapComplex64Error(data map[complex64]error) *ConMapComplex64Error

ToConMapComplex64Error creates a new ConMapComplex64Error prepopulated with the data from the specified map[Complex64]Error.

func (*ConMapComplex64Error) Delete 

func (cm *ConMapComplex64Error) Delete(k complex64) (error, bool)

Delete removes the specified complex64 key, returning its error value and a bool indicating whether the delete occurred or not.

func (*ConMapComplex64Error) Get 

func (cm *ConMapComplex64Error) Get(k complex64) error

Get gets the error value for the given complex64 key.

func (*ConMapComplex64Error) GetOK 

func (cm *ConMapComplex64Error) GetOK(k complex64) (error, bool)

GetOK gets the error value for the given complex64 key, and a bool indicating whether the key was present or not.

func (*ConMapComplex64Error) Len 

func (cm *ConMapComplex64Error) Len() int

Get gets the error value for the given complex64 key.

func (*ConMapComplex64Error) Set 

func (cm *ConMapComplex64Error) Set(k complex64, v error)

Set sets the error value for the specified complex64 key.

type ConMapComplex64Float32 

type ConMapComplex64Float32 struct {
	// M is the underlying map[Complex64]Float32.
	M map[complex64]float32
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapComplex64Float32 is a concurrent safe wrapper around a map[Complex64]Float32.

func NewConMapComplex64Float32 

func NewConMapComplex64Float32() *ConMapComplex64Float32

NewConMapComplex64Float32 creates a new concurrent safe map storing float32 values, for complex64 keys.

func ToConMapComplex64Float32 

func ToConMapComplex64Float32(data map[complex64]float32) *ConMapComplex64Float32

ToConMapComplex64Float32 creates a new ConMapComplex64Float32 prepopulated with the data from the specified map[Complex64]Float32.

func (*ConMapComplex64Float32) Delete 

func (cm *ConMapComplex64Float32) Delete(k complex64) (float32, bool)

Delete removes the specified complex64 key, returning its float32 value and a bool indicating whether the delete occurred or not.

func (*ConMapComplex64Float32) Get 

func (cm *ConMapComplex64Float32) Get(k complex64) float32

Get gets the float32 value for the given complex64 key.

func (*ConMapComplex64Float32) GetOK 

func (cm *ConMapComplex64Float32) GetOK(k complex64) (float32, bool)

GetOK gets the float32 value for the given complex64 key, and a bool indicating whether the key was present or not.

func (*ConMapComplex64Float32) Len 

func (cm *ConMapComplex64Float32) Len() int

Get gets the float32 value for the given complex64 key.

func (*ConMapComplex64Float32) Set 

func (cm *ConMapComplex64Float32) Set(k complex64, v float32)

Set sets the float32 value for the specified complex64 key.

type ConMapComplex64Float64 

type ConMapComplex64Float64 struct {
	// M is the underlying map[Complex64]Float64.
	M map[complex64]float64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapComplex64Float64 is a concurrent safe wrapper around a map[Complex64]Float64.

func NewConMapComplex64Float64 

func NewConMapComplex64Float64() *ConMapComplex64Float64

NewConMapComplex64Float64 creates a new concurrent safe map storing float64 values, for complex64 keys.

func ToConMapComplex64Float64 

func ToConMapComplex64Float64(data map[complex64]float64) *ConMapComplex64Float64

ToConMapComplex64Float64 creates a new ConMapComplex64Float64 prepopulated with the data from the specified map[Complex64]Float64.

func (*ConMapComplex64Float64) Delete 

func (cm *ConMapComplex64Float64) Delete(k complex64) (float64, bool)

Delete removes the specified complex64 key, returning its float64 value and a bool indicating whether the delete occurred or not.

func (*ConMapComplex64Float64) Get 

func (cm *ConMapComplex64Float64) Get(k complex64) float64

Get gets the float64 value for the given complex64 key.

func (*ConMapComplex64Float64) GetOK 

func (cm *ConMapComplex64Float64) GetOK(k complex64) (float64, bool)

GetOK gets the float64 value for the given complex64 key, and a bool indicating whether the key was present or not.

func (*ConMapComplex64Float64) Len 

func (cm *ConMapComplex64Float64) Len() int

Get gets the float64 value for the given complex64 key.

func (*ConMapComplex64Float64) Set 

func (cm *ConMapComplex64Float64) Set(k complex64, v float64)

Set sets the float64 value for the specified complex64 key.

type ConMapComplex64Int 

type ConMapComplex64Int struct {
	// M is the underlying map[Complex64]Int.
	M map[complex64]int
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapComplex64Int is a concurrent safe wrapper around a map[Complex64]Int.

func NewConMapComplex64Int 

func NewConMapComplex64Int() *ConMapComplex64Int

NewConMapComplex64Int creates a new concurrent safe map storing int values, for complex64 keys.

func ToConMapComplex64Int 

func ToConMapComplex64Int(data map[complex64]int) *ConMapComplex64Int

ToConMapComplex64Int creates a new ConMapComplex64Int prepopulated with the data from the specified map[Complex64]Int.

func (*ConMapComplex64Int) Delete 

func (cm *ConMapComplex64Int) Delete(k complex64) (int, bool)

Delete removes the specified complex64 key, returning its int value and a bool indicating whether the delete occurred or not.

func (*ConMapComplex64Int) Get 

func (cm *ConMapComplex64Int) Get(k complex64) int

Get gets the int value for the given complex64 key.

func (*ConMapComplex64Int) GetOK 

func (cm *ConMapComplex64Int) GetOK(k complex64) (int, bool)

GetOK gets the int value for the given complex64 key, and a bool indicating whether the key was present or not.

func (*ConMapComplex64Int) Len 

func (cm *ConMapComplex64Int) Len() int

Get gets the int value for the given complex64 key.

func (*ConMapComplex64Int) Set 

func (cm *ConMapComplex64Int) Set(k complex64, v int)

Set sets the int value for the specified complex64 key.

type ConMapComplex64Int16 

type ConMapComplex64Int16 struct {
	// M is the underlying map[Complex64]Int16.
	M map[complex64]int16
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapComplex64Int16 is a concurrent safe wrapper around a map[Complex64]Int16.

func NewConMapComplex64Int16 

func NewConMapComplex64Int16() *ConMapComplex64Int16

NewConMapComplex64Int16 creates a new concurrent safe map storing int16 values, for complex64 keys.

func ToConMapComplex64Int16 

func ToConMapComplex64Int16(data map[complex64]int16) *ConMapComplex64Int16

ToConMapComplex64Int16 creates a new ConMapComplex64Int16 prepopulated with the data from the specified map[Complex64]Int16.

func (*ConMapComplex64Int16) Delete 

func (cm *ConMapComplex64Int16) Delete(k complex64) (int16, bool)

Delete removes the specified complex64 key, returning its int16 value and a bool indicating whether the delete occurred or not.

func (*ConMapComplex64Int16) Get 

func (cm *ConMapComplex64Int16) Get(k complex64) int16

Get gets the int16 value for the given complex64 key.

func (*ConMapComplex64Int16) GetOK 

func (cm *ConMapComplex64Int16) GetOK(k complex64) (int16, bool)

GetOK gets the int16 value for the given complex64 key, and a bool indicating whether the key was present or not.

func (*ConMapComplex64Int16) Len 

func (cm *ConMapComplex64Int16) Len() int

Get gets the int16 value for the given complex64 key.

func (*ConMapComplex64Int16) Set 

func (cm *ConMapComplex64Int16) Set(k complex64, v int16)

Set sets the int16 value for the specified complex64 key.

type ConMapComplex64Int32 

type ConMapComplex64Int32 struct {
	// M is the underlying map[Complex64]Int32.
	M map[complex64]int32
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapComplex64Int32 is a concurrent safe wrapper around a map[Complex64]Int32.

func NewConMapComplex64Int32 

func NewConMapComplex64Int32() *ConMapComplex64Int32

NewConMapComplex64Int32 creates a new concurrent safe map storing int32 values, for complex64 keys.

func ToConMapComplex64Int32 

func ToConMapComplex64Int32(data map[complex64]int32) *ConMapComplex64Int32

ToConMapComplex64Int32 creates a new ConMapComplex64Int32 prepopulated with the data from the specified map[Complex64]Int32.

func (*ConMapComplex64Int32) Delete 

func (cm *ConMapComplex64Int32) Delete(k complex64) (int32, bool)

Delete removes the specified complex64 key, returning its int32 value and a bool indicating whether the delete occurred or not.

func (*ConMapComplex64Int32) Get 

func (cm *ConMapComplex64Int32) Get(k complex64) int32

Get gets the int32 value for the given complex64 key.

func (*ConMapComplex64Int32) GetOK 

func (cm *ConMapComplex64Int32) GetOK(k complex64) (int32, bool)

GetOK gets the int32 value for the given complex64 key, and a bool indicating whether the key was present or not.

func (*ConMapComplex64Int32) Len 

func (cm *ConMapComplex64Int32) Len() int

Get gets the int32 value for the given complex64 key.

func (*ConMapComplex64Int32) Set 

func (cm *ConMapComplex64Int32) Set(k complex64, v int32)

Set sets the int32 value for the specified complex64 key.

type ConMapComplex64Int64 

type ConMapComplex64Int64 struct {
	// M is the underlying map[Complex64]Int64.
	M map[complex64]int64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapComplex64Int64 is a concurrent safe wrapper around a map[Complex64]Int64.

func NewConMapComplex64Int64 

func NewConMapComplex64Int64() *ConMapComplex64Int64

NewConMapComplex64Int64 creates a new concurrent safe map storing int64 values, for complex64 keys.

func ToConMapComplex64Int64 

func ToConMapComplex64Int64(data map[complex64]int64) *ConMapComplex64Int64

ToConMapComplex64Int64 creates a new ConMapComplex64Int64 prepopulated with the data from the specified map[Complex64]Int64.

func (*ConMapComplex64Int64) Delete 

func (cm *ConMapComplex64Int64) Delete(k complex64) (int64, bool)

Delete removes the specified complex64 key, returning its int64 value and a bool indicating whether the delete occurred or not.

func (*ConMapComplex64Int64) Get 

func (cm *ConMapComplex64Int64) Get(k complex64) int64

Get gets the int64 value for the given complex64 key.

func (*ConMapComplex64Int64) GetOK 

func (cm *ConMapComplex64Int64) GetOK(k complex64) (int64, bool)

GetOK gets the int64 value for the given complex64 key, and a bool indicating whether the key was present or not.

func (*ConMapComplex64Int64) Len 

func (cm *ConMapComplex64Int64) Len() int

Get gets the int64 value for the given complex64 key.

func (*ConMapComplex64Int64) Set 

func (cm *ConMapComplex64Int64) Set(k complex64, v int64)

Set sets the int64 value for the specified complex64 key.

type ConMapComplex64Int8 

type ConMapComplex64Int8 struct {
	// M is the underlying map[Complex64]Int8.
	M map[complex64]int8
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapComplex64Int8 is a concurrent safe wrapper around a map[Complex64]Int8.

func NewConMapComplex64Int8 

func NewConMapComplex64Int8() *ConMapComplex64Int8

NewConMapComplex64Int8 creates a new concurrent safe map storing int8 values, for complex64 keys.

func ToConMapComplex64Int8 

func ToConMapComplex64Int8(data map[complex64]int8) *ConMapComplex64Int8

ToConMapComplex64Int8 creates a new ConMapComplex64Int8 prepopulated with the data from the specified map[Complex64]Int8.

func (*ConMapComplex64Int8) Delete 

func (cm *ConMapComplex64Int8) Delete(k complex64) (int8, bool)

Delete removes the specified complex64 key, returning its int8 value and a bool indicating whether the delete occurred or not.

func (*ConMapComplex64Int8) Get 

func (cm *ConMapComplex64Int8) Get(k complex64) int8

Get gets the int8 value for the given complex64 key.

func (*ConMapComplex64Int8) GetOK 

func (cm *ConMapComplex64Int8) GetOK(k complex64) (int8, bool)

GetOK gets the int8 value for the given complex64 key, and a bool indicating whether the key was present or not.

func (*ConMapComplex64Int8) Len 

func (cm *ConMapComplex64Int8) Len() int

Get gets the int8 value for the given complex64 key.

func (*ConMapComplex64Int8) Set 

func (cm *ConMapComplex64Int8) Set(k complex64, v int8)

Set sets the int8 value for the specified complex64 key.

type ConMapComplex64Rune 

type ConMapComplex64Rune struct {
	// M is the underlying map[Complex64]Rune.
	M map[complex64]rune
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapComplex64Rune is a concurrent safe wrapper around a map[Complex64]Rune.

func NewConMapComplex64Rune 

func NewConMapComplex64Rune() *ConMapComplex64Rune

NewConMapComplex64Rune creates a new concurrent safe map storing rune values, for complex64 keys.

func ToConMapComplex64Rune 

func ToConMapComplex64Rune(data map[complex64]rune) *ConMapComplex64Rune

ToConMapComplex64Rune creates a new ConMapComplex64Rune prepopulated with the data from the specified map[Complex64]Rune.

func (*ConMapComplex64Rune) Delete 

func (cm *ConMapComplex64Rune) Delete(k complex64) (rune, bool)

Delete removes the specified complex64 key, returning its rune value and a bool indicating whether the delete occurred or not.

func (*ConMapComplex64Rune) Get 

func (cm *ConMapComplex64Rune) Get(k complex64) rune

Get gets the rune value for the given complex64 key.

func (*ConMapComplex64Rune) GetOK 

func (cm *ConMapComplex64Rune) GetOK(k complex64) (rune, bool)

GetOK gets the rune value for the given complex64 key, and a bool indicating whether the key was present or not.

func (*ConMapComplex64Rune) Len 

func (cm *ConMapComplex64Rune) Len() int

Get gets the rune value for the given complex64 key.

func (*ConMapComplex64Rune) Set 

func (cm *ConMapComplex64Rune) Set(k complex64, v rune)

Set sets the rune value for the specified complex64 key.

type ConMapComplex64String 

type ConMapComplex64String struct {
	// M is the underlying map[Complex64]String.
	M map[complex64]string
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapComplex64String is a concurrent safe wrapper around a map[Complex64]String.

func NewConMapComplex64String 

func NewConMapComplex64String() *ConMapComplex64String

NewConMapComplex64String creates a new concurrent safe map storing string values, for complex64 keys.

func ToConMapComplex64String 

func ToConMapComplex64String(data map[complex64]string) *ConMapComplex64String

ToConMapComplex64String creates a new ConMapComplex64String prepopulated with the data from the specified map[Complex64]String.

func (*ConMapComplex64String) Delete 

func (cm *ConMapComplex64String) Delete(k complex64) (string, bool)

Delete removes the specified complex64 key, returning its string value and a bool indicating whether the delete occurred or not.

func (*ConMapComplex64String) Get 

func (cm *ConMapComplex64String) Get(k complex64) string

Get gets the string value for the given complex64 key.

func (*ConMapComplex64String) GetOK 

func (cm *ConMapComplex64String) GetOK(k complex64) (string, bool)

GetOK gets the string value for the given complex64 key, and a bool indicating whether the key was present or not.

func (*ConMapComplex64String) Len 

func (cm *ConMapComplex64String) Len() int

Get gets the string value for the given complex64 key.

func (*ConMapComplex64String) Set 

func (cm *ConMapComplex64String) Set(k complex64, v string)

Set sets the string value for the specified complex64 key.

type ConMapComplex64Uint 

type ConMapComplex64Uint struct {
	// M is the underlying map[Complex64]Uint.
	M map[complex64]uint
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapComplex64Uint is a concurrent safe wrapper around a map[Complex64]Uint.

func NewConMapComplex64Uint 

func NewConMapComplex64Uint() *ConMapComplex64Uint

NewConMapComplex64Uint creates a new concurrent safe map storing uint values, for complex64 keys.

func ToConMapComplex64Uint 

func ToConMapComplex64Uint(data map[complex64]uint) *ConMapComplex64Uint

ToConMapComplex64Uint creates a new ConMapComplex64Uint prepopulated with the data from the specified map[Complex64]Uint.

func (*ConMapComplex64Uint) Delete 

func (cm *ConMapComplex64Uint) Delete(k complex64) (uint, bool)

Delete removes the specified complex64 key, returning its uint value and a bool indicating whether the delete occurred or not.

func (*ConMapComplex64Uint) Get 

func (cm *ConMapComplex64Uint) Get(k complex64) uint

Get gets the uint value for the given complex64 key.

func (*ConMapComplex64Uint) GetOK 

func (cm *ConMapComplex64Uint) GetOK(k complex64) (uint, bool)

GetOK gets the uint value for the given complex64 key, and a bool indicating whether the key was present or not.

func (*ConMapComplex64Uint) Len 

func (cm *ConMapComplex64Uint) Len() int

Get gets the uint value for the given complex64 key.

func (*ConMapComplex64Uint) Set 

func (cm *ConMapComplex64Uint) Set(k complex64, v uint)

Set sets the uint value for the specified complex64 key.

type ConMapComplex64Uint16 

type ConMapComplex64Uint16 struct {
	// M is the underlying map[Complex64]Uint16.
	M map[complex64]uint16
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapComplex64Uint16 is a concurrent safe wrapper around a map[Complex64]Uint16.

func NewConMapComplex64Uint16 

func NewConMapComplex64Uint16() *ConMapComplex64Uint16

NewConMapComplex64Uint16 creates a new concurrent safe map storing uint16 values, for complex64 keys.

func ToConMapComplex64Uint16 

func ToConMapComplex64Uint16(data map[complex64]uint16) *ConMapComplex64Uint16

ToConMapComplex64Uint16 creates a new ConMapComplex64Uint16 prepopulated with the data from the specified map[Complex64]Uint16.

func (*ConMapComplex64Uint16) Delete 

func (cm *ConMapComplex64Uint16) Delete(k complex64) (uint16, bool)

Delete removes the specified complex64 key, returning its uint16 value and a bool indicating whether the delete occurred or not.

func (*ConMapComplex64Uint16) Get 

func (cm *ConMapComplex64Uint16) Get(k complex64) uint16

Get gets the uint16 value for the given complex64 key.

func (*ConMapComplex64Uint16) GetOK 

func (cm *ConMapComplex64Uint16) GetOK(k complex64) (uint16, bool)

GetOK gets the uint16 value for the given complex64 key, and a bool indicating whether the key was present or not.

func (*ConMapComplex64Uint16) Len 

func (cm *ConMapComplex64Uint16) Len() int

Get gets the uint16 value for the given complex64 key.

func (*ConMapComplex64Uint16) Set 

func (cm *ConMapComplex64Uint16) Set(k complex64, v uint16)

Set sets the uint16 value for the specified complex64 key.

type ConMapComplex64Uint32 

type ConMapComplex64Uint32 struct {
	// M is the underlying map[Complex64]Uint32.
	M map[complex64]uint32
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapComplex64Uint32 is a concurrent safe wrapper around a map[Complex64]Uint32.

func NewConMapComplex64Uint32 

func NewConMapComplex64Uint32() *ConMapComplex64Uint32

NewConMapComplex64Uint32 creates a new concurrent safe map storing uint32 values, for complex64 keys.

func ToConMapComplex64Uint32 

func ToConMapComplex64Uint32(data map[complex64]uint32) *ConMapComplex64Uint32

ToConMapComplex64Uint32 creates a new ConMapComplex64Uint32 prepopulated with the data from the specified map[Complex64]Uint32.

func (*ConMapComplex64Uint32) Delete 

func (cm *ConMapComplex64Uint32) Delete(k complex64) (uint32, bool)

Delete removes the specified complex64 key, returning its uint32 value and a bool indicating whether the delete occurred or not.

func (*ConMapComplex64Uint32) Get 

func (cm *ConMapComplex64Uint32) Get(k complex64) uint32

Get gets the uint32 value for the given complex64 key.

func (*ConMapComplex64Uint32) GetOK 

func (cm *ConMapComplex64Uint32) GetOK(k complex64) (uint32, bool)

GetOK gets the uint32 value for the given complex64 key, and a bool indicating whether the key was present or not.

func (*ConMapComplex64Uint32) Len 

func (cm *ConMapComplex64Uint32) Len() int

Get gets the uint32 value for the given complex64 key.

func (*ConMapComplex64Uint32) Set 

func (cm *ConMapComplex64Uint32) Set(k complex64, v uint32)

Set sets the uint32 value for the specified complex64 key.

type ConMapComplex64Uint64 

type ConMapComplex64Uint64 struct {
	// M is the underlying map[Complex64]Uint64.
	M map[complex64]uint64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapComplex64Uint64 is a concurrent safe wrapper around a map[Complex64]Uint64.

func NewConMapComplex64Uint64 

func NewConMapComplex64Uint64() *ConMapComplex64Uint64

NewConMapComplex64Uint64 creates a new concurrent safe map storing uint64 values, for complex64 keys.

func ToConMapComplex64Uint64 

func ToConMapComplex64Uint64(data map[complex64]uint64) *ConMapComplex64Uint64

ToConMapComplex64Uint64 creates a new ConMapComplex64Uint64 prepopulated with the data from the specified map[Complex64]Uint64.

func (*ConMapComplex64Uint64) Delete 

func (cm *ConMapComplex64Uint64) Delete(k complex64) (uint64, bool)

Delete removes the specified complex64 key, returning its uint64 value and a bool indicating whether the delete occurred or not.

func (*ConMapComplex64Uint64) Get 

func (cm *ConMapComplex64Uint64) Get(k complex64) uint64

Get gets the uint64 value for the given complex64 key.

func (*ConMapComplex64Uint64) GetOK 

func (cm *ConMapComplex64Uint64) GetOK(k complex64) (uint64, bool)

GetOK gets the uint64 value for the given complex64 key, and a bool indicating whether the key was present or not.

func (*ConMapComplex64Uint64) Len 

func (cm *ConMapComplex64Uint64) Len() int

Get gets the uint64 value for the given complex64 key.

func (*ConMapComplex64Uint64) Set 

func (cm *ConMapComplex64Uint64) Set(k complex64, v uint64)

Set sets the uint64 value for the specified complex64 key.

type ConMapComplex64Uint8 

type ConMapComplex64Uint8 struct {
	// M is the underlying map[Complex64]Uint8.
	M map[complex64]uint8
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapComplex64Uint8 is a concurrent safe wrapper around a map[Complex64]Uint8.

func NewConMapComplex64Uint8 

func NewConMapComplex64Uint8() *ConMapComplex64Uint8

NewConMapComplex64Uint8 creates a new concurrent safe map storing uint8 values, for complex64 keys.

func ToConMapComplex64Uint8 

func ToConMapComplex64Uint8(data map[complex64]uint8) *ConMapComplex64Uint8

ToConMapComplex64Uint8 creates a new ConMapComplex64Uint8 prepopulated with the data from the specified map[Complex64]Uint8.

func (*ConMapComplex64Uint8) Delete 

func (cm *ConMapComplex64Uint8) Delete(k complex64) (uint8, bool)

Delete removes the specified complex64 key, returning its uint8 value and a bool indicating whether the delete occurred or not.

func (*ConMapComplex64Uint8) Get 

func (cm *ConMapComplex64Uint8) Get(k complex64) uint8

Get gets the uint8 value for the given complex64 key.

func (*ConMapComplex64Uint8) GetOK 

func (cm *ConMapComplex64Uint8) GetOK(k complex64) (uint8, bool)

GetOK gets the uint8 value for the given complex64 key, and a bool indicating whether the key was present or not.

func (*ConMapComplex64Uint8) Len 

func (cm *ConMapComplex64Uint8) Len() int

Get gets the uint8 value for the given complex64 key.

func (*ConMapComplex64Uint8) Set 

func (cm *ConMapComplex64Uint8) Set(k complex64, v uint8)

Set sets the uint8 value for the specified complex64 key.

type ConMapComplex64Uintptr 

type ConMapComplex64Uintptr struct {
	// M is the underlying map[Complex64]Uintptr.
	M map[complex64]uintptr
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapComplex64Uintptr is a concurrent safe wrapper around a map[Complex64]Uintptr.

func NewConMapComplex64Uintptr 

func NewConMapComplex64Uintptr() *ConMapComplex64Uintptr

NewConMapComplex64Uintptr creates a new concurrent safe map storing uintptr values, for complex64 keys.

func ToConMapComplex64Uintptr 

func ToConMapComplex64Uintptr(data map[complex64]uintptr) *ConMapComplex64Uintptr

ToConMapComplex64Uintptr creates a new ConMapComplex64Uintptr prepopulated with the data from the specified map[Complex64]Uintptr.

func (*ConMapComplex64Uintptr) Delete 

func (cm *ConMapComplex64Uintptr) Delete(k complex64) (uintptr, bool)

Delete removes the specified complex64 key, returning its uintptr value and a bool indicating whether the delete occurred or not.

func (*ConMapComplex64Uintptr) Get 

func (cm *ConMapComplex64Uintptr) Get(k complex64) uintptr

Get gets the uintptr value for the given complex64 key.

func (*ConMapComplex64Uintptr) GetOK 

func (cm *ConMapComplex64Uintptr) GetOK(k complex64) (uintptr, bool)

GetOK gets the uintptr value for the given complex64 key, and a bool indicating whether the key was present or not.

func (*ConMapComplex64Uintptr) Len 

func (cm *ConMapComplex64Uintptr) Len() int

Get gets the uintptr value for the given complex64 key.

func (*ConMapComplex64Uintptr) Set 

func (cm *ConMapComplex64Uintptr) Set(k complex64, v uintptr)

Set sets the uintptr value for the specified complex64 key.

type ConMapErrorBool 

type ConMapErrorBool struct {
	// M is the underlying map[Error]Bool.
	M map[error]bool
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapErrorBool is a concurrent safe wrapper around a map[Error]Bool.

func NewConMapErrorBool 

func NewConMapErrorBool() *ConMapErrorBool

NewConMapErrorBool creates a new concurrent safe map storing bool values, for error keys.

func ToConMapErrorBool 

func ToConMapErrorBool(data map[error]bool) *ConMapErrorBool

ToConMapErrorBool creates a new ConMapErrorBool prepopulated with the data from the specified map[Error]Bool.

func (*ConMapErrorBool) Delete 

func (cm *ConMapErrorBool) Delete(k error) (bool, bool)

Delete removes the specified error key, returning its bool value and a bool indicating whether the delete occurred or not.

func (*ConMapErrorBool) Get 

func (cm *ConMapErrorBool) Get(k error) bool

Get gets the bool value for the given error key.

func (*ConMapErrorBool) GetOK 

func (cm *ConMapErrorBool) GetOK(k error) (bool, bool)

GetOK gets the bool value for the given error key, and a bool indicating whether the key was present or not.

func (*ConMapErrorBool) Len 

func (cm *ConMapErrorBool) Len() int

Get gets the bool value for the given error key.

func (*ConMapErrorBool) Set 

func (cm *ConMapErrorBool) Set(k error, v bool)

Set sets the bool value for the specified error key.

type ConMapErrorByte 

type ConMapErrorByte struct {
	// M is the underlying map[Error]Byte.
	M map[error]byte
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapErrorByte is a concurrent safe wrapper around a map[Error]Byte.

func NewConMapErrorByte 

func NewConMapErrorByte() *ConMapErrorByte

NewConMapErrorByte creates a new concurrent safe map storing byte values, for error keys.

func ToConMapErrorByte 

func ToConMapErrorByte(data map[error]byte) *ConMapErrorByte

ToConMapErrorByte creates a new ConMapErrorByte prepopulated with the data from the specified map[Error]Byte.

func (*ConMapErrorByte) Delete 

func (cm *ConMapErrorByte) Delete(k error) (byte, bool)

Delete removes the specified error key, returning its byte value and a bool indicating whether the delete occurred or not.

func (*ConMapErrorByte) Get 

func (cm *ConMapErrorByte) Get(k error) byte

Get gets the byte value for the given error key.

func (*ConMapErrorByte) GetOK 

func (cm *ConMapErrorByte) GetOK(k error) (byte, bool)

GetOK gets the byte value for the given error key, and a bool indicating whether the key was present or not.

func (*ConMapErrorByte) Len 

func (cm *ConMapErrorByte) Len() int

Get gets the byte value for the given error key.

func (*ConMapErrorByte) Set 

func (cm *ConMapErrorByte) Set(k error, v byte)

Set sets the byte value for the specified error key.

type ConMapErrorComplex128 

type ConMapErrorComplex128 struct {
	// M is the underlying map[Error]Complex128.
	M map[error]complex128
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapErrorComplex128 is a concurrent safe wrapper around a map[Error]Complex128.

func NewConMapErrorComplex128 

func NewConMapErrorComplex128() *ConMapErrorComplex128

NewConMapErrorComplex128 creates a new concurrent safe map storing complex128 values, for error keys.

func ToConMapErrorComplex128 

func ToConMapErrorComplex128(data map[error]complex128) *ConMapErrorComplex128

ToConMapErrorComplex128 creates a new ConMapErrorComplex128 prepopulated with the data from the specified map[Error]Complex128.

func (*ConMapErrorComplex128) Delete 

func (cm *ConMapErrorComplex128) Delete(k error) (complex128, bool)

Delete removes the specified error key, returning its complex128 value and a bool indicating whether the delete occurred or not.

func (*ConMapErrorComplex128) Get 

func (cm *ConMapErrorComplex128) Get(k error) complex128

Get gets the complex128 value for the given error key.

func (*ConMapErrorComplex128) GetOK 

func (cm *ConMapErrorComplex128) GetOK(k error) (complex128, bool)

GetOK gets the complex128 value for the given error key, and a bool indicating whether the key was present or not.

func (*ConMapErrorComplex128) Len 

func (cm *ConMapErrorComplex128) Len() int

Get gets the complex128 value for the given error key.

func (*ConMapErrorComplex128) Set 

func (cm *ConMapErrorComplex128) Set(k error, v complex128)

Set sets the complex128 value for the specified error key.

type ConMapErrorComplex64 

type ConMapErrorComplex64 struct {
	// M is the underlying map[Error]Complex64.
	M map[error]complex64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapErrorComplex64 is a concurrent safe wrapper around a map[Error]Complex64.

func NewConMapErrorComplex64 

func NewConMapErrorComplex64() *ConMapErrorComplex64

NewConMapErrorComplex64 creates a new concurrent safe map storing complex64 values, for error keys.

func ToConMapErrorComplex64 

func ToConMapErrorComplex64(data map[error]complex64) *ConMapErrorComplex64

ToConMapErrorComplex64 creates a new ConMapErrorComplex64 prepopulated with the data from the specified map[Error]Complex64.

func (*ConMapErrorComplex64) Delete 

func (cm *ConMapErrorComplex64) Delete(k error) (complex64, bool)

Delete removes the specified error key, returning its complex64 value and a bool indicating whether the delete occurred or not.

func (*ConMapErrorComplex64) Get 

func (cm *ConMapErrorComplex64) Get(k error) complex64

Get gets the complex64 value for the given error key.

func (*ConMapErrorComplex64) GetOK 

func (cm *ConMapErrorComplex64) GetOK(k error) (complex64, bool)

GetOK gets the complex64 value for the given error key, and a bool indicating whether the key was present or not.

func (*ConMapErrorComplex64) Len 

func (cm *ConMapErrorComplex64) Len() int

Get gets the complex64 value for the given error key.

func (*ConMapErrorComplex64) Set 

func (cm *ConMapErrorComplex64) Set(k error, v complex64)

Set sets the complex64 value for the specified error key.

type ConMapErrorError 

type ConMapErrorError struct {
	// M is the underlying map[Error]Error.
	M map[error]error
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapErrorError is a concurrent safe wrapper around a map[Error]Error.

func NewConMapErrorError 

func NewConMapErrorError() *ConMapErrorError

NewConMapErrorError creates a new concurrent safe map storing error values, for error keys.

func ToConMapErrorError 

func ToConMapErrorError(data map[error]error) *ConMapErrorError

ToConMapErrorError creates a new ConMapErrorError prepopulated with the data from the specified map[Error]Error.

func (*ConMapErrorError) Delete 

func (cm *ConMapErrorError) Delete(k error) (error, bool)

Delete removes the specified error key, returning its error value and a bool indicating whether the delete occurred or not.

func (*ConMapErrorError) Get 

func (cm *ConMapErrorError) Get(k error) error

Get gets the error value for the given error key.

func (*ConMapErrorError) GetOK 

func (cm *ConMapErrorError) GetOK(k error) (error, bool)

GetOK gets the error value for the given error key, and a bool indicating whether the key was present or not.

func (*ConMapErrorError) Len 

func (cm *ConMapErrorError) Len() int

Get gets the error value for the given error key.

func (*ConMapErrorError) Set 

func (cm *ConMapErrorError) Set(k error, v error)

Set sets the error value for the specified error key.

type ConMapErrorFloat32 

type ConMapErrorFloat32 struct {
	// M is the underlying map[Error]Float32.
	M map[error]float32
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapErrorFloat32 is a concurrent safe wrapper around a map[Error]Float32.

func NewConMapErrorFloat32 

func NewConMapErrorFloat32() *ConMapErrorFloat32

NewConMapErrorFloat32 creates a new concurrent safe map storing float32 values, for error keys.

func ToConMapErrorFloat32 

func ToConMapErrorFloat32(data map[error]float32) *ConMapErrorFloat32

ToConMapErrorFloat32 creates a new ConMapErrorFloat32 prepopulated with the data from the specified map[Error]Float32.

func (*ConMapErrorFloat32) Delete 

func (cm *ConMapErrorFloat32) Delete(k error) (float32, bool)

Delete removes the specified error key, returning its float32 value and a bool indicating whether the delete occurred or not.

func (*ConMapErrorFloat32) Get 

func (cm *ConMapErrorFloat32) Get(k error) float32

Get gets the float32 value for the given error key.

func (*ConMapErrorFloat32) GetOK 

func (cm *ConMapErrorFloat32) GetOK(k error) (float32, bool)

GetOK gets the float32 value for the given error key, and a bool indicating whether the key was present or not.

func (*ConMapErrorFloat32) Len 

func (cm *ConMapErrorFloat32) Len() int

Get gets the float32 value for the given error key.

func (*ConMapErrorFloat32) Set 

func (cm *ConMapErrorFloat32) Set(k error, v float32)

Set sets the float32 value for the specified error key.

type ConMapErrorFloat64 

type ConMapErrorFloat64 struct {
	// M is the underlying map[Error]Float64.
	M map[error]float64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapErrorFloat64 is a concurrent safe wrapper around a map[Error]Float64.

func NewConMapErrorFloat64 

func NewConMapErrorFloat64() *ConMapErrorFloat64

NewConMapErrorFloat64 creates a new concurrent safe map storing float64 values, for error keys.

func ToConMapErrorFloat64 

func ToConMapErrorFloat64(data map[error]float64) *ConMapErrorFloat64

ToConMapErrorFloat64 creates a new ConMapErrorFloat64 prepopulated with the data from the specified map[Error]Float64.

func (*ConMapErrorFloat64) Delete 

func (cm *ConMapErrorFloat64) Delete(k error) (float64, bool)

Delete removes the specified error key, returning its float64 value and a bool indicating whether the delete occurred or not.

func (*ConMapErrorFloat64) Get 

func (cm *ConMapErrorFloat64) Get(k error) float64

Get gets the float64 value for the given error key.

func (*ConMapErrorFloat64) GetOK 

func (cm *ConMapErrorFloat64) GetOK(k error) (float64, bool)

GetOK gets the float64 value for the given error key, and a bool indicating whether the key was present or not.

func (*ConMapErrorFloat64) Len 

func (cm *ConMapErrorFloat64) Len() int

Get gets the float64 value for the given error key.

func (*ConMapErrorFloat64) Set 

func (cm *ConMapErrorFloat64) Set(k error, v float64)

Set sets the float64 value for the specified error key.

type ConMapErrorInt 

type ConMapErrorInt struct {
	// M is the underlying map[Error]Int.
	M map[error]int
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapErrorInt is a concurrent safe wrapper around a map[Error]Int.

func NewConMapErrorInt 

func NewConMapErrorInt() *ConMapErrorInt

NewConMapErrorInt creates a new concurrent safe map storing int values, for error keys.

func ToConMapErrorInt 

func ToConMapErrorInt(data map[error]int) *ConMapErrorInt

ToConMapErrorInt creates a new ConMapErrorInt prepopulated with the data from the specified map[Error]Int.

func (*ConMapErrorInt) Delete 

func (cm *ConMapErrorInt) Delete(k error) (int, bool)

Delete removes the specified error key, returning its int value and a bool indicating whether the delete occurred or not.

func (*ConMapErrorInt) Get 

func (cm *ConMapErrorInt) Get(k error) int

Get gets the int value for the given error key.

func (*ConMapErrorInt) GetOK 

func (cm *ConMapErrorInt) GetOK(k error) (int, bool)

GetOK gets the int value for the given error key, and a bool indicating whether the key was present or not.

func (*ConMapErrorInt) Len 

func (cm *ConMapErrorInt) Len() int

Get gets the int value for the given error key.

func (*ConMapErrorInt) Set 

func (cm *ConMapErrorInt) Set(k error, v int)

Set sets the int value for the specified error key.

type ConMapErrorInt16 

type ConMapErrorInt16 struct {
	// M is the underlying map[Error]Int16.
	M map[error]int16
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapErrorInt16 is a concurrent safe wrapper around a map[Error]Int16.

func NewConMapErrorInt16 

func NewConMapErrorInt16() *ConMapErrorInt16

NewConMapErrorInt16 creates a new concurrent safe map storing int16 values, for error keys.

func ToConMapErrorInt16 

func ToConMapErrorInt16(data map[error]int16) *ConMapErrorInt16

ToConMapErrorInt16 creates a new ConMapErrorInt16 prepopulated with the data from the specified map[Error]Int16.

func (*ConMapErrorInt16) Delete 

func (cm *ConMapErrorInt16) Delete(k error) (int16, bool)

Delete removes the specified error key, returning its int16 value and a bool indicating whether the delete occurred or not.

func (*ConMapErrorInt16) Get 

func (cm *ConMapErrorInt16) Get(k error) int16

Get gets the int16 value for the given error key.

func (*ConMapErrorInt16) GetOK 

func (cm *ConMapErrorInt16) GetOK(k error) (int16, bool)

GetOK gets the int16 value for the given error key, and a bool indicating whether the key was present or not.

func (*ConMapErrorInt16) Len 

func (cm *ConMapErrorInt16) Len() int

Get gets the int16 value for the given error key.

func (*ConMapErrorInt16) Set 

func (cm *ConMapErrorInt16) Set(k error, v int16)

Set sets the int16 value for the specified error key.

type ConMapErrorInt32 

type ConMapErrorInt32 struct {
	// M is the underlying map[Error]Int32.
	M map[error]int32
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapErrorInt32 is a concurrent safe wrapper around a map[Error]Int32.

func NewConMapErrorInt32 

func NewConMapErrorInt32() *ConMapErrorInt32

NewConMapErrorInt32 creates a new concurrent safe map storing int32 values, for error keys.

func ToConMapErrorInt32 

func ToConMapErrorInt32(data map[error]int32) *ConMapErrorInt32

ToConMapErrorInt32 creates a new ConMapErrorInt32 prepopulated with the data from the specified map[Error]Int32.

func (*ConMapErrorInt32) Delete 

func (cm *ConMapErrorInt32) Delete(k error) (int32, bool)

Delete removes the specified error key, returning its int32 value and a bool indicating whether the delete occurred or not.

func (*ConMapErrorInt32) Get 

func (cm *ConMapErrorInt32) Get(k error) int32

Get gets the int32 value for the given error key.

func (*ConMapErrorInt32) GetOK 

func (cm *ConMapErrorInt32) GetOK(k error) (int32, bool)

GetOK gets the int32 value for the given error key, and a bool indicating whether the key was present or not.

func (*ConMapErrorInt32) Len 

func (cm *ConMapErrorInt32) Len() int

Get gets the int32 value for the given error key.

func (*ConMapErrorInt32) Set 

func (cm *ConMapErrorInt32) Set(k error, v int32)

Set sets the int32 value for the specified error key.

type ConMapErrorInt64 

type ConMapErrorInt64 struct {
	// M is the underlying map[Error]Int64.
	M map[error]int64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapErrorInt64 is a concurrent safe wrapper around a map[Error]Int64.

func NewConMapErrorInt64 

func NewConMapErrorInt64() *ConMapErrorInt64

NewConMapErrorInt64 creates a new concurrent safe map storing int64 values, for error keys.

func ToConMapErrorInt64 

func ToConMapErrorInt64(data map[error]int64) *ConMapErrorInt64

ToConMapErrorInt64 creates a new ConMapErrorInt64 prepopulated with the data from the specified map[Error]Int64.

func (*ConMapErrorInt64) Delete 

func (cm *ConMapErrorInt64) Delete(k error) (int64, bool)

Delete removes the specified error key, returning its int64 value and a bool indicating whether the delete occurred or not.

func (*ConMapErrorInt64) Get 

func (cm *ConMapErrorInt64) Get(k error) int64

Get gets the int64 value for the given error key.

func (*ConMapErrorInt64) GetOK 

func (cm *ConMapErrorInt64) GetOK(k error) (int64, bool)

GetOK gets the int64 value for the given error key, and a bool indicating whether the key was present or not.

func (*ConMapErrorInt64) Len 

func (cm *ConMapErrorInt64) Len() int

Get gets the int64 value for the given error key.

func (*ConMapErrorInt64) Set 

func (cm *ConMapErrorInt64) Set(k error, v int64)

Set sets the int64 value for the specified error key.

type ConMapErrorInt8 

type ConMapErrorInt8 struct {
	// M is the underlying map[Error]Int8.
	M map[error]int8
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapErrorInt8 is a concurrent safe wrapper around a map[Error]Int8.

func NewConMapErrorInt8 

func NewConMapErrorInt8() *ConMapErrorInt8

NewConMapErrorInt8 creates a new concurrent safe map storing int8 values, for error keys.

func ToConMapErrorInt8 

func ToConMapErrorInt8(data map[error]int8) *ConMapErrorInt8

ToConMapErrorInt8 creates a new ConMapErrorInt8 prepopulated with the data from the specified map[Error]Int8.

func (*ConMapErrorInt8) Delete 

func (cm *ConMapErrorInt8) Delete(k error) (int8, bool)

Delete removes the specified error key, returning its int8 value and a bool indicating whether the delete occurred or not.

func (*ConMapErrorInt8) Get 

func (cm *ConMapErrorInt8) Get(k error) int8

Get gets the int8 value for the given error key.

func (*ConMapErrorInt8) GetOK 

func (cm *ConMapErrorInt8) GetOK(k error) (int8, bool)

GetOK gets the int8 value for the given error key, and a bool indicating whether the key was present or not.

func (*ConMapErrorInt8) Len 

func (cm *ConMapErrorInt8) Len() int

Get gets the int8 value for the given error key.

func (*ConMapErrorInt8) Set 

func (cm *ConMapErrorInt8) Set(k error, v int8)

Set sets the int8 value for the specified error key.

type ConMapErrorRune 

type ConMapErrorRune struct {
	// M is the underlying map[Error]Rune.
	M map[error]rune
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapErrorRune is a concurrent safe wrapper around a map[Error]Rune.

func NewConMapErrorRune 

func NewConMapErrorRune() *ConMapErrorRune

NewConMapErrorRune creates a new concurrent safe map storing rune values, for error keys.

func ToConMapErrorRune 

func ToConMapErrorRune(data map[error]rune) *ConMapErrorRune

ToConMapErrorRune creates a new ConMapErrorRune prepopulated with the data from the specified map[Error]Rune.

func (*ConMapErrorRune) Delete 

func (cm *ConMapErrorRune) Delete(k error) (rune, bool)

Delete removes the specified error key, returning its rune value and a bool indicating whether the delete occurred or not.

func (*ConMapErrorRune) Get 

func (cm *ConMapErrorRune) Get(k error) rune

Get gets the rune value for the given error key.

func (*ConMapErrorRune) GetOK 

func (cm *ConMapErrorRune) GetOK(k error) (rune, bool)

GetOK gets the rune value for the given error key, and a bool indicating whether the key was present or not.

func (*ConMapErrorRune) Len 

func (cm *ConMapErrorRune) Len() int

Get gets the rune value for the given error key.

func (*ConMapErrorRune) Set 

func (cm *ConMapErrorRune) Set(k error, v rune)

Set sets the rune value for the specified error key.

type ConMapErrorString 

type ConMapErrorString struct {
	// M is the underlying map[Error]String.
	M map[error]string
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapErrorString is a concurrent safe wrapper around a map[Error]String.

func NewConMapErrorString 

func NewConMapErrorString() *ConMapErrorString

NewConMapErrorString creates a new concurrent safe map storing string values, for error keys.

func ToConMapErrorString 

func ToConMapErrorString(data map[error]string) *ConMapErrorString

ToConMapErrorString creates a new ConMapErrorString prepopulated with the data from the specified map[Error]String.

func (*ConMapErrorString) Delete 

func (cm *ConMapErrorString) Delete(k error) (string, bool)

Delete removes the specified error key, returning its string value and a bool indicating whether the delete occurred or not.

func (*ConMapErrorString) Get 

func (cm *ConMapErrorString) Get(k error) string

Get gets the string value for the given error key.

func (*ConMapErrorString) GetOK 

func (cm *ConMapErrorString) GetOK(k error) (string, bool)

GetOK gets the string value for the given error key, and a bool indicating whether the key was present or not.

func (*ConMapErrorString) Len 

func (cm *ConMapErrorString) Len() int

Get gets the string value for the given error key.

func (*ConMapErrorString) Set 

func (cm *ConMapErrorString) Set(k error, v string)

Set sets the string value for the specified error key.

type ConMapErrorUint 

type ConMapErrorUint struct {
	// M is the underlying map[Error]Uint.
	M map[error]uint
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapErrorUint is a concurrent safe wrapper around a map[Error]Uint.

func NewConMapErrorUint 

func NewConMapErrorUint() *ConMapErrorUint

NewConMapErrorUint creates a new concurrent safe map storing uint values, for error keys.

func ToConMapErrorUint 

func ToConMapErrorUint(data map[error]uint) *ConMapErrorUint

ToConMapErrorUint creates a new ConMapErrorUint prepopulated with the data from the specified map[Error]Uint.

func (*ConMapErrorUint) Delete 

func (cm *ConMapErrorUint) Delete(k error) (uint, bool)

Delete removes the specified error key, returning its uint value and a bool indicating whether the delete occurred or not.

func (*ConMapErrorUint) Get 

func (cm *ConMapErrorUint) Get(k error) uint

Get gets the uint value for the given error key.

func (*ConMapErrorUint) GetOK 

func (cm *ConMapErrorUint) GetOK(k error) (uint, bool)

GetOK gets the uint value for the given error key, and a bool indicating whether the key was present or not.

func (*ConMapErrorUint) Len 

func (cm *ConMapErrorUint) Len() int

Get gets the uint value for the given error key.

func (*ConMapErrorUint) Set 

func (cm *ConMapErrorUint) Set(k error, v uint)

Set sets the uint value for the specified error key.

type ConMapErrorUint16 

type ConMapErrorUint16 struct {
	// M is the underlying map[Error]Uint16.
	M map[error]uint16
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapErrorUint16 is a concurrent safe wrapper around a map[Error]Uint16.

func NewConMapErrorUint16 

func NewConMapErrorUint16() *ConMapErrorUint16

NewConMapErrorUint16 creates a new concurrent safe map storing uint16 values, for error keys.

func ToConMapErrorUint16 

func ToConMapErrorUint16(data map[error]uint16) *ConMapErrorUint16

ToConMapErrorUint16 creates a new ConMapErrorUint16 prepopulated with the data from the specified map[Error]Uint16.

func (*ConMapErrorUint16) Delete 

func (cm *ConMapErrorUint16) Delete(k error) (uint16, bool)

Delete removes the specified error key, returning its uint16 value and a bool indicating whether the delete occurred or not.

func (*ConMapErrorUint16) Get 

func (cm *ConMapErrorUint16) Get(k error) uint16

Get gets the uint16 value for the given error key.

func (*ConMapErrorUint16) GetOK 

func (cm *ConMapErrorUint16) GetOK(k error) (uint16, bool)

GetOK gets the uint16 value for the given error key, and a bool indicating whether the key was present or not.

func (*ConMapErrorUint16) Len 

func (cm *ConMapErrorUint16) Len() int

Get gets the uint16 value for the given error key.

func (*ConMapErrorUint16) Set 

func (cm *ConMapErrorUint16) Set(k error, v uint16)

Set sets the uint16 value for the specified error key.

type ConMapErrorUint32 

type ConMapErrorUint32 struct {
	// M is the underlying map[Error]Uint32.
	M map[error]uint32
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapErrorUint32 is a concurrent safe wrapper around a map[Error]Uint32.

func NewConMapErrorUint32 

func NewConMapErrorUint32() *ConMapErrorUint32

NewConMapErrorUint32 creates a new concurrent safe map storing uint32 values, for error keys.

func ToConMapErrorUint32 

func ToConMapErrorUint32(data map[error]uint32) *ConMapErrorUint32

ToConMapErrorUint32 creates a new ConMapErrorUint32 prepopulated with the data from the specified map[Error]Uint32.

func (*ConMapErrorUint32) Delete 

func (cm *ConMapErrorUint32) Delete(k error) (uint32, bool)

Delete removes the specified error key, returning its uint32 value and a bool indicating whether the delete occurred or not.

func (*ConMapErrorUint32) Get 

func (cm *ConMapErrorUint32) Get(k error) uint32

Get gets the uint32 value for the given error key.

func (*ConMapErrorUint32) GetOK 

func (cm *ConMapErrorUint32) GetOK(k error) (uint32, bool)

GetOK gets the uint32 value for the given error key, and a bool indicating whether the key was present or not.

func (*ConMapErrorUint32) Len 

func (cm *ConMapErrorUint32) Len() int

Get gets the uint32 value for the given error key.

func (*ConMapErrorUint32) Set 

func (cm *ConMapErrorUint32) Set(k error, v uint32)

Set sets the uint32 value for the specified error key.

type ConMapErrorUint64 

type ConMapErrorUint64 struct {
	// M is the underlying map[Error]Uint64.
	M map[error]uint64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapErrorUint64 is a concurrent safe wrapper around a map[Error]Uint64.

func NewConMapErrorUint64 

func NewConMapErrorUint64() *ConMapErrorUint64

NewConMapErrorUint64 creates a new concurrent safe map storing uint64 values, for error keys.

func ToConMapErrorUint64 

func ToConMapErrorUint64(data map[error]uint64) *ConMapErrorUint64

ToConMapErrorUint64 creates a new ConMapErrorUint64 prepopulated with the data from the specified map[Error]Uint64.

func (*ConMapErrorUint64) Delete 

func (cm *ConMapErrorUint64) Delete(k error) (uint64, bool)

Delete removes the specified error key, returning its uint64 value and a bool indicating whether the delete occurred or not.

func (*ConMapErrorUint64) Get 

func (cm *ConMapErrorUint64) Get(k error) uint64

Get gets the uint64 value for the given error key.

func (*ConMapErrorUint64) GetOK 

func (cm *ConMapErrorUint64) GetOK(k error) (uint64, bool)

GetOK gets the uint64 value for the given error key, and a bool indicating whether the key was present or not.

func (*ConMapErrorUint64) Len 

func (cm *ConMapErrorUint64) Len() int

Get gets the uint64 value for the given error key.

func (*ConMapErrorUint64) Set 

func (cm *ConMapErrorUint64) Set(k error, v uint64)

Set sets the uint64 value for the specified error key.

type ConMapErrorUint8 

type ConMapErrorUint8 struct {
	// M is the underlying map[Error]Uint8.
	M map[error]uint8
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapErrorUint8 is a concurrent safe wrapper around a map[Error]Uint8.

func NewConMapErrorUint8 

func NewConMapErrorUint8() *ConMapErrorUint8

NewConMapErrorUint8 creates a new concurrent safe map storing uint8 values, for error keys.

func ToConMapErrorUint8 

func ToConMapErrorUint8(data map[error]uint8) *ConMapErrorUint8

ToConMapErrorUint8 creates a new ConMapErrorUint8 prepopulated with the data from the specified map[Error]Uint8.

func (*ConMapErrorUint8) Delete 

func (cm *ConMapErrorUint8) Delete(k error) (uint8, bool)

Delete removes the specified error key, returning its uint8 value and a bool indicating whether the delete occurred or not.

func (*ConMapErrorUint8) Get 

func (cm *ConMapErrorUint8) Get(k error) uint8

Get gets the uint8 value for the given error key.

func (*ConMapErrorUint8) GetOK 

func (cm *ConMapErrorUint8) GetOK(k error) (uint8, bool)

GetOK gets the uint8 value for the given error key, and a bool indicating whether the key was present or not.

func (*ConMapErrorUint8) Len 

func (cm *ConMapErrorUint8) Len() int

Get gets the uint8 value for the given error key.

func (*ConMapErrorUint8) Set 

func (cm *ConMapErrorUint8) Set(k error, v uint8)

Set sets the uint8 value for the specified error key.

type ConMapErrorUintptr 

type ConMapErrorUintptr struct {
	// M is the underlying map[Error]Uintptr.
	M map[error]uintptr
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapErrorUintptr is a concurrent safe wrapper around a map[Error]Uintptr.

func NewConMapErrorUintptr 

func NewConMapErrorUintptr() *ConMapErrorUintptr

NewConMapErrorUintptr creates a new concurrent safe map storing uintptr values, for error keys.

func ToConMapErrorUintptr 

func ToConMapErrorUintptr(data map[error]uintptr) *ConMapErrorUintptr

ToConMapErrorUintptr creates a new ConMapErrorUintptr prepopulated with the data from the specified map[Error]Uintptr.

func (*ConMapErrorUintptr) Delete 

func (cm *ConMapErrorUintptr) Delete(k error) (uintptr, bool)

Delete removes the specified error key, returning its uintptr value and a bool indicating whether the delete occurred or not.

func (*ConMapErrorUintptr) Get 

func (cm *ConMapErrorUintptr) Get(k error) uintptr

Get gets the uintptr value for the given error key.

func (*ConMapErrorUintptr) GetOK 

func (cm *ConMapErrorUintptr) GetOK(k error) (uintptr, bool)

GetOK gets the uintptr value for the given error key, and a bool indicating whether the key was present or not.

func (*ConMapErrorUintptr) Len 

func (cm *ConMapErrorUintptr) Len() int

Get gets the uintptr value for the given error key.

func (*ConMapErrorUintptr) Set 

func (cm *ConMapErrorUintptr) Set(k error, v uintptr)

Set sets the uintptr value for the specified error key.

type ConMapFloat32Bool 

type ConMapFloat32Bool struct {
	// M is the underlying map[Float32]Bool.
	M map[float32]bool
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapFloat32Bool is a concurrent safe wrapper around a map[Float32]Bool.

func NewConMapFloat32Bool 

func NewConMapFloat32Bool() *ConMapFloat32Bool

NewConMapFloat32Bool creates a new concurrent safe map storing bool values, for float32 keys.

func ToConMapFloat32Bool 

func ToConMapFloat32Bool(data map[float32]bool) *ConMapFloat32Bool

ToConMapFloat32Bool creates a new ConMapFloat32Bool prepopulated with the data from the specified map[Float32]Bool.

func (*ConMapFloat32Bool) Delete 

func (cm *ConMapFloat32Bool) Delete(k float32) (bool, bool)

Delete removes the specified float32 key, returning its bool value and a bool indicating whether the delete occurred or not.

func (*ConMapFloat32Bool) Get 

func (cm *ConMapFloat32Bool) Get(k float32) bool

Get gets the bool value for the given float32 key.

func (*ConMapFloat32Bool) GetOK 

func (cm *ConMapFloat32Bool) GetOK(k float32) (bool, bool)

GetOK gets the bool value for the given float32 key, and a bool indicating whether the key was present or not.

func (*ConMapFloat32Bool) Len 

func (cm *ConMapFloat32Bool) Len() int

Get gets the bool value for the given float32 key.

func (*ConMapFloat32Bool) Set 

func (cm *ConMapFloat32Bool) Set(k float32, v bool)

Set sets the bool value for the specified float32 key.

type ConMapFloat32Byte 

type ConMapFloat32Byte struct {
	// M is the underlying map[Float32]Byte.
	M map[float32]byte
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapFloat32Byte is a concurrent safe wrapper around a map[Float32]Byte.

func NewConMapFloat32Byte 

func NewConMapFloat32Byte() *ConMapFloat32Byte

NewConMapFloat32Byte creates a new concurrent safe map storing byte values, for float32 keys.

func ToConMapFloat32Byte 

func ToConMapFloat32Byte(data map[float32]byte) *ConMapFloat32Byte

ToConMapFloat32Byte creates a new ConMapFloat32Byte prepopulated with the data from the specified map[Float32]Byte.

func (*ConMapFloat32Byte) Delete 

func (cm *ConMapFloat32Byte) Delete(k float32) (byte, bool)

Delete removes the specified float32 key, returning its byte value and a bool indicating whether the delete occurred or not.

func (*ConMapFloat32Byte) Get 

func (cm *ConMapFloat32Byte) Get(k float32) byte

Get gets the byte value for the given float32 key.

func (*ConMapFloat32Byte) GetOK 

func (cm *ConMapFloat32Byte) GetOK(k float32) (byte, bool)

GetOK gets the byte value for the given float32 key, and a bool indicating whether the key was present or not.

func (*ConMapFloat32Byte) Len 

func (cm *ConMapFloat32Byte) Len() int

Get gets the byte value for the given float32 key.

func (*ConMapFloat32Byte) Set 

func (cm *ConMapFloat32Byte) Set(k float32, v byte)

Set sets the byte value for the specified float32 key.

type ConMapFloat32Complex128 

type ConMapFloat32Complex128 struct {
	// M is the underlying map[Float32]Complex128.
	M map[float32]complex128
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapFloat32Complex128 is a concurrent safe wrapper around a map[Float32]Complex128.

func NewConMapFloat32Complex128 

func NewConMapFloat32Complex128() *ConMapFloat32Complex128

NewConMapFloat32Complex128 creates a new concurrent safe map storing complex128 values, for float32 keys.

func ToConMapFloat32Complex128 

func ToConMapFloat32Complex128(data map[float32]complex128) *ConMapFloat32Complex128

ToConMapFloat32Complex128 creates a new ConMapFloat32Complex128 prepopulated with the data from the specified map[Float32]Complex128.

func (*ConMapFloat32Complex128) Delete 

func (cm *ConMapFloat32Complex128) Delete(k float32) (complex128, bool)

Delete removes the specified float32 key, returning its complex128 value and a bool indicating whether the delete occurred or not.

func (*ConMapFloat32Complex128) Get 

func (cm *ConMapFloat32Complex128) Get(k float32) complex128

Get gets the complex128 value for the given float32 key.

func (*ConMapFloat32Complex128) GetOK 

func (cm *ConMapFloat32Complex128) GetOK(k float32) (complex128, bool)

GetOK gets the complex128 value for the given float32 key, and a bool indicating whether the key was present or not.

func (*ConMapFloat32Complex128) Len 

func (cm *ConMapFloat32Complex128) Len() int

Get gets the complex128 value for the given float32 key.

func (*ConMapFloat32Complex128) Set 

func (cm *ConMapFloat32Complex128) Set(k float32, v complex128)

Set sets the complex128 value for the specified float32 key.

type ConMapFloat32Complex64 

type ConMapFloat32Complex64 struct {
	// M is the underlying map[Float32]Complex64.
	M map[float32]complex64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapFloat32Complex64 is a concurrent safe wrapper around a map[Float32]Complex64.

func NewConMapFloat32Complex64 

func NewConMapFloat32Complex64() *ConMapFloat32Complex64

NewConMapFloat32Complex64 creates a new concurrent safe map storing complex64 values, for float32 keys.

func ToConMapFloat32Complex64 

func ToConMapFloat32Complex64(data map[float32]complex64) *ConMapFloat32Complex64

ToConMapFloat32Complex64 creates a new ConMapFloat32Complex64 prepopulated with the data from the specified map[Float32]Complex64.

func (*ConMapFloat32Complex64) Delete 

func (cm *ConMapFloat32Complex64) Delete(k float32) (complex64, bool)

Delete removes the specified float32 key, returning its complex64 value and a bool indicating whether the delete occurred or not.

func (*ConMapFloat32Complex64) Get 

func (cm *ConMapFloat32Complex64) Get(k float32) complex64

Get gets the complex64 value for the given float32 key.

func (*ConMapFloat32Complex64) GetOK 

func (cm *ConMapFloat32Complex64) GetOK(k float32) (complex64, bool)

GetOK gets the complex64 value for the given float32 key, and a bool indicating whether the key was present or not.

func (*ConMapFloat32Complex64) Len 

func (cm *ConMapFloat32Complex64) Len() int

Get gets the complex64 value for the given float32 key.

func (*ConMapFloat32Complex64) Set 

func (cm *ConMapFloat32Complex64) Set(k float32, v complex64)

Set sets the complex64 value for the specified float32 key.

type ConMapFloat32Error 

type ConMapFloat32Error struct {
	// M is the underlying map[Float32]Error.
	M map[float32]error
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapFloat32Error is a concurrent safe wrapper around a map[Float32]Error.

func NewConMapFloat32Error 

func NewConMapFloat32Error() *ConMapFloat32Error

NewConMapFloat32Error creates a new concurrent safe map storing error values, for float32 keys.

func ToConMapFloat32Error 

func ToConMapFloat32Error(data map[float32]error) *ConMapFloat32Error

ToConMapFloat32Error creates a new ConMapFloat32Error prepopulated with the data from the specified map[Float32]Error.

func (*ConMapFloat32Error) Delete 

func (cm *ConMapFloat32Error) Delete(k float32) (error, bool)

Delete removes the specified float32 key, returning its error value and a bool indicating whether the delete occurred or not.

func (*ConMapFloat32Error) Get 

func (cm *ConMapFloat32Error) Get(k float32) error

Get gets the error value for the given float32 key.

func (*ConMapFloat32Error) GetOK 

func (cm *ConMapFloat32Error) GetOK(k float32) (error, bool)

GetOK gets the error value for the given float32 key, and a bool indicating whether the key was present or not.

func (*ConMapFloat32Error) Len 

func (cm *ConMapFloat32Error) Len() int

Get gets the error value for the given float32 key.

func (*ConMapFloat32Error) Set 

func (cm *ConMapFloat32Error) Set(k float32, v error)

Set sets the error value for the specified float32 key.

type ConMapFloat32Float32 

type ConMapFloat32Float32 struct {
	// M is the underlying map[Float32]Float32.
	M map[float32]float32
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapFloat32Float32 is a concurrent safe wrapper around a map[Float32]Float32.

func NewConMapFloat32Float32 

func NewConMapFloat32Float32() *ConMapFloat32Float32

NewConMapFloat32Float32 creates a new concurrent safe map storing float32 values, for float32 keys.

func ToConMapFloat32Float32 

func ToConMapFloat32Float32(data map[float32]float32) *ConMapFloat32Float32

ToConMapFloat32Float32 creates a new ConMapFloat32Float32 prepopulated with the data from the specified map[Float32]Float32.

func (*ConMapFloat32Float32) Delete 

func (cm *ConMapFloat32Float32) Delete(k float32) (float32, bool)

Delete removes the specified float32 key, returning its float32 value and a bool indicating whether the delete occurred or not.

func (*ConMapFloat32Float32) Get 

func (cm *ConMapFloat32Float32) Get(k float32) float32

Get gets the float32 value for the given float32 key.

func (*ConMapFloat32Float32) GetOK 

func (cm *ConMapFloat32Float32) GetOK(k float32) (float32, bool)

GetOK gets the float32 value for the given float32 key, and a bool indicating whether the key was present or not.

func (*ConMapFloat32Float32) Len 

func (cm *ConMapFloat32Float32) Len() int

Get gets the float32 value for the given float32 key.

func (*ConMapFloat32Float32) Set 

func (cm *ConMapFloat32Float32) Set(k float32, v float32)

Set sets the float32 value for the specified float32 key.

type ConMapFloat32Float64 

type ConMapFloat32Float64 struct {
	// M is the underlying map[Float32]Float64.
	M map[float32]float64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapFloat32Float64 is a concurrent safe wrapper around a map[Float32]Float64.

func NewConMapFloat32Float64 

func NewConMapFloat32Float64() *ConMapFloat32Float64

NewConMapFloat32Float64 creates a new concurrent safe map storing float64 values, for float32 keys.

func ToConMapFloat32Float64 

func ToConMapFloat32Float64(data map[float32]float64) *ConMapFloat32Float64

ToConMapFloat32Float64 creates a new ConMapFloat32Float64 prepopulated with the data from the specified map[Float32]Float64.

func (*ConMapFloat32Float64) Delete 

func (cm *ConMapFloat32Float64) Delete(k float32) (float64, bool)

Delete removes the specified float32 key, returning its float64 value and a bool indicating whether the delete occurred or not.

func (*ConMapFloat32Float64) Get 

func (cm *ConMapFloat32Float64) Get(k float32) float64

Get gets the float64 value for the given float32 key.

func (*ConMapFloat32Float64) GetOK 

func (cm *ConMapFloat32Float64) GetOK(k float32) (float64, bool)

GetOK gets the float64 value for the given float32 key, and a bool indicating whether the key was present or not.

func (*ConMapFloat32Float64) Len 

func (cm *ConMapFloat32Float64) Len() int

Get gets the float64 value for the given float32 key.

func (*ConMapFloat32Float64) Set 

func (cm *ConMapFloat32Float64) Set(k float32, v float64)

Set sets the float64 value for the specified float32 key.

type ConMapFloat32Int 

type ConMapFloat32Int struct {
	// M is the underlying map[Float32]Int.
	M map[float32]int
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapFloat32Int is a concurrent safe wrapper around a map[Float32]Int.

func NewConMapFloat32Int 

func NewConMapFloat32Int() *ConMapFloat32Int

NewConMapFloat32Int creates a new concurrent safe map storing int values, for float32 keys.

func ToConMapFloat32Int 

func ToConMapFloat32Int(data map[float32]int) *ConMapFloat32Int

ToConMapFloat32Int creates a new ConMapFloat32Int prepopulated with the data from the specified map[Float32]Int.

func (*ConMapFloat32Int) Delete 

func (cm *ConMapFloat32Int) Delete(k float32) (int, bool)

Delete removes the specified float32 key, returning its int value and a bool indicating whether the delete occurred or not.

func (*ConMapFloat32Int) Get 

func (cm *ConMapFloat32Int) Get(k float32) int

Get gets the int value for the given float32 key.

func (*ConMapFloat32Int) GetOK 

func (cm *ConMapFloat32Int) GetOK(k float32) (int, bool)

GetOK gets the int value for the given float32 key, and a bool indicating whether the key was present or not.

func (*ConMapFloat32Int) Len 

func (cm *ConMapFloat32Int) Len() int

Get gets the int value for the given float32 key.

func (*ConMapFloat32Int) Set 

func (cm *ConMapFloat32Int) Set(k float32, v int)

Set sets the int value for the specified float32 key.

type ConMapFloat32Int16 

type ConMapFloat32Int16 struct {
	// M is the underlying map[Float32]Int16.
	M map[float32]int16
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapFloat32Int16 is a concurrent safe wrapper around a map[Float32]Int16.

func NewConMapFloat32Int16 

func NewConMapFloat32Int16() *ConMapFloat32Int16

NewConMapFloat32Int16 creates a new concurrent safe map storing int16 values, for float32 keys.

func ToConMapFloat32Int16 

func ToConMapFloat32Int16(data map[float32]int16) *ConMapFloat32Int16

ToConMapFloat32Int16 creates a new ConMapFloat32Int16 prepopulated with the data from the specified map[Float32]Int16.

func (*ConMapFloat32Int16) Delete 

func (cm *ConMapFloat32Int16) Delete(k float32) (int16, bool)

Delete removes the specified float32 key, returning its int16 value and a bool indicating whether the delete occurred or not.

func (*ConMapFloat32Int16) Get 

func (cm *ConMapFloat32Int16) Get(k float32) int16

Get gets the int16 value for the given float32 key.

func (*ConMapFloat32Int16) GetOK 

func (cm *ConMapFloat32Int16) GetOK(k float32) (int16, bool)

GetOK gets the int16 value for the given float32 key, and a bool indicating whether the key was present or not.

func (*ConMapFloat32Int16) Len 

func (cm *ConMapFloat32Int16) Len() int

Get gets the int16 value for the given float32 key.

func (*ConMapFloat32Int16) Set 

func (cm *ConMapFloat32Int16) Set(k float32, v int16)

Set sets the int16 value for the specified float32 key.

type ConMapFloat32Int32 

type ConMapFloat32Int32 struct {
	// M is the underlying map[Float32]Int32.
	M map[float32]int32
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapFloat32Int32 is a concurrent safe wrapper around a map[Float32]Int32.

func NewConMapFloat32Int32 

func NewConMapFloat32Int32() *ConMapFloat32Int32

NewConMapFloat32Int32 creates a new concurrent safe map storing int32 values, for float32 keys.

func ToConMapFloat32Int32 

func ToConMapFloat32Int32(data map[float32]int32) *ConMapFloat32Int32

ToConMapFloat32Int32 creates a new ConMapFloat32Int32 prepopulated with the data from the specified map[Float32]Int32.

func (*ConMapFloat32Int32) Delete 

func (cm *ConMapFloat32Int32) Delete(k float32) (int32, bool)

Delete removes the specified float32 key, returning its int32 value and a bool indicating whether the delete occurred or not.

func (*ConMapFloat32Int32) Get 

func (cm *ConMapFloat32Int32) Get(k float32) int32

Get gets the int32 value for the given float32 key.

func (*ConMapFloat32Int32) GetOK 

func (cm *ConMapFloat32Int32) GetOK(k float32) (int32, bool)

GetOK gets the int32 value for the given float32 key, and a bool indicating whether the key was present or not.

func (*ConMapFloat32Int32) Len 

func (cm *ConMapFloat32Int32) Len() int

Get gets the int32 value for the given float32 key.

func (*ConMapFloat32Int32) Set 

func (cm *ConMapFloat32Int32) Set(k float32, v int32)

Set sets the int32 value for the specified float32 key.

type ConMapFloat32Int64 

type ConMapFloat32Int64 struct {
	// M is the underlying map[Float32]Int64.
	M map[float32]int64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapFloat32Int64 is a concurrent safe wrapper around a map[Float32]Int64.

func NewConMapFloat32Int64 

func NewConMapFloat32Int64() *ConMapFloat32Int64

NewConMapFloat32Int64 creates a new concurrent safe map storing int64 values, for float32 keys.

func ToConMapFloat32Int64 

func ToConMapFloat32Int64(data map[float32]int64) *ConMapFloat32Int64

ToConMapFloat32Int64 creates a new ConMapFloat32Int64 prepopulated with the data from the specified map[Float32]Int64.

func (*ConMapFloat32Int64) Delete 

func (cm *ConMapFloat32Int64) Delete(k float32) (int64, bool)

Delete removes the specified float32 key, returning its int64 value and a bool indicating whether the delete occurred or not.

func (*ConMapFloat32Int64) Get 

func (cm *ConMapFloat32Int64) Get(k float32) int64

Get gets the int64 value for the given float32 key.

func (*ConMapFloat32Int64) GetOK 

func (cm *ConMapFloat32Int64) GetOK(k float32) (int64, bool)

GetOK gets the int64 value for the given float32 key, and a bool indicating whether the key was present or not.

func (*ConMapFloat32Int64) Len 

func (cm *ConMapFloat32Int64) Len() int

Get gets the int64 value for the given float32 key.

func (*ConMapFloat32Int64) Set 

func (cm *ConMapFloat32Int64) Set(k float32, v int64)

Set sets the int64 value for the specified float32 key.

type ConMapFloat32Int8 

type ConMapFloat32Int8 struct {
	// M is the underlying map[Float32]Int8.
	M map[float32]int8
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapFloat32Int8 is a concurrent safe wrapper around a map[Float32]Int8.

func NewConMapFloat32Int8 

func NewConMapFloat32Int8() *ConMapFloat32Int8

NewConMapFloat32Int8 creates a new concurrent safe map storing int8 values, for float32 keys.

func ToConMapFloat32Int8 

func ToConMapFloat32Int8(data map[float32]int8) *ConMapFloat32Int8

ToConMapFloat32Int8 creates a new ConMapFloat32Int8 prepopulated with the data from the specified map[Float32]Int8.

func (*ConMapFloat32Int8) Delete 

func (cm *ConMapFloat32Int8) Delete(k float32) (int8, bool)

Delete removes the specified float32 key, returning its int8 value and a bool indicating whether the delete occurred or not.

func (*ConMapFloat32Int8) Get 

func (cm *ConMapFloat32Int8) Get(k float32) int8

Get gets the int8 value for the given float32 key.

func (*ConMapFloat32Int8) GetOK 

func (cm *ConMapFloat32Int8) GetOK(k float32) (int8, bool)

GetOK gets the int8 value for the given float32 key, and a bool indicating whether the key was present or not.

func (*ConMapFloat32Int8) Len 

func (cm *ConMapFloat32Int8) Len() int

Get gets the int8 value for the given float32 key.

func (*ConMapFloat32Int8) Set 

func (cm *ConMapFloat32Int8) Set(k float32, v int8)

Set sets the int8 value for the specified float32 key.

type ConMapFloat32Rune 

type ConMapFloat32Rune struct {
	// M is the underlying map[Float32]Rune.
	M map[float32]rune
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapFloat32Rune is a concurrent safe wrapper around a map[Float32]Rune.

func NewConMapFloat32Rune 

func NewConMapFloat32Rune() *ConMapFloat32Rune

NewConMapFloat32Rune creates a new concurrent safe map storing rune values, for float32 keys.

func ToConMapFloat32Rune 

func ToConMapFloat32Rune(data map[float32]rune) *ConMapFloat32Rune

ToConMapFloat32Rune creates a new ConMapFloat32Rune prepopulated with the data from the specified map[Float32]Rune.

func (*ConMapFloat32Rune) Delete 

func (cm *ConMapFloat32Rune) Delete(k float32) (rune, bool)

Delete removes the specified float32 key, returning its rune value and a bool indicating whether the delete occurred or not.

func (*ConMapFloat32Rune) Get 

func (cm *ConMapFloat32Rune) Get(k float32) rune

Get gets the rune value for the given float32 key.

func (*ConMapFloat32Rune) GetOK 

func (cm *ConMapFloat32Rune) GetOK(k float32) (rune, bool)

GetOK gets the rune value for the given float32 key, and a bool indicating whether the key was present or not.

func (*ConMapFloat32Rune) Len 

func (cm *ConMapFloat32Rune) Len() int

Get gets the rune value for the given float32 key.

func (*ConMapFloat32Rune) Set 

func (cm *ConMapFloat32Rune) Set(k float32, v rune)

Set sets the rune value for the specified float32 key.

type ConMapFloat32String 

type ConMapFloat32String struct {
	// M is the underlying map[Float32]String.
	M map[float32]string
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapFloat32String is a concurrent safe wrapper around a map[Float32]String.

func NewConMapFloat32String 

func NewConMapFloat32String() *ConMapFloat32String

NewConMapFloat32String creates a new concurrent safe map storing string values, for float32 keys.

func ToConMapFloat32String 

func ToConMapFloat32String(data map[float32]string) *ConMapFloat32String

ToConMapFloat32String creates a new ConMapFloat32String prepopulated with the data from the specified map[Float32]String.

func (*ConMapFloat32String) Delete 

func (cm *ConMapFloat32String) Delete(k float32) (string, bool)

Delete removes the specified float32 key, returning its string value and a bool indicating whether the delete occurred or not.

func (*ConMapFloat32String) Get 

func (cm *ConMapFloat32String) Get(k float32) string

Get gets the string value for the given float32 key.

func (*ConMapFloat32String) GetOK 

func (cm *ConMapFloat32String) GetOK(k float32) (string, bool)

GetOK gets the string value for the given float32 key, and a bool indicating whether the key was present or not.

func (*ConMapFloat32String) Len 

func (cm *ConMapFloat32String) Len() int

Get gets the string value for the given float32 key.

func (*ConMapFloat32String) Set 

func (cm *ConMapFloat32String) Set(k float32, v string)

Set sets the string value for the specified float32 key.

type ConMapFloat32Uint 

type ConMapFloat32Uint struct {
	// M is the underlying map[Float32]Uint.
	M map[float32]uint
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapFloat32Uint is a concurrent safe wrapper around a map[Float32]Uint.

func NewConMapFloat32Uint 

func NewConMapFloat32Uint() *ConMapFloat32Uint

NewConMapFloat32Uint creates a new concurrent safe map storing uint values, for float32 keys.

func ToConMapFloat32Uint 

func ToConMapFloat32Uint(data map[float32]uint) *ConMapFloat32Uint

ToConMapFloat32Uint creates a new ConMapFloat32Uint prepopulated with the data from the specified map[Float32]Uint.

func (*ConMapFloat32Uint) Delete 

func (cm *ConMapFloat32Uint) Delete(k float32) (uint, bool)

Delete removes the specified float32 key, returning its uint value and a bool indicating whether the delete occurred or not.

func (*ConMapFloat32Uint) Get 

func (cm *ConMapFloat32Uint) Get(k float32) uint

Get gets the uint value for the given float32 key.

func (*ConMapFloat32Uint) GetOK 

func (cm *ConMapFloat32Uint) GetOK(k float32) (uint, bool)

GetOK gets the uint value for the given float32 key, and a bool indicating whether the key was present or not.

func (*ConMapFloat32Uint) Len 

func (cm *ConMapFloat32Uint) Len() int

Get gets the uint value for the given float32 key.

func (*ConMapFloat32Uint) Set 

func (cm *ConMapFloat32Uint) Set(k float32, v uint)

Set sets the uint value for the specified float32 key.

type ConMapFloat32Uint16 

type ConMapFloat32Uint16 struct {
	// M is the underlying map[Float32]Uint16.
	M map[float32]uint16
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapFloat32Uint16 is a concurrent safe wrapper around a map[Float32]Uint16.

func NewConMapFloat32Uint16 

func NewConMapFloat32Uint16() *ConMapFloat32Uint16

NewConMapFloat32Uint16 creates a new concurrent safe map storing uint16 values, for float32 keys.

func ToConMapFloat32Uint16 

func ToConMapFloat32Uint16(data map[float32]uint16) *ConMapFloat32Uint16

ToConMapFloat32Uint16 creates a new ConMapFloat32Uint16 prepopulated with the data from the specified map[Float32]Uint16.

func (*ConMapFloat32Uint16) Delete 

func (cm *ConMapFloat32Uint16) Delete(k float32) (uint16, bool)

Delete removes the specified float32 key, returning its uint16 value and a bool indicating whether the delete occurred or not.

func (*ConMapFloat32Uint16) Get 

func (cm *ConMapFloat32Uint16) Get(k float32) uint16

Get gets the uint16 value for the given float32 key.

func (*ConMapFloat32Uint16) GetOK 

func (cm *ConMapFloat32Uint16) GetOK(k float32) (uint16, bool)

GetOK gets the uint16 value for the given float32 key, and a bool indicating whether the key was present or not.

func (*ConMapFloat32Uint16) Len 

func (cm *ConMapFloat32Uint16) Len() int

Get gets the uint16 value for the given float32 key.

func (*ConMapFloat32Uint16) Set 

func (cm *ConMapFloat32Uint16) Set(k float32, v uint16)

Set sets the uint16 value for the specified float32 key.

type ConMapFloat32Uint32 

type ConMapFloat32Uint32 struct {
	// M is the underlying map[Float32]Uint32.
	M map[float32]uint32
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapFloat32Uint32 is a concurrent safe wrapper around a map[Float32]Uint32.

func NewConMapFloat32Uint32 

func NewConMapFloat32Uint32() *ConMapFloat32Uint32

NewConMapFloat32Uint32 creates a new concurrent safe map storing uint32 values, for float32 keys.

func ToConMapFloat32Uint32 

func ToConMapFloat32Uint32(data map[float32]uint32) *ConMapFloat32Uint32

ToConMapFloat32Uint32 creates a new ConMapFloat32Uint32 prepopulated with the data from the specified map[Float32]Uint32.

func (*ConMapFloat32Uint32) Delete 

func (cm *ConMapFloat32Uint32) Delete(k float32) (uint32, bool)

Delete removes the specified float32 key, returning its uint32 value and a bool indicating whether the delete occurred or not.

func (*ConMapFloat32Uint32) Get 

func (cm *ConMapFloat32Uint32) Get(k float32) uint32

Get gets the uint32 value for the given float32 key.

func (*ConMapFloat32Uint32) GetOK 

func (cm *ConMapFloat32Uint32) GetOK(k float32) (uint32, bool)

GetOK gets the uint32 value for the given float32 key, and a bool indicating whether the key was present or not.

func (*ConMapFloat32Uint32) Len 

func (cm *ConMapFloat32Uint32) Len() int

Get gets the uint32 value for the given float32 key.

func (*ConMapFloat32Uint32) Set 

func (cm *ConMapFloat32Uint32) Set(k float32, v uint32)

Set sets the uint32 value for the specified float32 key.

type ConMapFloat32Uint64 

type ConMapFloat32Uint64 struct {
	// M is the underlying map[Float32]Uint64.
	M map[float32]uint64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapFloat32Uint64 is a concurrent safe wrapper around a map[Float32]Uint64.

func NewConMapFloat32Uint64 

func NewConMapFloat32Uint64() *ConMapFloat32Uint64

NewConMapFloat32Uint64 creates a new concurrent safe map storing uint64 values, for float32 keys.

func ToConMapFloat32Uint64 

func ToConMapFloat32Uint64(data map[float32]uint64) *ConMapFloat32Uint64

ToConMapFloat32Uint64 creates a new ConMapFloat32Uint64 prepopulated with the data from the specified map[Float32]Uint64.

func (*ConMapFloat32Uint64) Delete 

func (cm *ConMapFloat32Uint64) Delete(k float32) (uint64, bool)

Delete removes the specified float32 key, returning its uint64 value and a bool indicating whether the delete occurred or not.

func (*ConMapFloat32Uint64) Get 

func (cm *ConMapFloat32Uint64) Get(k float32) uint64

Get gets the uint64 value for the given float32 key.

func (*ConMapFloat32Uint64) GetOK 

func (cm *ConMapFloat32Uint64) GetOK(k float32) (uint64, bool)

GetOK gets the uint64 value for the given float32 key, and a bool indicating whether the key was present or not.

func (*ConMapFloat32Uint64) Len 

func (cm *ConMapFloat32Uint64) Len() int

Get gets the uint64 value for the given float32 key.

func (*ConMapFloat32Uint64) Set 

func (cm *ConMapFloat32Uint64) Set(k float32, v uint64)

Set sets the uint64 value for the specified float32 key.

type ConMapFloat32Uint8 

type ConMapFloat32Uint8 struct {
	// M is the underlying map[Float32]Uint8.
	M map[float32]uint8
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapFloat32Uint8 is a concurrent safe wrapper around a map[Float32]Uint8.

func NewConMapFloat32Uint8 

func NewConMapFloat32Uint8() *ConMapFloat32Uint8

NewConMapFloat32Uint8 creates a new concurrent safe map storing uint8 values, for float32 keys.

func ToConMapFloat32Uint8 

func ToConMapFloat32Uint8(data map[float32]uint8) *ConMapFloat32Uint8

ToConMapFloat32Uint8 creates a new ConMapFloat32Uint8 prepopulated with the data from the specified map[Float32]Uint8.

func (*ConMapFloat32Uint8) Delete 

func (cm *ConMapFloat32Uint8) Delete(k float32) (uint8, bool)

Delete removes the specified float32 key, returning its uint8 value and a bool indicating whether the delete occurred or not.

func (*ConMapFloat32Uint8) Get 

func (cm *ConMapFloat32Uint8) Get(k float32) uint8

Get gets the uint8 value for the given float32 key.

func (*ConMapFloat32Uint8) GetOK 

func (cm *ConMapFloat32Uint8) GetOK(k float32) (uint8, bool)

GetOK gets the uint8 value for the given float32 key, and a bool indicating whether the key was present or not.

func (*ConMapFloat32Uint8) Len 

func (cm *ConMapFloat32Uint8) Len() int

Get gets the uint8 value for the given float32 key.

func (*ConMapFloat32Uint8) Set 

func (cm *ConMapFloat32Uint8) Set(k float32, v uint8)

Set sets the uint8 value for the specified float32 key.

type ConMapFloat32Uintptr 

type ConMapFloat32Uintptr struct {
	// M is the underlying map[Float32]Uintptr.
	M map[float32]uintptr
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapFloat32Uintptr is a concurrent safe wrapper around a map[Float32]Uintptr.

func NewConMapFloat32Uintptr 

func NewConMapFloat32Uintptr() *ConMapFloat32Uintptr

NewConMapFloat32Uintptr creates a new concurrent safe map storing uintptr values, for float32 keys.

func ToConMapFloat32Uintptr 

func ToConMapFloat32Uintptr(data map[float32]uintptr) *ConMapFloat32Uintptr

ToConMapFloat32Uintptr creates a new ConMapFloat32Uintptr prepopulated with the data from the specified map[Float32]Uintptr.

func (*ConMapFloat32Uintptr) Delete 

func (cm *ConMapFloat32Uintptr) Delete(k float32) (uintptr, bool)

Delete removes the specified float32 key, returning its uintptr value and a bool indicating whether the delete occurred or not.

func (*ConMapFloat32Uintptr) Get 

func (cm *ConMapFloat32Uintptr) Get(k float32) uintptr

Get gets the uintptr value for the given float32 key.

func (*ConMapFloat32Uintptr) GetOK 

func (cm *ConMapFloat32Uintptr) GetOK(k float32) (uintptr, bool)

GetOK gets the uintptr value for the given float32 key, and a bool indicating whether the key was present or not.

func (*ConMapFloat32Uintptr) Len 

func (cm *ConMapFloat32Uintptr) Len() int

Get gets the uintptr value for the given float32 key.

func (*ConMapFloat32Uintptr) Set 

func (cm *ConMapFloat32Uintptr) Set(k float32, v uintptr)

Set sets the uintptr value for the specified float32 key.

type ConMapFloat64Bool 

type ConMapFloat64Bool struct {
	// M is the underlying map[Float64]Bool.
	M map[float64]bool
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapFloat64Bool is a concurrent safe wrapper around a map[Float64]Bool.

func NewConMapFloat64Bool 

func NewConMapFloat64Bool() *ConMapFloat64Bool

NewConMapFloat64Bool creates a new concurrent safe map storing bool values, for float64 keys.

func ToConMapFloat64Bool 

func ToConMapFloat64Bool(data map[float64]bool) *ConMapFloat64Bool

ToConMapFloat64Bool creates a new ConMapFloat64Bool prepopulated with the data from the specified map[Float64]Bool.

func (*ConMapFloat64Bool) Delete 

func (cm *ConMapFloat64Bool) Delete(k float64) (bool, bool)

Delete removes the specified float64 key, returning its bool value and a bool indicating whether the delete occurred or not.

func (*ConMapFloat64Bool) Get 

func (cm *ConMapFloat64Bool) Get(k float64) bool

Get gets the bool value for the given float64 key.

func (*ConMapFloat64Bool) GetOK 

func (cm *ConMapFloat64Bool) GetOK(k float64) (bool, bool)

GetOK gets the bool value for the given float64 key, and a bool indicating whether the key was present or not.

func (*ConMapFloat64Bool) Len 

func (cm *ConMapFloat64Bool) Len() int

Get gets the bool value for the given float64 key.

func (*ConMapFloat64Bool) Set 

func (cm *ConMapFloat64Bool) Set(k float64, v bool)

Set sets the bool value for the specified float64 key.

type ConMapFloat64Byte 

type ConMapFloat64Byte struct {
	// M is the underlying map[Float64]Byte.
	M map[float64]byte
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapFloat64Byte is a concurrent safe wrapper around a map[Float64]Byte.

func NewConMapFloat64Byte 

func NewConMapFloat64Byte() *ConMapFloat64Byte

NewConMapFloat64Byte creates a new concurrent safe map storing byte values, for float64 keys.

func ToConMapFloat64Byte 

func ToConMapFloat64Byte(data map[float64]byte) *ConMapFloat64Byte

ToConMapFloat64Byte creates a new ConMapFloat64Byte prepopulated with the data from the specified map[Float64]Byte.

func (*ConMapFloat64Byte) Delete 

func (cm *ConMapFloat64Byte) Delete(k float64) (byte, bool)

Delete removes the specified float64 key, returning its byte value and a bool indicating whether the delete occurred or not.

func (*ConMapFloat64Byte) Get 

func (cm *ConMapFloat64Byte) Get(k float64) byte

Get gets the byte value for the given float64 key.

func (*ConMapFloat64Byte) GetOK 

func (cm *ConMapFloat64Byte) GetOK(k float64) (byte, bool)

GetOK gets the byte value for the given float64 key, and a bool indicating whether the key was present or not.

func (*ConMapFloat64Byte) Len 

func (cm *ConMapFloat64Byte) Len() int

Get gets the byte value for the given float64 key.

func (*ConMapFloat64Byte) Set 

func (cm *ConMapFloat64Byte) Set(k float64, v byte)

Set sets the byte value for the specified float64 key.

type ConMapFloat64Complex128 

type ConMapFloat64Complex128 struct {
	// M is the underlying map[Float64]Complex128.
	M map[float64]complex128
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapFloat64Complex128 is a concurrent safe wrapper around a map[Float64]Complex128.

func NewConMapFloat64Complex128 

func NewConMapFloat64Complex128() *ConMapFloat64Complex128

NewConMapFloat64Complex128 creates a new concurrent safe map storing complex128 values, for float64 keys.

func ToConMapFloat64Complex128 

func ToConMapFloat64Complex128(data map[float64]complex128) *ConMapFloat64Complex128

ToConMapFloat64Complex128 creates a new ConMapFloat64Complex128 prepopulated with the data from the specified map[Float64]Complex128.

func (*ConMapFloat64Complex128) Delete 

func (cm *ConMapFloat64Complex128) Delete(k float64) (complex128, bool)

Delete removes the specified float64 key, returning its complex128 value and a bool indicating whether the delete occurred or not.

func (*ConMapFloat64Complex128) Get 

func (cm *ConMapFloat64Complex128) Get(k float64) complex128

Get gets the complex128 value for the given float64 key.

func (*ConMapFloat64Complex128) GetOK 

func (cm *ConMapFloat64Complex128) GetOK(k float64) (complex128, bool)

GetOK gets the complex128 value for the given float64 key, and a bool indicating whether the key was present or not.

func (*ConMapFloat64Complex128) Len 

func (cm *ConMapFloat64Complex128) Len() int

Get gets the complex128 value for the given float64 key.

func (*ConMapFloat64Complex128) Set 

func (cm *ConMapFloat64Complex128) Set(k float64, v complex128)

Set sets the complex128 value for the specified float64 key.

type ConMapFloat64Complex64 

type ConMapFloat64Complex64 struct {
	// M is the underlying map[Float64]Complex64.
	M map[float64]complex64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapFloat64Complex64 is a concurrent safe wrapper around a map[Float64]Complex64.

func NewConMapFloat64Complex64 

func NewConMapFloat64Complex64() *ConMapFloat64Complex64

NewConMapFloat64Complex64 creates a new concurrent safe map storing complex64 values, for float64 keys.

func ToConMapFloat64Complex64 

func ToConMapFloat64Complex64(data map[float64]complex64) *ConMapFloat64Complex64

ToConMapFloat64Complex64 creates a new ConMapFloat64Complex64 prepopulated with the data from the specified map[Float64]Complex64.

func (*ConMapFloat64Complex64) Delete 

func (cm *ConMapFloat64Complex64) Delete(k float64) (complex64, bool)

Delete removes the specified float64 key, returning its complex64 value and a bool indicating whether the delete occurred or not.

func (*ConMapFloat64Complex64) Get 

func (cm *ConMapFloat64Complex64) Get(k float64) complex64

Get gets the complex64 value for the given float64 key.

func (*ConMapFloat64Complex64) GetOK 

func (cm *ConMapFloat64Complex64) GetOK(k float64) (complex64, bool)

GetOK gets the complex64 value for the given float64 key, and a bool indicating whether the key was present or not.

func (*ConMapFloat64Complex64) Len 

func (cm *ConMapFloat64Complex64) Len() int

Get gets the complex64 value for the given float64 key.

func (*ConMapFloat64Complex64) Set 

func (cm *ConMapFloat64Complex64) Set(k float64, v complex64)

Set sets the complex64 value for the specified float64 key.

type ConMapFloat64Error 

type ConMapFloat64Error struct {
	// M is the underlying map[Float64]Error.
	M map[float64]error
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapFloat64Error is a concurrent safe wrapper around a map[Float64]Error.

func NewConMapFloat64Error 

func NewConMapFloat64Error() *ConMapFloat64Error

NewConMapFloat64Error creates a new concurrent safe map storing error values, for float64 keys.

func ToConMapFloat64Error 

func ToConMapFloat64Error(data map[float64]error) *ConMapFloat64Error

ToConMapFloat64Error creates a new ConMapFloat64Error prepopulated with the data from the specified map[Float64]Error.

func (*ConMapFloat64Error) Delete 

func (cm *ConMapFloat64Error) Delete(k float64) (error, bool)

Delete removes the specified float64 key, returning its error value and a bool indicating whether the delete occurred or not.

func (*ConMapFloat64Error) Get 

func (cm *ConMapFloat64Error) Get(k float64) error

Get gets the error value for the given float64 key.

func (*ConMapFloat64Error) GetOK 

func (cm *ConMapFloat64Error) GetOK(k float64) (error, bool)

GetOK gets the error value for the given float64 key, and a bool indicating whether the key was present or not.

func (*ConMapFloat64Error) Len 

func (cm *ConMapFloat64Error) Len() int

Get gets the error value for the given float64 key.

func (*ConMapFloat64Error) Set 

func (cm *ConMapFloat64Error) Set(k float64, v error)

Set sets the error value for the specified float64 key.

type ConMapFloat64Float32 

type ConMapFloat64Float32 struct {
	// M is the underlying map[Float64]Float32.
	M map[float64]float32
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapFloat64Float32 is a concurrent safe wrapper around a map[Float64]Float32.

func NewConMapFloat64Float32 

func NewConMapFloat64Float32() *ConMapFloat64Float32

NewConMapFloat64Float32 creates a new concurrent safe map storing float32 values, for float64 keys.

func ToConMapFloat64Float32 

func ToConMapFloat64Float32(data map[float64]float32) *ConMapFloat64Float32

ToConMapFloat64Float32 creates a new ConMapFloat64Float32 prepopulated with the data from the specified map[Float64]Float32.

func (*ConMapFloat64Float32) Delete 

func (cm *ConMapFloat64Float32) Delete(k float64) (float32, bool)

Delete removes the specified float64 key, returning its float32 value and a bool indicating whether the delete occurred or not.

func (*ConMapFloat64Float32) Get 

func (cm *ConMapFloat64Float32) Get(k float64) float32

Get gets the float32 value for the given float64 key.

func (*ConMapFloat64Float32) GetOK 

func (cm *ConMapFloat64Float32) GetOK(k float64) (float32, bool)

GetOK gets the float32 value for the given float64 key, and a bool indicating whether the key was present or not.

func (*ConMapFloat64Float32) Len 

func (cm *ConMapFloat64Float32) Len() int

Get gets the float32 value for the given float64 key.

func (*ConMapFloat64Float32) Set 

func (cm *ConMapFloat64Float32) Set(k float64, v float32)

Set sets the float32 value for the specified float64 key.

type ConMapFloat64Float64 

type ConMapFloat64Float64 struct {
	// M is the underlying map[Float64]Float64.
	M map[float64]float64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapFloat64Float64 is a concurrent safe wrapper around a map[Float64]Float64.

func NewConMapFloat64Float64 

func NewConMapFloat64Float64() *ConMapFloat64Float64

NewConMapFloat64Float64 creates a new concurrent safe map storing float64 values, for float64 keys.

func ToConMapFloat64Float64 

func ToConMapFloat64Float64(data map[float64]float64) *ConMapFloat64Float64

ToConMapFloat64Float64 creates a new ConMapFloat64Float64 prepopulated with the data from the specified map[Float64]Float64.

func (*ConMapFloat64Float64) Delete 

func (cm *ConMapFloat64Float64) Delete(k float64) (float64, bool)

Delete removes the specified float64 key, returning its float64 value and a bool indicating whether the delete occurred or not.

func (*ConMapFloat64Float64) Get 

func (cm *ConMapFloat64Float64) Get(k float64) float64

Get gets the float64 value for the given float64 key.

func (*ConMapFloat64Float64) GetOK 

func (cm *ConMapFloat64Float64) GetOK(k float64) (float64, bool)

GetOK gets the float64 value for the given float64 key, and a bool indicating whether the key was present or not.

func (*ConMapFloat64Float64) Len 

func (cm *ConMapFloat64Float64) Len() int

Get gets the float64 value for the given float64 key.

func (*ConMapFloat64Float64) Set 

func (cm *ConMapFloat64Float64) Set(k float64, v float64)

Set sets the float64 value for the specified float64 key.

type ConMapFloat64Int 

type ConMapFloat64Int struct {
	// M is the underlying map[Float64]Int.
	M map[float64]int
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapFloat64Int is a concurrent safe wrapper around a map[Float64]Int.

func NewConMapFloat64Int 

func NewConMapFloat64Int() *ConMapFloat64Int

NewConMapFloat64Int creates a new concurrent safe map storing int values, for float64 keys.

func ToConMapFloat64Int 

func ToConMapFloat64Int(data map[float64]int) *ConMapFloat64Int

ToConMapFloat64Int creates a new ConMapFloat64Int prepopulated with the data from the specified map[Float64]Int.

func (*ConMapFloat64Int) Delete 

func (cm *ConMapFloat64Int) Delete(k float64) (int, bool)

Delete removes the specified float64 key, returning its int value and a bool indicating whether the delete occurred or not.

func (*ConMapFloat64Int) Get 

func (cm *ConMapFloat64Int) Get(k float64) int

Get gets the int value for the given float64 key.

func (*ConMapFloat64Int) GetOK 

func (cm *ConMapFloat64Int) GetOK(k float64) (int, bool)

GetOK gets the int value for the given float64 key, and a bool indicating whether the key was present or not.

func (*ConMapFloat64Int) Len 

func (cm *ConMapFloat64Int) Len() int

Get gets the int value for the given float64 key.

func (*ConMapFloat64Int) Set 

func (cm *ConMapFloat64Int) Set(k float64, v int)

Set sets the int value for the specified float64 key.

type ConMapFloat64Int16 

type ConMapFloat64Int16 struct {
	// M is the underlying map[Float64]Int16.
	M map[float64]int16
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapFloat64Int16 is a concurrent safe wrapper around a map[Float64]Int16.

func NewConMapFloat64Int16 

func NewConMapFloat64Int16() *ConMapFloat64Int16

NewConMapFloat64Int16 creates a new concurrent safe map storing int16 values, for float64 keys.

func ToConMapFloat64Int16 

func ToConMapFloat64Int16(data map[float64]int16) *ConMapFloat64Int16

ToConMapFloat64Int16 creates a new ConMapFloat64Int16 prepopulated with the data from the specified map[Float64]Int16.

func (*ConMapFloat64Int16) Delete 

func (cm *ConMapFloat64Int16) Delete(k float64) (int16, bool)

Delete removes the specified float64 key, returning its int16 value and a bool indicating whether the delete occurred or not.

func (*ConMapFloat64Int16) Get 

func (cm *ConMapFloat64Int16) Get(k float64) int16

Get gets the int16 value for the given float64 key.

func (*ConMapFloat64Int16) GetOK 

func (cm *ConMapFloat64Int16) GetOK(k float64) (int16, bool)

GetOK gets the int16 value for the given float64 key, and a bool indicating whether the key was present or not.

func (*ConMapFloat64Int16) Len 

func (cm *ConMapFloat64Int16) Len() int

Get gets the int16 value for the given float64 key.

func (*ConMapFloat64Int16) Set 

func (cm *ConMapFloat64Int16) Set(k float64, v int16)

Set sets the int16 value for the specified float64 key.

type ConMapFloat64Int32 

type ConMapFloat64Int32 struct {
	// M is the underlying map[Float64]Int32.
	M map[float64]int32
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapFloat64Int32 is a concurrent safe wrapper around a map[Float64]Int32.

func NewConMapFloat64Int32 

func NewConMapFloat64Int32() *ConMapFloat64Int32

NewConMapFloat64Int32 creates a new concurrent safe map storing int32 values, for float64 keys.

func ToConMapFloat64Int32 

func ToConMapFloat64Int32(data map[float64]int32) *ConMapFloat64Int32

ToConMapFloat64Int32 creates a new ConMapFloat64Int32 prepopulated with the data from the specified map[Float64]Int32.

func (*ConMapFloat64Int32) Delete 

func (cm *ConMapFloat64Int32) Delete(k float64) (int32, bool)

Delete removes the specified float64 key, returning its int32 value and a bool indicating whether the delete occurred or not.

func (*ConMapFloat64Int32) Get 

func (cm *ConMapFloat64Int32) Get(k float64) int32

Get gets the int32 value for the given float64 key.

func (*ConMapFloat64Int32) GetOK 

func (cm *ConMapFloat64Int32) GetOK(k float64) (int32, bool)

GetOK gets the int32 value for the given float64 key, and a bool indicating whether the key was present or not.

func (*ConMapFloat64Int32) Len 

func (cm *ConMapFloat64Int32) Len() int

Get gets the int32 value for the given float64 key.

func (*ConMapFloat64Int32) Set 

func (cm *ConMapFloat64Int32) Set(k float64, v int32)

Set sets the int32 value for the specified float64 key.

type ConMapFloat64Int64 

type ConMapFloat64Int64 struct {
	// M is the underlying map[Float64]Int64.
	M map[float64]int64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapFloat64Int64 is a concurrent safe wrapper around a map[Float64]Int64.

func NewConMapFloat64Int64 

func NewConMapFloat64Int64() *ConMapFloat64Int64

NewConMapFloat64Int64 creates a new concurrent safe map storing int64 values, for float64 keys.

func ToConMapFloat64Int64 

func ToConMapFloat64Int64(data map[float64]int64) *ConMapFloat64Int64

ToConMapFloat64Int64 creates a new ConMapFloat64Int64 prepopulated with the data from the specified map[Float64]Int64.

func (*ConMapFloat64Int64) Delete 

func (cm *ConMapFloat64Int64) Delete(k float64) (int64, bool)

Delete removes the specified float64 key, returning its int64 value and a bool indicating whether the delete occurred or not.

func (*ConMapFloat64Int64) Get 

func (cm *ConMapFloat64Int64) Get(k float64) int64

Get gets the int64 value for the given float64 key.

func (*ConMapFloat64Int64) GetOK 

func (cm *ConMapFloat64Int64) GetOK(k float64) (int64, bool)

GetOK gets the int64 value for the given float64 key, and a bool indicating whether the key was present or not.

func (*ConMapFloat64Int64) Len 

func (cm *ConMapFloat64Int64) Len() int

Get gets the int64 value for the given float64 key.

func (*ConMapFloat64Int64) Set 

func (cm *ConMapFloat64Int64) Set(k float64, v int64)

Set sets the int64 value for the specified float64 key.

type ConMapFloat64Int8 

type ConMapFloat64Int8 struct {
	// M is the underlying map[Float64]Int8.
	M map[float64]int8
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapFloat64Int8 is a concurrent safe wrapper around a map[Float64]Int8.

func NewConMapFloat64Int8 

func NewConMapFloat64Int8() *ConMapFloat64Int8

NewConMapFloat64Int8 creates a new concurrent safe map storing int8 values, for float64 keys.

func ToConMapFloat64Int8 

func ToConMapFloat64Int8(data map[float64]int8) *ConMapFloat64Int8

ToConMapFloat64Int8 creates a new ConMapFloat64Int8 prepopulated with the data from the specified map[Float64]Int8.

func (*ConMapFloat64Int8) Delete 

func (cm *ConMapFloat64Int8) Delete(k float64) (int8, bool)

Delete removes the specified float64 key, returning its int8 value and a bool indicating whether the delete occurred or not.

func (*ConMapFloat64Int8) Get 

func (cm *ConMapFloat64Int8) Get(k float64) int8

Get gets the int8 value for the given float64 key.

func (*ConMapFloat64Int8) GetOK 

func (cm *ConMapFloat64Int8) GetOK(k float64) (int8, bool)

GetOK gets the int8 value for the given float64 key, and a bool indicating whether the key was present or not.

func (*ConMapFloat64Int8) Len 

func (cm *ConMapFloat64Int8) Len() int

Get gets the int8 value for the given float64 key.

func (*ConMapFloat64Int8) Set 

func (cm *ConMapFloat64Int8) Set(k float64, v int8)

Set sets the int8 value for the specified float64 key.

type ConMapFloat64Rune 

type ConMapFloat64Rune struct {
	// M is the underlying map[Float64]Rune.
	M map[float64]rune
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapFloat64Rune is a concurrent safe wrapper around a map[Float64]Rune.

func NewConMapFloat64Rune 

func NewConMapFloat64Rune() *ConMapFloat64Rune

NewConMapFloat64Rune creates a new concurrent safe map storing rune values, for float64 keys.

func ToConMapFloat64Rune 

func ToConMapFloat64Rune(data map[float64]rune) *ConMapFloat64Rune

ToConMapFloat64Rune creates a new ConMapFloat64Rune prepopulated with the data from the specified map[Float64]Rune.

func (*ConMapFloat64Rune) Delete 

func (cm *ConMapFloat64Rune) Delete(k float64) (rune, bool)

Delete removes the specified float64 key, returning its rune value and a bool indicating whether the delete occurred or not.

func (*ConMapFloat64Rune) Get 

func (cm *ConMapFloat64Rune) Get(k float64) rune

Get gets the rune value for the given float64 key.

func (*ConMapFloat64Rune) GetOK 

func (cm *ConMapFloat64Rune) GetOK(k float64) (rune, bool)

GetOK gets the rune value for the given float64 key, and a bool indicating whether the key was present or not.

func (*ConMapFloat64Rune) Len 

func (cm *ConMapFloat64Rune) Len() int

Get gets the rune value for the given float64 key.

func (*ConMapFloat64Rune) Set 

func (cm *ConMapFloat64Rune) Set(k float64, v rune)

Set sets the rune value for the specified float64 key.

type ConMapFloat64String 

type ConMapFloat64String struct {
	// M is the underlying map[Float64]String.
	M map[float64]string
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapFloat64String is a concurrent safe wrapper around a map[Float64]String.

func NewConMapFloat64String 

func NewConMapFloat64String() *ConMapFloat64String

NewConMapFloat64String creates a new concurrent safe map storing string values, for float64 keys.

func ToConMapFloat64String 

func ToConMapFloat64String(data map[float64]string) *ConMapFloat64String

ToConMapFloat64String creates a new ConMapFloat64String prepopulated with the data from the specified map[Float64]String.

func (*ConMapFloat64String) Delete 

func (cm *ConMapFloat64String) Delete(k float64) (string, bool)

Delete removes the specified float64 key, returning its string value and a bool indicating whether the delete occurred or not.

func (*ConMapFloat64String) Get 

func (cm *ConMapFloat64String) Get(k float64) string

Get gets the string value for the given float64 key.

func (*ConMapFloat64String) GetOK 

func (cm *ConMapFloat64String) GetOK(k float64) (string, bool)

GetOK gets the string value for the given float64 key, and a bool indicating whether the key was present or not.

func (*ConMapFloat64String) Len 

func (cm *ConMapFloat64String) Len() int

Get gets the string value for the given float64 key.

func (*ConMapFloat64String) Set 

func (cm *ConMapFloat64String) Set(k float64, v string)

Set sets the string value for the specified float64 key.

type ConMapFloat64Uint 

type ConMapFloat64Uint struct {
	// M is the underlying map[Float64]Uint.
	M map[float64]uint
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapFloat64Uint is a concurrent safe wrapper around a map[Float64]Uint.

func NewConMapFloat64Uint 

func NewConMapFloat64Uint() *ConMapFloat64Uint

NewConMapFloat64Uint creates a new concurrent safe map storing uint values, for float64 keys.

func ToConMapFloat64Uint 

func ToConMapFloat64Uint(data map[float64]uint) *ConMapFloat64Uint

ToConMapFloat64Uint creates a new ConMapFloat64Uint prepopulated with the data from the specified map[Float64]Uint.

func (*ConMapFloat64Uint) Delete 

func (cm *ConMapFloat64Uint) Delete(k float64) (uint, bool)

Delete removes the specified float64 key, returning its uint value and a bool indicating whether the delete occurred or not.

func (*ConMapFloat64Uint) Get 

func (cm *ConMapFloat64Uint) Get(k float64) uint

Get gets the uint value for the given float64 key.

func (*ConMapFloat64Uint) GetOK 

func (cm *ConMapFloat64Uint) GetOK(k float64) (uint, bool)

GetOK gets the uint value for the given float64 key, and a bool indicating whether the key was present or not.

func (*ConMapFloat64Uint) Len 

func (cm *ConMapFloat64Uint) Len() int

Get gets the uint value for the given float64 key.

func (*ConMapFloat64Uint) Set 

func (cm *ConMapFloat64Uint) Set(k float64, v uint)

Set sets the uint value for the specified float64 key.

type ConMapFloat64Uint16 

type ConMapFloat64Uint16 struct {
	// M is the underlying map[Float64]Uint16.
	M map[float64]uint16
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapFloat64Uint16 is a concurrent safe wrapper around a map[Float64]Uint16.

func NewConMapFloat64Uint16 

func NewConMapFloat64Uint16() *ConMapFloat64Uint16

NewConMapFloat64Uint16 creates a new concurrent safe map storing uint16 values, for float64 keys.

func ToConMapFloat64Uint16 

func ToConMapFloat64Uint16(data map[float64]uint16) *ConMapFloat64Uint16

ToConMapFloat64Uint16 creates a new ConMapFloat64Uint16 prepopulated with the data from the specified map[Float64]Uint16.

func (*ConMapFloat64Uint16) Delete 

func (cm *ConMapFloat64Uint16) Delete(k float64) (uint16, bool)

Delete removes the specified float64 key, returning its uint16 value and a bool indicating whether the delete occurred or not.

func (*ConMapFloat64Uint16) Get 

func (cm *ConMapFloat64Uint16) Get(k float64) uint16

Get gets the uint16 value for the given float64 key.

func (*ConMapFloat64Uint16) GetOK 

func (cm *ConMapFloat64Uint16) GetOK(k float64) (uint16, bool)

GetOK gets the uint16 value for the given float64 key, and a bool indicating whether the key was present or not.

func (*ConMapFloat64Uint16) Len 

func (cm *ConMapFloat64Uint16) Len() int

Get gets the uint16 value for the given float64 key.

func (*ConMapFloat64Uint16) Set 

func (cm *ConMapFloat64Uint16) Set(k float64, v uint16)

Set sets the uint16 value for the specified float64 key.

type ConMapFloat64Uint32 

type ConMapFloat64Uint32 struct {
	// M is the underlying map[Float64]Uint32.
	M map[float64]uint32
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapFloat64Uint32 is a concurrent safe wrapper around a map[Float64]Uint32.

func NewConMapFloat64Uint32 

func NewConMapFloat64Uint32() *ConMapFloat64Uint32

NewConMapFloat64Uint32 creates a new concurrent safe map storing uint32 values, for float64 keys.

func ToConMapFloat64Uint32 

func ToConMapFloat64Uint32(data map[float64]uint32) *ConMapFloat64Uint32

ToConMapFloat64Uint32 creates a new ConMapFloat64Uint32 prepopulated with the data from the specified map[Float64]Uint32.

func (*ConMapFloat64Uint32) Delete 

func (cm *ConMapFloat64Uint32) Delete(k float64) (uint32, bool)

Delete removes the specified float64 key, returning its uint32 value and a bool indicating whether the delete occurred or not.

func (*ConMapFloat64Uint32) Get 

func (cm *ConMapFloat64Uint32) Get(k float64) uint32

Get gets the uint32 value for the given float64 key.

func (*ConMapFloat64Uint32) GetOK 

func (cm *ConMapFloat64Uint32) GetOK(k float64) (uint32, bool)

GetOK gets the uint32 value for the given float64 key, and a bool indicating whether the key was present or not.

func (*ConMapFloat64Uint32) Len 

func (cm *ConMapFloat64Uint32) Len() int

Get gets the uint32 value for the given float64 key.

func (*ConMapFloat64Uint32) Set 

func (cm *ConMapFloat64Uint32) Set(k float64, v uint32)

Set sets the uint32 value for the specified float64 key.

type ConMapFloat64Uint64 

type ConMapFloat64Uint64 struct {
	// M is the underlying map[Float64]Uint64.
	M map[float64]uint64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapFloat64Uint64 is a concurrent safe wrapper around a map[Float64]Uint64.

func NewConMapFloat64Uint64 

func NewConMapFloat64Uint64() *ConMapFloat64Uint64

NewConMapFloat64Uint64 creates a new concurrent safe map storing uint64 values, for float64 keys.

func ToConMapFloat64Uint64 

func ToConMapFloat64Uint64(data map[float64]uint64) *ConMapFloat64Uint64

ToConMapFloat64Uint64 creates a new ConMapFloat64Uint64 prepopulated with the data from the specified map[Float64]Uint64.

func (*ConMapFloat64Uint64) Delete 

func (cm *ConMapFloat64Uint64) Delete(k float64) (uint64, bool)

Delete removes the specified float64 key, returning its uint64 value and a bool indicating whether the delete occurred or not.

func (*ConMapFloat64Uint64) Get 

func (cm *ConMapFloat64Uint64) Get(k float64) uint64

Get gets the uint64 value for the given float64 key.

func (*ConMapFloat64Uint64) GetOK 

func (cm *ConMapFloat64Uint64) GetOK(k float64) (uint64, bool)

GetOK gets the uint64 value for the given float64 key, and a bool indicating whether the key was present or not.

func (*ConMapFloat64Uint64) Len 

func (cm *ConMapFloat64Uint64) Len() int

Get gets the uint64 value for the given float64 key.

func (*ConMapFloat64Uint64) Set 

func (cm *ConMapFloat64Uint64) Set(k float64, v uint64)

Set sets the uint64 value for the specified float64 key.

type ConMapFloat64Uint8 

type ConMapFloat64Uint8 struct {
	// M is the underlying map[Float64]Uint8.
	M map[float64]uint8
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapFloat64Uint8 is a concurrent safe wrapper around a map[Float64]Uint8.

func NewConMapFloat64Uint8 

func NewConMapFloat64Uint8() *ConMapFloat64Uint8

NewConMapFloat64Uint8 creates a new concurrent safe map storing uint8 values, for float64 keys.

func ToConMapFloat64Uint8 

func ToConMapFloat64Uint8(data map[float64]uint8) *ConMapFloat64Uint8

ToConMapFloat64Uint8 creates a new ConMapFloat64Uint8 prepopulated with the data from the specified map[Float64]Uint8.

func (*ConMapFloat64Uint8) Delete 

func (cm *ConMapFloat64Uint8) Delete(k float64) (uint8, bool)

Delete removes the specified float64 key, returning its uint8 value and a bool indicating whether the delete occurred or not.

func (*ConMapFloat64Uint8) Get 

func (cm *ConMapFloat64Uint8) Get(k float64) uint8

Get gets the uint8 value for the given float64 key.

func (*ConMapFloat64Uint8) GetOK 

func (cm *ConMapFloat64Uint8) GetOK(k float64) (uint8, bool)

GetOK gets the uint8 value for the given float64 key, and a bool indicating whether the key was present or not.

func (*ConMapFloat64Uint8) Len 

func (cm *ConMapFloat64Uint8) Len() int

Get gets the uint8 value for the given float64 key.

func (*ConMapFloat64Uint8) Set 

func (cm *ConMapFloat64Uint8) Set(k float64, v uint8)

Set sets the uint8 value for the specified float64 key.

type ConMapFloat64Uintptr 

type ConMapFloat64Uintptr struct {
	// M is the underlying map[Float64]Uintptr.
	M map[float64]uintptr
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapFloat64Uintptr is a concurrent safe wrapper around a map[Float64]Uintptr.

func NewConMapFloat64Uintptr 

func NewConMapFloat64Uintptr() *ConMapFloat64Uintptr

NewConMapFloat64Uintptr creates a new concurrent safe map storing uintptr values, for float64 keys.

func ToConMapFloat64Uintptr 

func ToConMapFloat64Uintptr(data map[float64]uintptr) *ConMapFloat64Uintptr

ToConMapFloat64Uintptr creates a new ConMapFloat64Uintptr prepopulated with the data from the specified map[Float64]Uintptr.

func (*ConMapFloat64Uintptr) Delete 

func (cm *ConMapFloat64Uintptr) Delete(k float64) (uintptr, bool)

Delete removes the specified float64 key, returning its uintptr value and a bool indicating whether the delete occurred or not.

func (*ConMapFloat64Uintptr) Get 

func (cm *ConMapFloat64Uintptr) Get(k float64) uintptr

Get gets the uintptr value for the given float64 key.

func (*ConMapFloat64Uintptr) GetOK 

func (cm *ConMapFloat64Uintptr) GetOK(k float64) (uintptr, bool)

GetOK gets the uintptr value for the given float64 key, and a bool indicating whether the key was present or not.

func (*ConMapFloat64Uintptr) Len 

func (cm *ConMapFloat64Uintptr) Len() int

Get gets the uintptr value for the given float64 key.

func (*ConMapFloat64Uintptr) Set 

func (cm *ConMapFloat64Uintptr) Set(k float64, v uintptr)

Set sets the uintptr value for the specified float64 key.

type ConMapInt16Bool 

type ConMapInt16Bool struct {
	// M is the underlying map[Int16]Bool.
	M map[int16]bool
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt16Bool is a concurrent safe wrapper around a map[Int16]Bool.

func NewConMapInt16Bool 

func NewConMapInt16Bool() *ConMapInt16Bool

NewConMapInt16Bool creates a new concurrent safe map storing bool values, for int16 keys.

func ToConMapInt16Bool 

func ToConMapInt16Bool(data map[int16]bool) *ConMapInt16Bool

ToConMapInt16Bool creates a new ConMapInt16Bool prepopulated with the data from the specified map[Int16]Bool.

func (*ConMapInt16Bool) Delete 

func (cm *ConMapInt16Bool) Delete(k int16) (bool, bool)

Delete removes the specified int16 key, returning its bool value and a bool indicating whether the delete occurred or not.

func (*ConMapInt16Bool) Get 

func (cm *ConMapInt16Bool) Get(k int16) bool

Get gets the bool value for the given int16 key.

func (*ConMapInt16Bool) GetOK 

func (cm *ConMapInt16Bool) GetOK(k int16) (bool, bool)

GetOK gets the bool value for the given int16 key, and a bool indicating whether the key was present or not.

func (*ConMapInt16Bool) Len 

func (cm *ConMapInt16Bool) Len() int

Get gets the bool value for the given int16 key.

func (*ConMapInt16Bool) Set 

func (cm *ConMapInt16Bool) Set(k int16, v bool)

Set sets the bool value for the specified int16 key.

type ConMapInt16Byte 

type ConMapInt16Byte struct {
	// M is the underlying map[Int16]Byte.
	M map[int16]byte
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt16Byte is a concurrent safe wrapper around a map[Int16]Byte.

func NewConMapInt16Byte 

func NewConMapInt16Byte() *ConMapInt16Byte

NewConMapInt16Byte creates a new concurrent safe map storing byte values, for int16 keys.

func ToConMapInt16Byte 

func ToConMapInt16Byte(data map[int16]byte) *ConMapInt16Byte

ToConMapInt16Byte creates a new ConMapInt16Byte prepopulated with the data from the specified map[Int16]Byte.

func (*ConMapInt16Byte) Delete 

func (cm *ConMapInt16Byte) Delete(k int16) (byte, bool)

Delete removes the specified int16 key, returning its byte value and a bool indicating whether the delete occurred or not.

func (*ConMapInt16Byte) Get 

func (cm *ConMapInt16Byte) Get(k int16) byte

Get gets the byte value for the given int16 key.

func (*ConMapInt16Byte) GetOK 

func (cm *ConMapInt16Byte) GetOK(k int16) (byte, bool)

GetOK gets the byte value for the given int16 key, and a bool indicating whether the key was present or not.

func (*ConMapInt16Byte) Len 

func (cm *ConMapInt16Byte) Len() int

Get gets the byte value for the given int16 key.

func (*ConMapInt16Byte) Set 

func (cm *ConMapInt16Byte) Set(k int16, v byte)

Set sets the byte value for the specified int16 key.

type ConMapInt16Complex128 

type ConMapInt16Complex128 struct {
	// M is the underlying map[Int16]Complex128.
	M map[int16]complex128
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt16Complex128 is a concurrent safe wrapper around a map[Int16]Complex128.

func NewConMapInt16Complex128 

func NewConMapInt16Complex128() *ConMapInt16Complex128

NewConMapInt16Complex128 creates a new concurrent safe map storing complex128 values, for int16 keys.

func ToConMapInt16Complex128 

func ToConMapInt16Complex128(data map[int16]complex128) *ConMapInt16Complex128

ToConMapInt16Complex128 creates a new ConMapInt16Complex128 prepopulated with the data from the specified map[Int16]Complex128.

func (*ConMapInt16Complex128) Delete 

func (cm *ConMapInt16Complex128) Delete(k int16) (complex128, bool)

Delete removes the specified int16 key, returning its complex128 value and a bool indicating whether the delete occurred or not.

func (*ConMapInt16Complex128) Get 

func (cm *ConMapInt16Complex128) Get(k int16) complex128

Get gets the complex128 value for the given int16 key.

func (*ConMapInt16Complex128) GetOK 

func (cm *ConMapInt16Complex128) GetOK(k int16) (complex128, bool)

GetOK gets the complex128 value for the given int16 key, and a bool indicating whether the key was present or not.

func (*ConMapInt16Complex128) Len 

func (cm *ConMapInt16Complex128) Len() int

Get gets the complex128 value for the given int16 key.

func (*ConMapInt16Complex128) Set 

func (cm *ConMapInt16Complex128) Set(k int16, v complex128)

Set sets the complex128 value for the specified int16 key.

type ConMapInt16Complex64 

type ConMapInt16Complex64 struct {
	// M is the underlying map[Int16]Complex64.
	M map[int16]complex64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt16Complex64 is a concurrent safe wrapper around a map[Int16]Complex64.

func NewConMapInt16Complex64 

func NewConMapInt16Complex64() *ConMapInt16Complex64

NewConMapInt16Complex64 creates a new concurrent safe map storing complex64 values, for int16 keys.

func ToConMapInt16Complex64 

func ToConMapInt16Complex64(data map[int16]complex64) *ConMapInt16Complex64

ToConMapInt16Complex64 creates a new ConMapInt16Complex64 prepopulated with the data from the specified map[Int16]Complex64.

func (*ConMapInt16Complex64) Delete 

func (cm *ConMapInt16Complex64) Delete(k int16) (complex64, bool)

Delete removes the specified int16 key, returning its complex64 value and a bool indicating whether the delete occurred or not.

func (*ConMapInt16Complex64) Get 

func (cm *ConMapInt16Complex64) Get(k int16) complex64

Get gets the complex64 value for the given int16 key.

func (*ConMapInt16Complex64) GetOK 

func (cm *ConMapInt16Complex64) GetOK(k int16) (complex64, bool)

GetOK gets the complex64 value for the given int16 key, and a bool indicating whether the key was present or not.

func (*ConMapInt16Complex64) Len 

func (cm *ConMapInt16Complex64) Len() int

Get gets the complex64 value for the given int16 key.

func (*ConMapInt16Complex64) Set 

func (cm *ConMapInt16Complex64) Set(k int16, v complex64)

Set sets the complex64 value for the specified int16 key.

type ConMapInt16Error 

type ConMapInt16Error struct {
	// M is the underlying map[Int16]Error.
	M map[int16]error
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt16Error is a concurrent safe wrapper around a map[Int16]Error.

func NewConMapInt16Error 

func NewConMapInt16Error() *ConMapInt16Error

NewConMapInt16Error creates a new concurrent safe map storing error values, for int16 keys.

func ToConMapInt16Error 

func ToConMapInt16Error(data map[int16]error) *ConMapInt16Error

ToConMapInt16Error creates a new ConMapInt16Error prepopulated with the data from the specified map[Int16]Error.

func (*ConMapInt16Error) Delete 

func (cm *ConMapInt16Error) Delete(k int16) (error, bool)

Delete removes the specified int16 key, returning its error value and a bool indicating whether the delete occurred or not.

func (*ConMapInt16Error) Get 

func (cm *ConMapInt16Error) Get(k int16) error

Get gets the error value for the given int16 key.

func (*ConMapInt16Error) GetOK 

func (cm *ConMapInt16Error) GetOK(k int16) (error, bool)

GetOK gets the error value for the given int16 key, and a bool indicating whether the key was present or not.

func (*ConMapInt16Error) Len 

func (cm *ConMapInt16Error) Len() int

Get gets the error value for the given int16 key.

func (*ConMapInt16Error) Set 

func (cm *ConMapInt16Error) Set(k int16, v error)

Set sets the error value for the specified int16 key.

type ConMapInt16Float32 

type ConMapInt16Float32 struct {
	// M is the underlying map[Int16]Float32.
	M map[int16]float32
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt16Float32 is a concurrent safe wrapper around a map[Int16]Float32.

func NewConMapInt16Float32 

func NewConMapInt16Float32() *ConMapInt16Float32

NewConMapInt16Float32 creates a new concurrent safe map storing float32 values, for int16 keys.

func ToConMapInt16Float32 

func ToConMapInt16Float32(data map[int16]float32) *ConMapInt16Float32

ToConMapInt16Float32 creates a new ConMapInt16Float32 prepopulated with the data from the specified map[Int16]Float32.

func (*ConMapInt16Float32) Delete 

func (cm *ConMapInt16Float32) Delete(k int16) (float32, bool)

Delete removes the specified int16 key, returning its float32 value and a bool indicating whether the delete occurred or not.

func (*ConMapInt16Float32) Get 

func (cm *ConMapInt16Float32) Get(k int16) float32

Get gets the float32 value for the given int16 key.

func (*ConMapInt16Float32) GetOK 

func (cm *ConMapInt16Float32) GetOK(k int16) (float32, bool)

GetOK gets the float32 value for the given int16 key, and a bool indicating whether the key was present or not.

func (*ConMapInt16Float32) Len 

func (cm *ConMapInt16Float32) Len() int

Get gets the float32 value for the given int16 key.

func (*ConMapInt16Float32) Set 

func (cm *ConMapInt16Float32) Set(k int16, v float32)

Set sets the float32 value for the specified int16 key.

type ConMapInt16Float64 

type ConMapInt16Float64 struct {
	// M is the underlying map[Int16]Float64.
	M map[int16]float64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt16Float64 is a concurrent safe wrapper around a map[Int16]Float64.

func NewConMapInt16Float64 

func NewConMapInt16Float64() *ConMapInt16Float64

NewConMapInt16Float64 creates a new concurrent safe map storing float64 values, for int16 keys.

func ToConMapInt16Float64 

func ToConMapInt16Float64(data map[int16]float64) *ConMapInt16Float64

ToConMapInt16Float64 creates a new ConMapInt16Float64 prepopulated with the data from the specified map[Int16]Float64.

func (*ConMapInt16Float64) Delete 

func (cm *ConMapInt16Float64) Delete(k int16) (float64, bool)

Delete removes the specified int16 key, returning its float64 value and a bool indicating whether the delete occurred or not.

func (*ConMapInt16Float64) Get 

func (cm *ConMapInt16Float64) Get(k int16) float64

Get gets the float64 value for the given int16 key.

func (*ConMapInt16Float64) GetOK 

func (cm *ConMapInt16Float64) GetOK(k int16) (float64, bool)

GetOK gets the float64 value for the given int16 key, and a bool indicating whether the key was present or not.

func (*ConMapInt16Float64) Len 

func (cm *ConMapInt16Float64) Len() int

Get gets the float64 value for the given int16 key.

func (*ConMapInt16Float64) Set 

func (cm *ConMapInt16Float64) Set(k int16, v float64)

Set sets the float64 value for the specified int16 key.

type ConMapInt16Int 

type ConMapInt16Int struct {
	// M is the underlying map[Int16]Int.
	M map[int16]int
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt16Int is a concurrent safe wrapper around a map[Int16]Int.

func NewConMapInt16Int 

func NewConMapInt16Int() *ConMapInt16Int

NewConMapInt16Int creates a new concurrent safe map storing int values, for int16 keys.

func ToConMapInt16Int 

func ToConMapInt16Int(data map[int16]int) *ConMapInt16Int

ToConMapInt16Int creates a new ConMapInt16Int prepopulated with the data from the specified map[Int16]Int.

func (*ConMapInt16Int) Delete 

func (cm *ConMapInt16Int) Delete(k int16) (int, bool)

Delete removes the specified int16 key, returning its int value and a bool indicating whether the delete occurred or not.

func (*ConMapInt16Int) Get 

func (cm *ConMapInt16Int) Get(k int16) int

Get gets the int value for the given int16 key.

func (*ConMapInt16Int) GetOK 

func (cm *ConMapInt16Int) GetOK(k int16) (int, bool)

GetOK gets the int value for the given int16 key, and a bool indicating whether the key was present or not.

func (*ConMapInt16Int) Len 

func (cm *ConMapInt16Int) Len() int

Get gets the int value for the given int16 key.

func (*ConMapInt16Int) Set 

func (cm *ConMapInt16Int) Set(k int16, v int)

Set sets the int value for the specified int16 key.

type ConMapInt16Int16 

type ConMapInt16Int16 struct {
	// M is the underlying map[Int16]Int16.
	M map[int16]int16
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt16Int16 is a concurrent safe wrapper around a map[Int16]Int16.

func NewConMapInt16Int16 

func NewConMapInt16Int16() *ConMapInt16Int16

NewConMapInt16Int16 creates a new concurrent safe map storing int16 values, for int16 keys.

func ToConMapInt16Int16 

func ToConMapInt16Int16(data map[int16]int16) *ConMapInt16Int16

ToConMapInt16Int16 creates a new ConMapInt16Int16 prepopulated with the data from the specified map[Int16]Int16.

func (*ConMapInt16Int16) Delete 

func (cm *ConMapInt16Int16) Delete(k int16) (int16, bool)

Delete removes the specified int16 key, returning its int16 value and a bool indicating whether the delete occurred or not.

func (*ConMapInt16Int16) Get 

func (cm *ConMapInt16Int16) Get(k int16) int16

Get gets the int16 value for the given int16 key.

func (*ConMapInt16Int16) GetOK 

func (cm *ConMapInt16Int16) GetOK(k int16) (int16, bool)

GetOK gets the int16 value for the given int16 key, and a bool indicating whether the key was present or not.

func (*ConMapInt16Int16) Len 

func (cm *ConMapInt16Int16) Len() int

Get gets the int16 value for the given int16 key.

func (*ConMapInt16Int16) Set 

func (cm *ConMapInt16Int16) Set(k int16, v int16)

Set sets the int16 value for the specified int16 key.

type ConMapInt16Int32 

type ConMapInt16Int32 struct {
	// M is the underlying map[Int16]Int32.
	M map[int16]int32
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt16Int32 is a concurrent safe wrapper around a map[Int16]Int32.

func NewConMapInt16Int32 

func NewConMapInt16Int32() *ConMapInt16Int32

NewConMapInt16Int32 creates a new concurrent safe map storing int32 values, for int16 keys.

func ToConMapInt16Int32 

func ToConMapInt16Int32(data map[int16]int32) *ConMapInt16Int32

ToConMapInt16Int32 creates a new ConMapInt16Int32 prepopulated with the data from the specified map[Int16]Int32.

func (*ConMapInt16Int32) Delete 

func (cm *ConMapInt16Int32) Delete(k int16) (int32, bool)

Delete removes the specified int16 key, returning its int32 value and a bool indicating whether the delete occurred or not.

func (*ConMapInt16Int32) Get 

func (cm *ConMapInt16Int32) Get(k int16) int32

Get gets the int32 value for the given int16 key.

func (*ConMapInt16Int32) GetOK 

func (cm *ConMapInt16Int32) GetOK(k int16) (int32, bool)

GetOK gets the int32 value for the given int16 key, and a bool indicating whether the key was present or not.

func (*ConMapInt16Int32) Len 

func (cm *ConMapInt16Int32) Len() int

Get gets the int32 value for the given int16 key.

func (*ConMapInt16Int32) Set 

func (cm *ConMapInt16Int32) Set(k int16, v int32)

Set sets the int32 value for the specified int16 key.

type ConMapInt16Int64 

type ConMapInt16Int64 struct {
	// M is the underlying map[Int16]Int64.
	M map[int16]int64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt16Int64 is a concurrent safe wrapper around a map[Int16]Int64.

func NewConMapInt16Int64 

func NewConMapInt16Int64() *ConMapInt16Int64

NewConMapInt16Int64 creates a new concurrent safe map storing int64 values, for int16 keys.

func ToConMapInt16Int64 

func ToConMapInt16Int64(data map[int16]int64) *ConMapInt16Int64

ToConMapInt16Int64 creates a new ConMapInt16Int64 prepopulated with the data from the specified map[Int16]Int64.

func (*ConMapInt16Int64) Delete 

func (cm *ConMapInt16Int64) Delete(k int16) (int64, bool)

Delete removes the specified int16 key, returning its int64 value and a bool indicating whether the delete occurred or not.

func (*ConMapInt16Int64) Get 

func (cm *ConMapInt16Int64) Get(k int16) int64

Get gets the int64 value for the given int16 key.

func (*ConMapInt16Int64) GetOK 

func (cm *ConMapInt16Int64) GetOK(k int16) (int64, bool)

GetOK gets the int64 value for the given int16 key, and a bool indicating whether the key was present or not.

func (*ConMapInt16Int64) Len 

func (cm *ConMapInt16Int64) Len() int

Get gets the int64 value for the given int16 key.

func (*ConMapInt16Int64) Set 

func (cm *ConMapInt16Int64) Set(k int16, v int64)

Set sets the int64 value for the specified int16 key.

type ConMapInt16Int8 

type ConMapInt16Int8 struct {
	// M is the underlying map[Int16]Int8.
	M map[int16]int8
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt16Int8 is a concurrent safe wrapper around a map[Int16]Int8.

func NewConMapInt16Int8 

func NewConMapInt16Int8() *ConMapInt16Int8

NewConMapInt16Int8 creates a new concurrent safe map storing int8 values, for int16 keys.

func ToConMapInt16Int8 

func ToConMapInt16Int8(data map[int16]int8) *ConMapInt16Int8

ToConMapInt16Int8 creates a new ConMapInt16Int8 prepopulated with the data from the specified map[Int16]Int8.

func (*ConMapInt16Int8) Delete 

func (cm *ConMapInt16Int8) Delete(k int16) (int8, bool)

Delete removes the specified int16 key, returning its int8 value and a bool indicating whether the delete occurred or not.

func (*ConMapInt16Int8) Get 

func (cm *ConMapInt16Int8) Get(k int16) int8

Get gets the int8 value for the given int16 key.

func (*ConMapInt16Int8) GetOK 

func (cm *ConMapInt16Int8) GetOK(k int16) (int8, bool)

GetOK gets the int8 value for the given int16 key, and a bool indicating whether the key was present or not.

func (*ConMapInt16Int8) Len 

func (cm *ConMapInt16Int8) Len() int

Get gets the int8 value for the given int16 key.

func (*ConMapInt16Int8) Set 

func (cm *ConMapInt16Int8) Set(k int16, v int8)

Set sets the int8 value for the specified int16 key.

type ConMapInt16Rune 

type ConMapInt16Rune struct {
	// M is the underlying map[Int16]Rune.
	M map[int16]rune
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt16Rune is a concurrent safe wrapper around a map[Int16]Rune.

func NewConMapInt16Rune 

func NewConMapInt16Rune() *ConMapInt16Rune

NewConMapInt16Rune creates a new concurrent safe map storing rune values, for int16 keys.

func ToConMapInt16Rune 

func ToConMapInt16Rune(data map[int16]rune) *ConMapInt16Rune

ToConMapInt16Rune creates a new ConMapInt16Rune prepopulated with the data from the specified map[Int16]Rune.

func (*ConMapInt16Rune) Delete 

func (cm *ConMapInt16Rune) Delete(k int16) (rune, bool)

Delete removes the specified int16 key, returning its rune value and a bool indicating whether the delete occurred or not.

func (*ConMapInt16Rune) Get 

func (cm *ConMapInt16Rune) Get(k int16) rune

Get gets the rune value for the given int16 key.

func (*ConMapInt16Rune) GetOK 

func (cm *ConMapInt16Rune) GetOK(k int16) (rune, bool)

GetOK gets the rune value for the given int16 key, and a bool indicating whether the key was present or not.

func (*ConMapInt16Rune) Len 

func (cm *ConMapInt16Rune) Len() int

Get gets the rune value for the given int16 key.

func (*ConMapInt16Rune) Set 

func (cm *ConMapInt16Rune) Set(k int16, v rune)

Set sets the rune value for the specified int16 key.

type ConMapInt16String 

type ConMapInt16String struct {
	// M is the underlying map[Int16]String.
	M map[int16]string
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt16String is a concurrent safe wrapper around a map[Int16]String.

func NewConMapInt16String 

func NewConMapInt16String() *ConMapInt16String

NewConMapInt16String creates a new concurrent safe map storing string values, for int16 keys.

func ToConMapInt16String 

func ToConMapInt16String(data map[int16]string) *ConMapInt16String

ToConMapInt16String creates a new ConMapInt16String prepopulated with the data from the specified map[Int16]String.

func (*ConMapInt16String) Delete 

func (cm *ConMapInt16String) Delete(k int16) (string, bool)

Delete removes the specified int16 key, returning its string value and a bool indicating whether the delete occurred or not.

func (*ConMapInt16String) Get 

func (cm *ConMapInt16String) Get(k int16) string

Get gets the string value for the given int16 key.

func (*ConMapInt16String) GetOK 

func (cm *ConMapInt16String) GetOK(k int16) (string, bool)

GetOK gets the string value for the given int16 key, and a bool indicating whether the key was present or not.

func (*ConMapInt16String) Len 

func (cm *ConMapInt16String) Len() int

Get gets the string value for the given int16 key.

func (*ConMapInt16String) Set 

func (cm *ConMapInt16String) Set(k int16, v string)

Set sets the string value for the specified int16 key.

type ConMapInt16Uint 

type ConMapInt16Uint struct {
	// M is the underlying map[Int16]Uint.
	M map[int16]uint
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt16Uint is a concurrent safe wrapper around a map[Int16]Uint.

func NewConMapInt16Uint 

func NewConMapInt16Uint() *ConMapInt16Uint

NewConMapInt16Uint creates a new concurrent safe map storing uint values, for int16 keys.

func ToConMapInt16Uint 

func ToConMapInt16Uint(data map[int16]uint) *ConMapInt16Uint

ToConMapInt16Uint creates a new ConMapInt16Uint prepopulated with the data from the specified map[Int16]Uint.

func (*ConMapInt16Uint) Delete 

func (cm *ConMapInt16Uint) Delete(k int16) (uint, bool)

Delete removes the specified int16 key, returning its uint value and a bool indicating whether the delete occurred or not.

func (*ConMapInt16Uint) Get 

func (cm *ConMapInt16Uint) Get(k int16) uint

Get gets the uint value for the given int16 key.

func (*ConMapInt16Uint) GetOK 

func (cm *ConMapInt16Uint) GetOK(k int16) (uint, bool)

GetOK gets the uint value for the given int16 key, and a bool indicating whether the key was present or not.

func (*ConMapInt16Uint) Len 

func (cm *ConMapInt16Uint) Len() int

Get gets the uint value for the given int16 key.

func (*ConMapInt16Uint) Set 

func (cm *ConMapInt16Uint) Set(k int16, v uint)

Set sets the uint value for the specified int16 key.

type ConMapInt16Uint16 

type ConMapInt16Uint16 struct {
	// M is the underlying map[Int16]Uint16.
	M map[int16]uint16
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt16Uint16 is a concurrent safe wrapper around a map[Int16]Uint16.

func NewConMapInt16Uint16 

func NewConMapInt16Uint16() *ConMapInt16Uint16

NewConMapInt16Uint16 creates a new concurrent safe map storing uint16 values, for int16 keys.

func ToConMapInt16Uint16 

func ToConMapInt16Uint16(data map[int16]uint16) *ConMapInt16Uint16

ToConMapInt16Uint16 creates a new ConMapInt16Uint16 prepopulated with the data from the specified map[Int16]Uint16.

func (*ConMapInt16Uint16) Delete 

func (cm *ConMapInt16Uint16) Delete(k int16) (uint16, bool)

Delete removes the specified int16 key, returning its uint16 value and a bool indicating whether the delete occurred or not.

func (*ConMapInt16Uint16) Get 

func (cm *ConMapInt16Uint16) Get(k int16) uint16

Get gets the uint16 value for the given int16 key.

func (*ConMapInt16Uint16) GetOK 

func (cm *ConMapInt16Uint16) GetOK(k int16) (uint16, bool)

GetOK gets the uint16 value for the given int16 key, and a bool indicating whether the key was present or not.

func (*ConMapInt16Uint16) Len 

func (cm *ConMapInt16Uint16) Len() int

Get gets the uint16 value for the given int16 key.

func (*ConMapInt16Uint16) Set 

func (cm *ConMapInt16Uint16) Set(k int16, v uint16)

Set sets the uint16 value for the specified int16 key.

type ConMapInt16Uint32 

type ConMapInt16Uint32 struct {
	// M is the underlying map[Int16]Uint32.
	M map[int16]uint32
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt16Uint32 is a concurrent safe wrapper around a map[Int16]Uint32.

func NewConMapInt16Uint32 

func NewConMapInt16Uint32() *ConMapInt16Uint32

NewConMapInt16Uint32 creates a new concurrent safe map storing uint32 values, for int16 keys.

func ToConMapInt16Uint32 

func ToConMapInt16Uint32(data map[int16]uint32) *ConMapInt16Uint32

ToConMapInt16Uint32 creates a new ConMapInt16Uint32 prepopulated with the data from the specified map[Int16]Uint32.

func (*ConMapInt16Uint32) Delete 

func (cm *ConMapInt16Uint32) Delete(k int16) (uint32, bool)

Delete removes the specified int16 key, returning its uint32 value and a bool indicating whether the delete occurred or not.

func (*ConMapInt16Uint32) Get 

func (cm *ConMapInt16Uint32) Get(k int16) uint32

Get gets the uint32 value for the given int16 key.

func (*ConMapInt16Uint32) GetOK 

func (cm *ConMapInt16Uint32) GetOK(k int16) (uint32, bool)

GetOK gets the uint32 value for the given int16 key, and a bool indicating whether the key was present or not.

func (*ConMapInt16Uint32) Len 

func (cm *ConMapInt16Uint32) Len() int

Get gets the uint32 value for the given int16 key.

func (*ConMapInt16Uint32) Set 

func (cm *ConMapInt16Uint32) Set(k int16, v uint32)

Set sets the uint32 value for the specified int16 key.

type ConMapInt16Uint64 

type ConMapInt16Uint64 struct {
	// M is the underlying map[Int16]Uint64.
	M map[int16]uint64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt16Uint64 is a concurrent safe wrapper around a map[Int16]Uint64.

func NewConMapInt16Uint64 

func NewConMapInt16Uint64() *ConMapInt16Uint64

NewConMapInt16Uint64 creates a new concurrent safe map storing uint64 values, for int16 keys.

func ToConMapInt16Uint64 

func ToConMapInt16Uint64(data map[int16]uint64) *ConMapInt16Uint64

ToConMapInt16Uint64 creates a new ConMapInt16Uint64 prepopulated with the data from the specified map[Int16]Uint64.

func (*ConMapInt16Uint64) Delete 

func (cm *ConMapInt16Uint64) Delete(k int16) (uint64, bool)

Delete removes the specified int16 key, returning its uint64 value and a bool indicating whether the delete occurred or not.

func (*ConMapInt16Uint64) Get 

func (cm *ConMapInt16Uint64) Get(k int16) uint64

Get gets the uint64 value for the given int16 key.

func (*ConMapInt16Uint64) GetOK 

func (cm *ConMapInt16Uint64) GetOK(k int16) (uint64, bool)

GetOK gets the uint64 value for the given int16 key, and a bool indicating whether the key was present or not.

func (*ConMapInt16Uint64) Len 

func (cm *ConMapInt16Uint64) Len() int

Get gets the uint64 value for the given int16 key.

func (*ConMapInt16Uint64) Set 

func (cm *ConMapInt16Uint64) Set(k int16, v uint64)

Set sets the uint64 value for the specified int16 key.

type ConMapInt16Uint8 

type ConMapInt16Uint8 struct {
	// M is the underlying map[Int16]Uint8.
	M map[int16]uint8
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt16Uint8 is a concurrent safe wrapper around a map[Int16]Uint8.

func NewConMapInt16Uint8 

func NewConMapInt16Uint8() *ConMapInt16Uint8

NewConMapInt16Uint8 creates a new concurrent safe map storing uint8 values, for int16 keys.

func ToConMapInt16Uint8 

func ToConMapInt16Uint8(data map[int16]uint8) *ConMapInt16Uint8

ToConMapInt16Uint8 creates a new ConMapInt16Uint8 prepopulated with the data from the specified map[Int16]Uint8.

func (*ConMapInt16Uint8) Delete 

func (cm *ConMapInt16Uint8) Delete(k int16) (uint8, bool)

Delete removes the specified int16 key, returning its uint8 value and a bool indicating whether the delete occurred or not.

func (*ConMapInt16Uint8) Get 

func (cm *ConMapInt16Uint8) Get(k int16) uint8

Get gets the uint8 value for the given int16 key.

func (*ConMapInt16Uint8) GetOK 

func (cm *ConMapInt16Uint8) GetOK(k int16) (uint8, bool)

GetOK gets the uint8 value for the given int16 key, and a bool indicating whether the key was present or not.

func (*ConMapInt16Uint8) Len 

func (cm *ConMapInt16Uint8) Len() int

Get gets the uint8 value for the given int16 key.

func (*ConMapInt16Uint8) Set 

func (cm *ConMapInt16Uint8) Set(k int16, v uint8)

Set sets the uint8 value for the specified int16 key.

type ConMapInt16Uintptr 

type ConMapInt16Uintptr struct {
	// M is the underlying map[Int16]Uintptr.
	M map[int16]uintptr
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt16Uintptr is a concurrent safe wrapper around a map[Int16]Uintptr.

func NewConMapInt16Uintptr 

func NewConMapInt16Uintptr() *ConMapInt16Uintptr

NewConMapInt16Uintptr creates a new concurrent safe map storing uintptr values, for int16 keys.

func ToConMapInt16Uintptr 

func ToConMapInt16Uintptr(data map[int16]uintptr) *ConMapInt16Uintptr

ToConMapInt16Uintptr creates a new ConMapInt16Uintptr prepopulated with the data from the specified map[Int16]Uintptr.

func (*ConMapInt16Uintptr) Delete 

func (cm *ConMapInt16Uintptr) Delete(k int16) (uintptr, bool)

Delete removes the specified int16 key, returning its uintptr value and a bool indicating whether the delete occurred or not.

func (*ConMapInt16Uintptr) Get 

func (cm *ConMapInt16Uintptr) Get(k int16) uintptr

Get gets the uintptr value for the given int16 key.

func (*ConMapInt16Uintptr) GetOK 

func (cm *ConMapInt16Uintptr) GetOK(k int16) (uintptr, bool)

GetOK gets the uintptr value for the given int16 key, and a bool indicating whether the key was present or not.

func (*ConMapInt16Uintptr) Len 

func (cm *ConMapInt16Uintptr) Len() int

Get gets the uintptr value for the given int16 key.

func (*ConMapInt16Uintptr) Set 

func (cm *ConMapInt16Uintptr) Set(k int16, v uintptr)

Set sets the uintptr value for the specified int16 key.

type ConMapInt32Bool 

type ConMapInt32Bool struct {
	// M is the underlying map[Int32]Bool.
	M map[int32]bool
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt32Bool is a concurrent safe wrapper around a map[Int32]Bool.

func NewConMapInt32Bool 

func NewConMapInt32Bool() *ConMapInt32Bool

NewConMapInt32Bool creates a new concurrent safe map storing bool values, for int32 keys.

func ToConMapInt32Bool 

func ToConMapInt32Bool(data map[int32]bool) *ConMapInt32Bool

ToConMapInt32Bool creates a new ConMapInt32Bool prepopulated with the data from the specified map[Int32]Bool.

func (*ConMapInt32Bool) Delete 

func (cm *ConMapInt32Bool) Delete(k int32) (bool, bool)

Delete removes the specified int32 key, returning its bool value and a bool indicating whether the delete occurred or not.

func (*ConMapInt32Bool) Get 

func (cm *ConMapInt32Bool) Get(k int32) bool

Get gets the bool value for the given int32 key.

func (*ConMapInt32Bool) GetOK 

func (cm *ConMapInt32Bool) GetOK(k int32) (bool, bool)

GetOK gets the bool value for the given int32 key, and a bool indicating whether the key was present or not.

func (*ConMapInt32Bool) Len 

func (cm *ConMapInt32Bool) Len() int

Get gets the bool value for the given int32 key.

func (*ConMapInt32Bool) Set 

func (cm *ConMapInt32Bool) Set(k int32, v bool)

Set sets the bool value for the specified int32 key.

type ConMapInt32Byte 

type ConMapInt32Byte struct {
	// M is the underlying map[Int32]Byte.
	M map[int32]byte
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt32Byte is a concurrent safe wrapper around a map[Int32]Byte.

func NewConMapInt32Byte 

func NewConMapInt32Byte() *ConMapInt32Byte

NewConMapInt32Byte creates a new concurrent safe map storing byte values, for int32 keys.

func ToConMapInt32Byte 

func ToConMapInt32Byte(data map[int32]byte) *ConMapInt32Byte

ToConMapInt32Byte creates a new ConMapInt32Byte prepopulated with the data from the specified map[Int32]Byte.

func (*ConMapInt32Byte) Delete 

func (cm *ConMapInt32Byte) Delete(k int32) (byte, bool)

Delete removes the specified int32 key, returning its byte value and a bool indicating whether the delete occurred or not.

func (*ConMapInt32Byte) Get 

func (cm *ConMapInt32Byte) Get(k int32) byte

Get gets the byte value for the given int32 key.

func (*ConMapInt32Byte) GetOK 

func (cm *ConMapInt32Byte) GetOK(k int32) (byte, bool)

GetOK gets the byte value for the given int32 key, and a bool indicating whether the key was present or not.

func (*ConMapInt32Byte) Len 

func (cm *ConMapInt32Byte) Len() int

Get gets the byte value for the given int32 key.

func (*ConMapInt32Byte) Set 

func (cm *ConMapInt32Byte) Set(k int32, v byte)

Set sets the byte value for the specified int32 key.

type ConMapInt32Complex128 

type ConMapInt32Complex128 struct {
	// M is the underlying map[Int32]Complex128.
	M map[int32]complex128
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt32Complex128 is a concurrent safe wrapper around a map[Int32]Complex128.

func NewConMapInt32Complex128 

func NewConMapInt32Complex128() *ConMapInt32Complex128

NewConMapInt32Complex128 creates a new concurrent safe map storing complex128 values, for int32 keys.

func ToConMapInt32Complex128 

func ToConMapInt32Complex128(data map[int32]complex128) *ConMapInt32Complex128

ToConMapInt32Complex128 creates a new ConMapInt32Complex128 prepopulated with the data from the specified map[Int32]Complex128.

func (*ConMapInt32Complex128) Delete 

func (cm *ConMapInt32Complex128) Delete(k int32) (complex128, bool)

Delete removes the specified int32 key, returning its complex128 value and a bool indicating whether the delete occurred or not.

func (*ConMapInt32Complex128) Get 

func (cm *ConMapInt32Complex128) Get(k int32) complex128

Get gets the complex128 value for the given int32 key.

func (*ConMapInt32Complex128) GetOK 

func (cm *ConMapInt32Complex128) GetOK(k int32) (complex128, bool)

GetOK gets the complex128 value for the given int32 key, and a bool indicating whether the key was present or not.

func (*ConMapInt32Complex128) Len 

func (cm *ConMapInt32Complex128) Len() int

Get gets the complex128 value for the given int32 key.

func (*ConMapInt32Complex128) Set 

func (cm *ConMapInt32Complex128) Set(k int32, v complex128)

Set sets the complex128 value for the specified int32 key.

type ConMapInt32Complex64 

type ConMapInt32Complex64 struct {
	// M is the underlying map[Int32]Complex64.
	M map[int32]complex64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt32Complex64 is a concurrent safe wrapper around a map[Int32]Complex64.

func NewConMapInt32Complex64 

func NewConMapInt32Complex64() *ConMapInt32Complex64

NewConMapInt32Complex64 creates a new concurrent safe map storing complex64 values, for int32 keys.

func ToConMapInt32Complex64 

func ToConMapInt32Complex64(data map[int32]complex64) *ConMapInt32Complex64

ToConMapInt32Complex64 creates a new ConMapInt32Complex64 prepopulated with the data from the specified map[Int32]Complex64.

func (*ConMapInt32Complex64) Delete 

func (cm *ConMapInt32Complex64) Delete(k int32) (complex64, bool)

Delete removes the specified int32 key, returning its complex64 value and a bool indicating whether the delete occurred or not.

func (*ConMapInt32Complex64) Get 

func (cm *ConMapInt32Complex64) Get(k int32) complex64

Get gets the complex64 value for the given int32 key.

func (*ConMapInt32Complex64) GetOK 

func (cm *ConMapInt32Complex64) GetOK(k int32) (complex64, bool)

GetOK gets the complex64 value for the given int32 key, and a bool indicating whether the key was present or not.

func (*ConMapInt32Complex64) Len 

func (cm *ConMapInt32Complex64) Len() int

Get gets the complex64 value for the given int32 key.

func (*ConMapInt32Complex64) Set 

func (cm *ConMapInt32Complex64) Set(k int32, v complex64)

Set sets the complex64 value for the specified int32 key.

type ConMapInt32Error 

type ConMapInt32Error struct {
	// M is the underlying map[Int32]Error.
	M map[int32]error
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt32Error is a concurrent safe wrapper around a map[Int32]Error.

func NewConMapInt32Error 

func NewConMapInt32Error() *ConMapInt32Error

NewConMapInt32Error creates a new concurrent safe map storing error values, for int32 keys.

func ToConMapInt32Error 

func ToConMapInt32Error(data map[int32]error) *ConMapInt32Error

ToConMapInt32Error creates a new ConMapInt32Error prepopulated with the data from the specified map[Int32]Error.

func (*ConMapInt32Error) Delete 

func (cm *ConMapInt32Error) Delete(k int32) (error, bool)

Delete removes the specified int32 key, returning its error value and a bool indicating whether the delete occurred or not.

func (*ConMapInt32Error) Get 

func (cm *ConMapInt32Error) Get(k int32) error

Get gets the error value for the given int32 key.

func (*ConMapInt32Error) GetOK 

func (cm *ConMapInt32Error) GetOK(k int32) (error, bool)

GetOK gets the error value for the given int32 key, and a bool indicating whether the key was present or not.

func (*ConMapInt32Error) Len 

func (cm *ConMapInt32Error) Len() int

Get gets the error value for the given int32 key.

func (*ConMapInt32Error) Set 

func (cm *ConMapInt32Error) Set(k int32, v error)

Set sets the error value for the specified int32 key.

type ConMapInt32Float32 

type ConMapInt32Float32 struct {
	// M is the underlying map[Int32]Float32.
	M map[int32]float32
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt32Float32 is a concurrent safe wrapper around a map[Int32]Float32.

func NewConMapInt32Float32 

func NewConMapInt32Float32() *ConMapInt32Float32

NewConMapInt32Float32 creates a new concurrent safe map storing float32 values, for int32 keys.

func ToConMapInt32Float32 

func ToConMapInt32Float32(data map[int32]float32) *ConMapInt32Float32

ToConMapInt32Float32 creates a new ConMapInt32Float32 prepopulated with the data from the specified map[Int32]Float32.

func (*ConMapInt32Float32) Delete 

func (cm *ConMapInt32Float32) Delete(k int32) (float32, bool)

Delete removes the specified int32 key, returning its float32 value and a bool indicating whether the delete occurred or not.

func (*ConMapInt32Float32) Get 

func (cm *ConMapInt32Float32) Get(k int32) float32

Get gets the float32 value for the given int32 key.

func (*ConMapInt32Float32) GetOK 

func (cm *ConMapInt32Float32) GetOK(k int32) (float32, bool)

GetOK gets the float32 value for the given int32 key, and a bool indicating whether the key was present or not.

func (*ConMapInt32Float32) Len 

func (cm *ConMapInt32Float32) Len() int

Get gets the float32 value for the given int32 key.

func (*ConMapInt32Float32) Set 

func (cm *ConMapInt32Float32) Set(k int32, v float32)

Set sets the float32 value for the specified int32 key.

type ConMapInt32Float64 

type ConMapInt32Float64 struct {
	// M is the underlying map[Int32]Float64.
	M map[int32]float64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt32Float64 is a concurrent safe wrapper around a map[Int32]Float64.

func NewConMapInt32Float64 

func NewConMapInt32Float64() *ConMapInt32Float64

NewConMapInt32Float64 creates a new concurrent safe map storing float64 values, for int32 keys.

func ToConMapInt32Float64 

func ToConMapInt32Float64(data map[int32]float64) *ConMapInt32Float64

ToConMapInt32Float64 creates a new ConMapInt32Float64 prepopulated with the data from the specified map[Int32]Float64.

func (*ConMapInt32Float64) Delete 

func (cm *ConMapInt32Float64) Delete(k int32) (float64, bool)

Delete removes the specified int32 key, returning its float64 value and a bool indicating whether the delete occurred or not.

func (*ConMapInt32Float64) Get 

func (cm *ConMapInt32Float64) Get(k int32) float64

Get gets the float64 value for the given int32 key.

func (*ConMapInt32Float64) GetOK 

func (cm *ConMapInt32Float64) GetOK(k int32) (float64, bool)

GetOK gets the float64 value for the given int32 key, and a bool indicating whether the key was present or not.

func (*ConMapInt32Float64) Len 

func (cm *ConMapInt32Float64) Len() int

Get gets the float64 value for the given int32 key.

func (*ConMapInt32Float64) Set 

func (cm *ConMapInt32Float64) Set(k int32, v float64)

Set sets the float64 value for the specified int32 key.

type ConMapInt32Int 

type ConMapInt32Int struct {
	// M is the underlying map[Int32]Int.
	M map[int32]int
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt32Int is a concurrent safe wrapper around a map[Int32]Int.

func NewConMapInt32Int 

func NewConMapInt32Int() *ConMapInt32Int

NewConMapInt32Int creates a new concurrent safe map storing int values, for int32 keys.

func ToConMapInt32Int 

func ToConMapInt32Int(data map[int32]int) *ConMapInt32Int

ToConMapInt32Int creates a new ConMapInt32Int prepopulated with the data from the specified map[Int32]Int.

func (*ConMapInt32Int) Delete 

func (cm *ConMapInt32Int) Delete(k int32) (int, bool)

Delete removes the specified int32 key, returning its int value and a bool indicating whether the delete occurred or not.

func (*ConMapInt32Int) Get 

func (cm *ConMapInt32Int) Get(k int32) int

Get gets the int value for the given int32 key.

func (*ConMapInt32Int) GetOK 

func (cm *ConMapInt32Int) GetOK(k int32) (int, bool)

GetOK gets the int value for the given int32 key, and a bool indicating whether the key was present or not.

func (*ConMapInt32Int) Len 

func (cm *ConMapInt32Int) Len() int

Get gets the int value for the given int32 key.

func (*ConMapInt32Int) Set 

func (cm *ConMapInt32Int) Set(k int32, v int)

Set sets the int value for the specified int32 key.

type ConMapInt32Int16 

type ConMapInt32Int16 struct {
	// M is the underlying map[Int32]Int16.
	M map[int32]int16
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt32Int16 is a concurrent safe wrapper around a map[Int32]Int16.

func NewConMapInt32Int16 

func NewConMapInt32Int16() *ConMapInt32Int16

NewConMapInt32Int16 creates a new concurrent safe map storing int16 values, for int32 keys.

func ToConMapInt32Int16 

func ToConMapInt32Int16(data map[int32]int16) *ConMapInt32Int16

ToConMapInt32Int16 creates a new ConMapInt32Int16 prepopulated with the data from the specified map[Int32]Int16.

func (*ConMapInt32Int16) Delete 

func (cm *ConMapInt32Int16) Delete(k int32) (int16, bool)

Delete removes the specified int32 key, returning its int16 value and a bool indicating whether the delete occurred or not.

func (*ConMapInt32Int16) Get 

func (cm *ConMapInt32Int16) Get(k int32) int16

Get gets the int16 value for the given int32 key.

func (*ConMapInt32Int16) GetOK 

func (cm *ConMapInt32Int16) GetOK(k int32) (int16, bool)

GetOK gets the int16 value for the given int32 key, and a bool indicating whether the key was present or not.

func (*ConMapInt32Int16) Len 

func (cm *ConMapInt32Int16) Len() int

Get gets the int16 value for the given int32 key.

func (*ConMapInt32Int16) Set 

func (cm *ConMapInt32Int16) Set(k int32, v int16)

Set sets the int16 value for the specified int32 key.

type ConMapInt32Int32 

type ConMapInt32Int32 struct {
	// M is the underlying map[Int32]Int32.
	M map[int32]int32
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt32Int32 is a concurrent safe wrapper around a map[Int32]Int32.

func NewConMapInt32Int32 

func NewConMapInt32Int32() *ConMapInt32Int32

NewConMapInt32Int32 creates a new concurrent safe map storing int32 values, for int32 keys.

func ToConMapInt32Int32 

func ToConMapInt32Int32(data map[int32]int32) *ConMapInt32Int32

ToConMapInt32Int32 creates a new ConMapInt32Int32 prepopulated with the data from the specified map[Int32]Int32.

func (*ConMapInt32Int32) Delete 

func (cm *ConMapInt32Int32) Delete(k int32) (int32, bool)

Delete removes the specified int32 key, returning its int32 value and a bool indicating whether the delete occurred or not.

func (*ConMapInt32Int32) Get 

func (cm *ConMapInt32Int32) Get(k int32) int32

Get gets the int32 value for the given int32 key.

func (*ConMapInt32Int32) GetOK 

func (cm *ConMapInt32Int32) GetOK(k int32) (int32, bool)

GetOK gets the int32 value for the given int32 key, and a bool indicating whether the key was present or not.

func (*ConMapInt32Int32) Len 

func (cm *ConMapInt32Int32) Len() int

Get gets the int32 value for the given int32 key.

func (*ConMapInt32Int32) Set 

func (cm *ConMapInt32Int32) Set(k int32, v int32)

Set sets the int32 value for the specified int32 key.

type ConMapInt32Int64 

type ConMapInt32Int64 struct {
	// M is the underlying map[Int32]Int64.
	M map[int32]int64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt32Int64 is a concurrent safe wrapper around a map[Int32]Int64.

func NewConMapInt32Int64 

func NewConMapInt32Int64() *ConMapInt32Int64

NewConMapInt32Int64 creates a new concurrent safe map storing int64 values, for int32 keys.

func ToConMapInt32Int64 

func ToConMapInt32Int64(data map[int32]int64) *ConMapInt32Int64

ToConMapInt32Int64 creates a new ConMapInt32Int64 prepopulated with the data from the specified map[Int32]Int64.

func (*ConMapInt32Int64) Delete 

func (cm *ConMapInt32Int64) Delete(k int32) (int64, bool)

Delete removes the specified int32 key, returning its int64 value and a bool indicating whether the delete occurred or not.

func (*ConMapInt32Int64) Get 

func (cm *ConMapInt32Int64) Get(k int32) int64

Get gets the int64 value for the given int32 key.

func (*ConMapInt32Int64) GetOK 

func (cm *ConMapInt32Int64) GetOK(k int32) (int64, bool)

GetOK gets the int64 value for the given int32 key, and a bool indicating whether the key was present or not.

func (*ConMapInt32Int64) Len 

func (cm *ConMapInt32Int64) Len() int

Get gets the int64 value for the given int32 key.

func (*ConMapInt32Int64) Set 

func (cm *ConMapInt32Int64) Set(k int32, v int64)

Set sets the int64 value for the specified int32 key.

type ConMapInt32Int8 

type ConMapInt32Int8 struct {
	// M is the underlying map[Int32]Int8.
	M map[int32]int8
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt32Int8 is a concurrent safe wrapper around a map[Int32]Int8.

func NewConMapInt32Int8 

func NewConMapInt32Int8() *ConMapInt32Int8

NewConMapInt32Int8 creates a new concurrent safe map storing int8 values, for int32 keys.

func ToConMapInt32Int8 

func ToConMapInt32Int8(data map[int32]int8) *ConMapInt32Int8

ToConMapInt32Int8 creates a new ConMapInt32Int8 prepopulated with the data from the specified map[Int32]Int8.

func (*ConMapInt32Int8) Delete 

func (cm *ConMapInt32Int8) Delete(k int32) (int8, bool)

Delete removes the specified int32 key, returning its int8 value and a bool indicating whether the delete occurred or not.

func (*ConMapInt32Int8) Get 

func (cm *ConMapInt32Int8) Get(k int32) int8

Get gets the int8 value for the given int32 key.

func (*ConMapInt32Int8) GetOK 

func (cm *ConMapInt32Int8) GetOK(k int32) (int8, bool)

GetOK gets the int8 value for the given int32 key, and a bool indicating whether the key was present or not.

func (*ConMapInt32Int8) Len 

func (cm *ConMapInt32Int8) Len() int

Get gets the int8 value for the given int32 key.

func (*ConMapInt32Int8) Set 

func (cm *ConMapInt32Int8) Set(k int32, v int8)

Set sets the int8 value for the specified int32 key.

type ConMapInt32Rune 

type ConMapInt32Rune struct {
	// M is the underlying map[Int32]Rune.
	M map[int32]rune
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt32Rune is a concurrent safe wrapper around a map[Int32]Rune.

func NewConMapInt32Rune 

func NewConMapInt32Rune() *ConMapInt32Rune

NewConMapInt32Rune creates a new concurrent safe map storing rune values, for int32 keys.

func ToConMapInt32Rune 

func ToConMapInt32Rune(data map[int32]rune) *ConMapInt32Rune

ToConMapInt32Rune creates a new ConMapInt32Rune prepopulated with the data from the specified map[Int32]Rune.

func (*ConMapInt32Rune) Delete 

func (cm *ConMapInt32Rune) Delete(k int32) (rune, bool)

Delete removes the specified int32 key, returning its rune value and a bool indicating whether the delete occurred or not.

func (*ConMapInt32Rune) Get 

func (cm *ConMapInt32Rune) Get(k int32) rune

Get gets the rune value for the given int32 key.

func (*ConMapInt32Rune) GetOK 

func (cm *ConMapInt32Rune) GetOK(k int32) (rune, bool)

GetOK gets the rune value for the given int32 key, and a bool indicating whether the key was present or not.

func (*ConMapInt32Rune) Len 

func (cm *ConMapInt32Rune) Len() int

Get gets the rune value for the given int32 key.

func (*ConMapInt32Rune) Set 

func (cm *ConMapInt32Rune) Set(k int32, v rune)

Set sets the rune value for the specified int32 key.

type ConMapInt32String 

type ConMapInt32String struct {
	// M is the underlying map[Int32]String.
	M map[int32]string
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt32String is a concurrent safe wrapper around a map[Int32]String.

func NewConMapInt32String 

func NewConMapInt32String() *ConMapInt32String

NewConMapInt32String creates a new concurrent safe map storing string values, for int32 keys.

func ToConMapInt32String 

func ToConMapInt32String(data map[int32]string) *ConMapInt32String

ToConMapInt32String creates a new ConMapInt32String prepopulated with the data from the specified map[Int32]String.

func (*ConMapInt32String) Delete 

func (cm *ConMapInt32String) Delete(k int32) (string, bool)

Delete removes the specified int32 key, returning its string value and a bool indicating whether the delete occurred or not.

func (*ConMapInt32String) Get 

func (cm *ConMapInt32String) Get(k int32) string

Get gets the string value for the given int32 key.

func (*ConMapInt32String) GetOK 

func (cm *ConMapInt32String) GetOK(k int32) (string, bool)

GetOK gets the string value for the given int32 key, and a bool indicating whether the key was present or not.

func (*ConMapInt32String) Len 

func (cm *ConMapInt32String) Len() int

Get gets the string value for the given int32 key.

func (*ConMapInt32String) Set 

func (cm *ConMapInt32String) Set(k int32, v string)

Set sets the string value for the specified int32 key.

type ConMapInt32Uint 

type ConMapInt32Uint struct {
	// M is the underlying map[Int32]Uint.
	M map[int32]uint
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt32Uint is a concurrent safe wrapper around a map[Int32]Uint.

func NewConMapInt32Uint 

func NewConMapInt32Uint() *ConMapInt32Uint

NewConMapInt32Uint creates a new concurrent safe map storing uint values, for int32 keys.

func ToConMapInt32Uint 

func ToConMapInt32Uint(data map[int32]uint) *ConMapInt32Uint

ToConMapInt32Uint creates a new ConMapInt32Uint prepopulated with the data from the specified map[Int32]Uint.

func (*ConMapInt32Uint) Delete 

func (cm *ConMapInt32Uint) Delete(k int32) (uint, bool)

Delete removes the specified int32 key, returning its uint value and a bool indicating whether the delete occurred or not.

func (*ConMapInt32Uint) Get 

func (cm *ConMapInt32Uint) Get(k int32) uint

Get gets the uint value for the given int32 key.

func (*ConMapInt32Uint) GetOK 

func (cm *ConMapInt32Uint) GetOK(k int32) (uint, bool)

GetOK gets the uint value for the given int32 key, and a bool indicating whether the key was present or not.

func (*ConMapInt32Uint) Len 

func (cm *ConMapInt32Uint) Len() int

Get gets the uint value for the given int32 key.

func (*ConMapInt32Uint) Set 

func (cm *ConMapInt32Uint) Set(k int32, v uint)

Set sets the uint value for the specified int32 key.

type ConMapInt32Uint16 

type ConMapInt32Uint16 struct {
	// M is the underlying map[Int32]Uint16.
	M map[int32]uint16
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt32Uint16 is a concurrent safe wrapper around a map[Int32]Uint16.

func NewConMapInt32Uint16 

func NewConMapInt32Uint16() *ConMapInt32Uint16

NewConMapInt32Uint16 creates a new concurrent safe map storing uint16 values, for int32 keys.

func ToConMapInt32Uint16 

func ToConMapInt32Uint16(data map[int32]uint16) *ConMapInt32Uint16

ToConMapInt32Uint16 creates a new ConMapInt32Uint16 prepopulated with the data from the specified map[Int32]Uint16.

func (*ConMapInt32Uint16) Delete 

func (cm *ConMapInt32Uint16) Delete(k int32) (uint16, bool)

Delete removes the specified int32 key, returning its uint16 value and a bool indicating whether the delete occurred or not.

func (*ConMapInt32Uint16) Get 

func (cm *ConMapInt32Uint16) Get(k int32) uint16

Get gets the uint16 value for the given int32 key.

func (*ConMapInt32Uint16) GetOK 

func (cm *ConMapInt32Uint16) GetOK(k int32) (uint16, bool)

GetOK gets the uint16 value for the given int32 key, and a bool indicating whether the key was present or not.

func (*ConMapInt32Uint16) Len 

func (cm *ConMapInt32Uint16) Len() int

Get gets the uint16 value for the given int32 key.

func (*ConMapInt32Uint16) Set 

func (cm *ConMapInt32Uint16) Set(k int32, v uint16)

Set sets the uint16 value for the specified int32 key.

type ConMapInt32Uint32 

type ConMapInt32Uint32 struct {
	// M is the underlying map[Int32]Uint32.
	M map[int32]uint32
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt32Uint32 is a concurrent safe wrapper around a map[Int32]Uint32.

func NewConMapInt32Uint32 

func NewConMapInt32Uint32() *ConMapInt32Uint32

NewConMapInt32Uint32 creates a new concurrent safe map storing uint32 values, for int32 keys.

func ToConMapInt32Uint32 

func ToConMapInt32Uint32(data map[int32]uint32) *ConMapInt32Uint32

ToConMapInt32Uint32 creates a new ConMapInt32Uint32 prepopulated with the data from the specified map[Int32]Uint32.

func (*ConMapInt32Uint32) Delete 

func (cm *ConMapInt32Uint32) Delete(k int32) (uint32, bool)

Delete removes the specified int32 key, returning its uint32 value and a bool indicating whether the delete occurred or not.

func (*ConMapInt32Uint32) Get 

func (cm *ConMapInt32Uint32) Get(k int32) uint32

Get gets the uint32 value for the given int32 key.

func (*ConMapInt32Uint32) GetOK 

func (cm *ConMapInt32Uint32) GetOK(k int32) (uint32, bool)

GetOK gets the uint32 value for the given int32 key, and a bool indicating whether the key was present or not.

func (*ConMapInt32Uint32) Len 

func (cm *ConMapInt32Uint32) Len() int

Get gets the uint32 value for the given int32 key.

func (*ConMapInt32Uint32) Set 

func (cm *ConMapInt32Uint32) Set(k int32, v uint32)

Set sets the uint32 value for the specified int32 key.

type ConMapInt32Uint64 

type ConMapInt32Uint64 struct {
	// M is the underlying map[Int32]Uint64.
	M map[int32]uint64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt32Uint64 is a concurrent safe wrapper around a map[Int32]Uint64.

func NewConMapInt32Uint64 

func NewConMapInt32Uint64() *ConMapInt32Uint64

NewConMapInt32Uint64 creates a new concurrent safe map storing uint64 values, for int32 keys.

func ToConMapInt32Uint64 

func ToConMapInt32Uint64(data map[int32]uint64) *ConMapInt32Uint64

ToConMapInt32Uint64 creates a new ConMapInt32Uint64 prepopulated with the data from the specified map[Int32]Uint64.

func (*ConMapInt32Uint64) Delete 

func (cm *ConMapInt32Uint64) Delete(k int32) (uint64, bool)

Delete removes the specified int32 key, returning its uint64 value and a bool indicating whether the delete occurred or not.

func (*ConMapInt32Uint64) Get 

func (cm *ConMapInt32Uint64) Get(k int32) uint64

Get gets the uint64 value for the given int32 key.

func (*ConMapInt32Uint64) GetOK 

func (cm *ConMapInt32Uint64) GetOK(k int32) (uint64, bool)

GetOK gets the uint64 value for the given int32 key, and a bool indicating whether the key was present or not.

func (*ConMapInt32Uint64) Len 

func (cm *ConMapInt32Uint64) Len() int

Get gets the uint64 value for the given int32 key.

func (*ConMapInt32Uint64) Set 

func (cm *ConMapInt32Uint64) Set(k int32, v uint64)

Set sets the uint64 value for the specified int32 key.

type ConMapInt32Uint8 

type ConMapInt32Uint8 struct {
	// M is the underlying map[Int32]Uint8.
	M map[int32]uint8
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt32Uint8 is a concurrent safe wrapper around a map[Int32]Uint8.

func NewConMapInt32Uint8 

func NewConMapInt32Uint8() *ConMapInt32Uint8

NewConMapInt32Uint8 creates a new concurrent safe map storing uint8 values, for int32 keys.

func ToConMapInt32Uint8 

func ToConMapInt32Uint8(data map[int32]uint8) *ConMapInt32Uint8

ToConMapInt32Uint8 creates a new ConMapInt32Uint8 prepopulated with the data from the specified map[Int32]Uint8.

func (*ConMapInt32Uint8) Delete 

func (cm *ConMapInt32Uint8) Delete(k int32) (uint8, bool)

Delete removes the specified int32 key, returning its uint8 value and a bool indicating whether the delete occurred or not.

func (*ConMapInt32Uint8) Get 

func (cm *ConMapInt32Uint8) Get(k int32) uint8

Get gets the uint8 value for the given int32 key.

func (*ConMapInt32Uint8) GetOK 

func (cm *ConMapInt32Uint8) GetOK(k int32) (uint8, bool)

GetOK gets the uint8 value for the given int32 key, and a bool indicating whether the key was present or not.

func (*ConMapInt32Uint8) Len 

func (cm *ConMapInt32Uint8) Len() int

Get gets the uint8 value for the given int32 key.

func (*ConMapInt32Uint8) Set 

func (cm *ConMapInt32Uint8) Set(k int32, v uint8)

Set sets the uint8 value for the specified int32 key.

type ConMapInt32Uintptr 

type ConMapInt32Uintptr struct {
	// M is the underlying map[Int32]Uintptr.
	M map[int32]uintptr
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt32Uintptr is a concurrent safe wrapper around a map[Int32]Uintptr.

func NewConMapInt32Uintptr 

func NewConMapInt32Uintptr() *ConMapInt32Uintptr

NewConMapInt32Uintptr creates a new concurrent safe map storing uintptr values, for int32 keys.

func ToConMapInt32Uintptr 

func ToConMapInt32Uintptr(data map[int32]uintptr) *ConMapInt32Uintptr

ToConMapInt32Uintptr creates a new ConMapInt32Uintptr prepopulated with the data from the specified map[Int32]Uintptr.

func (*ConMapInt32Uintptr) Delete 

func (cm *ConMapInt32Uintptr) Delete(k int32) (uintptr, bool)

Delete removes the specified int32 key, returning its uintptr value and a bool indicating whether the delete occurred or not.

func (*ConMapInt32Uintptr) Get 

func (cm *ConMapInt32Uintptr) Get(k int32) uintptr

Get gets the uintptr value for the given int32 key.

func (*ConMapInt32Uintptr) GetOK 

func (cm *ConMapInt32Uintptr) GetOK(k int32) (uintptr, bool)

GetOK gets the uintptr value for the given int32 key, and a bool indicating whether the key was present or not.

func (*ConMapInt32Uintptr) Len 

func (cm *ConMapInt32Uintptr) Len() int

Get gets the uintptr value for the given int32 key.

func (*ConMapInt32Uintptr) Set 

func (cm *ConMapInt32Uintptr) Set(k int32, v uintptr)

Set sets the uintptr value for the specified int32 key.

type ConMapInt64Bool 

type ConMapInt64Bool struct {
	// M is the underlying map[Int64]Bool.
	M map[int64]bool
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt64Bool is a concurrent safe wrapper around a map[Int64]Bool.

func NewConMapInt64Bool 

func NewConMapInt64Bool() *ConMapInt64Bool

NewConMapInt64Bool creates a new concurrent safe map storing bool values, for int64 keys.

func ToConMapInt64Bool 

func ToConMapInt64Bool(data map[int64]bool) *ConMapInt64Bool

ToConMapInt64Bool creates a new ConMapInt64Bool prepopulated with the data from the specified map[Int64]Bool.

func (*ConMapInt64Bool) Delete 

func (cm *ConMapInt64Bool) Delete(k int64) (bool, bool)

Delete removes the specified int64 key, returning its bool value and a bool indicating whether the delete occurred or not.

func (*ConMapInt64Bool) Get 

func (cm *ConMapInt64Bool) Get(k int64) bool

Get gets the bool value for the given int64 key.

func (*ConMapInt64Bool) GetOK 

func (cm *ConMapInt64Bool) GetOK(k int64) (bool, bool)

GetOK gets the bool value for the given int64 key, and a bool indicating whether the key was present or not.

func (*ConMapInt64Bool) Len 

func (cm *ConMapInt64Bool) Len() int

Get gets the bool value for the given int64 key.

func (*ConMapInt64Bool) Set 

func (cm *ConMapInt64Bool) Set(k int64, v bool)

Set sets the bool value for the specified int64 key.

type ConMapInt64Byte 

type ConMapInt64Byte struct {
	// M is the underlying map[Int64]Byte.
	M map[int64]byte
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt64Byte is a concurrent safe wrapper around a map[Int64]Byte.

func NewConMapInt64Byte 

func NewConMapInt64Byte() *ConMapInt64Byte

NewConMapInt64Byte creates a new concurrent safe map storing byte values, for int64 keys.

func ToConMapInt64Byte 

func ToConMapInt64Byte(data map[int64]byte) *ConMapInt64Byte

ToConMapInt64Byte creates a new ConMapInt64Byte prepopulated with the data from the specified map[Int64]Byte.

func (*ConMapInt64Byte) Delete 

func (cm *ConMapInt64Byte) Delete(k int64) (byte, bool)

Delete removes the specified int64 key, returning its byte value and a bool indicating whether the delete occurred or not.

func (*ConMapInt64Byte) Get 

func (cm *ConMapInt64Byte) Get(k int64) byte

Get gets the byte value for the given int64 key.

func (*ConMapInt64Byte) GetOK 

func (cm *ConMapInt64Byte) GetOK(k int64) (byte, bool)

GetOK gets the byte value for the given int64 key, and a bool indicating whether the key was present or not.

func (*ConMapInt64Byte) Len 

func (cm *ConMapInt64Byte) Len() int

Get gets the byte value for the given int64 key.

func (*ConMapInt64Byte) Set 

func (cm *ConMapInt64Byte) Set(k int64, v byte)

Set sets the byte value for the specified int64 key.

type ConMapInt64Complex128 

type ConMapInt64Complex128 struct {
	// M is the underlying map[Int64]Complex128.
	M map[int64]complex128
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt64Complex128 is a concurrent safe wrapper around a map[Int64]Complex128.

func NewConMapInt64Complex128 

func NewConMapInt64Complex128() *ConMapInt64Complex128

NewConMapInt64Complex128 creates a new concurrent safe map storing complex128 values, for int64 keys.

func ToConMapInt64Complex128 

func ToConMapInt64Complex128(data map[int64]complex128) *ConMapInt64Complex128

ToConMapInt64Complex128 creates a new ConMapInt64Complex128 prepopulated with the data from the specified map[Int64]Complex128.

func (*ConMapInt64Complex128) Delete 

func (cm *ConMapInt64Complex128) Delete(k int64) (complex128, bool)

Delete removes the specified int64 key, returning its complex128 value and a bool indicating whether the delete occurred or not.

func (*ConMapInt64Complex128) Get 

func (cm *ConMapInt64Complex128) Get(k int64) complex128

Get gets the complex128 value for the given int64 key.

func (*ConMapInt64Complex128) GetOK 

func (cm *ConMapInt64Complex128) GetOK(k int64) (complex128, bool)

GetOK gets the complex128 value for the given int64 key, and a bool indicating whether the key was present or not.

func (*ConMapInt64Complex128) Len 

func (cm *ConMapInt64Complex128) Len() int

Get gets the complex128 value for the given int64 key.

func (*ConMapInt64Complex128) Set 

func (cm *ConMapInt64Complex128) Set(k int64, v complex128)

Set sets the complex128 value for the specified int64 key.

type ConMapInt64Complex64 

type ConMapInt64Complex64 struct {
	// M is the underlying map[Int64]Complex64.
	M map[int64]complex64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt64Complex64 is a concurrent safe wrapper around a map[Int64]Complex64.

func NewConMapInt64Complex64 

func NewConMapInt64Complex64() *ConMapInt64Complex64

NewConMapInt64Complex64 creates a new concurrent safe map storing complex64 values, for int64 keys.

func ToConMapInt64Complex64 

func ToConMapInt64Complex64(data map[int64]complex64) *ConMapInt64Complex64

ToConMapInt64Complex64 creates a new ConMapInt64Complex64 prepopulated with the data from the specified map[Int64]Complex64.

func (*ConMapInt64Complex64) Delete 

func (cm *ConMapInt64Complex64) Delete(k int64) (complex64, bool)

Delete removes the specified int64 key, returning its complex64 value and a bool indicating whether the delete occurred or not.

func (*ConMapInt64Complex64) Get 

func (cm *ConMapInt64Complex64) Get(k int64) complex64

Get gets the complex64 value for the given int64 key.

func (*ConMapInt64Complex64) GetOK 

func (cm *ConMapInt64Complex64) GetOK(k int64) (complex64, bool)

GetOK gets the complex64 value for the given int64 key, and a bool indicating whether the key was present or not.

func (*ConMapInt64Complex64) Len 

func (cm *ConMapInt64Complex64) Len() int

Get gets the complex64 value for the given int64 key.

func (*ConMapInt64Complex64) Set 

func (cm *ConMapInt64Complex64) Set(k int64, v complex64)

Set sets the complex64 value for the specified int64 key.

type ConMapInt64Error 

type ConMapInt64Error struct {
	// M is the underlying map[Int64]Error.
	M map[int64]error
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt64Error is a concurrent safe wrapper around a map[Int64]Error.

func NewConMapInt64Error 

func NewConMapInt64Error() *ConMapInt64Error

NewConMapInt64Error creates a new concurrent safe map storing error values, for int64 keys.

func ToConMapInt64Error 

func ToConMapInt64Error(data map[int64]error) *ConMapInt64Error

ToConMapInt64Error creates a new ConMapInt64Error prepopulated with the data from the specified map[Int64]Error.

func (*ConMapInt64Error) Delete 

func (cm *ConMapInt64Error) Delete(k int64) (error, bool)

Delete removes the specified int64 key, returning its error value and a bool indicating whether the delete occurred or not.

func (*ConMapInt64Error) Get 

func (cm *ConMapInt64Error) Get(k int64) error

Get gets the error value for the given int64 key.

func (*ConMapInt64Error) GetOK 

func (cm *ConMapInt64Error) GetOK(k int64) (error, bool)

GetOK gets the error value for the given int64 key, and a bool indicating whether the key was present or not.

func (*ConMapInt64Error) Len 

func (cm *ConMapInt64Error) Len() int

Get gets the error value for the given int64 key.

func (*ConMapInt64Error) Set 

func (cm *ConMapInt64Error) Set(k int64, v error)

Set sets the error value for the specified int64 key.

type ConMapInt64Float32 

type ConMapInt64Float32 struct {
	// M is the underlying map[Int64]Float32.
	M map[int64]float32
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt64Float32 is a concurrent safe wrapper around a map[Int64]Float32.

func NewConMapInt64Float32 

func NewConMapInt64Float32() *ConMapInt64Float32

NewConMapInt64Float32 creates a new concurrent safe map storing float32 values, for int64 keys.

func ToConMapInt64Float32 

func ToConMapInt64Float32(data map[int64]float32) *ConMapInt64Float32

ToConMapInt64Float32 creates a new ConMapInt64Float32 prepopulated with the data from the specified map[Int64]Float32.

func (*ConMapInt64Float32) Delete 

func (cm *ConMapInt64Float32) Delete(k int64) (float32, bool)

Delete removes the specified int64 key, returning its float32 value and a bool indicating whether the delete occurred or not.

func (*ConMapInt64Float32) Get 

func (cm *ConMapInt64Float32) Get(k int64) float32

Get gets the float32 value for the given int64 key.

func (*ConMapInt64Float32) GetOK 

func (cm *ConMapInt64Float32) GetOK(k int64) (float32, bool)

GetOK gets the float32 value for the given int64 key, and a bool indicating whether the key was present or not.

func (*ConMapInt64Float32) Len 

func (cm *ConMapInt64Float32) Len() int

Get gets the float32 value for the given int64 key.

func (*ConMapInt64Float32) Set 

func (cm *ConMapInt64Float32) Set(k int64, v float32)

Set sets the float32 value for the specified int64 key.

type ConMapInt64Float64 

type ConMapInt64Float64 struct {
	// M is the underlying map[Int64]Float64.
	M map[int64]float64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt64Float64 is a concurrent safe wrapper around a map[Int64]Float64.

func NewConMapInt64Float64 

func NewConMapInt64Float64() *ConMapInt64Float64

NewConMapInt64Float64 creates a new concurrent safe map storing float64 values, for int64 keys.

func ToConMapInt64Float64 

func ToConMapInt64Float64(data map[int64]float64) *ConMapInt64Float64

ToConMapInt64Float64 creates a new ConMapInt64Float64 prepopulated with the data from the specified map[Int64]Float64.

func (*ConMapInt64Float64) Delete 

func (cm *ConMapInt64Float64) Delete(k int64) (float64, bool)

Delete removes the specified int64 key, returning its float64 value and a bool indicating whether the delete occurred or not.

func (*ConMapInt64Float64) Get 

func (cm *ConMapInt64Float64) Get(k int64) float64

Get gets the float64 value for the given int64 key.

func (*ConMapInt64Float64) GetOK 

func (cm *ConMapInt64Float64) GetOK(k int64) (float64, bool)

GetOK gets the float64 value for the given int64 key, and a bool indicating whether the key was present or not.

func (*ConMapInt64Float64) Len 

func (cm *ConMapInt64Float64) Len() int

Get gets the float64 value for the given int64 key.

func (*ConMapInt64Float64) Set 

func (cm *ConMapInt64Float64) Set(k int64, v float64)

Set sets the float64 value for the specified int64 key.

type ConMapInt64Int 

type ConMapInt64Int struct {
	// M is the underlying map[Int64]Int.
	M map[int64]int
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt64Int is a concurrent safe wrapper around a map[Int64]Int.

func NewConMapInt64Int 

func NewConMapInt64Int() *ConMapInt64Int

NewConMapInt64Int creates a new concurrent safe map storing int values, for int64 keys.

func ToConMapInt64Int 

func ToConMapInt64Int(data map[int64]int) *ConMapInt64Int

ToConMapInt64Int creates a new ConMapInt64Int prepopulated with the data from the specified map[Int64]Int.

func (*ConMapInt64Int) Delete 

func (cm *ConMapInt64Int) Delete(k int64) (int, bool)

Delete removes the specified int64 key, returning its int value and a bool indicating whether the delete occurred or not.

func (*ConMapInt64Int) Get 

func (cm *ConMapInt64Int) Get(k int64) int

Get gets the int value for the given int64 key.

func (*ConMapInt64Int) GetOK 

func (cm *ConMapInt64Int) GetOK(k int64) (int, bool)

GetOK gets the int value for the given int64 key, and a bool indicating whether the key was present or not.

func (*ConMapInt64Int) Len 

func (cm *ConMapInt64Int) Len() int

Get gets the int value for the given int64 key.

func (*ConMapInt64Int) Set 

func (cm *ConMapInt64Int) Set(k int64, v int)

Set sets the int value for the specified int64 key.

type ConMapInt64Int16 

type ConMapInt64Int16 struct {
	// M is the underlying map[Int64]Int16.
	M map[int64]int16
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt64Int16 is a concurrent safe wrapper around a map[Int64]Int16.

func NewConMapInt64Int16 

func NewConMapInt64Int16() *ConMapInt64Int16

NewConMapInt64Int16 creates a new concurrent safe map storing int16 values, for int64 keys.

func ToConMapInt64Int16 

func ToConMapInt64Int16(data map[int64]int16) *ConMapInt64Int16

ToConMapInt64Int16 creates a new ConMapInt64Int16 prepopulated with the data from the specified map[Int64]Int16.

func (*ConMapInt64Int16) Delete 

func (cm *ConMapInt64Int16) Delete(k int64) (int16, bool)

Delete removes the specified int64 key, returning its int16 value and a bool indicating whether the delete occurred or not.

func (*ConMapInt64Int16) Get 

func (cm *ConMapInt64Int16) Get(k int64) int16

Get gets the int16 value for the given int64 key.

func (*ConMapInt64Int16) GetOK 

func (cm *ConMapInt64Int16) GetOK(k int64) (int16, bool)

GetOK gets the int16 value for the given int64 key, and a bool indicating whether the key was present or not.

func (*ConMapInt64Int16) Len 

func (cm *ConMapInt64Int16) Len() int

Get gets the int16 value for the given int64 key.

func (*ConMapInt64Int16) Set 

func (cm *ConMapInt64Int16) Set(k int64, v int16)

Set sets the int16 value for the specified int64 key.

type ConMapInt64Int32 

type ConMapInt64Int32 struct {
	// M is the underlying map[Int64]Int32.
	M map[int64]int32
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt64Int32 is a concurrent safe wrapper around a map[Int64]Int32.

func NewConMapInt64Int32 

func NewConMapInt64Int32() *ConMapInt64Int32

NewConMapInt64Int32 creates a new concurrent safe map storing int32 values, for int64 keys.

func ToConMapInt64Int32 

func ToConMapInt64Int32(data map[int64]int32) *ConMapInt64Int32

ToConMapInt64Int32 creates a new ConMapInt64Int32 prepopulated with the data from the specified map[Int64]Int32.

func (*ConMapInt64Int32) Delete 

func (cm *ConMapInt64Int32) Delete(k int64) (int32, bool)

Delete removes the specified int64 key, returning its int32 value and a bool indicating whether the delete occurred or not.

func (*ConMapInt64Int32) Get 

func (cm *ConMapInt64Int32) Get(k int64) int32

Get gets the int32 value for the given int64 key.

func (*ConMapInt64Int32) GetOK 

func (cm *ConMapInt64Int32) GetOK(k int64) (int32, bool)

GetOK gets the int32 value for the given int64 key, and a bool indicating whether the key was present or not.

func (*ConMapInt64Int32) Len 

func (cm *ConMapInt64Int32) Len() int

Get gets the int32 value for the given int64 key.

func (*ConMapInt64Int32) Set 

func (cm *ConMapInt64Int32) Set(k int64, v int32)

Set sets the int32 value for the specified int64 key.

type ConMapInt64Int64 

type ConMapInt64Int64 struct {
	// M is the underlying map[Int64]Int64.
	M map[int64]int64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt64Int64 is a concurrent safe wrapper around a map[Int64]Int64.

func NewConMapInt64Int64 

func NewConMapInt64Int64() *ConMapInt64Int64

NewConMapInt64Int64 creates a new concurrent safe map storing int64 values, for int64 keys.

func ToConMapInt64Int64 

func ToConMapInt64Int64(data map[int64]int64) *ConMapInt64Int64

ToConMapInt64Int64 creates a new ConMapInt64Int64 prepopulated with the data from the specified map[Int64]Int64.

func (*ConMapInt64Int64) Delete 

func (cm *ConMapInt64Int64) Delete(k int64) (int64, bool)

Delete removes the specified int64 key, returning its int64 value and a bool indicating whether the delete occurred or not.

func (*ConMapInt64Int64) Get 

func (cm *ConMapInt64Int64) Get(k int64) int64

Get gets the int64 value for the given int64 key.

func (*ConMapInt64Int64) GetOK 

func (cm *ConMapInt64Int64) GetOK(k int64) (int64, bool)

GetOK gets the int64 value for the given int64 key, and a bool indicating whether the key was present or not.

func (*ConMapInt64Int64) Len 

func (cm *ConMapInt64Int64) Len() int

Get gets the int64 value for the given int64 key.

func (*ConMapInt64Int64) Set 

func (cm *ConMapInt64Int64) Set(k int64, v int64)

Set sets the int64 value for the specified int64 key.

type ConMapInt64Int8 

type ConMapInt64Int8 struct {
	// M is the underlying map[Int64]Int8.
	M map[int64]int8
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt64Int8 is a concurrent safe wrapper around a map[Int64]Int8.

func NewConMapInt64Int8 

func NewConMapInt64Int8() *ConMapInt64Int8

NewConMapInt64Int8 creates a new concurrent safe map storing int8 values, for int64 keys.

func ToConMapInt64Int8 

func ToConMapInt64Int8(data map[int64]int8) *ConMapInt64Int8

ToConMapInt64Int8 creates a new ConMapInt64Int8 prepopulated with the data from the specified map[Int64]Int8.

func (*ConMapInt64Int8) Delete 

func (cm *ConMapInt64Int8) Delete(k int64) (int8, bool)

Delete removes the specified int64 key, returning its int8 value and a bool indicating whether the delete occurred or not.

func (*ConMapInt64Int8) Get 

func (cm *ConMapInt64Int8) Get(k int64) int8

Get gets the int8 value for the given int64 key.

func (*ConMapInt64Int8) GetOK 

func (cm *ConMapInt64Int8) GetOK(k int64) (int8, bool)

GetOK gets the int8 value for the given int64 key, and a bool indicating whether the key was present or not.

func (*ConMapInt64Int8) Len 

func (cm *ConMapInt64Int8) Len() int

Get gets the int8 value for the given int64 key.

func (*ConMapInt64Int8) Set 

func (cm *ConMapInt64Int8) Set(k int64, v int8)

Set sets the int8 value for the specified int64 key.

type ConMapInt64Rune 

type ConMapInt64Rune struct {
	// M is the underlying map[Int64]Rune.
	M map[int64]rune
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt64Rune is a concurrent safe wrapper around a map[Int64]Rune.

func NewConMapInt64Rune 

func NewConMapInt64Rune() *ConMapInt64Rune

NewConMapInt64Rune creates a new concurrent safe map storing rune values, for int64 keys.

func ToConMapInt64Rune 

func ToConMapInt64Rune(data map[int64]rune) *ConMapInt64Rune

ToConMapInt64Rune creates a new ConMapInt64Rune prepopulated with the data from the specified map[Int64]Rune.

func (*ConMapInt64Rune) Delete 

func (cm *ConMapInt64Rune) Delete(k int64) (rune, bool)

Delete removes the specified int64 key, returning its rune value and a bool indicating whether the delete occurred or not.

func (*ConMapInt64Rune) Get 

func (cm *ConMapInt64Rune) Get(k int64) rune

Get gets the rune value for the given int64 key.

func (*ConMapInt64Rune) GetOK 

func (cm *ConMapInt64Rune) GetOK(k int64) (rune, bool)

GetOK gets the rune value for the given int64 key, and a bool indicating whether the key was present or not.

func (*ConMapInt64Rune) Len 

func (cm *ConMapInt64Rune) Len() int

Get gets the rune value for the given int64 key.

func (*ConMapInt64Rune) Set 

func (cm *ConMapInt64Rune) Set(k int64, v rune)

Set sets the rune value for the specified int64 key.

type ConMapInt64String 

type ConMapInt64String struct {
	// M is the underlying map[Int64]String.
	M map[int64]string
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt64String is a concurrent safe wrapper around a map[Int64]String.

func NewConMapInt64String 

func NewConMapInt64String() *ConMapInt64String

NewConMapInt64String creates a new concurrent safe map storing string values, for int64 keys.

func ToConMapInt64String 

func ToConMapInt64String(data map[int64]string) *ConMapInt64String

ToConMapInt64String creates a new ConMapInt64String prepopulated with the data from the specified map[Int64]String.

func (*ConMapInt64String) Delete 

func (cm *ConMapInt64String) Delete(k int64) (string, bool)

Delete removes the specified int64 key, returning its string value and a bool indicating whether the delete occurred or not.

func (*ConMapInt64String) Get 

func (cm *ConMapInt64String) Get(k int64) string

Get gets the string value for the given int64 key.

func (*ConMapInt64String) GetOK 

func (cm *ConMapInt64String) GetOK(k int64) (string, bool)

GetOK gets the string value for the given int64 key, and a bool indicating whether the key was present or not.

func (*ConMapInt64String) Len 

func (cm *ConMapInt64String) Len() int

Get gets the string value for the given int64 key.

func (*ConMapInt64String) Set 

func (cm *ConMapInt64String) Set(k int64, v string)

Set sets the string value for the specified int64 key.

type ConMapInt64Uint 

type ConMapInt64Uint struct {
	// M is the underlying map[Int64]Uint.
	M map[int64]uint
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt64Uint is a concurrent safe wrapper around a map[Int64]Uint.

func NewConMapInt64Uint 

func NewConMapInt64Uint() *ConMapInt64Uint

NewConMapInt64Uint creates a new concurrent safe map storing uint values, for int64 keys.

func ToConMapInt64Uint 

func ToConMapInt64Uint(data map[int64]uint) *ConMapInt64Uint

ToConMapInt64Uint creates a new ConMapInt64Uint prepopulated with the data from the specified map[Int64]Uint.

func (*ConMapInt64Uint) Delete 

func (cm *ConMapInt64Uint) Delete(k int64) (uint, bool)

Delete removes the specified int64 key, returning its uint value and a bool indicating whether the delete occurred or not.

func (*ConMapInt64Uint) Get 

func (cm *ConMapInt64Uint) Get(k int64) uint

Get gets the uint value for the given int64 key.

func (*ConMapInt64Uint) GetOK 

func (cm *ConMapInt64Uint) GetOK(k int64) (uint, bool)

GetOK gets the uint value for the given int64 key, and a bool indicating whether the key was present or not.

func (*ConMapInt64Uint) Len 

func (cm *ConMapInt64Uint) Len() int

Get gets the uint value for the given int64 key.

func (*ConMapInt64Uint) Set 

func (cm *ConMapInt64Uint) Set(k int64, v uint)

Set sets the uint value for the specified int64 key.

type ConMapInt64Uint16 

type ConMapInt64Uint16 struct {
	// M is the underlying map[Int64]Uint16.
	M map[int64]uint16
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt64Uint16 is a concurrent safe wrapper around a map[Int64]Uint16.

func NewConMapInt64Uint16 

func NewConMapInt64Uint16() *ConMapInt64Uint16

NewConMapInt64Uint16 creates a new concurrent safe map storing uint16 values, for int64 keys.

func ToConMapInt64Uint16 

func ToConMapInt64Uint16(data map[int64]uint16) *ConMapInt64Uint16

ToConMapInt64Uint16 creates a new ConMapInt64Uint16 prepopulated with the data from the specified map[Int64]Uint16.

func (*ConMapInt64Uint16) Delete 

func (cm *ConMapInt64Uint16) Delete(k int64) (uint16, bool)

Delete removes the specified int64 key, returning its uint16 value and a bool indicating whether the delete occurred or not.

func (*ConMapInt64Uint16) Get 

func (cm *ConMapInt64Uint16) Get(k int64) uint16

Get gets the uint16 value for the given int64 key.

func (*ConMapInt64Uint16) GetOK 

func (cm *ConMapInt64Uint16) GetOK(k int64) (uint16, bool)

GetOK gets the uint16 value for the given int64 key, and a bool indicating whether the key was present or not.

func (*ConMapInt64Uint16) Len 

func (cm *ConMapInt64Uint16) Len() int

Get gets the uint16 value for the given int64 key.

func (*ConMapInt64Uint16) Set 

func (cm *ConMapInt64Uint16) Set(k int64, v uint16)

Set sets the uint16 value for the specified int64 key.

type ConMapInt64Uint32 

type ConMapInt64Uint32 struct {
	// M is the underlying map[Int64]Uint32.
	M map[int64]uint32
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt64Uint32 is a concurrent safe wrapper around a map[Int64]Uint32.

func NewConMapInt64Uint32 

func NewConMapInt64Uint32() *ConMapInt64Uint32

NewConMapInt64Uint32 creates a new concurrent safe map storing uint32 values, for int64 keys.

func ToConMapInt64Uint32 

func ToConMapInt64Uint32(data map[int64]uint32) *ConMapInt64Uint32

ToConMapInt64Uint32 creates a new ConMapInt64Uint32 prepopulated with the data from the specified map[Int64]Uint32.

func (*ConMapInt64Uint32) Delete 

func (cm *ConMapInt64Uint32) Delete(k int64) (uint32, bool)

Delete removes the specified int64 key, returning its uint32 value and a bool indicating whether the delete occurred or not.

func (*ConMapInt64Uint32) Get 

func (cm *ConMapInt64Uint32) Get(k int64) uint32

Get gets the uint32 value for the given int64 key.

func (*ConMapInt64Uint32) GetOK 

func (cm *ConMapInt64Uint32) GetOK(k int64) (uint32, bool)

GetOK gets the uint32 value for the given int64 key, and a bool indicating whether the key was present or not.

func (*ConMapInt64Uint32) Len 

func (cm *ConMapInt64Uint32) Len() int

Get gets the uint32 value for the given int64 key.

func (*ConMapInt64Uint32) Set 

func (cm *ConMapInt64Uint32) Set(k int64, v uint32)

Set sets the uint32 value for the specified int64 key.

type ConMapInt64Uint64 

type ConMapInt64Uint64 struct {
	// M is the underlying map[Int64]Uint64.
	M map[int64]uint64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt64Uint64 is a concurrent safe wrapper around a map[Int64]Uint64.

func NewConMapInt64Uint64 

func NewConMapInt64Uint64() *ConMapInt64Uint64

NewConMapInt64Uint64 creates a new concurrent safe map storing uint64 values, for int64 keys.

func ToConMapInt64Uint64 

func ToConMapInt64Uint64(data map[int64]uint64) *ConMapInt64Uint64

ToConMapInt64Uint64 creates a new ConMapInt64Uint64 prepopulated with the data from the specified map[Int64]Uint64.

func (*ConMapInt64Uint64) Delete 

func (cm *ConMapInt64Uint64) Delete(k int64) (uint64, bool)

Delete removes the specified int64 key, returning its uint64 value and a bool indicating whether the delete occurred or not.

func (*ConMapInt64Uint64) Get 

func (cm *ConMapInt64Uint64) Get(k int64) uint64

Get gets the uint64 value for the given int64 key.

func (*ConMapInt64Uint64) GetOK 

func (cm *ConMapInt64Uint64) GetOK(k int64) (uint64, bool)

GetOK gets the uint64 value for the given int64 key, and a bool indicating whether the key was present or not.

func (*ConMapInt64Uint64) Len 

func (cm *ConMapInt64Uint64) Len() int

Get gets the uint64 value for the given int64 key.

func (*ConMapInt64Uint64) Set 

func (cm *ConMapInt64Uint64) Set(k int64, v uint64)

Set sets the uint64 value for the specified int64 key.

type ConMapInt64Uint8 

type ConMapInt64Uint8 struct {
	// M is the underlying map[Int64]Uint8.
	M map[int64]uint8
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt64Uint8 is a concurrent safe wrapper around a map[Int64]Uint8.

func NewConMapInt64Uint8 

func NewConMapInt64Uint8() *ConMapInt64Uint8

NewConMapInt64Uint8 creates a new concurrent safe map storing uint8 values, for int64 keys.

func ToConMapInt64Uint8 

func ToConMapInt64Uint8(data map[int64]uint8) *ConMapInt64Uint8

ToConMapInt64Uint8 creates a new ConMapInt64Uint8 prepopulated with the data from the specified map[Int64]Uint8.

func (*ConMapInt64Uint8) Delete 

func (cm *ConMapInt64Uint8) Delete(k int64) (uint8, bool)

Delete removes the specified int64 key, returning its uint8 value and a bool indicating whether the delete occurred or not.

func (*ConMapInt64Uint8) Get 

func (cm *ConMapInt64Uint8) Get(k int64) uint8

Get gets the uint8 value for the given int64 key.

func (*ConMapInt64Uint8) GetOK 

func (cm *ConMapInt64Uint8) GetOK(k int64) (uint8, bool)

GetOK gets the uint8 value for the given int64 key, and a bool indicating whether the key was present or not.

func (*ConMapInt64Uint8) Len 

func (cm *ConMapInt64Uint8) Len() int

Get gets the uint8 value for the given int64 key.

func (*ConMapInt64Uint8) Set 

func (cm *ConMapInt64Uint8) Set(k int64, v uint8)

Set sets the uint8 value for the specified int64 key.

type ConMapInt64Uintptr 

type ConMapInt64Uintptr struct {
	// M is the underlying map[Int64]Uintptr.
	M map[int64]uintptr
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt64Uintptr is a concurrent safe wrapper around a map[Int64]Uintptr.

func NewConMapInt64Uintptr 

func NewConMapInt64Uintptr() *ConMapInt64Uintptr

NewConMapInt64Uintptr creates a new concurrent safe map storing uintptr values, for int64 keys.

func ToConMapInt64Uintptr 

func ToConMapInt64Uintptr(data map[int64]uintptr) *ConMapInt64Uintptr

ToConMapInt64Uintptr creates a new ConMapInt64Uintptr prepopulated with the data from the specified map[Int64]Uintptr.

func (*ConMapInt64Uintptr) Delete 

func (cm *ConMapInt64Uintptr) Delete(k int64) (uintptr, bool)

Delete removes the specified int64 key, returning its uintptr value and a bool indicating whether the delete occurred or not.

func (*ConMapInt64Uintptr) Get 

func (cm *ConMapInt64Uintptr) Get(k int64) uintptr

Get gets the uintptr value for the given int64 key.

func (*ConMapInt64Uintptr) GetOK 

func (cm *ConMapInt64Uintptr) GetOK(k int64) (uintptr, bool)

GetOK gets the uintptr value for the given int64 key, and a bool indicating whether the key was present or not.

func (*ConMapInt64Uintptr) Len 

func (cm *ConMapInt64Uintptr) Len() int

Get gets the uintptr value for the given int64 key.

func (*ConMapInt64Uintptr) Set 

func (cm *ConMapInt64Uintptr) Set(k int64, v uintptr)

Set sets the uintptr value for the specified int64 key.

type ConMapInt8Bool 

type ConMapInt8Bool struct {
	// M is the underlying map[Int8]Bool.
	M map[int8]bool
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt8Bool is a concurrent safe wrapper around a map[Int8]Bool.

func NewConMapInt8Bool 

func NewConMapInt8Bool() *ConMapInt8Bool

NewConMapInt8Bool creates a new concurrent safe map storing bool values, for int8 keys.

func ToConMapInt8Bool 

func ToConMapInt8Bool(data map[int8]bool) *ConMapInt8Bool

ToConMapInt8Bool creates a new ConMapInt8Bool prepopulated with the data from the specified map[Int8]Bool.

func (*ConMapInt8Bool) Delete 

func (cm *ConMapInt8Bool) Delete(k int8) (bool, bool)

Delete removes the specified int8 key, returning its bool value and a bool indicating whether the delete occurred or not.

func (*ConMapInt8Bool) Get 

func (cm *ConMapInt8Bool) Get(k int8) bool

Get gets the bool value for the given int8 key.

func (*ConMapInt8Bool) GetOK 

func (cm *ConMapInt8Bool) GetOK(k int8) (bool, bool)

GetOK gets the bool value for the given int8 key, and a bool indicating whether the key was present or not.

func (*ConMapInt8Bool) Len 

func (cm *ConMapInt8Bool) Len() int

Get gets the bool value for the given int8 key.

func (*ConMapInt8Bool) Set 

func (cm *ConMapInt8Bool) Set(k int8, v bool)

Set sets the bool value for the specified int8 key.

type ConMapInt8Byte 

type ConMapInt8Byte struct {
	// M is the underlying map[Int8]Byte.
	M map[int8]byte
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt8Byte is a concurrent safe wrapper around a map[Int8]Byte.

func NewConMapInt8Byte 

func NewConMapInt8Byte() *ConMapInt8Byte

NewConMapInt8Byte creates a new concurrent safe map storing byte values, for int8 keys.

func ToConMapInt8Byte 

func ToConMapInt8Byte(data map[int8]byte) *ConMapInt8Byte

ToConMapInt8Byte creates a new ConMapInt8Byte prepopulated with the data from the specified map[Int8]Byte.

func (*ConMapInt8Byte) Delete 

func (cm *ConMapInt8Byte) Delete(k int8) (byte, bool)

Delete removes the specified int8 key, returning its byte value and a bool indicating whether the delete occurred or not.

func (*ConMapInt8Byte) Get 

func (cm *ConMapInt8Byte) Get(k int8) byte

Get gets the byte value for the given int8 key.

func (*ConMapInt8Byte) GetOK 

func (cm *ConMapInt8Byte) GetOK(k int8) (byte, bool)

GetOK gets the byte value for the given int8 key, and a bool indicating whether the key was present or not.

func (*ConMapInt8Byte) Len 

func (cm *ConMapInt8Byte) Len() int

Get gets the byte value for the given int8 key.

func (*ConMapInt8Byte) Set 

func (cm *ConMapInt8Byte) Set(k int8, v byte)

Set sets the byte value for the specified int8 key.

type ConMapInt8Complex128 

type ConMapInt8Complex128 struct {
	// M is the underlying map[Int8]Complex128.
	M map[int8]complex128
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt8Complex128 is a concurrent safe wrapper around a map[Int8]Complex128.

func NewConMapInt8Complex128 

func NewConMapInt8Complex128() *ConMapInt8Complex128

NewConMapInt8Complex128 creates a new concurrent safe map storing complex128 values, for int8 keys.

func ToConMapInt8Complex128 

func ToConMapInt8Complex128(data map[int8]complex128) *ConMapInt8Complex128

ToConMapInt8Complex128 creates a new ConMapInt8Complex128 prepopulated with the data from the specified map[Int8]Complex128.

func (*ConMapInt8Complex128) Delete 

func (cm *ConMapInt8Complex128) Delete(k int8) (complex128, bool)

Delete removes the specified int8 key, returning its complex128 value and a bool indicating whether the delete occurred or not.

func (*ConMapInt8Complex128) Get 

func (cm *ConMapInt8Complex128) Get(k int8) complex128

Get gets the complex128 value for the given int8 key.

func (*ConMapInt8Complex128) GetOK 

func (cm *ConMapInt8Complex128) GetOK(k int8) (complex128, bool)

GetOK gets the complex128 value for the given int8 key, and a bool indicating whether the key was present or not.

func (*ConMapInt8Complex128) Len 

func (cm *ConMapInt8Complex128) Len() int

Get gets the complex128 value for the given int8 key.

func (*ConMapInt8Complex128) Set 

func (cm *ConMapInt8Complex128) Set(k int8, v complex128)

Set sets the complex128 value for the specified int8 key.

type ConMapInt8Complex64 

type ConMapInt8Complex64 struct {
	// M is the underlying map[Int8]Complex64.
	M map[int8]complex64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt8Complex64 is a concurrent safe wrapper around a map[Int8]Complex64.

func NewConMapInt8Complex64 

func NewConMapInt8Complex64() *ConMapInt8Complex64

NewConMapInt8Complex64 creates a new concurrent safe map storing complex64 values, for int8 keys.

func ToConMapInt8Complex64 

func ToConMapInt8Complex64(data map[int8]complex64) *ConMapInt8Complex64

ToConMapInt8Complex64 creates a new ConMapInt8Complex64 prepopulated with the data from the specified map[Int8]Complex64.

func (*ConMapInt8Complex64) Delete 

func (cm *ConMapInt8Complex64) Delete(k int8) (complex64, bool)

Delete removes the specified int8 key, returning its complex64 value and a bool indicating whether the delete occurred or not.

func (*ConMapInt8Complex64) Get 

func (cm *ConMapInt8Complex64) Get(k int8) complex64

Get gets the complex64 value for the given int8 key.

func (*ConMapInt8Complex64) GetOK 

func (cm *ConMapInt8Complex64) GetOK(k int8) (complex64, bool)

GetOK gets the complex64 value for the given int8 key, and a bool indicating whether the key was present or not.

func (*ConMapInt8Complex64) Len 

func (cm *ConMapInt8Complex64) Len() int

Get gets the complex64 value for the given int8 key.

func (*ConMapInt8Complex64) Set 

func (cm *ConMapInt8Complex64) Set(k int8, v complex64)

Set sets the complex64 value for the specified int8 key.

type ConMapInt8Error 

type ConMapInt8Error struct {
	// M is the underlying map[Int8]Error.
	M map[int8]error
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt8Error is a concurrent safe wrapper around a map[Int8]Error.

func NewConMapInt8Error 

func NewConMapInt8Error() *ConMapInt8Error

NewConMapInt8Error creates a new concurrent safe map storing error values, for int8 keys.

func ToConMapInt8Error 

func ToConMapInt8Error(data map[int8]error) *ConMapInt8Error

ToConMapInt8Error creates a new ConMapInt8Error prepopulated with the data from the specified map[Int8]Error.

func (*ConMapInt8Error) Delete 

func (cm *ConMapInt8Error) Delete(k int8) (error, bool)

Delete removes the specified int8 key, returning its error value and a bool indicating whether the delete occurred or not.

func (*ConMapInt8Error) Get 

func (cm *ConMapInt8Error) Get(k int8) error

Get gets the error value for the given int8 key.

func (*ConMapInt8Error) GetOK 

func (cm *ConMapInt8Error) GetOK(k int8) (error, bool)

GetOK gets the error value for the given int8 key, and a bool indicating whether the key was present or not.

func (*ConMapInt8Error) Len 

func (cm *ConMapInt8Error) Len() int

Get gets the error value for the given int8 key.

func (*ConMapInt8Error) Set 

func (cm *ConMapInt8Error) Set(k int8, v error)

Set sets the error value for the specified int8 key.

type ConMapInt8Float32 

type ConMapInt8Float32 struct {
	// M is the underlying map[Int8]Float32.
	M map[int8]float32
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt8Float32 is a concurrent safe wrapper around a map[Int8]Float32.

func NewConMapInt8Float32 

func NewConMapInt8Float32() *ConMapInt8Float32

NewConMapInt8Float32 creates a new concurrent safe map storing float32 values, for int8 keys.

func ToConMapInt8Float32 

func ToConMapInt8Float32(data map[int8]float32) *ConMapInt8Float32

ToConMapInt8Float32 creates a new ConMapInt8Float32 prepopulated with the data from the specified map[Int8]Float32.

func (*ConMapInt8Float32) Delete 

func (cm *ConMapInt8Float32) Delete(k int8) (float32, bool)

Delete removes the specified int8 key, returning its float32 value and a bool indicating whether the delete occurred or not.

func (*ConMapInt8Float32) Get 

func (cm *ConMapInt8Float32) Get(k int8) float32

Get gets the float32 value for the given int8 key.

func (*ConMapInt8Float32) GetOK 

func (cm *ConMapInt8Float32) GetOK(k int8) (float32, bool)

GetOK gets the float32 value for the given int8 key, and a bool indicating whether the key was present or not.

func (*ConMapInt8Float32) Len 

func (cm *ConMapInt8Float32) Len() int

Get gets the float32 value for the given int8 key.

func (*ConMapInt8Float32) Set 

func (cm *ConMapInt8Float32) Set(k int8, v float32)

Set sets the float32 value for the specified int8 key.

type ConMapInt8Float64 

type ConMapInt8Float64 struct {
	// M is the underlying map[Int8]Float64.
	M map[int8]float64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt8Float64 is a concurrent safe wrapper around a map[Int8]Float64.

func NewConMapInt8Float64 

func NewConMapInt8Float64() *ConMapInt8Float64

NewConMapInt8Float64 creates a new concurrent safe map storing float64 values, for int8 keys.

func ToConMapInt8Float64 

func ToConMapInt8Float64(data map[int8]float64) *ConMapInt8Float64

ToConMapInt8Float64 creates a new ConMapInt8Float64 prepopulated with the data from the specified map[Int8]Float64.

func (*ConMapInt8Float64) Delete 

func (cm *ConMapInt8Float64) Delete(k int8) (float64, bool)

Delete removes the specified int8 key, returning its float64 value and a bool indicating whether the delete occurred or not.

func (*ConMapInt8Float64) Get 

func (cm *ConMapInt8Float64) Get(k int8) float64

Get gets the float64 value for the given int8 key.

func (*ConMapInt8Float64) GetOK 

func (cm *ConMapInt8Float64) GetOK(k int8) (float64, bool)

GetOK gets the float64 value for the given int8 key, and a bool indicating whether the key was present or not.

func (*ConMapInt8Float64) Len 

func (cm *ConMapInt8Float64) Len() int

Get gets the float64 value for the given int8 key.

func (*ConMapInt8Float64) Set 

func (cm *ConMapInt8Float64) Set(k int8, v float64)

Set sets the float64 value for the specified int8 key.

type ConMapInt8Int 

type ConMapInt8Int struct {
	// M is the underlying map[Int8]Int.
	M map[int8]int
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt8Int is a concurrent safe wrapper around a map[Int8]Int.

func NewConMapInt8Int 

func NewConMapInt8Int() *ConMapInt8Int

NewConMapInt8Int creates a new concurrent safe map storing int values, for int8 keys.

func ToConMapInt8Int 

func ToConMapInt8Int(data map[int8]int) *ConMapInt8Int

ToConMapInt8Int creates a new ConMapInt8Int prepopulated with the data from the specified map[Int8]Int.

func (*ConMapInt8Int) Delete 

func (cm *ConMapInt8Int) Delete(k int8) (int, bool)

Delete removes the specified int8 key, returning its int value and a bool indicating whether the delete occurred or not.

func (*ConMapInt8Int) Get 

func (cm *ConMapInt8Int) Get(k int8) int

Get gets the int value for the given int8 key.

func (*ConMapInt8Int) GetOK 

func (cm *ConMapInt8Int) GetOK(k int8) (int, bool)

GetOK gets the int value for the given int8 key, and a bool indicating whether the key was present or not.

func (*ConMapInt8Int) Len 

func (cm *ConMapInt8Int) Len() int

Get gets the int value for the given int8 key.

func (*ConMapInt8Int) Set 

func (cm *ConMapInt8Int) Set(k int8, v int)

Set sets the int value for the specified int8 key.

type ConMapInt8Int16 

type ConMapInt8Int16 struct {
	// M is the underlying map[Int8]Int16.
	M map[int8]int16
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt8Int16 is a concurrent safe wrapper around a map[Int8]Int16.

func NewConMapInt8Int16 

func NewConMapInt8Int16() *ConMapInt8Int16

NewConMapInt8Int16 creates a new concurrent safe map storing int16 values, for int8 keys.

func ToConMapInt8Int16 

func ToConMapInt8Int16(data map[int8]int16) *ConMapInt8Int16

ToConMapInt8Int16 creates a new ConMapInt8Int16 prepopulated with the data from the specified map[Int8]Int16.

func (*ConMapInt8Int16) Delete 

func (cm *ConMapInt8Int16) Delete(k int8) (int16, bool)

Delete removes the specified int8 key, returning its int16 value and a bool indicating whether the delete occurred or not.

func (*ConMapInt8Int16) Get 

func (cm *ConMapInt8Int16) Get(k int8) int16

Get gets the int16 value for the given int8 key.

func (*ConMapInt8Int16) GetOK 

func (cm *ConMapInt8Int16) GetOK(k int8) (int16, bool)

GetOK gets the int16 value for the given int8 key, and a bool indicating whether the key was present or not.

func (*ConMapInt8Int16) Len 

func (cm *ConMapInt8Int16) Len() int

Get gets the int16 value for the given int8 key.

func (*ConMapInt8Int16) Set 

func (cm *ConMapInt8Int16) Set(k int8, v int16)

Set sets the int16 value for the specified int8 key.

type ConMapInt8Int32 

type ConMapInt8Int32 struct {
	// M is the underlying map[Int8]Int32.
	M map[int8]int32
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt8Int32 is a concurrent safe wrapper around a map[Int8]Int32.

func NewConMapInt8Int32 

func NewConMapInt8Int32() *ConMapInt8Int32

NewConMapInt8Int32 creates a new concurrent safe map storing int32 values, for int8 keys.

func ToConMapInt8Int32 

func ToConMapInt8Int32(data map[int8]int32) *ConMapInt8Int32

ToConMapInt8Int32 creates a new ConMapInt8Int32 prepopulated with the data from the specified map[Int8]Int32.

func (*ConMapInt8Int32) Delete 

func (cm *ConMapInt8Int32) Delete(k int8) (int32, bool)

Delete removes the specified int8 key, returning its int32 value and a bool indicating whether the delete occurred or not.

func (*ConMapInt8Int32) Get 

func (cm *ConMapInt8Int32) Get(k int8) int32

Get gets the int32 value for the given int8 key.

func (*ConMapInt8Int32) GetOK 

func (cm *ConMapInt8Int32) GetOK(k int8) (int32, bool)

GetOK gets the int32 value for the given int8 key, and a bool indicating whether the key was present or not.

func (*ConMapInt8Int32) Len 

func (cm *ConMapInt8Int32) Len() int

Get gets the int32 value for the given int8 key.

func (*ConMapInt8Int32) Set 

func (cm *ConMapInt8Int32) Set(k int8, v int32)

Set sets the int32 value for the specified int8 key.

type ConMapInt8Int64 

type ConMapInt8Int64 struct {
	// M is the underlying map[Int8]Int64.
	M map[int8]int64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt8Int64 is a concurrent safe wrapper around a map[Int8]Int64.

func NewConMapInt8Int64 

func NewConMapInt8Int64() *ConMapInt8Int64

NewConMapInt8Int64 creates a new concurrent safe map storing int64 values, for int8 keys.

func ToConMapInt8Int64 

func ToConMapInt8Int64(data map[int8]int64) *ConMapInt8Int64

ToConMapInt8Int64 creates a new ConMapInt8Int64 prepopulated with the data from the specified map[Int8]Int64.

func (*ConMapInt8Int64) Delete 

func (cm *ConMapInt8Int64) Delete(k int8) (int64, bool)

Delete removes the specified int8 key, returning its int64 value and a bool indicating whether the delete occurred or not.

func (*ConMapInt8Int64) Get 

func (cm *ConMapInt8Int64) Get(k int8) int64

Get gets the int64 value for the given int8 key.

func (*ConMapInt8Int64) GetOK 

func (cm *ConMapInt8Int64) GetOK(k int8) (int64, bool)

GetOK gets the int64 value for the given int8 key, and a bool indicating whether the key was present or not.

func (*ConMapInt8Int64) Len 

func (cm *ConMapInt8Int64) Len() int

Get gets the int64 value for the given int8 key.

func (*ConMapInt8Int64) Set 

func (cm *ConMapInt8Int64) Set(k int8, v int64)

Set sets the int64 value for the specified int8 key.

type ConMapInt8Int8 

type ConMapInt8Int8 struct {
	// M is the underlying map[Int8]Int8.
	M map[int8]int8
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt8Int8 is a concurrent safe wrapper around a map[Int8]Int8.

func NewConMapInt8Int8 

func NewConMapInt8Int8() *ConMapInt8Int8

NewConMapInt8Int8 creates a new concurrent safe map storing int8 values, for int8 keys.

func ToConMapInt8Int8 

func ToConMapInt8Int8(data map[int8]int8) *ConMapInt8Int8

ToConMapInt8Int8 creates a new ConMapInt8Int8 prepopulated with the data from the specified map[Int8]Int8.

func (*ConMapInt8Int8) Delete 

func (cm *ConMapInt8Int8) Delete(k int8) (int8, bool)

Delete removes the specified int8 key, returning its int8 value and a bool indicating whether the delete occurred or not.

func (*ConMapInt8Int8) Get 

func (cm *ConMapInt8Int8) Get(k int8) int8

Get gets the int8 value for the given int8 key.

func (*ConMapInt8Int8) GetOK 

func (cm *ConMapInt8Int8) GetOK(k int8) (int8, bool)

GetOK gets the int8 value for the given int8 key, and a bool indicating whether the key was present or not.

func (*ConMapInt8Int8) Len 

func (cm *ConMapInt8Int8) Len() int

Get gets the int8 value for the given int8 key.

func (*ConMapInt8Int8) Set 

func (cm *ConMapInt8Int8) Set(k int8, v int8)

Set sets the int8 value for the specified int8 key.

type ConMapInt8Rune 

type ConMapInt8Rune struct {
	// M is the underlying map[Int8]Rune.
	M map[int8]rune
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt8Rune is a concurrent safe wrapper around a map[Int8]Rune.

func NewConMapInt8Rune 

func NewConMapInt8Rune() *ConMapInt8Rune

NewConMapInt8Rune creates a new concurrent safe map storing rune values, for int8 keys.

func ToConMapInt8Rune 

func ToConMapInt8Rune(data map[int8]rune) *ConMapInt8Rune

ToConMapInt8Rune creates a new ConMapInt8Rune prepopulated with the data from the specified map[Int8]Rune.

func (*ConMapInt8Rune) Delete 

func (cm *ConMapInt8Rune) Delete(k int8) (rune, bool)

Delete removes the specified int8 key, returning its rune value and a bool indicating whether the delete occurred or not.

func (*ConMapInt8Rune) Get 

func (cm *ConMapInt8Rune) Get(k int8) rune

Get gets the rune value for the given int8 key.

func (*ConMapInt8Rune) GetOK 

func (cm *ConMapInt8Rune) GetOK(k int8) (rune, bool)

GetOK gets the rune value for the given int8 key, and a bool indicating whether the key was present or not.

func (*ConMapInt8Rune) Len 

func (cm *ConMapInt8Rune) Len() int

Get gets the rune value for the given int8 key.

func (*ConMapInt8Rune) Set 

func (cm *ConMapInt8Rune) Set(k int8, v rune)

Set sets the rune value for the specified int8 key.

type ConMapInt8String 

type ConMapInt8String struct {
	// M is the underlying map[Int8]String.
	M map[int8]string
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt8String is a concurrent safe wrapper around a map[Int8]String.

func NewConMapInt8String 

func NewConMapInt8String() *ConMapInt8String

NewConMapInt8String creates a new concurrent safe map storing string values, for int8 keys.

func ToConMapInt8String 

func ToConMapInt8String(data map[int8]string) *ConMapInt8String

ToConMapInt8String creates a new ConMapInt8String prepopulated with the data from the specified map[Int8]String.

func (*ConMapInt8String) Delete 

func (cm *ConMapInt8String) Delete(k int8) (string, bool)

Delete removes the specified int8 key, returning its string value and a bool indicating whether the delete occurred or not.

func (*ConMapInt8String) Get 

func (cm *ConMapInt8String) Get(k int8) string

Get gets the string value for the given int8 key.

func (*ConMapInt8String) GetOK 

func (cm *ConMapInt8String) GetOK(k int8) (string, bool)

GetOK gets the string value for the given int8 key, and a bool indicating whether the key was present or not.

func (*ConMapInt8String) Len 

func (cm *ConMapInt8String) Len() int

Get gets the string value for the given int8 key.

func (*ConMapInt8String) Set 

func (cm *ConMapInt8String) Set(k int8, v string)

Set sets the string value for the specified int8 key.

type ConMapInt8Uint 

type ConMapInt8Uint struct {
	// M is the underlying map[Int8]Uint.
	M map[int8]uint
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt8Uint is a concurrent safe wrapper around a map[Int8]Uint.

func NewConMapInt8Uint 

func NewConMapInt8Uint() *ConMapInt8Uint

NewConMapInt8Uint creates a new concurrent safe map storing uint values, for int8 keys.

func ToConMapInt8Uint 

func ToConMapInt8Uint(data map[int8]uint) *ConMapInt8Uint

ToConMapInt8Uint creates a new ConMapInt8Uint prepopulated with the data from the specified map[Int8]Uint.

func (*ConMapInt8Uint) Delete 

func (cm *ConMapInt8Uint) Delete(k int8) (uint, bool)

Delete removes the specified int8 key, returning its uint value and a bool indicating whether the delete occurred or not.

func (*ConMapInt8Uint) Get 

func (cm *ConMapInt8Uint) Get(k int8) uint

Get gets the uint value for the given int8 key.

func (*ConMapInt8Uint) GetOK 

func (cm *ConMapInt8Uint) GetOK(k int8) (uint, bool)

GetOK gets the uint value for the given int8 key, and a bool indicating whether the key was present or not.

func (*ConMapInt8Uint) Len 

func (cm *ConMapInt8Uint) Len() int

Get gets the uint value for the given int8 key.

func (*ConMapInt8Uint) Set 

func (cm *ConMapInt8Uint) Set(k int8, v uint)

Set sets the uint value for the specified int8 key.

type ConMapInt8Uint16 

type ConMapInt8Uint16 struct {
	// M is the underlying map[Int8]Uint16.
	M map[int8]uint16
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt8Uint16 is a concurrent safe wrapper around a map[Int8]Uint16.

func NewConMapInt8Uint16 

func NewConMapInt8Uint16() *ConMapInt8Uint16

NewConMapInt8Uint16 creates a new concurrent safe map storing uint16 values, for int8 keys.

func ToConMapInt8Uint16 

func ToConMapInt8Uint16(data map[int8]uint16) *ConMapInt8Uint16

ToConMapInt8Uint16 creates a new ConMapInt8Uint16 prepopulated with the data from the specified map[Int8]Uint16.

func (*ConMapInt8Uint16) Delete 

func (cm *ConMapInt8Uint16) Delete(k int8) (uint16, bool)

Delete removes the specified int8 key, returning its uint16 value and a bool indicating whether the delete occurred or not.

func (*ConMapInt8Uint16) Get 

func (cm *ConMapInt8Uint16) Get(k int8) uint16

Get gets the uint16 value for the given int8 key.

func (*ConMapInt8Uint16) GetOK 

func (cm *ConMapInt8Uint16) GetOK(k int8) (uint16, bool)

GetOK gets the uint16 value for the given int8 key, and a bool indicating whether the key was present or not.

func (*ConMapInt8Uint16) Len 

func (cm *ConMapInt8Uint16) Len() int

Get gets the uint16 value for the given int8 key.

func (*ConMapInt8Uint16) Set 

func (cm *ConMapInt8Uint16) Set(k int8, v uint16)

Set sets the uint16 value for the specified int8 key.

type ConMapInt8Uint32 

type ConMapInt8Uint32 struct {
	// M is the underlying map[Int8]Uint32.
	M map[int8]uint32
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt8Uint32 is a concurrent safe wrapper around a map[Int8]Uint32.

func NewConMapInt8Uint32 

func NewConMapInt8Uint32() *ConMapInt8Uint32

NewConMapInt8Uint32 creates a new concurrent safe map storing uint32 values, for int8 keys.

func ToConMapInt8Uint32 

func ToConMapInt8Uint32(data map[int8]uint32) *ConMapInt8Uint32

ToConMapInt8Uint32 creates a new ConMapInt8Uint32 prepopulated with the data from the specified map[Int8]Uint32.

func (*ConMapInt8Uint32) Delete 

func (cm *ConMapInt8Uint32) Delete(k int8) (uint32, bool)

Delete removes the specified int8 key, returning its uint32 value and a bool indicating whether the delete occurred or not.

func (*ConMapInt8Uint32) Get 

func (cm *ConMapInt8Uint32) Get(k int8) uint32

Get gets the uint32 value for the given int8 key.

func (*ConMapInt8Uint32) GetOK 

func (cm *ConMapInt8Uint32) GetOK(k int8) (uint32, bool)

GetOK gets the uint32 value for the given int8 key, and a bool indicating whether the key was present or not.

func (*ConMapInt8Uint32) Len 

func (cm *ConMapInt8Uint32) Len() int

Get gets the uint32 value for the given int8 key.

func (*ConMapInt8Uint32) Set 

func (cm *ConMapInt8Uint32) Set(k int8, v uint32)

Set sets the uint32 value for the specified int8 key.

type ConMapInt8Uint64 

type ConMapInt8Uint64 struct {
	// M is the underlying map[Int8]Uint64.
	M map[int8]uint64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt8Uint64 is a concurrent safe wrapper around a map[Int8]Uint64.

func NewConMapInt8Uint64 

func NewConMapInt8Uint64() *ConMapInt8Uint64

NewConMapInt8Uint64 creates a new concurrent safe map storing uint64 values, for int8 keys.

func ToConMapInt8Uint64 

func ToConMapInt8Uint64(data map[int8]uint64) *ConMapInt8Uint64

ToConMapInt8Uint64 creates a new ConMapInt8Uint64 prepopulated with the data from the specified map[Int8]Uint64.

func (*ConMapInt8Uint64) Delete 

func (cm *ConMapInt8Uint64) Delete(k int8) (uint64, bool)

Delete removes the specified int8 key, returning its uint64 value and a bool indicating whether the delete occurred or not.

func (*ConMapInt8Uint64) Get 

func (cm *ConMapInt8Uint64) Get(k int8) uint64

Get gets the uint64 value for the given int8 key.

func (*ConMapInt8Uint64) GetOK 

func (cm *ConMapInt8Uint64) GetOK(k int8) (uint64, bool)

GetOK gets the uint64 value for the given int8 key, and a bool indicating whether the key was present or not.

func (*ConMapInt8Uint64) Len 

func (cm *ConMapInt8Uint64) Len() int

Get gets the uint64 value for the given int8 key.

func (*ConMapInt8Uint64) Set 

func (cm *ConMapInt8Uint64) Set(k int8, v uint64)

Set sets the uint64 value for the specified int8 key.

type ConMapInt8Uint8 

type ConMapInt8Uint8 struct {
	// M is the underlying map[Int8]Uint8.
	M map[int8]uint8
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt8Uint8 is a concurrent safe wrapper around a map[Int8]Uint8.

func NewConMapInt8Uint8 

func NewConMapInt8Uint8() *ConMapInt8Uint8

NewConMapInt8Uint8 creates a new concurrent safe map storing uint8 values, for int8 keys.

func ToConMapInt8Uint8 

func ToConMapInt8Uint8(data map[int8]uint8) *ConMapInt8Uint8

ToConMapInt8Uint8 creates a new ConMapInt8Uint8 prepopulated with the data from the specified map[Int8]Uint8.

func (*ConMapInt8Uint8) Delete 

func (cm *ConMapInt8Uint8) Delete(k int8) (uint8, bool)

Delete removes the specified int8 key, returning its uint8 value and a bool indicating whether the delete occurred or not.

func (*ConMapInt8Uint8) Get 

func (cm *ConMapInt8Uint8) Get(k int8) uint8

Get gets the uint8 value for the given int8 key.

func (*ConMapInt8Uint8) GetOK 

func (cm *ConMapInt8Uint8) GetOK(k int8) (uint8, bool)

GetOK gets the uint8 value for the given int8 key, and a bool indicating whether the key was present or not.

func (*ConMapInt8Uint8) Len 

func (cm *ConMapInt8Uint8) Len() int

Get gets the uint8 value for the given int8 key.

func (*ConMapInt8Uint8) Set 

func (cm *ConMapInt8Uint8) Set(k int8, v uint8)

Set sets the uint8 value for the specified int8 key.

type ConMapInt8Uintptr 

type ConMapInt8Uintptr struct {
	// M is the underlying map[Int8]Uintptr.
	M map[int8]uintptr
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapInt8Uintptr is a concurrent safe wrapper around a map[Int8]Uintptr.

func NewConMapInt8Uintptr 

func NewConMapInt8Uintptr() *ConMapInt8Uintptr

NewConMapInt8Uintptr creates a new concurrent safe map storing uintptr values, for int8 keys.

func ToConMapInt8Uintptr 

func ToConMapInt8Uintptr(data map[int8]uintptr) *ConMapInt8Uintptr

ToConMapInt8Uintptr creates a new ConMapInt8Uintptr prepopulated with the data from the specified map[Int8]Uintptr.

func (*ConMapInt8Uintptr) Delete 

func (cm *ConMapInt8Uintptr) Delete(k int8) (uintptr, bool)

Delete removes the specified int8 key, returning its uintptr value and a bool indicating whether the delete occurred or not.

func (*ConMapInt8Uintptr) Get 

func (cm *ConMapInt8Uintptr) Get(k int8) uintptr

Get gets the uintptr value for the given int8 key.

func (*ConMapInt8Uintptr) GetOK 

func (cm *ConMapInt8Uintptr) GetOK(k int8) (uintptr, bool)

GetOK gets the uintptr value for the given int8 key, and a bool indicating whether the key was present or not.

func (*ConMapInt8Uintptr) Len 

func (cm *ConMapInt8Uintptr) Len() int

Get gets the uintptr value for the given int8 key.

func (*ConMapInt8Uintptr) Set 

func (cm *ConMapInt8Uintptr) Set(k int8, v uintptr)

Set sets the uintptr value for the specified int8 key.

type ConMapIntBool 

type ConMapIntBool struct {
	// M is the underlying map[Int]Bool.
	M map[int]bool
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapIntBool is a concurrent safe wrapper around a map[Int]Bool.

func NewConMapIntBool 

func NewConMapIntBool() *ConMapIntBool

NewConMapIntBool creates a new concurrent safe map storing bool values, for int keys.

func ToConMapIntBool 

func ToConMapIntBool(data map[int]bool) *ConMapIntBool

ToConMapIntBool creates a new ConMapIntBool prepopulated with the data from the specified map[Int]Bool.

func (*ConMapIntBool) Delete 

func (cm *ConMapIntBool) Delete(k int) (bool, bool)

Delete removes the specified int key, returning its bool value and a bool indicating whether the delete occurred or not.

func (*ConMapIntBool) Get 

func (cm *ConMapIntBool) Get(k int) bool

Get gets the bool value for the given int key.

func (*ConMapIntBool) GetOK 

func (cm *ConMapIntBool) GetOK(k int) (bool, bool)

GetOK gets the bool value for the given int key, and a bool indicating whether the key was present or not.

func (*ConMapIntBool) Len 

func (cm *ConMapIntBool) Len() int

Get gets the bool value for the given int key.

func (*ConMapIntBool) Set 

func (cm *ConMapIntBool) Set(k int, v bool)

Set sets the bool value for the specified int key.

type ConMapIntByte 

type ConMapIntByte struct {
	// M is the underlying map[Int]Byte.
	M map[int]byte
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapIntByte is a concurrent safe wrapper around a map[Int]Byte.

func NewConMapIntByte 

func NewConMapIntByte() *ConMapIntByte

NewConMapIntByte creates a new concurrent safe map storing byte values, for int keys.

func ToConMapIntByte 

func ToConMapIntByte(data map[int]byte) *ConMapIntByte

ToConMapIntByte creates a new ConMapIntByte prepopulated with the data from the specified map[Int]Byte.

func (*ConMapIntByte) Delete 

func (cm *ConMapIntByte) Delete(k int) (byte, bool)

Delete removes the specified int key, returning its byte value and a bool indicating whether the delete occurred or not.

func (*ConMapIntByte) Get 

func (cm *ConMapIntByte) Get(k int) byte

Get gets the byte value for the given int key.

func (*ConMapIntByte) GetOK 

func (cm *ConMapIntByte) GetOK(k int) (byte, bool)

GetOK gets the byte value for the given int key, and a bool indicating whether the key was present or not.

func (*ConMapIntByte) Len 

func (cm *ConMapIntByte) Len() int

Get gets the byte value for the given int key.

func (*ConMapIntByte) Set 

func (cm *ConMapIntByte) Set(k int, v byte)

Set sets the byte value for the specified int key.

type ConMapIntComplex128 

type ConMapIntComplex128 struct {
	// M is the underlying map[Int]Complex128.
	M map[int]complex128
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapIntComplex128 is a concurrent safe wrapper around a map[Int]Complex128.

func NewConMapIntComplex128 

func NewConMapIntComplex128() *ConMapIntComplex128

NewConMapIntComplex128 creates a new concurrent safe map storing complex128 values, for int keys.

func ToConMapIntComplex128 

func ToConMapIntComplex128(data map[int]complex128) *ConMapIntComplex128

ToConMapIntComplex128 creates a new ConMapIntComplex128 prepopulated with the data from the specified map[Int]Complex128.

func (*ConMapIntComplex128) Delete 

func (cm *ConMapIntComplex128) Delete(k int) (complex128, bool)

Delete removes the specified int key, returning its complex128 value and a bool indicating whether the delete occurred or not.

func (*ConMapIntComplex128) Get 

func (cm *ConMapIntComplex128) Get(k int) complex128

Get gets the complex128 value for the given int key.

func (*ConMapIntComplex128) GetOK 

func (cm *ConMapIntComplex128) GetOK(k int) (complex128, bool)

GetOK gets the complex128 value for the given int key, and a bool indicating whether the key was present or not.

func (*ConMapIntComplex128) Len 

func (cm *ConMapIntComplex128) Len() int

Get gets the complex128 value for the given int key.

func (*ConMapIntComplex128) Set 

func (cm *ConMapIntComplex128) Set(k int, v complex128)

Set sets the complex128 value for the specified int key.

type ConMapIntComplex64 

type ConMapIntComplex64 struct {
	// M is the underlying map[Int]Complex64.
	M map[int]complex64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapIntComplex64 is a concurrent safe wrapper around a map[Int]Complex64.

func NewConMapIntComplex64 

func NewConMapIntComplex64() *ConMapIntComplex64

NewConMapIntComplex64 creates a new concurrent safe map storing complex64 values, for int keys.

func ToConMapIntComplex64 

func ToConMapIntComplex64(data map[int]complex64) *ConMapIntComplex64

ToConMapIntComplex64 creates a new ConMapIntComplex64 prepopulated with the data from the specified map[Int]Complex64.

func (*ConMapIntComplex64) Delete 

func (cm *ConMapIntComplex64) Delete(k int) (complex64, bool)

Delete removes the specified int key, returning its complex64 value and a bool indicating whether the delete occurred or not.

func (*ConMapIntComplex64) Get 

func (cm *ConMapIntComplex64) Get(k int) complex64

Get gets the complex64 value for the given int key.

func (*ConMapIntComplex64) GetOK 

func (cm *ConMapIntComplex64) GetOK(k int) (complex64, bool)

GetOK gets the complex64 value for the given int key, and a bool indicating whether the key was present or not.

func (*ConMapIntComplex64) Len 

func (cm *ConMapIntComplex64) Len() int

Get gets the complex64 value for the given int key.

func (*ConMapIntComplex64) Set 

func (cm *ConMapIntComplex64) Set(k int, v complex64)

Set sets the complex64 value for the specified int key.

type ConMapIntError 

type ConMapIntError struct {
	// M is the underlying map[Int]Error.
	M map[int]error
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapIntError is a concurrent safe wrapper around a map[Int]Error.

func NewConMapIntError 

func NewConMapIntError() *ConMapIntError

NewConMapIntError creates a new concurrent safe map storing error values, for int keys.

func ToConMapIntError 

func ToConMapIntError(data map[int]error) *ConMapIntError

ToConMapIntError creates a new ConMapIntError prepopulated with the data from the specified map[Int]Error.

func (*ConMapIntError) Delete 

func (cm *ConMapIntError) Delete(k int) (error, bool)

Delete removes the specified int key, returning its error value and a bool indicating whether the delete occurred or not.

func (*ConMapIntError) Get 

func (cm *ConMapIntError) Get(k int) error

Get gets the error value for the given int key.

func (*ConMapIntError) GetOK 

func (cm *ConMapIntError) GetOK(k int) (error, bool)

GetOK gets the error value for the given int key, and a bool indicating whether the key was present or not.

func (*ConMapIntError) Len 

func (cm *ConMapIntError) Len() int

Get gets the error value for the given int key.

func (*ConMapIntError) Set 

func (cm *ConMapIntError) Set(k int, v error)

Set sets the error value for the specified int key.

type ConMapIntFloat32 

type ConMapIntFloat32 struct {
	// M is the underlying map[Int]Float32.
	M map[int]float32
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapIntFloat32 is a concurrent safe wrapper around a map[Int]Float32.

func NewConMapIntFloat32 

func NewConMapIntFloat32() *ConMapIntFloat32

NewConMapIntFloat32 creates a new concurrent safe map storing float32 values, for int keys.

func ToConMapIntFloat32 

func ToConMapIntFloat32(data map[int]float32) *ConMapIntFloat32

ToConMapIntFloat32 creates a new ConMapIntFloat32 prepopulated with the data from the specified map[Int]Float32.

func (*ConMapIntFloat32) Delete 

func (cm *ConMapIntFloat32) Delete(k int) (float32, bool)

Delete removes the specified int key, returning its float32 value and a bool indicating whether the delete occurred or not.

func (*ConMapIntFloat32) Get 

func (cm *ConMapIntFloat32) Get(k int) float32

Get gets the float32 value for the given int key.

func (*ConMapIntFloat32) GetOK 

func (cm *ConMapIntFloat32) GetOK(k int) (float32, bool)

GetOK gets the float32 value for the given int key, and a bool indicating whether the key was present or not.

func (*ConMapIntFloat32) Len 

func (cm *ConMapIntFloat32) Len() int

Get gets the float32 value for the given int key.

func (*ConMapIntFloat32) Set 

func (cm *ConMapIntFloat32) Set(k int, v float32)

Set sets the float32 value for the specified int key.

type ConMapIntFloat64 

type ConMapIntFloat64 struct {
	// M is the underlying map[Int]Float64.
	M map[int]float64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapIntFloat64 is a concurrent safe wrapper around a map[Int]Float64.

func NewConMapIntFloat64 

func NewConMapIntFloat64() *ConMapIntFloat64

NewConMapIntFloat64 creates a new concurrent safe map storing float64 values, for int keys.

func ToConMapIntFloat64 

func ToConMapIntFloat64(data map[int]float64) *ConMapIntFloat64

ToConMapIntFloat64 creates a new ConMapIntFloat64 prepopulated with the data from the specified map[Int]Float64.

func (*ConMapIntFloat64) Delete 

func (cm *ConMapIntFloat64) Delete(k int) (float64, bool)

Delete removes the specified int key, returning its float64 value and a bool indicating whether the delete occurred or not.

func (*ConMapIntFloat64) Get 

func (cm *ConMapIntFloat64) Get(k int) float64

Get gets the float64 value for the given int key.

func (*ConMapIntFloat64) GetOK 

func (cm *ConMapIntFloat64) GetOK(k int) (float64, bool)

GetOK gets the float64 value for the given int key, and a bool indicating whether the key was present or not.

func (*ConMapIntFloat64) Len 

func (cm *ConMapIntFloat64) Len() int

Get gets the float64 value for the given int key.

func (*ConMapIntFloat64) Set 

func (cm *ConMapIntFloat64) Set(k int, v float64)

Set sets the float64 value for the specified int key.

type ConMapIntInt 

type ConMapIntInt struct {
	// M is the underlying map[Int]Int.
	M map[int]int
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapIntInt is a concurrent safe wrapper around a map[Int]Int.

func NewConMapIntInt 

func NewConMapIntInt() *ConMapIntInt

NewConMapIntInt creates a new concurrent safe map storing int values, for int keys.

func ToConMapIntInt 

func ToConMapIntInt(data map[int]int) *ConMapIntInt

ToConMapIntInt creates a new ConMapIntInt prepopulated with the data from the specified map[Int]Int.

func (*ConMapIntInt) Delete 

func (cm *ConMapIntInt) Delete(k int) (int, bool)

Delete removes the specified int key, returning its int value and a bool indicating whether the delete occurred or not.

func (*ConMapIntInt) Get 

func (cm *ConMapIntInt) Get(k int) int

Get gets the int value for the given int key.

func (*ConMapIntInt) GetOK 

func (cm *ConMapIntInt) GetOK(k int) (int, bool)

GetOK gets the int value for the given int key, and a bool indicating whether the key was present or not.

func (*ConMapIntInt) Len 

func (cm *ConMapIntInt) Len() int

Get gets the int value for the given int key.

func (*ConMapIntInt) Set 

func (cm *ConMapIntInt) Set(k int, v int)

Set sets the int value for the specified int key.

type ConMapIntInt16 

type ConMapIntInt16 struct {
	// M is the underlying map[Int]Int16.
	M map[int]int16
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapIntInt16 is a concurrent safe wrapper around a map[Int]Int16.

func NewConMapIntInt16 

func NewConMapIntInt16() *ConMapIntInt16

NewConMapIntInt16 creates a new concurrent safe map storing int16 values, for int keys.

func ToConMapIntInt16 

func ToConMapIntInt16(data map[int]int16) *ConMapIntInt16

ToConMapIntInt16 creates a new ConMapIntInt16 prepopulated with the data from the specified map[Int]Int16.

func (*ConMapIntInt16) Delete 

func (cm *ConMapIntInt16) Delete(k int) (int16, bool)

Delete removes the specified int key, returning its int16 value and a bool indicating whether the delete occurred or not.

func (*ConMapIntInt16) Get 

func (cm *ConMapIntInt16) Get(k int) int16

Get gets the int16 value for the given int key.

func (*ConMapIntInt16) GetOK 

func (cm *ConMapIntInt16) GetOK(k int) (int16, bool)

GetOK gets the int16 value for the given int key, and a bool indicating whether the key was present or not.

func (*ConMapIntInt16) Len 

func (cm *ConMapIntInt16) Len() int

Get gets the int16 value for the given int key.

func (*ConMapIntInt16) Set 

func (cm *ConMapIntInt16) Set(k int, v int16)

Set sets the int16 value for the specified int key.

type ConMapIntInt32 

type ConMapIntInt32 struct {
	// M is the underlying map[Int]Int32.
	M map[int]int32
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapIntInt32 is a concurrent safe wrapper around a map[Int]Int32.

func NewConMapIntInt32 

func NewConMapIntInt32() *ConMapIntInt32

NewConMapIntInt32 creates a new concurrent safe map storing int32 values, for int keys.

func ToConMapIntInt32 

func ToConMapIntInt32(data map[int]int32) *ConMapIntInt32

ToConMapIntInt32 creates a new ConMapIntInt32 prepopulated with the data from the specified map[Int]Int32.

func (*ConMapIntInt32) Delete 

func (cm *ConMapIntInt32) Delete(k int) (int32, bool)

Delete removes the specified int key, returning its int32 value and a bool indicating whether the delete occurred or not.

func (*ConMapIntInt32) Get 

func (cm *ConMapIntInt32) Get(k int) int32

Get gets the int32 value for the given int key.

func (*ConMapIntInt32) GetOK 

func (cm *ConMapIntInt32) GetOK(k int) (int32, bool)

GetOK gets the int32 value for the given int key, and a bool indicating whether the key was present or not.

func (*ConMapIntInt32) Len 

func (cm *ConMapIntInt32) Len() int

Get gets the int32 value for the given int key.

func (*ConMapIntInt32) Set 

func (cm *ConMapIntInt32) Set(k int, v int32)

Set sets the int32 value for the specified int key.

type ConMapIntInt64 

type ConMapIntInt64 struct {
	// M is the underlying map[Int]Int64.
	M map[int]int64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapIntInt64 is a concurrent safe wrapper around a map[Int]Int64.

func NewConMapIntInt64 

func NewConMapIntInt64() *ConMapIntInt64

NewConMapIntInt64 creates a new concurrent safe map storing int64 values, for int keys.

func ToConMapIntInt64 

func ToConMapIntInt64(data map[int]int64) *ConMapIntInt64

ToConMapIntInt64 creates a new ConMapIntInt64 prepopulated with the data from the specified map[Int]Int64.

func (*ConMapIntInt64) Delete 

func (cm *ConMapIntInt64) Delete(k int) (int64, bool)

Delete removes the specified int key, returning its int64 value and a bool indicating whether the delete occurred or not.

func (*ConMapIntInt64) Get 

func (cm *ConMapIntInt64) Get(k int) int64

Get gets the int64 value for the given int key.

func (*ConMapIntInt64) GetOK 

func (cm *ConMapIntInt64) GetOK(k int) (int64, bool)

GetOK gets the int64 value for the given int key, and a bool indicating whether the key was present or not.

func (*ConMapIntInt64) Len 

func (cm *ConMapIntInt64) Len() int

Get gets the int64 value for the given int key.

func (*ConMapIntInt64) Set 

func (cm *ConMapIntInt64) Set(k int, v int64)

Set sets the int64 value for the specified int key.

type ConMapIntInt8 

type ConMapIntInt8 struct {
	// M is the underlying map[Int]Int8.
	M map[int]int8
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapIntInt8 is a concurrent safe wrapper around a map[Int]Int8.

func NewConMapIntInt8 

func NewConMapIntInt8() *ConMapIntInt8

NewConMapIntInt8 creates a new concurrent safe map storing int8 values, for int keys.

func ToConMapIntInt8 

func ToConMapIntInt8(data map[int]int8) *ConMapIntInt8

ToConMapIntInt8 creates a new ConMapIntInt8 prepopulated with the data from the specified map[Int]Int8.

func (*ConMapIntInt8) Delete 

func (cm *ConMapIntInt8) Delete(k int) (int8, bool)

Delete removes the specified int key, returning its int8 value and a bool indicating whether the delete occurred or not.

func (*ConMapIntInt8) Get 

func (cm *ConMapIntInt8) Get(k int) int8

Get gets the int8 value for the given int key.

func (*ConMapIntInt8) GetOK 

func (cm *ConMapIntInt8) GetOK(k int) (int8, bool)

GetOK gets the int8 value for the given int key, and a bool indicating whether the key was present or not.

func (*ConMapIntInt8) Len 

func (cm *ConMapIntInt8) Len() int

Get gets the int8 value for the given int key.

func (*ConMapIntInt8) Set 

func (cm *ConMapIntInt8) Set(k int, v int8)

Set sets the int8 value for the specified int key.

type ConMapIntRune 

type ConMapIntRune struct {
	// M is the underlying map[Int]Rune.
	M map[int]rune
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapIntRune is a concurrent safe wrapper around a map[Int]Rune.

func NewConMapIntRune 

func NewConMapIntRune() *ConMapIntRune

NewConMapIntRune creates a new concurrent safe map storing rune values, for int keys.

func ToConMapIntRune 

func ToConMapIntRune(data map[int]rune) *ConMapIntRune

ToConMapIntRune creates a new ConMapIntRune prepopulated with the data from the specified map[Int]Rune.

func (*ConMapIntRune) Delete 

func (cm *ConMapIntRune) Delete(k int) (rune, bool)

Delete removes the specified int key, returning its rune value and a bool indicating whether the delete occurred or not.

func (*ConMapIntRune) Get 

func (cm *ConMapIntRune) Get(k int) rune

Get gets the rune value for the given int key.

func (*ConMapIntRune) GetOK 

func (cm *ConMapIntRune) GetOK(k int) (rune, bool)

GetOK gets the rune value for the given int key, and a bool indicating whether the key was present or not.

func (*ConMapIntRune) Len 

func (cm *ConMapIntRune) Len() int

Get gets the rune value for the given int key.

func (*ConMapIntRune) Set 

func (cm *ConMapIntRune) Set(k int, v rune)

Set sets the rune value for the specified int key.

type ConMapIntString 

type ConMapIntString struct {
	// M is the underlying map[Int]String.
	M map[int]string
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapIntString is a concurrent safe wrapper around a map[Int]String.

func NewConMapIntString 

func NewConMapIntString() *ConMapIntString

NewConMapIntString creates a new concurrent safe map storing string values, for int keys.

func ToConMapIntString 

func ToConMapIntString(data map[int]string) *ConMapIntString

ToConMapIntString creates a new ConMapIntString prepopulated with the data from the specified map[Int]String.

func (*ConMapIntString) Delete 

func (cm *ConMapIntString) Delete(k int) (string, bool)

Delete removes the specified int key, returning its string value and a bool indicating whether the delete occurred or not.

func (*ConMapIntString) Get 

func (cm *ConMapIntString) Get(k int) string

Get gets the string value for the given int key.

func (*ConMapIntString) GetOK 

func (cm *ConMapIntString) GetOK(k int) (string, bool)

GetOK gets the string value for the given int key, and a bool indicating whether the key was present or not.

func (*ConMapIntString) Len 

func (cm *ConMapIntString) Len() int

Get gets the string value for the given int key.

func (*ConMapIntString) Set 

func (cm *ConMapIntString) Set(k int, v string)

Set sets the string value for the specified int key.

type ConMapIntUint 

type ConMapIntUint struct {
	// M is the underlying map[Int]Uint.
	M map[int]uint
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapIntUint is a concurrent safe wrapper around a map[Int]Uint.

func NewConMapIntUint 

func NewConMapIntUint() *ConMapIntUint

NewConMapIntUint creates a new concurrent safe map storing uint values, for int keys.

func ToConMapIntUint 

func ToConMapIntUint(data map[int]uint) *ConMapIntUint

ToConMapIntUint creates a new ConMapIntUint prepopulated with the data from the specified map[Int]Uint.

func (*ConMapIntUint) Delete 

func (cm *ConMapIntUint) Delete(k int) (uint, bool)

Delete removes the specified int key, returning its uint value and a bool indicating whether the delete occurred or not.

func (*ConMapIntUint) Get 

func (cm *ConMapIntUint) Get(k int) uint

Get gets the uint value for the given int key.

func (*ConMapIntUint) GetOK 

func (cm *ConMapIntUint) GetOK(k int) (uint, bool)

GetOK gets the uint value for the given int key, and a bool indicating whether the key was present or not.

func (*ConMapIntUint) Len 

func (cm *ConMapIntUint) Len() int

Get gets the uint value for the given int key.

func (*ConMapIntUint) Set 

func (cm *ConMapIntUint) Set(k int, v uint)

Set sets the uint value for the specified int key.

type ConMapIntUint16 

type ConMapIntUint16 struct {
	// M is the underlying map[Int]Uint16.
	M map[int]uint16
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapIntUint16 is a concurrent safe wrapper around a map[Int]Uint16.

func NewConMapIntUint16 

func NewConMapIntUint16() *ConMapIntUint16

NewConMapIntUint16 creates a new concurrent safe map storing uint16 values, for int keys.

func ToConMapIntUint16 

func ToConMapIntUint16(data map[int]uint16) *ConMapIntUint16

ToConMapIntUint16 creates a new ConMapIntUint16 prepopulated with the data from the specified map[Int]Uint16.

func (*ConMapIntUint16) Delete 

func (cm *ConMapIntUint16) Delete(k int) (uint16, bool)

Delete removes the specified int key, returning its uint16 value and a bool indicating whether the delete occurred or not.

func (*ConMapIntUint16) Get 

func (cm *ConMapIntUint16) Get(k int) uint16

Get gets the uint16 value for the given int key.

func (*ConMapIntUint16) GetOK 

func (cm *ConMapIntUint16) GetOK(k int) (uint16, bool)

GetOK gets the uint16 value for the given int key, and a bool indicating whether the key was present or not.

func (*ConMapIntUint16) Len 

func (cm *ConMapIntUint16) Len() int

Get gets the uint16 value for the given int key.

func (*ConMapIntUint16) Set 

func (cm *ConMapIntUint16) Set(k int, v uint16)

Set sets the uint16 value for the specified int key.

type ConMapIntUint32 

type ConMapIntUint32 struct {
	// M is the underlying map[Int]Uint32.
	M map[int]uint32
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapIntUint32 is a concurrent safe wrapper around a map[Int]Uint32.

func NewConMapIntUint32 

func NewConMapIntUint32() *ConMapIntUint32

NewConMapIntUint32 creates a new concurrent safe map storing uint32 values, for int keys.

func ToConMapIntUint32 

func ToConMapIntUint32(data map[int]uint32) *ConMapIntUint32

ToConMapIntUint32 creates a new ConMapIntUint32 prepopulated with the data from the specified map[Int]Uint32.

func (*ConMapIntUint32) Delete 

func (cm *ConMapIntUint32) Delete(k int) (uint32, bool)

Delete removes the specified int key, returning its uint32 value and a bool indicating whether the delete occurred or not.

func (*ConMapIntUint32) Get 

func (cm *ConMapIntUint32) Get(k int) uint32

Get gets the uint32 value for the given int key.

func (*ConMapIntUint32) GetOK 

func (cm *ConMapIntUint32) GetOK(k int) (uint32, bool)

GetOK gets the uint32 value for the given int key, and a bool indicating whether the key was present or not.

func (*ConMapIntUint32) Len 

func (cm *ConMapIntUint32) Len() int

Get gets the uint32 value for the given int key.

func (*ConMapIntUint32) Set 

func (cm *ConMapIntUint32) Set(k int, v uint32)

Set sets the uint32 value for the specified int key.

type ConMapIntUint64 

type ConMapIntUint64 struct {
	// M is the underlying map[Int]Uint64.
	M map[int]uint64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapIntUint64 is a concurrent safe wrapper around a map[Int]Uint64.

func NewConMapIntUint64 

func NewConMapIntUint64() *ConMapIntUint64

NewConMapIntUint64 creates a new concurrent safe map storing uint64 values, for int keys.

func ToConMapIntUint64 

func ToConMapIntUint64(data map[int]uint64) *ConMapIntUint64

ToConMapIntUint64 creates a new ConMapIntUint64 prepopulated with the data from the specified map[Int]Uint64.

func (*ConMapIntUint64) Delete 

func (cm *ConMapIntUint64) Delete(k int) (uint64, bool)

Delete removes the specified int key, returning its uint64 value and a bool indicating whether the delete occurred or not.

func (*ConMapIntUint64) Get 

func (cm *ConMapIntUint64) Get(k int) uint64

Get gets the uint64 value for the given int key.

func (*ConMapIntUint64) GetOK 

func (cm *ConMapIntUint64) GetOK(k int) (uint64, bool)

GetOK gets the uint64 value for the given int key, and a bool indicating whether the key was present or not.

func (*ConMapIntUint64) Len 

func (cm *ConMapIntUint64) Len() int

Get gets the uint64 value for the given int key.

func (*ConMapIntUint64) Set 

func (cm *ConMapIntUint64) Set(k int, v uint64)

Set sets the uint64 value for the specified int key.

type ConMapIntUint8 

type ConMapIntUint8 struct {
	// M is the underlying map[Int]Uint8.
	M map[int]uint8
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapIntUint8 is a concurrent safe wrapper around a map[Int]Uint8.

func NewConMapIntUint8 

func NewConMapIntUint8() *ConMapIntUint8

NewConMapIntUint8 creates a new concurrent safe map storing uint8 values, for int keys.

func ToConMapIntUint8 

func ToConMapIntUint8(data map[int]uint8) *ConMapIntUint8

ToConMapIntUint8 creates a new ConMapIntUint8 prepopulated with the data from the specified map[Int]Uint8.

func (*ConMapIntUint8) Delete 

func (cm *ConMapIntUint8) Delete(k int) (uint8, bool)

Delete removes the specified int key, returning its uint8 value and a bool indicating whether the delete occurred or not.

func (*ConMapIntUint8) Get 

func (cm *ConMapIntUint8) Get(k int) uint8

Get gets the uint8 value for the given int key.

func (*ConMapIntUint8) GetOK 

func (cm *ConMapIntUint8) GetOK(k int) (uint8, bool)

GetOK gets the uint8 value for the given int key, and a bool indicating whether the key was present or not.

func (*ConMapIntUint8) Len 

func (cm *ConMapIntUint8) Len() int

Get gets the uint8 value for the given int key.

func (*ConMapIntUint8) Set 

func (cm *ConMapIntUint8) Set(k int, v uint8)

Set sets the uint8 value for the specified int key.

type ConMapIntUintptr 

type ConMapIntUintptr struct {
	// M is the underlying map[Int]Uintptr.
	M map[int]uintptr
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapIntUintptr is a concurrent safe wrapper around a map[Int]Uintptr.

func NewConMapIntUintptr 

func NewConMapIntUintptr() *ConMapIntUintptr

NewConMapIntUintptr creates a new concurrent safe map storing uintptr values, for int keys.

func ToConMapIntUintptr 

func ToConMapIntUintptr(data map[int]uintptr) *ConMapIntUintptr

ToConMapIntUintptr creates a new ConMapIntUintptr prepopulated with the data from the specified map[Int]Uintptr.

func (*ConMapIntUintptr) Delete 

func (cm *ConMapIntUintptr) Delete(k int) (uintptr, bool)

Delete removes the specified int key, returning its uintptr value and a bool indicating whether the delete occurred or not.

func (*ConMapIntUintptr) Get 

func (cm *ConMapIntUintptr) Get(k int) uintptr

Get gets the uintptr value for the given int key.

func (*ConMapIntUintptr) GetOK 

func (cm *ConMapIntUintptr) GetOK(k int) (uintptr, bool)

GetOK gets the uintptr value for the given int key, and a bool indicating whether the key was present or not.

func (*ConMapIntUintptr) Len 

func (cm *ConMapIntUintptr) Len() int

Get gets the uintptr value for the given int key.

func (*ConMapIntUintptr) Set 

func (cm *ConMapIntUintptr) Set(k int, v uintptr)

Set sets the uintptr value for the specified int key.

type ConMapKeyTypeValueType 

type ConMapKeyTypeValueType struct {
	// M is the underlying map[KeyType]ValueType.
	M map[KeyType]ValueType
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapKeyTypeValueType is a concurrent safe wrapper around a map[KeyType]ValueType.

func NewConMapKeyTypeValueType 

func NewConMapKeyTypeValueType() *ConMapKeyTypeValueType

NewConMapKeyTypeValueType creates a new concurrent safe map storing ValueType values, for KeyType keys.

func ToConMapKeyTypeValueType 

func ToConMapKeyTypeValueType(data map[KeyType]ValueType) *ConMapKeyTypeValueType

ToConMapKeyTypeValueType creates a new ConMapKeyTypeValueType prepopulated with the data from the specified map[KeyType]ValueType.

func (*ConMapKeyTypeValueType) Delete 

func (cm *ConMapKeyTypeValueType) Delete(k KeyType) (ValueType, bool)

Delete removes the specified KeyType key, returning its ValueType value and a bool indicating whether the delete occurred or not.

func (*ConMapKeyTypeValueType) Get 

func (cm *ConMapKeyTypeValueType) Get(k KeyType) ValueType

Get gets the ValueType value for the given KeyType key.

func (*ConMapKeyTypeValueType) GetOK 

func (cm *ConMapKeyTypeValueType) GetOK(k KeyType) (ValueType, bool)

GetOK gets the ValueType value for the given KeyType key, and a bool indicating whether the key was present or not.

func (*ConMapKeyTypeValueType) Len 

func (cm *ConMapKeyTypeValueType) Len() int

Get gets the ValueType value for the given KeyType key.

func (*ConMapKeyTypeValueType) Set 

func (cm *ConMapKeyTypeValueType) Set(k KeyType, v ValueType)

Set sets the ValueType value for the specified KeyType key.

type ConMapRuneBool 

type ConMapRuneBool struct {
	// M is the underlying map[Rune]Bool.
	M map[rune]bool
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapRuneBool is a concurrent safe wrapper around a map[Rune]Bool.

func NewConMapRuneBool 

func NewConMapRuneBool() *ConMapRuneBool

NewConMapRuneBool creates a new concurrent safe map storing bool values, for rune keys.

func ToConMapRuneBool 

func ToConMapRuneBool(data map[rune]bool) *ConMapRuneBool

ToConMapRuneBool creates a new ConMapRuneBool prepopulated with the data from the specified map[Rune]Bool.

func (*ConMapRuneBool) Delete 

func (cm *ConMapRuneBool) Delete(k rune) (bool, bool)

Delete removes the specified rune key, returning its bool value and a bool indicating whether the delete occurred or not.

func (*ConMapRuneBool) Get 

func (cm *ConMapRuneBool) Get(k rune) bool

Get gets the bool value for the given rune key.

func (*ConMapRuneBool) GetOK 

func (cm *ConMapRuneBool) GetOK(k rune) (bool, bool)

GetOK gets the bool value for the given rune key, and a bool indicating whether the key was present or not.

func (*ConMapRuneBool) Len 

func (cm *ConMapRuneBool) Len() int

Get gets the bool value for the given rune key.

func (*ConMapRuneBool) Set 

func (cm *ConMapRuneBool) Set(k rune, v bool)

Set sets the bool value for the specified rune key.

type ConMapRuneByte 

type ConMapRuneByte struct {
	// M is the underlying map[Rune]Byte.
	M map[rune]byte
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapRuneByte is a concurrent safe wrapper around a map[Rune]Byte.

func NewConMapRuneByte 

func NewConMapRuneByte() *ConMapRuneByte

NewConMapRuneByte creates a new concurrent safe map storing byte values, for rune keys.

func ToConMapRuneByte 

func ToConMapRuneByte(data map[rune]byte) *ConMapRuneByte

ToConMapRuneByte creates a new ConMapRuneByte prepopulated with the data from the specified map[Rune]Byte.

func (*ConMapRuneByte) Delete 

func (cm *ConMapRuneByte) Delete(k rune) (byte, bool)

Delete removes the specified rune key, returning its byte value and a bool indicating whether the delete occurred or not.

func (*ConMapRuneByte) Get 

func (cm *ConMapRuneByte) Get(k rune) byte

Get gets the byte value for the given rune key.

func (*ConMapRuneByte) GetOK 

func (cm *ConMapRuneByte) GetOK(k rune) (byte, bool)

GetOK gets the byte value for the given rune key, and a bool indicating whether the key was present or not.

func (*ConMapRuneByte) Len 

func (cm *ConMapRuneByte) Len() int

Get gets the byte value for the given rune key.

func (*ConMapRuneByte) Set 

func (cm *ConMapRuneByte) Set(k rune, v byte)

Set sets the byte value for the specified rune key.

type ConMapRuneComplex128 

type ConMapRuneComplex128 struct {
	// M is the underlying map[Rune]Complex128.
	M map[rune]complex128
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapRuneComplex128 is a concurrent safe wrapper around a map[Rune]Complex128.

func NewConMapRuneComplex128 

func NewConMapRuneComplex128() *ConMapRuneComplex128

NewConMapRuneComplex128 creates a new concurrent safe map storing complex128 values, for rune keys.

func ToConMapRuneComplex128 

func ToConMapRuneComplex128(data map[rune]complex128) *ConMapRuneComplex128

ToConMapRuneComplex128 creates a new ConMapRuneComplex128 prepopulated with the data from the specified map[Rune]Complex128.

func (*ConMapRuneComplex128) Delete 

func (cm *ConMapRuneComplex128) Delete(k rune) (complex128, bool)

Delete removes the specified rune key, returning its complex128 value and a bool indicating whether the delete occurred or not.

func (*ConMapRuneComplex128) Get 

func (cm *ConMapRuneComplex128) Get(k rune) complex128

Get gets the complex128 value for the given rune key.

func (*ConMapRuneComplex128) GetOK 

func (cm *ConMapRuneComplex128) GetOK(k rune) (complex128, bool)

GetOK gets the complex128 value for the given rune key, and a bool indicating whether the key was present or not.

func (*ConMapRuneComplex128) Len 

func (cm *ConMapRuneComplex128) Len() int

Get gets the complex128 value for the given rune key.

func (*ConMapRuneComplex128) Set 

func (cm *ConMapRuneComplex128) Set(k rune, v complex128)

Set sets the complex128 value for the specified rune key.

type ConMapRuneComplex64 

type ConMapRuneComplex64 struct {
	// M is the underlying map[Rune]Complex64.
	M map[rune]complex64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapRuneComplex64 is a concurrent safe wrapper around a map[Rune]Complex64.

func NewConMapRuneComplex64 

func NewConMapRuneComplex64() *ConMapRuneComplex64

NewConMapRuneComplex64 creates a new concurrent safe map storing complex64 values, for rune keys.

func ToConMapRuneComplex64 

func ToConMapRuneComplex64(data map[rune]complex64) *ConMapRuneComplex64

ToConMapRuneComplex64 creates a new ConMapRuneComplex64 prepopulated with the data from the specified map[Rune]Complex64.

func (*ConMapRuneComplex64) Delete 

func (cm *ConMapRuneComplex64) Delete(k rune) (complex64, bool)

Delete removes the specified rune key, returning its complex64 value and a bool indicating whether the delete occurred or not.

func (*ConMapRuneComplex64) Get 

func (cm *ConMapRuneComplex64) Get(k rune) complex64

Get gets the complex64 value for the given rune key.

func (*ConMapRuneComplex64) GetOK 

func (cm *ConMapRuneComplex64) GetOK(k rune) (complex64, bool)

GetOK gets the complex64 value for the given rune key, and a bool indicating whether the key was present or not.

func (*ConMapRuneComplex64) Len 

func (cm *ConMapRuneComplex64) Len() int

Get gets the complex64 value for the given rune key.

func (*ConMapRuneComplex64) Set 

func (cm *ConMapRuneComplex64) Set(k rune, v complex64)

Set sets the complex64 value for the specified rune key.

type ConMapRuneError 

type ConMapRuneError struct {
	// M is the underlying map[Rune]Error.
	M map[rune]error
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapRuneError is a concurrent safe wrapper around a map[Rune]Error.

func NewConMapRuneError 

func NewConMapRuneError() *ConMapRuneError

NewConMapRuneError creates a new concurrent safe map storing error values, for rune keys.

func ToConMapRuneError 

func ToConMapRuneError(data map[rune]error) *ConMapRuneError

ToConMapRuneError creates a new ConMapRuneError prepopulated with the data from the specified map[Rune]Error.

func (*ConMapRuneError) Delete 

func (cm *ConMapRuneError) Delete(k rune) (error, bool)

Delete removes the specified rune key, returning its error value and a bool indicating whether the delete occurred or not.

func (*ConMapRuneError) Get 

func (cm *ConMapRuneError) Get(k rune) error

Get gets the error value for the given rune key.

func (*ConMapRuneError) GetOK 

func (cm *ConMapRuneError) GetOK(k rune) (error, bool)

GetOK gets the error value for the given rune key, and a bool indicating whether the key was present or not.

func (*ConMapRuneError) Len 

func (cm *ConMapRuneError) Len() int

Get gets the error value for the given rune key.

func (*ConMapRuneError) Set 

func (cm *ConMapRuneError) Set(k rune, v error)

Set sets the error value for the specified rune key.

type ConMapRuneFloat32 

type ConMapRuneFloat32 struct {
	// M is the underlying map[Rune]Float32.
	M map[rune]float32
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapRuneFloat32 is a concurrent safe wrapper around a map[Rune]Float32.

func NewConMapRuneFloat32 

func NewConMapRuneFloat32() *ConMapRuneFloat32

NewConMapRuneFloat32 creates a new concurrent safe map storing float32 values, for rune keys.

func ToConMapRuneFloat32 

func ToConMapRuneFloat32(data map[rune]float32) *ConMapRuneFloat32

ToConMapRuneFloat32 creates a new ConMapRuneFloat32 prepopulated with the data from the specified map[Rune]Float32.

func (*ConMapRuneFloat32) Delete 

func (cm *ConMapRuneFloat32) Delete(k rune) (float32, bool)

Delete removes the specified rune key, returning its float32 value and a bool indicating whether the delete occurred or not.

func (*ConMapRuneFloat32) Get 

func (cm *ConMapRuneFloat32) Get(k rune) float32

Get gets the float32 value for the given rune key.

func (*ConMapRuneFloat32) GetOK 

func (cm *ConMapRuneFloat32) GetOK(k rune) (float32, bool)

GetOK gets the float32 value for the given rune key, and a bool indicating whether the key was present or not.

func (*ConMapRuneFloat32) Len 

func (cm *ConMapRuneFloat32) Len() int

Get gets the float32 value for the given rune key.

func (*ConMapRuneFloat32) Set 

func (cm *ConMapRuneFloat32) Set(k rune, v float32)

Set sets the float32 value for the specified rune key.

type ConMapRuneFloat64 

type ConMapRuneFloat64 struct {
	// M is the underlying map[Rune]Float64.
	M map[rune]float64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapRuneFloat64 is a concurrent safe wrapper around a map[Rune]Float64.

func NewConMapRuneFloat64 

func NewConMapRuneFloat64() *ConMapRuneFloat64

NewConMapRuneFloat64 creates a new concurrent safe map storing float64 values, for rune keys.

func ToConMapRuneFloat64 

func ToConMapRuneFloat64(data map[rune]float64) *ConMapRuneFloat64

ToConMapRuneFloat64 creates a new ConMapRuneFloat64 prepopulated with the data from the specified map[Rune]Float64.

func (*ConMapRuneFloat64) Delete 

func (cm *ConMapRuneFloat64) Delete(k rune) (float64, bool)

Delete removes the specified rune key, returning its float64 value and a bool indicating whether the delete occurred or not.

func (*ConMapRuneFloat64) Get 

func (cm *ConMapRuneFloat64) Get(k rune) float64

Get gets the float64 value for the given rune key.

func (*ConMapRuneFloat64) GetOK 

func (cm *ConMapRuneFloat64) GetOK(k rune) (float64, bool)

GetOK gets the float64 value for the given rune key, and a bool indicating whether the key was present or not.

func (*ConMapRuneFloat64) Len 

func (cm *ConMapRuneFloat64) Len() int

Get gets the float64 value for the given rune key.

func (*ConMapRuneFloat64) Set 

func (cm *ConMapRuneFloat64) Set(k rune, v float64)

Set sets the float64 value for the specified rune key.

type ConMapRuneInt 

type ConMapRuneInt struct {
	// M is the underlying map[Rune]Int.
	M map[rune]int
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapRuneInt is a concurrent safe wrapper around a map[Rune]Int.

func NewConMapRuneInt 

func NewConMapRuneInt() *ConMapRuneInt

NewConMapRuneInt creates a new concurrent safe map storing int values, for rune keys.

func ToConMapRuneInt 

func ToConMapRuneInt(data map[rune]int) *ConMapRuneInt

ToConMapRuneInt creates a new ConMapRuneInt prepopulated with the data from the specified map[Rune]Int.

func (*ConMapRuneInt) Delete 

func (cm *ConMapRuneInt) Delete(k rune) (int, bool)

Delete removes the specified rune key, returning its int value and a bool indicating whether the delete occurred or not.

func (*ConMapRuneInt) Get 

func (cm *ConMapRuneInt) Get(k rune) int

Get gets the int value for the given rune key.

func (*ConMapRuneInt) GetOK 

func (cm *ConMapRuneInt) GetOK(k rune) (int, bool)

GetOK gets the int value for the given rune key, and a bool indicating whether the key was present or not.

func (*ConMapRuneInt) Len 

func (cm *ConMapRuneInt) Len() int

Get gets the int value for the given rune key.

func (*ConMapRuneInt) Set 

func (cm *ConMapRuneInt) Set(k rune, v int)

Set sets the int value for the specified rune key.

type ConMapRuneInt16 

type ConMapRuneInt16 struct {
	// M is the underlying map[Rune]Int16.
	M map[rune]int16
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapRuneInt16 is a concurrent safe wrapper around a map[Rune]Int16.

func NewConMapRuneInt16 

func NewConMapRuneInt16() *ConMapRuneInt16

NewConMapRuneInt16 creates a new concurrent safe map storing int16 values, for rune keys.

func ToConMapRuneInt16 

func ToConMapRuneInt16(data map[rune]int16) *ConMapRuneInt16

ToConMapRuneInt16 creates a new ConMapRuneInt16 prepopulated with the data from the specified map[Rune]Int16.

func (*ConMapRuneInt16) Delete 

func (cm *ConMapRuneInt16) Delete(k rune) (int16, bool)

Delete removes the specified rune key, returning its int16 value and a bool indicating whether the delete occurred or not.

func (*ConMapRuneInt16) Get 

func (cm *ConMapRuneInt16) Get(k rune) int16

Get gets the int16 value for the given rune key.

func (*ConMapRuneInt16) GetOK 

func (cm *ConMapRuneInt16) GetOK(k rune) (int16, bool)

GetOK gets the int16 value for the given rune key, and a bool indicating whether the key was present or not.

func (*ConMapRuneInt16) Len 

func (cm *ConMapRuneInt16) Len() int

Get gets the int16 value for the given rune key.

func (*ConMapRuneInt16) Set 

func (cm *ConMapRuneInt16) Set(k rune, v int16)

Set sets the int16 value for the specified rune key.

type ConMapRuneInt32 

type ConMapRuneInt32 struct {
	// M is the underlying map[Rune]Int32.
	M map[rune]int32
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapRuneInt32 is a concurrent safe wrapper around a map[Rune]Int32.

func NewConMapRuneInt32 

func NewConMapRuneInt32() *ConMapRuneInt32

NewConMapRuneInt32 creates a new concurrent safe map storing int32 values, for rune keys.

func ToConMapRuneInt32 

func ToConMapRuneInt32(data map[rune]int32) *ConMapRuneInt32

ToConMapRuneInt32 creates a new ConMapRuneInt32 prepopulated with the data from the specified map[Rune]Int32.

func (*ConMapRuneInt32) Delete 

func (cm *ConMapRuneInt32) Delete(k rune) (int32, bool)

Delete removes the specified rune key, returning its int32 value and a bool indicating whether the delete occurred or not.

func (*ConMapRuneInt32) Get 

func (cm *ConMapRuneInt32) Get(k rune) int32

Get gets the int32 value for the given rune key.

func (*ConMapRuneInt32) GetOK 

func (cm *ConMapRuneInt32) GetOK(k rune) (int32, bool)

GetOK gets the int32 value for the given rune key, and a bool indicating whether the key was present or not.

func (*ConMapRuneInt32) Len 

func (cm *ConMapRuneInt32) Len() int

Get gets the int32 value for the given rune key.

func (*ConMapRuneInt32) Set 

func (cm *ConMapRuneInt32) Set(k rune, v int32)

Set sets the int32 value for the specified rune key.

type ConMapRuneInt64 

type ConMapRuneInt64 struct {
	// M is the underlying map[Rune]Int64.
	M map[rune]int64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapRuneInt64 is a concurrent safe wrapper around a map[Rune]Int64.

func NewConMapRuneInt64 

func NewConMapRuneInt64() *ConMapRuneInt64

NewConMapRuneInt64 creates a new concurrent safe map storing int64 values, for rune keys.

func ToConMapRuneInt64 

func ToConMapRuneInt64(data map[rune]int64) *ConMapRuneInt64

ToConMapRuneInt64 creates a new ConMapRuneInt64 prepopulated with the data from the specified map[Rune]Int64.

func (*ConMapRuneInt64) Delete 

func (cm *ConMapRuneInt64) Delete(k rune) (int64, bool)

Delete removes the specified rune key, returning its int64 value and a bool indicating whether the delete occurred or not.

func (*ConMapRuneInt64) Get 

func (cm *ConMapRuneInt64) Get(k rune) int64

Get gets the int64 value for the given rune key.

func (*ConMapRuneInt64) GetOK 

func (cm *ConMapRuneInt64) GetOK(k rune) (int64, bool)

GetOK gets the int64 value for the given rune key, and a bool indicating whether the key was present or not.

func (*ConMapRuneInt64) Len 

func (cm *ConMapRuneInt64) Len() int

Get gets the int64 value for the given rune key.

func (*ConMapRuneInt64) Set 

func (cm *ConMapRuneInt64) Set(k rune, v int64)

Set sets the int64 value for the specified rune key.

type ConMapRuneInt8 

type ConMapRuneInt8 struct {
	// M is the underlying map[Rune]Int8.
	M map[rune]int8
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapRuneInt8 is a concurrent safe wrapper around a map[Rune]Int8.

func NewConMapRuneInt8 

func NewConMapRuneInt8() *ConMapRuneInt8

NewConMapRuneInt8 creates a new concurrent safe map storing int8 values, for rune keys.

func ToConMapRuneInt8 

func ToConMapRuneInt8(data map[rune]int8) *ConMapRuneInt8

ToConMapRuneInt8 creates a new ConMapRuneInt8 prepopulated with the data from the specified map[Rune]Int8.

func (*ConMapRuneInt8) Delete 

func (cm *ConMapRuneInt8) Delete(k rune) (int8, bool)

Delete removes the specified rune key, returning its int8 value and a bool indicating whether the delete occurred or not.

func (*ConMapRuneInt8) Get 

func (cm *ConMapRuneInt8) Get(k rune) int8

Get gets the int8 value for the given rune key.

func (*ConMapRuneInt8) GetOK 

func (cm *ConMapRuneInt8) GetOK(k rune) (int8, bool)

GetOK gets the int8 value for the given rune key, and a bool indicating whether the key was present or not.

func (*ConMapRuneInt8) Len 

func (cm *ConMapRuneInt8) Len() int

Get gets the int8 value for the given rune key.

func (*ConMapRuneInt8) Set 

func (cm *ConMapRuneInt8) Set(k rune, v int8)

Set sets the int8 value for the specified rune key.

type ConMapRuneRune 

type ConMapRuneRune struct {
	// M is the underlying map[Rune]Rune.
	M map[rune]rune
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapRuneRune is a concurrent safe wrapper around a map[Rune]Rune.

func NewConMapRuneRune 

func NewConMapRuneRune() *ConMapRuneRune

NewConMapRuneRune creates a new concurrent safe map storing rune values, for rune keys.

func ToConMapRuneRune 

func ToConMapRuneRune(data map[rune]rune) *ConMapRuneRune

ToConMapRuneRune creates a new ConMapRuneRune prepopulated with the data from the specified map[Rune]Rune.

func (*ConMapRuneRune) Delete 

func (cm *ConMapRuneRune) Delete(k rune) (rune, bool)

Delete removes the specified rune key, returning its rune value and a bool indicating whether the delete occurred or not.

func (*ConMapRuneRune) Get 

func (cm *ConMapRuneRune) Get(k rune) rune

Get gets the rune value for the given rune key.

func (*ConMapRuneRune) GetOK 

func (cm *ConMapRuneRune) GetOK(k rune) (rune, bool)

GetOK gets the rune value for the given rune key, and a bool indicating whether the key was present or not.

func (*ConMapRuneRune) Len 

func (cm *ConMapRuneRune) Len() int

Get gets the rune value for the given rune key.

func (*ConMapRuneRune) Set 

func (cm *ConMapRuneRune) Set(k rune, v rune)

Set sets the rune value for the specified rune key.

type ConMapRuneString 

type ConMapRuneString struct {
	// M is the underlying map[Rune]String.
	M map[rune]string
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapRuneString is a concurrent safe wrapper around a map[Rune]String.

func NewConMapRuneString 

func NewConMapRuneString() *ConMapRuneString

NewConMapRuneString creates a new concurrent safe map storing string values, for rune keys.

func ToConMapRuneString 

func ToConMapRuneString(data map[rune]string) *ConMapRuneString

ToConMapRuneString creates a new ConMapRuneString prepopulated with the data from the specified map[Rune]String.

func (*ConMapRuneString) Delete 

func (cm *ConMapRuneString) Delete(k rune) (string, bool)

Delete removes the specified rune key, returning its string value and a bool indicating whether the delete occurred or not.

func (*ConMapRuneString) Get 

func (cm *ConMapRuneString) Get(k rune) string

Get gets the string value for the given rune key.

func (*ConMapRuneString) GetOK 

func (cm *ConMapRuneString) GetOK(k rune) (string, bool)

GetOK gets the string value for the given rune key, and a bool indicating whether the key was present or not.

func (*ConMapRuneString) Len 

func (cm *ConMapRuneString) Len() int

Get gets the string value for the given rune key.

func (*ConMapRuneString) Set 

func (cm *ConMapRuneString) Set(k rune, v string)

Set sets the string value for the specified rune key.

type ConMapRuneUint 

type ConMapRuneUint struct {
	// M is the underlying map[Rune]Uint.
	M map[rune]uint
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapRuneUint is a concurrent safe wrapper around a map[Rune]Uint.

func NewConMapRuneUint 

func NewConMapRuneUint() *ConMapRuneUint

NewConMapRuneUint creates a new concurrent safe map storing uint values, for rune keys.

func ToConMapRuneUint 

func ToConMapRuneUint(data map[rune]uint) *ConMapRuneUint

ToConMapRuneUint creates a new ConMapRuneUint prepopulated with the data from the specified map[Rune]Uint.

func (*ConMapRuneUint) Delete 

func (cm *ConMapRuneUint) Delete(k rune) (uint, bool)

Delete removes the specified rune key, returning its uint value and a bool indicating whether the delete occurred or not.

func (*ConMapRuneUint) Get 

func (cm *ConMapRuneUint) Get(k rune) uint

Get gets the uint value for the given rune key.

func (*ConMapRuneUint) GetOK 

func (cm *ConMapRuneUint) GetOK(k rune) (uint, bool)

GetOK gets the uint value for the given rune key, and a bool indicating whether the key was present or not.

func (*ConMapRuneUint) Len 

func (cm *ConMapRuneUint) Len() int

Get gets the uint value for the given rune key.

func (*ConMapRuneUint) Set 

func (cm *ConMapRuneUint) Set(k rune, v uint)

Set sets the uint value for the specified rune key.

type ConMapRuneUint16 

type ConMapRuneUint16 struct {
	// M is the underlying map[Rune]Uint16.
	M map[rune]uint16
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapRuneUint16 is a concurrent safe wrapper around a map[Rune]Uint16.

func NewConMapRuneUint16 

func NewConMapRuneUint16() *ConMapRuneUint16

NewConMapRuneUint16 creates a new concurrent safe map storing uint16 values, for rune keys.

func ToConMapRuneUint16 

func ToConMapRuneUint16(data map[rune]uint16) *ConMapRuneUint16

ToConMapRuneUint16 creates a new ConMapRuneUint16 prepopulated with the data from the specified map[Rune]Uint16.

func (*ConMapRuneUint16) Delete 

func (cm *ConMapRuneUint16) Delete(k rune) (uint16, bool)

Delete removes the specified rune key, returning its uint16 value and a bool indicating whether the delete occurred or not.

func (*ConMapRuneUint16) Get 

func (cm *ConMapRuneUint16) Get(k rune) uint16

Get gets the uint16 value for the given rune key.

func (*ConMapRuneUint16) GetOK 

func (cm *ConMapRuneUint16) GetOK(k rune) (uint16, bool)

GetOK gets the uint16 value for the given rune key, and a bool indicating whether the key was present or not.

func (*ConMapRuneUint16) Len 

func (cm *ConMapRuneUint16) Len() int

Get gets the uint16 value for the given rune key.

func (*ConMapRuneUint16) Set 

func (cm *ConMapRuneUint16) Set(k rune, v uint16)

Set sets the uint16 value for the specified rune key.

type ConMapRuneUint32 

type ConMapRuneUint32 struct {
	// M is the underlying map[Rune]Uint32.
	M map[rune]uint32
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapRuneUint32 is a concurrent safe wrapper around a map[Rune]Uint32.

func NewConMapRuneUint32 

func NewConMapRuneUint32() *ConMapRuneUint32

NewConMapRuneUint32 creates a new concurrent safe map storing uint32 values, for rune keys.

func ToConMapRuneUint32 

func ToConMapRuneUint32(data map[rune]uint32) *ConMapRuneUint32

ToConMapRuneUint32 creates a new ConMapRuneUint32 prepopulated with the data from the specified map[Rune]Uint32.

func (*ConMapRuneUint32) Delete 

func (cm *ConMapRuneUint32) Delete(k rune) (uint32, bool)

Delete removes the specified rune key, returning its uint32 value and a bool indicating whether the delete occurred or not.

func (*ConMapRuneUint32) Get 

func (cm *ConMapRuneUint32) Get(k rune) uint32

Get gets the uint32 value for the given rune key.

func (*ConMapRuneUint32) GetOK 

func (cm *ConMapRuneUint32) GetOK(k rune) (uint32, bool)

GetOK gets the uint32 value for the given rune key, and a bool indicating whether the key was present or not.

func (*ConMapRuneUint32) Len 

func (cm *ConMapRuneUint32) Len() int

Get gets the uint32 value for the given rune key.

func (*ConMapRuneUint32) Set 

func (cm *ConMapRuneUint32) Set(k rune, v uint32)

Set sets the uint32 value for the specified rune key.

type ConMapRuneUint64 

type ConMapRuneUint64 struct {
	// M is the underlying map[Rune]Uint64.
	M map[rune]uint64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapRuneUint64 is a concurrent safe wrapper around a map[Rune]Uint64.

func NewConMapRuneUint64 

func NewConMapRuneUint64() *ConMapRuneUint64

NewConMapRuneUint64 creates a new concurrent safe map storing uint64 values, for rune keys.

func ToConMapRuneUint64 

func ToConMapRuneUint64(data map[rune]uint64) *ConMapRuneUint64

ToConMapRuneUint64 creates a new ConMapRuneUint64 prepopulated with the data from the specified map[Rune]Uint64.

func (*ConMapRuneUint64) Delete 

func (cm *ConMapRuneUint64) Delete(k rune) (uint64, bool)

Delete removes the specified rune key, returning its uint64 value and a bool indicating whether the delete occurred or not.

func (*ConMapRuneUint64) Get 

func (cm *ConMapRuneUint64) Get(k rune) uint64

Get gets the uint64 value for the given rune key.

func (*ConMapRuneUint64) GetOK 

func (cm *ConMapRuneUint64) GetOK(k rune) (uint64, bool)

GetOK gets the uint64 value for the given rune key, and a bool indicating whether the key was present or not.

func (*ConMapRuneUint64) Len 

func (cm *ConMapRuneUint64) Len() int

Get gets the uint64 value for the given rune key.

func (*ConMapRuneUint64) Set 

func (cm *ConMapRuneUint64) Set(k rune, v uint64)

Set sets the uint64 value for the specified rune key.

type ConMapRuneUint8 

type ConMapRuneUint8 struct {
	// M is the underlying map[Rune]Uint8.
	M map[rune]uint8
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapRuneUint8 is a concurrent safe wrapper around a map[Rune]Uint8.

func NewConMapRuneUint8 

func NewConMapRuneUint8() *ConMapRuneUint8

NewConMapRuneUint8 creates a new concurrent safe map storing uint8 values, for rune keys.

func ToConMapRuneUint8 

func ToConMapRuneUint8(data map[rune]uint8) *ConMapRuneUint8

ToConMapRuneUint8 creates a new ConMapRuneUint8 prepopulated with the data from the specified map[Rune]Uint8.

func (*ConMapRuneUint8) Delete 

func (cm *ConMapRuneUint8) Delete(k rune) (uint8, bool)

Delete removes the specified rune key, returning its uint8 value and a bool indicating whether the delete occurred or not.

func (*ConMapRuneUint8) Get 

func (cm *ConMapRuneUint8) Get(k rune) uint8

Get gets the uint8 value for the given rune key.

func (*ConMapRuneUint8) GetOK 

func (cm *ConMapRuneUint8) GetOK(k rune) (uint8, bool)

GetOK gets the uint8 value for the given rune key, and a bool indicating whether the key was present or not.

func (*ConMapRuneUint8) Len 

func (cm *ConMapRuneUint8) Len() int

Get gets the uint8 value for the given rune key.

func (*ConMapRuneUint8) Set 

func (cm *ConMapRuneUint8) Set(k rune, v uint8)

Set sets the uint8 value for the specified rune key.

type ConMapRuneUintptr 

type ConMapRuneUintptr struct {
	// M is the underlying map[Rune]Uintptr.
	M map[rune]uintptr
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapRuneUintptr is a concurrent safe wrapper around a map[Rune]Uintptr.

func NewConMapRuneUintptr 

func NewConMapRuneUintptr() *ConMapRuneUintptr

NewConMapRuneUintptr creates a new concurrent safe map storing uintptr values, for rune keys.

func ToConMapRuneUintptr 

func ToConMapRuneUintptr(data map[rune]uintptr) *ConMapRuneUintptr

ToConMapRuneUintptr creates a new ConMapRuneUintptr prepopulated with the data from the specified map[Rune]Uintptr.

func (*ConMapRuneUintptr) Delete 

func (cm *ConMapRuneUintptr) Delete(k rune) (uintptr, bool)

Delete removes the specified rune key, returning its uintptr value and a bool indicating whether the delete occurred or not.

func (*ConMapRuneUintptr) Get 

func (cm *ConMapRuneUintptr) Get(k rune) uintptr

Get gets the uintptr value for the given rune key.

func (*ConMapRuneUintptr) GetOK 

func (cm *ConMapRuneUintptr) GetOK(k rune) (uintptr, bool)

GetOK gets the uintptr value for the given rune key, and a bool indicating whether the key was present or not.

func (*ConMapRuneUintptr) Len 

func (cm *ConMapRuneUintptr) Len() int

Get gets the uintptr value for the given rune key.

func (*ConMapRuneUintptr) Set 

func (cm *ConMapRuneUintptr) Set(k rune, v uintptr)

Set sets the uintptr value for the specified rune key.

type ConMapStringBool 

type ConMapStringBool struct {
	// M is the underlying map[String]Bool.
	M map[string]bool
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapStringBool is a concurrent safe wrapper around a map[String]Bool.

func NewConMapStringBool 

func NewConMapStringBool() *ConMapStringBool

NewConMapStringBool creates a new concurrent safe map storing bool values, for string keys.

func ToConMapStringBool 

func ToConMapStringBool(data map[string]bool) *ConMapStringBool

ToConMapStringBool creates a new ConMapStringBool prepopulated with the data from the specified map[String]Bool.

func (*ConMapStringBool) Delete 

func (cm *ConMapStringBool) Delete(k string) (bool, bool)

Delete removes the specified string key, returning its bool value and a bool indicating whether the delete occurred or not.

func (*ConMapStringBool) Get 

func (cm *ConMapStringBool) Get(k string) bool

Get gets the bool value for the given string key.

func (*ConMapStringBool) GetOK 

func (cm *ConMapStringBool) GetOK(k string) (bool, bool)

GetOK gets the bool value for the given string key, and a bool indicating whether the key was present or not.

func (*ConMapStringBool) Len 

func (cm *ConMapStringBool) Len() int

Get gets the bool value for the given string key.

func (*ConMapStringBool) Set 

func (cm *ConMapStringBool) Set(k string, v bool)

Set sets the bool value for the specified string key.

type ConMapStringByte 

type ConMapStringByte struct {
	// M is the underlying map[String]Byte.
	M map[string]byte
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapStringByte is a concurrent safe wrapper around a map[String]Byte.

func NewConMapStringByte 

func NewConMapStringByte() *ConMapStringByte

NewConMapStringByte creates a new concurrent safe map storing byte values, for string keys.

func ToConMapStringByte 

func ToConMapStringByte(data map[string]byte) *ConMapStringByte

ToConMapStringByte creates a new ConMapStringByte prepopulated with the data from the specified map[String]Byte.

func (*ConMapStringByte) Delete 

func (cm *ConMapStringByte) Delete(k string) (byte, bool)

Delete removes the specified string key, returning its byte value and a bool indicating whether the delete occurred or not.

func (*ConMapStringByte) Get 

func (cm *ConMapStringByte) Get(k string) byte

Get gets the byte value for the given string key.

func (*ConMapStringByte) GetOK 

func (cm *ConMapStringByte) GetOK(k string) (byte, bool)

GetOK gets the byte value for the given string key, and a bool indicating whether the key was present or not.

func (*ConMapStringByte) Len 

func (cm *ConMapStringByte) Len() int

Get gets the byte value for the given string key.

func (*ConMapStringByte) Set 

func (cm *ConMapStringByte) Set(k string, v byte)

Set sets the byte value for the specified string key.

type ConMapStringComplex128 

type ConMapStringComplex128 struct {
	// M is the underlying map[String]Complex128.
	M map[string]complex128
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapStringComplex128 is a concurrent safe wrapper around a map[String]Complex128.

func NewConMapStringComplex128 

func NewConMapStringComplex128() *ConMapStringComplex128

NewConMapStringComplex128 creates a new concurrent safe map storing complex128 values, for string keys.

func ToConMapStringComplex128 

func ToConMapStringComplex128(data map[string]complex128) *ConMapStringComplex128

ToConMapStringComplex128 creates a new ConMapStringComplex128 prepopulated with the data from the specified map[String]Complex128.

func (*ConMapStringComplex128) Delete 

func (cm *ConMapStringComplex128) Delete(k string) (complex128, bool)

Delete removes the specified string key, returning its complex128 value and a bool indicating whether the delete occurred or not.

func (*ConMapStringComplex128) Get 

func (cm *ConMapStringComplex128) Get(k string) complex128

Get gets the complex128 value for the given string key.

func (*ConMapStringComplex128) GetOK 

func (cm *ConMapStringComplex128) GetOK(k string) (complex128, bool)

GetOK gets the complex128 value for the given string key, and a bool indicating whether the key was present or not.

func (*ConMapStringComplex128) Len 

func (cm *ConMapStringComplex128) Len() int

Get gets the complex128 value for the given string key.

func (*ConMapStringComplex128) Set 

func (cm *ConMapStringComplex128) Set(k string, v complex128)

Set sets the complex128 value for the specified string key.

type ConMapStringComplex64 

type ConMapStringComplex64 struct {
	// M is the underlying map[String]Complex64.
	M map[string]complex64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapStringComplex64 is a concurrent safe wrapper around a map[String]Complex64.

func NewConMapStringComplex64 

func NewConMapStringComplex64() *ConMapStringComplex64

NewConMapStringComplex64 creates a new concurrent safe map storing complex64 values, for string keys.

func ToConMapStringComplex64 

func ToConMapStringComplex64(data map[string]complex64) *ConMapStringComplex64

ToConMapStringComplex64 creates a new ConMapStringComplex64 prepopulated with the data from the specified map[String]Complex64.

func (*ConMapStringComplex64) Delete 

func (cm *ConMapStringComplex64) Delete(k string) (complex64, bool)

Delete removes the specified string key, returning its complex64 value and a bool indicating whether the delete occurred or not.

func (*ConMapStringComplex64) Get 

func (cm *ConMapStringComplex64) Get(k string) complex64

Get gets the complex64 value for the given string key.

func (*ConMapStringComplex64) GetOK 

func (cm *ConMapStringComplex64) GetOK(k string) (complex64, bool)

GetOK gets the complex64 value for the given string key, and a bool indicating whether the key was present or not.

func (*ConMapStringComplex64) Len 

func (cm *ConMapStringComplex64) Len() int

Get gets the complex64 value for the given string key.

func (*ConMapStringComplex64) Set 

func (cm *ConMapStringComplex64) Set(k string, v complex64)

Set sets the complex64 value for the specified string key.

type ConMapStringError 

type ConMapStringError struct {
	// M is the underlying map[String]Error.
	M map[string]error
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapStringError is a concurrent safe wrapper around a map[String]Error.

func NewConMapStringError 

func NewConMapStringError() *ConMapStringError

NewConMapStringError creates a new concurrent safe map storing error values, for string keys.

func ToConMapStringError 

func ToConMapStringError(data map[string]error) *ConMapStringError

ToConMapStringError creates a new ConMapStringError prepopulated with the data from the specified map[String]Error.

func (*ConMapStringError) Delete 

func (cm *ConMapStringError) Delete(k string) (error, bool)

Delete removes the specified string key, returning its error value and a bool indicating whether the delete occurred or not.

func (*ConMapStringError) Get 

func (cm *ConMapStringError) Get(k string) error

Get gets the error value for the given string key.

func (*ConMapStringError) GetOK 

func (cm *ConMapStringError) GetOK(k string) (error, bool)

GetOK gets the error value for the given string key, and a bool indicating whether the key was present or not.

func (*ConMapStringError) Len 

func (cm *ConMapStringError) Len() int

Get gets the error value for the given string key.

func (*ConMapStringError) Set 

func (cm *ConMapStringError) Set(k string, v error)

Set sets the error value for the specified string key.

type ConMapStringFloat32 

type ConMapStringFloat32 struct {
	// M is the underlying map[String]Float32.
	M map[string]float32
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapStringFloat32 is a concurrent safe wrapper around a map[String]Float32.

func NewConMapStringFloat32 

func NewConMapStringFloat32() *ConMapStringFloat32

NewConMapStringFloat32 creates a new concurrent safe map storing float32 values, for string keys.

func ToConMapStringFloat32 

func ToConMapStringFloat32(data map[string]float32) *ConMapStringFloat32

ToConMapStringFloat32 creates a new ConMapStringFloat32 prepopulated with the data from the specified map[String]Float32.

func (*ConMapStringFloat32) Delete 

func (cm *ConMapStringFloat32) Delete(k string) (float32, bool)

Delete removes the specified string key, returning its float32 value and a bool indicating whether the delete occurred or not.

func (*ConMapStringFloat32) Get 

func (cm *ConMapStringFloat32) Get(k string) float32

Get gets the float32 value for the given string key.

func (*ConMapStringFloat32) GetOK 

func (cm *ConMapStringFloat32) GetOK(k string) (float32, bool)

GetOK gets the float32 value for the given string key, and a bool indicating whether the key was present or not.

func (*ConMapStringFloat32) Len 

func (cm *ConMapStringFloat32) Len() int

Get gets the float32 value for the given string key.

func (*ConMapStringFloat32) Set 

func (cm *ConMapStringFloat32) Set(k string, v float32)

Set sets the float32 value for the specified string key.

type ConMapStringFloat64 

type ConMapStringFloat64 struct {
	// M is the underlying map[String]Float64.
	M map[string]float64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapStringFloat64 is a concurrent safe wrapper around a map[String]Float64.

func NewConMapStringFloat64 

func NewConMapStringFloat64() *ConMapStringFloat64

NewConMapStringFloat64 creates a new concurrent safe map storing float64 values, for string keys.

func ToConMapStringFloat64 

func ToConMapStringFloat64(data map[string]float64) *ConMapStringFloat64

ToConMapStringFloat64 creates a new ConMapStringFloat64 prepopulated with the data from the specified map[String]Float64.

func (*ConMapStringFloat64) Delete 

func (cm *ConMapStringFloat64) Delete(k string) (float64, bool)

Delete removes the specified string key, returning its float64 value and a bool indicating whether the delete occurred or not.

func (*ConMapStringFloat64) Get 

func (cm *ConMapStringFloat64) Get(k string) float64

Get gets the float64 value for the given string key.

func (*ConMapStringFloat64) GetOK 

func (cm *ConMapStringFloat64) GetOK(k string) (float64, bool)

GetOK gets the float64 value for the given string key, and a bool indicating whether the key was present or not.

func (*ConMapStringFloat64) Len 

func (cm *ConMapStringFloat64) Len() int

Get gets the float64 value for the given string key.

func (*ConMapStringFloat64) Set 

func (cm *ConMapStringFloat64) Set(k string, v float64)

Set sets the float64 value for the specified string key.

type ConMapStringInt 

type ConMapStringInt struct {
	// M is the underlying map[String]Int.
	M map[string]int
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapStringInt is a concurrent safe wrapper around a map[String]Int.

func NewConMapStringInt 

func NewConMapStringInt() *ConMapStringInt

NewConMapStringInt creates a new concurrent safe map storing int values, for string keys.

func ToConMapStringInt 

func ToConMapStringInt(data map[string]int) *ConMapStringInt

ToConMapStringInt creates a new ConMapStringInt prepopulated with the data from the specified map[String]Int.

func (*ConMapStringInt) Delete 

func (cm *ConMapStringInt) Delete(k string) (int, bool)

Delete removes the specified string key, returning its int value and a bool indicating whether the delete occurred or not.

func (*ConMapStringInt) Get 

func (cm *ConMapStringInt) Get(k string) int

Get gets the int value for the given string key.

func (*ConMapStringInt) GetOK 

func (cm *ConMapStringInt) GetOK(k string) (int, bool)

GetOK gets the int value for the given string key, and a bool indicating whether the key was present or not.

func (*ConMapStringInt) Len 

func (cm *ConMapStringInt) Len() int

Get gets the int value for the given string key.

func (*ConMapStringInt) Set 

func (cm *ConMapStringInt) Set(k string, v int)

Set sets the int value for the specified string key.

type ConMapStringInt16 

type ConMapStringInt16 struct {
	// M is the underlying map[String]Int16.
	M map[string]int16
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapStringInt16 is a concurrent safe wrapper around a map[String]Int16.

func NewConMapStringInt16 

func NewConMapStringInt16() *ConMapStringInt16

NewConMapStringInt16 creates a new concurrent safe map storing int16 values, for string keys.

func ToConMapStringInt16 

func ToConMapStringInt16(data map[string]int16) *ConMapStringInt16

ToConMapStringInt16 creates a new ConMapStringInt16 prepopulated with the data from the specified map[String]Int16.

func (*ConMapStringInt16) Delete 

func (cm *ConMapStringInt16) Delete(k string) (int16, bool)

Delete removes the specified string key, returning its int16 value and a bool indicating whether the delete occurred or not.

func (*ConMapStringInt16) Get 

func (cm *ConMapStringInt16) Get(k string) int16

Get gets the int16 value for the given string key.

func (*ConMapStringInt16) GetOK 

func (cm *ConMapStringInt16) GetOK(k string) (int16, bool)

GetOK gets the int16 value for the given string key, and a bool indicating whether the key was present or not.

func (*ConMapStringInt16) Len 

func (cm *ConMapStringInt16) Len() int

Get gets the int16 value for the given string key.

func (*ConMapStringInt16) Set 

func (cm *ConMapStringInt16) Set(k string, v int16)

Set sets the int16 value for the specified string key.

type ConMapStringInt32 

type ConMapStringInt32 struct {
	// M is the underlying map[String]Int32.
	M map[string]int32
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapStringInt32 is a concurrent safe wrapper around a map[String]Int32.

func NewConMapStringInt32 

func NewConMapStringInt32() *ConMapStringInt32

NewConMapStringInt32 creates a new concurrent safe map storing int32 values, for string keys.

func ToConMapStringInt32 

func ToConMapStringInt32(data map[string]int32) *ConMapStringInt32

ToConMapStringInt32 creates a new ConMapStringInt32 prepopulated with the data from the specified map[String]Int32.

func (*ConMapStringInt32) Delete 

func (cm *ConMapStringInt32) Delete(k string) (int32, bool)

Delete removes the specified string key, returning its int32 value and a bool indicating whether the delete occurred or not.

func (*ConMapStringInt32) Get 

func (cm *ConMapStringInt32) Get(k string) int32

Get gets the int32 value for the given string key.

func (*ConMapStringInt32) GetOK 

func (cm *ConMapStringInt32) GetOK(k string) (int32, bool)

GetOK gets the int32 value for the given string key, and a bool indicating whether the key was present or not.

func (*ConMapStringInt32) Len 

func (cm *ConMapStringInt32) Len() int

Get gets the int32 value for the given string key.

func (*ConMapStringInt32) Set 

func (cm *ConMapStringInt32) Set(k string, v int32)

Set sets the int32 value for the specified string key.

type ConMapStringInt64 

type ConMapStringInt64 struct {
	// M is the underlying map[String]Int64.
	M map[string]int64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapStringInt64 is a concurrent safe wrapper around a map[String]Int64.

func NewConMapStringInt64 

func NewConMapStringInt64() *ConMapStringInt64

NewConMapStringInt64 creates a new concurrent safe map storing int64 values, for string keys.

func ToConMapStringInt64 

func ToConMapStringInt64(data map[string]int64) *ConMapStringInt64

ToConMapStringInt64 creates a new ConMapStringInt64 prepopulated with the data from the specified map[String]Int64.

func (*ConMapStringInt64) Delete 

func (cm *ConMapStringInt64) Delete(k string) (int64, bool)

Delete removes the specified string key, returning its int64 value and a bool indicating whether the delete occurred or not.

func (*ConMapStringInt64) Get 

func (cm *ConMapStringInt64) Get(k string) int64

Get gets the int64 value for the given string key.

func (*ConMapStringInt64) GetOK 

func (cm *ConMapStringInt64) GetOK(k string) (int64, bool)

GetOK gets the int64 value for the given string key, and a bool indicating whether the key was present or not.

func (*ConMapStringInt64) Len 

func (cm *ConMapStringInt64) Len() int

Get gets the int64 value for the given string key.

func (*ConMapStringInt64) Set 

func (cm *ConMapStringInt64) Set(k string, v int64)

Set sets the int64 value for the specified string key.

type ConMapStringInt8 

type ConMapStringInt8 struct {
	// M is the underlying map[String]Int8.
	M map[string]int8
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapStringInt8 is a concurrent safe wrapper around a map[String]Int8.

func NewConMapStringInt8 

func NewConMapStringInt8() *ConMapStringInt8

NewConMapStringInt8 creates a new concurrent safe map storing int8 values, for string keys.

func ToConMapStringInt8 

func ToConMapStringInt8(data map[string]int8) *ConMapStringInt8

ToConMapStringInt8 creates a new ConMapStringInt8 prepopulated with the data from the specified map[String]Int8.

func (*ConMapStringInt8) Delete 

func (cm *ConMapStringInt8) Delete(k string) (int8, bool)

Delete removes the specified string key, returning its int8 value and a bool indicating whether the delete occurred or not.

func (*ConMapStringInt8) Get 

func (cm *ConMapStringInt8) Get(k string) int8

Get gets the int8 value for the given string key.

func (*ConMapStringInt8) GetOK 

func (cm *ConMapStringInt8) GetOK(k string) (int8, bool)

GetOK gets the int8 value for the given string key, and a bool indicating whether the key was present or not.

func (*ConMapStringInt8) Len 

func (cm *ConMapStringInt8) Len() int

Get gets the int8 value for the given string key.

func (*ConMapStringInt8) Set 

func (cm *ConMapStringInt8) Set(k string, v int8)

Set sets the int8 value for the specified string key.

type ConMapStringRune 

type ConMapStringRune struct {
	// M is the underlying map[String]Rune.
	M map[string]rune
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapStringRune is a concurrent safe wrapper around a map[String]Rune.

func NewConMapStringRune 

func NewConMapStringRune() *ConMapStringRune

NewConMapStringRune creates a new concurrent safe map storing rune values, for string keys.

func ToConMapStringRune 

func ToConMapStringRune(data map[string]rune) *ConMapStringRune

ToConMapStringRune creates a new ConMapStringRune prepopulated with the data from the specified map[String]Rune.

func (*ConMapStringRune) Delete 

func (cm *ConMapStringRune) Delete(k string) (rune, bool)

Delete removes the specified string key, returning its rune value and a bool indicating whether the delete occurred or not.

func (*ConMapStringRune) Get 

func (cm *ConMapStringRune) Get(k string) rune

Get gets the rune value for the given string key.

func (*ConMapStringRune) GetOK 

func (cm *ConMapStringRune) GetOK(k string) (rune, bool)

GetOK gets the rune value for the given string key, and a bool indicating whether the key was present or not.

func (*ConMapStringRune) Len 

func (cm *ConMapStringRune) Len() int

Get gets the rune value for the given string key.

func (*ConMapStringRune) Set 

func (cm *ConMapStringRune) Set(k string, v rune)

Set sets the rune value for the specified string key.

type ConMapStringString 

type ConMapStringString struct {
	// M is the underlying map[String]String.
	M map[string]string
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapStringString is a concurrent safe wrapper around a map[String]String.

func NewConMapStringString 

func NewConMapStringString() *ConMapStringString

NewConMapStringString creates a new concurrent safe map storing string values, for string keys.

func ToConMapStringString 

func ToConMapStringString(data map[string]string) *ConMapStringString

ToConMapStringString creates a new ConMapStringString prepopulated with the data from the specified map[String]String.

func (*ConMapStringString) Delete 

func (cm *ConMapStringString) Delete(k string) (string, bool)

Delete removes the specified string key, returning its string value and a bool indicating whether the delete occurred or not.

func (*ConMapStringString) Get 

func (cm *ConMapStringString) Get(k string) string

Get gets the string value for the given string key.

func (*ConMapStringString) GetOK 

func (cm *ConMapStringString) GetOK(k string) (string, bool)

GetOK gets the string value for the given string key, and a bool indicating whether the key was present or not.

func (*ConMapStringString) Len 

func (cm *ConMapStringString) Len() int

Get gets the string value for the given string key.

func (*ConMapStringString) Set 

func (cm *ConMapStringString) Set(k string, v string)

Set sets the string value for the specified string key.

type ConMapStringUint 

type ConMapStringUint struct {
	// M is the underlying map[String]Uint.
	M map[string]uint
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapStringUint is a concurrent safe wrapper around a map[String]Uint.

func NewConMapStringUint 

func NewConMapStringUint() *ConMapStringUint

NewConMapStringUint creates a new concurrent safe map storing uint values, for string keys.

func ToConMapStringUint 

func ToConMapStringUint(data map[string]uint) *ConMapStringUint

ToConMapStringUint creates a new ConMapStringUint prepopulated with the data from the specified map[String]Uint.

func (*ConMapStringUint) Delete 

func (cm *ConMapStringUint) Delete(k string) (uint, bool)

Delete removes the specified string key, returning its uint value and a bool indicating whether the delete occurred or not.

func (*ConMapStringUint) Get 

func (cm *ConMapStringUint) Get(k string) uint

Get gets the uint value for the given string key.

func (*ConMapStringUint) GetOK 

func (cm *ConMapStringUint) GetOK(k string) (uint, bool)

GetOK gets the uint value for the given string key, and a bool indicating whether the key was present or not.

func (*ConMapStringUint) Len 

func (cm *ConMapStringUint) Len() int

Get gets the uint value for the given string key.

func (*ConMapStringUint) Set 

func (cm *ConMapStringUint) Set(k string, v uint)

Set sets the uint value for the specified string key.

type ConMapStringUint16 

type ConMapStringUint16 struct {
	// M is the underlying map[String]Uint16.
	M map[string]uint16
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapStringUint16 is a concurrent safe wrapper around a map[String]Uint16.

func NewConMapStringUint16 

func NewConMapStringUint16() *ConMapStringUint16

NewConMapStringUint16 creates a new concurrent safe map storing uint16 values, for string keys.

func ToConMapStringUint16 

func ToConMapStringUint16(data map[string]uint16) *ConMapStringUint16

ToConMapStringUint16 creates a new ConMapStringUint16 prepopulated with the data from the specified map[String]Uint16.

func (*ConMapStringUint16) Delete 

func (cm *ConMapStringUint16) Delete(k string) (uint16, bool)

Delete removes the specified string key, returning its uint16 value and a bool indicating whether the delete occurred or not.

func (*ConMapStringUint16) Get 

func (cm *ConMapStringUint16) Get(k string) uint16

Get gets the uint16 value for the given string key.

func (*ConMapStringUint16) GetOK 

func (cm *ConMapStringUint16) GetOK(k string) (uint16, bool)

GetOK gets the uint16 value for the given string key, and a bool indicating whether the key was present or not.

func (*ConMapStringUint16) Len 

func (cm *ConMapStringUint16) Len() int

Get gets the uint16 value for the given string key.

func (*ConMapStringUint16) Set 

func (cm *ConMapStringUint16) Set(k string, v uint16)

Set sets the uint16 value for the specified string key.

type ConMapStringUint32 

type ConMapStringUint32 struct {
	// M is the underlying map[String]Uint32.
	M map[string]uint32
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapStringUint32 is a concurrent safe wrapper around a map[String]Uint32.

func NewConMapStringUint32 

func NewConMapStringUint32() *ConMapStringUint32

NewConMapStringUint32 creates a new concurrent safe map storing uint32 values, for string keys.

func ToConMapStringUint32 

func ToConMapStringUint32(data map[string]uint32) *ConMapStringUint32

ToConMapStringUint32 creates a new ConMapStringUint32 prepopulated with the data from the specified map[String]Uint32.

func (*ConMapStringUint32) Delete 

func (cm *ConMapStringUint32) Delete(k string) (uint32, bool)

Delete removes the specified string key, returning its uint32 value and a bool indicating whether the delete occurred or not.

func (*ConMapStringUint32) Get 

func (cm *ConMapStringUint32) Get(k string) uint32

Get gets the uint32 value for the given string key.

func (*ConMapStringUint32) GetOK 

func (cm *ConMapStringUint32) GetOK(k string) (uint32, bool)

GetOK gets the uint32 value for the given string key, and a bool indicating whether the key was present or not.

func (*ConMapStringUint32) Len 

func (cm *ConMapStringUint32) Len() int

Get gets the uint32 value for the given string key.

func (*ConMapStringUint32) Set 

func (cm *ConMapStringUint32) Set(k string, v uint32)

Set sets the uint32 value for the specified string key.

type ConMapStringUint64 

type ConMapStringUint64 struct {
	// M is the underlying map[String]Uint64.
	M map[string]uint64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapStringUint64 is a concurrent safe wrapper around a map[String]Uint64.

func NewConMapStringUint64 

func NewConMapStringUint64() *ConMapStringUint64

NewConMapStringUint64 creates a new concurrent safe map storing uint64 values, for string keys.

func ToConMapStringUint64 

func ToConMapStringUint64(data map[string]uint64) *ConMapStringUint64

ToConMapStringUint64 creates a new ConMapStringUint64 prepopulated with the data from the specified map[String]Uint64.

func (*ConMapStringUint64) Delete 

func (cm *ConMapStringUint64) Delete(k string) (uint64, bool)

Delete removes the specified string key, returning its uint64 value and a bool indicating whether the delete occurred or not.

func (*ConMapStringUint64) Get 

func (cm *ConMapStringUint64) Get(k string) uint64

Get gets the uint64 value for the given string key.

func (*ConMapStringUint64) GetOK 

func (cm *ConMapStringUint64) GetOK(k string) (uint64, bool)

GetOK gets the uint64 value for the given string key, and a bool indicating whether the key was present or not.

func (*ConMapStringUint64) Len 

func (cm *ConMapStringUint64) Len() int

Get gets the uint64 value for the given string key.

func (*ConMapStringUint64) Set 

func (cm *ConMapStringUint64) Set(k string, v uint64)

Set sets the uint64 value for the specified string key.

type ConMapStringUint8 

type ConMapStringUint8 struct {
	// M is the underlying map[String]Uint8.
	M map[string]uint8
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapStringUint8 is a concurrent safe wrapper around a map[String]Uint8.

func NewConMapStringUint8 

func NewConMapStringUint8() *ConMapStringUint8

NewConMapStringUint8 creates a new concurrent safe map storing uint8 values, for string keys.

func ToConMapStringUint8 

func ToConMapStringUint8(data map[string]uint8) *ConMapStringUint8

ToConMapStringUint8 creates a new ConMapStringUint8 prepopulated with the data from the specified map[String]Uint8.

func (*ConMapStringUint8) Delete 

func (cm *ConMapStringUint8) Delete(k string) (uint8, bool)

Delete removes the specified string key, returning its uint8 value and a bool indicating whether the delete occurred or not.

func (*ConMapStringUint8) Get 

func (cm *ConMapStringUint8) Get(k string) uint8

Get gets the uint8 value for the given string key.

func (*ConMapStringUint8) GetOK 

func (cm *ConMapStringUint8) GetOK(k string) (uint8, bool)

GetOK gets the uint8 value for the given string key, and a bool indicating whether the key was present or not.

func (*ConMapStringUint8) Len 

func (cm *ConMapStringUint8) Len() int

Get gets the uint8 value for the given string key.

func (*ConMapStringUint8) Set 

func (cm *ConMapStringUint8) Set(k string, v uint8)

Set sets the uint8 value for the specified string key.

type ConMapStringUintptr 

type ConMapStringUintptr struct {
	// M is the underlying map[String]Uintptr.
	M map[string]uintptr
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapStringUintptr is a concurrent safe wrapper around a map[String]Uintptr.

func NewConMapStringUintptr 

func NewConMapStringUintptr() *ConMapStringUintptr

NewConMapStringUintptr creates a new concurrent safe map storing uintptr values, for string keys.

func ToConMapStringUintptr 

func ToConMapStringUintptr(data map[string]uintptr) *ConMapStringUintptr

ToConMapStringUintptr creates a new ConMapStringUintptr prepopulated with the data from the specified map[String]Uintptr.

func (*ConMapStringUintptr) Delete 

func (cm *ConMapStringUintptr) Delete(k string) (uintptr, bool)

Delete removes the specified string key, returning its uintptr value and a bool indicating whether the delete occurred or not.

func (*ConMapStringUintptr) Get 

func (cm *ConMapStringUintptr) Get(k string) uintptr

Get gets the uintptr value for the given string key.

func (*ConMapStringUintptr) GetOK 

func (cm *ConMapStringUintptr) GetOK(k string) (uintptr, bool)

GetOK gets the uintptr value for the given string key, and a bool indicating whether the key was present or not.

func (*ConMapStringUintptr) Len 

func (cm *ConMapStringUintptr) Len() int

Get gets the uintptr value for the given string key.

func (*ConMapStringUintptr) Set 

func (cm *ConMapStringUintptr) Set(k string, v uintptr)

Set sets the uintptr value for the specified string key.

type ConMapUint16Bool 

type ConMapUint16Bool struct {
	// M is the underlying map[Uint16]Bool.
	M map[uint16]bool
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint16Bool is a concurrent safe wrapper around a map[Uint16]Bool.

func NewConMapUint16Bool 

func NewConMapUint16Bool() *ConMapUint16Bool

NewConMapUint16Bool creates a new concurrent safe map storing bool values, for uint16 keys.

func ToConMapUint16Bool 

func ToConMapUint16Bool(data map[uint16]bool) *ConMapUint16Bool

ToConMapUint16Bool creates a new ConMapUint16Bool prepopulated with the data from the specified map[Uint16]Bool.

func (*ConMapUint16Bool) Delete 

func (cm *ConMapUint16Bool) Delete(k uint16) (bool, bool)

Delete removes the specified uint16 key, returning its bool value and a bool indicating whether the delete occurred or not.

func (*ConMapUint16Bool) Get 

func (cm *ConMapUint16Bool) Get(k uint16) bool

Get gets the bool value for the given uint16 key.

func (*ConMapUint16Bool) GetOK 

func (cm *ConMapUint16Bool) GetOK(k uint16) (bool, bool)

GetOK gets the bool value for the given uint16 key, and a bool indicating whether the key was present or not.

func (*ConMapUint16Bool) Len 

func (cm *ConMapUint16Bool) Len() int

Get gets the bool value for the given uint16 key.

func (*ConMapUint16Bool) Set 

func (cm *ConMapUint16Bool) Set(k uint16, v bool)

Set sets the bool value for the specified uint16 key.

type ConMapUint16Byte 

type ConMapUint16Byte struct {
	// M is the underlying map[Uint16]Byte.
	M map[uint16]byte
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint16Byte is a concurrent safe wrapper around a map[Uint16]Byte.

func NewConMapUint16Byte 

func NewConMapUint16Byte() *ConMapUint16Byte

NewConMapUint16Byte creates a new concurrent safe map storing byte values, for uint16 keys.

func ToConMapUint16Byte 

func ToConMapUint16Byte(data map[uint16]byte) *ConMapUint16Byte

ToConMapUint16Byte creates a new ConMapUint16Byte prepopulated with the data from the specified map[Uint16]Byte.

func (*ConMapUint16Byte) Delete 

func (cm *ConMapUint16Byte) Delete(k uint16) (byte, bool)

Delete removes the specified uint16 key, returning its byte value and a bool indicating whether the delete occurred or not.

func (*ConMapUint16Byte) Get 

func (cm *ConMapUint16Byte) Get(k uint16) byte

Get gets the byte value for the given uint16 key.

func (*ConMapUint16Byte) GetOK 

func (cm *ConMapUint16Byte) GetOK(k uint16) (byte, bool)

GetOK gets the byte value for the given uint16 key, and a bool indicating whether the key was present or not.

func (*ConMapUint16Byte) Len 

func (cm *ConMapUint16Byte) Len() int

Get gets the byte value for the given uint16 key.

func (*ConMapUint16Byte) Set 

func (cm *ConMapUint16Byte) Set(k uint16, v byte)

Set sets the byte value for the specified uint16 key.

type ConMapUint16Complex128 

type ConMapUint16Complex128 struct {
	// M is the underlying map[Uint16]Complex128.
	M map[uint16]complex128
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint16Complex128 is a concurrent safe wrapper around a map[Uint16]Complex128.

func NewConMapUint16Complex128 

func NewConMapUint16Complex128() *ConMapUint16Complex128

NewConMapUint16Complex128 creates a new concurrent safe map storing complex128 values, for uint16 keys.

func ToConMapUint16Complex128 

func ToConMapUint16Complex128(data map[uint16]complex128) *ConMapUint16Complex128

ToConMapUint16Complex128 creates a new ConMapUint16Complex128 prepopulated with the data from the specified map[Uint16]Complex128.

func (*ConMapUint16Complex128) Delete 

func (cm *ConMapUint16Complex128) Delete(k uint16) (complex128, bool)

Delete removes the specified uint16 key, returning its complex128 value and a bool indicating whether the delete occurred or not.

func (*ConMapUint16Complex128) Get 

func (cm *ConMapUint16Complex128) Get(k uint16) complex128

Get gets the complex128 value for the given uint16 key.

func (*ConMapUint16Complex128) GetOK 

func (cm *ConMapUint16Complex128) GetOK(k uint16) (complex128, bool)

GetOK gets the complex128 value for the given uint16 key, and a bool indicating whether the key was present or not.

func (*ConMapUint16Complex128) Len 

func (cm *ConMapUint16Complex128) Len() int

Get gets the complex128 value for the given uint16 key.

func (*ConMapUint16Complex128) Set 

func (cm *ConMapUint16Complex128) Set(k uint16, v complex128)

Set sets the complex128 value for the specified uint16 key.

type ConMapUint16Complex64 

type ConMapUint16Complex64 struct {
	// M is the underlying map[Uint16]Complex64.
	M map[uint16]complex64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint16Complex64 is a concurrent safe wrapper around a map[Uint16]Complex64.

func NewConMapUint16Complex64 

func NewConMapUint16Complex64() *ConMapUint16Complex64

NewConMapUint16Complex64 creates a new concurrent safe map storing complex64 values, for uint16 keys.

func ToConMapUint16Complex64 

func ToConMapUint16Complex64(data map[uint16]complex64) *ConMapUint16Complex64

ToConMapUint16Complex64 creates a new ConMapUint16Complex64 prepopulated with the data from the specified map[Uint16]Complex64.

func (*ConMapUint16Complex64) Delete 

func (cm *ConMapUint16Complex64) Delete(k uint16) (complex64, bool)

Delete removes the specified uint16 key, returning its complex64 value and a bool indicating whether the delete occurred or not.

func (*ConMapUint16Complex64) Get 

func (cm *ConMapUint16Complex64) Get(k uint16) complex64

Get gets the complex64 value for the given uint16 key.

func (*ConMapUint16Complex64) GetOK 

func (cm *ConMapUint16Complex64) GetOK(k uint16) (complex64, bool)

GetOK gets the complex64 value for the given uint16 key, and a bool indicating whether the key was present or not.

func (*ConMapUint16Complex64) Len 

func (cm *ConMapUint16Complex64) Len() int

Get gets the complex64 value for the given uint16 key.

func (*ConMapUint16Complex64) Set 

func (cm *ConMapUint16Complex64) Set(k uint16, v complex64)

Set sets the complex64 value for the specified uint16 key.

type ConMapUint16Error 

type ConMapUint16Error struct {
	// M is the underlying map[Uint16]Error.
	M map[uint16]error
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint16Error is a concurrent safe wrapper around a map[Uint16]Error.

func NewConMapUint16Error 

func NewConMapUint16Error() *ConMapUint16Error

NewConMapUint16Error creates a new concurrent safe map storing error values, for uint16 keys.

func ToConMapUint16Error 

func ToConMapUint16Error(data map[uint16]error) *ConMapUint16Error

ToConMapUint16Error creates a new ConMapUint16Error prepopulated with the data from the specified map[Uint16]Error.

func (*ConMapUint16Error) Delete 

func (cm *ConMapUint16Error) Delete(k uint16) (error, bool)

Delete removes the specified uint16 key, returning its error value and a bool indicating whether the delete occurred or not.

func (*ConMapUint16Error) Get 

func (cm *ConMapUint16Error) Get(k uint16) error

Get gets the error value for the given uint16 key.

func (*ConMapUint16Error) GetOK 

func (cm *ConMapUint16Error) GetOK(k uint16) (error, bool)

GetOK gets the error value for the given uint16 key, and a bool indicating whether the key was present or not.

func (*ConMapUint16Error) Len 

func (cm *ConMapUint16Error) Len() int

Get gets the error value for the given uint16 key.

func (*ConMapUint16Error) Set 

func (cm *ConMapUint16Error) Set(k uint16, v error)

Set sets the error value for the specified uint16 key.

type ConMapUint16Float32 

type ConMapUint16Float32 struct {
	// M is the underlying map[Uint16]Float32.
	M map[uint16]float32
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint16Float32 is a concurrent safe wrapper around a map[Uint16]Float32.

func NewConMapUint16Float32 

func NewConMapUint16Float32() *ConMapUint16Float32

NewConMapUint16Float32 creates a new concurrent safe map storing float32 values, for uint16 keys.

func ToConMapUint16Float32 

func ToConMapUint16Float32(data map[uint16]float32) *ConMapUint16Float32

ToConMapUint16Float32 creates a new ConMapUint16Float32 prepopulated with the data from the specified map[Uint16]Float32.

func (*ConMapUint16Float32) Delete 

func (cm *ConMapUint16Float32) Delete(k uint16) (float32, bool)

Delete removes the specified uint16 key, returning its float32 value and a bool indicating whether the delete occurred or not.

func (*ConMapUint16Float32) Get 

func (cm *ConMapUint16Float32) Get(k uint16) float32

Get gets the float32 value for the given uint16 key.

func (*ConMapUint16Float32) GetOK 

func (cm *ConMapUint16Float32) GetOK(k uint16) (float32, bool)

GetOK gets the float32 value for the given uint16 key, and a bool indicating whether the key was present or not.

func (*ConMapUint16Float32) Len 

func (cm *ConMapUint16Float32) Len() int

Get gets the float32 value for the given uint16 key.

func (*ConMapUint16Float32) Set 

func (cm *ConMapUint16Float32) Set(k uint16, v float32)

Set sets the float32 value for the specified uint16 key.

type ConMapUint16Float64 

type ConMapUint16Float64 struct {
	// M is the underlying map[Uint16]Float64.
	M map[uint16]float64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint16Float64 is a concurrent safe wrapper around a map[Uint16]Float64.

func NewConMapUint16Float64 

func NewConMapUint16Float64() *ConMapUint16Float64

NewConMapUint16Float64 creates a new concurrent safe map storing float64 values, for uint16 keys.

func ToConMapUint16Float64 

func ToConMapUint16Float64(data map[uint16]float64) *ConMapUint16Float64

ToConMapUint16Float64 creates a new ConMapUint16Float64 prepopulated with the data from the specified map[Uint16]Float64.

func (*ConMapUint16Float64) Delete 

func (cm *ConMapUint16Float64) Delete(k uint16) (float64, bool)

Delete removes the specified uint16 key, returning its float64 value and a bool indicating whether the delete occurred or not.

func (*ConMapUint16Float64) Get 

func (cm *ConMapUint16Float64) Get(k uint16) float64

Get gets the float64 value for the given uint16 key.

func (*ConMapUint16Float64) GetOK 

func (cm *ConMapUint16Float64) GetOK(k uint16) (float64, bool)

GetOK gets the float64 value for the given uint16 key, and a bool indicating whether the key was present or not.

func (*ConMapUint16Float64) Len 

func (cm *ConMapUint16Float64) Len() int

Get gets the float64 value for the given uint16 key.

func (*ConMapUint16Float64) Set 

func (cm *ConMapUint16Float64) Set(k uint16, v float64)

Set sets the float64 value for the specified uint16 key.

type ConMapUint16Int 

type ConMapUint16Int struct {
	// M is the underlying map[Uint16]Int.
	M map[uint16]int
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint16Int is a concurrent safe wrapper around a map[Uint16]Int.

func NewConMapUint16Int 

func NewConMapUint16Int() *ConMapUint16Int

NewConMapUint16Int creates a new concurrent safe map storing int values, for uint16 keys.

func ToConMapUint16Int 

func ToConMapUint16Int(data map[uint16]int) *ConMapUint16Int

ToConMapUint16Int creates a new ConMapUint16Int prepopulated with the data from the specified map[Uint16]Int.

func (*ConMapUint16Int) Delete 

func (cm *ConMapUint16Int) Delete(k uint16) (int, bool)

Delete removes the specified uint16 key, returning its int value and a bool indicating whether the delete occurred or not.

func (*ConMapUint16Int) Get 

func (cm *ConMapUint16Int) Get(k uint16) int

Get gets the int value for the given uint16 key.

func (*ConMapUint16Int) GetOK 

func (cm *ConMapUint16Int) GetOK(k uint16) (int, bool)

GetOK gets the int value for the given uint16 key, and a bool indicating whether the key was present or not.

func (*ConMapUint16Int) Len 

func (cm *ConMapUint16Int) Len() int

Get gets the int value for the given uint16 key.

func (*ConMapUint16Int) Set 

func (cm *ConMapUint16Int) Set(k uint16, v int)

Set sets the int value for the specified uint16 key.

type ConMapUint16Int16 

type ConMapUint16Int16 struct {
	// M is the underlying map[Uint16]Int16.
	M map[uint16]int16
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint16Int16 is a concurrent safe wrapper around a map[Uint16]Int16.

func NewConMapUint16Int16 

func NewConMapUint16Int16() *ConMapUint16Int16

NewConMapUint16Int16 creates a new concurrent safe map storing int16 values, for uint16 keys.

func ToConMapUint16Int16 

func ToConMapUint16Int16(data map[uint16]int16) *ConMapUint16Int16

ToConMapUint16Int16 creates a new ConMapUint16Int16 prepopulated with the data from the specified map[Uint16]Int16.

func (*ConMapUint16Int16) Delete 

func (cm *ConMapUint16Int16) Delete(k uint16) (int16, bool)

Delete removes the specified uint16 key, returning its int16 value and a bool indicating whether the delete occurred or not.

func (*ConMapUint16Int16) Get 

func (cm *ConMapUint16Int16) Get(k uint16) int16

Get gets the int16 value for the given uint16 key.

func (*ConMapUint16Int16) GetOK 

func (cm *ConMapUint16Int16) GetOK(k uint16) (int16, bool)

GetOK gets the int16 value for the given uint16 key, and a bool indicating whether the key was present or not.

func (*ConMapUint16Int16) Len 

func (cm *ConMapUint16Int16) Len() int

Get gets the int16 value for the given uint16 key.

func (*ConMapUint16Int16) Set 

func (cm *ConMapUint16Int16) Set(k uint16, v int16)

Set sets the int16 value for the specified uint16 key.

type ConMapUint16Int32 

type ConMapUint16Int32 struct {
	// M is the underlying map[Uint16]Int32.
	M map[uint16]int32
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint16Int32 is a concurrent safe wrapper around a map[Uint16]Int32.

func NewConMapUint16Int32 

func NewConMapUint16Int32() *ConMapUint16Int32

NewConMapUint16Int32 creates a new concurrent safe map storing int32 values, for uint16 keys.

func ToConMapUint16Int32 

func ToConMapUint16Int32(data map[uint16]int32) *ConMapUint16Int32

ToConMapUint16Int32 creates a new ConMapUint16Int32 prepopulated with the data from the specified map[Uint16]Int32.

func (*ConMapUint16Int32) Delete 

func (cm *ConMapUint16Int32) Delete(k uint16) (int32, bool)

Delete removes the specified uint16 key, returning its int32 value and a bool indicating whether the delete occurred or not.

func (*ConMapUint16Int32) Get 

func (cm *ConMapUint16Int32) Get(k uint16) int32

Get gets the int32 value for the given uint16 key.

func (*ConMapUint16Int32) GetOK 

func (cm *ConMapUint16Int32) GetOK(k uint16) (int32, bool)

GetOK gets the int32 value for the given uint16 key, and a bool indicating whether the key was present or not.

func (*ConMapUint16Int32) Len 

func (cm *ConMapUint16Int32) Len() int

Get gets the int32 value for the given uint16 key.

func (*ConMapUint16Int32) Set 

func (cm *ConMapUint16Int32) Set(k uint16, v int32)

Set sets the int32 value for the specified uint16 key.

type ConMapUint16Int64 

type ConMapUint16Int64 struct {
	// M is the underlying map[Uint16]Int64.
	M map[uint16]int64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint16Int64 is a concurrent safe wrapper around a map[Uint16]Int64.

func NewConMapUint16Int64 

func NewConMapUint16Int64() *ConMapUint16Int64

NewConMapUint16Int64 creates a new concurrent safe map storing int64 values, for uint16 keys.

func ToConMapUint16Int64 

func ToConMapUint16Int64(data map[uint16]int64) *ConMapUint16Int64

ToConMapUint16Int64 creates a new ConMapUint16Int64 prepopulated with the data from the specified map[Uint16]Int64.

func (*ConMapUint16Int64) Delete 

func (cm *ConMapUint16Int64) Delete(k uint16) (int64, bool)

Delete removes the specified uint16 key, returning its int64 value and a bool indicating whether the delete occurred or not.

func (*ConMapUint16Int64) Get 

func (cm *ConMapUint16Int64) Get(k uint16) int64

Get gets the int64 value for the given uint16 key.

func (*ConMapUint16Int64) GetOK 

func (cm *ConMapUint16Int64) GetOK(k uint16) (int64, bool)

GetOK gets the int64 value for the given uint16 key, and a bool indicating whether the key was present or not.

func (*ConMapUint16Int64) Len 

func (cm *ConMapUint16Int64) Len() int

Get gets the int64 value for the given uint16 key.

func (*ConMapUint16Int64) Set 

func (cm *ConMapUint16Int64) Set(k uint16, v int64)

Set sets the int64 value for the specified uint16 key.

type ConMapUint16Int8 

type ConMapUint16Int8 struct {
	// M is the underlying map[Uint16]Int8.
	M map[uint16]int8
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint16Int8 is a concurrent safe wrapper around a map[Uint16]Int8.

func NewConMapUint16Int8 

func NewConMapUint16Int8() *ConMapUint16Int8

NewConMapUint16Int8 creates a new concurrent safe map storing int8 values, for uint16 keys.

func ToConMapUint16Int8 

func ToConMapUint16Int8(data map[uint16]int8) *ConMapUint16Int8

ToConMapUint16Int8 creates a new ConMapUint16Int8 prepopulated with the data from the specified map[Uint16]Int8.

func (*ConMapUint16Int8) Delete 

func (cm *ConMapUint16Int8) Delete(k uint16) (int8, bool)

Delete removes the specified uint16 key, returning its int8 value and a bool indicating whether the delete occurred or not.

func (*ConMapUint16Int8) Get 

func (cm *ConMapUint16Int8) Get(k uint16) int8

Get gets the int8 value for the given uint16 key.

func (*ConMapUint16Int8) GetOK 

func (cm *ConMapUint16Int8) GetOK(k uint16) (int8, bool)

GetOK gets the int8 value for the given uint16 key, and a bool indicating whether the key was present or not.

func (*ConMapUint16Int8) Len 

func (cm *ConMapUint16Int8) Len() int

Get gets the int8 value for the given uint16 key.

func (*ConMapUint16Int8) Set 

func (cm *ConMapUint16Int8) Set(k uint16, v int8)

Set sets the int8 value for the specified uint16 key.

type ConMapUint16Rune 

type ConMapUint16Rune struct {
	// M is the underlying map[Uint16]Rune.
	M map[uint16]rune
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint16Rune is a concurrent safe wrapper around a map[Uint16]Rune.

func NewConMapUint16Rune 

func NewConMapUint16Rune() *ConMapUint16Rune

NewConMapUint16Rune creates a new concurrent safe map storing rune values, for uint16 keys.

func ToConMapUint16Rune 

func ToConMapUint16Rune(data map[uint16]rune) *ConMapUint16Rune

ToConMapUint16Rune creates a new ConMapUint16Rune prepopulated with the data from the specified map[Uint16]Rune.

func (*ConMapUint16Rune) Delete 

func (cm *ConMapUint16Rune) Delete(k uint16) (rune, bool)

Delete removes the specified uint16 key, returning its rune value and a bool indicating whether the delete occurred or not.

func (*ConMapUint16Rune) Get 

func (cm *ConMapUint16Rune) Get(k uint16) rune

Get gets the rune value for the given uint16 key.

func (*ConMapUint16Rune) GetOK 

func (cm *ConMapUint16Rune) GetOK(k uint16) (rune, bool)

GetOK gets the rune value for the given uint16 key, and a bool indicating whether the key was present or not.

func (*ConMapUint16Rune) Len 

func (cm *ConMapUint16Rune) Len() int

Get gets the rune value for the given uint16 key.

func (*ConMapUint16Rune) Set 

func (cm *ConMapUint16Rune) Set(k uint16, v rune)

Set sets the rune value for the specified uint16 key.

type ConMapUint16String 

type ConMapUint16String struct {
	// M is the underlying map[Uint16]String.
	M map[uint16]string
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint16String is a concurrent safe wrapper around a map[Uint16]String.

func NewConMapUint16String 

func NewConMapUint16String() *ConMapUint16String

NewConMapUint16String creates a new concurrent safe map storing string values, for uint16 keys.

func ToConMapUint16String 

func ToConMapUint16String(data map[uint16]string) *ConMapUint16String

ToConMapUint16String creates a new ConMapUint16String prepopulated with the data from the specified map[Uint16]String.

func (*ConMapUint16String) Delete 

func (cm *ConMapUint16String) Delete(k uint16) (string, bool)

Delete removes the specified uint16 key, returning its string value and a bool indicating whether the delete occurred or not.

func (*ConMapUint16String) Get 

func (cm *ConMapUint16String) Get(k uint16) string

Get gets the string value for the given uint16 key.

func (*ConMapUint16String) GetOK 

func (cm *ConMapUint16String) GetOK(k uint16) (string, bool)

GetOK gets the string value for the given uint16 key, and a bool indicating whether the key was present or not.

func (*ConMapUint16String) Len 

func (cm *ConMapUint16String) Len() int

Get gets the string value for the given uint16 key.

func (*ConMapUint16String) Set 

func (cm *ConMapUint16String) Set(k uint16, v string)

Set sets the string value for the specified uint16 key.

type ConMapUint16Uint 

type ConMapUint16Uint struct {
	// M is the underlying map[Uint16]Uint.
	M map[uint16]uint
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint16Uint is a concurrent safe wrapper around a map[Uint16]Uint.

func NewConMapUint16Uint 

func NewConMapUint16Uint() *ConMapUint16Uint

NewConMapUint16Uint creates a new concurrent safe map storing uint values, for uint16 keys.

func ToConMapUint16Uint 

func ToConMapUint16Uint(data map[uint16]uint) *ConMapUint16Uint

ToConMapUint16Uint creates a new ConMapUint16Uint prepopulated with the data from the specified map[Uint16]Uint.

func (*ConMapUint16Uint) Delete 

func (cm *ConMapUint16Uint) Delete(k uint16) (uint, bool)

Delete removes the specified uint16 key, returning its uint value and a bool indicating whether the delete occurred or not.

func (*ConMapUint16Uint) Get 

func (cm *ConMapUint16Uint) Get(k uint16) uint

Get gets the uint value for the given uint16 key.

func (*ConMapUint16Uint) GetOK 

func (cm *ConMapUint16Uint) GetOK(k uint16) (uint, bool)

GetOK gets the uint value for the given uint16 key, and a bool indicating whether the key was present or not.

func (*ConMapUint16Uint) Len 

func (cm *ConMapUint16Uint) Len() int

Get gets the uint value for the given uint16 key.

func (*ConMapUint16Uint) Set 

func (cm *ConMapUint16Uint) Set(k uint16, v uint)

Set sets the uint value for the specified uint16 key.

type ConMapUint16Uint16 

type ConMapUint16Uint16 struct {
	// M is the underlying map[Uint16]Uint16.
	M map[uint16]uint16
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint16Uint16 is a concurrent safe wrapper around a map[Uint16]Uint16.

func NewConMapUint16Uint16 

func NewConMapUint16Uint16() *ConMapUint16Uint16

NewConMapUint16Uint16 creates a new concurrent safe map storing uint16 values, for uint16 keys.

func ToConMapUint16Uint16 

func ToConMapUint16Uint16(data map[uint16]uint16) *ConMapUint16Uint16

ToConMapUint16Uint16 creates a new ConMapUint16Uint16 prepopulated with the data from the specified map[Uint16]Uint16.

func (*ConMapUint16Uint16) Delete 

func (cm *ConMapUint16Uint16) Delete(k uint16) (uint16, bool)

Delete removes the specified uint16 key, returning its uint16 value and a bool indicating whether the delete occurred or not.

func (*ConMapUint16Uint16) Get 

func (cm *ConMapUint16Uint16) Get(k uint16) uint16

Get gets the uint16 value for the given uint16 key.

func (*ConMapUint16Uint16) GetOK 

func (cm *ConMapUint16Uint16) GetOK(k uint16) (uint16, bool)

GetOK gets the uint16 value for the given uint16 key, and a bool indicating whether the key was present or not.

func (*ConMapUint16Uint16) Len 

func (cm *ConMapUint16Uint16) Len() int

Get gets the uint16 value for the given uint16 key.

func (*ConMapUint16Uint16) Set 

func (cm *ConMapUint16Uint16) Set(k uint16, v uint16)

Set sets the uint16 value for the specified uint16 key.

type ConMapUint16Uint32 

type ConMapUint16Uint32 struct {
	// M is the underlying map[Uint16]Uint32.
	M map[uint16]uint32
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint16Uint32 is a concurrent safe wrapper around a map[Uint16]Uint32.

func NewConMapUint16Uint32 

func NewConMapUint16Uint32() *ConMapUint16Uint32

NewConMapUint16Uint32 creates a new concurrent safe map storing uint32 values, for uint16 keys.

func ToConMapUint16Uint32 

func ToConMapUint16Uint32(data map[uint16]uint32) *ConMapUint16Uint32

ToConMapUint16Uint32 creates a new ConMapUint16Uint32 prepopulated with the data from the specified map[Uint16]Uint32.

func (*ConMapUint16Uint32) Delete 

func (cm *ConMapUint16Uint32) Delete(k uint16) (uint32, bool)

Delete removes the specified uint16 key, returning its uint32 value and a bool indicating whether the delete occurred or not.

func (*ConMapUint16Uint32) Get 

func (cm *ConMapUint16Uint32) Get(k uint16) uint32

Get gets the uint32 value for the given uint16 key.

func (*ConMapUint16Uint32) GetOK 

func (cm *ConMapUint16Uint32) GetOK(k uint16) (uint32, bool)

GetOK gets the uint32 value for the given uint16 key, and a bool indicating whether the key was present or not.

func (*ConMapUint16Uint32) Len 

func (cm *ConMapUint16Uint32) Len() int

Get gets the uint32 value for the given uint16 key.

func (*ConMapUint16Uint32) Set 

func (cm *ConMapUint16Uint32) Set(k uint16, v uint32)

Set sets the uint32 value for the specified uint16 key.

type ConMapUint16Uint64 

type ConMapUint16Uint64 struct {
	// M is the underlying map[Uint16]Uint64.
	M map[uint16]uint64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint16Uint64 is a concurrent safe wrapper around a map[Uint16]Uint64.

func NewConMapUint16Uint64 

func NewConMapUint16Uint64() *ConMapUint16Uint64

NewConMapUint16Uint64 creates a new concurrent safe map storing uint64 values, for uint16 keys.

func ToConMapUint16Uint64 

func ToConMapUint16Uint64(data map[uint16]uint64) *ConMapUint16Uint64

ToConMapUint16Uint64 creates a new ConMapUint16Uint64 prepopulated with the data from the specified map[Uint16]Uint64.

func (*ConMapUint16Uint64) Delete 

func (cm *ConMapUint16Uint64) Delete(k uint16) (uint64, bool)

Delete removes the specified uint16 key, returning its uint64 value and a bool indicating whether the delete occurred or not.

func (*ConMapUint16Uint64) Get 

func (cm *ConMapUint16Uint64) Get(k uint16) uint64

Get gets the uint64 value for the given uint16 key.

func (*ConMapUint16Uint64) GetOK 

func (cm *ConMapUint16Uint64) GetOK(k uint16) (uint64, bool)

GetOK gets the uint64 value for the given uint16 key, and a bool indicating whether the key was present or not.

func (*ConMapUint16Uint64) Len 

func (cm *ConMapUint16Uint64) Len() int

Get gets the uint64 value for the given uint16 key.

func (*ConMapUint16Uint64) Set 

func (cm *ConMapUint16Uint64) Set(k uint16, v uint64)

Set sets the uint64 value for the specified uint16 key.

type ConMapUint16Uint8 

type ConMapUint16Uint8 struct {
	// M is the underlying map[Uint16]Uint8.
	M map[uint16]uint8
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint16Uint8 is a concurrent safe wrapper around a map[Uint16]Uint8.

func NewConMapUint16Uint8 

func NewConMapUint16Uint8() *ConMapUint16Uint8

NewConMapUint16Uint8 creates a new concurrent safe map storing uint8 values, for uint16 keys.

func ToConMapUint16Uint8 

func ToConMapUint16Uint8(data map[uint16]uint8) *ConMapUint16Uint8

ToConMapUint16Uint8 creates a new ConMapUint16Uint8 prepopulated with the data from the specified map[Uint16]Uint8.

func (*ConMapUint16Uint8) Delete 

func (cm *ConMapUint16Uint8) Delete(k uint16) (uint8, bool)

Delete removes the specified uint16 key, returning its uint8 value and a bool indicating whether the delete occurred or not.

func (*ConMapUint16Uint8) Get 

func (cm *ConMapUint16Uint8) Get(k uint16) uint8

Get gets the uint8 value for the given uint16 key.

func (*ConMapUint16Uint8) GetOK 

func (cm *ConMapUint16Uint8) GetOK(k uint16) (uint8, bool)

GetOK gets the uint8 value for the given uint16 key, and a bool indicating whether the key was present or not.

func (*ConMapUint16Uint8) Len 

func (cm *ConMapUint16Uint8) Len() int

Get gets the uint8 value for the given uint16 key.

func (*ConMapUint16Uint8) Set 

func (cm *ConMapUint16Uint8) Set(k uint16, v uint8)

Set sets the uint8 value for the specified uint16 key.

type ConMapUint16Uintptr 

type ConMapUint16Uintptr struct {
	// M is the underlying map[Uint16]Uintptr.
	M map[uint16]uintptr
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint16Uintptr is a concurrent safe wrapper around a map[Uint16]Uintptr.

func NewConMapUint16Uintptr 

func NewConMapUint16Uintptr() *ConMapUint16Uintptr

NewConMapUint16Uintptr creates a new concurrent safe map storing uintptr values, for uint16 keys.

func ToConMapUint16Uintptr 

func ToConMapUint16Uintptr(data map[uint16]uintptr) *ConMapUint16Uintptr

ToConMapUint16Uintptr creates a new ConMapUint16Uintptr prepopulated with the data from the specified map[Uint16]Uintptr.

func (*ConMapUint16Uintptr) Delete 

func (cm *ConMapUint16Uintptr) Delete(k uint16) (uintptr, bool)

Delete removes the specified uint16 key, returning its uintptr value and a bool indicating whether the delete occurred or not.

func (*ConMapUint16Uintptr) Get 

func (cm *ConMapUint16Uintptr) Get(k uint16) uintptr

Get gets the uintptr value for the given uint16 key.

func (*ConMapUint16Uintptr) GetOK 

func (cm *ConMapUint16Uintptr) GetOK(k uint16) (uintptr, bool)

GetOK gets the uintptr value for the given uint16 key, and a bool indicating whether the key was present or not.

func (*ConMapUint16Uintptr) Len 

func (cm *ConMapUint16Uintptr) Len() int

Get gets the uintptr value for the given uint16 key.

func (*ConMapUint16Uintptr) Set 

func (cm *ConMapUint16Uintptr) Set(k uint16, v uintptr)

Set sets the uintptr value for the specified uint16 key.

type ConMapUint32Bool 

type ConMapUint32Bool struct {
	// M is the underlying map[Uint32]Bool.
	M map[uint32]bool
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint32Bool is a concurrent safe wrapper around a map[Uint32]Bool.

func NewConMapUint32Bool 

func NewConMapUint32Bool() *ConMapUint32Bool

NewConMapUint32Bool creates a new concurrent safe map storing bool values, for uint32 keys.

func ToConMapUint32Bool 

func ToConMapUint32Bool(data map[uint32]bool) *ConMapUint32Bool

ToConMapUint32Bool creates a new ConMapUint32Bool prepopulated with the data from the specified map[Uint32]Bool.

func (*ConMapUint32Bool) Delete 

func (cm *ConMapUint32Bool) Delete(k uint32) (bool, bool)

Delete removes the specified uint32 key, returning its bool value and a bool indicating whether the delete occurred or not.

func (*ConMapUint32Bool) Get 

func (cm *ConMapUint32Bool) Get(k uint32) bool

Get gets the bool value for the given uint32 key.

func (*ConMapUint32Bool) GetOK 

func (cm *ConMapUint32Bool) GetOK(k uint32) (bool, bool)

GetOK gets the bool value for the given uint32 key, and a bool indicating whether the key was present or not.

func (*ConMapUint32Bool) Len 

func (cm *ConMapUint32Bool) Len() int

Get gets the bool value for the given uint32 key.

func (*ConMapUint32Bool) Set 

func (cm *ConMapUint32Bool) Set(k uint32, v bool)

Set sets the bool value for the specified uint32 key.

type ConMapUint32Byte 

type ConMapUint32Byte struct {
	// M is the underlying map[Uint32]Byte.
	M map[uint32]byte
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint32Byte is a concurrent safe wrapper around a map[Uint32]Byte.

func NewConMapUint32Byte 

func NewConMapUint32Byte() *ConMapUint32Byte

NewConMapUint32Byte creates a new concurrent safe map storing byte values, for uint32 keys.

func ToConMapUint32Byte 

func ToConMapUint32Byte(data map[uint32]byte) *ConMapUint32Byte

ToConMapUint32Byte creates a new ConMapUint32Byte prepopulated with the data from the specified map[Uint32]Byte.

func (*ConMapUint32Byte) Delete 

func (cm *ConMapUint32Byte) Delete(k uint32) (byte, bool)

Delete removes the specified uint32 key, returning its byte value and a bool indicating whether the delete occurred or not.

func (*ConMapUint32Byte) Get 

func (cm *ConMapUint32Byte) Get(k uint32) byte

Get gets the byte value for the given uint32 key.

func (*ConMapUint32Byte) GetOK 

func (cm *ConMapUint32Byte) GetOK(k uint32) (byte, bool)

GetOK gets the byte value for the given uint32 key, and a bool indicating whether the key was present or not.

func (*ConMapUint32Byte) Len 

func (cm *ConMapUint32Byte) Len() int

Get gets the byte value for the given uint32 key.

func (*ConMapUint32Byte) Set 

func (cm *ConMapUint32Byte) Set(k uint32, v byte)

Set sets the byte value for the specified uint32 key.

type ConMapUint32Complex128 

type ConMapUint32Complex128 struct {
	// M is the underlying map[Uint32]Complex128.
	M map[uint32]complex128
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint32Complex128 is a concurrent safe wrapper around a map[Uint32]Complex128.

func NewConMapUint32Complex128 

func NewConMapUint32Complex128() *ConMapUint32Complex128

NewConMapUint32Complex128 creates a new concurrent safe map storing complex128 values, for uint32 keys.

func ToConMapUint32Complex128 

func ToConMapUint32Complex128(data map[uint32]complex128) *ConMapUint32Complex128

ToConMapUint32Complex128 creates a new ConMapUint32Complex128 prepopulated with the data from the specified map[Uint32]Complex128.

func (*ConMapUint32Complex128) Delete 

func (cm *ConMapUint32Complex128) Delete(k uint32) (complex128, bool)

Delete removes the specified uint32 key, returning its complex128 value and a bool indicating whether the delete occurred or not.

func (*ConMapUint32Complex128) Get 

func (cm *ConMapUint32Complex128) Get(k uint32) complex128

Get gets the complex128 value for the given uint32 key.

func (*ConMapUint32Complex128) GetOK 

func (cm *ConMapUint32Complex128) GetOK(k uint32) (complex128, bool)

GetOK gets the complex128 value for the given uint32 key, and a bool indicating whether the key was present or not.

func (*ConMapUint32Complex128) Len 

func (cm *ConMapUint32Complex128) Len() int

Get gets the complex128 value for the given uint32 key.

func (*ConMapUint32Complex128) Set 

func (cm *ConMapUint32Complex128) Set(k uint32, v complex128)

Set sets the complex128 value for the specified uint32 key.

type ConMapUint32Complex64 

type ConMapUint32Complex64 struct {
	// M is the underlying map[Uint32]Complex64.
	M map[uint32]complex64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint32Complex64 is a concurrent safe wrapper around a map[Uint32]Complex64.

func NewConMapUint32Complex64 

func NewConMapUint32Complex64() *ConMapUint32Complex64

NewConMapUint32Complex64 creates a new concurrent safe map storing complex64 values, for uint32 keys.

func ToConMapUint32Complex64 

func ToConMapUint32Complex64(data map[uint32]complex64) *ConMapUint32Complex64

ToConMapUint32Complex64 creates a new ConMapUint32Complex64 prepopulated with the data from the specified map[Uint32]Complex64.

func (*ConMapUint32Complex64) Delete 

func (cm *ConMapUint32Complex64) Delete(k uint32) (complex64, bool)

Delete removes the specified uint32 key, returning its complex64 value and a bool indicating whether the delete occurred or not.

func (*ConMapUint32Complex64) Get 

func (cm *ConMapUint32Complex64) Get(k uint32) complex64

Get gets the complex64 value for the given uint32 key.

func (*ConMapUint32Complex64) GetOK 

func (cm *ConMapUint32Complex64) GetOK(k uint32) (complex64, bool)

GetOK gets the complex64 value for the given uint32 key, and a bool indicating whether the key was present or not.

func (*ConMapUint32Complex64) Len 

func (cm *ConMapUint32Complex64) Len() int

Get gets the complex64 value for the given uint32 key.

func (*ConMapUint32Complex64) Set 

func (cm *ConMapUint32Complex64) Set(k uint32, v complex64)

Set sets the complex64 value for the specified uint32 key.

type ConMapUint32Error 

type ConMapUint32Error struct {
	// M is the underlying map[Uint32]Error.
	M map[uint32]error
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint32Error is a concurrent safe wrapper around a map[Uint32]Error.

func NewConMapUint32Error 

func NewConMapUint32Error() *ConMapUint32Error

NewConMapUint32Error creates a new concurrent safe map storing error values, for uint32 keys.

func ToConMapUint32Error 

func ToConMapUint32Error(data map[uint32]error) *ConMapUint32Error

ToConMapUint32Error creates a new ConMapUint32Error prepopulated with the data from the specified map[Uint32]Error.

func (*ConMapUint32Error) Delete 

func (cm *ConMapUint32Error) Delete(k uint32) (error, bool)

Delete removes the specified uint32 key, returning its error value and a bool indicating whether the delete occurred or not.

func (*ConMapUint32Error) Get 

func (cm *ConMapUint32Error) Get(k uint32) error

Get gets the error value for the given uint32 key.

func (*ConMapUint32Error) GetOK 

func (cm *ConMapUint32Error) GetOK(k uint32) (error, bool)

GetOK gets the error value for the given uint32 key, and a bool indicating whether the key was present or not.

func (*ConMapUint32Error) Len 

func (cm *ConMapUint32Error) Len() int

Get gets the error value for the given uint32 key.

func (*ConMapUint32Error) Set 

func (cm *ConMapUint32Error) Set(k uint32, v error)

Set sets the error value for the specified uint32 key.

type ConMapUint32Float32 

type ConMapUint32Float32 struct {
	// M is the underlying map[Uint32]Float32.
	M map[uint32]float32
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint32Float32 is a concurrent safe wrapper around a map[Uint32]Float32.

func NewConMapUint32Float32 

func NewConMapUint32Float32() *ConMapUint32Float32

NewConMapUint32Float32 creates a new concurrent safe map storing float32 values, for uint32 keys.

func ToConMapUint32Float32 

func ToConMapUint32Float32(data map[uint32]float32) *ConMapUint32Float32

ToConMapUint32Float32 creates a new ConMapUint32Float32 prepopulated with the data from the specified map[Uint32]Float32.

func (*ConMapUint32Float32) Delete 

func (cm *ConMapUint32Float32) Delete(k uint32) (float32, bool)

Delete removes the specified uint32 key, returning its float32 value and a bool indicating whether the delete occurred or not.

func (*ConMapUint32Float32) Get 

func (cm *ConMapUint32Float32) Get(k uint32) float32

Get gets the float32 value for the given uint32 key.

func (*ConMapUint32Float32) GetOK 

func (cm *ConMapUint32Float32) GetOK(k uint32) (float32, bool)

GetOK gets the float32 value for the given uint32 key, and a bool indicating whether the key was present or not.

func (*ConMapUint32Float32) Len 

func (cm *ConMapUint32Float32) Len() int

Get gets the float32 value for the given uint32 key.

func (*ConMapUint32Float32) Set 

func (cm *ConMapUint32Float32) Set(k uint32, v float32)

Set sets the float32 value for the specified uint32 key.

type ConMapUint32Float64 

type ConMapUint32Float64 struct {
	// M is the underlying map[Uint32]Float64.
	M map[uint32]float64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint32Float64 is a concurrent safe wrapper around a map[Uint32]Float64.

func NewConMapUint32Float64 

func NewConMapUint32Float64() *ConMapUint32Float64

NewConMapUint32Float64 creates a new concurrent safe map storing float64 values, for uint32 keys.

func ToConMapUint32Float64 

func ToConMapUint32Float64(data map[uint32]float64) *ConMapUint32Float64

ToConMapUint32Float64 creates a new ConMapUint32Float64 prepopulated with the data from the specified map[Uint32]Float64.

func (*ConMapUint32Float64) Delete 

func (cm *ConMapUint32Float64) Delete(k uint32) (float64, bool)

Delete removes the specified uint32 key, returning its float64 value and a bool indicating whether the delete occurred or not.

func (*ConMapUint32Float64) Get 

func (cm *ConMapUint32Float64) Get(k uint32) float64

Get gets the float64 value for the given uint32 key.

func (*ConMapUint32Float64) GetOK 

func (cm *ConMapUint32Float64) GetOK(k uint32) (float64, bool)

GetOK gets the float64 value for the given uint32 key, and a bool indicating whether the key was present or not.

func (*ConMapUint32Float64) Len 

func (cm *ConMapUint32Float64) Len() int

Get gets the float64 value for the given uint32 key.

func (*ConMapUint32Float64) Set 

func (cm *ConMapUint32Float64) Set(k uint32, v float64)

Set sets the float64 value for the specified uint32 key.

type ConMapUint32Int 

type ConMapUint32Int struct {
	// M is the underlying map[Uint32]Int.
	M map[uint32]int
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint32Int is a concurrent safe wrapper around a map[Uint32]Int.

func NewConMapUint32Int 

func NewConMapUint32Int() *ConMapUint32Int

NewConMapUint32Int creates a new concurrent safe map storing int values, for uint32 keys.

func ToConMapUint32Int 

func ToConMapUint32Int(data map[uint32]int) *ConMapUint32Int

ToConMapUint32Int creates a new ConMapUint32Int prepopulated with the data from the specified map[Uint32]Int.

func (*ConMapUint32Int) Delete 

func (cm *ConMapUint32Int) Delete(k uint32) (int, bool)

Delete removes the specified uint32 key, returning its int value and a bool indicating whether the delete occurred or not.

func (*ConMapUint32Int) Get 

func (cm *ConMapUint32Int) Get(k uint32) int

Get gets the int value for the given uint32 key.

func (*ConMapUint32Int) GetOK 

func (cm *ConMapUint32Int) GetOK(k uint32) (int, bool)

GetOK gets the int value for the given uint32 key, and a bool indicating whether the key was present or not.

func (*ConMapUint32Int) Len 

func (cm *ConMapUint32Int) Len() int

Get gets the int value for the given uint32 key.

func (*ConMapUint32Int) Set 

func (cm *ConMapUint32Int) Set(k uint32, v int)

Set sets the int value for the specified uint32 key.

type ConMapUint32Int16 

type ConMapUint32Int16 struct {
	// M is the underlying map[Uint32]Int16.
	M map[uint32]int16
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint32Int16 is a concurrent safe wrapper around a map[Uint32]Int16.

func NewConMapUint32Int16 

func NewConMapUint32Int16() *ConMapUint32Int16

NewConMapUint32Int16 creates a new concurrent safe map storing int16 values, for uint32 keys.

func ToConMapUint32Int16 

func ToConMapUint32Int16(data map[uint32]int16) *ConMapUint32Int16

ToConMapUint32Int16 creates a new ConMapUint32Int16 prepopulated with the data from the specified map[Uint32]Int16.

func (*ConMapUint32Int16) Delete 

func (cm *ConMapUint32Int16) Delete(k uint32) (int16, bool)

Delete removes the specified uint32 key, returning its int16 value and a bool indicating whether the delete occurred or not.

func (*ConMapUint32Int16) Get 

func (cm *ConMapUint32Int16) Get(k uint32) int16

Get gets the int16 value for the given uint32 key.

func (*ConMapUint32Int16) GetOK 

func (cm *ConMapUint32Int16) GetOK(k uint32) (int16, bool)

GetOK gets the int16 value for the given uint32 key, and a bool indicating whether the key was present or not.

func (*ConMapUint32Int16) Len 

func (cm *ConMapUint32Int16) Len() int

Get gets the int16 value for the given uint32 key.

func (*ConMapUint32Int16) Set 

func (cm *ConMapUint32Int16) Set(k uint32, v int16)

Set sets the int16 value for the specified uint32 key.

type ConMapUint32Int32 

type ConMapUint32Int32 struct {
	// M is the underlying map[Uint32]Int32.
	M map[uint32]int32
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint32Int32 is a concurrent safe wrapper around a map[Uint32]Int32.

func NewConMapUint32Int32 

func NewConMapUint32Int32() *ConMapUint32Int32

NewConMapUint32Int32 creates a new concurrent safe map storing int32 values, for uint32 keys.

func ToConMapUint32Int32 

func ToConMapUint32Int32(data map[uint32]int32) *ConMapUint32Int32

ToConMapUint32Int32 creates a new ConMapUint32Int32 prepopulated with the data from the specified map[Uint32]Int32.

func (*ConMapUint32Int32) Delete 

func (cm *ConMapUint32Int32) Delete(k uint32) (int32, bool)

Delete removes the specified uint32 key, returning its int32 value and a bool indicating whether the delete occurred or not.

func (*ConMapUint32Int32) Get 

func (cm *ConMapUint32Int32) Get(k uint32) int32

Get gets the int32 value for the given uint32 key.

func (*ConMapUint32Int32) GetOK 

func (cm *ConMapUint32Int32) GetOK(k uint32) (int32, bool)

GetOK gets the int32 value for the given uint32 key, and a bool indicating whether the key was present or not.

func (*ConMapUint32Int32) Len 

func (cm *ConMapUint32Int32) Len() int

Get gets the int32 value for the given uint32 key.

func (*ConMapUint32Int32) Set 

func (cm *ConMapUint32Int32) Set(k uint32, v int32)

Set sets the int32 value for the specified uint32 key.

type ConMapUint32Int64 

type ConMapUint32Int64 struct {
	// M is the underlying map[Uint32]Int64.
	M map[uint32]int64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint32Int64 is a concurrent safe wrapper around a map[Uint32]Int64.

func NewConMapUint32Int64 

func NewConMapUint32Int64() *ConMapUint32Int64

NewConMapUint32Int64 creates a new concurrent safe map storing int64 values, for uint32 keys.

func ToConMapUint32Int64 

func ToConMapUint32Int64(data map[uint32]int64) *ConMapUint32Int64

ToConMapUint32Int64 creates a new ConMapUint32Int64 prepopulated with the data from the specified map[Uint32]Int64.

func (*ConMapUint32Int64) Delete 

func (cm *ConMapUint32Int64) Delete(k uint32) (int64, bool)

Delete removes the specified uint32 key, returning its int64 value and a bool indicating whether the delete occurred or not.

func (*ConMapUint32Int64) Get 

func (cm *ConMapUint32Int64) Get(k uint32) int64

Get gets the int64 value for the given uint32 key.

func (*ConMapUint32Int64) GetOK 

func (cm *ConMapUint32Int64) GetOK(k uint32) (int64, bool)

GetOK gets the int64 value for the given uint32 key, and a bool indicating whether the key was present or not.

func (*ConMapUint32Int64) Len 

func (cm *ConMapUint32Int64) Len() int

Get gets the int64 value for the given uint32 key.

func (*ConMapUint32Int64) Set 

func (cm *ConMapUint32Int64) Set(k uint32, v int64)

Set sets the int64 value for the specified uint32 key.

type ConMapUint32Int8 

type ConMapUint32Int8 struct {
	// M is the underlying map[Uint32]Int8.
	M map[uint32]int8
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint32Int8 is a concurrent safe wrapper around a map[Uint32]Int8.

func NewConMapUint32Int8 

func NewConMapUint32Int8() *ConMapUint32Int8

NewConMapUint32Int8 creates a new concurrent safe map storing int8 values, for uint32 keys.

func ToConMapUint32Int8 

func ToConMapUint32Int8(data map[uint32]int8) *ConMapUint32Int8

ToConMapUint32Int8 creates a new ConMapUint32Int8 prepopulated with the data from the specified map[Uint32]Int8.

func (*ConMapUint32Int8) Delete 

func (cm *ConMapUint32Int8) Delete(k uint32) (int8, bool)

Delete removes the specified uint32 key, returning its int8 value and a bool indicating whether the delete occurred or not.

func (*ConMapUint32Int8) Get 

func (cm *ConMapUint32Int8) Get(k uint32) int8

Get gets the int8 value for the given uint32 key.

func (*ConMapUint32Int8) GetOK 

func (cm *ConMapUint32Int8) GetOK(k uint32) (int8, bool)

GetOK gets the int8 value for the given uint32 key, and a bool indicating whether the key was present or not.

func (*ConMapUint32Int8) Len 

func (cm *ConMapUint32Int8) Len() int

Get gets the int8 value for the given uint32 key.

func (*ConMapUint32Int8) Set 

func (cm *ConMapUint32Int8) Set(k uint32, v int8)

Set sets the int8 value for the specified uint32 key.

type ConMapUint32Rune 

type ConMapUint32Rune struct {
	// M is the underlying map[Uint32]Rune.
	M map[uint32]rune
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint32Rune is a concurrent safe wrapper around a map[Uint32]Rune.

func NewConMapUint32Rune 

func NewConMapUint32Rune() *ConMapUint32Rune

NewConMapUint32Rune creates a new concurrent safe map storing rune values, for uint32 keys.

func ToConMapUint32Rune 

func ToConMapUint32Rune(data map[uint32]rune) *ConMapUint32Rune

ToConMapUint32Rune creates a new ConMapUint32Rune prepopulated with the data from the specified map[Uint32]Rune.

func (*ConMapUint32Rune) Delete 

func (cm *ConMapUint32Rune) Delete(k uint32) (rune, bool)

Delete removes the specified uint32 key, returning its rune value and a bool indicating whether the delete occurred or not.

func (*ConMapUint32Rune) Get 

func (cm *ConMapUint32Rune) Get(k uint32) rune

Get gets the rune value for the given uint32 key.

func (*ConMapUint32Rune) GetOK 

func (cm *ConMapUint32Rune) GetOK(k uint32) (rune, bool)

GetOK gets the rune value for the given uint32 key, and a bool indicating whether the key was present or not.

func (*ConMapUint32Rune) Len 

func (cm *ConMapUint32Rune) Len() int

Get gets the rune value for the given uint32 key.

func (*ConMapUint32Rune) Set 

func (cm *ConMapUint32Rune) Set(k uint32, v rune)

Set sets the rune value for the specified uint32 key.

type ConMapUint32String 

type ConMapUint32String struct {
	// M is the underlying map[Uint32]String.
	M map[uint32]string
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint32String is a concurrent safe wrapper around a map[Uint32]String.

func NewConMapUint32String 

func NewConMapUint32String() *ConMapUint32String

NewConMapUint32String creates a new concurrent safe map storing string values, for uint32 keys.

func ToConMapUint32String 

func ToConMapUint32String(data map[uint32]string) *ConMapUint32String

ToConMapUint32String creates a new ConMapUint32String prepopulated with the data from the specified map[Uint32]String.

func (*ConMapUint32String) Delete 

func (cm *ConMapUint32String) Delete(k uint32) (string, bool)

Delete removes the specified uint32 key, returning its string value and a bool indicating whether the delete occurred or not.

func (*ConMapUint32String) Get 

func (cm *ConMapUint32String) Get(k uint32) string

Get gets the string value for the given uint32 key.

func (*ConMapUint32String) GetOK 

func (cm *ConMapUint32String) GetOK(k uint32) (string, bool)

GetOK gets the string value for the given uint32 key, and a bool indicating whether the key was present or not.

func (*ConMapUint32String) Len 

func (cm *ConMapUint32String) Len() int

Get gets the string value for the given uint32 key.

func (*ConMapUint32String) Set 

func (cm *ConMapUint32String) Set(k uint32, v string)

Set sets the string value for the specified uint32 key.

type ConMapUint32Uint 

type ConMapUint32Uint struct {
	// M is the underlying map[Uint32]Uint.
	M map[uint32]uint
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint32Uint is a concurrent safe wrapper around a map[Uint32]Uint.

func NewConMapUint32Uint 

func NewConMapUint32Uint() *ConMapUint32Uint

NewConMapUint32Uint creates a new concurrent safe map storing uint values, for uint32 keys.

func ToConMapUint32Uint 

func ToConMapUint32Uint(data map[uint32]uint) *ConMapUint32Uint

ToConMapUint32Uint creates a new ConMapUint32Uint prepopulated with the data from the specified map[Uint32]Uint.

func (*ConMapUint32Uint) Delete 

func (cm *ConMapUint32Uint) Delete(k uint32) (uint, bool)

Delete removes the specified uint32 key, returning its uint value and a bool indicating whether the delete occurred or not.

func (*ConMapUint32Uint) Get 

func (cm *ConMapUint32Uint) Get(k uint32) uint

Get gets the uint value for the given uint32 key.

func (*ConMapUint32Uint) GetOK 

func (cm *ConMapUint32Uint) GetOK(k uint32) (uint, bool)

GetOK gets the uint value for the given uint32 key, and a bool indicating whether the key was present or not.

func (*ConMapUint32Uint) Len 

func (cm *ConMapUint32Uint) Len() int

Get gets the uint value for the given uint32 key.

func (*ConMapUint32Uint) Set 

func (cm *ConMapUint32Uint) Set(k uint32, v uint)

Set sets the uint value for the specified uint32 key.

type ConMapUint32Uint16 

type ConMapUint32Uint16 struct {
	// M is the underlying map[Uint32]Uint16.
	M map[uint32]uint16
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint32Uint16 is a concurrent safe wrapper around a map[Uint32]Uint16.

func NewConMapUint32Uint16 

func NewConMapUint32Uint16() *ConMapUint32Uint16

NewConMapUint32Uint16 creates a new concurrent safe map storing uint16 values, for uint32 keys.

func ToConMapUint32Uint16 

func ToConMapUint32Uint16(data map[uint32]uint16) *ConMapUint32Uint16

ToConMapUint32Uint16 creates a new ConMapUint32Uint16 prepopulated with the data from the specified map[Uint32]Uint16.

func (*ConMapUint32Uint16) Delete 

func (cm *ConMapUint32Uint16) Delete(k uint32) (uint16, bool)

Delete removes the specified uint32 key, returning its uint16 value and a bool indicating whether the delete occurred or not.

func (*ConMapUint32Uint16) Get 

func (cm *ConMapUint32Uint16) Get(k uint32) uint16

Get gets the uint16 value for the given uint32 key.

func (*ConMapUint32Uint16) GetOK 

func (cm *ConMapUint32Uint16) GetOK(k uint32) (uint16, bool)

GetOK gets the uint16 value for the given uint32 key, and a bool indicating whether the key was present or not.

func (*ConMapUint32Uint16) Len 

func (cm *ConMapUint32Uint16) Len() int

Get gets the uint16 value for the given uint32 key.

func (*ConMapUint32Uint16) Set 

func (cm *ConMapUint32Uint16) Set(k uint32, v uint16)

Set sets the uint16 value for the specified uint32 key.

type ConMapUint32Uint32 

type ConMapUint32Uint32 struct {
	// M is the underlying map[Uint32]Uint32.
	M map[uint32]uint32
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint32Uint32 is a concurrent safe wrapper around a map[Uint32]Uint32.

func NewConMapUint32Uint32 

func NewConMapUint32Uint32() *ConMapUint32Uint32

NewConMapUint32Uint32 creates a new concurrent safe map storing uint32 values, for uint32 keys.

func ToConMapUint32Uint32 

func ToConMapUint32Uint32(data map[uint32]uint32) *ConMapUint32Uint32

ToConMapUint32Uint32 creates a new ConMapUint32Uint32 prepopulated with the data from the specified map[Uint32]Uint32.

func (*ConMapUint32Uint32) Delete 

func (cm *ConMapUint32Uint32) Delete(k uint32) (uint32, bool)

Delete removes the specified uint32 key, returning its uint32 value and a bool indicating whether the delete occurred or not.

func (*ConMapUint32Uint32) Get 

func (cm *ConMapUint32Uint32) Get(k uint32) uint32

Get gets the uint32 value for the given uint32 key.

func (*ConMapUint32Uint32) GetOK 

func (cm *ConMapUint32Uint32) GetOK(k uint32) (uint32, bool)

GetOK gets the uint32 value for the given uint32 key, and a bool indicating whether the key was present or not.

func (*ConMapUint32Uint32) Len 

func (cm *ConMapUint32Uint32) Len() int

Get gets the uint32 value for the given uint32 key.

func (*ConMapUint32Uint32) Set 

func (cm *ConMapUint32Uint32) Set(k uint32, v uint32)

Set sets the uint32 value for the specified uint32 key.

type ConMapUint32Uint64 

type ConMapUint32Uint64 struct {
	// M is the underlying map[Uint32]Uint64.
	M map[uint32]uint64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint32Uint64 is a concurrent safe wrapper around a map[Uint32]Uint64.

func NewConMapUint32Uint64 

func NewConMapUint32Uint64() *ConMapUint32Uint64

NewConMapUint32Uint64 creates a new concurrent safe map storing uint64 values, for uint32 keys.

func ToConMapUint32Uint64 

func ToConMapUint32Uint64(data map[uint32]uint64) *ConMapUint32Uint64

ToConMapUint32Uint64 creates a new ConMapUint32Uint64 prepopulated with the data from the specified map[Uint32]Uint64.

func (*ConMapUint32Uint64) Delete 

func (cm *ConMapUint32Uint64) Delete(k uint32) (uint64, bool)

Delete removes the specified uint32 key, returning its uint64 value and a bool indicating whether the delete occurred or not.

func (*ConMapUint32Uint64) Get 

func (cm *ConMapUint32Uint64) Get(k uint32) uint64

Get gets the uint64 value for the given uint32 key.

func (*ConMapUint32Uint64) GetOK 

func (cm *ConMapUint32Uint64) GetOK(k uint32) (uint64, bool)

GetOK gets the uint64 value for the given uint32 key, and a bool indicating whether the key was present or not.

func (*ConMapUint32Uint64) Len 

func (cm *ConMapUint32Uint64) Len() int

Get gets the uint64 value for the given uint32 key.

func (*ConMapUint32Uint64) Set 

func (cm *ConMapUint32Uint64) Set(k uint32, v uint64)

Set sets the uint64 value for the specified uint32 key.

type ConMapUint32Uint8 

type ConMapUint32Uint8 struct {
	// M is the underlying map[Uint32]Uint8.
	M map[uint32]uint8
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint32Uint8 is a concurrent safe wrapper around a map[Uint32]Uint8.

func NewConMapUint32Uint8 

func NewConMapUint32Uint8() *ConMapUint32Uint8

NewConMapUint32Uint8 creates a new concurrent safe map storing uint8 values, for uint32 keys.

func ToConMapUint32Uint8 

func ToConMapUint32Uint8(data map[uint32]uint8) *ConMapUint32Uint8

ToConMapUint32Uint8 creates a new ConMapUint32Uint8 prepopulated with the data from the specified map[Uint32]Uint8.

func (*ConMapUint32Uint8) Delete 

func (cm *ConMapUint32Uint8) Delete(k uint32) (uint8, bool)

Delete removes the specified uint32 key, returning its uint8 value and a bool indicating whether the delete occurred or not.

func (*ConMapUint32Uint8) Get 

func (cm *ConMapUint32Uint8) Get(k uint32) uint8

Get gets the uint8 value for the given uint32 key.

func (*ConMapUint32Uint8) GetOK 

func (cm *ConMapUint32Uint8) GetOK(k uint32) (uint8, bool)

GetOK gets the uint8 value for the given uint32 key, and a bool indicating whether the key was present or not.

func (*ConMapUint32Uint8) Len 

func (cm *ConMapUint32Uint8) Len() int

Get gets the uint8 value for the given uint32 key.

func (*ConMapUint32Uint8) Set 

func (cm *ConMapUint32Uint8) Set(k uint32, v uint8)

Set sets the uint8 value for the specified uint32 key.

type ConMapUint32Uintptr 

type ConMapUint32Uintptr struct {
	// M is the underlying map[Uint32]Uintptr.
	M map[uint32]uintptr
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint32Uintptr is a concurrent safe wrapper around a map[Uint32]Uintptr.

func NewConMapUint32Uintptr 

func NewConMapUint32Uintptr() *ConMapUint32Uintptr

NewConMapUint32Uintptr creates a new concurrent safe map storing uintptr values, for uint32 keys.

func ToConMapUint32Uintptr 

func ToConMapUint32Uintptr(data map[uint32]uintptr) *ConMapUint32Uintptr

ToConMapUint32Uintptr creates a new ConMapUint32Uintptr prepopulated with the data from the specified map[Uint32]Uintptr.

func (*ConMapUint32Uintptr) Delete 

func (cm *ConMapUint32Uintptr) Delete(k uint32) (uintptr, bool)

Delete removes the specified uint32 key, returning its uintptr value and a bool indicating whether the delete occurred or not.

func (*ConMapUint32Uintptr) Get 

func (cm *ConMapUint32Uintptr) Get(k uint32) uintptr

Get gets the uintptr value for the given uint32 key.

func (*ConMapUint32Uintptr) GetOK 

func (cm *ConMapUint32Uintptr) GetOK(k uint32) (uintptr, bool)

GetOK gets the uintptr value for the given uint32 key, and a bool indicating whether the key was present or not.

func (*ConMapUint32Uintptr) Len 

func (cm *ConMapUint32Uintptr) Len() int

Get gets the uintptr value for the given uint32 key.

func (*ConMapUint32Uintptr) Set 

func (cm *ConMapUint32Uintptr) Set(k uint32, v uintptr)

Set sets the uintptr value for the specified uint32 key.

type ConMapUint64Bool 

type ConMapUint64Bool struct {
	// M is the underlying map[Uint64]Bool.
	M map[uint64]bool
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint64Bool is a concurrent safe wrapper around a map[Uint64]Bool.

func NewConMapUint64Bool 

func NewConMapUint64Bool() *ConMapUint64Bool

NewConMapUint64Bool creates a new concurrent safe map storing bool values, for uint64 keys.

func ToConMapUint64Bool 

func ToConMapUint64Bool(data map[uint64]bool) *ConMapUint64Bool

ToConMapUint64Bool creates a new ConMapUint64Bool prepopulated with the data from the specified map[Uint64]Bool.

func (*ConMapUint64Bool) Delete 

func (cm *ConMapUint64Bool) Delete(k uint64) (bool, bool)

Delete removes the specified uint64 key, returning its bool value and a bool indicating whether the delete occurred or not.

func (*ConMapUint64Bool) Get 

func (cm *ConMapUint64Bool) Get(k uint64) bool

Get gets the bool value for the given uint64 key.

func (*ConMapUint64Bool) GetOK 

func (cm *ConMapUint64Bool) GetOK(k uint64) (bool, bool)

GetOK gets the bool value for the given uint64 key, and a bool indicating whether the key was present or not.

func (*ConMapUint64Bool) Len 

func (cm *ConMapUint64Bool) Len() int

Get gets the bool value for the given uint64 key.

func (*ConMapUint64Bool) Set 

func (cm *ConMapUint64Bool) Set(k uint64, v bool)

Set sets the bool value for the specified uint64 key.

type ConMapUint64Byte 

type ConMapUint64Byte struct {
	// M is the underlying map[Uint64]Byte.
	M map[uint64]byte
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint64Byte is a concurrent safe wrapper around a map[Uint64]Byte.

func NewConMapUint64Byte 

func NewConMapUint64Byte() *ConMapUint64Byte

NewConMapUint64Byte creates a new concurrent safe map storing byte values, for uint64 keys.

func ToConMapUint64Byte 

func ToConMapUint64Byte(data map[uint64]byte) *ConMapUint64Byte

ToConMapUint64Byte creates a new ConMapUint64Byte prepopulated with the data from the specified map[Uint64]Byte.

func (*ConMapUint64Byte) Delete 

func (cm *ConMapUint64Byte) Delete(k uint64) (byte, bool)

Delete removes the specified uint64 key, returning its byte value and a bool indicating whether the delete occurred or not.

func (*ConMapUint64Byte) Get 

func (cm *ConMapUint64Byte) Get(k uint64) byte

Get gets the byte value for the given uint64 key.

func (*ConMapUint64Byte) GetOK 

func (cm *ConMapUint64Byte) GetOK(k uint64) (byte, bool)

GetOK gets the byte value for the given uint64 key, and a bool indicating whether the key was present or not.

func (*ConMapUint64Byte) Len 

func (cm *ConMapUint64Byte) Len() int

Get gets the byte value for the given uint64 key.

func (*ConMapUint64Byte) Set 

func (cm *ConMapUint64Byte) Set(k uint64, v byte)

Set sets the byte value for the specified uint64 key.

type ConMapUint64Complex128 

type ConMapUint64Complex128 struct {
	// M is the underlying map[Uint64]Complex128.
	M map[uint64]complex128
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint64Complex128 is a concurrent safe wrapper around a map[Uint64]Complex128.

func NewConMapUint64Complex128 

func NewConMapUint64Complex128() *ConMapUint64Complex128

NewConMapUint64Complex128 creates a new concurrent safe map storing complex128 values, for uint64 keys.

func ToConMapUint64Complex128 

func ToConMapUint64Complex128(data map[uint64]complex128) *ConMapUint64Complex128

ToConMapUint64Complex128 creates a new ConMapUint64Complex128 prepopulated with the data from the specified map[Uint64]Complex128.

func (*ConMapUint64Complex128) Delete 

func (cm *ConMapUint64Complex128) Delete(k uint64) (complex128, bool)

Delete removes the specified uint64 key, returning its complex128 value and a bool indicating whether the delete occurred or not.

func (*ConMapUint64Complex128) Get 

func (cm *ConMapUint64Complex128) Get(k uint64) complex128

Get gets the complex128 value for the given uint64 key.

func (*ConMapUint64Complex128) GetOK 

func (cm *ConMapUint64Complex128) GetOK(k uint64) (complex128, bool)

GetOK gets the complex128 value for the given uint64 key, and a bool indicating whether the key was present or not.

func (*ConMapUint64Complex128) Len 

func (cm *ConMapUint64Complex128) Len() int

Get gets the complex128 value for the given uint64 key.

func (*ConMapUint64Complex128) Set 

func (cm *ConMapUint64Complex128) Set(k uint64, v complex128)

Set sets the complex128 value for the specified uint64 key.

type ConMapUint64Complex64 

type ConMapUint64Complex64 struct {
	// M is the underlying map[Uint64]Complex64.
	M map[uint64]complex64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint64Complex64 is a concurrent safe wrapper around a map[Uint64]Complex64.

func NewConMapUint64Complex64 

func NewConMapUint64Complex64() *ConMapUint64Complex64

NewConMapUint64Complex64 creates a new concurrent safe map storing complex64 values, for uint64 keys.

func ToConMapUint64Complex64 

func ToConMapUint64Complex64(data map[uint64]complex64) *ConMapUint64Complex64

ToConMapUint64Complex64 creates a new ConMapUint64Complex64 prepopulated with the data from the specified map[Uint64]Complex64.

func (*ConMapUint64Complex64) Delete 

func (cm *ConMapUint64Complex64) Delete(k uint64) (complex64, bool)

Delete removes the specified uint64 key, returning its complex64 value and a bool indicating whether the delete occurred or not.

func (*ConMapUint64Complex64) Get 

func (cm *ConMapUint64Complex64) Get(k uint64) complex64

Get gets the complex64 value for the given uint64 key.

func (*ConMapUint64Complex64) GetOK 

func (cm *ConMapUint64Complex64) GetOK(k uint64) (complex64, bool)

GetOK gets the complex64 value for the given uint64 key, and a bool indicating whether the key was present or not.

func (*ConMapUint64Complex64) Len 

func (cm *ConMapUint64Complex64) Len() int

Get gets the complex64 value for the given uint64 key.

func (*ConMapUint64Complex64) Set 

func (cm *ConMapUint64Complex64) Set(k uint64, v complex64)

Set sets the complex64 value for the specified uint64 key.

type ConMapUint64Error 

type ConMapUint64Error struct {
	// M is the underlying map[Uint64]Error.
	M map[uint64]error
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint64Error is a concurrent safe wrapper around a map[Uint64]Error.

func NewConMapUint64Error 

func NewConMapUint64Error() *ConMapUint64Error

NewConMapUint64Error creates a new concurrent safe map storing error values, for uint64 keys.

func ToConMapUint64Error 

func ToConMapUint64Error(data map[uint64]error) *ConMapUint64Error

ToConMapUint64Error creates a new ConMapUint64Error prepopulated with the data from the specified map[Uint64]Error.

func (*ConMapUint64Error) Delete 

func (cm *ConMapUint64Error) Delete(k uint64) (error, bool)

Delete removes the specified uint64 key, returning its error value and a bool indicating whether the delete occurred or not.

func (*ConMapUint64Error) Get 

func (cm *ConMapUint64Error) Get(k uint64) error

Get gets the error value for the given uint64 key.

func (*ConMapUint64Error) GetOK 

func (cm *ConMapUint64Error) GetOK(k uint64) (error, bool)

GetOK gets the error value for the given uint64 key, and a bool indicating whether the key was present or not.

func (*ConMapUint64Error) Len 

func (cm *ConMapUint64Error) Len() int

Get gets the error value for the given uint64 key.

func (*ConMapUint64Error) Set 

func (cm *ConMapUint64Error) Set(k uint64, v error)

Set sets the error value for the specified uint64 key.

type ConMapUint64Float32 

type ConMapUint64Float32 struct {
	// M is the underlying map[Uint64]Float32.
	M map[uint64]float32
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint64Float32 is a concurrent safe wrapper around a map[Uint64]Float32.

func NewConMapUint64Float32 

func NewConMapUint64Float32() *ConMapUint64Float32

NewConMapUint64Float32 creates a new concurrent safe map storing float32 values, for uint64 keys.

func ToConMapUint64Float32 

func ToConMapUint64Float32(data map[uint64]float32) *ConMapUint64Float32

ToConMapUint64Float32 creates a new ConMapUint64Float32 prepopulated with the data from the specified map[Uint64]Float32.

func (*ConMapUint64Float32) Delete 

func (cm *ConMapUint64Float32) Delete(k uint64) (float32, bool)

Delete removes the specified uint64 key, returning its float32 value and a bool indicating whether the delete occurred or not.

func (*ConMapUint64Float32) Get 

func (cm *ConMapUint64Float32) Get(k uint64) float32

Get gets the float32 value for the given uint64 key.

func (*ConMapUint64Float32) GetOK 

func (cm *ConMapUint64Float32) GetOK(k uint64) (float32, bool)

GetOK gets the float32 value for the given uint64 key, and a bool indicating whether the key was present or not.

func (*ConMapUint64Float32) Len 

func (cm *ConMapUint64Float32) Len() int

Get gets the float32 value for the given uint64 key.

func (*ConMapUint64Float32) Set 

func (cm *ConMapUint64Float32) Set(k uint64, v float32)

Set sets the float32 value for the specified uint64 key.

type ConMapUint64Float64 

type ConMapUint64Float64 struct {
	// M is the underlying map[Uint64]Float64.
	M map[uint64]float64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint64Float64 is a concurrent safe wrapper around a map[Uint64]Float64.

func NewConMapUint64Float64 

func NewConMapUint64Float64() *ConMapUint64Float64

NewConMapUint64Float64 creates a new concurrent safe map storing float64 values, for uint64 keys.

func ToConMapUint64Float64 

func ToConMapUint64Float64(data map[uint64]float64) *ConMapUint64Float64

ToConMapUint64Float64 creates a new ConMapUint64Float64 prepopulated with the data from the specified map[Uint64]Float64.

func (*ConMapUint64Float64) Delete 

func (cm *ConMapUint64Float64) Delete(k uint64) (float64, bool)

Delete removes the specified uint64 key, returning its float64 value and a bool indicating whether the delete occurred or not.

func (*ConMapUint64Float64) Get 

func (cm *ConMapUint64Float64) Get(k uint64) float64

Get gets the float64 value for the given uint64 key.

func (*ConMapUint64Float64) GetOK 

func (cm *ConMapUint64Float64) GetOK(k uint64) (float64, bool)

GetOK gets the float64 value for the given uint64 key, and a bool indicating whether the key was present or not.

func (*ConMapUint64Float64) Len 

func (cm *ConMapUint64Float64) Len() int

Get gets the float64 value for the given uint64 key.

func (*ConMapUint64Float64) Set 

func (cm *ConMapUint64Float64) Set(k uint64, v float64)

Set sets the float64 value for the specified uint64 key.

type ConMapUint64Int 

type ConMapUint64Int struct {
	// M is the underlying map[Uint64]Int.
	M map[uint64]int
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint64Int is a concurrent safe wrapper around a map[Uint64]Int.

func NewConMapUint64Int 

func NewConMapUint64Int() *ConMapUint64Int

NewConMapUint64Int creates a new concurrent safe map storing int values, for uint64 keys.

func ToConMapUint64Int 

func ToConMapUint64Int(data map[uint64]int) *ConMapUint64Int

ToConMapUint64Int creates a new ConMapUint64Int prepopulated with the data from the specified map[Uint64]Int.

func (*ConMapUint64Int) Delete 

func (cm *ConMapUint64Int) Delete(k uint64) (int, bool)

Delete removes the specified uint64 key, returning its int value and a bool indicating whether the delete occurred or not.

func (*ConMapUint64Int) Get 

func (cm *ConMapUint64Int) Get(k uint64) int

Get gets the int value for the given uint64 key.

func (*ConMapUint64Int) GetOK 

func (cm *ConMapUint64Int) GetOK(k uint64) (int, bool)

GetOK gets the int value for the given uint64 key, and a bool indicating whether the key was present or not.

func (*ConMapUint64Int) Len 

func (cm *ConMapUint64Int) Len() int

Get gets the int value for the given uint64 key.

func (*ConMapUint64Int) Set 

func (cm *ConMapUint64Int) Set(k uint64, v int)

Set sets the int value for the specified uint64 key.

type ConMapUint64Int16 

type ConMapUint64Int16 struct {
	// M is the underlying map[Uint64]Int16.
	M map[uint64]int16
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint64Int16 is a concurrent safe wrapper around a map[Uint64]Int16.

func NewConMapUint64Int16 

func NewConMapUint64Int16() *ConMapUint64Int16

NewConMapUint64Int16 creates a new concurrent safe map storing int16 values, for uint64 keys.

func ToConMapUint64Int16 

func ToConMapUint64Int16(data map[uint64]int16) *ConMapUint64Int16

ToConMapUint64Int16 creates a new ConMapUint64Int16 prepopulated with the data from the specified map[Uint64]Int16.

func (*ConMapUint64Int16) Delete 

func (cm *ConMapUint64Int16) Delete(k uint64) (int16, bool)

Delete removes the specified uint64 key, returning its int16 value and a bool indicating whether the delete occurred or not.

func (*ConMapUint64Int16) Get 

func (cm *ConMapUint64Int16) Get(k uint64) int16

Get gets the int16 value for the given uint64 key.

func (*ConMapUint64Int16) GetOK 

func (cm *ConMapUint64Int16) GetOK(k uint64) (int16, bool)

GetOK gets the int16 value for the given uint64 key, and a bool indicating whether the key was present or not.

func (*ConMapUint64Int16) Len 

func (cm *ConMapUint64Int16) Len() int

Get gets the int16 value for the given uint64 key.

func (*ConMapUint64Int16) Set 

func (cm *ConMapUint64Int16) Set(k uint64, v int16)

Set sets the int16 value for the specified uint64 key.

type ConMapUint64Int32 

type ConMapUint64Int32 struct {
	// M is the underlying map[Uint64]Int32.
	M map[uint64]int32
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint64Int32 is a concurrent safe wrapper around a map[Uint64]Int32.

func NewConMapUint64Int32 

func NewConMapUint64Int32() *ConMapUint64Int32

NewConMapUint64Int32 creates a new concurrent safe map storing int32 values, for uint64 keys.

func ToConMapUint64Int32 

func ToConMapUint64Int32(data map[uint64]int32) *ConMapUint64Int32

ToConMapUint64Int32 creates a new ConMapUint64Int32 prepopulated with the data from the specified map[Uint64]Int32.

func (*ConMapUint64Int32) Delete 

func (cm *ConMapUint64Int32) Delete(k uint64) (int32, bool)

Delete removes the specified uint64 key, returning its int32 value and a bool indicating whether the delete occurred or not.

func (*ConMapUint64Int32) Get 

func (cm *ConMapUint64Int32) Get(k uint64) int32

Get gets the int32 value for the given uint64 key.

func (*ConMapUint64Int32) GetOK 

func (cm *ConMapUint64Int32) GetOK(k uint64) (int32, bool)

GetOK gets the int32 value for the given uint64 key, and a bool indicating whether the key was present or not.

func (*ConMapUint64Int32) Len 

func (cm *ConMapUint64Int32) Len() int

Get gets the int32 value for the given uint64 key.

func (*ConMapUint64Int32) Set 

func (cm *ConMapUint64Int32) Set(k uint64, v int32)

Set sets the int32 value for the specified uint64 key.

type ConMapUint64Int64 

type ConMapUint64Int64 struct {
	// M is the underlying map[Uint64]Int64.
	M map[uint64]int64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint64Int64 is a concurrent safe wrapper around a map[Uint64]Int64.

func NewConMapUint64Int64 

func NewConMapUint64Int64() *ConMapUint64Int64

NewConMapUint64Int64 creates a new concurrent safe map storing int64 values, for uint64 keys.

func ToConMapUint64Int64 

func ToConMapUint64Int64(data map[uint64]int64) *ConMapUint64Int64

ToConMapUint64Int64 creates a new ConMapUint64Int64 prepopulated with the data from the specified map[Uint64]Int64.

func (*ConMapUint64Int64) Delete 

func (cm *ConMapUint64Int64) Delete(k uint64) (int64, bool)

Delete removes the specified uint64 key, returning its int64 value and a bool indicating whether the delete occurred or not.

func (*ConMapUint64Int64) Get 

func (cm *ConMapUint64Int64) Get(k uint64) int64

Get gets the int64 value for the given uint64 key.

func (*ConMapUint64Int64) GetOK 

func (cm *ConMapUint64Int64) GetOK(k uint64) (int64, bool)

GetOK gets the int64 value for the given uint64 key, and a bool indicating whether the key was present or not.

func (*ConMapUint64Int64) Len 

func (cm *ConMapUint64Int64) Len() int

Get gets the int64 value for the given uint64 key.

func (*ConMapUint64Int64) Set 

func (cm *ConMapUint64Int64) Set(k uint64, v int64)

Set sets the int64 value for the specified uint64 key.

type ConMapUint64Int8 

type ConMapUint64Int8 struct {
	// M is the underlying map[Uint64]Int8.
	M map[uint64]int8
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint64Int8 is a concurrent safe wrapper around a map[Uint64]Int8.

func NewConMapUint64Int8 

func NewConMapUint64Int8() *ConMapUint64Int8

NewConMapUint64Int8 creates a new concurrent safe map storing int8 values, for uint64 keys.

func ToConMapUint64Int8 

func ToConMapUint64Int8(data map[uint64]int8) *ConMapUint64Int8

ToConMapUint64Int8 creates a new ConMapUint64Int8 prepopulated with the data from the specified map[Uint64]Int8.

func (*ConMapUint64Int8) Delete 

func (cm *ConMapUint64Int8) Delete(k uint64) (int8, bool)

Delete removes the specified uint64 key, returning its int8 value and a bool indicating whether the delete occurred or not.

func (*ConMapUint64Int8) Get 

func (cm *ConMapUint64Int8) Get(k uint64) int8

Get gets the int8 value for the given uint64 key.

func (*ConMapUint64Int8) GetOK 

func (cm *ConMapUint64Int8) GetOK(k uint64) (int8, bool)

GetOK gets the int8 value for the given uint64 key, and a bool indicating whether the key was present or not.

func (*ConMapUint64Int8) Len 

func (cm *ConMapUint64Int8) Len() int

Get gets the int8 value for the given uint64 key.

func (*ConMapUint64Int8) Set 

func (cm *ConMapUint64Int8) Set(k uint64, v int8)

Set sets the int8 value for the specified uint64 key.

type ConMapUint64Rune 

type ConMapUint64Rune struct {
	// M is the underlying map[Uint64]Rune.
	M map[uint64]rune
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint64Rune is a concurrent safe wrapper around a map[Uint64]Rune.

func NewConMapUint64Rune 

func NewConMapUint64Rune() *ConMapUint64Rune

NewConMapUint64Rune creates a new concurrent safe map storing rune values, for uint64 keys.

func ToConMapUint64Rune 

func ToConMapUint64Rune(data map[uint64]rune) *ConMapUint64Rune

ToConMapUint64Rune creates a new ConMapUint64Rune prepopulated with the data from the specified map[Uint64]Rune.

func (*ConMapUint64Rune) Delete 

func (cm *ConMapUint64Rune) Delete(k uint64) (rune, bool)

Delete removes the specified uint64 key, returning its rune value and a bool indicating whether the delete occurred or not.

func (*ConMapUint64Rune) Get 

func (cm *ConMapUint64Rune) Get(k uint64) rune

Get gets the rune value for the given uint64 key.

func (*ConMapUint64Rune) GetOK 

func (cm *ConMapUint64Rune) GetOK(k uint64) (rune, bool)

GetOK gets the rune value for the given uint64 key, and a bool indicating whether the key was present or not.

func (*ConMapUint64Rune) Len 

func (cm *ConMapUint64Rune) Len() int

Get gets the rune value for the given uint64 key.

func (*ConMapUint64Rune) Set 

func (cm *ConMapUint64Rune) Set(k uint64, v rune)

Set sets the rune value for the specified uint64 key.

type ConMapUint64String 

type ConMapUint64String struct {
	// M is the underlying map[Uint64]String.
	M map[uint64]string
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint64String is a concurrent safe wrapper around a map[Uint64]String.

func NewConMapUint64String 

func NewConMapUint64String() *ConMapUint64String

NewConMapUint64String creates a new concurrent safe map storing string values, for uint64 keys.

func ToConMapUint64String 

func ToConMapUint64String(data map[uint64]string) *ConMapUint64String

ToConMapUint64String creates a new ConMapUint64String prepopulated with the data from the specified map[Uint64]String.

func (*ConMapUint64String) Delete 

func (cm *ConMapUint64String) Delete(k uint64) (string, bool)

Delete removes the specified uint64 key, returning its string value and a bool indicating whether the delete occurred or not.

func (*ConMapUint64String) Get 

func (cm *ConMapUint64String) Get(k uint64) string

Get gets the string value for the given uint64 key.

func (*ConMapUint64String) GetOK 

func (cm *ConMapUint64String) GetOK(k uint64) (string, bool)

GetOK gets the string value for the given uint64 key, and a bool indicating whether the key was present or not.

func (*ConMapUint64String) Len 

func (cm *ConMapUint64String) Len() int

Get gets the string value for the given uint64 key.

func (*ConMapUint64String) Set 

func (cm *ConMapUint64String) Set(k uint64, v string)

Set sets the string value for the specified uint64 key.

type ConMapUint64Uint 

type ConMapUint64Uint struct {
	// M is the underlying map[Uint64]Uint.
	M map[uint64]uint
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint64Uint is a concurrent safe wrapper around a map[Uint64]Uint.

func NewConMapUint64Uint 

func NewConMapUint64Uint() *ConMapUint64Uint

NewConMapUint64Uint creates a new concurrent safe map storing uint values, for uint64 keys.

func ToConMapUint64Uint 

func ToConMapUint64Uint(data map[uint64]uint) *ConMapUint64Uint

ToConMapUint64Uint creates a new ConMapUint64Uint prepopulated with the data from the specified map[Uint64]Uint.

func (*ConMapUint64Uint) Delete 

func (cm *ConMapUint64Uint) Delete(k uint64) (uint, bool)

Delete removes the specified uint64 key, returning its uint value and a bool indicating whether the delete occurred or not.

func (*ConMapUint64Uint) Get 

func (cm *ConMapUint64Uint) Get(k uint64) uint

Get gets the uint value for the given uint64 key.

func (*ConMapUint64Uint) GetOK 

func (cm *ConMapUint64Uint) GetOK(k uint64) (uint, bool)

GetOK gets the uint value for the given uint64 key, and a bool indicating whether the key was present or not.

func (*ConMapUint64Uint) Len 

func (cm *ConMapUint64Uint) Len() int

Get gets the uint value for the given uint64 key.

func (*ConMapUint64Uint) Set 

func (cm *ConMapUint64Uint) Set(k uint64, v uint)

Set sets the uint value for the specified uint64 key.

type ConMapUint64Uint16 

type ConMapUint64Uint16 struct {
	// M is the underlying map[Uint64]Uint16.
	M map[uint64]uint16
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint64Uint16 is a concurrent safe wrapper around a map[Uint64]Uint16.

func NewConMapUint64Uint16 

func NewConMapUint64Uint16() *ConMapUint64Uint16

NewConMapUint64Uint16 creates a new concurrent safe map storing uint16 values, for uint64 keys.

func ToConMapUint64Uint16 

func ToConMapUint64Uint16(data map[uint64]uint16) *ConMapUint64Uint16

ToConMapUint64Uint16 creates a new ConMapUint64Uint16 prepopulated with the data from the specified map[Uint64]Uint16.

func (*ConMapUint64Uint16) Delete 

func (cm *ConMapUint64Uint16) Delete(k uint64) (uint16, bool)

Delete removes the specified uint64 key, returning its uint16 value and a bool indicating whether the delete occurred or not.

func (*ConMapUint64Uint16) Get 

func (cm *ConMapUint64Uint16) Get(k uint64) uint16

Get gets the uint16 value for the given uint64 key.

func (*ConMapUint64Uint16) GetOK 

func (cm *ConMapUint64Uint16) GetOK(k uint64) (uint16, bool)

GetOK gets the uint16 value for the given uint64 key, and a bool indicating whether the key was present or not.

func (*ConMapUint64Uint16) Len 

func (cm *ConMapUint64Uint16) Len() int

Get gets the uint16 value for the given uint64 key.

func (*ConMapUint64Uint16) Set 

func (cm *ConMapUint64Uint16) Set(k uint64, v uint16)

Set sets the uint16 value for the specified uint64 key.

type ConMapUint64Uint32 

type ConMapUint64Uint32 struct {
	// M is the underlying map[Uint64]Uint32.
	M map[uint64]uint32
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint64Uint32 is a concurrent safe wrapper around a map[Uint64]Uint32.

func NewConMapUint64Uint32 

func NewConMapUint64Uint32() *ConMapUint64Uint32

NewConMapUint64Uint32 creates a new concurrent safe map storing uint32 values, for uint64 keys.

func ToConMapUint64Uint32 

func ToConMapUint64Uint32(data map[uint64]uint32) *ConMapUint64Uint32

ToConMapUint64Uint32 creates a new ConMapUint64Uint32 prepopulated with the data from the specified map[Uint64]Uint32.

func (*ConMapUint64Uint32) Delete 

func (cm *ConMapUint64Uint32) Delete(k uint64) (uint32, bool)

Delete removes the specified uint64 key, returning its uint32 value and a bool indicating whether the delete occurred or not.

func (*ConMapUint64Uint32) Get 

func (cm *ConMapUint64Uint32) Get(k uint64) uint32

Get gets the uint32 value for the given uint64 key.

func (*ConMapUint64Uint32) GetOK 

func (cm *ConMapUint64Uint32) GetOK(k uint64) (uint32, bool)

GetOK gets the uint32 value for the given uint64 key, and a bool indicating whether the key was present or not.

func (*ConMapUint64Uint32) Len 

func (cm *ConMapUint64Uint32) Len() int

Get gets the uint32 value for the given uint64 key.

func (*ConMapUint64Uint32) Set 

func (cm *ConMapUint64Uint32) Set(k uint64, v uint32)

Set sets the uint32 value for the specified uint64 key.

type ConMapUint64Uint64 

type ConMapUint64Uint64 struct {
	// M is the underlying map[Uint64]Uint64.
	M map[uint64]uint64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint64Uint64 is a concurrent safe wrapper around a map[Uint64]Uint64.

func NewConMapUint64Uint64 

func NewConMapUint64Uint64() *ConMapUint64Uint64

NewConMapUint64Uint64 creates a new concurrent safe map storing uint64 values, for uint64 keys.

func ToConMapUint64Uint64 

func ToConMapUint64Uint64(data map[uint64]uint64) *ConMapUint64Uint64

ToConMapUint64Uint64 creates a new ConMapUint64Uint64 prepopulated with the data from the specified map[Uint64]Uint64.

func (*ConMapUint64Uint64) Delete 

func (cm *ConMapUint64Uint64) Delete(k uint64) (uint64, bool)

Delete removes the specified uint64 key, returning its uint64 value and a bool indicating whether the delete occurred or not.

func (*ConMapUint64Uint64) Get 

func (cm *ConMapUint64Uint64) Get(k uint64) uint64

Get gets the uint64 value for the given uint64 key.

func (*ConMapUint64Uint64) GetOK 

func (cm *ConMapUint64Uint64) GetOK(k uint64) (uint64, bool)

GetOK gets the uint64 value for the given uint64 key, and a bool indicating whether the key was present or not.

func (*ConMapUint64Uint64) Len 

func (cm *ConMapUint64Uint64) Len() int

Get gets the uint64 value for the given uint64 key.

func (*ConMapUint64Uint64) Set 

func (cm *ConMapUint64Uint64) Set(k uint64, v uint64)

Set sets the uint64 value for the specified uint64 key.

type ConMapUint64Uint8 

type ConMapUint64Uint8 struct {
	// M is the underlying map[Uint64]Uint8.
	M map[uint64]uint8
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint64Uint8 is a concurrent safe wrapper around a map[Uint64]Uint8.

func NewConMapUint64Uint8 

func NewConMapUint64Uint8() *ConMapUint64Uint8

NewConMapUint64Uint8 creates a new concurrent safe map storing uint8 values, for uint64 keys.

func ToConMapUint64Uint8 

func ToConMapUint64Uint8(data map[uint64]uint8) *ConMapUint64Uint8

ToConMapUint64Uint8 creates a new ConMapUint64Uint8 prepopulated with the data from the specified map[Uint64]Uint8.

func (*ConMapUint64Uint8) Delete 

func (cm *ConMapUint64Uint8) Delete(k uint64) (uint8, bool)

Delete removes the specified uint64 key, returning its uint8 value and a bool indicating whether the delete occurred or not.

func (*ConMapUint64Uint8) Get 

func (cm *ConMapUint64Uint8) Get(k uint64) uint8

Get gets the uint8 value for the given uint64 key.

func (*ConMapUint64Uint8) GetOK 

func (cm *ConMapUint64Uint8) GetOK(k uint64) (uint8, bool)

GetOK gets the uint8 value for the given uint64 key, and a bool indicating whether the key was present or not.

func (*ConMapUint64Uint8) Len 

func (cm *ConMapUint64Uint8) Len() int

Get gets the uint8 value for the given uint64 key.

func (*ConMapUint64Uint8) Set 

func (cm *ConMapUint64Uint8) Set(k uint64, v uint8)

Set sets the uint8 value for the specified uint64 key.

type ConMapUint64Uintptr 

type ConMapUint64Uintptr struct {
	// M is the underlying map[Uint64]Uintptr.
	M map[uint64]uintptr
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint64Uintptr is a concurrent safe wrapper around a map[Uint64]Uintptr.

func NewConMapUint64Uintptr 

func NewConMapUint64Uintptr() *ConMapUint64Uintptr

NewConMapUint64Uintptr creates a new concurrent safe map storing uintptr values, for uint64 keys.

func ToConMapUint64Uintptr 

func ToConMapUint64Uintptr(data map[uint64]uintptr) *ConMapUint64Uintptr

ToConMapUint64Uintptr creates a new ConMapUint64Uintptr prepopulated with the data from the specified map[Uint64]Uintptr.

func (*ConMapUint64Uintptr) Delete 

func (cm *ConMapUint64Uintptr) Delete(k uint64) (uintptr, bool)

Delete removes the specified uint64 key, returning its uintptr value and a bool indicating whether the delete occurred or not.

func (*ConMapUint64Uintptr) Get 

func (cm *ConMapUint64Uintptr) Get(k uint64) uintptr

Get gets the uintptr value for the given uint64 key.

func (*ConMapUint64Uintptr) GetOK 

func (cm *ConMapUint64Uintptr) GetOK(k uint64) (uintptr, bool)

GetOK gets the uintptr value for the given uint64 key, and a bool indicating whether the key was present or not.

func (*ConMapUint64Uintptr) Len 

func (cm *ConMapUint64Uintptr) Len() int

Get gets the uintptr value for the given uint64 key.

func (*ConMapUint64Uintptr) Set 

func (cm *ConMapUint64Uintptr) Set(k uint64, v uintptr)

Set sets the uintptr value for the specified uint64 key.

type ConMapUint8Bool 

type ConMapUint8Bool struct {
	// M is the underlying map[Uint8]Bool.
	M map[uint8]bool
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint8Bool is a concurrent safe wrapper around a map[Uint8]Bool.

func NewConMapUint8Bool 

func NewConMapUint8Bool() *ConMapUint8Bool

NewConMapUint8Bool creates a new concurrent safe map storing bool values, for uint8 keys.

func ToConMapUint8Bool 

func ToConMapUint8Bool(data map[uint8]bool) *ConMapUint8Bool

ToConMapUint8Bool creates a new ConMapUint8Bool prepopulated with the data from the specified map[Uint8]Bool.

func (*ConMapUint8Bool) Delete 

func (cm *ConMapUint8Bool) Delete(k uint8) (bool, bool)

Delete removes the specified uint8 key, returning its bool value and a bool indicating whether the delete occurred or not.

func (*ConMapUint8Bool) Get 

func (cm *ConMapUint8Bool) Get(k uint8) bool

Get gets the bool value for the given uint8 key.

func (*ConMapUint8Bool) GetOK 

func (cm *ConMapUint8Bool) GetOK(k uint8) (bool, bool)

GetOK gets the bool value for the given uint8 key, and a bool indicating whether the key was present or not.

func (*ConMapUint8Bool) Len 

func (cm *ConMapUint8Bool) Len() int

Get gets the bool value for the given uint8 key.

func (*ConMapUint8Bool) Set 

func (cm *ConMapUint8Bool) Set(k uint8, v bool)

Set sets the bool value for the specified uint8 key.

type ConMapUint8Byte 

type ConMapUint8Byte struct {
	// M is the underlying map[Uint8]Byte.
	M map[uint8]byte
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint8Byte is a concurrent safe wrapper around a map[Uint8]Byte.

func NewConMapUint8Byte 

func NewConMapUint8Byte() *ConMapUint8Byte

NewConMapUint8Byte creates a new concurrent safe map storing byte values, for uint8 keys.

func ToConMapUint8Byte 

func ToConMapUint8Byte(data map[uint8]byte) *ConMapUint8Byte

ToConMapUint8Byte creates a new ConMapUint8Byte prepopulated with the data from the specified map[Uint8]Byte.

func (*ConMapUint8Byte) Delete 

func (cm *ConMapUint8Byte) Delete(k uint8) (byte, bool)

Delete removes the specified uint8 key, returning its byte value and a bool indicating whether the delete occurred or not.

func (*ConMapUint8Byte) Get 

func (cm *ConMapUint8Byte) Get(k uint8) byte

Get gets the byte value for the given uint8 key.

func (*ConMapUint8Byte) GetOK 

func (cm *ConMapUint8Byte) GetOK(k uint8) (byte, bool)

GetOK gets the byte value for the given uint8 key, and a bool indicating whether the key was present or not.

func (*ConMapUint8Byte) Len 

func (cm *ConMapUint8Byte) Len() int

Get gets the byte value for the given uint8 key.

func (*ConMapUint8Byte) Set 

func (cm *ConMapUint8Byte) Set(k uint8, v byte)

Set sets the byte value for the specified uint8 key.

type ConMapUint8Complex128 

type ConMapUint8Complex128 struct {
	// M is the underlying map[Uint8]Complex128.
	M map[uint8]complex128
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint8Complex128 is a concurrent safe wrapper around a map[Uint8]Complex128.

func NewConMapUint8Complex128 

func NewConMapUint8Complex128() *ConMapUint8Complex128

NewConMapUint8Complex128 creates a new concurrent safe map storing complex128 values, for uint8 keys.

func ToConMapUint8Complex128 

func ToConMapUint8Complex128(data map[uint8]complex128) *ConMapUint8Complex128

ToConMapUint8Complex128 creates a new ConMapUint8Complex128 prepopulated with the data from the specified map[Uint8]Complex128.

func (*ConMapUint8Complex128) Delete 

func (cm *ConMapUint8Complex128) Delete(k uint8) (complex128, bool)

Delete removes the specified uint8 key, returning its complex128 value and a bool indicating whether the delete occurred or not.

func (*ConMapUint8Complex128) Get 

func (cm *ConMapUint8Complex128) Get(k uint8) complex128

Get gets the complex128 value for the given uint8 key.

func (*ConMapUint8Complex128) GetOK 

func (cm *ConMapUint8Complex128) GetOK(k uint8) (complex128, bool)

GetOK gets the complex128 value for the given uint8 key, and a bool indicating whether the key was present or not.

func (*ConMapUint8Complex128) Len 

func (cm *ConMapUint8Complex128) Len() int

Get gets the complex128 value for the given uint8 key.

func (*ConMapUint8Complex128) Set 

func (cm *ConMapUint8Complex128) Set(k uint8, v complex128)

Set sets the complex128 value for the specified uint8 key.

type ConMapUint8Complex64 

type ConMapUint8Complex64 struct {
	// M is the underlying map[Uint8]Complex64.
	M map[uint8]complex64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint8Complex64 is a concurrent safe wrapper around a map[Uint8]Complex64.

func NewConMapUint8Complex64 

func NewConMapUint8Complex64() *ConMapUint8Complex64

NewConMapUint8Complex64 creates a new concurrent safe map storing complex64 values, for uint8 keys.

func ToConMapUint8Complex64 

func ToConMapUint8Complex64(data map[uint8]complex64) *ConMapUint8Complex64

ToConMapUint8Complex64 creates a new ConMapUint8Complex64 prepopulated with the data from the specified map[Uint8]Complex64.

func (*ConMapUint8Complex64) Delete 

func (cm *ConMapUint8Complex64) Delete(k uint8) (complex64, bool)

Delete removes the specified uint8 key, returning its complex64 value and a bool indicating whether the delete occurred or not.

func (*ConMapUint8Complex64) Get 

func (cm *ConMapUint8Complex64) Get(k uint8) complex64

Get gets the complex64 value for the given uint8 key.

func (*ConMapUint8Complex64) GetOK 

func (cm *ConMapUint8Complex64) GetOK(k uint8) (complex64, bool)

GetOK gets the complex64 value for the given uint8 key, and a bool indicating whether the key was present or not.

func (*ConMapUint8Complex64) Len 

func (cm *ConMapUint8Complex64) Len() int

Get gets the complex64 value for the given uint8 key.

func (*ConMapUint8Complex64) Set 

func (cm *ConMapUint8Complex64) Set(k uint8, v complex64)

Set sets the complex64 value for the specified uint8 key.

type ConMapUint8Error 

type ConMapUint8Error struct {
	// M is the underlying map[Uint8]Error.
	M map[uint8]error
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint8Error is a concurrent safe wrapper around a map[Uint8]Error.

func NewConMapUint8Error 

func NewConMapUint8Error() *ConMapUint8Error

NewConMapUint8Error creates a new concurrent safe map storing error values, for uint8 keys.

func ToConMapUint8Error 

func ToConMapUint8Error(data map[uint8]error) *ConMapUint8Error

ToConMapUint8Error creates a new ConMapUint8Error prepopulated with the data from the specified map[Uint8]Error.

func (*ConMapUint8Error) Delete 

func (cm *ConMapUint8Error) Delete(k uint8) (error, bool)

Delete removes the specified uint8 key, returning its error value and a bool indicating whether the delete occurred or not.

func (*ConMapUint8Error) Get 

func (cm *ConMapUint8Error) Get(k uint8) error

Get gets the error value for the given uint8 key.

func (*ConMapUint8Error) GetOK 

func (cm *ConMapUint8Error) GetOK(k uint8) (error, bool)

GetOK gets the error value for the given uint8 key, and a bool indicating whether the key was present or not.

func (*ConMapUint8Error) Len 

func (cm *ConMapUint8Error) Len() int

Get gets the error value for the given uint8 key.

func (*ConMapUint8Error) Set 

func (cm *ConMapUint8Error) Set(k uint8, v error)

Set sets the error value for the specified uint8 key.

type ConMapUint8Float32 

type ConMapUint8Float32 struct {
	// M is the underlying map[Uint8]Float32.
	M map[uint8]float32
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint8Float32 is a concurrent safe wrapper around a map[Uint8]Float32.

func NewConMapUint8Float32 

func NewConMapUint8Float32() *ConMapUint8Float32

NewConMapUint8Float32 creates a new concurrent safe map storing float32 values, for uint8 keys.

func ToConMapUint8Float32 

func ToConMapUint8Float32(data map[uint8]float32) *ConMapUint8Float32

ToConMapUint8Float32 creates a new ConMapUint8Float32 prepopulated with the data from the specified map[Uint8]Float32.

func (*ConMapUint8Float32) Delete 

func (cm *ConMapUint8Float32) Delete(k uint8) (float32, bool)

Delete removes the specified uint8 key, returning its float32 value and a bool indicating whether the delete occurred or not.

func (*ConMapUint8Float32) Get 

func (cm *ConMapUint8Float32) Get(k uint8) float32

Get gets the float32 value for the given uint8 key.

func (*ConMapUint8Float32) GetOK 

func (cm *ConMapUint8Float32) GetOK(k uint8) (float32, bool)

GetOK gets the float32 value for the given uint8 key, and a bool indicating whether the key was present or not.

func (*ConMapUint8Float32) Len 

func (cm *ConMapUint8Float32) Len() int

Get gets the float32 value for the given uint8 key.

func (*ConMapUint8Float32) Set 

func (cm *ConMapUint8Float32) Set(k uint8, v float32)

Set sets the float32 value for the specified uint8 key.

type ConMapUint8Float64 

type ConMapUint8Float64 struct {
	// M is the underlying map[Uint8]Float64.
	M map[uint8]float64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint8Float64 is a concurrent safe wrapper around a map[Uint8]Float64.

func NewConMapUint8Float64 

func NewConMapUint8Float64() *ConMapUint8Float64

NewConMapUint8Float64 creates a new concurrent safe map storing float64 values, for uint8 keys.

func ToConMapUint8Float64 

func ToConMapUint8Float64(data map[uint8]float64) *ConMapUint8Float64

ToConMapUint8Float64 creates a new ConMapUint8Float64 prepopulated with the data from the specified map[Uint8]Float64.

func (*ConMapUint8Float64) Delete 

func (cm *ConMapUint8Float64) Delete(k uint8) (float64, bool)

Delete removes the specified uint8 key, returning its float64 value and a bool indicating whether the delete occurred or not.

func (*ConMapUint8Float64) Get 

func (cm *ConMapUint8Float64) Get(k uint8) float64

Get gets the float64 value for the given uint8 key.

func (*ConMapUint8Float64) GetOK 

func (cm *ConMapUint8Float64) GetOK(k uint8) (float64, bool)

GetOK gets the float64 value for the given uint8 key, and a bool indicating whether the key was present or not.

func (*ConMapUint8Float64) Len 

func (cm *ConMapUint8Float64) Len() int

Get gets the float64 value for the given uint8 key.

func (*ConMapUint8Float64) Set 

func (cm *ConMapUint8Float64) Set(k uint8, v float64)

Set sets the float64 value for the specified uint8 key.

type ConMapUint8Int 

type ConMapUint8Int struct {
	// M is the underlying map[Uint8]Int.
	M map[uint8]int
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint8Int is a concurrent safe wrapper around a map[Uint8]Int.

func NewConMapUint8Int 

func NewConMapUint8Int() *ConMapUint8Int

NewConMapUint8Int creates a new concurrent safe map storing int values, for uint8 keys.

func ToConMapUint8Int 

func ToConMapUint8Int(data map[uint8]int) *ConMapUint8Int

ToConMapUint8Int creates a new ConMapUint8Int prepopulated with the data from the specified map[Uint8]Int.

func (*ConMapUint8Int) Delete 

func (cm *ConMapUint8Int) Delete(k uint8) (int, bool)

Delete removes the specified uint8 key, returning its int value and a bool indicating whether the delete occurred or not.

func (*ConMapUint8Int) Get 

func (cm *ConMapUint8Int) Get(k uint8) int

Get gets the int value for the given uint8 key.

func (*ConMapUint8Int) GetOK 

func (cm *ConMapUint8Int) GetOK(k uint8) (int, bool)

GetOK gets the int value for the given uint8 key, and a bool indicating whether the key was present or not.

func (*ConMapUint8Int) Len 

func (cm *ConMapUint8Int) Len() int

Get gets the int value for the given uint8 key.

func (*ConMapUint8Int) Set 

func (cm *ConMapUint8Int) Set(k uint8, v int)

Set sets the int value for the specified uint8 key.

type ConMapUint8Int16 

type ConMapUint8Int16 struct {
	// M is the underlying map[Uint8]Int16.
	M map[uint8]int16
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint8Int16 is a concurrent safe wrapper around a map[Uint8]Int16.

func NewConMapUint8Int16 

func NewConMapUint8Int16() *ConMapUint8Int16

NewConMapUint8Int16 creates a new concurrent safe map storing int16 values, for uint8 keys.

func ToConMapUint8Int16 

func ToConMapUint8Int16(data map[uint8]int16) *ConMapUint8Int16

ToConMapUint8Int16 creates a new ConMapUint8Int16 prepopulated with the data from the specified map[Uint8]Int16.

func (*ConMapUint8Int16) Delete 

func (cm *ConMapUint8Int16) Delete(k uint8) (int16, bool)

Delete removes the specified uint8 key, returning its int16 value and a bool indicating whether the delete occurred or not.

func (*ConMapUint8Int16) Get 

func (cm *ConMapUint8Int16) Get(k uint8) int16

Get gets the int16 value for the given uint8 key.

func (*ConMapUint8Int16) GetOK 

func (cm *ConMapUint8Int16) GetOK(k uint8) (int16, bool)

GetOK gets the int16 value for the given uint8 key, and a bool indicating whether the key was present or not.

func (*ConMapUint8Int16) Len 

func (cm *ConMapUint8Int16) Len() int

Get gets the int16 value for the given uint8 key.

func (*ConMapUint8Int16) Set 

func (cm *ConMapUint8Int16) Set(k uint8, v int16)

Set sets the int16 value for the specified uint8 key.

type ConMapUint8Int32 

type ConMapUint8Int32 struct {
	// M is the underlying map[Uint8]Int32.
	M map[uint8]int32
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint8Int32 is a concurrent safe wrapper around a map[Uint8]Int32.

func NewConMapUint8Int32 

func NewConMapUint8Int32() *ConMapUint8Int32

NewConMapUint8Int32 creates a new concurrent safe map storing int32 values, for uint8 keys.

func ToConMapUint8Int32 

func ToConMapUint8Int32(data map[uint8]int32) *ConMapUint8Int32

ToConMapUint8Int32 creates a new ConMapUint8Int32 prepopulated with the data from the specified map[Uint8]Int32.

func (*ConMapUint8Int32) Delete 

func (cm *ConMapUint8Int32) Delete(k uint8) (int32, bool)

Delete removes the specified uint8 key, returning its int32 value and a bool indicating whether the delete occurred or not.

func (*ConMapUint8Int32) Get 

func (cm *ConMapUint8Int32) Get(k uint8) int32

Get gets the int32 value for the given uint8 key.

func (*ConMapUint8Int32) GetOK 

func (cm *ConMapUint8Int32) GetOK(k uint8) (int32, bool)

GetOK gets the int32 value for the given uint8 key, and a bool indicating whether the key was present or not.

func (*ConMapUint8Int32) Len 

func (cm *ConMapUint8Int32) Len() int

Get gets the int32 value for the given uint8 key.

func (*ConMapUint8Int32) Set 

func (cm *ConMapUint8Int32) Set(k uint8, v int32)

Set sets the int32 value for the specified uint8 key.

type ConMapUint8Int64 

type ConMapUint8Int64 struct {
	// M is the underlying map[Uint8]Int64.
	M map[uint8]int64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint8Int64 is a concurrent safe wrapper around a map[Uint8]Int64.

func NewConMapUint8Int64 

func NewConMapUint8Int64() *ConMapUint8Int64

NewConMapUint8Int64 creates a new concurrent safe map storing int64 values, for uint8 keys.

func ToConMapUint8Int64 

func ToConMapUint8Int64(data map[uint8]int64) *ConMapUint8Int64

ToConMapUint8Int64 creates a new ConMapUint8Int64 prepopulated with the data from the specified map[Uint8]Int64.

func (*ConMapUint8Int64) Delete 

func (cm *ConMapUint8Int64) Delete(k uint8) (int64, bool)

Delete removes the specified uint8 key, returning its int64 value and a bool indicating whether the delete occurred or not.

func (*ConMapUint8Int64) Get 

func (cm *ConMapUint8Int64) Get(k uint8) int64

Get gets the int64 value for the given uint8 key.

func (*ConMapUint8Int64) GetOK 

func (cm *ConMapUint8Int64) GetOK(k uint8) (int64, bool)

GetOK gets the int64 value for the given uint8 key, and a bool indicating whether the key was present or not.

func (*ConMapUint8Int64) Len 

func (cm *ConMapUint8Int64) Len() int

Get gets the int64 value for the given uint8 key.

func (*ConMapUint8Int64) Set 

func (cm *ConMapUint8Int64) Set(k uint8, v int64)

Set sets the int64 value for the specified uint8 key.

type ConMapUint8Int8 

type ConMapUint8Int8 struct {
	// M is the underlying map[Uint8]Int8.
	M map[uint8]int8
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint8Int8 is a concurrent safe wrapper around a map[Uint8]Int8.

func NewConMapUint8Int8 

func NewConMapUint8Int8() *ConMapUint8Int8

NewConMapUint8Int8 creates a new concurrent safe map storing int8 values, for uint8 keys.

func ToConMapUint8Int8 

func ToConMapUint8Int8(data map[uint8]int8) *ConMapUint8Int8

ToConMapUint8Int8 creates a new ConMapUint8Int8 prepopulated with the data from the specified map[Uint8]Int8.

func (*ConMapUint8Int8) Delete 

func (cm *ConMapUint8Int8) Delete(k uint8) (int8, bool)

Delete removes the specified uint8 key, returning its int8 value and a bool indicating whether the delete occurred or not.

func (*ConMapUint8Int8) Get 

func (cm *ConMapUint8Int8) Get(k uint8) int8

Get gets the int8 value for the given uint8 key.

func (*ConMapUint8Int8) GetOK 

func (cm *ConMapUint8Int8) GetOK(k uint8) (int8, bool)

GetOK gets the int8 value for the given uint8 key, and a bool indicating whether the key was present or not.

func (*ConMapUint8Int8) Len 

func (cm *ConMapUint8Int8) Len() int

Get gets the int8 value for the given uint8 key.

func (*ConMapUint8Int8) Set 

func (cm *ConMapUint8Int8) Set(k uint8, v int8)

Set sets the int8 value for the specified uint8 key.

type ConMapUint8Rune 

type ConMapUint8Rune struct {
	// M is the underlying map[Uint8]Rune.
	M map[uint8]rune
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint8Rune is a concurrent safe wrapper around a map[Uint8]Rune.

func NewConMapUint8Rune 

func NewConMapUint8Rune() *ConMapUint8Rune

NewConMapUint8Rune creates a new concurrent safe map storing rune values, for uint8 keys.

func ToConMapUint8Rune 

func ToConMapUint8Rune(data map[uint8]rune) *ConMapUint8Rune

ToConMapUint8Rune creates a new ConMapUint8Rune prepopulated with the data from the specified map[Uint8]Rune.

func (*ConMapUint8Rune) Delete 

func (cm *ConMapUint8Rune) Delete(k uint8) (rune, bool)

Delete removes the specified uint8 key, returning its rune value and a bool indicating whether the delete occurred or not.

func (*ConMapUint8Rune) Get 

func (cm *ConMapUint8Rune) Get(k uint8) rune

Get gets the rune value for the given uint8 key.

func (*ConMapUint8Rune) GetOK 

func (cm *ConMapUint8Rune) GetOK(k uint8) (rune, bool)

GetOK gets the rune value for the given uint8 key, and a bool indicating whether the key was present or not.

func (*ConMapUint8Rune) Len 

func (cm *ConMapUint8Rune) Len() int

Get gets the rune value for the given uint8 key.

func (*ConMapUint8Rune) Set 

func (cm *ConMapUint8Rune) Set(k uint8, v rune)

Set sets the rune value for the specified uint8 key.

type ConMapUint8String 

type ConMapUint8String struct {
	// M is the underlying map[Uint8]String.
	M map[uint8]string
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint8String is a concurrent safe wrapper around a map[Uint8]String.

func NewConMapUint8String 

func NewConMapUint8String() *ConMapUint8String

NewConMapUint8String creates a new concurrent safe map storing string values, for uint8 keys.

func ToConMapUint8String 

func ToConMapUint8String(data map[uint8]string) *ConMapUint8String

ToConMapUint8String creates a new ConMapUint8String prepopulated with the data from the specified map[Uint8]String.

func (*ConMapUint8String) Delete 

func (cm *ConMapUint8String) Delete(k uint8) (string, bool)

Delete removes the specified uint8 key, returning its string value and a bool indicating whether the delete occurred or not.

func (*ConMapUint8String) Get 

func (cm *ConMapUint8String) Get(k uint8) string

Get gets the string value for the given uint8 key.

func (*ConMapUint8String) GetOK 

func (cm *ConMapUint8String) GetOK(k uint8) (string, bool)

GetOK gets the string value for the given uint8 key, and a bool indicating whether the key was present or not.

func (*ConMapUint8String) Len 

func (cm *ConMapUint8String) Len() int

Get gets the string value for the given uint8 key.

func (*ConMapUint8String) Set 

func (cm *ConMapUint8String) Set(k uint8, v string)

Set sets the string value for the specified uint8 key.

type ConMapUint8Uint 

type ConMapUint8Uint struct {
	// M is the underlying map[Uint8]Uint.
	M map[uint8]uint
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint8Uint is a concurrent safe wrapper around a map[Uint8]Uint.

func NewConMapUint8Uint 

func NewConMapUint8Uint() *ConMapUint8Uint

NewConMapUint8Uint creates a new concurrent safe map storing uint values, for uint8 keys.

func ToConMapUint8Uint 

func ToConMapUint8Uint(data map[uint8]uint) *ConMapUint8Uint

ToConMapUint8Uint creates a new ConMapUint8Uint prepopulated with the data from the specified map[Uint8]Uint.

func (*ConMapUint8Uint) Delete 

func (cm *ConMapUint8Uint) Delete(k uint8) (uint, bool)

Delete removes the specified uint8 key, returning its uint value and a bool indicating whether the delete occurred or not.

func (*ConMapUint8Uint) Get 

func (cm *ConMapUint8Uint) Get(k uint8) uint

Get gets the uint value for the given uint8 key.

func (*ConMapUint8Uint) GetOK 

func (cm *ConMapUint8Uint) GetOK(k uint8) (uint, bool)

GetOK gets the uint value for the given uint8 key, and a bool indicating whether the key was present or not.

func (*ConMapUint8Uint) Len 

func (cm *ConMapUint8Uint) Len() int

Get gets the uint value for the given uint8 key.

func (*ConMapUint8Uint) Set 

func (cm *ConMapUint8Uint) Set(k uint8, v uint)

Set sets the uint value for the specified uint8 key.

type ConMapUint8Uint16 

type ConMapUint8Uint16 struct {
	// M is the underlying map[Uint8]Uint16.
	M map[uint8]uint16
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint8Uint16 is a concurrent safe wrapper around a map[Uint8]Uint16.

func NewConMapUint8Uint16 

func NewConMapUint8Uint16() *ConMapUint8Uint16

NewConMapUint8Uint16 creates a new concurrent safe map storing uint16 values, for uint8 keys.

func ToConMapUint8Uint16 

func ToConMapUint8Uint16(data map[uint8]uint16) *ConMapUint8Uint16

ToConMapUint8Uint16 creates a new ConMapUint8Uint16 prepopulated with the data from the specified map[Uint8]Uint16.

func (*ConMapUint8Uint16) Delete 

func (cm *ConMapUint8Uint16) Delete(k uint8) (uint16, bool)

Delete removes the specified uint8 key, returning its uint16 value and a bool indicating whether the delete occurred or not.

func (*ConMapUint8Uint16) Get 

func (cm *ConMapUint8Uint16) Get(k uint8) uint16

Get gets the uint16 value for the given uint8 key.

func (*ConMapUint8Uint16) GetOK 

func (cm *ConMapUint8Uint16) GetOK(k uint8) (uint16, bool)

GetOK gets the uint16 value for the given uint8 key, and a bool indicating whether the key was present or not.

func (*ConMapUint8Uint16) Len 

func (cm *ConMapUint8Uint16) Len() int

Get gets the uint16 value for the given uint8 key.

func (*ConMapUint8Uint16) Set 

func (cm *ConMapUint8Uint16) Set(k uint8, v uint16)

Set sets the uint16 value for the specified uint8 key.

type ConMapUint8Uint32 

type ConMapUint8Uint32 struct {
	// M is the underlying map[Uint8]Uint32.
	M map[uint8]uint32
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint8Uint32 is a concurrent safe wrapper around a map[Uint8]Uint32.

func NewConMapUint8Uint32 

func NewConMapUint8Uint32() *ConMapUint8Uint32

NewConMapUint8Uint32 creates a new concurrent safe map storing uint32 values, for uint8 keys.

func ToConMapUint8Uint32 

func ToConMapUint8Uint32(data map[uint8]uint32) *ConMapUint8Uint32

ToConMapUint8Uint32 creates a new ConMapUint8Uint32 prepopulated with the data from the specified map[Uint8]Uint32.

func (*ConMapUint8Uint32) Delete 

func (cm *ConMapUint8Uint32) Delete(k uint8) (uint32, bool)

Delete removes the specified uint8 key, returning its uint32 value and a bool indicating whether the delete occurred or not.

func (*ConMapUint8Uint32) Get 

func (cm *ConMapUint8Uint32) Get(k uint8) uint32

Get gets the uint32 value for the given uint8 key.

func (*ConMapUint8Uint32) GetOK 

func (cm *ConMapUint8Uint32) GetOK(k uint8) (uint32, bool)

GetOK gets the uint32 value for the given uint8 key, and a bool indicating whether the key was present or not.

func (*ConMapUint8Uint32) Len 

func (cm *ConMapUint8Uint32) Len() int

Get gets the uint32 value for the given uint8 key.

func (*ConMapUint8Uint32) Set 

func (cm *ConMapUint8Uint32) Set(k uint8, v uint32)

Set sets the uint32 value for the specified uint8 key.

type ConMapUint8Uint64 

type ConMapUint8Uint64 struct {
	// M is the underlying map[Uint8]Uint64.
	M map[uint8]uint64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint8Uint64 is a concurrent safe wrapper around a map[Uint8]Uint64.

func NewConMapUint8Uint64 

func NewConMapUint8Uint64() *ConMapUint8Uint64

NewConMapUint8Uint64 creates a new concurrent safe map storing uint64 values, for uint8 keys.

func ToConMapUint8Uint64 

func ToConMapUint8Uint64(data map[uint8]uint64) *ConMapUint8Uint64

ToConMapUint8Uint64 creates a new ConMapUint8Uint64 prepopulated with the data from the specified map[Uint8]Uint64.

func (*ConMapUint8Uint64) Delete 

func (cm *ConMapUint8Uint64) Delete(k uint8) (uint64, bool)

Delete removes the specified uint8 key, returning its uint64 value and a bool indicating whether the delete occurred or not.

func (*ConMapUint8Uint64) Get 

func (cm *ConMapUint8Uint64) Get(k uint8) uint64

Get gets the uint64 value for the given uint8 key.

func (*ConMapUint8Uint64) GetOK 

func (cm *ConMapUint8Uint64) GetOK(k uint8) (uint64, bool)

GetOK gets the uint64 value for the given uint8 key, and a bool indicating whether the key was present or not.

func (*ConMapUint8Uint64) Len 

func (cm *ConMapUint8Uint64) Len() int

Get gets the uint64 value for the given uint8 key.

func (*ConMapUint8Uint64) Set 

func (cm *ConMapUint8Uint64) Set(k uint8, v uint64)

Set sets the uint64 value for the specified uint8 key.

type ConMapUint8Uint8 

type ConMapUint8Uint8 struct {
	// M is the underlying map[Uint8]Uint8.
	M map[uint8]uint8
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint8Uint8 is a concurrent safe wrapper around a map[Uint8]Uint8.

func NewConMapUint8Uint8 

func NewConMapUint8Uint8() *ConMapUint8Uint8

NewConMapUint8Uint8 creates a new concurrent safe map storing uint8 values, for uint8 keys.

func ToConMapUint8Uint8 

func ToConMapUint8Uint8(data map[uint8]uint8) *ConMapUint8Uint8

ToConMapUint8Uint8 creates a new ConMapUint8Uint8 prepopulated with the data from the specified map[Uint8]Uint8.

func (*ConMapUint8Uint8) Delete 

func (cm *ConMapUint8Uint8) Delete(k uint8) (uint8, bool)

Delete removes the specified uint8 key, returning its uint8 value and a bool indicating whether the delete occurred or not.

func (*ConMapUint8Uint8) Get 

func (cm *ConMapUint8Uint8) Get(k uint8) uint8

Get gets the uint8 value for the given uint8 key.

func (*ConMapUint8Uint8) GetOK 

func (cm *ConMapUint8Uint8) GetOK(k uint8) (uint8, bool)

GetOK gets the uint8 value for the given uint8 key, and a bool indicating whether the key was present or not.

func (*ConMapUint8Uint8) Len 

func (cm *ConMapUint8Uint8) Len() int

Get gets the uint8 value for the given uint8 key.

func (*ConMapUint8Uint8) Set 

func (cm *ConMapUint8Uint8) Set(k uint8, v uint8)

Set sets the uint8 value for the specified uint8 key.

type ConMapUint8Uintptr 

type ConMapUint8Uintptr struct {
	// M is the underlying map[Uint8]Uintptr.
	M map[uint8]uintptr
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUint8Uintptr is a concurrent safe wrapper around a map[Uint8]Uintptr.

func NewConMapUint8Uintptr 

func NewConMapUint8Uintptr() *ConMapUint8Uintptr

NewConMapUint8Uintptr creates a new concurrent safe map storing uintptr values, for uint8 keys.

func ToConMapUint8Uintptr 

func ToConMapUint8Uintptr(data map[uint8]uintptr) *ConMapUint8Uintptr

ToConMapUint8Uintptr creates a new ConMapUint8Uintptr prepopulated with the data from the specified map[Uint8]Uintptr.

func (*ConMapUint8Uintptr) Delete 

func (cm *ConMapUint8Uintptr) Delete(k uint8) (uintptr, bool)

Delete removes the specified uint8 key, returning its uintptr value and a bool indicating whether the delete occurred or not.

func (*ConMapUint8Uintptr) Get 

func (cm *ConMapUint8Uintptr) Get(k uint8) uintptr

Get gets the uintptr value for the given uint8 key.

func (*ConMapUint8Uintptr) GetOK 

func (cm *ConMapUint8Uintptr) GetOK(k uint8) (uintptr, bool)

GetOK gets the uintptr value for the given uint8 key, and a bool indicating whether the key was present or not.

func (*ConMapUint8Uintptr) Len 

func (cm *ConMapUint8Uintptr) Len() int

Get gets the uintptr value for the given uint8 key.

func (*ConMapUint8Uintptr) Set 

func (cm *ConMapUint8Uintptr) Set(k uint8, v uintptr)

Set sets the uintptr value for the specified uint8 key.

type ConMapUintBool 

type ConMapUintBool struct {
	// M is the underlying map[Uint]Bool.
	M map[uint]bool
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUintBool is a concurrent safe wrapper around a map[Uint]Bool.

func NewConMapUintBool 

func NewConMapUintBool() *ConMapUintBool

NewConMapUintBool creates a new concurrent safe map storing bool values, for uint keys.

func ToConMapUintBool 

func ToConMapUintBool(data map[uint]bool) *ConMapUintBool

ToConMapUintBool creates a new ConMapUintBool prepopulated with the data from the specified map[Uint]Bool.

func (*ConMapUintBool) Delete 

func (cm *ConMapUintBool) Delete(k uint) (bool, bool)

Delete removes the specified uint key, returning its bool value and a bool indicating whether the delete occurred or not.

func (*ConMapUintBool) Get 

func (cm *ConMapUintBool) Get(k uint) bool

Get gets the bool value for the given uint key.

func (*ConMapUintBool) GetOK 

func (cm *ConMapUintBool) GetOK(k uint) (bool, bool)

GetOK gets the bool value for the given uint key, and a bool indicating whether the key was present or not.

func (*ConMapUintBool) Len 

func (cm *ConMapUintBool) Len() int

Get gets the bool value for the given uint key.

func (*ConMapUintBool) Set 

func (cm *ConMapUintBool) Set(k uint, v bool)

Set sets the bool value for the specified uint key.

type ConMapUintByte 

type ConMapUintByte struct {
	// M is the underlying map[Uint]Byte.
	M map[uint]byte
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUintByte is a concurrent safe wrapper around a map[Uint]Byte.

func NewConMapUintByte 

func NewConMapUintByte() *ConMapUintByte

NewConMapUintByte creates a new concurrent safe map storing byte values, for uint keys.

func ToConMapUintByte 

func ToConMapUintByte(data map[uint]byte) *ConMapUintByte

ToConMapUintByte creates a new ConMapUintByte prepopulated with the data from the specified map[Uint]Byte.

func (*ConMapUintByte) Delete 

func (cm *ConMapUintByte) Delete(k uint) (byte, bool)

Delete removes the specified uint key, returning its byte value and a bool indicating whether the delete occurred or not.

func (*ConMapUintByte) Get 

func (cm *ConMapUintByte) Get(k uint) byte

Get gets the byte value for the given uint key.

func (*ConMapUintByte) GetOK 

func (cm *ConMapUintByte) GetOK(k uint) (byte, bool)

GetOK gets the byte value for the given uint key, and a bool indicating whether the key was present or not.

func (*ConMapUintByte) Len 

func (cm *ConMapUintByte) Len() int

Get gets the byte value for the given uint key.

func (*ConMapUintByte) Set 

func (cm *ConMapUintByte) Set(k uint, v byte)

Set sets the byte value for the specified uint key.

type ConMapUintComplex128 

type ConMapUintComplex128 struct {
	// M is the underlying map[Uint]Complex128.
	M map[uint]complex128
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUintComplex128 is a concurrent safe wrapper around a map[Uint]Complex128.

func NewConMapUintComplex128 

func NewConMapUintComplex128() *ConMapUintComplex128

NewConMapUintComplex128 creates a new concurrent safe map storing complex128 values, for uint keys.

func ToConMapUintComplex128 

func ToConMapUintComplex128(data map[uint]complex128) *ConMapUintComplex128

ToConMapUintComplex128 creates a new ConMapUintComplex128 prepopulated with the data from the specified map[Uint]Complex128.

func (*ConMapUintComplex128) Delete 

func (cm *ConMapUintComplex128) Delete(k uint) (complex128, bool)

Delete removes the specified uint key, returning its complex128 value and a bool indicating whether the delete occurred or not.

func (*ConMapUintComplex128) Get 

func (cm *ConMapUintComplex128) Get(k uint) complex128

Get gets the complex128 value for the given uint key.

func (*ConMapUintComplex128) GetOK 

func (cm *ConMapUintComplex128) GetOK(k uint) (complex128, bool)

GetOK gets the complex128 value for the given uint key, and a bool indicating whether the key was present or not.

func (*ConMapUintComplex128) Len 

func (cm *ConMapUintComplex128) Len() int

Get gets the complex128 value for the given uint key.

func (*ConMapUintComplex128) Set 

func (cm *ConMapUintComplex128) Set(k uint, v complex128)

Set sets the complex128 value for the specified uint key.

type ConMapUintComplex64 

type ConMapUintComplex64 struct {
	// M is the underlying map[Uint]Complex64.
	M map[uint]complex64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUintComplex64 is a concurrent safe wrapper around a map[Uint]Complex64.

func NewConMapUintComplex64 

func NewConMapUintComplex64() *ConMapUintComplex64

NewConMapUintComplex64 creates a new concurrent safe map storing complex64 values, for uint keys.

func ToConMapUintComplex64 

func ToConMapUintComplex64(data map[uint]complex64) *ConMapUintComplex64

ToConMapUintComplex64 creates a new ConMapUintComplex64 prepopulated with the data from the specified map[Uint]Complex64.

func (*ConMapUintComplex64) Delete 

func (cm *ConMapUintComplex64) Delete(k uint) (complex64, bool)

Delete removes the specified uint key, returning its complex64 value and a bool indicating whether the delete occurred or not.

func (*ConMapUintComplex64) Get 

func (cm *ConMapUintComplex64) Get(k uint) complex64

Get gets the complex64 value for the given uint key.

func (*ConMapUintComplex64) GetOK 

func (cm *ConMapUintComplex64) GetOK(k uint) (complex64, bool)

GetOK gets the complex64 value for the given uint key, and a bool indicating whether the key was present or not.

func (*ConMapUintComplex64) Len 

func (cm *ConMapUintComplex64) Len() int

Get gets the complex64 value for the given uint key.

func (*ConMapUintComplex64) Set 

func (cm *ConMapUintComplex64) Set(k uint, v complex64)

Set sets the complex64 value for the specified uint key.

type ConMapUintError 

type ConMapUintError struct {
	// M is the underlying map[Uint]Error.
	M map[uint]error
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUintError is a concurrent safe wrapper around a map[Uint]Error.

func NewConMapUintError 

func NewConMapUintError() *ConMapUintError

NewConMapUintError creates a new concurrent safe map storing error values, for uint keys.

func ToConMapUintError 

func ToConMapUintError(data map[uint]error) *ConMapUintError

ToConMapUintError creates a new ConMapUintError prepopulated with the data from the specified map[Uint]Error.

func (*ConMapUintError) Delete 

func (cm *ConMapUintError) Delete(k uint) (error, bool)

Delete removes the specified uint key, returning its error value and a bool indicating whether the delete occurred or not.

func (*ConMapUintError) Get 

func (cm *ConMapUintError) Get(k uint) error

Get gets the error value for the given uint key.

func (*ConMapUintError) GetOK 

func (cm *ConMapUintError) GetOK(k uint) (error, bool)

GetOK gets the error value for the given uint key, and a bool indicating whether the key was present or not.

func (*ConMapUintError) Len 

func (cm *ConMapUintError) Len() int

Get gets the error value for the given uint key.

func (*ConMapUintError) Set 

func (cm *ConMapUintError) Set(k uint, v error)

Set sets the error value for the specified uint key.

type ConMapUintFloat32 

type ConMapUintFloat32 struct {
	// M is the underlying map[Uint]Float32.
	M map[uint]float32
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUintFloat32 is a concurrent safe wrapper around a map[Uint]Float32.

func NewConMapUintFloat32 

func NewConMapUintFloat32() *ConMapUintFloat32

NewConMapUintFloat32 creates a new concurrent safe map storing float32 values, for uint keys.

func ToConMapUintFloat32 

func ToConMapUintFloat32(data map[uint]float32) *ConMapUintFloat32

ToConMapUintFloat32 creates a new ConMapUintFloat32 prepopulated with the data from the specified map[Uint]Float32.

func (*ConMapUintFloat32) Delete 

func (cm *ConMapUintFloat32) Delete(k uint) (float32, bool)

Delete removes the specified uint key, returning its float32 value and a bool indicating whether the delete occurred or not.

func (*ConMapUintFloat32) Get 

func (cm *ConMapUintFloat32) Get(k uint) float32

Get gets the float32 value for the given uint key.

func (*ConMapUintFloat32) GetOK 

func (cm *ConMapUintFloat32) GetOK(k uint) (float32, bool)

GetOK gets the float32 value for the given uint key, and a bool indicating whether the key was present or not.

func (*ConMapUintFloat32) Len 

func (cm *ConMapUintFloat32) Len() int

Get gets the float32 value for the given uint key.

func (*ConMapUintFloat32) Set 

func (cm *ConMapUintFloat32) Set(k uint, v float32)

Set sets the float32 value for the specified uint key.

type ConMapUintFloat64 

type ConMapUintFloat64 struct {
	// M is the underlying map[Uint]Float64.
	M map[uint]float64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUintFloat64 is a concurrent safe wrapper around a map[Uint]Float64.

func NewConMapUintFloat64 

func NewConMapUintFloat64() *ConMapUintFloat64

NewConMapUintFloat64 creates a new concurrent safe map storing float64 values, for uint keys.

func ToConMapUintFloat64 

func ToConMapUintFloat64(data map[uint]float64) *ConMapUintFloat64

ToConMapUintFloat64 creates a new ConMapUintFloat64 prepopulated with the data from the specified map[Uint]Float64.

func (*ConMapUintFloat64) Delete 

func (cm *ConMapUintFloat64) Delete(k uint) (float64, bool)

Delete removes the specified uint key, returning its float64 value and a bool indicating whether the delete occurred or not.

func (*ConMapUintFloat64) Get 

func (cm *ConMapUintFloat64) Get(k uint) float64

Get gets the float64 value for the given uint key.

func (*ConMapUintFloat64) GetOK 

func (cm *ConMapUintFloat64) GetOK(k uint) (float64, bool)

GetOK gets the float64 value for the given uint key, and a bool indicating whether the key was present or not.

func (*ConMapUintFloat64) Len 

func (cm *ConMapUintFloat64) Len() int

Get gets the float64 value for the given uint key.

func (*ConMapUintFloat64) Set 

func (cm *ConMapUintFloat64) Set(k uint, v float64)

Set sets the float64 value for the specified uint key.

type ConMapUintInt 

type ConMapUintInt struct {
	// M is the underlying map[Uint]Int.
	M map[uint]int
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUintInt is a concurrent safe wrapper around a map[Uint]Int.

func NewConMapUintInt 

func NewConMapUintInt() *ConMapUintInt

NewConMapUintInt creates a new concurrent safe map storing int values, for uint keys.

func ToConMapUintInt 

func ToConMapUintInt(data map[uint]int) *ConMapUintInt

ToConMapUintInt creates a new ConMapUintInt prepopulated with the data from the specified map[Uint]Int.

func (*ConMapUintInt) Delete 

func (cm *ConMapUintInt) Delete(k uint) (int, bool)

Delete removes the specified uint key, returning its int value and a bool indicating whether the delete occurred or not.

func (*ConMapUintInt) Get 

func (cm *ConMapUintInt) Get(k uint) int

Get gets the int value for the given uint key.

func (*ConMapUintInt) GetOK 

func (cm *ConMapUintInt) GetOK(k uint) (int, bool)

GetOK gets the int value for the given uint key, and a bool indicating whether the key was present or not.

func (*ConMapUintInt) Len 

func (cm *ConMapUintInt) Len() int

Get gets the int value for the given uint key.

func (*ConMapUintInt) Set 

func (cm *ConMapUintInt) Set(k uint, v int)

Set sets the int value for the specified uint key.

type ConMapUintInt16 

type ConMapUintInt16 struct {
	// M is the underlying map[Uint]Int16.
	M map[uint]int16
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUintInt16 is a concurrent safe wrapper around a map[Uint]Int16.

func NewConMapUintInt16 

func NewConMapUintInt16() *ConMapUintInt16

NewConMapUintInt16 creates a new concurrent safe map storing int16 values, for uint keys.

func ToConMapUintInt16 

func ToConMapUintInt16(data map[uint]int16) *ConMapUintInt16

ToConMapUintInt16 creates a new ConMapUintInt16 prepopulated with the data from the specified map[Uint]Int16.

func (*ConMapUintInt16) Delete 

func (cm *ConMapUintInt16) Delete(k uint) (int16, bool)

Delete removes the specified uint key, returning its int16 value and a bool indicating whether the delete occurred or not.

func (*ConMapUintInt16) Get 

func (cm *ConMapUintInt16) Get(k uint) int16

Get gets the int16 value for the given uint key.

func (*ConMapUintInt16) GetOK 

func (cm *ConMapUintInt16) GetOK(k uint) (int16, bool)

GetOK gets the int16 value for the given uint key, and a bool indicating whether the key was present or not.

func (*ConMapUintInt16) Len 

func (cm *ConMapUintInt16) Len() int

Get gets the int16 value for the given uint key.

func (*ConMapUintInt16) Set 

func (cm *ConMapUintInt16) Set(k uint, v int16)

Set sets the int16 value for the specified uint key.

type ConMapUintInt32 

type ConMapUintInt32 struct {
	// M is the underlying map[Uint]Int32.
	M map[uint]int32
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUintInt32 is a concurrent safe wrapper around a map[Uint]Int32.

func NewConMapUintInt32 

func NewConMapUintInt32() *ConMapUintInt32

NewConMapUintInt32 creates a new concurrent safe map storing int32 values, for uint keys.

func ToConMapUintInt32 

func ToConMapUintInt32(data map[uint]int32) *ConMapUintInt32

ToConMapUintInt32 creates a new ConMapUintInt32 prepopulated with the data from the specified map[Uint]Int32.

func (*ConMapUintInt32) Delete 

func (cm *ConMapUintInt32) Delete(k uint) (int32, bool)

Delete removes the specified uint key, returning its int32 value and a bool indicating whether the delete occurred or not.

func (*ConMapUintInt32) Get 

func (cm *ConMapUintInt32) Get(k uint) int32

Get gets the int32 value for the given uint key.

func (*ConMapUintInt32) GetOK 

func (cm *ConMapUintInt32) GetOK(k uint) (int32, bool)

GetOK gets the int32 value for the given uint key, and a bool indicating whether the key was present or not.

func (*ConMapUintInt32) Len 

func (cm *ConMapUintInt32) Len() int

Get gets the int32 value for the given uint key.

func (*ConMapUintInt32) Set 

func (cm *ConMapUintInt32) Set(k uint, v int32)

Set sets the int32 value for the specified uint key.

type ConMapUintInt64 

type ConMapUintInt64 struct {
	// M is the underlying map[Uint]Int64.
	M map[uint]int64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUintInt64 is a concurrent safe wrapper around a map[Uint]Int64.

func NewConMapUintInt64 

func NewConMapUintInt64() *ConMapUintInt64

NewConMapUintInt64 creates a new concurrent safe map storing int64 values, for uint keys.

func ToConMapUintInt64 

func ToConMapUintInt64(data map[uint]int64) *ConMapUintInt64

ToConMapUintInt64 creates a new ConMapUintInt64 prepopulated with the data from the specified map[Uint]Int64.

func (*ConMapUintInt64) Delete 

func (cm *ConMapUintInt64) Delete(k uint) (int64, bool)

Delete removes the specified uint key, returning its int64 value and a bool indicating whether the delete occurred or not.

func (*ConMapUintInt64) Get 

func (cm *ConMapUintInt64) Get(k uint) int64

Get gets the int64 value for the given uint key.

func (*ConMapUintInt64) GetOK 

func (cm *ConMapUintInt64) GetOK(k uint) (int64, bool)

GetOK gets the int64 value for the given uint key, and a bool indicating whether the key was present or not.

func (*ConMapUintInt64) Len 

func (cm *ConMapUintInt64) Len() int

Get gets the int64 value for the given uint key.

func (*ConMapUintInt64) Set 

func (cm *ConMapUintInt64) Set(k uint, v int64)

Set sets the int64 value for the specified uint key.

type ConMapUintInt8 

type ConMapUintInt8 struct {
	// M is the underlying map[Uint]Int8.
	M map[uint]int8
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUintInt8 is a concurrent safe wrapper around a map[Uint]Int8.

func NewConMapUintInt8 

func NewConMapUintInt8() *ConMapUintInt8

NewConMapUintInt8 creates a new concurrent safe map storing int8 values, for uint keys.

func ToConMapUintInt8 

func ToConMapUintInt8(data map[uint]int8) *ConMapUintInt8

ToConMapUintInt8 creates a new ConMapUintInt8 prepopulated with the data from the specified map[Uint]Int8.

func (*ConMapUintInt8) Delete 

func (cm *ConMapUintInt8) Delete(k uint) (int8, bool)

Delete removes the specified uint key, returning its int8 value and a bool indicating whether the delete occurred or not.

func (*ConMapUintInt8) Get 

func (cm *ConMapUintInt8) Get(k uint) int8

Get gets the int8 value for the given uint key.

func (*ConMapUintInt8) GetOK 

func (cm *ConMapUintInt8) GetOK(k uint) (int8, bool)

GetOK gets the int8 value for the given uint key, and a bool indicating whether the key was present or not.

func (*ConMapUintInt8) Len 

func (cm *ConMapUintInt8) Len() int

Get gets the int8 value for the given uint key.

func (*ConMapUintInt8) Set 

func (cm *ConMapUintInt8) Set(k uint, v int8)

Set sets the int8 value for the specified uint key.

type ConMapUintRune 

type ConMapUintRune struct {
	// M is the underlying map[Uint]Rune.
	M map[uint]rune
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUintRune is a concurrent safe wrapper around a map[Uint]Rune.

func NewConMapUintRune 

func NewConMapUintRune() *ConMapUintRune

NewConMapUintRune creates a new concurrent safe map storing rune values, for uint keys.

func ToConMapUintRune 

func ToConMapUintRune(data map[uint]rune) *ConMapUintRune

ToConMapUintRune creates a new ConMapUintRune prepopulated with the data from the specified map[Uint]Rune.

func (*ConMapUintRune) Delete 

func (cm *ConMapUintRune) Delete(k uint) (rune, bool)

Delete removes the specified uint key, returning its rune value and a bool indicating whether the delete occurred or not.

func (*ConMapUintRune) Get 

func (cm *ConMapUintRune) Get(k uint) rune

Get gets the rune value for the given uint key.

func (*ConMapUintRune) GetOK 

func (cm *ConMapUintRune) GetOK(k uint) (rune, bool)

GetOK gets the rune value for the given uint key, and a bool indicating whether the key was present or not.

func (*ConMapUintRune) Len 

func (cm *ConMapUintRune) Len() int

Get gets the rune value for the given uint key.

func (*ConMapUintRune) Set 

func (cm *ConMapUintRune) Set(k uint, v rune)

Set sets the rune value for the specified uint key.

type ConMapUintString 

type ConMapUintString struct {
	// M is the underlying map[Uint]String.
	M map[uint]string
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUintString is a concurrent safe wrapper around a map[Uint]String.

func NewConMapUintString 

func NewConMapUintString() *ConMapUintString

NewConMapUintString creates a new concurrent safe map storing string values, for uint keys.

func ToConMapUintString 

func ToConMapUintString(data map[uint]string) *ConMapUintString

ToConMapUintString creates a new ConMapUintString prepopulated with the data from the specified map[Uint]String.

func (*ConMapUintString) Delete 

func (cm *ConMapUintString) Delete(k uint) (string, bool)

Delete removes the specified uint key, returning its string value and a bool indicating whether the delete occurred or not.

func (*ConMapUintString) Get 

func (cm *ConMapUintString) Get(k uint) string

Get gets the string value for the given uint key.

func (*ConMapUintString) GetOK 

func (cm *ConMapUintString) GetOK(k uint) (string, bool)

GetOK gets the string value for the given uint key, and a bool indicating whether the key was present or not.

func (*ConMapUintString) Len 

func (cm *ConMapUintString) Len() int

Get gets the string value for the given uint key.

func (*ConMapUintString) Set 

func (cm *ConMapUintString) Set(k uint, v string)

Set sets the string value for the specified uint key.

type ConMapUintUint 

type ConMapUintUint struct {
	// M is the underlying map[Uint]Uint.
	M map[uint]uint
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUintUint is a concurrent safe wrapper around a map[Uint]Uint.

func NewConMapUintUint 

func NewConMapUintUint() *ConMapUintUint

NewConMapUintUint creates a new concurrent safe map storing uint values, for uint keys.

func ToConMapUintUint 

func ToConMapUintUint(data map[uint]uint) *ConMapUintUint

ToConMapUintUint creates a new ConMapUintUint prepopulated with the data from the specified map[Uint]Uint.

func (*ConMapUintUint) Delete 

func (cm *ConMapUintUint) Delete(k uint) (uint, bool)

Delete removes the specified uint key, returning its uint value and a bool indicating whether the delete occurred or not.

func (*ConMapUintUint) Get 

func (cm *ConMapUintUint) Get(k uint) uint

Get gets the uint value for the given uint key.

func (*ConMapUintUint) GetOK 

func (cm *ConMapUintUint) GetOK(k uint) (uint, bool)

GetOK gets the uint value for the given uint key, and a bool indicating whether the key was present or not.

func (*ConMapUintUint) Len 

func (cm *ConMapUintUint) Len() int

Get gets the uint value for the given uint key.

func (*ConMapUintUint) Set 

func (cm *ConMapUintUint) Set(k uint, v uint)

Set sets the uint value for the specified uint key.

type ConMapUintUint16 

type ConMapUintUint16 struct {
	// M is the underlying map[Uint]Uint16.
	M map[uint]uint16
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUintUint16 is a concurrent safe wrapper around a map[Uint]Uint16.

func NewConMapUintUint16 

func NewConMapUintUint16() *ConMapUintUint16

NewConMapUintUint16 creates a new concurrent safe map storing uint16 values, for uint keys.

func ToConMapUintUint16 

func ToConMapUintUint16(data map[uint]uint16) *ConMapUintUint16

ToConMapUintUint16 creates a new ConMapUintUint16 prepopulated with the data from the specified map[Uint]Uint16.

func (*ConMapUintUint16) Delete 

func (cm *ConMapUintUint16) Delete(k uint) (uint16, bool)

Delete removes the specified uint key, returning its uint16 value and a bool indicating whether the delete occurred or not.

func (*ConMapUintUint16) Get 

func (cm *ConMapUintUint16) Get(k uint) uint16

Get gets the uint16 value for the given uint key.

func (*ConMapUintUint16) GetOK 

func (cm *ConMapUintUint16) GetOK(k uint) (uint16, bool)

GetOK gets the uint16 value for the given uint key, and a bool indicating whether the key was present or not.

func (*ConMapUintUint16) Len 

func (cm *ConMapUintUint16) Len() int

Get gets the uint16 value for the given uint key.

func (*ConMapUintUint16) Set 

func (cm *ConMapUintUint16) Set(k uint, v uint16)

Set sets the uint16 value for the specified uint key.

type ConMapUintUint32 

type ConMapUintUint32 struct {
	// M is the underlying map[Uint]Uint32.
	M map[uint]uint32
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUintUint32 is a concurrent safe wrapper around a map[Uint]Uint32.

func NewConMapUintUint32 

func NewConMapUintUint32() *ConMapUintUint32

NewConMapUintUint32 creates a new concurrent safe map storing uint32 values, for uint keys.

func ToConMapUintUint32 

func ToConMapUintUint32(data map[uint]uint32) *ConMapUintUint32

ToConMapUintUint32 creates a new ConMapUintUint32 prepopulated with the data from the specified map[Uint]Uint32.

func (*ConMapUintUint32) Delete 

func (cm *ConMapUintUint32) Delete(k uint) (uint32, bool)

Delete removes the specified uint key, returning its uint32 value and a bool indicating whether the delete occurred or not.

func (*ConMapUintUint32) Get 

func (cm *ConMapUintUint32) Get(k uint) uint32

Get gets the uint32 value for the given uint key.

func (*ConMapUintUint32) GetOK 

func (cm *ConMapUintUint32) GetOK(k uint) (uint32, bool)

GetOK gets the uint32 value for the given uint key, and a bool indicating whether the key was present or not.

func (*ConMapUintUint32) Len 

func (cm *ConMapUintUint32) Len() int

Get gets the uint32 value for the given uint key.

func (*ConMapUintUint32) Set 

func (cm *ConMapUintUint32) Set(k uint, v uint32)

Set sets the uint32 value for the specified uint key.

type ConMapUintUint64 

type ConMapUintUint64 struct {
	// M is the underlying map[Uint]Uint64.
	M map[uint]uint64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUintUint64 is a concurrent safe wrapper around a map[Uint]Uint64.

func NewConMapUintUint64 

func NewConMapUintUint64() *ConMapUintUint64

NewConMapUintUint64 creates a new concurrent safe map storing uint64 values, for uint keys.

func ToConMapUintUint64 

func ToConMapUintUint64(data map[uint]uint64) *ConMapUintUint64

ToConMapUintUint64 creates a new ConMapUintUint64 prepopulated with the data from the specified map[Uint]Uint64.

func (*ConMapUintUint64) Delete 

func (cm *ConMapUintUint64) Delete(k uint) (uint64, bool)

Delete removes the specified uint key, returning its uint64 value and a bool indicating whether the delete occurred or not.

func (*ConMapUintUint64) Get 

func (cm *ConMapUintUint64) Get(k uint) uint64

Get gets the uint64 value for the given uint key.

func (*ConMapUintUint64) GetOK 

func (cm *ConMapUintUint64) GetOK(k uint) (uint64, bool)

GetOK gets the uint64 value for the given uint key, and a bool indicating whether the key was present or not.

func (*ConMapUintUint64) Len 

func (cm *ConMapUintUint64) Len() int

Get gets the uint64 value for the given uint key.

func (*ConMapUintUint64) Set 

func (cm *ConMapUintUint64) Set(k uint, v uint64)

Set sets the uint64 value for the specified uint key.

type ConMapUintUint8 

type ConMapUintUint8 struct {
	// M is the underlying map[Uint]Uint8.
	M map[uint]uint8
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUintUint8 is a concurrent safe wrapper around a map[Uint]Uint8.

func NewConMapUintUint8 

func NewConMapUintUint8() *ConMapUintUint8

NewConMapUintUint8 creates a new concurrent safe map storing uint8 values, for uint keys.

func ToConMapUintUint8 

func ToConMapUintUint8(data map[uint]uint8) *ConMapUintUint8

ToConMapUintUint8 creates a new ConMapUintUint8 prepopulated with the data from the specified map[Uint]Uint8.

func (*ConMapUintUint8) Delete 

func (cm *ConMapUintUint8) Delete(k uint) (uint8, bool)

Delete removes the specified uint key, returning its uint8 value and a bool indicating whether the delete occurred or not.

func (*ConMapUintUint8) Get 

func (cm *ConMapUintUint8) Get(k uint) uint8

Get gets the uint8 value for the given uint key.

func (*ConMapUintUint8) GetOK 

func (cm *ConMapUintUint8) GetOK(k uint) (uint8, bool)

GetOK gets the uint8 value for the given uint key, and a bool indicating whether the key was present or not.

func (*ConMapUintUint8) Len 

func (cm *ConMapUintUint8) Len() int

Get gets the uint8 value for the given uint key.

func (*ConMapUintUint8) Set 

func (cm *ConMapUintUint8) Set(k uint, v uint8)

Set sets the uint8 value for the specified uint key.

type ConMapUintUintptr 

type ConMapUintUintptr struct {
	// M is the underlying map[Uint]Uintptr.
	M map[uint]uintptr
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUintUintptr is a concurrent safe wrapper around a map[Uint]Uintptr.

func NewConMapUintUintptr 

func NewConMapUintUintptr() *ConMapUintUintptr

NewConMapUintUintptr creates a new concurrent safe map storing uintptr values, for uint keys.

func ToConMapUintUintptr 

func ToConMapUintUintptr(data map[uint]uintptr) *ConMapUintUintptr

ToConMapUintUintptr creates a new ConMapUintUintptr prepopulated with the data from the specified map[Uint]Uintptr.

func (*ConMapUintUintptr) Delete 

func (cm *ConMapUintUintptr) Delete(k uint) (uintptr, bool)

Delete removes the specified uint key, returning its uintptr value and a bool indicating whether the delete occurred or not.

func (*ConMapUintUintptr) Get 

func (cm *ConMapUintUintptr) Get(k uint) uintptr

Get gets the uintptr value for the given uint key.

func (*ConMapUintUintptr) GetOK 

func (cm *ConMapUintUintptr) GetOK(k uint) (uintptr, bool)

GetOK gets the uintptr value for the given uint key, and a bool indicating whether the key was present or not.

func (*ConMapUintUintptr) Len 

func (cm *ConMapUintUintptr) Len() int

Get gets the uintptr value for the given uint key.

func (*ConMapUintUintptr) Set 

func (cm *ConMapUintUintptr) Set(k uint, v uintptr)

Set sets the uintptr value for the specified uint key.

type ConMapUintptrBool 

type ConMapUintptrBool struct {
	// M is the underlying map[Uintptr]Bool.
	M map[uintptr]bool
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUintptrBool is a concurrent safe wrapper around a map[Uintptr]Bool.

func NewConMapUintptrBool 

func NewConMapUintptrBool() *ConMapUintptrBool

NewConMapUintptrBool creates a new concurrent safe map storing bool values, for uintptr keys.

func ToConMapUintptrBool 

func ToConMapUintptrBool(data map[uintptr]bool) *ConMapUintptrBool

ToConMapUintptrBool creates a new ConMapUintptrBool prepopulated with the data from the specified map[Uintptr]Bool.

func (*ConMapUintptrBool) Delete 

func (cm *ConMapUintptrBool) Delete(k uintptr) (bool, bool)

Delete removes the specified uintptr key, returning its bool value and a bool indicating whether the delete occurred or not.

func (*ConMapUintptrBool) Get 

func (cm *ConMapUintptrBool) Get(k uintptr) bool

Get gets the bool value for the given uintptr key.

func (*ConMapUintptrBool) GetOK 

func (cm *ConMapUintptrBool) GetOK(k uintptr) (bool, bool)

GetOK gets the bool value for the given uintptr key, and a bool indicating whether the key was present or not.

func (*ConMapUintptrBool) Len 

func (cm *ConMapUintptrBool) Len() int

Get gets the bool value for the given uintptr key.

func (*ConMapUintptrBool) Set 

func (cm *ConMapUintptrBool) Set(k uintptr, v bool)

Set sets the bool value for the specified uintptr key.

type ConMapUintptrByte 

type ConMapUintptrByte struct {
	// M is the underlying map[Uintptr]Byte.
	M map[uintptr]byte
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUintptrByte is a concurrent safe wrapper around a map[Uintptr]Byte.

func NewConMapUintptrByte 

func NewConMapUintptrByte() *ConMapUintptrByte

NewConMapUintptrByte creates a new concurrent safe map storing byte values, for uintptr keys.

func ToConMapUintptrByte 

func ToConMapUintptrByte(data map[uintptr]byte) *ConMapUintptrByte

ToConMapUintptrByte creates a new ConMapUintptrByte prepopulated with the data from the specified map[Uintptr]Byte.

func (*ConMapUintptrByte) Delete 

func (cm *ConMapUintptrByte) Delete(k uintptr) (byte, bool)

Delete removes the specified uintptr key, returning its byte value and a bool indicating whether the delete occurred or not.

func (*ConMapUintptrByte) Get 

func (cm *ConMapUintptrByte) Get(k uintptr) byte

Get gets the byte value for the given uintptr key.

func (*ConMapUintptrByte) GetOK 

func (cm *ConMapUintptrByte) GetOK(k uintptr) (byte, bool)

GetOK gets the byte value for the given uintptr key, and a bool indicating whether the key was present or not.

func (*ConMapUintptrByte) Len 

func (cm *ConMapUintptrByte) Len() int

Get gets the byte value for the given uintptr key.

func (*ConMapUintptrByte) Set 

func (cm *ConMapUintptrByte) Set(k uintptr, v byte)

Set sets the byte value for the specified uintptr key.

type ConMapUintptrComplex128 

type ConMapUintptrComplex128 struct {
	// M is the underlying map[Uintptr]Complex128.
	M map[uintptr]complex128
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUintptrComplex128 is a concurrent safe wrapper around a map[Uintptr]Complex128.

func NewConMapUintptrComplex128 

func NewConMapUintptrComplex128() *ConMapUintptrComplex128

NewConMapUintptrComplex128 creates a new concurrent safe map storing complex128 values, for uintptr keys.

func ToConMapUintptrComplex128 

func ToConMapUintptrComplex128(data map[uintptr]complex128) *ConMapUintptrComplex128

ToConMapUintptrComplex128 creates a new ConMapUintptrComplex128 prepopulated with the data from the specified map[Uintptr]Complex128.

func (*ConMapUintptrComplex128) Delete 

func (cm *ConMapUintptrComplex128) Delete(k uintptr) (complex128, bool)

Delete removes the specified uintptr key, returning its complex128 value and a bool indicating whether the delete occurred or not.

func (*ConMapUintptrComplex128) Get 

func (cm *ConMapUintptrComplex128) Get(k uintptr) complex128

Get gets the complex128 value for the given uintptr key.

func (*ConMapUintptrComplex128) GetOK 

func (cm *ConMapUintptrComplex128) GetOK(k uintptr) (complex128, bool)

GetOK gets the complex128 value for the given uintptr key, and a bool indicating whether the key was present or not.

func (*ConMapUintptrComplex128) Len 

func (cm *ConMapUintptrComplex128) Len() int

Get gets the complex128 value for the given uintptr key.

func (*ConMapUintptrComplex128) Set 

func (cm *ConMapUintptrComplex128) Set(k uintptr, v complex128)

Set sets the complex128 value for the specified uintptr key.

type ConMapUintptrComplex64 

type ConMapUintptrComplex64 struct {
	// M is the underlying map[Uintptr]Complex64.
	M map[uintptr]complex64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUintptrComplex64 is a concurrent safe wrapper around a map[Uintptr]Complex64.

func NewConMapUintptrComplex64 

func NewConMapUintptrComplex64() *ConMapUintptrComplex64

NewConMapUintptrComplex64 creates a new concurrent safe map storing complex64 values, for uintptr keys.

func ToConMapUintptrComplex64 

func ToConMapUintptrComplex64(data map[uintptr]complex64) *ConMapUintptrComplex64

ToConMapUintptrComplex64 creates a new ConMapUintptrComplex64 prepopulated with the data from the specified map[Uintptr]Complex64.

func (*ConMapUintptrComplex64) Delete 

func (cm *ConMapUintptrComplex64) Delete(k uintptr) (complex64, bool)

Delete removes the specified uintptr key, returning its complex64 value and a bool indicating whether the delete occurred or not.

func (*ConMapUintptrComplex64) Get 

func (cm *ConMapUintptrComplex64) Get(k uintptr) complex64

Get gets the complex64 value for the given uintptr key.

func (*ConMapUintptrComplex64) GetOK 

func (cm *ConMapUintptrComplex64) GetOK(k uintptr) (complex64, bool)

GetOK gets the complex64 value for the given uintptr key, and a bool indicating whether the key was present or not.

func (*ConMapUintptrComplex64) Len 

func (cm *ConMapUintptrComplex64) Len() int

Get gets the complex64 value for the given uintptr key.

func (*ConMapUintptrComplex64) Set 

func (cm *ConMapUintptrComplex64) Set(k uintptr, v complex64)

Set sets the complex64 value for the specified uintptr key.

type ConMapUintptrError 

type ConMapUintptrError struct {
	// M is the underlying map[Uintptr]Error.
	M map[uintptr]error
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUintptrError is a concurrent safe wrapper around a map[Uintptr]Error.

func NewConMapUintptrError 

func NewConMapUintptrError() *ConMapUintptrError

NewConMapUintptrError creates a new concurrent safe map storing error values, for uintptr keys.

func ToConMapUintptrError 

func ToConMapUintptrError(data map[uintptr]error) *ConMapUintptrError

ToConMapUintptrError creates a new ConMapUintptrError prepopulated with the data from the specified map[Uintptr]Error.

func (*ConMapUintptrError) Delete 

func (cm *ConMapUintptrError) Delete(k uintptr) (error, bool)

Delete removes the specified uintptr key, returning its error value and a bool indicating whether the delete occurred or not.

func (*ConMapUintptrError) Get 

func (cm *ConMapUintptrError) Get(k uintptr) error

Get gets the error value for the given uintptr key.

func (*ConMapUintptrError) GetOK 

func (cm *ConMapUintptrError) GetOK(k uintptr) (error, bool)

GetOK gets the error value for the given uintptr key, and a bool indicating whether the key was present or not.

func (*ConMapUintptrError) Len 

func (cm *ConMapUintptrError) Len() int

Get gets the error value for the given uintptr key.

func (*ConMapUintptrError) Set 

func (cm *ConMapUintptrError) Set(k uintptr, v error)

Set sets the error value for the specified uintptr key.

type ConMapUintptrFloat32 

type ConMapUintptrFloat32 struct {
	// M is the underlying map[Uintptr]Float32.
	M map[uintptr]float32
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUintptrFloat32 is a concurrent safe wrapper around a map[Uintptr]Float32.

func NewConMapUintptrFloat32 

func NewConMapUintptrFloat32() *ConMapUintptrFloat32

NewConMapUintptrFloat32 creates a new concurrent safe map storing float32 values, for uintptr keys.

func ToConMapUintptrFloat32 

func ToConMapUintptrFloat32(data map[uintptr]float32) *ConMapUintptrFloat32

ToConMapUintptrFloat32 creates a new ConMapUintptrFloat32 prepopulated with the data from the specified map[Uintptr]Float32.

func (*ConMapUintptrFloat32) Delete 

func (cm *ConMapUintptrFloat32) Delete(k uintptr) (float32, bool)

Delete removes the specified uintptr key, returning its float32 value and a bool indicating whether the delete occurred or not.

func (*ConMapUintptrFloat32) Get 

func (cm *ConMapUintptrFloat32) Get(k uintptr) float32

Get gets the float32 value for the given uintptr key.

func (*ConMapUintptrFloat32) GetOK 

func (cm *ConMapUintptrFloat32) GetOK(k uintptr) (float32, bool)

GetOK gets the float32 value for the given uintptr key, and a bool indicating whether the key was present or not.

func (*ConMapUintptrFloat32) Len 

func (cm *ConMapUintptrFloat32) Len() int

Get gets the float32 value for the given uintptr key.

func (*ConMapUintptrFloat32) Set 

func (cm *ConMapUintptrFloat32) Set(k uintptr, v float32)

Set sets the float32 value for the specified uintptr key.

type ConMapUintptrFloat64 

type ConMapUintptrFloat64 struct {
	// M is the underlying map[Uintptr]Float64.
	M map[uintptr]float64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUintptrFloat64 is a concurrent safe wrapper around a map[Uintptr]Float64.

func NewConMapUintptrFloat64 

func NewConMapUintptrFloat64() *ConMapUintptrFloat64

NewConMapUintptrFloat64 creates a new concurrent safe map storing float64 values, for uintptr keys.

func ToConMapUintptrFloat64 

func ToConMapUintptrFloat64(data map[uintptr]float64) *ConMapUintptrFloat64

ToConMapUintptrFloat64 creates a new ConMapUintptrFloat64 prepopulated with the data from the specified map[Uintptr]Float64.

func (*ConMapUintptrFloat64) Delete 

func (cm *ConMapUintptrFloat64) Delete(k uintptr) (float64, bool)

Delete removes the specified uintptr key, returning its float64 value and a bool indicating whether the delete occurred or not.

func (*ConMapUintptrFloat64) Get 

func (cm *ConMapUintptrFloat64) Get(k uintptr) float64

Get gets the float64 value for the given uintptr key.

func (*ConMapUintptrFloat64) GetOK 

func (cm *ConMapUintptrFloat64) GetOK(k uintptr) (float64, bool)

GetOK gets the float64 value for the given uintptr key, and a bool indicating whether the key was present or not.

func (*ConMapUintptrFloat64) Len 

func (cm *ConMapUintptrFloat64) Len() int

Get gets the float64 value for the given uintptr key.

func (*ConMapUintptrFloat64) Set 

func (cm *ConMapUintptrFloat64) Set(k uintptr, v float64)

Set sets the float64 value for the specified uintptr key.

type ConMapUintptrInt 

type ConMapUintptrInt struct {
	// M is the underlying map[Uintptr]Int.
	M map[uintptr]int
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUintptrInt is a concurrent safe wrapper around a map[Uintptr]Int.

func NewConMapUintptrInt 

func NewConMapUintptrInt() *ConMapUintptrInt

NewConMapUintptrInt creates a new concurrent safe map storing int values, for uintptr keys.

func ToConMapUintptrInt 

func ToConMapUintptrInt(data map[uintptr]int) *ConMapUintptrInt

ToConMapUintptrInt creates a new ConMapUintptrInt prepopulated with the data from the specified map[Uintptr]Int.

func (*ConMapUintptrInt) Delete 

func (cm *ConMapUintptrInt) Delete(k uintptr) (int, bool)

Delete removes the specified uintptr key, returning its int value and a bool indicating whether the delete occurred or not.

func (*ConMapUintptrInt) Get 

func (cm *ConMapUintptrInt) Get(k uintptr) int

Get gets the int value for the given uintptr key.

func (*ConMapUintptrInt) GetOK 

func (cm *ConMapUintptrInt) GetOK(k uintptr) (int, bool)

GetOK gets the int value for the given uintptr key, and a bool indicating whether the key was present or not.

func (*ConMapUintptrInt) Len 

func (cm *ConMapUintptrInt) Len() int

Get gets the int value for the given uintptr key.

func (*ConMapUintptrInt) Set 

func (cm *ConMapUintptrInt) Set(k uintptr, v int)

Set sets the int value for the specified uintptr key.

type ConMapUintptrInt16 

type ConMapUintptrInt16 struct {
	// M is the underlying map[Uintptr]Int16.
	M map[uintptr]int16
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUintptrInt16 is a concurrent safe wrapper around a map[Uintptr]Int16.

func NewConMapUintptrInt16 

func NewConMapUintptrInt16() *ConMapUintptrInt16

NewConMapUintptrInt16 creates a new concurrent safe map storing int16 values, for uintptr keys.

func ToConMapUintptrInt16 

func ToConMapUintptrInt16(data map[uintptr]int16) *ConMapUintptrInt16

ToConMapUintptrInt16 creates a new ConMapUintptrInt16 prepopulated with the data from the specified map[Uintptr]Int16.

func (*ConMapUintptrInt16) Delete 

func (cm *ConMapUintptrInt16) Delete(k uintptr) (int16, bool)

Delete removes the specified uintptr key, returning its int16 value and a bool indicating whether the delete occurred or not.

func (*ConMapUintptrInt16) Get 

func (cm *ConMapUintptrInt16) Get(k uintptr) int16

Get gets the int16 value for the given uintptr key.

func (*ConMapUintptrInt16) GetOK 

func (cm *ConMapUintptrInt16) GetOK(k uintptr) (int16, bool)

GetOK gets the int16 value for the given uintptr key, and a bool indicating whether the key was present or not.

func (*ConMapUintptrInt16) Len 

func (cm *ConMapUintptrInt16) Len() int

Get gets the int16 value for the given uintptr key.

func (*ConMapUintptrInt16) Set 

func (cm *ConMapUintptrInt16) Set(k uintptr, v int16)

Set sets the int16 value for the specified uintptr key.

type ConMapUintptrInt32 

type ConMapUintptrInt32 struct {
	// M is the underlying map[Uintptr]Int32.
	M map[uintptr]int32
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUintptrInt32 is a concurrent safe wrapper around a map[Uintptr]Int32.

func NewConMapUintptrInt32 

func NewConMapUintptrInt32() *ConMapUintptrInt32

NewConMapUintptrInt32 creates a new concurrent safe map storing int32 values, for uintptr keys.

func ToConMapUintptrInt32 

func ToConMapUintptrInt32(data map[uintptr]int32) *ConMapUintptrInt32

ToConMapUintptrInt32 creates a new ConMapUintptrInt32 prepopulated with the data from the specified map[Uintptr]Int32.

func (*ConMapUintptrInt32) Delete 

func (cm *ConMapUintptrInt32) Delete(k uintptr) (int32, bool)

Delete removes the specified uintptr key, returning its int32 value and a bool indicating whether the delete occurred or not.

func (*ConMapUintptrInt32) Get 

func (cm *ConMapUintptrInt32) Get(k uintptr) int32

Get gets the int32 value for the given uintptr key.

func (*ConMapUintptrInt32) GetOK 

func (cm *ConMapUintptrInt32) GetOK(k uintptr) (int32, bool)

GetOK gets the int32 value for the given uintptr key, and a bool indicating whether the key was present or not.

func (*ConMapUintptrInt32) Len 

func (cm *ConMapUintptrInt32) Len() int

Get gets the int32 value for the given uintptr key.

func (*ConMapUintptrInt32) Set 

func (cm *ConMapUintptrInt32) Set(k uintptr, v int32)

Set sets the int32 value for the specified uintptr key.

type ConMapUintptrInt64 

type ConMapUintptrInt64 struct {
	// M is the underlying map[Uintptr]Int64.
	M map[uintptr]int64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUintptrInt64 is a concurrent safe wrapper around a map[Uintptr]Int64.

func NewConMapUintptrInt64 

func NewConMapUintptrInt64() *ConMapUintptrInt64

NewConMapUintptrInt64 creates a new concurrent safe map storing int64 values, for uintptr keys.

func ToConMapUintptrInt64 

func ToConMapUintptrInt64(data map[uintptr]int64) *ConMapUintptrInt64

ToConMapUintptrInt64 creates a new ConMapUintptrInt64 prepopulated with the data from the specified map[Uintptr]Int64.

func (*ConMapUintptrInt64) Delete 

func (cm *ConMapUintptrInt64) Delete(k uintptr) (int64, bool)

Delete removes the specified uintptr key, returning its int64 value and a bool indicating whether the delete occurred or not.

func (*ConMapUintptrInt64) Get 

func (cm *ConMapUintptrInt64) Get(k uintptr) int64

Get gets the int64 value for the given uintptr key.

func (*ConMapUintptrInt64) GetOK 

func (cm *ConMapUintptrInt64) GetOK(k uintptr) (int64, bool)

GetOK gets the int64 value for the given uintptr key, and a bool indicating whether the key was present or not.

func (*ConMapUintptrInt64) Len 

func (cm *ConMapUintptrInt64) Len() int

Get gets the int64 value for the given uintptr key.

func (*ConMapUintptrInt64) Set 

func (cm *ConMapUintptrInt64) Set(k uintptr, v int64)

Set sets the int64 value for the specified uintptr key.

type ConMapUintptrInt8 

type ConMapUintptrInt8 struct {
	// M is the underlying map[Uintptr]Int8.
	M map[uintptr]int8
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUintptrInt8 is a concurrent safe wrapper around a map[Uintptr]Int8.

func NewConMapUintptrInt8 

func NewConMapUintptrInt8() *ConMapUintptrInt8

NewConMapUintptrInt8 creates a new concurrent safe map storing int8 values, for uintptr keys.

func ToConMapUintptrInt8 

func ToConMapUintptrInt8(data map[uintptr]int8) *ConMapUintptrInt8

ToConMapUintptrInt8 creates a new ConMapUintptrInt8 prepopulated with the data from the specified map[Uintptr]Int8.

func (*ConMapUintptrInt8) Delete 

func (cm *ConMapUintptrInt8) Delete(k uintptr) (int8, bool)

Delete removes the specified uintptr key, returning its int8 value and a bool indicating whether the delete occurred or not.

func (*ConMapUintptrInt8) Get 

func (cm *ConMapUintptrInt8) Get(k uintptr) int8

Get gets the int8 value for the given uintptr key.

func (*ConMapUintptrInt8) GetOK 

func (cm *ConMapUintptrInt8) GetOK(k uintptr) (int8, bool)

GetOK gets the int8 value for the given uintptr key, and a bool indicating whether the key was present or not.

func (*ConMapUintptrInt8) Len 

func (cm *ConMapUintptrInt8) Len() int

Get gets the int8 value for the given uintptr key.

func (*ConMapUintptrInt8) Set 

func (cm *ConMapUintptrInt8) Set(k uintptr, v int8)

Set sets the int8 value for the specified uintptr key.

type ConMapUintptrRune 

type ConMapUintptrRune struct {
	// M is the underlying map[Uintptr]Rune.
	M map[uintptr]rune
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUintptrRune is a concurrent safe wrapper around a map[Uintptr]Rune.

func NewConMapUintptrRune 

func NewConMapUintptrRune() *ConMapUintptrRune

NewConMapUintptrRune creates a new concurrent safe map storing rune values, for uintptr keys.

func ToConMapUintptrRune 

func ToConMapUintptrRune(data map[uintptr]rune) *ConMapUintptrRune

ToConMapUintptrRune creates a new ConMapUintptrRune prepopulated with the data from the specified map[Uintptr]Rune.

func (*ConMapUintptrRune) Delete 

func (cm *ConMapUintptrRune) Delete(k uintptr) (rune, bool)

Delete removes the specified uintptr key, returning its rune value and a bool indicating whether the delete occurred or not.

func (*ConMapUintptrRune) Get 

func (cm *ConMapUintptrRune) Get(k uintptr) rune

Get gets the rune value for the given uintptr key.

func (*ConMapUintptrRune) GetOK 

func (cm *ConMapUintptrRune) GetOK(k uintptr) (rune, bool)

GetOK gets the rune value for the given uintptr key, and a bool indicating whether the key was present or not.

func (*ConMapUintptrRune) Len 

func (cm *ConMapUintptrRune) Len() int

Get gets the rune value for the given uintptr key.

func (*ConMapUintptrRune) Set 

func (cm *ConMapUintptrRune) Set(k uintptr, v rune)

Set sets the rune value for the specified uintptr key.

type ConMapUintptrString 

type ConMapUintptrString struct {
	// M is the underlying map[Uintptr]String.
	M map[uintptr]string
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUintptrString is a concurrent safe wrapper around a map[Uintptr]String.

func NewConMapUintptrString 

func NewConMapUintptrString() *ConMapUintptrString

NewConMapUintptrString creates a new concurrent safe map storing string values, for uintptr keys.

func ToConMapUintptrString 

func ToConMapUintptrString(data map[uintptr]string) *ConMapUintptrString

ToConMapUintptrString creates a new ConMapUintptrString prepopulated with the data from the specified map[Uintptr]String.

func (*ConMapUintptrString) Delete 

func (cm *ConMapUintptrString) Delete(k uintptr) (string, bool)

Delete removes the specified uintptr key, returning its string value and a bool indicating whether the delete occurred or not.

func (*ConMapUintptrString) Get 

func (cm *ConMapUintptrString) Get(k uintptr) string

Get gets the string value for the given uintptr key.

func (*ConMapUintptrString) GetOK 

func (cm *ConMapUintptrString) GetOK(k uintptr) (string, bool)

GetOK gets the string value for the given uintptr key, and a bool indicating whether the key was present or not.

func (*ConMapUintptrString) Len 

func (cm *ConMapUintptrString) Len() int

Get gets the string value for the given uintptr key.

func (*ConMapUintptrString) Set 

func (cm *ConMapUintptrString) Set(k uintptr, v string)

Set sets the string value for the specified uintptr key.

type ConMapUintptrUint 

type ConMapUintptrUint struct {
	// M is the underlying map[Uintptr]Uint.
	M map[uintptr]uint
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUintptrUint is a concurrent safe wrapper around a map[Uintptr]Uint.

func NewConMapUintptrUint 

func NewConMapUintptrUint() *ConMapUintptrUint

NewConMapUintptrUint creates a new concurrent safe map storing uint values, for uintptr keys.

func ToConMapUintptrUint 

func ToConMapUintptrUint(data map[uintptr]uint) *ConMapUintptrUint

ToConMapUintptrUint creates a new ConMapUintptrUint prepopulated with the data from the specified map[Uintptr]Uint.

func (*ConMapUintptrUint) Delete 

func (cm *ConMapUintptrUint) Delete(k uintptr) (uint, bool)

Delete removes the specified uintptr key, returning its uint value and a bool indicating whether the delete occurred or not.

func (*ConMapUintptrUint) Get 

func (cm *ConMapUintptrUint) Get(k uintptr) uint

Get gets the uint value for the given uintptr key.

func (*ConMapUintptrUint) GetOK 

func (cm *ConMapUintptrUint) GetOK(k uintptr) (uint, bool)

GetOK gets the uint value for the given uintptr key, and a bool indicating whether the key was present or not.

func (*ConMapUintptrUint) Len 

func (cm *ConMapUintptrUint) Len() int

Get gets the uint value for the given uintptr key.

func (*ConMapUintptrUint) Set 

func (cm *ConMapUintptrUint) Set(k uintptr, v uint)

Set sets the uint value for the specified uintptr key.

type ConMapUintptrUint16 

type ConMapUintptrUint16 struct {
	// M is the underlying map[Uintptr]Uint16.
	M map[uintptr]uint16
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUintptrUint16 is a concurrent safe wrapper around a map[Uintptr]Uint16.

func NewConMapUintptrUint16 

func NewConMapUintptrUint16() *ConMapUintptrUint16

NewConMapUintptrUint16 creates a new concurrent safe map storing uint16 values, for uintptr keys.

func ToConMapUintptrUint16 

func ToConMapUintptrUint16(data map[uintptr]uint16) *ConMapUintptrUint16

ToConMapUintptrUint16 creates a new ConMapUintptrUint16 prepopulated with the data from the specified map[Uintptr]Uint16.

func (*ConMapUintptrUint16) Delete 

func (cm *ConMapUintptrUint16) Delete(k uintptr) (uint16, bool)

Delete removes the specified uintptr key, returning its uint16 value and a bool indicating whether the delete occurred or not.

func (*ConMapUintptrUint16) Get 

func (cm *ConMapUintptrUint16) Get(k uintptr) uint16

Get gets the uint16 value for the given uintptr key.

func (*ConMapUintptrUint16) GetOK 

func (cm *ConMapUintptrUint16) GetOK(k uintptr) (uint16, bool)

GetOK gets the uint16 value for the given uintptr key, and a bool indicating whether the key was present or not.

func (*ConMapUintptrUint16) Len 

func (cm *ConMapUintptrUint16) Len() int

Get gets the uint16 value for the given uintptr key.

func (*ConMapUintptrUint16) Set 

func (cm *ConMapUintptrUint16) Set(k uintptr, v uint16)

Set sets the uint16 value for the specified uintptr key.

type ConMapUintptrUint32 

type ConMapUintptrUint32 struct {
	// M is the underlying map[Uintptr]Uint32.
	M map[uintptr]uint32
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUintptrUint32 is a concurrent safe wrapper around a map[Uintptr]Uint32.

func NewConMapUintptrUint32 

func NewConMapUintptrUint32() *ConMapUintptrUint32

NewConMapUintptrUint32 creates a new concurrent safe map storing uint32 values, for uintptr keys.

func ToConMapUintptrUint32 

func ToConMapUintptrUint32(data map[uintptr]uint32) *ConMapUintptrUint32

ToConMapUintptrUint32 creates a new ConMapUintptrUint32 prepopulated with the data from the specified map[Uintptr]Uint32.

func (*ConMapUintptrUint32) Delete 

func (cm *ConMapUintptrUint32) Delete(k uintptr) (uint32, bool)

Delete removes the specified uintptr key, returning its uint32 value and a bool indicating whether the delete occurred or not.

func (*ConMapUintptrUint32) Get 

func (cm *ConMapUintptrUint32) Get(k uintptr) uint32

Get gets the uint32 value for the given uintptr key.

func (*ConMapUintptrUint32) GetOK 

func (cm *ConMapUintptrUint32) GetOK(k uintptr) (uint32, bool)

GetOK gets the uint32 value for the given uintptr key, and a bool indicating whether the key was present or not.

func (*ConMapUintptrUint32) Len 

func (cm *ConMapUintptrUint32) Len() int

Get gets the uint32 value for the given uintptr key.

func (*ConMapUintptrUint32) Set 

func (cm *ConMapUintptrUint32) Set(k uintptr, v uint32)

Set sets the uint32 value for the specified uintptr key.

type ConMapUintptrUint64 

type ConMapUintptrUint64 struct {
	// M is the underlying map[Uintptr]Uint64.
	M map[uintptr]uint64
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUintptrUint64 is a concurrent safe wrapper around a map[Uintptr]Uint64.

func NewConMapUintptrUint64 

func NewConMapUintptrUint64() *ConMapUintptrUint64

NewConMapUintptrUint64 creates a new concurrent safe map storing uint64 values, for uintptr keys.

func ToConMapUintptrUint64 

func ToConMapUintptrUint64(data map[uintptr]uint64) *ConMapUintptrUint64

ToConMapUintptrUint64 creates a new ConMapUintptrUint64 prepopulated with the data from the specified map[Uintptr]Uint64.

func (*ConMapUintptrUint64) Delete 

func (cm *ConMapUintptrUint64) Delete(k uintptr) (uint64, bool)

Delete removes the specified uintptr key, returning its uint64 value and a bool indicating whether the delete occurred or not.

func (*ConMapUintptrUint64) Get 

func (cm *ConMapUintptrUint64) Get(k uintptr) uint64

Get gets the uint64 value for the given uintptr key.

func (*ConMapUintptrUint64) GetOK 

func (cm *ConMapUintptrUint64) GetOK(k uintptr) (uint64, bool)

GetOK gets the uint64 value for the given uintptr key, and a bool indicating whether the key was present or not.

func (*ConMapUintptrUint64) Len 

func (cm *ConMapUintptrUint64) Len() int

Get gets the uint64 value for the given uintptr key.

func (*ConMapUintptrUint64) Set 

func (cm *ConMapUintptrUint64) Set(k uintptr, v uint64)

Set sets the uint64 value for the specified uintptr key.

type ConMapUintptrUint8 

type ConMapUintptrUint8 struct {
	// M is the underlying map[Uintptr]Uint8.
	M map[uintptr]uint8
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUintptrUint8 is a concurrent safe wrapper around a map[Uintptr]Uint8.

func NewConMapUintptrUint8 

func NewConMapUintptrUint8() *ConMapUintptrUint8

NewConMapUintptrUint8 creates a new concurrent safe map storing uint8 values, for uintptr keys.

func ToConMapUintptrUint8 

func ToConMapUintptrUint8(data map[uintptr]uint8) *ConMapUintptrUint8

ToConMapUintptrUint8 creates a new ConMapUintptrUint8 prepopulated with the data from the specified map[Uintptr]Uint8.

func (*ConMapUintptrUint8) Delete 

func (cm *ConMapUintptrUint8) Delete(k uintptr) (uint8, bool)

Delete removes the specified uintptr key, returning its uint8 value and a bool indicating whether the delete occurred or not.

func (*ConMapUintptrUint8) Get 

func (cm *ConMapUintptrUint8) Get(k uintptr) uint8

Get gets the uint8 value for the given uintptr key.

func (*ConMapUintptrUint8) GetOK 

func (cm *ConMapUintptrUint8) GetOK(k uintptr) (uint8, bool)

GetOK gets the uint8 value for the given uintptr key, and a bool indicating whether the key was present or not.

func (*ConMapUintptrUint8) Len 

func (cm *ConMapUintptrUint8) Len() int

Get gets the uint8 value for the given uintptr key.

func (*ConMapUintptrUint8) Set 

func (cm *ConMapUintptrUint8) Set(k uintptr, v uint8)

Set sets the uint8 value for the specified uintptr key.

type ConMapUintptrUintptr 

type ConMapUintptrUintptr struct {
	// M is the underlying map[Uintptr]Uintptr.
	M map[uintptr]uintptr
	// L is the sync.RWMutex used to control access to M.
	L sync.RWMutex
}

ConMapUintptrUintptr is a concurrent safe wrapper around a map[Uintptr]Uintptr.

func NewConMapUintptrUintptr 

func NewConMapUintptrUintptr() *ConMapUintptrUintptr

NewConMapUintptrUintptr creates a new concurrent safe map storing uintptr values, for uintptr keys.

func ToConMapUintptrUintptr 

func ToConMapUintptrUintptr(data map[uintptr]uintptr) *ConMapUintptrUintptr

ToConMapUintptrUintptr creates a new ConMapUintptrUintptr prepopulated with the data from the specified map[Uintptr]Uintptr.

func (*ConMapUintptrUintptr) Delete 

func (cm *ConMapUintptrUintptr) Delete(k uintptr) (uintptr, bool)

Delete removes the specified uintptr key, returning its uintptr value and a bool indicating whether the delete occurred or not.

func (*ConMapUintptrUintptr) Get 

func (cm *ConMapUintptrUintptr) Get(k uintptr) uintptr

Get gets the uintptr value for the given uintptr key.

func (*ConMapUintptrUintptr) GetOK 

func (cm *ConMapUintptrUintptr) GetOK(k uintptr) (uintptr, bool)

GetOK gets the uintptr value for the given uintptr key, and a bool indicating whether the key was present or not.

func (*ConMapUintptrUintptr) Len 

func (cm *ConMapUintptrUintptr) Len() int

Get gets the uintptr value for the given uintptr key.

func (*ConMapUintptrUintptr) Set 

func (cm *ConMapUintptrUintptr) Set(k uintptr, v uintptr)

Set sets the uintptr value for the specified uintptr key.

type KeyType 

type KeyType generic.Type

KeyType is the key type for the map.

type ValueType 

type ValueType generic.Type

ValueType is the value type for the map.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.