MatchingEngine support for market to market matching

MatchingEngine.scala

class MatchingEngine(buy: OrderBook, sell: OrderBook, orderTypes: (Order => OrderType))
  extends mutable.Publisher[OrderBookEvent] {

  private var _referencePrice: Option[Double] = None

  def referencePrice = _referencePrice.get

  def referencePrice_=(price: Double) {
    _referencePrice = Some(price)
  }

  // unchanged methods are not shown
  // ...

  private def tryMatchWithTop(order: Order, top: Order): Option[Trade] = {
    def trade(price: Double) = {
      _referencePrice = Some(price)
      val (buy, sell) = if (order.side == Buy) (order, top) else (top, order)
      Some(Trade(buy.broker, sell.broker, price, math.min(buy.qty, sell.qty)))
    }

    lazy val oppositeBestLimit = {
      val oppositeBook = if (order.side == Buy) sell else buy
      oppositeBook.bestLimit
    }

    (order, top) match {

      case (_, topLimitOrder: LimitOrder) => {
        if (orderTypes(order).crossesAt(topLimitOrder.limit)) trade(topLimitOrder.limit)
        else None
      }

      case (limitOrder: LimitOrder, _: MarketOrder) => trade(oppositeBestLimit match {
        case Some(limit) => if (orderTypes(limitOrder).crossesAt(limit)) limit else limitOrder.limit
        case None => limitOrder.limit
      })

      case (_: MarketOrder, _: MarketOrder) => trade(oppositeBestLimit match {
        case Some(limit) => limit
        case None => _referencePrice match {
          case Some(price) => price
          case None => throw new IllegalStateException("Can't execute a trade with two market orders without best limit or reference price")
        }
      })
    }
  }
}