Versions in this module Expand all Collapse all v1 v1.0.0 Apr 5, 2021 Changes in this version + var ErrPrevExists = &errors.Error + type AdvancedTxnLockManager struct + func NewAdvancedTxnLockManager(partitionNum int) *AdvancedTxnLockManager + func (lm *AdvancedTxnLockManager) Initialize(partitionNum int) *AdvancedTxnLockManager + func (lm *AdvancedTxnLockManager) Lock(txnId types.TxnId) + func (lm *AdvancedTxnLockManager) RLock(txnId types.TxnId) + func (lm *AdvancedTxnLockManager) RUnlock(txnId types.TxnId) + func (lm *AdvancedTxnLockManager) Unlock(txnId types.TxnId) + type BasicLockManager struct + func NewBasicLockManager() *BasicLockManager + func (lm *BasicLockManager) Initialize() *BasicLockManager + func (lm BasicLockManager) Lock(key string) + func (lm BasicLockManager) RLock(key string) + func (lm BasicLockManager) RUnlock(key string) + func (lm BasicLockManager) Unlock(key string) + type BasicTaskLockManager struct + func NewBasicTaskLockManager() *BasicTaskLockManager + func (lm *BasicTaskLockManager) Initialize() *BasicTaskLockManager + func (lm BasicTaskLockManager) Lock(id basic.TaskId) + func (lm BasicTaskLockManager) RLock(id basic.TaskId) + func (lm BasicTaskLockManager) RUnlock(id basic.TaskId) + func (lm BasicTaskLockManager) Unlock(id basic.TaskId) + type BasicTxnLockManager struct + func NewBasicTxnLockManager() *BasicTxnLockManager + func (lm *BasicTxnLockManager) Initialize() *BasicTxnLockManager + func (lm BasicTxnLockManager) Lock(txnId types.TxnId) + func (lm BasicTxnLockManager) RLock(txnId types.TxnId) + func (lm BasicTxnLockManager) RUnlock(txnId types.TxnId) + func (lm BasicTxnLockManager) Unlock(txnId types.TxnId) + type ConcurrentList struct + func NewConcurrentList() *ConcurrentList + type ConcurrentListElement struct + CList *ConcurrentList + func NewConcurrentListElement(cl *ConcurrentList, ele *list.Element) *ConcurrentListElement + type ConcurrentMap struct + func (cmp *ConcurrentMap) Clear() + func (cmp *ConcurrentMap) Del(key string) + func (cmp *ConcurrentMap) ForEachLoosed(cb func(string, interface{})) + func (cmp *ConcurrentMap) ForEachStrict(cb func(string, interface{})) + func (cmp *ConcurrentMap) Get(key string) (interface{}, bool) + func (cmp *ConcurrentMap) GetLazy(key string, constructor func() interface{}) interface{} + func (cmp *ConcurrentMap) Initialize(partitionNum int) + func (cmp *ConcurrentMap) Lock() + func (cmp *ConcurrentMap) MustGet(key string) interface{} + func (cmp *ConcurrentMap) RLock() + func (cmp *ConcurrentMap) RUnlock() + func (cmp *ConcurrentMap) Set(key string, val interface{}) + func (cmp *ConcurrentMap) SetIf(key string, val interface{}, pred func(prev interface{}, exist bool) bool) (success bool, valAfterCall interface{}) + func (cmp *ConcurrentMap) Size() (sz int) + func (cmp *ConcurrentMap) Unlock() + type ConcurrentSet struct + func NewConcurrentSet() *ConcurrentSet + func (s *ConcurrentSet) Contains(key string) bool + func (s *ConcurrentSet) Initialize() + func (s *ConcurrentSet) Insert(key string) (newLength int) + func (s *ConcurrentSet) Len() int + func (s *ConcurrentSet) Remove(key string) + type ConcurrentStringSlice struct + func NewConcurrentStringSlice() *ConcurrentStringSlice + func (s *ConcurrentStringSlice) Append(str string) + func (s *ConcurrentStringSlice) Len() int + func (s *ConcurrentStringSlice) Strings() []string + type ConcurrentTreeMap struct + func NewConcurrentTreeMap(comparator utils.Comparator) *ConcurrentTreeMap + func (ctm *ConcurrentTreeMap) Ceiling(key interface{}) (foundKey interface{}, foundValue interface{}) + func (ctm *ConcurrentTreeMap) Clear() + func (ctm *ConcurrentTreeMap) Find(f func(key interface{}, value interface{}) bool) (foundKey interface{}, foundValue interface{}) + func (ctm *ConcurrentTreeMap) Floor(key interface{}) (foundKey interface{}, foundValue interface{}) + func (ctm *ConcurrentTreeMap) Get(key interface{}) (interface{}, bool) + func (ctm *ConcurrentTreeMap) Insert(key interface{}, val interface{}) (success bool) + func (ctm *ConcurrentTreeMap) Max() (key interface{}, value interface{}) + func (ctm *ConcurrentTreeMap) MaxIf(pred func(key interface{}) bool) (key interface{}, value interface{}) + func (ctm *ConcurrentTreeMap) Min() (key interface{}, value interface{}) + func (ctm *ConcurrentTreeMap) Put(key interface{}, val interface{}) + func (ctm *ConcurrentTreeMap) Remove(key interface{}) + func (ctm *ConcurrentTreeMap) RemoveIf(key interface{}, pred func(prev interface{}) bool) + func (ctm *ConcurrentTreeMap) Update(key interface{}, ...) (success bool) + type ConcurrentTxnMap struct + func (cmp *ConcurrentTxnMap) Close() + func (cmp *ConcurrentTxnMap) Contains(key types.TxnId) bool + func (cmp *ConcurrentTxnMap) Del(key types.TxnId) + func (cmp *ConcurrentTxnMap) ForEachLoosed(cb func(types.TxnId, interface{})) + func (cmp *ConcurrentTxnMap) ForEachStrict(cb func(types.TxnId, interface{})) + func (cmp *ConcurrentTxnMap) GCWhen(txn types.TxnId, scheduleTime time.Time) + func (cmp *ConcurrentTxnMap) Get(key types.TxnId) (interface{}, bool) + func (cmp *ConcurrentTxnMap) GetLazy(key types.TxnId, constructor func() interface{}) interface{} + func (cmp *ConcurrentTxnMap) Initialize(partitionNum int) + func (cmp *ConcurrentTxnMap) InitializeWithGCThreads(partitionNum int, chSizePerPartition int) + func (cmp *ConcurrentTxnMap) Insert(key types.TxnId, val interface{}) error + func (cmp *ConcurrentTxnMap) InsertIfNotExists(key types.TxnId, constructor func() interface{}) (success bool, newVal interface{}) + func (cmp *ConcurrentTxnMap) Lock() + func (cmp *ConcurrentTxnMap) MustGet(key types.TxnId) interface{} + func (cmp *ConcurrentTxnMap) RLock() + func (cmp *ConcurrentTxnMap) RUnlock() + func (cmp *ConcurrentTxnMap) Set(key types.TxnId, val interface{}) + func (cmp *ConcurrentTxnMap) SetIf(key types.TxnId, val interface{}, pred func(prev interface{}, exist bool) bool) (success bool, newValue interface{}) + func (cmp *ConcurrentTxnMap) Size() (sz int) + func (cmp *ConcurrentTxnMap) Unlock() + type Future struct + func NewFuture() *Future + func (s *Future) AddUnsafe(key string) (insertedNewKey bool, keyDone bool) + func (s *Future) DoneOnceUnsafe(key string) (doneOnce bool) + func (s *Future) GetAddedKeyCountUnsafe() int + func (s *Future) GetKeyCountUnsafe() int + func (s *Future) IsDoneUnsafe() bool + func (s *Future) IsKeyDoneUnsafe(key string) bool + type Graph struct + func NewGraph(graph [][]int) *Graph + func (g *Graph) SearchCircle() []int + type LockManager interface + Lock func(key string) + RLock func(key string) + RUnlock func(key string) + Unlock func(key string) + type Stack struct + func NewStack(capacity int) *Stack + func (s *Stack) Pop() + func (s *Stack) Push(i int) + func (s *Stack) Top() int + type Stat int + const Done + const Unvisited + const Visiting + type TxnLockManager interface + Lock func(id types.TxnId) + RLock func(id types.TxnId) + RUnlock func(id types.TxnId) + Unlock func(id types.TxnId) + type Visitor func(*context, int) (kontinue bool)