isglb

type ChanClientStream[S proto.Status] struct {
	// contains filtered or unexported fields
}

type ChanClientStreamFactory[S proto.Status] struct {
	// contains filtered or unexported fields
}

type ChanServerConn[S proto.Status] struct {
	// contains filtered or unexported fields
}

type Client[S proto.Status, R proto.Report] struct {
	*stream.Client[proto.Request, S]

	OnStatusRecv func(s S)
	// contains filtered or unexported fields
}

type ClientStreamFactory[S proto.Status] interface {
	NewClientStream(ctx context.Context) (stream.ClientStream[proto.Request, S], error)
}

type ComputationReporter interface {
	// Bind ComputationReporter to a channel
	// you should push your ComputationReport into this channel
	Bind(chan<- *pb.ComputationReport)
}

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

type ServerConn[S proto.Status] interface {
	setmap.IfaceSetMapItem[string]
	Send(S) error
	Recv() (proto.Request, error)
}

type Service[S proto.Status] struct {
	Alg proto.Algorithm // The core algorithm
	// contains filtered or unexported fields
}

type SessionEvent struct {
	Session *pb.ClientNeededSession
	State   SessionEvent_State
}

type SessionEvent_State int32

type SessionTracker interface {
	// FetchSessionEvent fetch a SessionEvent
	// Block until return a new SessionEvent
	FetchSessionEvent() *SessionEvent
}

type StupidComputationReporter struct {
	sync.Once
}

type StupidSessionTracker struct {
}

type StupidTrackForwarder struct {
}

type StupidTrackProcesser struct {
}

type StupidTransmissionReporter struct {
	sync.Once
}

type ToolBox struct {
	TrackForwarder       TrackForwarder
	TrackProcessor       TrackProcessor
	TransmissionReporter TransmissionReporter
	ComputationReporter  ComputationReporter
	SessionTracker       SessionTracker
}

type TrackForwarder interface {

	// StartForwardTrack begin a track route
	StartForwardTrack(trackInfo *pb.ForwardTrack)
	// StopForwardTrack end a track route
	StopForwardTrack(trackInfo *pb.ForwardTrack)
	// ReplaceForwardTrack change a track route
	ReplaceForwardTrack(oldTrackInfo *pb.ForwardTrack, newTrackInfo *pb.ForwardTrack)
}

type TrackProcessor interface {

	// StartProceedTrack begin a track proceed
	StartProceedTrack(trackInfo *pb.ProceedTrack)
	// StopProceedTrack end a track proceed
	StopProceedTrack(trackInfo *pb.ProceedTrack)
	// ReplaceProceedTrack change a track proceed
	ReplaceProceedTrack(oldTrackInfo *pb.ProceedTrack, newTrackInfo *pb.ProceedTrack)
}

type TransmissionReporter interface {
	// Bind TransmissionReporter to a channel
	// you should push your TransmissionReport into this channel
	Bind(chan<- *pb.TransmissionReport)
}