sdkalgo.h

Go to the documentation of this file.

/***************************************************************************
 *
 *                  Unpublished Work Copyright (c) 2020
 *                  Trading Technologies International, Inc.
 *                       All Rights Reserved Worldwide
 *
 *          * * *   S T R I C T L Y   P R O P R I E T A R Y   * * *
 *
 * WARNING:  This program (or document) is unpublished, proprietary property
 * of Trading Technologies International, Inc. and is to be maintained in
 * strict confidence. Unauthorized reproduction, distribution or disclosure
 * of this program (or document), or any program (or document) derived from
 * it is prohibited by State and Federal law, and by local law outside of
 * the U.S.
 *
 ***************************************************************************/
#pragma once
 
#include "consts.h"
#include "instrument.h"
#include "algo_definition.h"
#include "execution_report.h"
#include "sdkalgo_request.h"
#include "position.h"
#include "shared_ptr.h"
#include "enums/MarketId.h"
#include "enums/OrdStatus.h"
#include "enums/ExecType.h"
#include "enums/OrderRejectReason.h"
#include "enums/AlgoResponseCode.h"
#include "enums/RiskSide.h"
 
namespace ttsdk
{
    class SDKAlgo;
    using SDKAlgoPtr = shared_ptr<SDKAlgo>;
 
    class ISDKAlgoManager
    {
    public:
        virtual ~ISDKAlgoManager() noexcept = default;
 
        virtual const char* GetMarkets() = 0;
 
        virtual bool RecoverSDKAlgos() const { return false; }
 
 
        virtual void OnRecoverAlgo(SDKAlgoPtr algoOrder, SDKAlgoRequestPtr req) = 0;
        virtual void OnRecoveryEnd() = 0;
        virtual void OnRecoveryFailed() = 0;
 
        virtual void OnStartRequest(SDKAlgoPtr algoOrder, SDKAlgoRequestPtr req) = 0;
        virtual void OnStopRequest(SDKAlgoPtr algoOrder, SDKAlgoRequestPtr req) = 0;
        virtual void OnUpdateRequest(SDKAlgoPtr algoOrder, SDKAlgoRequestPtr req) = 0;
        //         no fills or user response messages may be generated and set to the users.
        virtual void OnPauseRequest(SDKAlgoPtr algoOrder, SDKAlgoRequestPtr req) = 0;
        virtual void OnResumeRequest(SDKAlgoPtr algoOrder, SDKAlgoRequestPtr req) = 0;
 
        //         through the ScheduleEvent() method.
        virtual void OnScheduledEvent(SDKAlgoPtr algoOrder, unsigned int eventId, void* eventUserData) = 0;
 
 
        virtual void OnRiskReserved(SDKAlgoPtr algoOrder, const uint64_t instrumentId, const uint64_t accountId, 
            const ttsdk::RiskSide side, const AlgoResponseCode code) {};
        virtual void OnRiskReleased(SDKAlgoPtr algoOrder, const uint64_t instrumentId, const uint64_t accountId, 
            const ttsdk::RiskSide side, const AlgoResponseCode code) {};
 
 
 
        //         when a stop request is successful, a full fill is sent, the algo fails or the 
        //         start request fails. The user should properly shutdown the algo and clean up
        //         the resources it is using when this event is received.
        virtual void OnAlgoCompleted(SDKAlgoPtr algoOrder) = 0;
 
    };
    using ISDKAlgoManagerPtr = ISDKAlgoManager*;
 
 
    //         The algo order lifespan begins with new order single request. Once that algo is running,
    //         the sdk algo will exist until either:
    //         1) a cancel request is issued by the user and the OnStopRequest request return ok
    //         2) the application fails the algo using the FailAlgo method
    //         3) the order is fully filled which is indicated by the application calling GenerateSyntheticFill
    //            and the fill qty becomes equal or greater than the algo order qty
    class SDKAlgo : public shared_base
    {
    public:
        explicit SDKAlgo() {};
        ~SDKAlgo() {};
 
        virtual const char* GetOrderId() const noexcept = 0;
        //         an instrument in the tradition manner in the algo requests.
        virtual InstrumentPtr GetInstrument() const noexcept = 0;
        virtual AlgoDefinitionPtr GetAlgoDefinition() const noexcept = 0;
        virtual ExecutionReportPtr GetCurrentState() const noexcept = 0;
 
        //         working qty of the algo, a full fill will be sent and the algo will be complete, triggering
        //         the ISDKAlgoManager::OnAlgoCompleted callback. Fills sent before the algo is started will be sent
        //         after the start is completed.
        virtual bool GenerateSyntheticFill(const double fillPrc, const double fillQty) noexcept = 0;
        //         if there is a pending action, this data will be collapsed into the pending action reqponse message.
        //         In addition, these messages are throttled so a limited number are sent per second to over constant
        //         sending of restatement messages. Throttle messages will be collapsed the lastest sent.
        virtual bool GenerateUserResponse(const char* msg, const ttsdk::UserParameter params[], const size_t numParams) noexcept = 0;
 
        virtual bool FailAlgo(const char* message) noexcept = 0;
        virtual bool StopAlgo(const char* message) noexcept = 0;
 
        virtual void OnPendingRequestCompleted(const AlgoResponseCode code, const char* message = nullptr) noexcept = 0;
 
        //  eventId: id to identify the event
        //  eventUserData: user provided data to be passed to the callback
        virtual void ScheduledEvent(unsigned int eventId, void* eventUserData) = 0;
 
        // Position Reserve Order support 
 
        virtual bool ReserveRisk(InstrumentPtr instrument, const uint64_t accountId, const RiskSide side, 
                                 const double quantity, const double maxClipSize) noexcept = 0;
        virtual bool ReleaseRisk(InstrumentPtr instrument, const uint64_t accountId, const RiskSide side) noexcept = 0;
        virtual PositionReserveBucket GetRiskBucket(InstrumentPtr instrument, const uint64_t accountId) noexcept = 0;
 
 
    private:
        SDKAlgo(const SDKAlgo&) = delete;
        SDKAlgo& operator=(SDKAlgo&) = delete;
        SDKAlgo(SDKAlgo&&) = delete;
        SDKAlgo& operator=(SDKAlgo&&) = delete;
    };
 
 
}