xsync

Documentation

Overview

package xsync provides some generics wrappers for some standard libraries like sync.Map, sync.Pool, sync.Mutext etc.

Index

• type LockedValue
  • func NewLockedValue[T any](value T) *LockedValue[T]
  • func (l *LockedValue[T]) Lock() T
  • func (l *LockedValue[T]) LockCB(cb func(T))
  • func (l *LockedValue[T]) SetValue(value T)
  • func (l *LockedValue[T]) TryLock() (val T, locked bool)
  • func (l *LockedValue[T]) Unlock()
• type RWLockedValue
  • func NewRWLockedValue[T any](value T) *RWLockedValue[T]
  • func (l *RWLockedValue[T]) Lock() T
  • func (l *RWLockedValue[T]) LockCB(cb func(T))
  • func (l *RWLockedValue[T]) RLock() T
  • func (l *RWLockedValue[T]) RLockCB(cb func(T))
  • func (l *RWLockedValue[T]) RUnlock()
  • func (l *RWLockedValue[T]) SetValue(value T)
  • func (l *RWLockedValue[T]) TryLock() (val T, locked bool)
  • func (l *RWLockedValue[T]) TryRLock() (val T, locked bool)
  • func (l *RWLockedValue[T]) Unlock()
• type SyncMap
  • func NewSyncMap[K comparable, V any]() *SyncMap[K, V]
  • func (s *SyncMap[K, V]) Clear()
  • func (s *SyncMap[K, V]) CompareAndDelete(key K, old V) bool
  • func (s *SyncMap[K, V]) CompareAndSwap(key K, old, new V) bool
  • func (s *SyncMap[K, V]) Delete(key K)
  • func (s *SyncMap[K, V]) Len() int
  • func (s *SyncMap[K, V]) Load(key K) (value V, ok bool)
  • func (s *SyncMap[K, V]) LoadAndDelete(key K) (value V, loaded bool)
  • func (s *SyncMap[K, V]) LoadOrStore(key K, value V) (actual V, loaded bool)
  • func (s *SyncMap[K, V]) Range(f func(key K, value V) bool)
  • func (s *SyncMap[K, V]) Store(key K, value V)
  • func (s *SyncMap[K, V]) Swap(key K, value V) (previous V, loaded bool)
  • func (s *SyncMap[K, V]) ToMap() map[K]V
• type SyncPool
  • func NewSyncPool[T any](new func() T) *SyncPool[T]
  • func (s *SyncPool[T]) Get() T
  • func (s *SyncPool[T]) Put(x T)

Types

type LockedValue

type LockedValue[T any] struct {
	// contains filtered or unexported fields
}

LockedValue is a wrapper wrapping a value protect by a mutex

func NewLockedValue

func NewLockedValue[T any](value T) *LockedValue[T]

NewLockedValue returns a new LockedValue

func (*LockedValue[T]) Lock

func (l *LockedValue[T]) Lock() T

Lock and get the value

func (*LockedValue[T]) LockCB

func (l *LockedValue[T]) LockCB(cb func(T))

LockCB is a shortcut for l.mu.Lock() and defer l.mu.Unlock()

func (*LockedValue[T]) SetValue

func (l *LockedValue[T]) SetValue(value T)

SetValue can modify the underlying value with protection

func (*LockedValue[T]) TryLock

func (l *LockedValue[T]) TryLock() (val T, locked bool)

TryLock return true with value if lock successfully, return false with zero value if lock failed

func (*LockedValue[T]) Unlock

func (l *LockedValue[T]) Unlock()

Unlock then the value is unprotected

type RWLockedValue

type RWLockedValue[T any] struct {
	// contains filtered or unexported fields
}

RWLockedValue is a wrapper wrapping a value protect by a RWMutex

func NewRWLockedValue

func NewRWLockedValue[T any](value T) *RWLockedValue[T]

NewRWLockedValue returns a new RWLockedValue

func (*RWLockedValue[T]) Lock

func (l *RWLockedValue[T]) Lock() T

Lock and get the value

