package player import ( "fmt" "sort" "sync" "git.maze.io/go/bragi/config" ) // NotFound signals the player can not be found. type NotFound struct { Name string } func (err NotFound) Error() string { return fmt.Sprintf("player: %q can not be found", err.Name) } // Factory is a function that can instantiate a new Player. type Factory func(*config.Player) (Player, error) // Detector checks if this player is available. type Detector func() bool type detector struct { Name string New Factory Detect Detector Priority int } var ( // protocols holds the per protocol factories protocols = new(sync.Map) detectors []detector // instances holds the named players instances = new(sync.Map) ) // Register a new protocol factory. func Register(name string, f Factory, d Detector, priority int) { if _, loaded := protocols.LoadOrStore(name, f); loaded { panic(fmt.Sprintf("player type %q already registered", name)) } if d != nil { detectors = append(detectors, detector{ Name: name, New: f, Detect: d, Priority: priority, }) sort.Slice(detectors, func(i, j int) bool { return detectors[i].Priority < detectors[j].Priority }) } } // New returns a player factory for the requested type. func New(config *config.Player) (Player, error) { f, ok := protocols.Load(config.Protocol) if !ok { return nil, NotFound{Name: config.Protocol} } p, err := f.(Factory)(config) if err != nil { return nil, err } instances.Store(config.Name, p) return p, nil } // RegisterInstance registers a new player instance by name. func RegisterInstance(name string, p Player) { if _, loaded := instances.LoadOrStore(name, p); loaded { panic(fmt.Sprintf("player instance %q already registered", name)) } } // Lookup a previously registered instance. func Lookup(name string) (Player, error) { f, ok := instances.Load(name) if ok { return f.(Player), nil } return nil, NotFound{Name: name} } // Detect what player is available. func Detect() (name string, factory Factory) { for _, d := range detectors { if d.Detect() { return d.Name, d.New } } return "", nil }