cog

package

Go to main page

Versions in this module

v1

v1.0.26

Sep 20, 2024

v1.0.25

Aug 16, 2024

v1.0.24

Aug 14, 2024

v1.0.23

Aug 11, 2024

v1.0.22

Jul 27, 2024

Changes in this version

+ type SortIF interface

+ Get func(index int) T

+ Len func() int

+ Swap func(i, j int)

v1.0.21

Jun 30, 2024

v1.0.20

Jun 13, 2024

v1.0.19

Jun 8, 2024

v1.0.18

Jun 3, 2024

v1.0.17

May 22, 2024

v1.0.16

May 8, 2024

v1.0.15

Apr 27, 2024

v1.0.14

Mar 19, 2024

v1.0.13

Feb 19, 2024

Changes in this version

type P

+ func KV[K any, V any](k K, v V) P[K, V]

v1.0.12

Jan 31, 2024

Changes in this version

type ArrayList

+ func (al *ArrayList[T]) ContainIter(it Iterator[T]) bool

+ func (al *ArrayList[T]) DeleteAt(index int)

+ func (al *ArrayList[T]) IndexFunc(f func(T) bool) int

+ func (al *ArrayList[T]) RemoveFunc(f func(T) bool)

+ func (al *ArrayList[T]) RemoveIter(it Iterator[T])

+ func (al *ArrayList[T]) RetainFunc(f func(T) bool)

type Collection

+ ContainIter func(it Iterator[T]) bool

+ RemoveFunc func(f func(T) bool)

+ RemoveIter func(it Iterator[T])

+ RetainFunc func(f func(T) bool)

type HashMap

+ func (hm *HashMap[K, V]) Entries() []P[K, V]

+ func (hm *HashMap[K, V]) MustGet(key K, defaults ...V) V

+ func (hm *HashMap[K, V]) SetEntries(pairs ...P[K, V])

type HashSet

+ func (hs *HashSet[T]) ContainIter(it Iterator[T]) bool

+ func (hs *HashSet[T]) RemoveFunc(f func(T) bool)

+ func (hs *HashSet[T]) RemoveIter(it Iterator[T])

+ func (hs *HashSet[T]) RetainFunc(f func(T) bool)

type LinkedHashMap

+ func (lm *LinkedHashMap[K, V]) Entries() []P[K, V]

+ func (lm *LinkedHashMap[K, V]) MustGet(key K, defaults ...V) V

+ func (lm *LinkedHashMap[K, V]) SetEntries(pairs ...P[K, V])

type LinkedHashSet

+ func (ls *LinkedHashSet[T]) ContainIter(it Iterator[T]) bool

+ func (ls *LinkedHashSet[T]) DeleteAt(index int)

+ func (ls *LinkedHashSet[T]) RemoveFunc(f func(T) bool)

+ func (ls *LinkedHashSet[T]) RemoveIter(it Iterator[T])

+ func (ls *LinkedHashSet[T]) RetainFunc(f func(T) bool)

type LinkedList

+ func (ll *LinkedList[T]) ContainIter(it Iterator[T]) bool

+ func (ll *LinkedList[T]) DeleteAt(index int)

+ func (ll *LinkedList[T]) IndexFunc(f func(T) bool) int

+ func (ll *LinkedList[T]) RemoveFunc(f func(T) bool)

+ func (ll *LinkedList[T]) RemoveIter(it Iterator[T])

+ func (ll *LinkedList[T]) RetainFunc(f func(T) bool)

type List

+ DeleteAt func(index int)

+ IndexFunc func(f func(T) bool) int

type Map

+ Entries func() []P[K, V]

+ MustGet func(key K, defaults ...V) V

+ SetEntries func(pairs ...P[K, V])

type P

+ func (p *P[K, V]) String() string

type RingBuffer

+ func (rb *RingBuffer[T]) ContainIter(it Iterator[T]) bool

+ func (rb *RingBuffer[T]) DeleteAt(index int)

+ func (rb *RingBuffer[T]) IndexFunc(f func(T) bool) int

+ func (rb *RingBuffer[T]) RemoveFunc(f func(T) bool)

+ func (rb *RingBuffer[T]) RemoveIter(it Iterator[T])

+ func (rb *RingBuffer[T]) RetainFunc(f func(T) bool)

type TreeMap

+ func (tm *TreeMap[K, V]) Entries() []P[K, V]

+ func (tm *TreeMap[K, V]) MustGet(key K, defaults ...V) V

+ func (tm *TreeMap[K, V]) SetEntries(pairs ...P[K, V])

type TreeSet

+ func (ts *TreeSet[T]) ContainIter(it Iterator[T]) bool

+ func (ts *TreeSet[T]) RemoveFunc(f func(T) bool)

+ func (ts *TreeSet[T]) RemoveIter(it Iterator[T])

+ func (ts *TreeSet[T]) RetainFunc(f func(T) bool)

v1.0.11

Nov 6, 2023

Changes in this version

+ func CompareStringFold(a, b string) int

+ func LessStringFold(a, b string) bool

v1.0.10

Oct 8, 2023

