test1

package
v0.140.0 Latest Latest
Warning

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

 Go to latest Published: May 24, 2023 License: Apache-2.0 Imports: 3 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type DurationAlias 

type DurationAlias time.Duration

type InnerStruct 

type InnerStruct struct {
	InnerFieldA int
	InnerFieldB time.Duration
}

type IntAlias 

type IntAlias int

type LibraryStructAlias 

type LibraryStructAlias librarypkg.LibraryStruct

type NestedStruct 

type NestedStruct struct {
	FieldA string
	FieldB int
}

type NestedStructAlias 

type NestedStructAlias NestedStruct

type NestedStructBC 

type NestedStructBC struct {
	FieldB string
	FieldC int
}

type OptionalDurationAlias 

type OptionalDurationAlias *DurationAlias

type OptionalIntAlias 

type OptionalIntAlias *IntAlias

type OptionalLibraryStructAlias 

type OptionalLibraryStructAlias *LibraryStructAlias

type OptionalNestedStructAlias 

type OptionalNestedStructAlias *NestedStructAlias

type OptionalStringAlias 

type OptionalStringAlias *StringAlias

type OtherStruct 

type OtherStruct struct {
	FieldA string
	FieldB InnerStruct
}

type RefreshableDurationAlias 

type RefreshableDurationAlias interface {
	refreshable.Refreshable
	CurrentDurationAlias() DurationAlias
	MapDurationAlias(func(DurationAlias) interface{}) refreshable.Refreshable
	SubscribeToDurationAlias(func(DurationAlias)) (unsubscribe func())
}

type RefreshableDurationAliasPtr 

type RefreshableDurationAliasPtr interface {
	refreshable.Refreshable
	CurrentDurationAliasPtr() *DurationAlias
	MapDurationAliasPtr(func(*DurationAlias) interface{}) refreshable.Refreshable
	SubscribeToDurationAliasPtr(func(*DurationAlias)) (unsubscribe func())
}

type RefreshableDurationArray 

type RefreshableDurationArray interface {
	refreshable.Refreshable
	CurrentDurationArray() time.Duration
	MapDurationArray(func(time.Duration) interface{}) refreshable.Refreshable
	SubscribeToDurationArray(func(time.Duration)) (unsubscribe func())
}

type RefreshableDurationSlice 

type RefreshableDurationSlice interface {
	refreshable.Refreshable
	CurrentDurationSlice() []time.Duration
	MapDurationSlice(func([]time.Duration) interface{}) refreshable.Refreshable
	SubscribeToDurationSlice(func([]time.Duration)) (unsubscribe func())
}

type RefreshableDurationToDuration 

type RefreshableDurationToDuration interface {
	refreshable.Refreshable
	CurrentDurationToDuration() map[time.Duration]time.Duration
	MapDurationToDuration(func(map[time.Duration]time.Duration) interface{}) refreshable.Refreshable
	SubscribeToDurationToDuration(func(map[time.Duration]time.Duration)) (unsubscribe func())
}

type RefreshableInnerStruct 

type RefreshableInnerStruct interface {
	refreshable.Refreshable
	CurrentInnerStruct() InnerStruct
	MapInnerStruct(func(InnerStruct) interface{}) refreshable.Refreshable
	SubscribeToInnerStruct(func(InnerStruct)) (unsubscribe func())

	InnerFieldA() refreshable.Int
	InnerFieldB() refreshable.Duration
}

type RefreshableIntAlias 

type RefreshableIntAlias interface {
	refreshable.Refreshable
	CurrentIntAlias() IntAlias
	MapIntAlias(func(IntAlias) interface{}) refreshable.Refreshable
	SubscribeToIntAlias(func(IntAlias)) (unsubscribe func())
}

type RefreshableIntAliasPtr 

type RefreshableIntAliasPtr interface {
	refreshable.Refreshable
	CurrentIntAliasPtr() *IntAlias
	MapIntAliasPtr(func(*IntAlias) interface{}) refreshable.Refreshable
	SubscribeToIntAliasPtr(func(*IntAlias)) (unsubscribe func())
}

type RefreshableIntArray 

type RefreshableIntArray interface {
	refreshable.Refreshable
	CurrentIntArray() int
	MapIntArray(func(int) interface{}) refreshable.Refreshable
	SubscribeToIntArray(func(int)) (unsubscribe func())
}

type RefreshableIntSlice 

type RefreshableIntSlice interface {
	refreshable.Refreshable
	CurrentIntSlice() []int
	MapIntSlice(func([]int) interface{}) refreshable.Refreshable
	SubscribeToIntSlice(func([]int)) (unsubscribe func())
}

type RefreshableIntToInt 

type RefreshableIntToInt interface {
	refreshable.Refreshable
	CurrentIntToInt() map[int]int
	MapIntToInt(func(map[int]int) interface{}) refreshable.Refreshable
	SubscribeToIntToInt(func(map[int]int)) (unsubscribe func())
}

type RefreshableLibraryStruct 

type RefreshableLibraryStruct interface {
	refreshable.Refreshable
	CurrentLibraryStruct() librarypkg.LibraryStruct
	MapLibraryStruct(func(librarypkg.LibraryStruct) interface{}) refreshable.Refreshable
	SubscribeToLibraryStruct(func(librarypkg.LibraryStruct)) (unsubscribe func())

	FieldA() refreshable.Int
}

type RefreshableLibraryStructAlias 

type RefreshableLibraryStructAlias interface {
	refreshable.Refreshable
	CurrentLibraryStructAlias() LibraryStructAlias
	MapLibraryStructAlias(func(LibraryStructAlias) interface{}) refreshable.Refreshable
	SubscribeToLibraryStructAlias(func(LibraryStructAlias)) (unsubscribe func())

	FieldA() refreshable.Int
}

type RefreshableLibraryStructAliasPtr 

type RefreshableLibraryStructAliasPtr interface {
	refreshable.Refreshable
	CurrentLibraryStructAliasPtr() *LibraryStructAlias
	MapLibraryStructAliasPtr(func(*LibraryStructAlias) interface{}) refreshable.Refreshable
	SubscribeToLibraryStructAliasPtr(func(*LibraryStructAlias)) (unsubscribe func())

	FieldA() refreshable.Int
}

type RefreshableLibraryStructArray 

type RefreshableLibraryStructArray interface {
	refreshable.Refreshable
	CurrentLibraryStructArray() librarypkg.LibraryStruct
	MapLibraryStructArray(func(librarypkg.LibraryStruct) interface{}) refreshable.Refreshable
	SubscribeToLibraryStructArray(func(librarypkg.LibraryStruct)) (unsubscribe func())
}

type RefreshableLibraryStructPtr 

type RefreshableLibraryStructPtr interface {
	refreshable.Refreshable
	CurrentLibraryStructPtr() *librarypkg.LibraryStruct
	MapLibraryStructPtr(func(*librarypkg.LibraryStruct) interface{}) refreshable.Refreshable
	SubscribeToLibraryStructPtr(func(*librarypkg.LibraryStruct)) (unsubscribe func())

	FieldA() refreshable.Int
}

type RefreshableLibraryStructSlice 

type RefreshableLibraryStructSlice interface {
	refreshable.Refreshable
	CurrentLibraryStructSlice() []librarypkg.LibraryStruct
	MapLibraryStructSlice(func([]librarypkg.LibraryStruct) interface{}) refreshable.Refreshable
	SubscribeToLibraryStructSlice(func([]librarypkg.LibraryStruct)) (unsubscribe func())
}

type RefreshableLibraryStructToLibraryStruct 

type RefreshableLibraryStructToLibraryStruct interface {
	refreshable.Refreshable
	CurrentLibraryStructToLibraryStruct() map[librarypkg.LibraryStruct]librarypkg.LibraryStruct
	MapLibraryStructToLibraryStruct(func(map[librarypkg.LibraryStruct]librarypkg.LibraryStruct) interface{}) refreshable.Refreshable
	SubscribeToLibraryStructToLibraryStruct(func(map[librarypkg.LibraryStruct]librarypkg.LibraryStruct)) (unsubscribe func())
}

type RefreshableNestedStruct 

