TSAOrder.h

/*  ===================================================================
*
*                 T R A D I N G   S Y S T E M   A P I ™
*    Copyright © 1999 - 2014 by Peter Ritter ( TradingSystemAPI.com )
*                A L L   R I G H T S   R E S E R V E D
*
*     Consult your license regarding permissions and restrictions.
*             You may obtain a copy of the License at:
*     http://www.TradingSystemAPI.com/licenses/LICENSE-TSAPI-3.0.html
*
*  ====================================================================
*/

#ifndef TSA_ORDER__INCLUDED
#define TSA_ORDER__INCLUDED

#include <ostream>

#include "TSAPOS.h"
#include "TSATime.h"
#include "TSAString.h"
#include "TSASupport.h"

namespace tsa {

    class position_manager;
    class instrument_price_bar;
    class transaction;
    class order;
    class instrument;

    class order_ref;

    /*
    ** ====================================================
    ** >>>               class order                    <<<
    ** ====================================================
    */

    class dll_export order : public object, public ref_count {
        tsa_declare_testable
        friend class order_manager;
        friend class order_ref;
        static const std::string class_name;
    public:

        enum status {

            created = 0,

            pending_submit = 1,  /*active*/

            pre_submitted = 2,  /*active*/

            submitted = 3,  /*active*/

            pending_cancel = 4,  /*active*/

            pending_cancel_replace = 5, /*active*/

            paused = 6, /*active*/

            filled = 7,

            cancelled = 8,

            rejected = 9
        };

        enum action {
            buy,          
            sell,         
            oa_undefined  
        };

        enum type {
            market,       
            stop,         
            limit,        
            ot_undefined  
        };

        enum exec_interval {
            at_open ,        
            at_close ,       
            during_bar,      

            this_close,
            ei_undefined  // internal use.
        };

        enum time_in_force {
            gtc,                
            day,                
            user_defined_tif    
        };

        struct order_info {
            identifier_t order_id;      
            identifier_t instrument_id; 
        };
    public:
        static std::string to_string(order::status);
        static std::string to_string(order::time_in_force);
        static std::string to_string(order::action);
        static std::string to_string(order::type);
        static std::string to_string(order::exec_interval);
    protected:
        order::exec_interval m_exec_interval = order::ei_undefined;
        order::time_in_force m_time_in_force = order::gtc;

