pubsub

type Change struct {
	// Operation which operation is performed by this change
	Operation Operation
	// Key the key of the affected item, if any
	Key string
	// Value the value of the affected item, if any
	Value []byte
}

type ChannelWatch struct {
	// Chan is the channel to watch for incoming data
	Chan reflect.Value
	// Callback is the function to call with that data (or empty if no data)
	Callback func(value interface{})
}

type Differ interface {
	DetermineDiffs(localCollection LocalCollection) []string
}

type Driver interface {
	// Publisher return a `DriverPublisher` for the given name and topic.
	// The caller passes the `Updaters`, `Restarted` checker and `Differ`.
	// These can be used to:
	// * add to or remove from the updaters
	// * determine if the topic has been restarted
	// * diff the current known state from the target known state
	Publisher(global bool, name, topic string, persistent bool, updaterList *Updaters, restarted Restarted, differ Differ) (DriverPublisher, error)
	// Subscriber return a `DriverSubscriber` for the given name and topic.
	// This is expected to create a `DriverSubscriber`, but not start it.
	// Once started, when changes arrive, they should be published to the provided
	// channel. Each update to the channel is of type `Change`, which encapsulates
	// the operation, key and value.
	Subscriber(global bool, name, topic string, persistent bool, C chan Change) (DriverSubscriber, error)
	// DefaultName Return the default name to use for an agent, when the name
	// is not provided.
	DefaultName() string
}

type DriverPublisher interface {
	// Start the publisher, if any startup is necessary.
	// This is expected to return immediately. If it needs to run in the
	// background, it is the responsibility of the driver to run it as a separate
	// goroutine.
	Start() error
	// Load current status from persistence. Usually called only on first start.
	// The implementation is responsible for determining if the load is necessary
	// or already has been performed. If it has been already, it should not change
	// anything. The caller has no knowledge of where the persistent state was
	// stored: disk, databases, or vellum. All it cares about is that it gets
	// a key-value list.
	Load() (map[string][]byte, int, error)
	// Publish a key-value pair to all subscribers and optionally persistence
	Publish(key string, item []byte) error
	// Unpublish a key, i.e. delete it and publish its deletion to all subscribers
	Unpublish(key string) error
	// Restart set the restartCounter for the topic. Zero implies no restart
	Restart(restartCounter int) error

	// Stop publishing
	// This is expected to return immediately.
	Stop() error

	// CheckMaxSize to see if it will fit
	CheckMaxSize(key string, val []byte) error

	// LargeDirName returns the directory to be used for large fields
	LargeDirName() string
}

type DriverSubscriber interface {
	// Start subscribing to a name and topic and publish changes to the channel.
	// This is expected to return immediately. If it needs to run in the
	// background, it is the responsibility of the driver to run it as a separate
	// goroutine.
	Start() error

	// Load initial status from persistence. Usually called only on first start.
	// The implementation is responsible for determining if the load is necessary
	// or already has been performed. If it has been already, it should not change
	// anything. The caller has no knowledge of where the persistent state was
	// stored: disk, databases, or vellum. All it cares about is that it gets
	// a key-value list.
	Load() (map[string][]byte, int, error)

	// Stop subscribing to a name and topic
	// This is expected to return immediately.
	Stop() error

	// LargeDirName returns the directory to be used for large fields
	LargeDirName() string
}

type EmptyDriver struct{}

type EmptyDriverPublisher struct{}

type EmptyDriverSubscriber struct{}

type Getter interface {
	Get(key string) (interface{}, error)
}

type LocalCollection map[string][]byte

type Notify struct{}

type Operation byte

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

type Publication interface {
	// CheckMaxSize returns an error if the item is too large
	CheckMaxSize(key string, item interface{}) error
	// Publish - Publish an object
	Publish(key string, item interface{}) error
	// Unpublish - Delete / UnPublish an object
	Unpublish(key string) error
	// SignalRestarted - Signal the publisher has started one more time
	SignalRestarted() error
	// ClearRestarted clear the restarted flag
	ClearRestarted() error
	// Get - Lookup an object
	Get(key string) (interface{}, error)
	// GetAll - Get a copy of the objects.
	GetAll() map[string]interface{}
	// Iterate - Perform some action on all items
	Iterate(function base.StrMapFunc)
	// Close - delete the publisher
	Close() error
}

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

type PublicationOptions struct {
	AgentName  string
	AgentScope string
	TopicType  interface{}
	Persistent bool
}

type Restarted interface {
	IsRestarted() bool
	RestartCounter() int
}

type SubCreateHandler func(ctx interface{}, key string, status interface{})

type SubDeleteHandler func(ctx interface{}, key string, status interface{})

type SubModifyHandler func(ctx interface{}, key string, status interface{},
	oldStatus interface{})

type SubRestartHandler func(ctx interface{}, restartCount int)

type SubSyncHandler func(ctx interface{}, synchronized bool)

type Subscription interface {
	// Get - get / lookup an object by key
	Get(key string) (interface{}, error)
	// GetAll - Get a copy of the objects.
	GetAll() map[string]interface{}
	// Iterate - Perform some action on all items
	Iterate(function base.StrMapFunc)
	// Restarted report if this subscription has been marked as restarted
	Restarted() bool
	// RestartCounter reports how many times this subscription has been restarted
	RestartCounter() int
	// Synchronized report if this subscription has received initial items
	Synchronized() bool
	// ProcessChange - Invoked on the string msg from Subscription Channel
	ProcessChange(change Change)
	// MsgChan - Message Channel for Subscription
	MsgChan() <-chan Change
	// Activate starts the subscription
	Activate() error
	// Close stops the subscription and removes the state
	Close() error
}

type SubscriptionImpl struct {
	C                   <-chan Change
	CreateHandler       SubCreateHandler
	ModifyHandler       SubModifyHandler
	DeleteHandler       SubDeleteHandler
	RestartHandler      SubRestartHandler
	SynchronizedHandler SubSyncHandler
	MaxProcessTimeWarn  time.Duration // If set generate warning if ProcessChange
	MaxProcessTimeError time.Duration // If set generate warning if ProcessChange
	Persistent          bool
	// contains filtered or unexported fields
}

type SubscriptionOptions struct {
	CreateHandler  SubCreateHandler
	ModifyHandler  SubModifyHandler
	DeleteHandler  SubDeleteHandler
	RestartHandler SubRestartHandler
	SyncHandler    SubSyncHandler
	WarningTime    time.Duration
	ErrorTime      time.Duration
	AgentName      string
	AgentScope     string
	TopicImpl      interface{}
	Activate       bool
	Ctx            interface{}
	Persistent     bool
	MyAgentName    string // For logging
}

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