Trader decorator

package main

type CreateAttempt struct {
    // ...
}

type CancelAttempt struct {
    // ...
}

type MoveAttempt struct {
    // ...
}

type Stats struct {
}

type Trader interface {
    CreateOrder(CreateAttempt)
    CancelOrder(CancelAttempt)
    MoveOrder(MoveAttempt)
    Stats() Stats
}

type Queue interface {
    Add(CreateAttempt)
    Iterator() <-chan CreateAttempt
}

type loggerTraderDecorator struct {
    Trader
}

func (l *loggerTraderDecorator) CreateOrder(attempt CreateAttempt) {
    // logging receive create

    l.Trader.CreateOrder(attempt)
}

func (l *loggerTraderDecorator) CancelOrder(attempt CancelAttempt) {
    // logging receive cancel

    l.Trader.CancelOrder(attempt)
}

func (l *loggerTraderDecorator) MoveOrder(attempt MoveAttempt) {
    // logging receive move

    l.Trader.MoveOrder(attempt)
}

func WrapLoggerDecorator(source Trader) Trader {
    return &loggerTraderDecorator{source}
}

type queueTraderDecorator struct {
    Trader
    queue Queue
}

func (q *queueTraderDecorator) CreateOrder(attempt CreateAttempt) {
    q.queue.Add(attempt)
}

func (q *queueTraderDecorator) run() {
    for attempt := range q.queue.Iterator() {
        q.Trader.CreateOrder(attempt)
    }
}

func WrapQueueDecorator(source Trader) Trader {
    queueDecorated := &queueTraderDecorator{
        source,
        nil, //new(Queue),
    }

    go queueDecorated.run()

    return queueDecorated
}

type hitTrader struct {
}

func (hitTrader) CreateOrder(CreateAttempt) {
    panic("implement me")
}

func (hitTrader) CancelOrder(CancelAttempt) {
    panic("implement me")
}

func (hitTrader) MoveOrder(MoveAttempt) {
    panic("implement me")
}

func (hitTrader) Stats() Stats {
    panic("implement me")
}

func newTrader(
// ... client connection
) *hitTrader {
    return &hitTrader{}
}

func main() {
    trader := WrapLoggerDecorator(WrapQueueDecorator(newTrader(
    // ...
    )))

    _ = trader
}