Changes in this version

+ func CopyMap(dst, src Map[K, V])

type ArrayList

+ func (al *ArrayList[T]) AddCol(ac Collection[T])

+ func (al *ArrayList[T]) Adds(vs ...T)

+ func (al *ArrayList[T]) Contain(v T) bool

+ func (al *ArrayList[T]) ContainCol(ac Collection[T]) bool

+ func (al *ArrayList[T]) InsertCol(index int, ac Collection[T])

+ func (al *ArrayList[T]) Inserts(index int, vs ...T)

+ func (al *ArrayList[T]) PushHeadCol(ac Collection[T])

+ func (al *ArrayList[T]) PushHeads(vs ...T)

+ func (al *ArrayList[T]) PushTailCol(ac Collection[T])

+ func (al *ArrayList[T]) PushTails(vs ...T)

+ func (al *ArrayList[T]) Pushs(vs ...T)

+ func (al *ArrayList[T]) RemoveAt(index int)

+ func (al *ArrayList[T]) RemoveCol(ac Collection[T])

+ func (al *ArrayList[T]) RemoveIf(f func(T) bool)

+ func (al *ArrayList[T]) Removes(vs ...T)

+ func (al *ArrayList[T]) RetainCol(ac Collection[T])

+ func (al *ArrayList[T]) Retains(vs ...T)

type Collection

+ AddCol func(ac Collection[T])

+ Adds func(vs ...T)

+ Contain func(v T) bool

+ ContainCol func(ac Collection[T]) bool

+ Remove func(v T)

+ RemoveCol func(ac Collection[T])

+ RemoveIf func(f func(T) bool)

+ Removes func(vs ...T)

+ RetainCol func(ac Collection[T])

+ Retains func(vs ...T)

type Deque

+ PushHeads func(vs ...T)

+ PushTails func(vs ...T)

type HashMap

+ func (hm *HashMap[K, V]) Contain(k K) bool

+ func (hm *HashMap[K, V]) Copy(am Map[K, V])

+ func (hm *HashMap[K, V]) Remove(k K) (ov V, ok bool)

+ func (hm *HashMap[K, V]) Removes(ks ...K)

type HashSet

+ func (hs *HashSet[T]) AddCol(ac Collection[T])

+ func (hs *HashSet[T]) Adds(vs ...T)

+ func (hs *HashSet[T]) Contain(v T) bool

+ func (hs *HashSet[T]) ContainCol(ac Collection[T]) bool

+ func (hs *HashSet[T]) Remove(v T)

+ func (hs *HashSet[T]) RemoveCol(ac Collection[T])

+ func (hs *HashSet[T]) RemoveIf(f func(T) bool)

+ func (hs *HashSet[T]) Removes(vs ...T)

+ func (hs *HashSet[T]) RetainCol(ac Collection[T])

+ func (hs *HashSet[T]) Retains(vs ...T)

type LinkedHashMap

+ func (lm *LinkedHashMap[K, V]) Contain(k K) bool

+ func (lm *LinkedHashMap[K, V]) Copy(am Map[K, V])

+ func (lm *LinkedHashMap[K, V]) Remove(k K) (ov V, ok bool)

+ func (lm *LinkedHashMap[K, V]) Removes(ks ...K)

type LinkedHashSet

+ func (ls *LinkedHashSet[T]) AddCol(ac Collection[T])

+ func (ls *LinkedHashSet[T]) Adds(vs ...T)

+ func (ls *LinkedHashSet[T]) Contain(v T) bool

+ func (ls *LinkedHashSet[T]) ContainCol(ac Collection[T]) bool

+ func (ls *LinkedHashSet[T]) InsertCol(index int, ac Collection[T])

+ func (ls *LinkedHashSet[T]) Inserts(index int, vs ...T)

+ func (ls *LinkedHashSet[T]) PushHeadCol(ac Collection[T])

+ func (ls *LinkedHashSet[T]) PushHeads(vs ...T)

+ func (ls *LinkedHashSet[T]) PushTailCol(ac Collection[T])

+ func (ls *LinkedHashSet[T]) PushTails(vs ...T)

+ func (ls *LinkedHashSet[T]) Pushs(vs ...T)

+ func (ls *LinkedHashSet[T]) RemoveAt(index int)

+ func (ls *LinkedHashSet[T]) RemoveCol(ac Collection[T])

+ func (ls *LinkedHashSet[T]) RemoveIf(f func(T) bool)

+ func (ls *LinkedHashSet[T]) Removes(vs ...T)

+ func (ls *LinkedHashSet[T]) RetainCol(ac Collection[T])

+ func (ls *LinkedHashSet[T]) Retains(vs ...T)

type LinkedList

+ func (ll *LinkedList[T]) AddCol(ac Collection[T])

+ func (ll *LinkedList[T]) Adds(vs ...T)

+ func (ll *LinkedList[T]) Contain(v T) bool

+ func (ll *LinkedList[T]) ContainCol(ac Collection[T]) bool

+ func (ll *LinkedList[T]) InsertCol(index int, ac Collection[T])

