TSAStrategy.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_STRATEGY__INCLUDED
#define TSA_STRATEGY__INCLUDED

#include <ostream>

#include "TSATypeDef.h"
#include "TSAVariant.h"
#include "TSAOrder.h"
#include "TSAError.h"
#include "TSARandGen.h"
#include "TSALogs.h"
#include "TSASeriesManaged.h"
#include "TSAMemTable.h"
#include "TSAMetrics.h"
#include "TSAMetrics2.h"
#include "TSAInstrument.h"
#include "TSAOS.h"
#include "TSASupport.h"
#include "TSAPlatformMsg.h"
#include "TSAJSON.h"


namespace tsa {

    class instrument;
    class in_stream;
    class strategy_delegate;
    class order_manager;
    class trade_manager;
    class equity_metrics;
    class trade_metrics;
    class platform_proxy;
    class transaction;
    class data_base;
    class json;
    namespace net{
        class socket_base;
    }

    struct reject_info {
        identifier_t order_id;     
        std::string  info;         
    };

#define on_bar_close on_next

    /*
    ** ====================================================
    ** >>>              class strategy                  <<<
    ** ====================================================
    */

    class dll_export strategy : public object, public metrics_source {
        tsa_declare_testable;
        friend class instrument;
        friend class series_core;
        friend class function_state;
        friend class strategy_delegate;
    private:
        friend void order_manager::ON_TRANSACTION(const transaction&);
        strategy_delegate* m_strat_delegate_ptr;
        double m_risk_free_annual_rate_of_return;
        double m_drawdown_multiplier;
        size_t m_bars_per_year;
        size_t m_min_series_freeze_size;
        size_t m_series_analyze_period_length;
    public:
        rand_gen m_Rng;
    public:
        strategy_state_type state();
    private:
        void touch_series_states(size_t _idx);
        void try_freeze_series_sizes(size_t min_ser_len);
        void delete_series_states(void);
        std::vector<managed_series*> m_series;
        void create_managed_series(identifier_t, type_t);
        bool managed_series_exists(identifier_t) const;
        const managed_series* const_series_ptr(long ID) const;
        managed_series* series_ptr(identifier_t ID);
        void PrintVectorStateObjects(std::ostream&, long _ID) const;
    public:
        size_t  series_count(void) const;
        size_t  m_managed_series_counter;
        size_t  m_nNumCallsOf_EVALUATE_member;
        bool    m_disallow_new_managed_series;
        bool    m_completed_first_bar_with_no_lookback_exception;
        bool    m_is_operational;
        size_t  m_operational_bar;
        bool    m_all_series_finalized;
        size_t  m_strategy_lookback;
        bool    m_managed_code_ran_clean;
        size_t  m_managed_code_ran_clean_count;
        size_t  m_min_series_length;
        bool    m_has_managed_code;
        bool    m_first_on_next_completed;
        named_values m_property_map;
        tsa::json m_json;
        duration  m_backfill_duration;
        date_time m_timestamp_of_first_bar_with_no_lookback_exception;
        date_time m_operational_timestamp;
        mutable std::mutex m_BAR_Mutex;
        //identifier_t m_platform__strategy_ID=0;
    public:
        bool    all_series_length_frozen(void) const;
        size_t  managed_series_count(void) const;
        void    socket__strategy_pos(int pos);
        size_t  socket__strategy_pos(void)const;
        void    strategy_ID(identifier_t id);
        identifier_t strategy_ID(void)const;
    private:
        void increment_series_state_counter(void);
        size_t GetNumCallsOf_BAR_Member(void) const;
        void invoke_virtual_evaluate_on_all_components(bool _pre);
        void _EVALUATE(void);
    private:
        void raise_series_bounds_error(void);
    public:
        log_type_t get_log_type(void) const;
        strategy_delegate& get_strategy_delegate(void);
    private:
        strategy(strategy&) = delete;
        strategy(const std::string&, const date_time& _t);
        void operator= (strategy&) = delete;
    private:
        void register_instrument(instrument*);
    public:
        void note_platform_destroyed(platform_proxy*);
    public:
        //===================================
        //===================================
        strategy(void);
        ~strategy(void);

        void args(const tsa::json& json_obj);

        const tsa::json& args(void)const;

        bool arg_exists(const std::string& arg_name);

        auto_cast_variant arg(const std::string& arg_name)const;

        //=================
        //=================
        
        void initialize(series_base*);
    public:
        //============================

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

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

        virtual void on_command(const tsa::json&);