type RefreshableNestedStruct interface {
	refreshable.Refreshable
	CurrentNestedStruct() NestedStruct
	MapNestedStruct(func(NestedStruct) interface{}) refreshable.Refreshable
	SubscribeToNestedStruct(func(NestedStruct)) (unsubscribe func())

	FieldA() refreshable.String
	FieldB() refreshable.Int
}

type RefreshableNestedStructAlias 

type RefreshableNestedStructAlias interface {
	refreshable.Refreshable
	CurrentNestedStructAlias() NestedStructAlias
	MapNestedStructAlias(func(NestedStructAlias) interface{}) refreshable.Refreshable
	SubscribeToNestedStructAlias(func(NestedStructAlias)) (unsubscribe func())

	FieldA() refreshable.String
	FieldB() refreshable.Int
}

type RefreshableNestedStructAliasPtr 

type RefreshableNestedStructAliasPtr interface {
	refreshable.Refreshable
	CurrentNestedStructAliasPtr() *NestedStructAlias
	MapNestedStructAliasPtr(func(*NestedStructAlias) interface{}) refreshable.Refreshable
	SubscribeToNestedStructAliasPtr(func(*NestedStructAlias)) (unsubscribe func())

	FieldA() refreshable.String
	FieldB() refreshable.Int
}

type RefreshableNestedStructArray 

type RefreshableNestedStructArray interface {
	refreshable.Refreshable
	CurrentNestedStructArray() NestedStruct
	MapNestedStructArray(func(NestedStruct) interface{}) refreshable.Refreshable
	SubscribeToNestedStructArray(func(NestedStruct)) (unsubscribe func())
}

type RefreshableNestedStructPtr 

type RefreshableNestedStructPtr interface {
	refreshable.Refreshable
	CurrentNestedStructPtr() *NestedStruct
	MapNestedStructPtr(func(*NestedStruct) interface{}) refreshable.Refreshable
	SubscribeToNestedStructPtr(func(*NestedStruct)) (unsubscribe func())

	FieldA() refreshable.String
	FieldB() refreshable.Int
}

type RefreshableNestedStructSlice 

type RefreshableNestedStructSlice interface {
	refreshable.Refreshable
	CurrentNestedStructSlice() []NestedStruct
	MapNestedStructSlice(func([]NestedStruct) interface{}) refreshable.Refreshable
	SubscribeToNestedStructSlice(func([]NestedStruct)) (unsubscribe func())
}

type RefreshableNestedStructToNestedStruct 

type RefreshableNestedStructToNestedStruct interface {
	refreshable.Refreshable
	CurrentNestedStructToNestedStruct() map[NestedStruct]NestedStruct
	MapNestedStructToNestedStruct(func(map[NestedStruct]NestedStruct) interface{}) refreshable.Refreshable
	SubscribeToNestedStructToNestedStruct(func(map[NestedStruct]NestedStruct)) (unsubscribe func())
}

type RefreshableOptionalDurationAlias 

type RefreshableOptionalDurationAlias interface {
	refreshable.Refreshable
	CurrentOptionalDurationAlias() OptionalDurationAlias
	MapOptionalDurationAlias(func(OptionalDurationAlias) interface{}) refreshable.Refreshable
	SubscribeToOptionalDurationAlias(func(OptionalDurationAlias)) (unsubscribe func())
}

type RefreshableOptionalDurationAliasPtr 

type RefreshableOptionalDurationAliasPtr interface {
	refreshable.Refreshable
	CurrentOptionalDurationAliasPtr() *OptionalDurationAlias
	MapOptionalDurationAliasPtr(func(*OptionalDurationAlias) interface{}) refreshable.Refreshable
	SubscribeToOptionalDurationAliasPtr(func(*OptionalDurationAlias)) (unsubscribe func())
}

type RefreshableOptionalIntAlias 

type RefreshableOptionalIntAlias interface {
	refreshable.Refreshable
	CurrentOptionalIntAlias() OptionalIntAlias
	MapOptionalIntAlias(func(OptionalIntAlias) interface{}) refreshable.Refreshable
	SubscribeToOptionalIntAlias(func(OptionalIntAlias)) (unsubscribe func())
}

type RefreshableOptionalIntAliasPtr 

type RefreshableOptionalIntAliasPtr interface {
	refreshable.Refreshable
	CurrentOptionalIntAliasPtr() *OptionalIntAlias
	MapOptionalIntAliasPtr(func(*OptionalIntAlias) interface{}) refreshable.Refreshable
	SubscribeToOptionalIntAliasPtr(func(*OptionalIntAlias)) (unsubscribe func())
}

type RefreshableOptionalLibraryStructAlias 

type RefreshableOptionalLibraryStructAlias interface {
	refreshable.Refreshable
	CurrentOptionalLibraryStructAlias() OptionalLibraryStructAlias
	MapOptionalLibraryStructAlias(func(OptionalLibraryStructAlias) interface{}) refreshable.Refreshable
	SubscribeToOptionalLibraryStructAlias(func(OptionalLibraryStructAlias)) (unsubscribe func())

	FieldA() refreshable.Int
}

type RefreshableOptionalNestedStructAlias 

type RefreshableOptionalNestedStructAlias interface {
	refreshable.Refreshable
	CurrentOptionalNestedStructAlias() OptionalNestedStructAlias
	MapOptionalNestedStructAlias(func(OptionalNestedStructAlias) interface{}) refreshable.Refreshable
	SubscribeToOptionalNestedStructAlias(func(OptionalNestedStructAlias)) (unsubscribe func())

	FieldA() refreshable.String
	FieldB() refreshable.Int
}

type RefreshableOptionalStringAlias 

type RefreshableOptionalStringAlias interface {
	refreshable.Refreshable
	CurrentOptionalStringAlias() OptionalStringAlias
	MapOptionalStringAlias(func(OptionalStringAlias) interface{}) refreshable.Refreshable
	SubscribeToOptionalStringAlias(func(OptionalStringAlias)) (unsubscribe func())
}

type RefreshableOptionalStringAliasPtr 

type RefreshableOptionalStringAliasPtr interface {
	refreshable.Refreshable
	CurrentOptionalStringAliasPtr() *OptionalStringAlias
	MapOptionalStringAliasPtr(func(*OptionalStringAlias) interface{}) refreshable.Refreshable
	SubscribeToOptionalStringAliasPtr(func(*OptionalStringAlias)) (unsubscribe func())
}

type RefreshableOtherStruct 

type RefreshableOtherStruct interface {
	refreshable.Refreshable
	CurrentOtherStruct() OtherStruct
	MapOtherStruct(func(OtherStruct) interface{}) refreshable.Refreshable
	SubscribeToOtherStruct(func(OtherStruct)) (unsubscribe func())

	FieldA() refreshable.String
	FieldB() RefreshableInnerStruct
}

type RefreshableStringAlias 

type RefreshableStringAlias interface {
	refreshable.Refreshable
	CurrentStringAlias() StringAlias
	MapStringAlias(func(StringAlias) interface{}) refreshable.Refreshable
	SubscribeToStringAlias(func(StringAlias)) (unsubscribe func())
}

type RefreshableStringAliasPtr 

type RefreshableStringAliasPtr interface {
	refreshable.Refreshable
	CurrentStringAliasPtr() *StringAlias
	MapStringAliasPtr(func(*StringAlias) interface{}) refreshable.Refreshable
	SubscribeToStringAliasPtr(func(*StringAlias)) (unsubscribe func())
}

type RefreshableStringArray 

type RefreshableStringArray interface {
	refreshable.Refreshable
	CurrentStringArray() string
	MapStringArray(func(string) interface{}) refreshable.Refreshable
	SubscribeToStringArray(func(string)) (unsubscribe func())
}

type RefreshableStringToString 

type RefreshableStringToString interface {
	refreshable.Refreshable
	CurrentStringToString() map[string]string
	MapStringToString(func(map[string]string) interface{}) refreshable.Refreshable
	SubscribeToStringToString(func(map[string]string)) (unsubscribe func())
}

type RefreshableSuperStruct 

