robin

package module

Go to main page

Versions in this module

v1

v1.2.0

Jan 6, 2023

v1.1.1

Jun 16, 2022

Changes in this version

+ type ConcurrentBag struct

+ func NewConcurrentBag() *ConcurrentBag

+ func (cb *ConcurrentBag) Add(element interface{})

+ func (cb *ConcurrentBag) Clear()

+ func (cb *ConcurrentBag) ToArray() (elements []interface{})

+ func (cb *ConcurrentBag) TryTake() (interface{}, bool)

+ func (cb ConcurrentBag) Len() int

type ConcurrentQueue

+ func (c *ConcurrentQueue) Clear()

+ func (c ConcurrentQueue) Len() int

+ func (c ConcurrentQueue) ToArray() (elements []interface{})

+ type ConcurrentStack struct

+ func NewConcurrentStack() *ConcurrentStack

+ func (c *ConcurrentStack) Clear()

+ func (c *ConcurrentStack) Push(element interface{})

+ func (c *ConcurrentStack) TryPeek() (interface{}, bool)

+ func (c *ConcurrentStack) TryPop() (interface{}, bool)

+ func (c ConcurrentStack) Len() int

+ func (c ConcurrentStack) ToArray() (elements []interface{})

type MemoryCache

+ ForgetAll func()

v1.1.0

Jul 3, 2019

Changes in this version

type ConcurrentQueue

+ func (c ConcurrentQueue) Clean()

+ type Item struct

+ Index int

+ Priority int64

+ Value interface{}

+ type MemoryCache interface

+ Forget func(key string)

+ Have func(string) bool

+ Keep func(key string, value interface{}, ttl time.Duration) error

+ Read func(string) (interface{}, bool)

+ func Memory() MemoryCache

+ type PriorityQueue []*Item

+ func NewPriorityQueue(capacity int) *PriorityQueue

+ func (pq *PriorityQueue) Pop() interface{}

+ func (pq *PriorityQueue) Push(x interface{})

+ func (pq *PriorityQueue) PushItem(item *Item)

+ func (pq *PriorityQueue) TryDequeue(limit int64) (*Item, bool)

+ func (pq *PriorityQueue) Update(item *Item)

+ func (pq PriorityQueue) Len() int

+ func (pq PriorityQueue) Less(i, j int) bool

+ func (pq PriorityQueue) Swap(i, j int)

v1.0.12

May 31, 2019

Changes in this version

type Job

+ func (j *Job) Between(f time.Time, t time.Time) *Job

+ type UntilJob struct

+ func (u *UntilJob) Do(fun interface{}, params ...interface{}) Disposable

+ type Worker interface

+ Do func(interface{}, ...interface{}) Disposable

+ func Until(time time.Time) Worker

v1.0.11

Mar 11, 2019

v1.0.10

Mar 1, 2019

Changes in this version

+ func NewContainer() *container

+ type Channel struct

+ func (c Channel) Clear()

+ func (c Channel) Count() int

+ func (c Channel) Publish(msg ...interface{})

+ func (c Channel) Subscribe(taskFun interface{}, params ...interface{}) *Subscriber

+ func (c Channel) Unsubscribe(subscriber interface{})

type IScheduler

+ Enqueue func(taskFun interface{}, params ...interface{})

+ EnqueueWithTask func(task Task)

+ Remove func(d Disposable)

+ type Subscriber struct

+ func (c *Subscriber) Unsubscribe()

v1.0.9

Jan 27, 2019

Changes in this version

+ func AbsForInt64(n int64) int64

type Job

+ func (j *Job) Milliseconds() *Job

+ func (j *Job) Times(times int64) *Job

v1.0.8

Jan 2, 2019

v1.0.7

Dec 27, 2018

Changes in this version

type Job

+ func Everyday() *Job

v1.0.6

Dec 25, 2018

Changes in this version

type ConcurrentMap

+ func (m ConcurrentMap) RemoveCb(key string, cb RemoveCb) bool

+ type DefaultQueue struct

+ func (d *DefaultQueue) Count() int

+ func (d *DefaultQueue) DequeueAll() ([]Task, bool)

+ func (d *DefaultQueue) Dispose()

+ func (d *DefaultQueue) Enqueue(task Task)

+ type RemoveCb func(key string, v interface{}, exists bool) bool

+ type Task struct

v1.0.5

Dec 11, 2018

v1.0.4

Dec 1, 2018