+ func (ll *LinkedList[T]) Inserts(index int, vs ...T)

+ func (ll *LinkedList[T]) PushHeadCol(ac Collection[T])

+ func (ll *LinkedList[T]) PushHeads(vs ...T)

+ func (ll *LinkedList[T]) PushTailCol(ac Collection[T])

+ func (ll *LinkedList[T]) PushTails(vs ...T)

+ func (ll *LinkedList[T]) Pushs(vs ...T)

+ func (ll *LinkedList[T]) RemoveAt(index int)

+ func (ll *LinkedList[T]) RemoveCol(ac Collection[T])

+ func (ll *LinkedList[T]) RemoveIf(f func(T) bool)

+ func (ll *LinkedList[T]) Removes(vs ...T)

+ func (ll *LinkedList[T]) RetainCol(ac Collection[T])

+ func (ll *LinkedList[T]) Retains(vs ...T)

type List

+ InsertCol func(index int, ac Collection[T])

+ Inserts func(index int, vs ...T)

+ RemoveAt func(index int)

type Map

+ Contain func(k K) bool

+ Copy func(am Map[K, V])

+ Remove func(k K) (ov V, ok bool)

+ Removes func(ks ...K)

type Queue

+ Pushs func(vs ...T)

type RingBuffer

+ func (rb *RingBuffer[T]) AddCol(ac Collection[T])

+ func (rb *RingBuffer[T]) Adds(vs ...T)

+ func (rb *RingBuffer[T]) Contain(v T) bool

+ func (rb *RingBuffer[T]) ContainCol(ac Collection[T]) bool

+ func (rb *RingBuffer[T]) InsertCol(index int, ac Collection[T])

+ func (rb *RingBuffer[T]) Inserts(index int, vs ...T)

+ func (rb *RingBuffer[T]) PushHeadCol(ac Collection[T])

+ func (rb *RingBuffer[T]) PushHeads(vs ...T)

+ func (rb *RingBuffer[T]) PushTailCol(ac Collection[T])

+ func (rb *RingBuffer[T]) PushTails(vs ...T)

+ func (rb *RingBuffer[T]) Pushs(vs ...T)

+ func (rb *RingBuffer[T]) RemoveAt(index int)

+ func (rb *RingBuffer[T]) RemoveCol(ac Collection[T])

+ func (rb *RingBuffer[T]) RemoveIf(f func(T) bool)

+ func (rb *RingBuffer[T]) Removes(vs ...T)

+ func (rb *RingBuffer[T]) RetainCol(ac Collection[T])

+ func (rb *RingBuffer[T]) Retains(vs ...T)

type TreeMap

+ func (tm *TreeMap[K, V]) Contain(k K) bool

+ func (tm *TreeMap[K, V]) Copy(am Map[K, V])

+ func (tm *TreeMap[K, V]) Remove(k K) (ov V, ok bool)

+ func (tm *TreeMap[K, V]) Removes(ks ...K)

type TreeSet

+ func (ts *TreeSet[T]) AddCol(ac Collection[T])

+ func (ts *TreeSet[T]) Adds(vs ...T)

+ func (ts *TreeSet[T]) Contain(v T) bool

+ func (ts *TreeSet[T]) ContainCol(ac Collection[T]) bool

+ func (ts *TreeSet[T]) Remove(v T)

+ func (ts *TreeSet[T]) RemoveCol(ac Collection[T])

+ func (ts *TreeSet[T]) RemoveIf(f func(T) bool)

+ func (ts *TreeSet[T]) Removes(vs ...T)

+ func (ts *TreeSet[T]) RetainCol(ac Collection[T])

+ func (ts *TreeSet[T]) Retains(vs ...T)

v1.0.9

Jul 19, 2023

v1.0.8

Apr 23, 2023

Changes in this version

+ func CompareByte(a, b byte) int

+ func CompareFloat32(a, b float32) int

+ func CompareFloat64(a, b float64) int

+ func CompareInt(a, b int) int

+ func CompareInt16(a, b int16) int

+ func CompareInt32(a, b int32) int

+ func CompareInt64(a, b int64) int

+ func CompareInt8(a, b int8) int

+ func CompareRune(a, b rune) int

+ func CompareString(a, b string) int

+ func CompareUInt(a, b uint) int

+ func CompareUInt16(a, b uint16) int

+ func CompareUInt32(a, b uint32) int

+ func CompareUInt64(a, b uint64) int

+ func CompareUInt8(a, b uint8) int

+ func LessByte(a, b byte) bool

+ func LessFloat32(a, b float32) bool

+ func LessFloat64(a, b float64) bool

+ func LessInt(a, b int) bool

+ func LessInt16(a, b int16) bool

+ func LessInt32(a, b int32) bool

+ func LessInt64(a, b int64) bool

+ func LessInt8(a, b int8) bool

+ func LessRune(a, b rune) bool

+ func LessString(a, b string) bool

+ func LessUint(a, b uint) bool

+ func LessUint16(a, b uint16) bool

+ func LessUint32(a, b uint32) bool

+ func LessUint64(a, b uint64) bool

+ func LessUint8(a, b uint8) bool