func (*RWLockedValue[T]) LockCB

func (l *RWLockedValue[T]) LockCB(cb func(T))

LockCB is a shortcut for l.mu.RLock() and defer l.mu.RUnlock()

func (*RWLockedValue[T]) RLock

func (l *RWLockedValue[T]) RLock() T

RLock and get the value Gentleman's agreement: RLock means you should not modify the value, We cannot force a declaration that the return value cannot be modified

func (*RWLockedValue[T]) RLockCB

func (l *RWLockedValue[T]) RLockCB(cb func(T))

RLockCB is a shortcut for l.mu.RLock() and defer l.mu.RUnlock()

func (*RWLockedValue[T]) RUnlock

func (l *RWLockedValue[T]) RUnlock()

RUnlock then the value is unprotected

func (*RWLockedValue[T]) SetValue

func (l *RWLockedValue[T]) SetValue(value T)

SetValue can modify the underlying value with protection

func (*RWLockedValue[T]) TryLock

func (l *RWLockedValue[T]) TryLock() (val T, locked bool)

TryLock return true with value if lock successfully, return false with zero value if lock failed

func (*RWLockedValue[T]) TryRLock

func (l *RWLockedValue[T]) TryRLock() (val T, locked bool)

TryRLock return true with value if lock successfully, return false with zero value if lock failed

func (*RWLockedValue[T]) Unlock

func (l *RWLockedValue[T]) Unlock()

Unlock then the value is unprotected

type SyncMap

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

SyncMap is a wrapper for sync.Map.

func NewSyncMap

func NewSyncMap[K comparable, V any]() *SyncMap[K, V]

NewSyncMap creates a new SyncMap.

func (*SyncMap[K, V]) Clear

func (s *SyncMap[K, V]) Clear()

Clear deletes all the entries, resulting in an empty Map. only available in go1.23

func (*SyncMap[K, V]) CompareAndDelete

func (s *SyncMap[K, V]) CompareAndDelete(key K, old V) bool

func (*SyncMap[K, V]) CompareAndSwap

func (s *SyncMap[K, V]) CompareAndSwap(key K, old, new V) bool

func (*SyncMap[K, V]) Delete

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

Delete wraps sync.Map.Delete.

func (*SyncMap[K, V]) Len

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

Len returns the number of elements in the map. The complexity is O(n). Not provided in stdlib but by our own

func (*SyncMap[K, V]) Load

func (s *SyncMap[K, V]) Load(key K) (value V, ok bool)

Load wraps sync.Map.Load.

func (*SyncMap[K, V]) LoadAndDelete

func (s *SyncMap[K, V]) LoadAndDelete(key K) (value V, loaded bool)

LoadAndDelete wraps sync.Map.LoadAndDelete.

func (*SyncMap[K, V]) LoadOrStore

func (s *SyncMap[K, V]) LoadOrStore(key K, value V) (actual V, loaded bool)

LoadOrStore wraps sync.Map.LoadOrStore.

func (*SyncMap[K, V]) Range

func (s *SyncMap[K, V]) Range(f func(key K, value V) bool)

Range wraps sync.Map.Range.

func (*SyncMap[K, V]) Store

func (s *SyncMap[K, V]) Store(key K, value V)

Store wraps sync.Map.Store.

func (*SyncMap[K, V]) Swap

func (s *SyncMap[K, V]) Swap(key K, value V) (previous V, loaded bool)

func (*SyncMap[K, V]) ToMap

func (s *SyncMap[K, V]) ToMap() map[K]V

ToMap returns a copy of the map as a regular map.

type SyncPool

type SyncPool[T any] struct {
	New func() T
	// contains filtered or unexported fields
}

func NewSyncPool

func NewSyncPool[T any](new func() T) *SyncPool[T]

NewSyncPool creates a new SyncPool with specified init function

func (*SyncPool[T]) Get

func (s *SyncPool[T]) Get() T

Get wraps sync.Pool.Get.

func (*SyncPool[T]) Put

func (s *SyncPool[T]) Put(x T)

Put wraps sync.Pool.Put.