concurrent

Sep 23, 2024

Changes in this version

type LockedSlice

+ func (ls *LockedSlice[T]) AnySorted(target T, fun generic.Func2[T, T, int]) (ret bool)

+ func (ls *LockedSlice[T]) AppendSorted(fun generic.Func2[T, T, int], values ...T)

+ func (ls *LockedSlice[T]) AppendStableSorted(fun generic.Func2[T, T, int], values ...T)

+ func (ls *LockedSlice[T]) DeleteOnce(fun generic.Func1[T, bool])

+ func (ls *LockedSlice[T]) DeleteOnceSorted(target T, fun generic.Func2[T, T, int])

+ func (ls *LockedSlice[T]) Prepend(values ...T)

Sep 21, 2024

Changes in this version

type LockedSlice

+ func (ls *LockedSlice[T]) All(fun generic.Func1[T, bool]) (ret bool)

+ func (ls *LockedSlice[T]) Any(fun generic.Func1[T, bool]) (ret bool)

+ func (ls *LockedSlice[T]) Filter(fun generic.Func1[T, bool]) (ret []T)

+ func (ls *LockedSlice[T]) FilterNot(fun generic.Func1[T, bool]) (ret []T)

+ func (ls *LockedSlice[T]) Shuffle(n int)

+ func (ls *LockedSlice[T]) Sort(fun generic.Func2[T, T, int])

+ func (ls *LockedSlice[T]) SortStable(fun generic.Func2[T, T, int])

Sep 20, 2024

Changes in this version

+ type Deduplicator struct

+ func NewDeduplicator() *Deduplicator

+ func (d *Deduplicator) Make() int64

+ func (d *Deduplicator) Remove(remote string)

+ func (d *Deduplicator) Validate(remote string, seq int64) (passed bool)

type Futures

+ func NewFutures(ctx context.Context, timeout time.Duration) *Futures

Jun 20, 2024

Changes in this version

type RespAsyncRet

+ func (ch RespAsyncRet) ToAsyncRet() async.AsyncRet

type RespAsyncRetT

+ func (ch RespAsyncRetT[T]) ToAsyncRetT() async.AsyncRetT[T]

Jun 20, 2024

Changes in this version

+ const CacheDefaultCleanInterval

+ const CacheDefaultCleanNum

+ var ErrFutureCanceled = errors.New("future canceled")

+ var ErrFutureNotFound = errors.New("future not found")

+ var ErrFutureRespIncorrectType = errors.New("future response has incorrect value type")

+ var ErrFutureTimeout = errors.New("future timeout")

+ var ErrFuturesClosed = errors.New("futures already closed")

+ func MakeFutureRespAsyncRet(fs IFutures, ctx context.Context, timeout ...time.Duration) (Future, RespAsyncRet)

+ func MakeFutureRespAsyncRetT[T any](fs IFutures, ctx context.Context, timeout ...time.Duration) (Future, RespAsyncRetT[T])

+ type Cache struct

+ func NewCache[K comparable, V any]() *Cache[K, V]

+ func (c *Cache[K, V]) AutoClean(ctx context.Context, interval time.Duration, num int)

+ func (c *Cache[K, V]) Clean(num int)

+ func (c *Cache[K, V]) Del(k K, revision int64)

+ func (c *Cache[K, V]) Get(k K) (V, bool)

+ func (c *Cache[K, V]) OnAdd(cb generic.Action2[K, V])

+ func (c *Cache[K, V]) OnDel(cb generic.Action2[K, V])

+ func (c *Cache[K, V]) RefreshTTL(k K)

+ func (c *Cache[K, V]) Set(k K, v V, revision int64, ttl time.Duration) V

+ func (c *Cache[K, V]) Snapshot() generic.UnorderedSliceMap[K, V]

+ type Deduplication struct

+ func MakeDeduplication() Deduplication

+ func (d *Deduplication) Make() int64

+ func (d *Deduplication) Remove(remote string)

+ func (d *Deduplication) Validate(remote string, seq int64) (passed bool)

+ type Future struct

+ Finish context.Context

+ Id int64