        instrument*     m_instrument_ptr = nullptr;
        order::status   m_status = order::created;
        order::status   m_prev_status = order::created;
        order::action   m_action = order::oa_undefined;
        order::type     m_type = order::ot_undefined;
        date_time       m_expiry_timepoint;
        date_time       m_creation_timestamp;
        date_time       m_last_fill_timestamp;
        std::string     m_symbol;
        std::string     m_exchange;
        identifier_t    m_order_id = tsa::undefined_id;
        identifier_t    m_external_order_id = tsa::undefined_id;
        identifier_t    m_permanent_order_id = tsa::undefined_id;
        quantity_t      m_quantity = 0;
        quantity_t      m_min_fill_quantity = 0;
        double          m_price = 0.0;
        double          m_aux_price = 0.0;
        bool            m_is_stop_limit = false;
        double          m_limit_fill_proviso = 0.0;
        bool            m_is_marked_for_deletion = false;
        bool            m_is_partially_filled = false;
        quantity_t      m_filled_quantity = 0;
        variant         m_fixed_fill_price;//leave as 'undefined'
        double          m_estimated_transaction_price = (-std::numeric_limits<double>::max());
        double          m_abs_price_diff_between_open_and_estimated_exec_price = (-std::numeric_limits<double>::max());
        bool            m_is_smart = false;
        variant         m_last_fill_price;
        std::string     m_user_message;
        int64_t         m_created_on_bar = 0;
    private:
        std::vector<order::order_info>* m_orders_to_cancel_ptr = nullptr;
    public:
        virtual void calculate_estimated_transaction_price(const instrument_price_bar& price_bar) = 0;
        double estimated_transaction_price(void);
        double abs_price_diff_between_open_and_estimated_exec_price(void) const;
        bool is_assumed_to_be_executed_before(const order* order_ptr) const;
        virtual bool TRY_FILL(const instrument_price_bar& price_bar, transaction&);
    public:
        virtual bool try_fill__long(const instrument_price_bar& price_bar, double& transact_price, bool& had_slippage) = 0;
        virtual bool try_fill__short(const instrument_price_bar& price_bar, double& transact_price, bool& had_slippage) = 0;
    private:
        order(const order&) = delete;
    public:
        order(void);
        virtual ~order(void);
    public:
        void set_instrument_ptr(instrument*);
        instrument* instrument_ptr(void) const;
    public:
        void add_order_to_cancel_on_fill(identifier_t order_id, identifier_t contract_id);
        bool has_orders_to_cancel_on_fill(void) const;
        const std::vector<order::order_info>& get_orders_to_cancel_on_fill(void) const;
    public:
        static identifier_t instrument_id_from_order_id(identifier_t order_id);
    public:
        void                set_symbol(const std::string& s);
        const std::string&  get_symbol(void) const;
        void                set_exchange(const std::string& s);
        const std::string&  get_exchange(void) const;
        identifier_t        get_contract_id(void) const;
        void                set_id(identifier_t);
        identifier_t        get_id(void) const;
        void                set_id_on_platform(identifier_t);
        identifier_t        get_id_on_platform(void) const;
        void                set_permanent_id(tsa::identifier_t);
        tsa::identifier_t   get_permanent_id(void) const;
        void                set_quantity(quantity_t);
        quantity_t          get_quantity(void) const;
        void                set_remaining_quantity(quantity_t);
        quantity_t          get_remaining_quantity(void) const;
        void                set_min_fill_quantity(quantity_t);
        quantity_t          get_min_fill_quantity(void) const;
        void                set_tag(const std::string&);
        const std::string&  get_tag(void) const;
        void                set_create_timestamp(const date_time&);
        const date_time&    get_create_timestamp(void) const;
        void                set_create_bar(int64_t);
        int64_t             get_create_bar(void) const;
        int64_t             get_age_in_bars(void) const;
        duration            get_age(void) const;
        void                set_status(order::status);
        order::status       get_status(void) const;
        order::status       get_prev_status(void) const;
        void                set_action(order::action);
        order::action       get_action(void) const;
        void                set_type(order::type);
        order::type         get_type(void) const;
        void                  set_exec_interval(order::exec_interval);
        order::exec_interval  get_exec_interval(void) const;
        order::time_in_force  get_time_in_force(void) const;
        const date_time&      get_expiry_time_point(void) const;
        void                  set_time_in_force(order::time_in_force);
        void                  set_time_in_force_time_point(const date_time&);
        void        set_price(double);
        double      get_price(void) const;
        void        set_aux_price(double);
        double      get_aux_price(void) const;
        void        set_last_fill_price(double);
        double      get_last_fill_price(void);
        void        set_fixed_fill_price(double);
        double      get_fixed_fill_price(void);
        void        set_is_stop_limit(bool);
        bool        get_is_stop_limit(void) const;
        void        set_limit_fill_proviso(double);
        double      get_limit_fill_proviso(void) const;
        bool        get_is_filled(void) const;
        void        set_is_partial_fill(bool);
        bool        get_is_partial_fill(void) const;
        void        set_filled_quantity(quantity_t);
        quantity_t  get_filled_quantity(void) const;
        void        apply_fill(quantity_t quantity, const date_time& timestamp);
        void        set_last_fill_timestamp(const date_time&);
        const date_time&  get_last_fill_timestamp(void) const;
        void        set_is_smart(bool);
        bool        get_is_smart(void) const;
        void        set_is_marked_for_deletion(bool);
        bool        get_is_marked_for_deletion(void) const;
        bool        get_is_eod(void) const;
        bool        get_is_cancelled(void) const;
        bool        get_is_active(void) const;
    public:
        static bool order_status_is_active(tsa::order::status);
    public:
        virtual void print(std::ostream& stream) const;
    public:
        quantity_t calc_rounded_order_quantity_for_ccy_amount(double unit_cost, double amount);
        quantity_t calculate_initial_order_size(double price);
    public://*** STOP orders helper function ***
        static bool try_fill__long_stop
            (double stop_price, double& transaction_price, double o, double h, double l);
        static bool try_fill__short_stop
            (double stop_price, double& transaction_price, double o, double h, double l);
    public://*** LIMIT orders helper function ***
        static bool try_fill__long_limit
            (double limit_price, double& transaction_price, double o, double h, double l);
        static bool try_fill__short_limit
            (double limit_price, double& transaction_price, double o, double h, double l);
    };

    /*
    ** ====================================================
    ** >>>             class order_ref                  <<<
    ** ====================================================
    */

    class dll_export  order_ref : public object {
        tsa_declare_testable;
        friend class instrument;
    public:
        order* order_ptr(void) const;
    private:
        order* m_order_ptr;
        void verify_init(const char* hint) const;
        size_t ref_count(void) const;
        void verify_inactive() const;
    public:
        //===========================
        //===========================
        
        order_ref(void);

        order_ref(order* order_ptr);

        order_ref(const order_ref& other);

        void operator= (const order_ref& other);

        ~order_ref(void);

    public:
        //===========================
        //===========================
        
        void send();

        void cancel(void);

        void update_price(double new_price);

        void update_price(double new_price, double new_aux_price);

        void update_quantity(quantity_t new_quantity);

        void release(void);

        order* get(void)const;

        void print(std::ostream& stream) const;

