adapter

type AdapterEvent struct {
	ConnectionId messages.ConnectionID
	Type         EventType
	Message      string
	Error        error
}

type ConnectionAdapter interface {
	// Start starts the connection
	Start() error

	// Stop stops the connection
	Close() error

	// Send sends a message to the connection
	Send(msg messages.Message)
}

type ConnectionAdapterOptions struct {
	// ConnectionID is the connection id
	ConnectionId messages.ConnectionID

	// LocalDeviceId is the id of the local device
	LocalDeviceId uuid.UUID

	// PeerDeviceId is the id of the peer device that this connection is bridged to/from
	PeerDeviceId uuid.UUID

	// PeerDevicePublicKey is the public key of the peer device that this connection is bridged to/from
	PeerDevicePublicKey string

	// BridgeOptions are the bridge options
	BridgeOptions messages.BridgeOptions

	// LocalPublicKey is the public key of the local device
	LocalPublicKey string

	// LocalPrivateKey is the private key of the local device
	LocalPrivateKey string

	// ResponseInterval is the interval in which the connection accept/failed message is sent
	ResponseInterval time.Duration

	// ConnectionReadTimeout is the read timeout for the connection
	ConnectionReadTimeout time.Duration

	// ThroughputLimit is the throughput limit for the connection in bytes per second
	ThroughputLimit int

	// ReadBufferSize is the size of the read buffer in bytes
	ReadBufferSize int
}

type ConnectionAdapterState interface {
	Start() error

	Stop() error

	Close() error

	HandleMessage(msg messages.Message) (ConnectionAdapterState, error)
}

type ConnectionMode string

type EventType string

type Forwarder interface {
	// Start starts the forwarder, returns a channel to which messages can be sent
	Start() error

	// AsyncSend sends a message asynchronously, returns an error if the send buffer is full
	SendAsync(msg messages.Message) error

	// Ack acknowledges a message, returns an error if the message is not found
	Ack(seqNo uint64, re bool) error

	// Stop stops the forwarder, and closes the send channel and the underlying connection
	Close() error
}

type ForwarderOptions struct {
	// Throughput is the maximum throughput in bytes per second
	Throughput int

	// LocalDeviceId is the id of the local device
	LocalDeviceID uuid.UUID

	// PeerDeviceId is the id of the peer device that this connection is bridged to/from
	PeerDeviceID uuid.UUID

	// ConnectionId is the connection id
	ConnectionID messages.ConnectionID

	// ReadTimeout is the read timeout
	ReadTimeout time.Duration

	// ReadBufferSize is the size of the read buffer in bytes
	ReadBufferSize int
}

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

type MessageHeap interface {
	// Test checks if the sequence number of msg is the next expected sequence number n_seq.
	// If it is, it returns a sequence of messages that are ready to be sent to the
	// port. The first message in the sequence is msg.
	//
	// The sequence is guaranteed to be in order, and contains no gaps, i.e. the
	// sequence number of the last message in the sequence is n_seq + len(sequence) - 1.
	//
	// If n_seq is not the next expected sequence number, it is kept in the queue until
	// a message with the next expected sequence number is received and a sequence
	// containing that message is returned.
	//
	// If the sequence number of msg is less than n_seq, it is considered an old message
	// and will be discarded.
	//
	// If the queue is full, or if the gap between n_seq and the sequence number of msg is
	// larger than MaxQueueGap, it returns an error.
	Test(msg messages.DataMessage) ([]messages.DataMessage, error)
}

type MessageHeapOptions struct {
	// MaxQueueSize is the maximum number of messages that can be queued
	MaxQueueSize int

	// MaxQueueGap is the maximum number of messages that can be missing from the queue
	MaxQueueGap int
}

type PriorityQueue []*Item

type Window interface {
	// contains filtered or unexported methods
}

type WindowOptions struct {
	// initial size of the window in bytes
	InitialCap float64

	// minimum rtt variance of the window in microseconds
	MinRTTVAR float64

	// minimum rto of the window in microseconds
	MinRTO float64

	// maximum rto of the window in microseconds
	MaxRTO float64

	// initial rto of the window in microseconds
	InitialRTO float64

	// rtt factor for calculating the rto
	RTTFactor float64 // 4.0

	// ewma alpha
	EWMAAlpha float64 // 0.125

	// ewma beta
	EWMABeta float64 // 0.25

	// MaxCap is the maximum size of the window in bytes
	MaxCap float64

	// WindowDownscaleFactor is the factor by which the window is downscaled when a retransmission is detected
	WindowDownscaleFactor float64

	// WindowUpscaleFactor is the factor by which the window is upscaled when a retransmission is not detected
	WindowUpscaleFactor float64

	// HistSize is the size of the sliding window histogram
	RTTHistSize int
}