+ type ArrayList struct

+ func AsArrayList(vs []T) *ArrayList[T]

+ func NewArrayList(vs ...T) *ArrayList[T]

+ func (al *ArrayList[T]) Add(vs ...T)

+ func (al *ArrayList[T]) AddAll(ac Collection[T])

+ func (al *ArrayList[T]) Cap() int

+ func (al *ArrayList[T]) Clear()

+ func (al *ArrayList[T]) Contains(vs ...T) bool

+ func (al *ArrayList[T]) ContainsAll(ac Collection[T]) bool

+ func (al *ArrayList[T]) Delete(vs ...T)

+ func (al *ArrayList[T]) DeleteAll(ac Collection[T])

+ func (al *ArrayList[T]) DeleteIf(f func(T) bool)

+ func (al *ArrayList[T]) Each(f func(T))

+ func (al *ArrayList[T]) Get(index int) T

+ func (al *ArrayList[T]) Head() (v T)

+ func (al *ArrayList[T]) Index(v T) int

+ func (al *ArrayList[T]) IndexIf(f func(T) bool) int

+ func (al *ArrayList[T]) Insert(index int, vs ...T)

+ func (al *ArrayList[T]) InsertAll(index int, ac Collection[T])

+ func (al *ArrayList[T]) IsEmpty() bool

+ func (al *ArrayList[T]) Iterator() Iterator[T]

+ func (al *ArrayList[T]) Len() int

+ func (al *ArrayList[T]) MarshalJSON() ([]byte, error)

+ func (al *ArrayList[T]) Peek() (v T, ok bool)

+ func (al *ArrayList[T]) PeekHead() (v T, ok bool)

+ func (al *ArrayList[T]) PeekTail() (v T, ok bool)

+ func (al *ArrayList[T]) Poll() (T, bool)

+ func (al *ArrayList[T]) PollHead() (v T, ok bool)

+ func (al *ArrayList[T]) PollTail() (v T, ok bool)

+ func (al *ArrayList[T]) Push(vs ...T)

+ func (al *ArrayList[T]) PushHead(vs ...T)

+ func (al *ArrayList[T]) PushHeadAll(ac Collection[T])

+ func (al *ArrayList[T]) PushTail(vs ...T)

+ func (al *ArrayList[T]) PushTailAll(ac Collection[T])

+ func (al *ArrayList[T]) Remove(index int)

+ func (al *ArrayList[T]) Reserve(n int)

+ func (al *ArrayList[T]) Retain(vs ...T)

+ func (al *ArrayList[T]) RetainAll(ac Collection[T])

+ func (al *ArrayList[T]) ReverseEach(f func(T))

+ func (al *ArrayList[T]) Set(index int, v T) (ov T)

+ func (al *ArrayList[T]) Sort(less Less[T])

+ func (al *ArrayList[T]) String() string

+ func (al *ArrayList[T]) Swap(i, j int)

+ func (al *ArrayList[T]) Tail() (v T)

+ func (al *ArrayList[T]) UnmarshalJSON(data []byte) error

+ func (al *ArrayList[T]) Values() []T

+ type Collection interface

+ Add func(vs ...T)

+ AddAll func(ac Collection[T])

+ Contains func(vs ...T) bool

+ ContainsAll func(ac Collection[T]) bool

+ Delete func(vs ...T)

+ DeleteAll func(ac Collection[T])

+ DeleteIf func(f func(T) bool)

+ Retain func(vs ...T)

+ RetainAll func(ac Collection[T])

+ Values func() []T

+ type Compare func(a, b T) int

+ type Container interface

+ Clear func()

+ IsEmpty func() bool

+ Len func() int

+ type Deque interface

+ PeekHead func() (T, bool)

+ PeekTail func() (T, bool)

+ PollHead func() (T, bool)

+ PollTail func() (T, bool)

+ PushHead func(vs ...T)

+ PushTail func(vs ...T)

+ type Eachable interface

+ Each func(f func(value T))

+ type Eachable2 interface

+ Each func(f func(key K, value V))

+ type HashMap struct

+ func AsHashMap(m map[K]V) *HashMap[K, V]

+ func NewHashMap(kvs ...P[K, V]) *HashMap[K, V]

+ func (hm *HashMap[K, V]) Clear()

+ func (hm *HashMap[K, V]) Contains(ks ...K) bool

+ func (hm *HashMap[K, V]) Delete(ks ...K) (ov V, ok bool)

+ func (hm *HashMap[K, V]) Each(f func(k K, v V))

+ func (hm *HashMap[K, V]) Get(key K) (v V, ok bool)

+ func (hm *HashMap[K, V]) HashMap() map[K]V

+ func (hm *HashMap[K, V]) IsEmpty() bool

+ func (hm *HashMap[K, V]) Keys() []K

+ func (hm *HashMap[K, V]) Len() int

+ func (hm *HashMap[K, V]) MarshalJSON() ([]byte, error)

+ func (hm *HashMap[K, V]) Set(key K, value V) (ov V, ok bool)

+ func (hm *HashMap[K, V]) SetAll(am Map[K, V])

