market_manager.h

Go to the documentation of this file.

 
#ifndef CPPTRADER_MATCHING_MARKET_MANAGER_H
#define CPPTRADER_MATCHING_MARKET_MANAGER_H
 
#include "fast_hash.h"
#include "market_handler.h"
 
#include "containers/hashmap.h"
#include "memory/allocator_pool.h"
 
#include <cassert>
#include <vector>
 
namespace CppTrader {
 
namespace Matching {
 
 
class MarketManager
{
    friend class OrderBook;
 
public:
    typedef std::vector<Symbol*> Symbols;
    typedef std::vector<OrderBook*> OrderBooks;
    typedef CppCommon::HashMap<uint64_t, OrderNode*, FastHash> Orders;
 
    MarketManager();
    MarketManager(MarketHandler& market_handler);
    MarketManager(const MarketManager&) = delete;
    MarketManager(MarketManager&&) = delete;
    ~MarketManager();
 
    MarketManager& operator=(const MarketManager&) = delete;
    MarketManager& operator=(MarketManager&&) = delete;
 
    const Symbols& symbols() const noexcept { return _symbols; }
    const OrderBooks& order_books() const noexcept { return _order_books; }
    const Orders& orders() const noexcept { return _orders; }
 
 
    const Symbol* GetSymbol(uint32_t id) const noexcept;
 
    const OrderBook* GetOrderBook(uint32_t id) const noexcept;
 
    const Order* GetOrder(uint64_t id) const noexcept;
 
 
    ErrorCode AddSymbol(const Symbol& symbol);
 
    ErrorCode DeleteSymbol(uint32_t id);
 
 
    ErrorCode AddOrderBook(const Symbol& symbol);
 
    ErrorCode DeleteOrderBook(uint32_t id);
 
 
    ErrorCode AddOrder(const Order& order);
 
    ErrorCode ReduceOrder(uint64_t id, uint64_t quantity);
 
    ErrorCode ModifyOrder(uint64_t id, uint64_t new_price, uint64_t new_quantity);
 
    ErrorCode MitigateOrder(uint64_t id, uint64_t new_price, uint64_t new_quantity);
 
    ErrorCode ReplaceOrder(uint64_t id, uint64_t new_id, uint64_t new_price, uint64_t new_quantity);
 
    ErrorCode ReplaceOrder(uint64_t id, const Order& new_order);
 
    ErrorCode DeleteOrder(uint64_t id);
 
 
    ErrorCode ExecuteOrder(uint64_t id, uint64_t quantity);
 
    ErrorCode ExecuteOrder(uint64_t id, uint64_t price, uint64_t quantity);
 
    bool IsMatchingEnabled() const noexcept { return _matching; }
    void EnableMatching() { _matching = true; Match(); }
    void DisableMatching() { _matching = false; }
 
 
    void Match();
 
private:
    // Market handler
    static MarketHandler _default;
    MarketHandler& _market_handler;
 
    // Auxiliary memory manager
    CppCommon::DefaultMemoryManager _auxiliary_memory_manager;
 
    // Bid/Ask price levels
    CppCommon::PoolMemoryManager<CppCommon::DefaultMemoryManager> _level_memory_manager;
    CppCommon::PoolAllocator<LevelNode, CppCommon::DefaultMemoryManager> _level_pool;
 
    // Symbols
    CppCommon::PoolMemoryManager<CppCommon::DefaultMemoryManager> _symbol_memory_manager;
    CppCommon::PoolAllocator<Symbol, CppCommon::DefaultMemoryManager> _symbol_pool;
    Symbols _symbols;
 
    // Order books
    CppCommon::PoolMemoryManager<CppCommon::DefaultMemoryManager> _order_book_memory_manager;
    CppCommon::PoolAllocator<OrderBook, CppCommon::DefaultMemoryManager> _order_book_pool;
    OrderBooks _order_books;
 
    // Orders
    CppCommon::PoolMemoryManager<CppCommon::DefaultMemoryManager> _order_memory_manager;
    CppCommon::PoolAllocator<OrderNode, CppCommon::DefaultMemoryManager> _order_pool;
    Orders _orders;
 
    ErrorCode AddMarketOrder(const Order& order, bool recursive);
    ErrorCode AddLimitOrder(const Order& order, bool recursive);
    ErrorCode AddStopOrder(const Order& order, bool recursive);
    ErrorCode AddStopLimitOrder(const Order& order, bool recursive);
    ErrorCode ReduceOrder(uint64_t id, uint64_t quantity, bool recursive);
    ErrorCode ModifyOrder(uint64_t id, uint64_t new_price, uint64_t new_quantity, bool mitigate, bool recursive);
    ErrorCode ReplaceOrder(uint64_t id, uint64_t new_id, uint64_t new_price, uint64_t new_quantity, bool recursive);
    ErrorCode DeleteOrder(uint64_t id, bool recursive);
 
    // Matching
    bool _matching;
 
    void Match(OrderBook* order_book_ptr);
    void MatchMarket(OrderBook* order_book_ptr, Order* order_ptr);
    void MatchLimit(OrderBook* order_book_ptr, Order* order_ptr);
    void MatchOrder(OrderBook* order_book_ptr, Order* order_ptr);
 
    bool ActivateStopOrders(OrderBook* order_book_ptr);
    bool ActivateStopOrders(OrderBook* order_book_ptr, LevelNode* level_ptr, uint64_t stop_price);
    bool ActivateStopOrder(OrderBook* order_book_ptr, OrderNode* order_ptr);
    bool ActivateStopLimitOrder(OrderBook* order_book_ptr, OrderNode* order_ptr);
 
    uint64_t CalculateMatchingChain(OrderBook* order_book_ptr, LevelNode* level_ptr, uint64_t price, uint64_t volume);
    uint64_t CalculateMatchingChain(OrderBook* order_book_ptr, LevelNode* bid_level_ptr, LevelNode* ask_level_ptr);
    void ExecuteMatchingChain(OrderBook* order_book_ptr, LevelNode* level_ptr, uint64_t price, uint64_t volume);
    void RecalculateTrailingStopPrice(OrderBook* order_book_ptr, LevelNode* level_ptr);
 
    void UpdateLevel(const OrderBook& order_book, const LevelUpdate& update) const;
};
 
} // namespace Matching
} // namespace CppTrader
 
#include "market_manager.inl"
 
#endif // CPPTRADER_MATCHING_MARKET_MANAGER_H