Go Bridge Pattern

bridge.go

package main

import "fmt"

// CollectorInterface defines the interface for the collector abstraction
type CollectorInterface interface {
    Collect()
    SetResolver(ResolverInterface)
}

// ResolverInterface defines the interface for the resolver implementation
type ResolverInterface interface {
    Resolve()
}

// DispatcherInterface defines the interface for the dispatcher implementation
type DispatcherInterface interface {
    Dispatch()
}

// ConcreteCollector is a concrete implementation of the CollectorInterface
type ConcreteCollector struct {
    resolver ResolverInterface
}

// Collect method for ConcreteCollector
func (c *ConcreteCollector) Collect() {
    fmt.Println("Collector: Collecting data")
    c.resolver.Resolve()
}

// SetResolver sets the resolver for ConcreteCollector
func (c *ConcreteCollector) SetResolver(r ResolverInterface) {
    c.resolver = r
}

// ConcreteResolver is a concrete implementation of the ResolverInterface
type ConcreteResolver struct {
    dispatcher DispatcherInterface
}

// Resolve method for ConcreteResolver
func (r *ConcreteResolver) Resolve() {
    fmt.Println("Resolver: Resolving data")
    r.dispatcher.Dispatch()
}

// SetDispatcher sets the dispatcher for ConcreteResolver
func (r *ConcreteResolver) SetDispatcher(d DispatcherInterface) {
    r.dispatcher = d
}

// ConcreteDispatcher is a concrete implementation of the DispatcherInterface
type ConcreteDispatcher struct{}

// Dispatch method for ConcreteDispatcher
func (d *ConcreteDispatcher) Dispatch() {
    fmt.Println("Dispatcher: Dispatching data")
}

func main() {
    dispatcher := &ConcreteDispatcher{}
    resolver := &ConcreteResolver{}
    resolver.SetDispatcher(dispatcher)
    collector := &ConcreteCollector{}
    collector.SetResolver(resolver)

    collector.Collect()
}