mino

type Address interface {
	encoding.TextMarshaler

	// Equal returns true when both addresses are similar.
	Equal(other Address) bool

	// String returns a string representation of the address.
	String() string

	// ConnectionType returns the type of connection for this Address
	ConnectionType() AddressConnectionType
}

type AddressConnectionType int32

type AddressFactory interface {
	serde.Factory

	// FromText returns the address of the text.
	FromText(text []byte) Address
}

type AddressIterator interface {
	// Seek moves the iterator to a specific index.
	Seek(int)

	// HasNext returns true if a address is available, false if the iterator is
	// exhausted.
	HasNext() bool

	// GetNext returns the next address in case HasNext returns true, otherwise
	// no assumption can be done.
	GetNext() Address
}

type Filter struct {
	// Indices indicates the indexes of the elements that must be included. This
	// list if updated based on the filter that we apply. For example, [0,3]
	// tells that this filter keeps 2 elements from the underlying data
	// structure we filter that are stored at indexes 0, 3. This list is always
	// sorted and can be shifted in a circular way.
	Indices []int
}

type FilterUpdater func(*Filter)

type Handler interface {
	// Process handles a single request by producing the response according to
	// the request message.
	Process(req Request) (resp serde.Message, err error)

	// Stream is a handler for a stream request. It will open a stream with the
	// participants.
	Stream(out Sender, in Receiver) error
}

type Mino interface {
	GetAddressFactory() AddressFactory

	// GetAddress returns the address that other participants should use to contact
	// this instance.
	GetAddress() Address

	// WithSegment returns a new mino instance that will have its URI path
	// extended with the provided segment.
	WithSegment(segment string) Mino

	// CreateRPC creates an RPC that can send to and receive from a unique
	// URI which is computed with URI = (segment || segment || ... || name). If
	// the combination already exists, it will return an error.
	CreateRPC(name string, h Handler, f serde.Factory) (RPC, error)
}

type Players interface {
	// Take should a subset of the players according to the filters.
	Take(...FilterUpdater) Players

	// AddressIterator returns an iterator that prevents changes of the
	// underlying array and save memory by iterating over the same array.
	AddressIterator() AddressIterator

	// Len returns the length of the set of players.
	Len() int
}

type RPC interface {
	// Call is a basic request to one or multiple distant peers. It directly
	// contacts all the players and thus expects a reasonable number of peers.
	//
	// The response channel must be closed once the request ends in a result,
	// either a reply or an error.
	Call(ctx context.Context, req serde.Message, players Players) (<-chan Response, error)

	// Stream is a persistent request that will be closed only when the
	// orchestrator is done or an error has occured, or the context is done.
	Stream(ctx context.Context, players Players) (Sender, Receiver, error)
}

type Receiver interface {
	// Recv waits for a message to send received from the stream. It returns the
	// address of the original sender and the message, or a message if the
	// stream is closed or the context is done.
	Recv(context.Context) (Address, serde.Message, error)
}

type Request struct {
	// Address is the address of the sender of the request.
	Address Address

	// Message is the message of the request.
	Message serde.Message
}

type Response interface {
	// GetFrom returns the address of the source of the reply.
	GetFrom() Address

	// GetMessageOrError returns the message, or an error if something wrong
	// happened.
	GetMessageOrError() (serde.Message, error)
}

type Sender interface {
	// Send sends the message to all the addresses. It returns a channel that
	// will be populated with errors coming from the network layer if the
	// message cannot be sent. The channel must be closed after the message has
	// been sent or failed to be sent.
	Send(msg serde.Message, addrs ...Address) <-chan error
}

type UnsupportedHandler struct{}