+ func (hm *HashMap[K, V]) SetIfAbsent(key K, value V) (ov V, ok bool)

+ func (hm *HashMap[K, V]) SetPairs(pairs ...P[K, V])

+ func (hm *HashMap[K, V]) String() string

+ func (hm *HashMap[K, V]) UnmarshalJSON(data []byte) error

+ func (hm *HashMap[K, V]) Values() []V

+ type HashSet struct

+ func NewHashSet(vs ...T) *HashSet[T]

+ func (hs *HashSet[T]) Add(vs ...T)

+ func (hs *HashSet[T]) AddAll(ac Collection[T])

+ func (hs *HashSet[T]) Clear()

+ func (hs *HashSet[T]) Contains(vs ...T) bool

+ func (hs *HashSet[T]) ContainsAll(ac Collection[T]) bool

+ func (hs *HashSet[T]) Delete(vs ...T)

+ func (hs *HashSet[T]) DeleteAll(ac Collection[T])

+ func (hs *HashSet[T]) DeleteIf(f func(T) bool)

+ func (hs *HashSet[T]) Difference(a *HashSet[T]) *HashSet[T]

+ func (hs *HashSet[T]) Each(f func(T))

+ func (hs *HashSet[T]) Intersection(a *HashSet[T]) *HashSet[T]

+ func (hs *HashSet[T]) IsEmpty() bool

+ func (hs *HashSet[T]) Len() int

+ func (hs *HashSet[T]) MarshalJSON() ([]byte, error)

+ func (hs *HashSet[T]) Retain(vs ...T)

+ func (hs *HashSet[T]) RetainAll(ac Collection[T])

+ func (hs *HashSet[T]) String() string

+ func (hs *HashSet[T]) UnmarshalJSON(data []byte) error

+ func (hs *HashSet[T]) Values() []T

+ type Iterable interface

+ Iterator func() Iterator[T]

+ type Iterable2 interface

+ Iterator func() Iterator2[K, V]

+ type IterableMap interface

+ type Iterator interface

+ Next func() bool

+ Prev func() bool

+ Remove func()

+ Reset func()

+ SetValue func(v T)

+ Value func() T

+ type Iterator2 interface

+ Key func() K

+ type Less func(a, b T) bool

+ type LinkedHashMap struct

+ func NewLinkedHashMap(kvs ...P[K, V]) *LinkedHashMap[K, V]

+ func (lm *LinkedHashMap[K, V]) Clear()

+ func (lm *LinkedHashMap[K, V]) Contains(ks ...K) bool

+ func (lm *LinkedHashMap[K, V]) Delete(ks ...K) (ov V, ok bool)

+ func (lm *LinkedHashMap[K, V]) Each(f func(k K, v V))

+ func (lm *LinkedHashMap[K, V]) Get(key K) (V, bool)

+ func (lm *LinkedHashMap[K, V]) Head() *LinkedMapNode[K, V]

+ func (lm *LinkedHashMap[K, V]) IsEmpty() bool

+ func (lm *LinkedHashMap[K, V]) Items() []*LinkedMapNode[K, V]

+ func (lm *LinkedHashMap[K, V]) Iterator() Iterator2[K, V]

+ func (lm *LinkedHashMap[K, V]) IteratorOf(k K) Iterator2[K, V]

+ func (lm *LinkedHashMap[K, V]) Keys() []K

+ func (lm *LinkedHashMap[K, V]) Len() int

+ func (lm *LinkedHashMap[K, V]) MarshalJSON() ([]byte, error)

+ func (lm *LinkedHashMap[K, V]) PollHead() *LinkedMapNode[K, V]

+ func (lm *LinkedHashMap[K, V]) PollTail() *LinkedMapNode[K, V]

+ func (lm *LinkedHashMap[K, V]) ReverseEach(f func(k K, v V))

+ func (lm *LinkedHashMap[K, V]) Set(key K, value V) (ov V, ok bool)

+ func (lm *LinkedHashMap[K, V]) SetAll(am Map[K, V])

+ func (lm *LinkedHashMap[K, V]) SetIfAbsent(key K, value V) (ov V, ok bool)

+ func (lm *LinkedHashMap[K, V]) SetPairs(pairs ...P[K, V])

+ func (lm *LinkedHashMap[K, V]) String() string

+ func (lm *LinkedHashMap[K, V]) Tail() *LinkedMapNode[K, V]

+ func (lm *LinkedHashMap[K, V]) UnmarshalJSON(data []byte) error

+ func (lm *LinkedHashMap[K, V]) Values() []V

+ type LinkedHashSet struct

+ func NewLinkedHashSet(vs ...T) *LinkedHashSet[T]

+ func (ls *LinkedHashSet[T]) Add(vs ...T)

+ func (ls *LinkedHashSet[T]) AddAll(ac Collection[T])

+ func (ls *LinkedHashSet[T]) Clear()

+ func (ls *LinkedHashSet[T]) Contains(vs ...T) bool

+ func (ls *LinkedHashSet[T]) ContainsAll(ac Collection[T]) bool

