OrderManager.h

Go to the documentation of this file.

 
#ifndef ATS_ORDERMANAGER_H
#define ATS_ORDERMANAGER_H
 
#include <string>
#include <queue>
#include <thread>
#include <mutex>
#include <map>
#include <vector>
#include <unordered_map>
#include <set>
 
namespace ats {
    enum OrderType {
        LIMIT,                  
        MARKET,                 
        STOP_LOSS,              
        STOP_LOSS_LIMIT,        
        TAKE_PROFIT,            
        TAKE_PROFIT_LIMIT,      
        LIMIT_MAKER,            
        OTCOUNT                 
    };
 
    std::string OrderTypeToString(OrderType t);
 
    OrderType stringToOrderType(const std::string &s);
 
    enum Side {
        BUY,        
        SELL,       
        SCOUNT      
    };
 
    std::string SideToString(Side t);
 
    Side stringToSide(const std::string &s);
 
 
    struct Order {
 
        long id; 
        std::string symbol; 
        double quantity; 
        double price; 
        OrderType type; 
        Side side; 
        double stopPrice; 
        double icebergQty; 
        long recvWindow; 
        long emsId; 
        std::string timeInForce; 
        time_t time; 
        Order(long id=-1) : id(id) {}
 
        Order(long id, OrderType type, Side side, std::string symbol, double quantity, double price,
              double stopPrice = 0., double icebergQty = 0., long recvWindow = 0, long emsId = 0,
              std::string timeInForce = "", time_t time=0) {
            this->id = id;
            this->side = side;
            this->symbol = symbol;
            this->quantity = quantity;
            this->type = type;
            this->price = price;
            this->stopPrice = stopPrice;
            this->icebergQty = icebergQty;
            this->recvWindow = recvWindow;
            this->emsId = emsId;
            this->timeInForce = timeInForce;
            this->time = time;
        }
    };
 
    struct OrderBook{
        std::vector<double> bid; 
        std::vector<double> bidVol; 
        std::vector<double> ask; 
        std::vector<double> askVol; 
        OrderBook(std::vector<double> bid={}, std::vector<double> bidVol={}, std::vector<double> ask={}, std::vector<double> askVol={}) {
            this->bid = bid;
            this->bidVol = bidVol;
            this->ask = ask;
            this->askVol = askVol;
        }
    };
 
    class OrderManager {
    private:
        std::unordered_map<long,Order> mSentOrders; 
        std::queue<std::pair<long,std::string>> mCancelOrders; 
        std::queue<Order> mOrders; 
        std::queue<Order> mPendingOrders; 
        std::thread mOrderManagerThread; 
        std::mutex mOrderCountMutex; 
        std::mutex mOrderFetchMutex; 
        bool mRunning; 
        long mOrderCount; 
        std::set<std::string> mSymbols; 
        double mLastOrderQty;
    public:
        OrderManager();
 
         OrderManager(std::vector<std::string> symbols);
 
        ~OrderManager();
 
        void start();
 
        void run();
 
        void stop();
 
        bool isRunning();
 
         double getLastOrderQty();
 
          void setLastOrderQty(double qty);
 
        long createOrder(OrderType type, Side side, std::string symbol, double quantity, double price=0);
 
        long createOrder(Order& order);
 
        void cancelOrder(long orderId, std::string symbol);
 
         void cancelAllOrders();
 
          void updateOpenOrders(std::unordered_map<long,Order> openOrders);
 
        void processOrder(Order order);
 
        void processOrders();
 
        bool hasOrders();
 
         bool hasCancelOrders();
 
        Order &getOldestOrder();
 
         Order getOrderById(long ID);
 
         std::pair<long,std::string> getCancelOrder();
 
          std::vector<std::string> getSymbols();
 
    private:
        int getNewOrderId();
    };
 
} // ats
 
#endif //ATS_ORDERMANAGER_H