v1.0.3

Dec 1, 2018

v1.0.2

Nov 10, 2018

v1.0.1

Oct 22, 2018

Changes in this version

type Job

+ func (c *Job) AfterExecuteTask() *Job

+ func (c *Job) BeforeExecuteTask() *Job

v1.0.0

Oct 10, 2018

Changes in this version

+ var SHARD_COUNT = 32

+ func Abs(a int) int

+ func NewChannel() *channel

+ func NewChannelSubscription(fiber Fiber, task task) *channelSubscription

+ func NewCronDelay() *cronDelay

+ func NewDefaultQueue() *defaultQueue

+ func NewEveryCron() *cronEvery

+ func NewUnsubscriber(receiver task, channel *channel, fiber SubscriptionRegistry) *unsubscriber

+ type ConcurrentMap []*ConcurrentMapShared

+ func NewConcurrentMap() ConcurrentMap

+ func (m ConcurrentMap) Count() int

+ func (m ConcurrentMap) Get(key string) (interface{}, bool)

+ func (m ConcurrentMap) GetShard(key string) *ConcurrentMapShared

+ func (m ConcurrentMap) Has(key string) bool

+ func (m ConcurrentMap) IsEmpty() bool

+ func (m ConcurrentMap) Items() map[string]interface{}

+ func (m ConcurrentMap) Iter() <-chan Tuple

+ func (m ConcurrentMap) IterBuffered() <-chan Tuple

+ func (m ConcurrentMap) IterCb(fn IterCb)

+ func (m ConcurrentMap) Keys() []string

+ func (m ConcurrentMap) MSet(data map[string]interface{})

+ func (m ConcurrentMap) MarshalJSON() ([]byte, error)

+ func (m ConcurrentMap) Pop(key string) (v interface{}, exists bool)

+ func (m ConcurrentMap) Remove(key string)

+ func (m ConcurrentMap) Set(key string, value interface{})

+ func (m ConcurrentMap) SetIfAbsent(key string, value interface{}) bool

+ func (m ConcurrentMap) Upsert(key string, value interface{}, cb UpsertCb) (res interface{})

+ type ConcurrentMapShared struct

+ type ConcurrentQueue struct

+ func NewConcurrentQueue() *ConcurrentQueue

+ func (c *ConcurrentQueue) Enqueue(item interface{})

+ func (c *ConcurrentQueue) TryDequeue() (interface{}, bool)

+ func (c *ConcurrentQueue) TryPeek() (interface{}, bool)

+ func (c ConcurrentQueue) Count() int

+ type Disposable interface

+ Dispose func()

+ Identify func() string

+ type Disposer struct

+ func NewDisposer() *Disposer

+ func (d *Disposer) Add(disposable Disposable)

+ func (d *Disposer) Count() int

+ func (d *Disposer) Dispose()

+ func (d *Disposer) Remove(disposable Disposable)

+ type ExecutionContext interface

+ Enqueue func(taskFun interface{}, params ...interface{})

+ EnqueueWithTask func(task task)

+ type Fiber interface

+ Dispose func()

+ Enqueue func(taskFun interface{}, params ...interface{})

+ EnqueueWithTask func(task task)

+ Schedule func(firstInMs int64, taskFun interface{}, params ...interface{}) (d Disposable)

+ ScheduleOnInterval func(firstInMs int64, regularInMs int64, taskFun interface{}, params ...interface{}) (d Disposable)

+ Start func()

+ Stop func()

+ type GoroutineMulti struct

+ func NewGoroutineMulti() *GoroutineMulti

+ func (g *GoroutineMulti) DeregisterSubscription(toRemove Disposable)

+ func (g *GoroutineMulti) Dispose()

+ func (g *GoroutineMulti) Enqueue(taskFun interface{}, params ...interface{})

+ func (g *GoroutineMulti) EnqueueWithTask(task task)

+ func (g *GoroutineMulti) RegisterSubscription(toAdd Disposable)

+ func (g *GoroutineMulti) Schedule(firstInMs int64, taskFun interface{}, params ...interface{}) (d Disposable)

+ func (g *GoroutineMulti) ScheduleOnInterval(firstInMs int64, regularInMs int64, taskFun interface{}, params ...interface{}) (d Disposable)

+ func (g *GoroutineMulti) Start()

+ func (g *GoroutineMulti) Stop()

+ func (g GoroutineMulti) NumSubscriptions() int

+ type GoroutineSingle struct

+ func NewGoroutineSingle() *GoroutineSingle

+ func (g *GoroutineSingle) DeregisterSubscription(toRemove Disposable)

+ func (g *GoroutineSingle) Dispose()

+ func (g *GoroutineSingle) Enqueue(taskFun interface{}, params ...interface{})

+ func (g *GoroutineSingle) EnqueueWithTask(task task)

+ func (g *GoroutineSingle) NumSubscriptions() int

+ func (g *GoroutineSingle) RegisterSubscription(toAdd Disposable)

+ func (g *GoroutineSingle) Start()

+ func (g *GoroutineSingle) Stop()

+ func (g GoroutineSingle) Schedule(firstInMs int64, taskFun interface{}, params ...interface{}) (d Disposable)

+ func (g GoroutineSingle) ScheduleOnInterval(firstInMs int64, regularInMs int64, taskFun interface{}, params ...interface{}) (d Disposable)

+ type IChannel interface

+ SubscribeOnProducerThreads func(subscriber IProducerThreadSubscriber) Disposable

+ type IProducerThreadSubscriber interface

+ ReceiveOnProducerThread func(msg ...interface{})

+ Subscriptions func() SubscriptionRegistry

+ type IPublisher interface

+ Publish func(interface{})

+ type IQueueChannel interface

+ Publish func(message interface{})

+ Subscribe func(executionContext ExecutionContext, onMessage interface{}) Disposable

+ type IReply interface

+ Receive func(timeoutInMs int, result *interface{}) Disposable

+ type IReplySubscriber interface

+ Subscribe func(fiber Fiber, onRequest *interface{}) Disposable

+ type IRequest interface

+ Request func() interface{}

+ SendReply func(replyMsg interface{}) bool

+ type IScheduler interface

+ Dispose func()

+ Schedule func(firstInMs int64, taskFun interface{}, params ...interface{}) (d Disposable)

+ ScheduleOnInterval func(firstInMs int64, regularInMs int64, taskFun interface{}, params ...interface{}) (d Disposable)

+ Start func()

+ Stop func()

+ type ISubscriber interface

+ ClearSubscribers func()

+ Subscribe func(fiber Fiber, taskFun interface{}, params ...interface{}) Disposable

+ type IterCb func(key string, v interface{})

+ type Job struct

+ func Delay(delayInMs int64) *Job

+ func Every(interval int64) *Job

+ func EveryFriday() *Job

+ func EveryMonday() *Job

+ func EverySaturday() *Job

+ func EverySunday() *Job

+ func EveryThursday() *Job

+ func EveryTuesday() *Job

+ func EveryWednesday() *Job

+ func NewJob(intervel int64, fiber Fiber, delayUnit delayUnit) *Job

+ func RightNow() *Job

+ func (c *Job) At(hour int, minute int, second int) *Job

+ func (c *Job) Days() *Job

+ func (c *Job) Dispose()

+ func (c *Job) Do(fun interface{}, params ...interface{}) Disposable

+ func (c *Job) Hours() *Job

+ func (c *Job) MilliSeconds() *Job

+ func (c *Job) Minutes() *Job

+ func (c *Job) Seconds() *Job

+ func (c Job) Identify() string

+ type Scheduler struct

+ func NewScheduler(executionState ExecutionContext) *Scheduler

+ func (s *Scheduler) Dispose()

+ func (s *Scheduler) Enqueue(taskFun interface{}, params ...interface{})

+ func (s *Scheduler) EnqueueWithTask(task task)

+ func (s *Scheduler) Remove(d Disposable)

+ func (s *Scheduler) Schedule(firstInMs int64, taskFun interface{}, params ...interface{}) (d Disposable)

+ func (s *Scheduler) ScheduleOnInterval(firstInMs int64, regularInMs int64, taskFun interface{}, params ...interface{}) (d Disposable)

+ func (s *Scheduler) Start()

+ func (s *Scheduler) Stop()

+ type SchedulerRegistry interface

+ Enqueue func(taskFun interface{}, params ...interface{})

+ EnqueueWithTask func(task task)

+ Remove func(d Disposable)

+ type SubscriptionRegistry interface

+ DeregisterSubscription func(Disposable)

+ RegisterSubscription func(Disposable)

+ type Tuple struct

+ Key string

+ Val interface{}

+ type UpsertCb func(exist bool, valueInMap interface{}, newValue interface{}) interface

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