+ func (ls *LinkedHashSet[T]) Delete(vs ...T)

+ func (ls *LinkedHashSet[T]) DeleteAll(ac Collection[T])

+ func (ls *LinkedHashSet[T]) DeleteIf(f func(T) bool)

+ func (ls *LinkedHashSet[T]) Each(f func(T))

+ func (ls *LinkedHashSet[T]) Get(index int) T

+ func (ls *LinkedHashSet[T]) Head() (v T)

+ func (ls *LinkedHashSet[T]) Index(v T) int

+ func (ls *LinkedHashSet[T]) Insert(index int, vs ...T)

+ func (ls *LinkedHashSet[T]) InsertAll(index int, ac Collection[T])

+ func (ls *LinkedHashSet[T]) IsEmpty() bool

+ func (ls *LinkedHashSet[T]) Iterator() Iterator[T]

+ func (ls *LinkedHashSet[T]) Len() int

+ func (ls *LinkedHashSet[T]) MarshalJSON() ([]byte, error)

+ func (ls *LinkedHashSet[T]) Peek() (v T, ok bool)

+ func (ls *LinkedHashSet[T]) PeekHead() (v T, ok bool)

+ func (ls *LinkedHashSet[T]) PeekTail() (v T, ok bool)

+ func (ls *LinkedHashSet[T]) Poll() (T, bool)

+ func (ls *LinkedHashSet[T]) PollHead() (v T, ok bool)

+ func (ls *LinkedHashSet[T]) PollTail() (v T, ok bool)

+ func (ls *LinkedHashSet[T]) Push(vs ...T)

+ func (ls *LinkedHashSet[T]) PushHead(vs ...T)

+ func (ls *LinkedHashSet[T]) PushHeadAll(ac Collection[T])

+ func (ls *LinkedHashSet[T]) PushTail(vs ...T)

+ func (ls *LinkedHashSet[T]) PushTailAll(ac Collection[T])

+ func (ls *LinkedHashSet[T]) Remove(index int)

+ func (ls *LinkedHashSet[T]) Retain(vs ...T)

+ func (ls *LinkedHashSet[T]) RetainAll(ac Collection[T])

+ func (ls *LinkedHashSet[T]) ReverseEach(f func(T))

+ func (ls *LinkedHashSet[T]) Set(index int, v T) (ov T)

+ func (ls *LinkedHashSet[T]) Sort(less Less[T])

+ func (ls *LinkedHashSet[T]) String() string

+ func (ls *LinkedHashSet[T]) Swap(i, j int)

+ func (ls *LinkedHashSet[T]) Tail() (v T)

+ func (ls *LinkedHashSet[T]) UnmarshalJSON(data []byte) error

+ func (ls *LinkedHashSet[T]) Values() []T

+ type LinkedList struct

+ func NewLinkedList(vs ...T) *LinkedList[T]

+ func (ll *LinkedList[T]) Add(vs ...T)

+ func (ll *LinkedList[T]) AddAll(ac Collection[T])

+ func (ll *LinkedList[T]) Clear()

+ func (ll *LinkedList[T]) Contains(vs ...T) bool

+ func (ll *LinkedList[T]) ContainsAll(ac Collection[T]) bool

+ func (ll *LinkedList[T]) Delete(vs ...T)

+ func (ll *LinkedList[T]) DeleteAll(ac Collection[T])

+ func (ll *LinkedList[T]) DeleteIf(f func(T) bool)

+ func (ll *LinkedList[T]) Each(f func(T))

+ func (ll *LinkedList[T]) Get(index int) T

+ func (ll *LinkedList[T]) Head() (v T)

+ func (ll *LinkedList[T]) Index(v T) int

+ func (ll *LinkedList[T]) IndexIf(f func(T) bool) int

+ func (ll *LinkedList[T]) Insert(index int, vs ...T)

+ func (ll *LinkedList[T]) InsertAll(index int, ac Collection[T])

+ func (ll *LinkedList[T]) IsEmpty() bool

+ func (ll *LinkedList[T]) Iterator() Iterator[T]

+ func (ll *LinkedList[T]) LastIndex(v T) int

+ func (ll *LinkedList[T]) Len() int

+ func (ll *LinkedList[T]) MarshalJSON() ([]byte, error)

+ func (ll *LinkedList[T]) Peek() (v T, ok bool)

+ func (ll *LinkedList[T]) PeekHead() (v T, ok bool)

+ func (ll *LinkedList[T]) PeekTail() (v T, ok bool)

+ func (ll *LinkedList[T]) Poll() (T, bool)

+ func (ll *LinkedList[T]) PollHead() (v T, ok bool)

+ func (ll *LinkedList[T]) PollTail() (v T, ok bool)

+ func (ll *LinkedList[T]) Push(vs ...T)

+ func (ll *LinkedList[T]) PushHead(vs ...T)

+ func (ll *LinkedList[T]) PushHeadAll(ac Collection[T])

+ func (ll *LinkedList[T]) PushTail(vs ...T)

+ func (ll *LinkedList[T]) PushTailAll(ac Collection[T])

