TradingCore.h

Go to the documentation of this file.

 
#pragma once
#include <exchange_routing/Command.h>
#include <exchange_state/OrderIDGenerator.h>
#include <exchange_routing/Partition.h>
#include <exchange_state/TradeIDGenerator.h>
#include <exchange_publishers/MarketDataPublisher.h>
#include "common/Order.h"
#include "common_fix/ExecutionReport.h"
#include "data/DatabaseWorker.h"
#include "data/TradeIDRepository.h"
#include "data/AuthRepository.h"
#include <functional>
#include <memory>
#include <optional>
#include <mutex>
 
namespace trading_core {
    class TradingCore {
    public:
        using ExecutionReportCallback = std::function<void(const fix::ExecutionReport&)>;
 
        TradingCore();
 
        explicit TradingCore(data::DatabaseWorker* dbWorker,
                             bool autoInitPartitions = true);
 
        TradingCore(std::unique_ptr<data::DatabaseWorker> dbWorker,
                    std::unique_ptr<data::AuthRepository> authRepo,
                    std::unique_ptr<data::TradeIDRepository> tradeIDRepo,
                    std::unique_ptr<TradeIDGenerator> tradeIDGen,
                    std::unique_ptr<OrderIDGenerator> orderIDGen,
                    bool autoInitPartitions = true);
 
        virtual ~TradingCore();
 
        void start();
 
        void stop();
 
        void stopAcceptingCommands();
 
        void waitAllQueuesIdle() const;
 
        virtual void submitCommand(std::unique_ptr<Command> command) const;
 
        Partition* getPartition(common::Instrument instrument) const;
 
        OrderIDGenerator* getOrderIDGenerator();
        
        data::AuthRepository* getAuthRepository() const;
 
        data::DatabaseWorker* getDatabaseWorker() const;
 
        virtual void subscribeToExecutions(ExecutionReportCallback callback);
 
        virtual void subscribeToMarketData(common::Symbol symbol, common::SessionID sessionId);
 
        virtual void unsubscribeFromMarketData(common::Symbol symbol, common::SessionID sessionId);
        
        virtual void unsubscribeFromMarketData(common::SessionID sessionId);
 
        const ExecutionReportCallback& getExecutionReportCallback() const;
 
        MarketDataPublisher& getMarketDataPublisher();
 
        static TradingCore& getInstance();
 
        std::optional<common::Instrument>
        findPartitionForOrder(common::OrderID orderId) const;
 
        std::optional<common::Order> getOrder(common::OrderID orderId) const;
        
        std::optional<common::Order> getOrderByClientOrderId(const std::string& clientOrderId) const;
 
 
#ifndef NDEBUG
        void setPartition(common::Instrument instrument,
                          std::unique_ptr<Partition> partition);
#endif
 
    private:
        void initPartitions();
 
    private:
        data::DatabaseWorker* mDatabaseWorker = nullptr;
        std::unique_ptr<data::DatabaseWorker> mOwnedDatabaseWorker;
        std::unique_ptr<data::AuthRepository> mAuthRepo;
        std::unique_ptr<data::TradeIDRepository> mTradeIDRepo;
        std::unique_ptr<TradeIDGenerator> mTradeIDGenerator;
        std::unique_ptr<OrderIDGenerator> mOrderIDGenerator;
        std::unique_ptr<Partition>
                mPartitions[static_cast<int>(common::Instrument::COUNT)];
        ExecutionReportCallback mExecutionReportCallback;
        mutable std::mutex mExecutionCallbackMutex;
        MarketDataPublisher mMarketDataPublisher;
    };
} // namespace trading_core