type RefreshableSuperStruct interface {
	refreshable.Refreshable
	CurrentSuperStruct() SuperStruct
	MapSuperStruct(func(SuperStruct) interface{}) refreshable.Refreshable
	SubscribeToSuperStruct(func(SuperStruct)) (unsubscribe func())

	String() refreshable.String
	OptionalString() refreshable.StringPtr
	SliceString() refreshable.StringSlice
	ArrayString() RefreshableStringArray
	StringString() RefreshableStringToString
	StringAlias() RefreshableStringAlias
	OptionalStringAlias() RefreshableOptionalStringAlias
	DoubleOptionalStringAlias() RefreshableOptionalStringAliasPtr
	Int() refreshable.Int
	OptionalInt() refreshable.IntPtr
	SliceInt() RefreshableIntSlice
	ArrayInt() RefreshableIntArray
	IntInt() RefreshableIntToInt
	IntAlias() RefreshableIntAlias
	OptionalIntAlias() RefreshableOptionalIntAlias
	DoubleOptionalIntAlias() RefreshableOptionalIntAliasPtr
	Duration() refreshable.Duration
	OptionalDuration() refreshable.DurationPtr
	SliceDuration() RefreshableDurationSlice
	ArrayDuration() RefreshableDurationArray
	DurationDuration() RefreshableDurationToDuration
	DurationAlias() RefreshableDurationAlias
	OptionalDurationAlias() RefreshableOptionalDurationAlias
	DoubleOptionalDurationAlias() RefreshableOptionalDurationAliasPtr
	Int64() refreshable.Int64
	Int64Ptr() refreshable.Int64Ptr
	Float64() refreshable.Float64
	Float64Ptr() refreshable.Float64Ptr
	NestedStruct() RefreshableNestedStruct
	NamedNestedStruct() RefreshableNestedStruct
	OptionalNestedStruct() RefreshableNestedStructPtr
	SliceNestedStruct() RefreshableNestedStructSlice
	ArrayNestedStruct() RefreshableNestedStructArray
	NestedStructNestedStruct() RefreshableNestedStructToNestedStruct
	NestedStructAlias() RefreshableNestedStructAlias
	OptionalNestedStructAlias() RefreshableOptionalNestedStructAlias
	LibraryStruct() RefreshableLibraryStruct
	NamedLibraryStruct() RefreshableLibraryStruct
	OptionalLibraryStruct() RefreshableLibraryStructPtr
	SliceLibraryStruct() RefreshableLibraryStructSlice
	ArrayLibraryStruct() RefreshableLibraryStructArray
	LibraryStructLibraryStruct() RefreshableLibraryStructToLibraryStruct
	LibraryStructAlias() RefreshableLibraryStructAlias
	OptionalLibraryStructAlias() RefreshableOptionalLibraryStructAlias
}

type RefreshingDurationAlias 

type RefreshingDurationAlias struct {
	refreshable.Refreshable
}

func NewRefreshingDurationAlias 

func NewRefreshingDurationAlias(in refreshable.Refreshable) RefreshingDurationAlias

func (RefreshingDurationAlias) CurrentDurationAlias 

func (r RefreshingDurationAlias) CurrentDurationAlias() DurationAlias

func (RefreshingDurationAlias) MapDurationAlias 

func (r RefreshingDurationAlias) MapDurationAlias(mapFn func(DurationAlias) interface{}) refreshable.Refreshable

func (RefreshingDurationAlias) SubscribeToDurationAlias 

func (r RefreshingDurationAlias) SubscribeToDurationAlias(consumer func(DurationAlias)) (unsubscribe func())

type RefreshingDurationAliasPtr 

type RefreshingDurationAliasPtr struct {
	refreshable.Refreshable
}

func NewRefreshingDurationAliasPtr 

func NewRefreshingDurationAliasPtr(in refreshable.Refreshable) RefreshingDurationAliasPtr

func (RefreshingDurationAliasPtr) CurrentDurationAliasPtr 

func (r RefreshingDurationAliasPtr) CurrentDurationAliasPtr() *DurationAlias

func (RefreshingDurationAliasPtr) MapDurationAliasPtr 

func (r RefreshingDurationAliasPtr) MapDurationAliasPtr(mapFn func(*DurationAlias) interface{}) refreshable.Refreshable

func (RefreshingDurationAliasPtr) SubscribeToDurationAliasPtr 

func (r RefreshingDurationAliasPtr) SubscribeToDurationAliasPtr(consumer func(*DurationAlias)) (unsubscribe func())

type RefreshingDurationArray 

type RefreshingDurationArray struct {
	refreshable.Refreshable
}

func NewRefreshingDurationArray 

func NewRefreshingDurationArray(in refreshable.Refreshable) RefreshingDurationArray

func (RefreshingDurationArray) CurrentDurationArray 

func (r RefreshingDurationArray) CurrentDurationArray() time.Duration

func (RefreshingDurationArray) MapDurationArray 

func (r RefreshingDurationArray) MapDurationArray(mapFn func(time.Duration) interface{}) refreshable.Refreshable

func (RefreshingDurationArray) SubscribeToDurationArray 

func (r RefreshingDurationArray) SubscribeToDurationArray(consumer func(time.Duration)) (unsubscribe func())

type RefreshingDurationSlice 

type RefreshingDurationSlice struct {
	refreshable.Refreshable
}

func NewRefreshingDurationSlice 

func NewRefreshingDurationSlice(in refreshable.Refreshable) RefreshingDurationSlice

func (RefreshingDurationSlice) CurrentDurationSlice 

func (r RefreshingDurationSlice) CurrentDurationSlice() []time.Duration

func (RefreshingDurationSlice) MapDurationSlice 

func (r RefreshingDurationSlice) MapDurationSlice(mapFn func([]time.Duration) interface{}) refreshable.Refreshable

func (RefreshingDurationSlice) SubscribeToDurationSlice 

func (r RefreshingDurationSlice) SubscribeToDurationSlice(consumer func([]time.Duration)) (unsubscribe func())

type RefreshingDurationToDuration 

type RefreshingDurationToDuration struct {
	refreshable.Refreshable
}

func NewRefreshingDurationToDuration 

func NewRefreshingDurationToDuration(in refreshable.Refreshable) RefreshingDurationToDuration

func (RefreshingDurationToDuration) CurrentDurationToDuration 

func (r RefreshingDurationToDuration) CurrentDurationToDuration() map[time.Duration]time.Duration

func (RefreshingDurationToDuration) MapDurationToDuration 

func (r RefreshingDurationToDuration) MapDurationToDuration(mapFn func(map[time.Duration]time.Duration) interface{}) refreshable.Refreshable

func (RefreshingDurationToDuration) SubscribeToDurationToDuration 

func (r RefreshingDurationToDuration) SubscribeToDurationToDuration(consumer func(map[time.Duration]time.Duration)) (unsubscribe func())

type RefreshingInnerStruct 

type RefreshingInnerStruct struct {
	refreshable.Refreshable
}

func NewRefreshingInnerStruct 

func NewRefreshingInnerStruct(in refreshable.Refreshable) RefreshingInnerStruct

func (RefreshingInnerStruct) CurrentInnerStruct 

func (r RefreshingInnerStruct) CurrentInnerStruct() InnerStruct

func (RefreshingInnerStruct) InnerFieldA 

func (r RefreshingInnerStruct) InnerFieldA() refreshable.Int

func (RefreshingInnerStruct) InnerFieldB 

func (r RefreshingInnerStruct) InnerFieldB() refreshable.Duration

func (RefreshingInnerStruct) MapInnerStruct 

func (r RefreshingInnerStruct) MapInnerStruct(mapFn func(InnerStruct) interface{}) refreshable.Refreshable

func (RefreshingInnerStruct) SubscribeToInnerStruct 

func (r RefreshingInnerStruct) SubscribeToInnerStruct(consumer func(InnerStruct)) (unsubscribe func())

type RefreshingIntAlias 

type RefreshingIntAlias struct {
	refreshable.Refreshable
}

func NewRefreshingIntAlias 

func NewRefreshingIntAlias(in refreshable.Refreshable) RefreshingIntAlias

func (RefreshingIntAlias) CurrentIntAlias 

