ctp_trader_adapter.hpp

Go to the documentation of this file.

 
#pragma once
 
#ifdef ENABLE_CTP
 
#include <thread>
#include <atomic>
#include <mutex>
#include <condition_variable>
#include <string>
#include <vector>
#include <functional>
#include "ThostFtdcTraderApi.h"
 
namespace fix40 {
 
// 前向声明
class InstrumentManager;
class CtpTraderAdapter;
 
enum class CtpTraderState {
    DISCONNECTED,   
    CONNECTING,     
    CONNECTED,      
    AUTHENTICATING, 
    LOGGING_IN,     
    READY,          
    QUERYING,       
    ERROR           
};
 
struct CtpTraderConfig {
    std::string traderFront;  
    std::string brokerId;     
    std::string userId;       
    std::string password;     
    std::string appId;        
    std::string authCode;     
    std::string flowPath;     
};
 
class CtpTraderSpi final : public CThostFtdcTraderSpi {
public:
    explicit CtpTraderSpi(CtpTraderAdapter* adapter) : adapter_(adapter) {}
    ~CtpTraderSpi() = default;
 
    void OnFrontConnected() override;
    void OnFrontDisconnected(int nReason) override;
    void OnRspAuthenticate(CThostFtdcRspAuthenticateField* pRspAuthenticateField,
                           CThostFtdcRspInfoField* pRspInfo,
                           int nRequestID, bool bIsLast) override;
    void OnRspUserLogin(CThostFtdcRspUserLoginField* pRspUserLogin,
                        CThostFtdcRspInfoField* pRspInfo,
                        int nRequestID, bool bIsLast) override;
    void OnRspQryInstrument(CThostFtdcInstrumentField* pInstrument,
                            CThostFtdcRspInfoField* pRspInfo,
                            int nRequestID, bool bIsLast) override;
    void OnRspError(CThostFtdcRspInfoField* pRspInfo, int nRequestID, bool bIsLast) override;
    void OnHeartBeatWarning(int nTimeLapse) override;
 
private:
    CtpTraderAdapter* adapter_;
};
 
class CtpTraderAdapter {
    friend class CtpTraderSpi;
 
public:
    using StateCallback = std::function<void(CtpTraderState state, const std::string& message)>;
    
    using QueryCompleteCallback = std::function<void(int count)>;
 
    explicit CtpTraderAdapter(const CtpTraderConfig& config);
 
    ~CtpTraderAdapter();
 
    // 禁止拷贝
    CtpTraderAdapter(const CtpTraderAdapter&) = delete;
    CtpTraderAdapter& operator=(const CtpTraderAdapter&) = delete;
 
    bool start();
 
    void stop();
 
    bool isRunning() const { return running_.load(); }
 
    CtpTraderState getState() const { return state_.load(); }
 
    bool waitForReady(int timeoutSeconds);
 
    bool queryInstruments();
 
    bool queryInstruments(const std::string& exchangeId);
 
    bool waitForQueryComplete(int timeoutSeconds);
 
    void setInstrumentManager(InstrumentManager* manager) { instrumentManager_ = manager; }
 
    void setStateCallback(StateCallback callback) { stateCallback_ = std::move(callback); }
 
    void setQueryCompleteCallback(QueryCompleteCallback callback) { queryCompleteCallback_ = std::move(callback); }
 
    std::string getTradingDay() const;
 
    int getQueriedInstrumentCount() const { return queriedCount_.load(); }
 
private:
    void doAuthenticate();
 
    void doLogin();
 
    void notifyState(CtpTraderState state, const std::string& message);
 
    CtpTraderConfig config_;
    CThostFtdcTraderApi* api_ = nullptr;
    std::unique_ptr<CtpTraderSpi> spi_;
 
    std::atomic<bool> running_{false};
    std::atomic<CtpTraderState> state_{CtpTraderState::DISCONNECTED};
    std::atomic<int> requestId_{0};
    std::atomic<int> queriedCount_{0};
    std::atomic<bool> queryComplete_{false};
 
    mutable std::mutex mutex_;
    std::condition_variable readyCv_;
    std::condition_variable queryCv_;
    std::string tradingDay_;
 
    InstrumentManager* instrumentManager_ = nullptr;
    StateCallback stateCallback_;
    QueryCompleteCallback queryCompleteCallback_;
};
 
CtpTraderConfig loadCtpTraderConfig(const std::string& filename);
 
} // namespace fix40
 
#endif // ENABLE_CTP