        // internal
        virtual void on_message(const tsa::json&);
        // internal
        virtual void on_signal(const std::string& signal_string);
        // internal
        virtual void on_error(const tsa::json&);

        virtual void on_start(void);

        virtual void on_end(void);

        strategy_end_type end_type(void)const;

        virtual void on_next(void);

        virtual void on_transaction(const transaction& t);

        virtual void on_order_filled(const order_ref& oref, const transaction& t);

        virtual void on_order_partially_filled(order_ref& o_ref, const transaction& t);

        virtual void on_order_status_changed(order_ref& o_ref);

        virtual void on_order_cancel_rejected(order_ref& o_ref, const reject_info& r_info);

        virtual void on_order_replace_rejected(order_ref&, const reject_info&);

        virtual void on_order_rejected(order_ref& o_ref, const reject_info& r_info);

        virtual void on_exception(const tsa::exception& e);

        virtual void on_prepare(void);

        virtual void on_pre_managed_code(void);

        virtual void on_timer(const std::string& timer_name);

        virtual void on_live(void);

        bool is_live(void)const;
        

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

    public:
        void assume_functor_ownership(functor::functor_parent_base*);
        //IU For platform deployment
        void on_platform_transaction(const transaction&);
    public:
        bool is_current(void);
    public:
        void on_series_bounds_error_terminate(void);

        void catch_series_bounds_errors(bool flag = true);
    private:
        bool m_terminate_on_series_bounds_error;
    private:
        void make_current(void);
        void release_current(void);
    private:
        mutable date_time m_tmp_metrics_source_end_timestamp;
    public: //metrics_source overrides
        virtual const date_time& metrics_source__begin_timestamp(void) const override;
        virtual const date_time& metrics_source__end_timestamp(void) const override;
        virtual bool is_contract(void) const override { return false; }
        virtual std::string metric_source_name(void) const override { return name(); }
    public:
        //============================
        //============================

        void min_series_length(size_t min_size);

        size_t min_series_length(void) const;

        void series_analyze_period(size_t num_bars);

        size_t series_analyze_period(void) const;
        //=================
        //=================
    public:
        //============================
        //============================

        void create_timer(const std::string& name, const duration& repeat_duration);

        /*  NOT IMPLEMENTED

         * @brief   Creates a named timer that will cause strategy::on_timer() to be invoked at given @a
         * trigger_timestamp. Timer events must be uniquely named. Timers can only be created when the
         * strategy is attached to a platform or socket and is intended to run on real-time events.  
         * @param   name                The timer name.
         * @param   trigger_timestamp   The trigger timestamp.
         */
        //void create_timer(const std::string& name, const date_time& trigger_timestamp);

        void remove_timer(const std::string& name);

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

        // @brief   Same as strategy::timestamp().
        // @return  A date_time&amp;
        const date_time& bar_timestamp(void) const;

        const date_time& timestamp(void) const;

        size_t count(void) const;

        size_t bar_count(void) const;
        size_t interval_count(void) const;

        bool first(void) const;

        double net_profit(void) const;

        // deprecated
        void require_bar_count(size_t bar_count);

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

        size_t order_count(void) const;

        size_t order_count_inclusive(void) const;

        void cancel_order(identifier_t order_id, identifier_t instrument_id);

        order_ref get_order_ref(identifier_t order_id) const;

        order* order_ptr(identifier_t order_id) const;
        //=================
        //=================
    public:
        //============================

        size_t instrument_count(void) const;

        std::vector<instrument*>& instruments(void) const;

        instrument* instrument_ptr(size_t position) const;

        //=================
        //=================
        
        //IU Returns true if the strategy is operational..
        bool is_operational(void) const;

        //IU Returns the number of bars that were processed before the strategy reached 'operational status'.
        size_t operational_bar(void) const;

        const date_time& operational_timestamp(void) const;
    public:
        //===================================
        //===================================

        void attach(net::socket_base& p);

        void attach(platform_proxy& p);

        bool is_platform_driven(void) const;

        platform_proxy* platform_proxy_ptr(void)const;
        //=================
        //=================
        
        void process_message_from_platform(net::message& msg);

    private:
        platform_proxy* m_platform_proxy_ptr = nullptr;
    public:
        //===================================
        //===================================

        bool is_attached_to(const std::string& data_base_name);

        // internal
        data_base* get_data_source_ptr(const std::string& data_store_name);

        void attach(tsa::data_base& db);

        void attach_as(const std::string& db_name, tsa::data_base& db);
        //=================
        //=================
        