func (r RefreshingIntAlias) CurrentIntAlias() IntAlias

func (RefreshingIntAlias) MapIntAlias 

func (r RefreshingIntAlias) MapIntAlias(mapFn func(IntAlias) interface{}) refreshable.Refreshable

func (RefreshingIntAlias) SubscribeToIntAlias 

func (r RefreshingIntAlias) SubscribeToIntAlias(consumer func(IntAlias)) (unsubscribe func())

type RefreshingIntAliasPtr 

type RefreshingIntAliasPtr struct {
	refreshable.Refreshable
}

func NewRefreshingIntAliasPtr 

func NewRefreshingIntAliasPtr(in refreshable.Refreshable) RefreshingIntAliasPtr

func (RefreshingIntAliasPtr) CurrentIntAliasPtr 

func (r RefreshingIntAliasPtr) CurrentIntAliasPtr() *IntAlias

func (RefreshingIntAliasPtr) MapIntAliasPtr 

func (r RefreshingIntAliasPtr) MapIntAliasPtr(mapFn func(*IntAlias) interface{}) refreshable.Refreshable

func (RefreshingIntAliasPtr) SubscribeToIntAliasPtr 

func (r RefreshingIntAliasPtr) SubscribeToIntAliasPtr(consumer func(*IntAlias)) (unsubscribe func())

type RefreshingIntArray 

type RefreshingIntArray struct {
	refreshable.Refreshable
}

func NewRefreshingIntArray 

func NewRefreshingIntArray(in refreshable.Refreshable) RefreshingIntArray

func (RefreshingIntArray) CurrentIntArray 

func (r RefreshingIntArray) CurrentIntArray() int

func (RefreshingIntArray) MapIntArray 

func (r RefreshingIntArray) MapIntArray(mapFn func(int) interface{}) refreshable.Refreshable

func (RefreshingIntArray) SubscribeToIntArray 

func (r RefreshingIntArray) SubscribeToIntArray(consumer func(int)) (unsubscribe func())

type RefreshingIntSlice 

type RefreshingIntSlice struct {
	refreshable.Refreshable
}

func NewRefreshingIntSlice 

func NewRefreshingIntSlice(in refreshable.Refreshable) RefreshingIntSlice

func (RefreshingIntSlice) CurrentIntSlice 

func (r RefreshingIntSlice) CurrentIntSlice() []int

func (RefreshingIntSlice) MapIntSlice 

func (r RefreshingIntSlice) MapIntSlice(mapFn func([]int) interface{}) refreshable.Refreshable

func (RefreshingIntSlice) SubscribeToIntSlice 

func (r RefreshingIntSlice) SubscribeToIntSlice(consumer func([]int)) (unsubscribe func())

type RefreshingIntToInt 

type RefreshingIntToInt struct {
	refreshable.Refreshable
}

func NewRefreshingIntToInt 

func NewRefreshingIntToInt(in refreshable.Refreshable) RefreshingIntToInt

func (RefreshingIntToInt) CurrentIntToInt 

func (r RefreshingIntToInt) CurrentIntToInt() map[int]int

func (RefreshingIntToInt) MapIntToInt 

func (r RefreshingIntToInt) MapIntToInt(mapFn func(map[int]int) interface{}) refreshable.Refreshable

func (RefreshingIntToInt) SubscribeToIntToInt 

func (r RefreshingIntToInt) SubscribeToIntToInt(consumer func(map[int]int)) (unsubscribe func())

type RefreshingLibraryStruct 

type RefreshingLibraryStruct struct {
	refreshable.Refreshable
}

func NewRefreshingLibraryStruct 

func NewRefreshingLibraryStruct(in refreshable.Refreshable) RefreshingLibraryStruct

func (RefreshingLibraryStruct) CurrentLibraryStruct 

func (r RefreshingLibraryStruct) CurrentLibraryStruct() librarypkg.LibraryStruct

func (RefreshingLibraryStruct) FieldA 

func (r RefreshingLibraryStruct) FieldA() refreshable.Int

func (RefreshingLibraryStruct) MapLibraryStruct 

func (r RefreshingLibraryStruct) MapLibraryStruct(mapFn func(librarypkg.LibraryStruct) interface{}) refreshable.Refreshable

func (RefreshingLibraryStruct) SubscribeToLibraryStruct 

func (r RefreshingLibraryStruct) SubscribeToLibraryStruct(consumer func(librarypkg.LibraryStruct)) (unsubscribe func())

type RefreshingLibraryStructAlias 

type RefreshingLibraryStructAlias struct {
	refreshable.Refreshable
}

func NewRefreshingLibraryStructAlias 

func NewRefreshingLibraryStructAlias(in refreshable.Refreshable) RefreshingLibraryStructAlias

func (RefreshingLibraryStructAlias) CurrentLibraryStructAlias 

func (r RefreshingLibraryStructAlias) CurrentLibraryStructAlias() LibraryStructAlias

func (RefreshingLibraryStructAlias) FieldA 

func (r RefreshingLibraryStructAlias) FieldA() refreshable.Int

func (RefreshingLibraryStructAlias) MapLibraryStructAlias 

func (r RefreshingLibraryStructAlias) MapLibraryStructAlias(mapFn func(LibraryStructAlias) interface{}) refreshable.Refreshable

func (RefreshingLibraryStructAlias) SubscribeToLibraryStructAlias 

func (r RefreshingLibraryStructAlias) SubscribeToLibraryStructAlias(consumer func(LibraryStructAlias)) (unsubscribe func())

type RefreshingLibraryStructAliasPtr 

type RefreshingLibraryStructAliasPtr struct {
	refreshable.Refreshable
}

func NewRefreshingLibraryStructAliasPtr 

func NewRefreshingLibraryStructAliasPtr(in refreshable.Refreshable) RefreshingLibraryStructAliasPtr

func (RefreshingLibraryStructAliasPtr) CurrentLibraryStructAliasPtr 

func (r RefreshingLibraryStructAliasPtr) CurrentLibraryStructAliasPtr() *LibraryStructAlias

func (RefreshingLibraryStructAliasPtr) FieldA 

func (r RefreshingLibraryStructAliasPtr) FieldA() refreshable.Int

func (RefreshingLibraryStructAliasPtr) MapLibraryStructAliasPtr 

func (r RefreshingLibraryStructAliasPtr) MapLibraryStructAliasPtr(mapFn func(*LibraryStructAlias) interface{}) refreshable.Refreshable

func (RefreshingLibraryStructAliasPtr) SubscribeToLibraryStructAliasPtr 

func (r RefreshingLibraryStructAliasPtr) SubscribeToLibraryStructAliasPtr(consumer func(*LibraryStructAlias)) (unsubscribe func())

type RefreshingLibraryStructArray 

type RefreshingLibraryStructArray struct {
	refreshable.Refreshable
}

func NewRefreshingLibraryStructArray 

func NewRefreshingLibraryStructArray(in refreshable.Refreshable) RefreshingLibraryStructArray

func (RefreshingLibraryStructArray) CurrentLibraryStructArray 

func (r RefreshingLibraryStructArray) CurrentLibraryStructArray() librarypkg.LibraryStruct

func (RefreshingLibraryStructArray) MapLibraryStructArray 

func (r RefreshingLibraryStructArray) MapLibraryStructArray(mapFn func(librarypkg.LibraryStruct) interface{}) refreshable.Refreshable

func (RefreshingLibraryStructArray) SubscribeToLibraryStructArray 

func (r RefreshingLibraryStructArray) SubscribeToLibraryStructArray(consumer func(librarypkg.LibraryStruct)) (unsubscribe func())

type RefreshingLibraryStructPtr 

type RefreshingLibraryStructPtr struct {
	refreshable.Refreshable
}

func NewRefreshingLibraryStructPtr 

func NewRefreshingLibraryStructPtr(in refreshable.Refreshable) RefreshingLibraryStructPtr

func (RefreshingLibraryStructPtr) CurrentLibraryStructPtr 

func (r RefreshingLibraryStructPtr) CurrentLibraryStructPtr() *librarypkg.LibraryStruct

func (RefreshingLibraryStructPtr) FieldA 

