package com.activequant.trading;
import java.util.HashMap;
import java.util.Map;
import com.activequant.domainmodel.ETransportType;
import com.activequant.domainmodel.TimeStamp;
import com.activequant.domainmodel.exceptions.IncompleteOrderInstructions;
import com.activequant.domainmodel.exceptions.NoSuchOrderBook;
import com.activequant.domainmodel.exceptions.TransportException;
import com.activequant.domainmodel.exceptions.UnsupportedOrderType;
import com.activequant.domainmodel.orderbook.MarketState;
import com.activequant.domainmodel.streaming.OrderStreamEvent;
import com.activequant.domainmodel.streaming.StreamEvent;
import com.activequant.domainmodel.trade.order.Order;
import com.activequant.domainmodel.trade.order.SingleLegOrder;
import com.activequant.interfaces.trading.IExchange;
import com.activequant.interfaces.trading.IOrderTracker;
import com.activequant.interfaces.transport.ITransportFactory;
import com.activequant.trading.virtual.LimitOrderBook;
import com.activequant.utils.UniqueTimeStampGenerator;
import com.activequant.utils.events.Event;
/**
* This transport exchange acts as an injectable exchange, based on a transport
* factory. The Google protocol buffer approach. not that it's anything specific
* which Google came up with, it's just that Google has a good open source
* library for this stuff.
*
* This exchange is a default transport exchange. It requires a
* ITransportFactory to work properly. This transport exchange must be injected
* into a trading system environment.
*
* TODOs: this exchange should also fetch a list of open orders from somewhere (to be discussed)
*
* @author GhostRider
*
*/
public class DefaultTransportExchange implements IExchange {
private final ITransportFactory transFac;
private final Event<OrderStreamEvent> event = new Event<OrderStreamEvent>();
private final Event<MarketState> marketStateEvent = new Event<MarketState>();
private final Map<String, TransportOrderTracker> trackers = new HashMap<String, TransportOrderTracker>();
private UniqueTimeStampGenerator utsg = new UniqueTimeStampGenerator();
public DefaultTransportExchange(ITransportFactory transFac)
throws TransportException {
this.transFac = transFac;
}
@Override
public TimeStamp currentExchangeTime() {
return new TimeStamp();
}
@Override
public IOrderTracker prepareOrder(Order order) throws UnsupportedOrderType,
IncompleteOrderInstructions {
if (order.getOrderId() == null)
order.setOrderId("ID"+utsg.now().toString());
// generate publisher and receiver for this order tracker ...
//
SingleLegOrder slo = (SingleLegOrder) order;
String tdiId = slo.getTradInstId();
//
TransportOrderTracker tracker;
try {
tracker = new TransportOrderTracker(
transFac.getPublisher(ETransportType.TRAD_DATA, tdiId),
transFac.getReceiver(ETransportType.TRAD_DATA, tdiId), slo);
trackers.put(order.getOrderId(), tracker);
return tracker;
} catch (TransportException e) {
e.printStackTrace();
// so dirty again, we would have to alter all the interface.
throw new UnsupportedOrderType("Transport Exception: " + e);
}
}
@Override
public IOrderTracker getOrderTracker(String orderId) {
//
return trackers.get(orderId);
}
@Override
public AbstractOrderBook<?> getOrderBook(String tradeableInstrumentId)
throws NoSuchOrderBook {
LimitOrderBook lob = new LimitOrderBook(null, null);
// ???
return null;
}
@Override
public void processStreamEvent(StreamEvent se) {
// doing nothing.
}
public Event<OrderStreamEvent> getEvent() {
return event;
}
public Event<MarketState> getMarketStateEvent() {
return marketStateEvent;
}
}