1 /****************************************************************************
2 ** Copyright (c) 2001-2014
3 **
4 ** This file is part of the QuickFIX FIX Engine
5 **
6 ** This file may be distributed under the terms of the quickfixengine.org
7 ** license as defined by quickfixengine.org and appearing in the file
8 ** LICENSE included in the packaging of this file.
9 **
10 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
11 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
12 **
13 ** See http://www.quickfixengine.org/LICENSE for licensing information.
14 **
15 ** Contact ask@quickfixengine.org if any conditions of this licensing are
16 ** not clear to you.
17 **
18 ****************************************************************************/
19 
20 package quickfix.banzai;
21 
22 import java.util.Date;
23 import java.util.Observable;
24 import java.util.Observer;
25 import java.util.Set;
26 import java.util.HashSet;
27 import java.util.Map;
28 import java.util.HashMap;
29 import quickfix.*;
30 import quickfix.banzai.Order;
31 import quickfix.field.*;
32 import javax.swing.SwingUtilities;
33 
34 public class BanzaiApplication implements Application {
35     private OrderTableModel orderTableModel = null;
36     private ExecutionTableModel executionTableModel = null;
37     private ObservableOrder observableOrder = new ObservableOrder();
38     private ObservableLogon observableLogon = new ObservableLogon();
39     static private TwoWayMap sideMap = new TwoWayMap();
40     static private TwoWayMap typeMap = new TwoWayMap();
41     static private TwoWayMap tifMap = new TwoWayMap();
42     static private HashMap execIDs = new HashMap();
43 
BanzaiApplication(OrderTableModel orderTableModel, ExecutionTableModel executionTableModel)44     public BanzaiApplication(OrderTableModel orderTableModel,
45                              ExecutionTableModel executionTableModel) {
46         this.orderTableModel = orderTableModel;
47         this.executionTableModel = executionTableModel;
48     }
49 
onCreate(SessionID sessionID)50     public void onCreate(SessionID sessionID) {}
onLogon(SessionID sessionID)51     public void onLogon(SessionID sessionID) {
52         observableLogon.logon(sessionID);
53     }
onLogout(SessionID sessionID)54     public void onLogout(SessionID sessionID) {
55         observableLogon.logout(sessionID);
56     }
57 
toAdmin(quickfix.Message message, SessionID sessionID)58     public void toAdmin(quickfix.Message message,
59                         SessionID sessionID) {}
60 
toApp(quickfix.Message message, SessionID sessionID)61     public void toApp(quickfix.Message message,
62                       SessionID sessionID) throws DoNotSend {}
63 
fromAdmin(quickfix.Message message,SessionID sessionID)64     public void fromAdmin(quickfix.Message message,SessionID sessionID)
65     throws FieldNotFound, IncorrectDataFormat, IncorrectTagValue, RejectLogon {}
66 
fromApp(quickfix.Message message, SessionID sessionID)67     public void fromApp(quickfix.Message message, SessionID sessionID)
68     throws FieldNotFound, IncorrectDataFormat, IncorrectTagValue, UnsupportedMessageType {
69         try {
70             SwingUtilities.invokeLater(new doFromApp(message, sessionID));
71         } catch(Exception e) {}
72     }
73 
74     public class doFromApp implements Runnable {
75         private quickfix.Message message;
76         private SessionID sessionID;
77 
doFromApp(quickfix.Message message, SessionID sessionID)78         public doFromApp(quickfix.Message message, SessionID sessionID) {
79             this.message = message;
80             this.sessionID = sessionID;
81         }
82 
run()83         public void run() {
84             try {
85                 MsgType msgType = new MsgType();
86                 if(message.getHeader().getField(msgType).valueEquals("8"))
87                     executionReport(message, sessionID);
88                 if(message.getHeader().getField(msgType).valueEquals("9"))
89                     cancelReject(message, sessionID);
90             } catch(FieldNotFound e) {
91                 System.out.println(e);
92             }
93         }
94     }
95 
executionReport(Message message, SessionID sessionID)96     private void executionReport(Message message, SessionID sessionID)
97     throws FieldNotFound {
98 
99         ExecID execID = (ExecID)message.getField(new ExecID());
100         if(alreadyProcessed(execID, sessionID))
101             return;
102 
103         String id = message.getField(new ClOrdID()).getValue();
104         Order order = orderTableModel.getOrder(id);
105         if(order == null)
106             return;
107 
108         LastShares lastShares = new LastShares(0);
109 
110         try {
111             OrderQty orderQty = (OrderQty)message.getField(new OrderQty());
112             int diff = order.getQuantity() - (int)orderQty.getValue();
113             order.setQuantity((int)orderQty.getValue());
114             order.setOpen(order.getOpen() - diff);
115         } catch(FieldNotFound e) {}
116         try {
117             Price price = (Price)message.getField(new Price());
118             order.setLimit(price.getValue());
119         } catch(FieldNotFound e) {}
120         try {
121             message.getField(lastShares);
122         } catch(FieldNotFound e) {}
123 
124         if(lastShares.getValue() > 0) {
125             order.setExecuted((int)message.getField(new CumQty()).getValue());
126             order.setAvgPx(message.getField(new AvgPx()).getValue());
127         }
128         OrdStatus ordStatus = (OrdStatus)message.getField(new OrdStatus());
129 
130         try {
131             order.setOpen((int)message.getField(new LeavesQty()).getValue());
132         } catch(FieldNotFound e) {
133             // FIX40 doesn't have LeavesQty
134             if(ordStatus.valueEquals(OrdStatus.REJECTED) ||
135                     ordStatus.valueEquals(OrdStatus.CANCELED))
136                 order.setOpen(0);
137             else if(ordStatus.valueEquals(OrdStatus.NEW)) {
138                 if(order.isNew()) {
139                     order.setOpen(order.getQuantity());
140                     order.setNew(false);
141                 }
142             }
143             order.setOpen(order.getOpen() - (int)lastShares.getValue());
144         }
145 
146         if(ordStatus.valueEquals(OrdStatus.REJECTED))
147             order.setRejected(true);
148         else if(ordStatus.valueEquals(OrdStatus.CANCELED) ||
149                 ordStatus.valueEquals(OrdStatus.DONE_FOR_DAY))
150             order.setCanceled(true);
151 
152         try {
153             order.setMessage(message.getField(new Text()).getValue());
154         } catch(FieldNotFound e) {
155             order.setMessage(null);
156         }
157 
158         orderTableModel.updateOrder(order, id);
159         observableOrder.update(order);
160 
161         if(lastShares.getValue() > 0) {
162             Execution execution = new Execution();
163             execution.setExchangeID(sessionID + message.getField(new ExecID()).getValue());
164             execution.setSymbol(message.getField(new Symbol()).getValue());
165             execution.setQuantity((int)lastShares.getValue());
166             execution.setPrice(message.getField(new LastPx()).getValue());
167             Side side = (Side)message.getField(new Side());
168             execution.setSide(FIXSideToSide(side));
169             executionTableModel.addExecution(execution);
170         }
171     }
172 
cancelReject(Message message, SessionID sessionID)173     private void cancelReject(Message message, SessionID sessionID)
174     throws FieldNotFound {
175 
176         String id = message.getField(new ClOrdID()).getValue();
177         Order order = orderTableModel.getOrder(id);
178         if(order == null)
179             return;
180         if(order.getOriginalID() != null)
181             order = orderTableModel.getOrder(order.getOriginalID());
182 
183         try {
184             order.setMessage(message.getField(new Text()).getValue());
185         } catch(FieldNotFound e) {}
186         orderTableModel.updateOrder(order, order.getID());
187     }
188 
alreadyProcessed(ExecID execID, SessionID sessionID)189     private boolean alreadyProcessed(ExecID execID, SessionID sessionID) {
190         HashSet set = (HashSet)execIDs.get(sessionID);
191         if(set == null) {
192             set = new HashSet();
193             set.add(execID);
194             execIDs.put(sessionID, set);
195             return false;
196         } else {
197             if(set.contains(execID))
198                 return true;
199             set.add(execID);
200             return false;
201         }
202     }
203 
send(quickfix.Message message, SessionID sessionID)204     private void send(quickfix.Message message, SessionID sessionID) {
205         try {
206             Session.sendToTarget(message, sessionID);
207         } catch(SessionNotFound e) {
208             System.out.println(e);
209         }
210     }
211 
send(Order order)212     public void send(Order order) throws IllegalArgumentException {
213         String beginString = order.getSessionID().getBeginString();
214         if(beginString.equals("FIX.4.0"))
215             send40(order);
216         else if(beginString.equals("FIX.4.1"))
217             send41(order);
218         else if(beginString.equals("FIX.4.2"))
219             send42(order);
220         else if(beginString.equals("FIX.4.3"))
221             send43(order);
222         else if(beginString.equals("FIX.4.4"))
223             send44(order);
224         else if(beginString.equals("FIXT.1.1"))
225             send50(order);
226         else
227         {
228           throw new IllegalArgumentException("Unsupported BeginString '"
229               + beginString + "' in order");
230         }
231 
232         return;
233     }
234 
send40(Order order)235     public void send40(Order order) {
236         quickfix.fix40.NewOrderSingle newOrderSingle =
237             new quickfix.fix40.NewOrderSingle
238             (new ClOrdID(order.getID()),
239              new HandlInst('1'),
240              new Symbol(order.getSymbol()),
241              sideToFIXSide(order.getSide()),
242              new OrderQty(order.getQuantity()),
243              typeToFIXType(order.getType()));
244 
245         send(populateOrder(order, newOrderSingle), order.getSessionID());
246     }
247 
send41(Order order)248     public void send41(Order order) {
249         quickfix.fix41.NewOrderSingle newOrderSingle =
250             new quickfix.fix41.NewOrderSingle
251             (new ClOrdID(order.getID()),
252              new HandlInst('1'),
253              new Symbol(order.getSymbol()),
254              sideToFIXSide(order.getSide()),
255              typeToFIXType(order.getType()));
256         newOrderSingle.set(new OrderQty(order.getQuantity()));
257 
258         send(populateOrder(order, newOrderSingle), order.getSessionID());
259     }
260 
send42(Order order)261     public void send42(Order order) {
262         quickfix.fix42.NewOrderSingle newOrderSingle =
263             new quickfix.fix42.NewOrderSingle
264             (new ClOrdID(order.getID()),
265              new HandlInst('1'),
266              new Symbol(order.getSymbol()),
267              sideToFIXSide(order.getSide()),
268              new TransactTime(),
269              typeToFIXType(order.getType()));
270         newOrderSingle.set(new OrderQty(order.getQuantity()));
271 
272         send(populateOrder(order, newOrderSingle), order.getSessionID());
273     }
274 
send43(Order order)275     public void send43(Order order) {
276         quickfix.fix43.NewOrderSingle newOrderSingle =
277             new quickfix.fix43.NewOrderSingle
278             (new ClOrdID(order.getID()),
279              new HandlInst('1'),
280              sideToFIXSide(order.getSide()),
281              new TransactTime(),
282              typeToFIXType(order.getType()));
283         newOrderSingle.set(new OrderQty(order.getQuantity()));
284         newOrderSingle.set(new Symbol(order.getSymbol()));
285 
286         send(populateOrder(order, newOrderSingle), order.getSessionID());
287     }
288 
send44(Order order)289     public void send44(Order order) {
290         quickfix.fix44.NewOrderSingle newOrderSingle =
291             new quickfix.fix44.NewOrderSingle
292             (new ClOrdID(order.getID()),
293              sideToFIXSide(order.getSide()),
294              new TransactTime(),
295              typeToFIXType(order.getType()));
296         newOrderSingle.set(new OrderQty(order.getQuantity()));
297         newOrderSingle.set(new HandlInst('1'));
298         newOrderSingle.set(new Symbol(order.getSymbol()));
299 
300         send(populateOrder(order, newOrderSingle), order.getSessionID());
301     }
302 
send50(Order order)303     public void send50(Order order) {
304         quickfix.fix50.NewOrderSingle newOrderSingle =
305             new quickfix.fix50.NewOrderSingle
306             (new ClOrdID(order.getID()),
307              sideToFIXSide(order.getSide()),
308              new TransactTime(),
309              typeToFIXType(order.getType()));
310         newOrderSingle.set(new OrderQty(order.getQuantity()));
311         newOrderSingle.set(new HandlInst('1'));
312         newOrderSingle.set(new Symbol(order.getSymbol()));
313 
314         send(populateOrder(order, newOrderSingle), order.getSessionID());
315     }
316 
populateOrder(Order order, quickfix.Message newOrderSingle)317     public quickfix.Message populateOrder
318     (Order order, quickfix.Message newOrderSingle) {
319 
320         OrderType type = order.getType();
321 
322         if(type == OrderType.LIMIT)
323             newOrderSingle.setField(new Price(order.getLimit().doubleValue()));
324         else if(type == OrderType.STOP)
325             newOrderSingle.setField(new StopPx(order.getStop().doubleValue()));
326         else if(type == OrderType.STOP_LIMIT) {
327             newOrderSingle.setField(new Price(order.getLimit().doubleValue()));
328             newOrderSingle.setField(new StopPx(order.getStop().doubleValue()));
329         }
330 
331         newOrderSingle.setField(tifToFIXTif(order.getTIF()))
332         ;
333         return newOrderSingle;
334     }
335 
cancel(Order order)336     public void cancel(Order order) {
337         String beginString = order.getSessionID().getBeginString();
338         if(beginString.equals("FIX.4.0"))
339             cancel40(order);
340         else if(beginString.equals("FIX.4.1"))
341             cancel41(order);
342         else if(beginString.equals("FIX.4.2"))
343             cancel42(order);
344         else if(beginString.equals("FIX.4.3"))
345             cancel42(order);
346         else if(beginString.equals("FIX.4.4"))
347             cancel42(order);
348         else if(beginString.equals("FIXT.1.1"))
349             cancel42(order);
350         return;
351     }
352 
cancel40(Order order)353     public void cancel40(Order order) {
354         String id = order.generateID();
355         quickfix.fix40.OrderCancelRequest message =
356             new quickfix.fix40.OrderCancelRequest
357             (new OrigClOrdID(order.getID()),
358              new ClOrdID(id),
359              new CxlType('F'),
360              new Symbol(order.getSymbol()),
361              sideToFIXSide(order.getSide()),
362              new OrderQty(order.getQuantity()));
363 
364         orderTableModel.addID(order, id);
365         send(message, order.getSessionID());
366     }
367 
cancel41(Order order)368     public void cancel41(Order order) {
369         String id = order.generateID();
370         quickfix.fix41.OrderCancelRequest message =
371             new quickfix.fix41.OrderCancelRequest
372             (new OrigClOrdID(order.getID()),
373              new ClOrdID(id),
374              new Symbol(order.getSymbol()),
375              sideToFIXSide(order.getSide()));
376         message.setField(new OrderQty(order.getQuantity()));
377 
378         orderTableModel.addID(order, id);
379         send(message, order.getSessionID());
380     }
381 
cancel42(Order order)382     public void cancel42(Order order) {
383         String id = order.generateID();
384         quickfix.fix42.OrderCancelRequest message =
385             new quickfix.fix42.OrderCancelRequest
386             (new OrigClOrdID(order.getID()),
387              new ClOrdID(id),
388              new Symbol(order.getSymbol()),
389              sideToFIXSide(order.getSide()),
390              new TransactTime());
391         message.setField(new OrderQty(order.getQuantity()));
392 
393         orderTableModel.addID(order, id);
394         send(message, order.getSessionID());
395     }
396 
cancel43(Order order)397     public void cancel43(Order order) {
398         String id = order.generateID();
399         quickfix.fix43.OrderCancelRequest message =
400             new quickfix.fix43.OrderCancelRequest
401             (new OrigClOrdID(order.getID()),
402              new ClOrdID(id),
403              sideToFIXSide(order.getSide()),
404              new TransactTime());
405         message.setField(new OrderQty(order.getQuantity()));
406         message.setField(new Symbol(order.getSymbol()));
407 
408         orderTableModel.addID(order, id);
409         send(message, order.getSessionID());
410     }
411 
cancel44(Order order)412     public void cancel44(Order order) {
413         String id = order.generateID();
414         quickfix.fix44.OrderCancelRequest message =
415             new quickfix.fix44.OrderCancelRequest
416             (new OrigClOrdID(order.getID()),
417              new ClOrdID(id),
418              sideToFIXSide(order.getSide()),
419              new TransactTime());
420         message.setField(new OrderQty(order.getQuantity()));
421         message.setField(new Symbol(order.getSymbol()));
422 
423         orderTableModel.addID(order, id);
424         send(message, order.getSessionID());
425     }
426 
cancel50(Order order)427     public void cancel50(Order order) {
428         String id = order.generateID();
429         quickfix.fix50.OrderCancelRequest message =
430             new quickfix.fix50.OrderCancelRequest
431             (new OrigClOrdID(order.getID()),
432              new ClOrdID(id),
433              sideToFIXSide(order.getSide()),
434              new TransactTime());
435         message.setField(new OrderQty(order.getQuantity()));
436         message.setField(new Symbol(order.getSymbol()));
437 
438         orderTableModel.addID(order, id);
439         send(message, order.getSessionID());
440     }
441 
replace(Order order, Order newOrder)442     public void replace(Order order, Order newOrder) {
443         String beginString = order.getSessionID().getBeginString();
444         if(beginString.equals("FIX.4.0"))
445             replace40(order, newOrder);
446         else if(beginString.equals("FIX.4.1"))
447             replace41(order, newOrder);
448         else if(beginString.equals("FIX.4.2"))
449             replace42(order, newOrder);
450         else if(beginString.equals("FIX.4.3"))
451             replace42(order, newOrder);
452         else if(beginString.equals("FIX.4.4"))
453             replace42(order, newOrder);
454         else if(beginString.equals("FIXT.1.1"))
455             replace42(order, newOrder);
456         return;
457     }
458 
replace40(Order order, Order newOrder)459     public void replace40(Order order, Order newOrder) {
460         quickfix.fix40.OrderCancelReplaceRequest message =
461             new quickfix.fix40.OrderCancelReplaceRequest
462             (new OrigClOrdID(order.getID()),
463              new ClOrdID(newOrder.getID()),
464              new HandlInst('1'),
465              new Symbol(order.getSymbol()),
466              sideToFIXSide(order.getSide()),
467              new OrderQty(newOrder.getQuantity()),
468              typeToFIXType(order.getType()));
469 
470         orderTableModel.addID(order, newOrder.getID());
471         send(populateCancelReplace(order, newOrder,
472                                    message), order.getSessionID());
473     }
474 
replace41(Order order, Order newOrder)475     public void replace41(Order order, Order newOrder) {
476         quickfix.fix41.OrderCancelReplaceRequest message =
477             new quickfix.fix41.OrderCancelReplaceRequest
478             (new OrigClOrdID(order.getID()),
479              new ClOrdID(newOrder.getID()),
480              new HandlInst('1'),
481              new Symbol(order.getSymbol()),
482              sideToFIXSide(order.getSide()),
483              typeToFIXType(order.getType()));
484 
485         orderTableModel.addID(order, newOrder.getID());
486         send(populateCancelReplace(order, newOrder,
487                                    message), order.getSessionID());
488     }
489 
replace42(Order order, Order newOrder)490     public void replace42(Order order, Order newOrder) {
491         quickfix.fix42.OrderCancelReplaceRequest message =
492             new quickfix.fix42.OrderCancelReplaceRequest
493             (new OrigClOrdID(order.getID()),
494              new ClOrdID(newOrder.getID()),
495              new HandlInst('1'),
496              new Symbol(order.getSymbol()),
497              sideToFIXSide(order.getSide()),
498              new TransactTime(),
499              typeToFIXType(order.getType()));
500 
501         orderTableModel.addID(order, newOrder.getID());
502         send(populateCancelReplace(order, newOrder,
503                                    message), order.getSessionID());
504     }
505 
replace43(Order order, Order newOrder)506     public void replace43(Order order, Order newOrder) {
507         quickfix.fix43.OrderCancelReplaceRequest message =
508             new quickfix.fix43.OrderCancelReplaceRequest
509             (new OrigClOrdID(order.getID()),
510              new ClOrdID(newOrder.getID()),
511              new HandlInst('1'),
512              sideToFIXSide(order.getSide()),
513              new TransactTime(),
514              typeToFIXType(order.getType()));
515         message.setField(new Symbol(order.getSymbol()));
516 
517         orderTableModel.addID(order, newOrder.getID());
518         send(populateCancelReplace(order, newOrder,
519                                    message), order.getSessionID());
520     }
521 
replace44(Order order, Order newOrder)522     public void replace44(Order order, Order newOrder) {
523         quickfix.fix44.OrderCancelReplaceRequest message =
524             new quickfix.fix44.OrderCancelReplaceRequest
525             (new OrigClOrdID(order.getID()),
526              new ClOrdID(newOrder.getID()),
527              sideToFIXSide(order.getSide()),
528              new TransactTime(),
529              typeToFIXType(order.getType()));
530         message.setField(new Symbol(order.getSymbol()));
531         message.setField(new HandlInst('1'));
532 
533         orderTableModel.addID(order, newOrder.getID());
534         send(populateCancelReplace(order, newOrder,
535                                    message), order.getSessionID());
536     }
537 
replace50(Order order, Order newOrder)538     public void replace50(Order order, Order newOrder) {
539         quickfix.fix50.OrderCancelReplaceRequest message =
540             new quickfix.fix50.OrderCancelReplaceRequest
541             (new OrigClOrdID(order.getID()),
542              new ClOrdID(newOrder.getID()),
543              sideToFIXSide(order.getSide()),
544              new TransactTime(),
545              typeToFIXType(order.getType()));
546         message.setField(new Symbol(order.getSymbol()));
547         message.setField(new HandlInst('1'));
548 
549         orderTableModel.addID(order, newOrder.getID());
550         send(populateCancelReplace(order, newOrder,
551                                    message), order.getSessionID());
552     }
553 
populateCancelReplace(Order order, Order newOrder, quickfix.Message message)554     Message populateCancelReplace(Order order, Order newOrder,
555                                   quickfix.Message message) {
556 
557         if(order.getQuantity() != newOrder.getQuantity())
558             message.setField(new OrderQty(newOrder.getQuantity()));
559         if(order.getLimit() != newOrder.getLimit())
560             message.setField(new Price(newOrder.getLimit().doubleValue()));
561         return message;
562     }
563 
sideToFIXSide(OrderSide side)564     public  Side sideToFIXSide(OrderSide side) {
565         return (Side)sideMap.getFirst(side);
566     }
FIXSideToSide(Side side)567     public  OrderSide FIXSideToSide(Side side) {
568         return (OrderSide)sideMap.getSecond(side);
569     }
570 
typeToFIXType(OrderType type)571     public  OrdType typeToFIXType(OrderType type) {
572         return (OrdType)typeMap.getFirst(type);
573     }
FIXTypeToType(OrdType type)574     public  OrderType FIXTypeToType(OrdType type) {
575         return (OrderType)typeMap.getSecond(type);
576     }
577 
tifToFIXTif(OrderTIF tif)578     public  TimeInForce tifToFIXTif(OrderTIF tif) {
579         return (TimeInForce)tifMap.getFirst(tif);
580     }
FIXTifToTif(TimeInForce tif)581     public  OrderTIF FIXTifToTif(TimeInForce tif) {
582         return (OrderTIF)tifMap.getSecond(tif);
583     }
584 
addLogonObserver(Observer observer)585     public void addLogonObserver(Observer observer) {
586         observableLogon.addObserver(observer);
587     }
deleteLogonObserver(Observer observer)588     public void deleteLogonObserver(Observer observer) {
589         observableLogon.deleteObserver(observer);
590     }
addOrderObserver(Observer observer)591     public void addOrderObserver(Observer observer) {
592         observableOrder.addObserver(observer);
593     }
deleteOrderObserver(Observer observer)594     public void deleteOrderObserver(Observer observer) {
595         observableOrder.deleteObserver(observer);
596     }
597 
598     public class ObservableOrder extends Observable {
update(Order order)599         public void update(Order order) {
600             setChanged();
601             notifyObservers(order);
602             clearChanged();
603         }
604     }
605 
606     public class ObservableLogon extends Observable {
607         private HashSet set = new HashSet();
608 
logon(SessionID sessionID)609         public void logon(SessionID sessionID) {
610             set.add(sessionID);
611             setChanged();
612             notifyObservers(new LogonEvent(sessionID, true));
613             clearChanged();
614         }
logout(SessionID sessionID)615         public void logout(SessionID sessionID) {
616             set.remove(sessionID);
617             setChanged();
618             notifyObservers(new LogonEvent(sessionID, false));
619             clearChanged();
620         }
621     }
622 
623     static {
sideMap.put(OrderSide.BUY, new Side(Side.BUY))624         sideMap.put(OrderSide.BUY, new Side(Side.BUY));
sideMap.put(OrderSide.SELL, new Side(Side.SELL))625         sideMap.put(OrderSide.SELL, new Side(Side.SELL));
sideMap.put(OrderSide.SHORT_SELL, new Side(Side.SELL_SHORT))626         sideMap.put(OrderSide.SHORT_SELL, new Side(Side.SELL_SHORT));
sideMap.put(OrderSide.SHORT_SELL_EXEMPT, new Side(Side.SELL_SHORT_EXEMPT))627         sideMap.put(OrderSide.SHORT_SELL_EXEMPT,
628                     new Side(Side.SELL_SHORT_EXEMPT));
sideMap.put(OrderSide.CROSS, new Side(Side.CROSS))629         sideMap.put(OrderSide.CROSS, new Side(Side.CROSS));
sideMap.put(OrderSide.CROSS_SHORT, new Side(Side.CROSS_SHORT))630         sideMap.put(OrderSide.CROSS_SHORT, new Side(Side.CROSS_SHORT));
631 
typeMap.put(OrderType.MARKET, new OrdType(OrdType.MARKET))632         typeMap.put(OrderType.MARKET, new OrdType(OrdType.MARKET));
typeMap.put(OrderType.LIMIT, new OrdType(OrdType.LIMIT))633         typeMap.put(OrderType.LIMIT, new OrdType(OrdType.LIMIT));
typeMap.put(OrderType.STOP, new OrdType(OrdType.STOP))634         typeMap.put(OrderType.STOP, new OrdType(OrdType.STOP));
typeMap.put(OrderType.STOP_LIMIT, new OrdType(OrdType.STOP_LIMIT))635         typeMap.put(OrderType.STOP_LIMIT, new OrdType(OrdType.STOP_LIMIT));
636 
tifMap.put(OrderTIF.DAY, new TimeInForce(TimeInForce.DAY))637         tifMap.put(OrderTIF.DAY, new TimeInForce(TimeInForce.DAY));
tifMap.put(OrderTIF.IOC, new TimeInForce(TimeInForce.IMMEDIATE_OR_CANCEL))638         tifMap.put(OrderTIF.IOC,
639                    new TimeInForce(TimeInForce.IMMEDIATE_OR_CANCEL));
tifMap.put(OrderTIF.OPG, new TimeInForce(TimeInForce.AT_THE_OPENING))640         tifMap.put(OrderTIF.OPG, new TimeInForce(TimeInForce.AT_THE_OPENING));
tifMap.put(OrderTIF.GTC, new TimeInForce(TimeInForce.GOOD_TILL_CANCEL))641         tifMap.put(OrderTIF.GTC,
642                    new TimeInForce(TimeInForce.GOOD_TILL_CANCEL));
tifMap.put(OrderTIF.GTX, new TimeInForce(TimeInForce.GOOD_TILL_CROSSING))643         tifMap.put(OrderTIF.GTX,
644                    new TimeInForce(TimeInForce.GOOD_TILL_CROSSING));
645 
646     }
647 }
648