func (r RefreshingLibraryStructPtr) FieldA() refreshable.Int

func (RefreshingLibraryStructPtr) MapLibraryStructPtr 

func (r RefreshingLibraryStructPtr) MapLibraryStructPtr(mapFn func(*librarypkg.LibraryStruct) interface{}) refreshable.Refreshable

func (RefreshingLibraryStructPtr) SubscribeToLibraryStructPtr 

func (r RefreshingLibraryStructPtr) SubscribeToLibraryStructPtr(consumer func(*librarypkg.LibraryStruct)) (unsubscribe func())

type RefreshingLibraryStructSlice 

type RefreshingLibraryStructSlice struct {
	refreshable.Refreshable
}

func NewRefreshingLibraryStructSlice 

func NewRefreshingLibraryStructSlice(in refreshable.Refreshable) RefreshingLibraryStructSlice

func (RefreshingLibraryStructSlice) CurrentLibraryStructSlice 

func (r RefreshingLibraryStructSlice) CurrentLibraryStructSlice() []librarypkg.LibraryStruct

func (RefreshingLibraryStructSlice) MapLibraryStructSlice 

func (r RefreshingLibraryStructSlice) MapLibraryStructSlice(mapFn func([]librarypkg.LibraryStruct) interface{}) refreshable.Refreshable

func (RefreshingLibraryStructSlice) SubscribeToLibraryStructSlice 

func (r RefreshingLibraryStructSlice) SubscribeToLibraryStructSlice(consumer func([]librarypkg.LibraryStruct)) (unsubscribe func())

type RefreshingLibraryStructToLibraryStruct 

type RefreshingLibraryStructToLibraryStruct struct {
	refreshable.Refreshable
}

func NewRefreshingLibraryStructToLibraryStruct 

func NewRefreshingLibraryStructToLibraryStruct(in refreshable.Refreshable) RefreshingLibraryStructToLibraryStruct

func (RefreshingLibraryStructToLibraryStruct) CurrentLibraryStructToLibraryStruct 

func (r RefreshingLibraryStructToLibraryStruct) CurrentLibraryStructToLibraryStruct() map[librarypkg.LibraryStruct]librarypkg.LibraryStruct

func (RefreshingLibraryStructToLibraryStruct) MapLibraryStructToLibraryStruct 

func (r RefreshingLibraryStructToLibraryStruct) MapLibraryStructToLibraryStruct(mapFn func(map[librarypkg.LibraryStruct]librarypkg.LibraryStruct) interface{}) refreshable.Refreshable

func (RefreshingLibraryStructToLibraryStruct) SubscribeToLibraryStructToLibraryStruct 

func (r RefreshingLibraryStructToLibraryStruct) SubscribeToLibraryStructToLibraryStruct(consumer func(map[librarypkg.LibraryStruct]librarypkg.LibraryStruct)) (unsubscribe func())

type RefreshingNestedStruct 

type RefreshingNestedStruct struct {
	refreshable.Refreshable
}

func NewRefreshingNestedStruct 

func NewRefreshingNestedStruct(in refreshable.Refreshable) RefreshingNestedStruct

func (RefreshingNestedStruct) CurrentNestedStruct 

func (r RefreshingNestedStruct) CurrentNestedStruct() NestedStruct

func (RefreshingNestedStruct) FieldA 

func (r RefreshingNestedStruct) FieldA() refreshable.String

func (RefreshingNestedStruct) FieldB 

func (r RefreshingNestedStruct) FieldB() refreshable.Int

func (RefreshingNestedStruct) MapNestedStruct 

func (r RefreshingNestedStruct) MapNestedStruct(mapFn func(NestedStruct) interface{}) refreshable.Refreshable

func (RefreshingNestedStruct) SubscribeToNestedStruct 

func (r RefreshingNestedStruct) SubscribeToNestedStruct(consumer func(NestedStruct)) (unsubscribe func())

type RefreshingNestedStructAlias 

type RefreshingNestedStructAlias struct {
	refreshable.Refreshable
}

func NewRefreshingNestedStructAlias 

func NewRefreshingNestedStructAlias(in refreshable.Refreshable) RefreshingNestedStructAlias

func (RefreshingNestedStructAlias) CurrentNestedStructAlias 

func (r RefreshingNestedStructAlias) CurrentNestedStructAlias() NestedStructAlias

func (RefreshingNestedStructAlias) FieldA 

func (r RefreshingNestedStructAlias) FieldA() refreshable.String

func (RefreshingNestedStructAlias) FieldB 

func (r RefreshingNestedStructAlias) FieldB() refreshable.Int

func (RefreshingNestedStructAlias) MapNestedStructAlias 

func (r RefreshingNestedStructAlias) MapNestedStructAlias(mapFn func(NestedStructAlias) interface{}) refreshable.Refreshable

func (RefreshingNestedStructAlias) SubscribeToNestedStructAlias 

func (r RefreshingNestedStructAlias) SubscribeToNestedStructAlias(consumer func(NestedStructAlias)) (unsubscribe func())

type RefreshingNestedStructAliasPtr 

type RefreshingNestedStructAliasPtr struct {
	refreshable.Refreshable
}

func NewRefreshingNestedStructAliasPtr 

func NewRefreshingNestedStructAliasPtr(in refreshable.Refreshable) RefreshingNestedStructAliasPtr

func (RefreshingNestedStructAliasPtr) CurrentNestedStructAliasPtr 

func (r RefreshingNestedStructAliasPtr) CurrentNestedStructAliasPtr() *NestedStructAlias

func (RefreshingNestedStructAliasPtr) FieldA 

func (r RefreshingNestedStructAliasPtr) FieldA() refreshable.String

func (RefreshingNestedStructAliasPtr) FieldB 

func (r RefreshingNestedStructAliasPtr) FieldB() refreshable.Int

func (RefreshingNestedStructAliasPtr) MapNestedStructAliasPtr 

func (r RefreshingNestedStructAliasPtr) MapNestedStructAliasPtr(mapFn func(*NestedStructAlias) interface{}) refreshable.Refreshable

func (RefreshingNestedStructAliasPtr) SubscribeToNestedStructAliasPtr 

func (r RefreshingNestedStructAliasPtr) SubscribeToNestedStructAliasPtr(consumer func(*NestedStructAlias)) (unsubscribe func())

type RefreshingNestedStructArray 

type RefreshingNestedStructArray struct {
	refreshable.Refreshable
}

func NewRefreshingNestedStructArray 

func NewRefreshingNestedStructArray(in refreshable.Refreshable) RefreshingNestedStructArray

func (RefreshingNestedStructArray) CurrentNestedStructArray 

func (r RefreshingNestedStructArray) CurrentNestedStructArray() NestedStruct

func (RefreshingNestedStructArray) MapNestedStructArray 

func (r RefreshingNestedStructArray) MapNestedStructArray(mapFn func(NestedStruct) interface{}) refreshable.Refreshable

func (RefreshingNestedStructArray) SubscribeToNestedStructArray 

func (r RefreshingNestedStructArray) SubscribeToNestedStructArray(consumer func(NestedStruct)) (unsubscribe func())

type RefreshingNestedStructPtr 

type RefreshingNestedStructPtr struct {
	refreshable.Refreshable
}

func NewRefreshingNestedStructPtr 

func NewRefreshingNestedStructPtr(in refreshable.Refreshable) RefreshingNestedStructPtr

func (RefreshingNestedStructPtr) CurrentNestedStructPtr 

func (r RefreshingNestedStructPtr) CurrentNestedStructPtr() *NestedStruct

func (RefreshingNestedStructPtr) FieldA 

func (r RefreshingNestedStructPtr) FieldA() refreshable.String

func (RefreshingNestedStructPtr) FieldB 

func (r RefreshingNestedStructPtr) FieldB() refreshable.Int

func (RefreshingNestedStructPtr) MapNestedStructPtr 

func (r RefreshingNestedStructPtr) MapNestedStructPtr(mapFn func(*NestedStruct) interface{}) refreshable.Refreshable

func (RefreshingNestedStructPtr) SubscribeToNestedStructPtr 

func (r RefreshingNestedStructPtr) SubscribeToNestedStructPtr(consumer func(*NestedStruct)) (unsubscribe func())