+ func (ll *LinkedList[T]) Remove(index int)

+ func (ll *LinkedList[T]) Retain(vs ...T)

+ func (ll *LinkedList[T]) RetainAll(ac Collection[T])

+ func (ll *LinkedList[T]) ReverseEach(f func(T))

+ func (ll *LinkedList[T]) Set(index int, v T) (ov T)

+ func (ll *LinkedList[T]) Sort(less Less[T])

+ func (ll *LinkedList[T]) String() string

+ func (ll *LinkedList[T]) Swap(i, j int)

+ func (ll *LinkedList[T]) Tail() (v T)

+ func (ll *LinkedList[T]) UnmarshalJSON(data []byte) error

+ func (ll *LinkedList[T]) Values() []T

+ type LinkedMapNode struct

+ func (ln *LinkedMapNode[K, V]) Key() K

+ func (ln *LinkedMapNode[K, V]) SetValue(v V)

+ func (ln *LinkedMapNode[K, V]) String() string

+ func (ln *LinkedMapNode[K, V]) Value() V

+ type List interface

+ Get func(index int) T

+ Index func(v T) int

+ IndexIf func(f func(T) bool) int

+ Insert func(index int, vs ...T)

+ InsertAll func(index int, ac Collection[T])

+ Remove func(index int)

+ Set func(index int, v T) T

+ Swap func(i, j int)

+ type Map interface

+ Contains func(ks ...K) bool

+ Delete func(ks ...K) (ov V, ok bool)

+ Get func(key K) (V, bool)

+ Keys func() []K

+ Set func(key K, value V) (ov V, ok bool)

+ SetAll func(am Map[K, V])

+ SetIfAbsent func(key K, value V) (ov V, ok bool)

+ SetPairs func(pairs ...P[K, V])

+ Values func() []V

+ type P struct

+ Key K

+ Value V

+ type Queue interface

+ Peek func() (T, bool)

+ Poll func() (T, bool)

+ Push func(vs ...T)

+ type ReverseEachable interface

+ ReverseEach func(f func(value T))

+ type ReverseEachable2 interface

+ ReverseEach func(f func(key K, value V))

+ type RingBuffer struct

+ func NewRingBuffer(vs ...T) *RingBuffer[T]

+ func (rb *RingBuffer[T]) Add(vs ...T)

+ func (rb *RingBuffer[T]) AddAll(ac Collection[T])

+ func (rb *RingBuffer[T]) Cap() int

+ func (rb *RingBuffer[T]) Clear()

+ func (rb *RingBuffer[T]) Contains(vs ...T) bool

+ func (rb *RingBuffer[T]) ContainsAll(ac Collection[T]) bool

+ func (rb *RingBuffer[T]) Delete(vs ...T)

+ func (rb *RingBuffer[T]) DeleteAll(ac Collection[T])

+ func (rb *RingBuffer[T]) DeleteIf(f func(T) bool)

+ func (rb *RingBuffer[T]) Each(f func(T))

+ func (rb *RingBuffer[T]) Get(index int) T

+ func (rb *RingBuffer[T]) Head() (v T)

+ func (rb *RingBuffer[T]) Index(v T) int

+ func (rb *RingBuffer[T]) IndexIf(f func(T) bool) int

+ func (rb *RingBuffer[T]) Insert(index int, vs ...T)

+ func (rb *RingBuffer[T]) InsertAll(index int, ac Collection[T])

+ func (rb *RingBuffer[T]) IsEmpty() bool

+ func (rb *RingBuffer[T]) Iterator() Iterator[T]

+ func (rb *RingBuffer[T]) Len() int

+ func (rb *RingBuffer[T]) MarshalJSON() ([]byte, error)

+ func (rb *RingBuffer[T]) MustPeek() T

+ func (rb *RingBuffer[T]) MustPoll() T

+ func (rb *RingBuffer[T]) Peek() (v T, ok bool)

+ func (rb *RingBuffer[T]) PeekHead() (v T, ok bool)

+ func (rb *RingBuffer[T]) PeekTail() (v T, ok bool)

+ func (rb *RingBuffer[T]) Poll() (T, bool)

+ func (rb *RingBuffer[T]) PollHead() (v T, ok bool)

+ func (rb *RingBuffer[T]) PollTail() (v T, ok bool)

+ func (rb *RingBuffer[T]) Push(vs ...T)

+ func (rb *RingBuffer[T]) PushHead(vs ...T)

+ func (rb *RingBuffer[T]) PushHeadAll(ac Collection[T])

+ func (rb *RingBuffer[T]) PushTail(vs ...T)

+ func (rb *RingBuffer[T]) PushTailAll(ac Collection[T])

+ func (rb *RingBuffer[T]) Remove(index int)

+ func (rb *RingBuffer[T]) Retain(vs ...T)

+ func (rb *RingBuffer[T]) RetainAll(ac Collection[T])

+ func (rb *RingBuffer[T]) ReverseEach(f func(T))

+ func (rb *RingBuffer[T]) Set(index int, v T) (ov T)

+ func (rb *RingBuffer[T]) Sort(less Less[T])