+ func MakeFuture[T Resp](fs IFutures, ctx context.Context, resp T, timeout ...time.Duration) Future

+ func (f Future) Cancel(err error)

+ func (f Future) Wait(ctx context.Context)

+ type Futures struct

+ Ctx context.Context

+ Id int64

+ Timeout time.Duration

+ func MakeFutures(ctx context.Context, timeout time.Duration) Futures

+ func (fs *Futures) Make(ctx context.Context, resp Resp, timeout ...time.Duration) Future

+ func (fs *Futures) Request(ctx context.Context, handler RequestHandler, timeout ...time.Duration) async.AsyncRet

+ func (fs *Futures) Resolve(id int64, ret async.Ret) error

+ type IDeduplication interface

+ Make func() int64

+ Remove func(remote string)

+ Validate func(remote string, seq int64) bool

+ type IFutures interface

+ Make func(ctx context.Context, resp Resp, timeout ...time.Duration) Future

+ Request func(ctx context.Context, handler RequestHandler, timeout ...time.Duration) async.AsyncRet

+ Resolve func(id int64, ret async.Ret) error

+ type Locked struct

+ func MakeLocked[T any](obj T) Locked[T]

+ func NewLocked[T any](obj T) *Locked[T]

+ func (l *Locked[T]) AutoLock(fun generic.Action1[*T])

+ type LockedMap struct

+ func MakeLockedMap[K comparable, V any](size int) LockedMap[K, V]

+ func NewLockedMap[K comparable, V any](size int) *LockedMap[K, V]

+ func (lm *LockedMap[K, V]) Add(k K, v V)

+ func (lm *LockedMap[K, V]) Delete(k K)

+ func (lm *LockedMap[K, V]) Each(fun generic.Action2[K, V])

+ func (lm *LockedMap[K, V]) Exist(k K) (b bool)

+ func (lm *LockedMap[K, V]) Get(k K) (v V, ok bool)

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

+ func (lm *LockedMap[K, V]) Range(fun generic.Func2[K, V, bool])

+ func (lm *LockedMap[K, V]) TryAdd(k K, v V)

+ func (lm *LockedMap[K, V]) Value(k K) (v V)

+ type LockedSlice struct

+ func MakeLockedSlice[T any](len, cap int) LockedSlice[T]

+ func NewLockedSlice[T any](len, cap int) *LockedSlice[T]

+ func (ls *LockedSlice[T]) Append(values ...T)

+ func (ls *LockedSlice[T]) Delete(idx ...int)

+ func (ls *LockedSlice[T]) Each(fun generic.Action1[T])

+ func (ls *LockedSlice[T]) Insert(idx int, values ...T)

+ func (ls *LockedSlice[T]) Len() (l int)

+ func (ls *LockedSlice[T]) Range(fun generic.Func1[T, bool])

+ type RWLocked struct

+ func MakeRWLocked[T any](obj T) RWLocked[T]

+ func NewRWLocked[T any](obj T) *RWLocked[T]

+ func (l *RWLocked[T]) AutoLock(fun generic.Action1[*T])

+ func (l *RWLocked[T]) AutoRLock(fun generic.Action1[*T])

+ type RequestHandler = generic.Action1[Future]

+ type Resp interface

+ Push func(ret async.Ret) error

+ type RespAsyncRet chan async.Ret

+ func MakeRespAsyncRet() RespAsyncRet

+ func (ch RespAsyncRet) CastAsyncRet() async.AsyncRet

+ func (ch RespAsyncRet) Push(ret async.Ret) error

+ type RespAsyncRetT chan async.RetT[T]

+ func MakeRespAsyncRetT[T any]() RespAsyncRetT[T]

+ func (ch RespAsyncRetT[T]) CastAsyncRetT() async.AsyncRetT[T]

+ func (ch RespAsyncRetT[T]) Push(ret async.Ret) error

+ type RespDelegate generic.DelegateAction1[async.RetT[T]]

+ func (dlg RespDelegate[T]) Push(ret async.RetT[any]) error

+ type RespFunc generic.Action1[async.RetT[T]]

+ func (fun RespFunc[T]) Push(ret async.RetT[any]) error