type RefreshingNestedStructSlice 

type RefreshingNestedStructSlice struct {
	refreshable.Refreshable
}

func NewRefreshingNestedStructSlice 

func NewRefreshingNestedStructSlice(in refreshable.Refreshable) RefreshingNestedStructSlice

func (RefreshingNestedStructSlice) CurrentNestedStructSlice 

func (r RefreshingNestedStructSlice) CurrentNestedStructSlice() []NestedStruct

func (RefreshingNestedStructSlice) MapNestedStructSlice 

func (r RefreshingNestedStructSlice) MapNestedStructSlice(mapFn func([]NestedStruct) interface{}) refreshable.Refreshable

func (RefreshingNestedStructSlice) SubscribeToNestedStructSlice 

func (r RefreshingNestedStructSlice) SubscribeToNestedStructSlice(consumer func([]NestedStruct)) (unsubscribe func())

type RefreshingNestedStructToNestedStruct 

type RefreshingNestedStructToNestedStruct struct {
	refreshable.Refreshable
}

func NewRefreshingNestedStructToNestedStruct 

func NewRefreshingNestedStructToNestedStruct(in refreshable.Refreshable) RefreshingNestedStructToNestedStruct

func (RefreshingNestedStructToNestedStruct) CurrentNestedStructToNestedStruct 

func (r RefreshingNestedStructToNestedStruct) CurrentNestedStructToNestedStruct() map[NestedStruct]NestedStruct

func (RefreshingNestedStructToNestedStruct) MapNestedStructToNestedStruct 

func (r RefreshingNestedStructToNestedStruct) MapNestedStructToNestedStruct(mapFn func(map[NestedStruct]NestedStruct) interface{}) refreshable.Refreshable

func (RefreshingNestedStructToNestedStruct) SubscribeToNestedStructToNestedStruct 

func (r RefreshingNestedStructToNestedStruct) SubscribeToNestedStructToNestedStruct(consumer func(map[NestedStruct]NestedStruct)) (unsubscribe func())

type RefreshingOptionalDurationAlias 

type RefreshingOptionalDurationAlias struct {
	refreshable.Refreshable
}

func NewRefreshingOptionalDurationAlias 

func NewRefreshingOptionalDurationAlias(in refreshable.Refreshable) RefreshingOptionalDurationAlias

func (RefreshingOptionalDurationAlias) CurrentOptionalDurationAlias 

func (r RefreshingOptionalDurationAlias) CurrentOptionalDurationAlias() OptionalDurationAlias

func (RefreshingOptionalDurationAlias) MapOptionalDurationAlias 

func (r RefreshingOptionalDurationAlias) MapOptionalDurationAlias(mapFn func(OptionalDurationAlias) interface{}) refreshable.Refreshable

func (RefreshingOptionalDurationAlias) SubscribeToOptionalDurationAlias 

func (r RefreshingOptionalDurationAlias) SubscribeToOptionalDurationAlias(consumer func(OptionalDurationAlias)) (unsubscribe func())

type RefreshingOptionalDurationAliasPtr 

type RefreshingOptionalDurationAliasPtr struct {
	refreshable.Refreshable
}

func NewRefreshingOptionalDurationAliasPtr 

func NewRefreshingOptionalDurationAliasPtr(in refreshable.Refreshable) RefreshingOptionalDurationAliasPtr

func (RefreshingOptionalDurationAliasPtr) CurrentOptionalDurationAliasPtr 

func (r RefreshingOptionalDurationAliasPtr) CurrentOptionalDurationAliasPtr() *OptionalDurationAlias

func (RefreshingOptionalDurationAliasPtr) MapOptionalDurationAliasPtr 

func (r RefreshingOptionalDurationAliasPtr) MapOptionalDurationAliasPtr(mapFn func(*OptionalDurationAlias) interface{}) refreshable.Refreshable

func (RefreshingOptionalDurationAliasPtr) SubscribeToOptionalDurationAliasPtr 

func (r RefreshingOptionalDurationAliasPtr) SubscribeToOptionalDurationAliasPtr(consumer func(*OptionalDurationAlias)) (unsubscribe func())

type RefreshingOptionalIntAlias 

type RefreshingOptionalIntAlias struct {
	refreshable.Refreshable
}

func NewRefreshingOptionalIntAlias 

func NewRefreshingOptionalIntAlias(in refreshable.Refreshable) RefreshingOptionalIntAlias

func (RefreshingOptionalIntAlias) CurrentOptionalIntAlias 

func (r RefreshingOptionalIntAlias) CurrentOptionalIntAlias() OptionalIntAlias

func (RefreshingOptionalIntAlias) MapOptionalIntAlias 

func (r RefreshingOptionalIntAlias) MapOptionalIntAlias(mapFn func(OptionalIntAlias) interface{}) refreshable.Refreshable

func (RefreshingOptionalIntAlias) SubscribeToOptionalIntAlias 

func (r RefreshingOptionalIntAlias) SubscribeToOptionalIntAlias(consumer func(OptionalIntAlias)) (unsubscribe func())

type RefreshingOptionalIntAliasPtr 

type RefreshingOptionalIntAliasPtr struct {
	refreshable.Refreshable
}

func NewRefreshingOptionalIntAliasPtr 

func NewRefreshingOptionalIntAliasPtr(in refreshable.Refreshable) RefreshingOptionalIntAliasPtr

func (RefreshingOptionalIntAliasPtr) CurrentOptionalIntAliasPtr 

func (r RefreshingOptionalIntAliasPtr) CurrentOptionalIntAliasPtr() *OptionalIntAlias

func (RefreshingOptionalIntAliasPtr) MapOptionalIntAliasPtr 

func (r RefreshingOptionalIntAliasPtr) MapOptionalIntAliasPtr(mapFn func(*OptionalIntAlias) interface{}) refreshable.Refreshable

func (RefreshingOptionalIntAliasPtr) SubscribeToOptionalIntAliasPtr 

func (r RefreshingOptionalIntAliasPtr) SubscribeToOptionalIntAliasPtr(consumer func(*OptionalIntAlias)) (unsubscribe func())

type RefreshingOptionalLibraryStructAlias 

type RefreshingOptionalLibraryStructAlias struct {
	refreshable.Refreshable
}

func NewRefreshingOptionalLibraryStructAlias 

func NewRefreshingOptionalLibraryStructAlias(in refreshable.Refreshable) RefreshingOptionalLibraryStructAlias

func (RefreshingOptionalLibraryStructAlias) CurrentOptionalLibraryStructAlias 

func (r RefreshingOptionalLibraryStructAlias) CurrentOptionalLibraryStructAlias() OptionalLibraryStructAlias

func (RefreshingOptionalLibraryStructAlias) FieldA 

func (r RefreshingOptionalLibraryStructAlias) FieldA() refreshable.Int

func (RefreshingOptionalLibraryStructAlias) MapOptionalLibraryStructAlias 

func (r RefreshingOptionalLibraryStructAlias) MapOptionalLibraryStructAlias(mapFn func(OptionalLibraryStructAlias) interface{}) refreshable.Refreshable

func (RefreshingOptionalLibraryStructAlias) SubscribeToOptionalLibraryStructAlias 

func (r RefreshingOptionalLibraryStructAlias) SubscribeToOptionalLibraryStructAlias(consumer func(OptionalLibraryStructAlias)) (unsubscribe func())

type RefreshingOptionalNestedStructAlias 

type RefreshingOptionalNestedStructAlias struct {
	refreshable.Refreshable
}

func NewRefreshingOptionalNestedStructAlias 

func NewRefreshingOptionalNestedStructAlias(in refreshable.Refreshable) RefreshingOptionalNestedStructAlias

func (RefreshingOptionalNestedStructAlias) CurrentOptionalNestedStructAlias 

func (r RefreshingOptionalNestedStructAlias) CurrentOptionalNestedStructAlias() OptionalNestedStructAlias

func (RefreshingOptionalNestedStructAlias) FieldA 

func (r RefreshingOptionalNestedStructAlias) FieldA() refreshable.String

func (RefreshingOptionalNestedStructAlias) FieldB 