+ func (rb *RingBuffer[T]) String() string

+ func (rb *RingBuffer[T]) Swap(i, j int)

+ func (rb *RingBuffer[T]) Tail() (v T)

+ func (rb *RingBuffer[T]) UnmarshalJSON(data []byte) error

+ func (rb *RingBuffer[T]) Values() []T

+ type S interface

+ type Set Collection[T]

+ type Sortable interface

+ Sort func(less Less[T])

+ type TreeMap struct

+ func NewTreeMap(compare Compare[K], kvs ...P[K, V]) *TreeMap[K, V]

+ func (tm *TreeMap[K, V]) Ceiling(key K) *TreeMapNode[K, V]

+ func (tm *TreeMap[K, V]) Clear()

+ func (tm *TreeMap[K, V]) Contains(ks ...K) bool

+ func (tm *TreeMap[K, V]) Delete(ks ...K) (ov V, ok bool)

+ func (tm *TreeMap[K, V]) Each(f func(k K, v V))

+ func (tm *TreeMap[K, V]) Floor(key K) *TreeMapNode[K, V]

+ func (tm *TreeMap[K, V]) Get(key K) (V, bool)

+ func (tm *TreeMap[K, V]) Graph(value bool) string

+ func (tm *TreeMap[K, V]) Head() *TreeMapNode[K, V]

+ func (tm *TreeMap[K, V]) IsEmpty() bool

+ func (tm *TreeMap[K, V]) Items() []*TreeMapNode[K, V]

+ func (tm *TreeMap[K, V]) Iterator() Iterator2[K, V]

+ func (tm *TreeMap[K, V]) Keys() []K

+ func (tm *TreeMap[K, V]) Len() int

+ func (tm *TreeMap[K, V]) MarshalJSON() ([]byte, error)

+ func (tm *TreeMap[K, V]) PollHead() *TreeMapNode[K, V]

+ func (tm *TreeMap[K, V]) PollTail() *TreeMapNode[K, V]

+ func (tm *TreeMap[K, V]) ReverseEach(f func(k K, v V))

+ func (tm *TreeMap[K, V]) Set(key K, value V) (ov V, ok bool)

+ func (tm *TreeMap[K, V]) SetAll(am Map[K, V])

+ func (tm *TreeMap[K, V]) SetIfAbsent(key K, value V) (ov V, ok bool)

+ func (tm *TreeMap[K, V]) SetPairs(pairs ...P[K, V])

+ func (tm *TreeMap[K, V]) String() string

+ func (tm *TreeMap[K, V]) Tail() *TreeMapNode[K, V]

+ func (tm *TreeMap[K, V]) UnmarshalJSON(data []byte) error

+ func (tm *TreeMap[K, V]) Values() []V

+ type TreeMapNode struct

+ func (tn *TreeMapNode[K, V]) Key() K

+ func (tn *TreeMapNode[K, V]) SetValue(v V)

+ func (tn *TreeMapNode[K, V]) String() string

+ func (tn *TreeMapNode[K, V]) Value() V

+ type TreeSet struct

+ func NewTreeSet(compare Compare[T], vs ...T) *TreeSet[T]

+ func (ts *TreeSet[T]) Add(vs ...T)

+ func (ts *TreeSet[T]) AddAll(ac Collection[T])

+ func (ts *TreeSet[T]) Ceiling(v T) *T

+ func (ts *TreeSet[T]) Clear()

+ func (ts *TreeSet[T]) Contains(vs ...T) bool

+ func (ts *TreeSet[T]) ContainsAll(ac Collection[T]) bool

+ func (ts *TreeSet[T]) Delete(vs ...T)

+ func (ts *TreeSet[T]) DeleteAll(ac Collection[T])

+ func (ts *TreeSet[T]) DeleteIf(f func(T) bool)

+ func (ts *TreeSet[T]) Each(f func(v T))

+ func (ts *TreeSet[T]) Floor(v T) *T

+ func (ts *TreeSet[T]) Graph() string

+ func (ts *TreeSet[T]) Head() (v T)

+ func (ts *TreeSet[T]) IsEmpty() bool

+ func (ts *TreeSet[T]) Iterator() Iterator[T]

+ func (ts *TreeSet[T]) Len() int

+ func (ts *TreeSet[T]) MarshalJSON() ([]byte, error)

+ func (ts *TreeSet[T]) PeekHead() (v T, ok bool)

+ func (ts *TreeSet[T]) PeekTail() (v T, ok bool)

+ func (ts *TreeSet[T]) PollHead() (v T, ok bool)

+ func (ts *TreeSet[T]) PollTail() (v T, ok bool)

+ func (ts *TreeSet[T]) Retain(vs ...T)

+ func (ts *TreeSet[T]) RetainAll(ac Collection[T])

+ func (ts *TreeSet[T]) ReverseEach(f func(v T))

+ func (ts *TreeSet[T]) String() string

+ func (ts *TreeSet[T]) Tail() (v T)

+ func (ts *TreeSet[T]) UnmarshalJSON(data []byte) error

+ func (ts *TreeSet[T]) Values() []T

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL