rx

type Disposable interface {
	// Dispose dispose current resource.
	Dispose()
	// IsDisposed returns true if it has been disposed.
	IsDisposed() bool
}

type Do = func(ctx context.Context)

type Flux interface {
	Publisher
	// LimitRate limits the number of elements in batches.
	LimitRate(n int) Flux
	// DoOnRequest register handler when subsccriber request more elements.
	DoOnRequest(fn FnOnRequest) Flux
	// DoOnSubscribe register handler when subscribe begin.
	DoOnSubscribe(fn FnOnSubscribe) Flux
	// DoOnNext register handler when emitting next element.
	DoOnNext(fn FnOnNext) Flux
	// DoOnNext register handler after emitting next element.
	DoAfterNext(fn FnConsumer) Flux
	// DoOnComplete register handler when Flux was completed.
	DoOnComplete(fn FnOnComplete) Flux
	// DoOnError register handler when an exception occurs.
	DoOnError(fn FnOnError) Flux
	// DoOnCancel register handler when Mono was canceled.
	DoOnCancel(fn FnOnCancel) Flux
	// DoFinally register handler when Mono was terminated.
	// DoFinally will definitely be executed.
	DoFinally(fn FnOnFinally) Flux
	// SubscribeOn specify scheduler for subscriber.
	SubscribeOn(s Scheduler) Flux
	// PublishOn specify scheduler for publisher.
	PublishOn(s Scheduler) Flux
}

type FnConsumer = func(ctx context.Context, elem payload.Payload)

type FnOnCancel = func(ctx context.Context)

type FnOnComplete = func(ctx context.Context)

type FnOnError = func(ctx context.Context, err error)

type FnOnFinally = func(ctx context.Context, st SignalType)

type FnOnNext = func(ctx context.Context, s Subscription, elem payload.Payload)

type FnOnRequest = func(ctx context.Context, n int)

type FnOnSubscribe = func(ctx context.Context, s Subscription)

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

type Mono interface {
	Publisher
	// DoAfterSuccess register handler after emitting element successfully.
	DoAfterSuccess(fn FnConsumer) Mono
	// DoOnSubscribe register handler on subscribe begin.
	DoOnSubscribe(fn FnOnSubscribe) Mono
	// DoOnSuccess register handler when emitting element successfully.
	DoOnSuccess(fn FnOnNext) Mono
	// DoOnError register handler when an exception occurs.
	DoOnError(fn FnOnError) Mono
	// DoOnCancel register handler when Mono was canceled.
	DoOnCancel(fn FnOnCancel) Mono
	// DoFinally register handler when Mono was terminated.
	// DoFinally will definitely be executed.
	DoFinally(fn FnOnFinally) Mono
	// SubscribeOn specify scheduler for subscriber.
	SubscribeOn(s Scheduler) Mono
	// PublishOn specify scheduler for publisher.
	PublishOn(s Scheduler) Mono
}

type MonoProducer interface {
	// Success append payload.
	Success(elem payload.Payload) error
	// Error means some bad things happened.
	Error(err error)
}

type OptSubscribe func(*hooks)

type Processor interface {
	Publisher
	Subscriber
}

type Producer interface {
	// Next append next element.
	Next(elem payload.Payload) error
	// Error means some bad things happened.
	Error(err error)
	// Complete means production completed.
	Complete()
}

type Publisher interface {
	// Subscribe subscribe elements from a publisher, returns a Disposable.
	// You can add some custome options.
	// Using `OnSubscribe`, `OnNext`, `OnComplete` and `OnError` as handler wrapper.
	Subscribe(ctx context.Context, ops ...OptSubscribe) Disposable
}

type Scheduler interface {
	io.Closer
	// Do register function to do.
	Do(ctx context.Context, fn Do)
}

type SignalType int8

type Subscriber interface {
	// OnSubscribe handle event when subscribe begin.
	OnSubscribe(ctx context.Context, s Subscription)
	// OnNext handle event when a new element produced.
	OnNext(ctx context.Context, s Subscription, elem payload.Payload)
	// OnComplete handle event when subscribe finish.
	OnComplete(ctx context.Context)
	// OnError handle event when an error occurred。
	OnError(ctx context.Context, err error)
}

type Subscription interface {
	// Request pull next n elements. (It was used for FlowControl)
	// When you call it, subscriber will emit `OnRequest` event and you can use `DoOnRequest` catch it.
	Request(n int)
	// Cancel cancel the current subscriber.
	// Subscribers will emit `OnCancel` event and you can use `DoOnCancel` catch it.
	Cancel()
	// N returns current N in queue.
	N() int
}