zarray

Documentation

Overview

Package zarray provides array operations

Index

• Variables
• func Contains[T comparable](collection []T, v T) bool
• func Diff[T comparable](list1 []T, list2 []T) ([]T, []T)
• func Filter[T any](slice []T, predicate func(index int, item T) bool) []T
• func Find[T any](collection []T, predicate func(index int, item T) bool) (T, bool)
• func GetInf(arr []interface{}, index int, def ...interface{}) (value interface{}, err error)
• func Keys[K comparable, V any](in map[K]V) []K
• func Map[T any, R any](collection []T, iteratee func(int, T) R) []R
• func Rand[T any](collection []T) T
• func Shuffle[T any](collection []T) []T
• func Unique[T comparable](collection []T) []T
• func Values[K comparable, V any](in map[K]V) []V
• type Array
  • func Copy(arr interface{}) (array *Array, err error)
  • func CopyArray(arr interface{}) (array *Array, err error)
  • func New(capacity ...int) (array *Array)
  • func NewArray(capacity ...int) (array *Array)
  • func (arr *Array) Add(index int, value interface{}) (err error)
  • func (arr *Array) CapLength() int
  • func (arr *Array) Clear()
  • func (arr *Array) Contains(value interface{}) bool
  • func (arr *Array) Format() (format string)
  • func (arr *Array) Get(index int, def ...interface{}) (value interface{}, err error)
  • func (arr *Array) Index(value interface{}) int
  • func (arr *Array) IsEmpty() bool
  • func (arr *Array) Length() int
  • func (arr *Array) Map(fn func(int, interface{}) interface{}) *Array
  • func (arr *Array) Pop() (interface{}, error)
  • func (arr *Array) Push(values ...interface{})
  • func (arr *Array) Raw() []interface{}
  • func (arr *Array) Remove(index int, l ...int) (value []interface{}, err error)
  • func (arr *Array) RemoveValue(value interface{}) (e interface{}, err error)
  • func (arr *Array) Set(index int, value interface{}) (err error)
  • func (arr *Array) Shift() (interface{}, error)
  • func (arr *Array) Shuffle() (array *Array)
  • func (arr *Array) Unshift(value interface{}) error
• type Maper
  • func NewHashMap[K hashable, V any](size ...uintptr) *Maper[K, V]
  • func (m *Maper[K, V]) CAS(key K, oldValue, newValue V) bool
  • func (m *Maper[K, V]) Delete(keys ...K)
  • func (m *Maper[K, V]) Fillrate() uintptr
  • func (m *Maper[K, V]) ForEach(lambda func(K, V) bool)
  • func (m *Maper[K, V]) Get(key K) (value V, ok bool)
  • func (m *Maper[K, V]) GetAndDelete(key K) (value V, ok bool)
  • func (m *Maper[K, V]) GetOrSet(key K, value V) (actual V, loaded bool)
  • func (m *Maper[K, V]) Grow(newSize uintptr)
  • func (m *Maper[K, V]) Has(key K) (ok bool)
  • func (m *Maper[K, V]) Len() uintptr
  • func (m *Maper[K, V]) MarshalJSON() ([]byte, error)
  • func (m *Maper[K, V]) ProvideGet(key K, provide func() (V, bool)) (actual V, loaded, computed bool)
  • func (m *Maper[K, V]) Set(key K, value V)
  • func (m *Maper[K, V]) SetHasher(hasher func(K) uintptr)
  • func (m *Maper[K, V]) Swap(key K, newValue V) (oldValue V, swapped bool)
  • func (m *Maper[K, V]) UnmarshalJSON(i []byte) error
• type SortMaper
  • func NewSortMap[K hashable, V any](size ...uintptr) *SortMaper[K, V]
  • func (s *SortMaper[K, V]) Delete(key ...K)
  • func (s *SortMaper[K, V]) ForEach(lambda func(K, V) bool)
  • func (s *SortMaper[K, V]) Get(key K) (value V, ok bool)
  • func (s *SortMaper[K, V]) Has(key K) (ok bool)
  • func (s *SortMaper[K, V]) Keys() []K
  • func (s *SortMaper[K, V]) Len() int
  • func (s *SortMaper[K, V]) Set(key K, value V)

Variables

var ErrIllegalIndex = errors.New("illegal index")

ErrIllegalIndex illegal index

Functions

func Contains

func Contains[T comparable](collection []T, v T) bool

Contains returns true if an eent is present in a collection

func Diff

func Diff[T comparable](list1 []T, list2 []T) ([]T, []T)

func Filter

func Filter[T any](slice []T, predicate func(index int, item T) bool) []T

Filter iterates over eents of collection

func Find

func Find[T any](collection []T, predicate func(index int, item T) bool) (T, bool)

Find search an eent in a slice based on a predicate. It returns eent and true if eent was found.

func GetInf

func GetInf(arr []interface{}, index int, def ...interface{}) (value interface{}, err error)

GetInf Get the element corresponding to the index position of [] interface {}

func Keys

func Keys[K comparable, V any](in map[K]V) []K

Keys creates an array of the map keys

func Map

func Map[T any, R any](collection []T, iteratee func(int, T) R) []R

Map manipulates a slice and transforms it to a slice of another type

func Rand

func Rand[T any](collection []T) T

Rand A random eents

func Shuffle

func Shuffle[T any](collection []T) []T

Shuffle creates a slice of shuffled values

func Unique

func Unique[T comparable](collection []T) []T

Unique returns a duplicate-free version of an array

func Values

func Values[K comparable, V any](in map[K]V) []V

Values creates an array of the map values

Types

type Array

type Array struct {
	// contains filtered or unexported fields
}