func (r RefreshingOptionalNestedStructAlias) FieldB() refreshable.Int

func (RefreshingOptionalNestedStructAlias) MapOptionalNestedStructAlias 

func (r RefreshingOptionalNestedStructAlias) MapOptionalNestedStructAlias(mapFn func(OptionalNestedStructAlias) interface{}) refreshable.Refreshable

func (RefreshingOptionalNestedStructAlias) SubscribeToOptionalNestedStructAlias 

func (r RefreshingOptionalNestedStructAlias) SubscribeToOptionalNestedStructAlias(consumer func(OptionalNestedStructAlias)) (unsubscribe func())

type RefreshingOptionalStringAlias 

type RefreshingOptionalStringAlias struct {
	refreshable.Refreshable
}

func NewRefreshingOptionalStringAlias 

func NewRefreshingOptionalStringAlias(in refreshable.Refreshable) RefreshingOptionalStringAlias

func (RefreshingOptionalStringAlias) CurrentOptionalStringAlias 

func (r RefreshingOptionalStringAlias) CurrentOptionalStringAlias() OptionalStringAlias

func (RefreshingOptionalStringAlias) MapOptionalStringAlias 

func (r RefreshingOptionalStringAlias) MapOptionalStringAlias(mapFn func(OptionalStringAlias) interface{}) refreshable.Refreshable

func (RefreshingOptionalStringAlias) SubscribeToOptionalStringAlias 

func (r RefreshingOptionalStringAlias) SubscribeToOptionalStringAlias(consumer func(OptionalStringAlias)) (unsubscribe func())

type RefreshingOptionalStringAliasPtr 

type RefreshingOptionalStringAliasPtr struct {
	refreshable.Refreshable
}

func NewRefreshingOptionalStringAliasPtr 

func NewRefreshingOptionalStringAliasPtr(in refreshable.Refreshable) RefreshingOptionalStringAliasPtr

func (RefreshingOptionalStringAliasPtr) CurrentOptionalStringAliasPtr 

func (r RefreshingOptionalStringAliasPtr) CurrentOptionalStringAliasPtr() *OptionalStringAlias

func (RefreshingOptionalStringAliasPtr) MapOptionalStringAliasPtr 

func (r RefreshingOptionalStringAliasPtr) MapOptionalStringAliasPtr(mapFn func(*OptionalStringAlias) interface{}) refreshable.Refreshable

func (RefreshingOptionalStringAliasPtr) SubscribeToOptionalStringAliasPtr 

func (r RefreshingOptionalStringAliasPtr) SubscribeToOptionalStringAliasPtr(consumer func(*OptionalStringAlias)) (unsubscribe func())

type RefreshingOtherStruct 

type RefreshingOtherStruct struct {
	refreshable.Refreshable
}

func NewRefreshingOtherStruct 

func NewRefreshingOtherStruct(in refreshable.Refreshable) RefreshingOtherStruct

func (RefreshingOtherStruct) CurrentOtherStruct 

func (r RefreshingOtherStruct) CurrentOtherStruct() OtherStruct

func (RefreshingOtherStruct) FieldA 

func (r RefreshingOtherStruct) FieldA() refreshable.String

func (RefreshingOtherStruct) FieldB 

func (r RefreshingOtherStruct) FieldB() RefreshableInnerStruct

func (RefreshingOtherStruct) MapOtherStruct 

func (r RefreshingOtherStruct) MapOtherStruct(mapFn func(OtherStruct) interface{}) refreshable.Refreshable

func (RefreshingOtherStruct) SubscribeToOtherStruct 

func (r RefreshingOtherStruct) SubscribeToOtherStruct(consumer func(OtherStruct)) (unsubscribe func())

type RefreshingStringAlias 

type RefreshingStringAlias struct {
	refreshable.Refreshable
}

func NewRefreshingStringAlias 

func NewRefreshingStringAlias(in refreshable.Refreshable) RefreshingStringAlias

func (RefreshingStringAlias) CurrentStringAlias 

func (r RefreshingStringAlias) CurrentStringAlias() StringAlias

func (RefreshingStringAlias) MapStringAlias 

func (r RefreshingStringAlias) MapStringAlias(mapFn func(StringAlias) interface{}) refreshable.Refreshable

func (RefreshingStringAlias) SubscribeToStringAlias 

func (r RefreshingStringAlias) SubscribeToStringAlias(consumer func(StringAlias)) (unsubscribe func())

type RefreshingStringAliasPtr 

type RefreshingStringAliasPtr struct {
	refreshable.Refreshable
}

func NewRefreshingStringAliasPtr 

func NewRefreshingStringAliasPtr(in refreshable.Refreshable) RefreshingStringAliasPtr

func (RefreshingStringAliasPtr) CurrentStringAliasPtr 

func (r RefreshingStringAliasPtr) CurrentStringAliasPtr() *StringAlias

func (RefreshingStringAliasPtr) MapStringAliasPtr 

func (r RefreshingStringAliasPtr) MapStringAliasPtr(mapFn func(*StringAlias) interface{}) refreshable.Refreshable

func (RefreshingStringAliasPtr) SubscribeToStringAliasPtr 

func (r RefreshingStringAliasPtr) SubscribeToStringAliasPtr(consumer func(*StringAlias)) (unsubscribe func())

type RefreshingStringArray 

type RefreshingStringArray struct {
	refreshable.Refreshable
}

func NewRefreshingStringArray 

func NewRefreshingStringArray(in refreshable.Refreshable) RefreshingStringArray

func (RefreshingStringArray) CurrentStringArray 

func (r RefreshingStringArray) CurrentStringArray() string

func (RefreshingStringArray) MapStringArray 

func (r RefreshingStringArray) MapStringArray(mapFn func(string) interface{}) refreshable.Refreshable

func (RefreshingStringArray) SubscribeToStringArray 

func (r RefreshingStringArray) SubscribeToStringArray(consumer func(string)) (unsubscribe func())

type RefreshingStringToString 

type RefreshingStringToString struct {
	refreshable.Refreshable
}

func NewRefreshingStringToString 

func NewRefreshingStringToString(in refreshable.Refreshable) RefreshingStringToString

func (RefreshingStringToString) CurrentStringToString 

func (r RefreshingStringToString) CurrentStringToString() map[string]string

func (RefreshingStringToString) MapStringToString 

func (r RefreshingStringToString) MapStringToString(mapFn func(map[string]string) interface{}) refreshable.Refreshable

func (RefreshingStringToString) SubscribeToStringToString 

func (r RefreshingStringToString) SubscribeToStringToString(consumer func(map[string]string)) (unsubscribe func())

type RefreshingSuperStruct 

type RefreshingSuperStruct struct {
	refreshable.Refreshable
}

func NewRefreshingSuperStruct 

func NewRefreshingSuperStruct(in refreshable.Refreshable) RefreshingSuperStruct

func (RefreshingSuperStruct) ArrayDuration 

func (r RefreshingSuperStruct) ArrayDuration() RefreshableDurationArray

func (RefreshingSuperStruct) ArrayInt 

func (r RefreshingSuperStruct) ArrayInt() RefreshableIntArray

func (RefreshingSuperStruct) ArrayLibraryStruct 

func (r RefreshingSuperStruct) ArrayLibraryStruct() RefreshableLibraryStructArray

func (RefreshingSuperStruct) ArrayNestedStruct 

func (r RefreshingSuperStruct) ArrayNestedStruct() RefreshableNestedStructArray

func (RefreshingSuperStruct) ArrayString 

func (r RefreshingSuperStruct) ArrayString() RefreshableStringArray

func (RefreshingSuperStruct) CurrentSuperStruct 

func (r RefreshingSuperStruct) CurrentSuperStruct() SuperStruct

func (RefreshingSuperStruct) DoubleOptionalDurationAlias 

func (r RefreshingSuperStruct) DoubleOptionalDurationAlias() RefreshableOptionalDurationAliasPtr

func (RefreshingSuperStruct) DoubleOptionalIntAlias 

func (r RefreshingSuperStruct) DoubleOptionalIntAlias() RefreshableOptionalIntAliasPtr

