intracom

type Action string

type Broadcaster[T any] interface {
	Broadcast(requests <-chan any, messages chan T)
}

type BufferPolicyDropNewest[T any] struct{}

type BufferPolicyDropNewestAfterTimeout[T any] struct {
	Timer      *time.Timer
	DropTimout time.Duration
}

type BufferPolicyDropNone[T any] struct{}

type BufferPolicyDropOldest[T any] struct{}

type BufferPolicyDropOldestAfterTimeout[T any] struct {
	Timer       *time.Timer
	DropTimeout time.Duration
}

type BufferPolicyHandler[T any] interface {
	Handle(ch chan T, message T, stopC <-chan struct{}) error
}

type Channel[T any] interface {
	ChannelCloser[T]
	ChannelSender[T]
	Chan() <-chan T
}

type ChannelCloser[T any] interface {
	Close() error
}

type ChannelSender[T any] interface {
	Send(message T) error
}

type ErrIntracom struct {
	Action Action
	Err    error
}

type ErrSubscribe struct {
	Topic    string
	Consumer string
	Action   Action
	Err      error
}

type ErrTopic struct {
	Topic  string
	Action Action
	Err    error
}

type Error string

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

type Option func(*Intracom)

type SubscriberConfig[T any] struct {
	ConsumerGroup string
	ErrIfExists   bool
	BufferSize    int
	BufferPolicy  BufferPolicyHandler[T]
	DropTimeout   time.Duration
}

type Subscription struct {
	Topic         string
	ConsumerGroup string
	// MaxWaitTimeout is the max time to wait before error due to a topic not existing.
	MaxWaitTimeout time.Duration
}

type SyncBroadcaster[T any] struct {
	SubscriberAware bool // if true, broadcaster wont broadcast if there are no subscribers.
}

type Topic[T any] interface {
	Name() string                                                              // Name returns the unique name of the topic.
	PublishChannel() chan<- T                                                  // PublishChannel returns the channel publishers use to send messages to the topic.
	Subscribe(ctx context.Context, conf SubscriberConfig[T]) (<-chan T, error) // Subscribe will attemp to add a consumer group to the topic.
	Unsubscribe(consumer string, ch <-chan T) error                            // Unsubscribe will remove the consumer group from the topic and close the subscriber channel.
	Close() error                                                              // Close will remove all consumer groups from the topic and close all channels.
}

type TopicConfig struct {
	Name            string // unique name for the topic
	ErrIfExists     bool   // return error if topic already exists
	SubscriberAware bool   // if true, topic broadcaster wont broadcast if there are no subscribers.
}

type TopicOption[T any] func(*topic[T])