9.3.4 الگو Mediator

1package main
2
3type train interface {
4    requestArrival()
5    departure()
6    permitArrival()
7}

 1package main
 2
 3import "fmt"
 4
 5type passengerTrain struct {
 6    mediator mediator
 7}
 8
 9func (g *passengerTrain) requestArrival() {
10    if g.mediator.canLand(g) {
11        fmt.Println("PassengerTrain: Landing")
12    } else {
13        fmt.Println("PassengerTrain: Waiting")
14    }
15}
16
17func (g *passengerTrain) departure() {
18    fmt.Println("PassengerTrain: Leaving")
19    g.mediator.notifyFree()
20}
21
22func (g *passengerTrain) permitArrival() {
23    fmt.Println("PassengerTrain: Arrival Permitted. Landing")
24}

 1package main
 2
 3import "fmt"
 4
 5type goodsTrain struct {
 6    mediator mediator
 7}
 8
 9func (g *goodsTrain) requestArrival() {
10    if g.mediator.canLand(g) {
11        fmt.Println("GoodsTrain: Landing")
12    } else {
13        fmt.Println("GoodsTrain: Waiting")
14    }
15}
16
17func (g *goodsTrain) departure() {
18    g.mediator.notifyFree()
19    fmt.Println("GoodsTrain: Leaving")
20}
21
22func (g *goodsTrain) permitArrival() {
23    fmt.Println("GoodsTrain: Arrival Permitted. Landing")
24}

1package main
2
3type mediator interface {
4    canLand(train) bool
5    notifyFree()
6}

 1package main
 2
 3import "sync"
 4
 5type stationManager struct {
 6    isPlatformFree bool
 7    lock           *sync.Mutex
 8    trainQueue     []train
 9}
10
11func newStationManger() *stationManager {
12    return &stationManager{
13        isPlatformFree: true,
14        lock:           &sync.Mutex{},
15    }
16}
17
18func (s *stationManager) canLand(t train) bool {
19    s.lock.Lock()
20    defer s.lock.Unlock()
21    if s.isPlatformFree {
22        s.isPlatformFree = false
23        return true
24    }
25    s.trainQueue = append(s.trainQueue, t)
26    return false
27}
28
29func (s *stationManager) notifyFree() {
30    s.lock.Lock()
31    defer s.lock.Unlock()
32    if !s.isPlatformFree {
33        s.isPlatformFree = true
34    }
35    if len(s.trainQueue) > 0 {
36        firstTrainInQueue := s.trainQueue[0]
37        s.trainQueue = s.trainQueue[1:]
38        firstTrainInQueue.permitArrival()
39    }
40}

 1package main
 2
 3func main() {
 4    stationManager := newStationManger()
 5    passengerTrain := &passengerTrain{
 6        mediator: stationManager,
 7    }
 8    goodsTrain := &goodsTrain{
 9        mediator: stationManager,
10    }
11    passengerTrain.requestArrival()
12    goodsTrain.requestArrival()
13    passengerTrain.departure()
14}

1PassengerTrain: Landing
2GoodsTrain: Waiting
3PassengerTrain: Leaving
4GoodsTrain: Arrival Permitted. Landing

  1package main
  2
  3import (
  4    "fmt"
  5    "sync"
  6)
  7
  8type train interface {
  9    requestArrival()
 10    departure()
 11    permitArrival()
 12}
 13
 14type passengerTrain struct {
 15    mediator mediator
 16}
 17
 18func (g *passengerTrain) requestArrival() {
 19    if g.mediator.canLand(g) {
 20        fmt.Println("PassengerTrain: Landing")
 21    } else {
 22        fmt.Println("PassengerTrain: Waiting")
 23    }
 24}
 25
 26func (g *passengerTrain) departure() {
 27    fmt.Println("PassengerTrain: Leaving")
 28    g.mediator.notifyFree()
 29}
 30
 31func (g *passengerTrain) permitArrival() {
 32    fmt.Println("PassengerTrain: Arrival Permitted. Landing")
 33}
 34
 35type goodsTrain struct {
 36    mediator mediator
 37}
 38
 39func (g *goodsTrain) requestArrival() {
 40    if g.mediator.canLand(g) {
 41        fmt.Println("GoodsTrain: Landing")
 42    } else {
 43        fmt.Println("GoodsTrain: Waiting")
 44    }
 45}
 46
 47func (g *goodsTrain) departure() {
 48    g.mediator.notifyFree()
 49    fmt.Println("GoodsTrain: Leaving")
 50}
 51
 52func (g *goodsTrain) permitArrival() {
 53    fmt.Println("GoodsTrain: Arrival Permitted. Landing")
 54}
 55
 56type mediator interface {
 57    canLand(train) bool
 58    notifyFree()
 59}
 60
 61type stationManager struct {
 62    isPlatformFree bool
 63    lock           *sync.Mutex
 64    trainQueue     []train
 65}
 66
 67func newStationManger() *stationManager {
 68    return &stationManager{
 69        isPlatformFree: true,
 70        lock:           &sync.Mutex{},
 71    }
 72}
 73
 74func (s *stationManager) canLand(t train) bool {
 75    s.lock.Lock()
 76    defer s.lock.Unlock()
 77    if s.isPlatformFree {
 78        s.isPlatformFree = false
 79        return true
 80    }
 81    s.trainQueue = append(s.trainQueue, t)
 82    return false
 83}
 84
 85func (s *stationManager) notifyFree() {
 86    s.lock.Lock()
 87    defer s.lock.Unlock()
 88    if !s.isPlatformFree {
 89        s.isPlatformFree = true
 90    }
 91    if len(s.trainQueue) > 0 {
 92        firstTrainInQueue := s.trainQueue[0]
 93        s.trainQueue = s.trainQueue[1:]
 94        firstTrainInQueue.permitArrival()
 95    }
 96}
 97
 98func main() {
 99    stationManager := newStationManger()
100    passengerTrain := &passengerTrain{
101        mediator: stationManager,
102    }
103    goodsTrain := &goodsTrain{
104        mediator: stationManager,
105    }
106    passengerTrain.requestArrival()
107    goodsTrain.requestArrival()
108    passengerTrain.departure()
109}

1PassengerTrain: Landing
2GoodsTrain: Waiting
3PassengerTrain: Leaving
4GoodsTrain: Arrival Permitted. Landing