        //=================
        //=================
    public:
        //===========================
        //===========================

        const std::string& symbol(void) const;

        const std::string& exchange(void) const;

        identifier_t id(void) const;

        identifier_t instrument_id(void) const;

        order_ref tag(const std::string& tag_string);

        const std::string& tag(void) const;
        //=================
        //=================
        
    public:
        //===========================
        //===========================

        void time_in_force(order::time_in_force tif, const date_time& expiry_time_point = date_time());


        order::time_in_force time_in_force(void) const;

        date_time expiry_time_point(void) const;


        double price(void) const;

        void fixed_fill_price(double fixed_fill_price);

        double fixed_fill_price(void)const;

        quantity_t quantity(void) const;

        quantity_t remaining(void) const;

        quantity_t size(void) const;

        quantity_t min_fill_quantity(void) const;

        void min_fill_quantity(quantity_t quantity);

        order::action action(void) const;

        order::type type(void) const;

        order::exec_interval exec_interval(void) const;

        double aux_price(void) const;

        bool is_stop_limit(void) const;

        quantity_t filled_quantity(void) const;

        date_time last_fill_timestamp(void) const;

        date_time create_timestamp(void) const;

        int64_t create_bar_ordinal(void) const;

        int64_t age_in_bars(void) const;

        duration age(void) const;

        //=================
        //=================
        
    public:
        //===========================
        //===========================

        bool defined(void) const;

        operator bool(void)const;

        // Same as is_filled().
        //bool filled(void) const;

        bool is_filled(void) const;

        // Same as order_ref::is_active()
        bool active(void) const;

        bool is_active(void) const;

        // obsolete
        //bool partially_filled(void) const;

        bool is_partially_filled(void) const;

        bool cancelled(void) const;

        bool is_cancelled(void)const;

        bool marked_for_deletion(void) const;

        order::status status(void) const;

        order::status prev_status(void) const;

        bool is_pending_submit(void);

        bool is_pre_submitted(void);

        bool is_acknowledged(void);

        bool is_submitted(void);

        bool is_pending_cancel(void);

        bool is_cancelled(void);

        //=================
        //=================
        
    public:
        // internal use
        void mark_for_deletion(void);

        //===========================
        //===========================

        // internal
        void update_status(order::status);

        // internal
        void external_id(identifier_t);

        identifier_t external_id(void)const;

        identifier_t permanent_id(void)const;

        //=================
        //=================
        
    public:
        //===========================
        //===========================

        void one_cancels_other(order_ref& other_order);

        void oco(order_ref& other);

        void on_fill_cancel(const order_ref& other_order);

        void on_fill_cancel(identifier_t order_id, identifier_t instrument_id);

        bool has_orders_to_cancel_on_fill(void) const;

        const std::vector<order::order_info>& orders_to_cancel(void) const;

        //=================
        //=================
        
    public:
        //===========================
        //===========================

        void exec_interval(order::exec_interval execution_interval);

        //=================
        //=================
    };

    bool operator==(const order_ref& lhs, const order_ref& rhs);

    bool operator!=(const order_ref& lhs, const order_ref& rhs);

    /*
    ** ====================================================
    ** >>>               internal                       <<<
    ** ====================================================
    */

    // internal use
    class dll_export order__on_stop : public order {
    public:
        order__on_stop(order::action, double price);
        order__on_stop(order::action, double price, double auxPrice);
        virtual ~order__on_stop();
        virtual bool try_fill__long(const instrument_price_bar& price_bar,
            double& transaction_price, bool& incurred_slippage)override;
        virtual bool try_fill__short(const instrument_price_bar& price_bar,
            double& transaction_price, bool& incurred_slippage)override;
        // for calculating order fill precedence in simulations
        virtual void calculate_estimated_transaction_price(const instrument_price_bar& price_bar)override;
    };

    // internal use
    class dll_export order__at_limit : public order {
    public:
        order__at_limit(order::action, double price);
        virtual ~order__at_limit(void);
        virtual bool try_fill__long(const instrument_price_bar& price_bar,
            double& transaction_price, bool& incurred_slippage)override;
        virtual bool try_fill__short(const instrument_price_bar& price_bar,
            double& transaction_price, bool& incurred_slippage)override;
        virtual void calculate_estimated_transaction_price(const instrument_price_bar& price_bar)override;
    };

    // internal use
    class dll_export order__at_market : public order {
    public:
        order__at_market(order::action);
        virtual ~order__at_market(void);
        virtual bool try_fill__long(const instrument_price_bar& price_bar,
            double& transaction_price, bool& incurred_slippage)override;
        virtual bool try_fill__short(const instrument_price_bar& price_bar,
            double& transaction_price, bool& incurred_slippage)override;
        virtual void calculate_estimated_transaction_price(const instrument_price_bar& price_bar)override;
    };

    
}  // namespace tsa

#endif