        void log_db(tsa::fast::database&); //internal
        void register_component(component*); //internal

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

        void backfill(const duration& dur);

        void begin(const date_time& begin_time_point);

        void end(const date_time& time_point);

        const date_time& begin(void) const;

        const date_time& end(void) const;

        void period(const date_time& start_time_point, const date_time& end_time_point);

        void run(void);

        void run(const date_time& start_time_point, const date_time& end_time_point);

        void run(const date_time& start_time_point);

        void exit(void);

        bool is_finalized(void) const;

        void verbose(std::ostream& stream, int verbose_level = 1);

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

        // future use
        void start(const date_time& start_timestamp = date_time());
        // future use
        void next(const date_time&);
        // future use
        void stop(void);
    public:
        //======================
        //======================

        bool is_auto_scheduled(void) const;

        bool schedule_was_set(void) const;

        std::string scheduler_name(void) const;

        void schedule_with(const in_stream& instream);

        void schedule_with(instrument& instr);

        void schedule_with(time_point_stream& stream);

        void auto_schedule(const duration& dur);

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

        void terminate(void);
        bool evaluation_started(void) const;
        bool evaluate_bar(void);
        bool evaluate_bar(std::istream& stream);
        bool GetPostBacktestUpdateWasCompleted(void) const;
        void verify_finalized(void) const;
        void verify_eval_not_started(void) const;
        bool is_scheduled_by_series(void) const;

        //================================
        // Platform     
        //================================
        void platform__initialize(void);
        void platform__run(void);
        bool platform__evaluate_bar(const date_time&);
    private:
        time_point_stream* m_schedule_sequence_ptr;
        auto_time_point_stream m_scheduler_intra;
    public:
        //================================
        //================================

        os::path output_base_path(void) const;

        os::path output_path(void) const;

        void output_base_path(const os::path& base_path, bool replace_existing_strategy_dir = false) const;

        void enable_reports(void);

        void auto_open_reports(bool flag = true);

        bool auto_open_reports_enabled(void) const;

        // deprecated
        void report(const os::path& report_dir, bool replace_existing = false);

        // deprecated
        void save_performance_report(const os::path& directory, 
            const std::string& name = "", bool replace = true);

        void risk_free_annual_rate_of_return(double rate);

        double risk_free_annual_rate_of_return(void) const;

        void drawdown_multiplier(double multiplier);

        double drawdown_multiplier(void) const;

        // Returns the 'number of bars per year'. This number is used by internal volatility calculations.
        size_t num_bars_per_year(void) const;
        //=================
        //=================
    public:
        //================================
        //================================

        /* obsolete
         * @brief   Returns the metric corresponding to the given @a metric_type and @a aggregation_type.
         *  Only invoke this member once the strategy had been finalized (see strategy::is_finalized()).
         *  These metrics are the same metrics as can be found on the 'Strategy Performance Report'. (see
         *  strategy::enable_reporting()).
         * @param   metric_type         Type of metric.
         * @param   aggregation_type    Type of metric aggregation.
         * @return  The metric. The metric is returns as a variant since different metrics have different
         *  types.
         */
        variant get_metric(perf_metric_type metric_type, trade_grouping gr = all_trades) const;

        variant metric(const std::string& metric_name, trade_grouping trade_group = tsa::all_trades) const;


        /* obsolete
         * @brief   Returns a metrics object containing all the strategy's performance properties. Only
         *  invoke this member once the strategy had been 'finalized'.
         *
         *  Multiple metrics objects from different strategies can be aggregated into aggregated
         *  portfolio metrics.
         * @return  The metrics object.
         */
        const tsa::metrics& metrics(void) const;

        const tsa::metrics2& metrics2(void) const;

        //=================
        //=================
    protected:
        void report(log_type_t logTypes, 
            const os::path& report_dir, bool replace_existing = false);
    public:
        fast::database* log_db_ptr(void) const;
        virtual void daily_cash_flow(mem_table& mt) const;
        void daily_equity_vector(std::vector<double>& vector) const;
        void num_bars_per_year(size_t nNumBars);
        //size_t total_bars_processed() const;
        double simulation_period_in_years(void) const;
        double simulation_period_in_days(void) const;
        //double GetNumUnitsTraded_Other(trade_grouping direction = all_trades) const;
        double annualized_volatility(double start_account_equity, size_t bars_per_year) const;
        bool is_in_drawdown(void) const;
        //double GetCurrentDrawdown(void) const;
    };

    
} // namespace tsa

#endif