Array insert, delete, random access according to the subscript operation, the data is interface type

func Copy

func Copy(arr interface{}) (array *Array, err error)

Deprecated: please use CopyArray

func CopyArray

func CopyArray(arr interface{}) (array *Array, err error)

Copy an array

func New

func New(capacity ...int) (array *Array)

Deprecated: please use NewArray

func NewArray

func NewArray(capacity ...int) (array *Array)

New array initialization memory

func (*Array) Add

func (arr *Array) Add(index int, value interface{}) (err error)

Add in the index position insert the element

func (*Array) CapLength

func (arr *Array) CapLength() int

CapLength get array capacity

func (*Array) Clear

func (arr *Array) Clear()

Clear array

func (*Array) Contains

func (arr *Array) Contains(value interface{}) bool

Contains find if there are elements in the array

func (*Array) Format

func (arr *Array) Format() (format string)

Format output sequence

func (*Array) Get

func (arr *Array) Get(index int, def ...interface{}) (value interface{}, err error)

Get the element corresponding to the index position

func (*Array) Index

func (arr *Array) Index(value interface{}) int

Index find array by index, index range [0, n-1] (not found, return - 1)

func (*Array) IsEmpty

func (arr *Array) IsEmpty() bool

IsEmpty determine whether the array is empty

func (*Array) Length

func (arr *Array) Length() int

Length get array length

func (*Array) Map

func (arr *Array) Map(fn func(int, interface{}) interface{}) *Array

Map ForEcho traversing generates a new array

func (*Array) Pop

func (arr *Array) Pop() (interface{}, error)

Pop delete end element

func (*Array) Push

func (arr *Array) Push(values ...interface{})

Push insert element to end of array

func (*Array) Raw

func (arr *Array) Raw() []interface{}

Raw original array

func (*Array) Remove

func (arr *Array) Remove(index int, l ...int) (value []interface{}, err error)

Remove delete the element at index position and return

func (*Array) RemoveValue

func (arr *Array) RemoveValue(value interface{}) (e interface{}, err error)

RemoveValue removes the specified element from the array

func (*Array) Set

func (arr *Array) Set(index int, value interface{}) (err error)

Set modify the element at the index position

func (*Array) Shift

func (arr *Array) Shift() (interface{}, error)

Shift delete the first element of the array

func (*Array) Shuffle

func (arr *Array) Shuffle() (array *Array)

Shuffle creates an slice of shuffled values

func (*Array) Unshift

func (arr *Array) Unshift(value interface{}) error

Unshift insert element into array header

type Maper

type Maper[K hashable, V any] struct {
	// contains filtered or unexported fields
}

Maper implements the concurrent hashmap

func NewHashMap

func NewHashMap[K hashable, V any](size ...uintptr) *Maper[K, V]

func (*Maper[K, V]) CAS

func (m *Maper[K, V]) CAS(key K, oldValue, newValue V) bool

func (*Maper[K, V]) Delete

func (m *Maper[K, V]) Delete(keys ...K)

func (*Maper[K, V]) Fillrate

func (m *Maper[K, V]) Fillrate() uintptr

func (*Maper[K, V]) ForEach

func (m *Maper[K, V]) ForEach(lambda func(K, V) bool)

func (*Maper[K, V]) Get

func (m *Maper[K, V]) Get(key K) (value V, ok bool)

func (*Maper[K, V]) GetAndDelete

func (m *Maper[K, V]) GetAndDelete(key K) (value V, ok bool)

func (*Maper[K, V]) GetOrSet

func (m *Maper[K, V]) GetOrSet(key K, value V) (actual V, loaded bool)

func (*Maper[K, V]) Grow

func (m *Maper[K, V]) Grow(newSize uintptr)

func (*Maper[K, V]) Has

func (m *Maper[K, V]) Has(key K) (ok bool)

func (*Maper[K, V]) Len

func (m *Maper[K, V]) Len() uintptr

func (*Maper[K, V]) MarshalJSON

func (m *Maper[K, V]) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaler interface.

func (*Maper[K, V]) ProvideGet

func (m *Maper[K, V]) ProvideGet(key K, provide func() (V, bool)) (actual V, loaded, computed bool)

func (*Maper[K, V]) Set

func (m *Maper[K, V]) Set(key K, value V)

func (*Maper[K, V]) SetHasher

func (m *Maper[K, V]) SetHasher(hasher func(K) uintptr)

func (*Maper[K, V]) Swap

func (m *Maper[K, V]) Swap(key K, newValue V) (oldValue V, swapped bool)

func (*Maper[K, V]) UnmarshalJSON

func (m *Maper[K, V]) UnmarshalJSON(i []byte) error

UnmarshalJSON implements the json.Unmarshaler interface.

type SortMaper

type SortMaper[K hashable, V any] struct {
	// contains filtered or unexported fields
}

func NewSortMap

func NewSortMap[K hashable, V any](size ...uintptr) *SortMaper[K, V]

func (*SortMaper[K, V]) Delete

func (s *SortMaper[K, V]) Delete(key ...K)

func (*SortMaper[K, V]) ForEach

func (s *SortMaper[K, V]) ForEach(lambda func(K, V) bool)

func (*SortMaper[K, V]) Get

func (s *SortMaper[K, V]) Get(key K) (value V, ok bool)

func (*SortMaper[K, V]) Has

func (s *SortMaper[K, V]) Has(key K) (ok bool)

func (*SortMaper[K, V]) Keys

func (s *SortMaper[K, V]) Keys() []K

func (*SortMaper[K, V]) Len

func (s *SortMaper[K, V]) Len() int

func (*SortMaper[K, V]) Set

func (s *SortMaper[K, V]) Set(key K, value V)