prystupa

object OrderType {

  def all(buy: => OrderBook, sell: => OrderBook): PartialFunction[Order, OrderType] = {

    // omitted [unmodified] order type definitions for limit and market orders
    // ...
    
    case self@PegOrder(_, side, _) => new OrderType {
      private lazy val book = side match {
        case Buy => buy

prystupa

sealed trait OrderBookEvent

case class Trade(buyingBroker: String, sellingBroker: String,
                 price: Double, qty: Double) extends OrderBookEvent

prystupa

sealed trait PriceLevel

case class LimitPrice(limit: Double) extends PriceLevel

case object MarketPrice extends PriceLevel

prystupa

sealed trait PriceLevel

case class LimitPrice(limit: Double) extends PriceLevel

prystupa

trait Order {
  val broker: String
  val qty: Double
  val side: Side
}

case class LimitOrder(broker: String, side: Side, qty: Double, limit: Double) extends Order

case class MarketOrder(broker: String, side: Side, qty: Double) extends Order

prystupa

object OrderType {

  def all(): PartialFunction[Order, OrderType] = {

    // Unmodified code omitted
    // ...

    case self@MarketOrder(_, _, _) => new OrderType {
      def bookDisplay: String = "MO"

prystupa

trait OrderType {
  def bookDisplay: String

  def price: PriceLevel
}

object OrderType {

  def all(): PartialFunction[Order, OrderType] = {

prystupa

Feature: Maintaining reference price as trades occur

  Scenario: Updating reference price as it is set at the opening and trades occur
    Given the reference price is set to "10"

    When the following orders are submitted in this order:
      | Broker | Side | Qty | Price |
      | A      | Buy  | 100 | 11    |
      | B      | Sell | 100 | 11    |
    Then the following trades are generated:

prystupa

# Matching using a reference price

  Scenario: Matching incoming Buy market order against Sell market order when no best limit price is available
    Given the reference price is set to "10"
    Given the following orders are submitted in this order:
      | Broker | Side | Qty | Price |
      | A      | Sell | 100 | MO    |
      | B      | Buy  | 100 | MO    |
    Then the following trades are generated:
      | Buying broker | Selling broker | Qty | Price |

prystupa

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)
  }