Receiving Solicited and Unsolicited Order / Fill Events

To receive solicited and unsolicited order / fill events, you need to:

• Create a class that is derived from ttsdk::IOrderBookEventHandler and defines your Order Book event handler.
  • You must provide implementations for the following methods:
    • virtual void OnExecutionReport(OrderPtr order, ExecutionReportPtr execRpt) = 0;
      • Callback fired when delivering execution report messages
    • virtual void OnReject(OrderPtr order, RejectResponsePtr rejResp) = 0;
      • Callback fired when delivering order reject messages
    • virtual void OnSendFailed(OrderPtr order, const OrderProfile& profile, const SendCode code) = 0;
      • Callback fired when a request delivery surpasses the timeout threshold
    • virtual void OnUnsubscribed(const char* orderId) = 0;
      • Callback fired when the unsubscribe request is complete and it is safe to destroy the handler object
  • You can also optionally provide implementations for the following methods:
    • virtual void OnPositionUpdate(const Position& updatedPosition) {};
      • Callback delivering position updates
    • virtual void OnAccountDownloadEnd(const uint64_t accountId) {};
      • Callback indicating that the given account has been synchronized with the real time streams, and orders and positions have been downloaded.
    • virtual void OnAccountDownloadFailed(const uint64_t accountId, const char* message) {};
      • Callback indicating that the given account’s orders and positions downloads have failed and the account is not usable.
    • virtual void OnOrderBookDownloadEnd() {};
      • Callback indicating that all orders and positions for all accounts are downloaded and synchronized with the real time stream.
  • Initialize the TT Core SDK passing your TTSDKOptions instance variable, your SDK event handler instance variable, and your Order Book event handler instance variable.
    • Note that both the SDK and Order Book event handlers must have a lifespan that is valid for the life of the SDK (until shutdown is completed).

An OnAccountDownloadEnd event is fired when an account is ready to be used for trading. And an OnOrderBookDownloadEnd event is fired when all accounts are ready.

The following code snippet demonstrates an example of this process.

#include 
#include 
#include 
#include 
#include 
#include 
#include 

std::mutex mutex;
std::condition_variable sdkReadyCondition;

//
//  SDK event handler class
//

class SDKEventHandler : public ttsdk::IEventHandler
{
  public:
      SDKEventHandler() : IEventHandler() {}
      virtual ~SDKEventHandler() {}

      // received on an SDK managed thread that can be used for processing.
      // beware that time consuming tasks can delay the delivery of another status event.

      virtual void OnStatus(const ttsdk::IEventHandler::Status status) override
      {
          std::cout  lock(mutex);
      sdkReadyCondition.notify_one();
    }
    
    // the SDK synchronizes the order book and positions by account.  as such, 
    // any given account can be able to trade without needing to wait 
    // for all accounts to be ready

    virtual void OnAccountDownloadEnd(const uint64_t accountId) override
    {
      std::cout GetAlias()  lock(mutex);
  if (sdkReadyCondition.wait_for(lock, std::chrono::seconds(300)) == std::cv_status::timeout)
  {
    std::cout >>>>" > command)
  {
    if (command == "q")
    {
      std::cout