func (RefreshingSuperStruct) DoubleOptionalStringAlias 

func (r RefreshingSuperStruct) DoubleOptionalStringAlias() RefreshableOptionalStringAliasPtr

func (RefreshingSuperStruct) Duration 

func (r RefreshingSuperStruct) Duration() refreshable.Duration

func (RefreshingSuperStruct) DurationAlias 

func (r RefreshingSuperStruct) DurationAlias() RefreshableDurationAlias

func (RefreshingSuperStruct) DurationDuration 

func (r RefreshingSuperStruct) DurationDuration() RefreshableDurationToDuration

func (RefreshingSuperStruct) Float64 added in v0.0.2 

func (r RefreshingSuperStruct) Float64() refreshable.Float64

func (RefreshingSuperStruct) Float64Ptr added in v0.0.2 

func (r RefreshingSuperStruct) Float64Ptr() refreshable.Float64Ptr

func (RefreshingSuperStruct) Int 

func (r RefreshingSuperStruct) Int() refreshable.Int

func (RefreshingSuperStruct) Int64 added in v0.0.2 

func (r RefreshingSuperStruct) Int64() refreshable.Int64

func (RefreshingSuperStruct) Int64Ptr added in v0.0.2 

func (r RefreshingSuperStruct) Int64Ptr() refreshable.Int64Ptr

func (RefreshingSuperStruct) IntAlias 

func (r RefreshingSuperStruct) IntAlias() RefreshableIntAlias

func (RefreshingSuperStruct) IntInt 

func (r RefreshingSuperStruct) IntInt() RefreshableIntToInt

func (RefreshingSuperStruct) LibraryStruct 

func (r RefreshingSuperStruct) LibraryStruct() RefreshableLibraryStruct

func (RefreshingSuperStruct) LibraryStructAlias 

func (r RefreshingSuperStruct) LibraryStructAlias() RefreshableLibraryStructAlias

func (RefreshingSuperStruct) LibraryStructLibraryStruct 

func (r RefreshingSuperStruct) LibraryStructLibraryStruct() RefreshableLibraryStructToLibraryStruct

func (RefreshingSuperStruct) MapSuperStruct 

func (r RefreshingSuperStruct) MapSuperStruct(mapFn func(SuperStruct) interface{}) refreshable.Refreshable

func (RefreshingSuperStruct) NamedLibraryStruct 

func (r RefreshingSuperStruct) NamedLibraryStruct() RefreshableLibraryStruct

func (RefreshingSuperStruct) NamedNestedStruct 

func (r RefreshingSuperStruct) NamedNestedStruct() RefreshableNestedStruct

func (RefreshingSuperStruct) NestedStruct 

func (r RefreshingSuperStruct) NestedStruct() RefreshableNestedStruct

func (RefreshingSuperStruct) NestedStructAlias 

func (r RefreshingSuperStruct) NestedStructAlias() RefreshableNestedStructAlias

func (RefreshingSuperStruct) NestedStructNestedStruct 

func (r RefreshingSuperStruct) NestedStructNestedStruct() RefreshableNestedStructToNestedStruct

func (RefreshingSuperStruct) OptionalDuration 

func (r RefreshingSuperStruct) OptionalDuration() refreshable.DurationPtr

func (RefreshingSuperStruct) OptionalDurationAlias 

func (r RefreshingSuperStruct) OptionalDurationAlias() RefreshableOptionalDurationAlias

func (RefreshingSuperStruct) OptionalInt 

func (r RefreshingSuperStruct) OptionalInt() refreshable.IntPtr

func (RefreshingSuperStruct) OptionalIntAlias 

func (r RefreshingSuperStruct) OptionalIntAlias() RefreshableOptionalIntAlias

func (RefreshingSuperStruct) OptionalLibraryStruct 

func (r RefreshingSuperStruct) OptionalLibraryStruct() RefreshableLibraryStructPtr

func (RefreshingSuperStruct) OptionalLibraryStructAlias 

func (r RefreshingSuperStruct) OptionalLibraryStructAlias() RefreshableOptionalLibraryStructAlias

func (RefreshingSuperStruct) OptionalNestedStruct 

func (r RefreshingSuperStruct) OptionalNestedStruct() RefreshableNestedStructPtr

func (RefreshingSuperStruct) OptionalNestedStructAlias 

func (r RefreshingSuperStruct) OptionalNestedStructAlias() RefreshableOptionalNestedStructAlias

func (RefreshingSuperStruct) OptionalString 

func (r RefreshingSuperStruct) OptionalString() refreshable.StringPtr

func (RefreshingSuperStruct) OptionalStringAlias 

func (r RefreshingSuperStruct) OptionalStringAlias() RefreshableOptionalStringAlias

func (RefreshingSuperStruct) SliceDuration 

func (r RefreshingSuperStruct) SliceDuration() RefreshableDurationSlice

func (RefreshingSuperStruct) SliceInt 

func (r RefreshingSuperStruct) SliceInt() RefreshableIntSlice

func (RefreshingSuperStruct) SliceLibraryStruct 

func (r RefreshingSuperStruct) SliceLibraryStruct() RefreshableLibraryStructSlice

func (RefreshingSuperStruct) SliceNestedStruct 

func (r RefreshingSuperStruct) SliceNestedStruct() RefreshableNestedStructSlice

func (RefreshingSuperStruct) SliceString 

func (r RefreshingSuperStruct) SliceString() refreshable.StringSlice

func (RefreshingSuperStruct) String 

func (r RefreshingSuperStruct) String() refreshable.String

func (RefreshingSuperStruct) StringAlias 

func (r RefreshingSuperStruct) StringAlias() RefreshableStringAlias

func (RefreshingSuperStruct) StringString 

func (r RefreshingSuperStruct) StringString() RefreshableStringToString

func (RefreshingSuperStruct) SubscribeToSuperStruct 

func (r RefreshingSuperStruct) SubscribeToSuperStruct(consumer func(SuperStruct)) (unsubscribe func())

type StringAlias 

type StringAlias string

type SuperStruct 

type SuperStruct struct {
	// Primitives and Variants
	String                    string
	OptionalString            *string
	SliceString               []string
	ArrayString               [8]string
	StringString              map[string]string
	StringAlias               StringAlias
	OptionalStringAlias       OptionalStringAlias
	DoubleOptionalStringAlias *OptionalStringAlias

	Int                    int
	OptionalInt            *int
	SliceInt               []int
	ArrayInt               [8]int
	IntInt                 map[int]int
	IntAlias               IntAlias
	OptionalIntAlias       OptionalIntAlias
	DoubleOptionalIntAlias *OptionalIntAlias

	Duration                    time.Duration
	OptionalDuration            *time.Duration
	SliceDuration               []time.Duration
	ArrayDuration               [8]time.Duration
	DurationDuration            map[time.Duration]time.Duration
	DurationAlias               DurationAlias
	OptionalDurationAlias       OptionalDurationAlias
	DoubleOptionalDurationAlias *OptionalDurationAlias

	// 64 bit numbers
	Int64      int64
	Int64Ptr   *int64
	Float64    float64
	Float64Ptr *float64

	// Local types
	NestedStruct
	NamedNestedStruct         NestedStruct
	OptionalNestedStruct      *NestedStruct
	SliceNestedStruct         []NestedStruct
	ArrayNestedStruct         [8]NestedStruct
	NestedStructNestedStruct  map[NestedStruct]NestedStruct
	NestedStructAlias         NestedStructAlias
	OptionalNestedStructAlias OptionalNestedStructAlias

	// Imported Types
	librarypkg.LibraryStruct
	NamedLibraryStruct         librarypkg.LibraryStruct
	OptionalLibraryStruct      *librarypkg.LibraryStruct
	SliceLibraryStruct         []librarypkg.LibraryStruct
	ArrayLibraryStruct         [8]librarypkg.LibraryStruct
	LibraryStructLibraryStruct map[librarypkg.LibraryStruct]librarypkg.LibraryStruct
	LibraryStructAlias         LibraryStructAlias
	OptionalLibraryStructAlias OptionalLibraryStructAlias
}

Source Files

View all Source files

Directories

Path Synopsis

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.