TSCWrapper.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 __TSC_WRAPPER_H
#define __TSC_WRAPPER_H

#include "TSCPlots.h"

namespace tsa {

        class chart_maker;
        class chart;
        class plot::plot_base;

        struct trend_line {
            tsa::date_time  start_timestamp; 
            double          start_price; 
            tsa::date_time  end_timestamp; 
            double          end_price; 
            color           line_color; 
            int             weight; 
        };

        struct horizontal_line {
            double  y_value;     
            color   line_color; 
            int     weight;    
        };


        class pane_proxy {
            friend class chart;
          private:
            size_t m_paneIdx;
            chart* m_pChart;
          public:
            //IU
            pane_proxy(chart&);
            ~pane_proxy(void);
          public:
            void height(size_t height_);
            size_t height(void)const;
            void plot_bg(const color& bg_color);
            void header_bg(const color& bg_color);
            void show_header(bool show_flag = true);
            void x_axis_legend(bool show_flag);
            void background(const color& bg_color);
            void title(const tsa::string& title);
            std::string title(void)const;
            void y_axis_legend(const color& clr);
            void x_axis_legend(const color& clr);
            void v_lines(bool enable_flag);
            void h_lines(bool enable_flag);
            void dashed_v_lines(bool enable_flag = true);
            void dashed_h_lines(bool enable_flag = true);
            void h_line(double y_value, const color& clr = color::white, size_t weight = 1);
            void line(
                const tsa::date_time& start_timestamp, 
                double start_y_value, 
                const tsa::date_time& end_timestamp, 
                double end_y_value, 
                const color& clr = color::white, 
                size_t weight = 1 
            );
            void y_max(double max);
            void y_min(double);
          public://Internal use
            void ShowTransactions(size_t _plotID, bool b = true);
            void ShowTransactionPrices(size_t _plotID, bool b = true);
            void position_as_plot_color(size_t _plotID, const color& longColor = color::auto_color, 
                                        const color& shortColor = color::auto_color);
            void ShowTrades(size_t plotID,
                            const color& longColor = color::auto_color, const color& shortColor = color::auto_color);
            void AxisHLine(double price, const color& = color::white, size_t width = 1);

        };

        //IU
        
        class graphics_plot_info : public tsa::object, public chart_property_map {
          public:
              graphics_plot_info(void) {
                set_property("VISUALIZE_TRADES", false);
                set_property("TYPE", "UNDEFINED");
            }
              virtual ~graphics_plot_info(void) { ; }
        };


        //IU
        class pane_info : public chart_property_map, public tsa::object {
          public:
            std::vector<graphics_plot_info> m_plot_infos;
            std::vector<horizontal_line>    m_CustomHLines;
            std::vector<horizontal_line>    m_AxisHLines;
            std::vector<trend_line>         m_TLines;
            graphics_plot_info& GetPlotInfo(size_t idx);
          public:
            pane_info(void);
        };


        class dll_export chart : public tsa::object, public tsa::component {
            friend class pane_proxy;
          public:
            class pane {
              public:
                color  m_color;
                size_t m_height_px;
                size_t m_index;
              public:
                pane(void);
                pane(unsigned height, const color& bg_color);
                pane(unsigned height);
                pane(const color& bg_color);
                ~pane(void);
            };
          public:
            enum ElementType {
                LINE = 1,
                DLINE, //discontinuous line
                AREA,
                BAR,
            };
          private:
            color_manager m_color_man;
            std::vector<pane_info> m_pane_infos;
            tsa::column_defs m_columns;
            std::vector<tsa::variant> m_Rec;
            bool m_bFirstPreEval;
            bool m_bTrackTransactAndPosition;
            int m_nMaxChartsToSave;
            int m_nMaxBarsPerChart;
            std::vector<tsa::transaction> m_tmpTransArr;
          public:
            pane_info& get_pane_info(size_t _idx);
          private:
            tsa::mem_table m_mem_table; //default - if no series_base
            tsa::fast::database* m_db_ptr;
          private:
            bool m_using_mem_table;
            int m_width_px;
            std::string m_title;
            void prepare_chart_maker(chart_maker& _chartMaker,
                                     const tsa::date_time& _start, const tsa::date_time& _end);
          private: //***TRANSACTIONS***
            //std::vector<tsa::transaction> m_Transactions;
          public:
            chart(void);

            //IU
            chart(tsa::series_base& _db);

            virtual ~chart(void);

            int max_bars_per_chart(void)const;

            void max_bars_per_chart(int);

            int max_charts_to_save(void)const;

            void max_charts_to_save(int max_num_charts);

            void set_color(DefaultColorID id, const color& c);

            void width(int width);

            int width(void)const;

            void name(const tsa::string& _s) { m_title = _s; }

            const std::string& name(void)const { return m_title; }

            pane_proxy get_pane(size_t _idx);

            size_t pane_count(void)const;

          public://internal use
            const std::string& title(void)const { return m_title; }
            //IU
            void title(const tsa::string& _s) { m_title = _s; }
            pane_proxy operator[](size_t);
            pane_proxy get_pane_proxy(size_t idx, bool noCreate);
            //void    AddLatestTransactions(std::vector<tsa::transaction>& _transArr);
            void    SetTrackTransactionsAndPosition(bool b = true);
          public:
            void save_png(const tsa::os::path& path);
            void save_png(const tsa::os::path& path,
                          const tsa::date_time& start, const tsa::date_time& end);
            size_t save_png_book(const tsa::os::path& dir_path, size_t bars_per_page = 0);
            //IU
            void print_table(std::ostream&);
          private: // Internal Use.
            void save_gif(const tsa::string& fileName);
            void save_gif(const tsa::string& fileName, const tsa::date_time& start, const tsa::date_time& end);
            void save_multi_gif(const tsa::string& fileName, size_t nBarsPerPage = 0);
          private:
            bool m_columns_defined;
            bool m_prev_input_was_field_name;
            size_t m_input_pos;
            size_t m_value_pos;
            size_t m_curr_input_pos;
            size_t m_num_named_fields;//not necessarily same as num items
            size_t m_num_values;
            std::string m_most_recent_field_name;
            std::vector<tsa::type_t> m_types;
            std::vector<size_t> m_first_column_positions;
            std::vector<bool> m_input_is_name;
            tsa::date_time m_timestamp;
          public:
            virtual void cmp__evaluate_bar(const date_time&)override;
            virtual void cmp__finalize(void)override;
            void reset_counters(void);
            bool FirstRecordCompletedAndSchemaReset(void)const;

            chart& operator<<(const chart::pane& pane);
            chart& operator<<(const char* name);
            chart& operator<<(const string& name);
            chart& operator<<(double value);
            chart& operator<<(int64_t value);
            chart& operator<<(const plot::plot_base&);
            chart& operator<<(const functor::auto_plot& functor);

            template<typename T>
            chart& operator<<(const functor::parent<T>& _functor) {
                if(!m_columns_defined) {
                    //------------------------
                    //  Register Chart Component
                    if(!tsa::component::is_registered_with_strategy()) {
                        component::register_with_strategy(strategy_context::strategy_ptr__null_ok());
                    }
                    //------------------------
                    size_t pane_count = this->pane_count();
                    if(pane_count == 0) {
                        throw exception(class_name(), "chart has no pane", SLOC);
                    }
                    pane_proxy pp = this->get_pane(pane_count - 1);
                    //pane y min max
                    if(_functor.pane_y_max.defined()) {
                        pp.y_max((double)_functor.pane_y_max);
                    }
                    if(_functor.pane_y_min.defined()) {
                        pp.y_min((double)_functor.pane_y_min);
                    }
                    //horizontal lines
                    for(size_t l = 0; l < _functor.m_h_lines.size(); l++) {
                        double y_value = _functor.m_h_lines[l].y_value;
                        color c = _functor.m_h_lines[l].clr;
                        int w = _functor.m_h_lines[l].weight;
                        pp.h_line(y_value, c, w);
                    }
                }
                //paint the plots
                size_t num_plots = _functor.output_count();
                for(size_t pl = 0; pl < num_plots; pl++) {
                    auto p = _functor.get_plot_info(pl);
                    if(!p.plot_it) {
                        continue;
                    }
                    auto t = p.type;
#ifdef _DEBUG
                    /*color c = p.color;
                    int w = p.weight;
                    string n = p.name;
                    double value = p.value;*/
#endif
                    if(t == plot_type::line) {
                        *this << plot::line(_functor.value(pl), p.clr, p.weight) << p.name;
                    } else if(t == plot_type::area) {
                        *this << plot::area(_functor.value(pl), p.clr) << p.name;
                    } else if(t == plot_type::bar) {
                        *this << plot::bar(_functor.value(pl), p.clr) << p.name;
                    } else {
                        throw exception(class_name(), "unrecognized plot type", SLOC);
                    }
                }
                return *this;
            }

            template<typename T>
            chart& operator<<(const series_tuple<T>& _tuple) {
                if(!m_columns_defined) {
                    //------------------------
                    //  Register Chart Component
                    if(!tsa::component::is_registered_with_strategy()) {
                        component::register_with_strategy(strategy_context::strategy_ptr__null_ok());
                    }
                    //------------------------
                    size_t pane_count = this->pane_count();
                    if(pane_count == 0) {
                        throw exception(class_name(), "chart has no pane", SLOC);
                    }
                    pane_proxy pp = get_pane(pane_count - 1);
                    //pane y min max
                    if(_tuple.pane_y_max().defined()) {
                        pp.y_max((double)_tuple.pane_y_max());
                    }
                    if(_tuple.pane_y_min().defined()) {
                        pp.y_min((double)_tuple.pane_y_min());
                    }
                    //horizontal lines
                    auto hl = _tuple.pane_h_lines();
                    for(size_t l = 0; l < hl.size(); l++) {
                        double y_value = hl[l].y_value;
                        color c = hl[l].clr;
                        int w = hl[l].weight;
                        pp.h_line(y_value, c, w);
                    }
                    size_t num_plots = _tuple.size();
                    for (size_t pl = 0; pl < num_plots; pl++) {
                        if (_tuple[pl].empty())
                            throw tsa::exception(class_name(), "tuple has empty series - cannot plot" , SLOC);
                    }
                }
                //paint the plots
                size_t num_plots = _tuple.size();
                for(size_t pl = 0; pl < num_plots; pl++) {
                    auto p = _tuple[pl].plot_info();
                    if(!p.plot_it) {
                        continue;
                    }
                    auto t = p.type;
#ifdef _DEBUG
                    /*color c = p.color;
                    int w = p.weight;
                    string n = p.name;
                    double value = p.value;*/
#endif
                    if(t == plot_type::line) {
                        *this << plot::line(_tuple[pl][0], p.clr, p.weight) << p.name;
                    } else if(t == plot_type::area) {
                        *this << plot::area(_tuple[pl][0], p.clr) << p.name;
                    } else if(t == plot_type::bar) {
                        *this << plot::bar(_tuple[pl][0], p.clr) << p.name;
                    } else {
                        throw exception(class_name(), "unrecognized plot type", SLOC);
                    }
                }
                return *this;
            }

        /*  template<typename T>
            chart& operator<<(const scalar<T>& _scalar){
                return operator<<(*_scalar.series_ptr());
            }*/

            template<typename T>
            chart& operator<<(const series<T>& _ser) {
                if(!m_columns_defined) {
                    //------------------------
                    //  Register Chart Component
                    if(!tsa::component::is_registered_with_strategy()) {
                        component::register_with_strategy(strategy_context::strategy_ptr__null_ok());
                    }
                    //------------------------
                    size_t pane_count = this->pane_count();
                    if(pane_count == 0) {
                        throw exception(class_name(), "chart has no pane", SLOC);
                    }
                    pane_proxy pp = get_pane(pane_count - 1);
                    //pane y min max
                    if(_ser.pane_y_max().defined()) {
                        pp.y_max((double)_ser.pane_y_max());
                    }
                    if(_ser.pane_y_min().defined()) {
                        pp.y_min((double)_ser.pane_y_min());
                    }
                    //horizontal lines
                    auto hl = _ser.pane_h_lines();
                    for(size_t l = 0; l < hl.size(); l++) {
                        double y_value = hl[l].y_value;
                        color c = hl[l].clr;
                        int w = hl[l].weight;
                        pp.h_line(y_value, c, w);
                    }

                    if (_ser.empty())
                        throw exception(class_name(), "Cannot plot an empty series", SLOC);
                }
                //paint the plots

                auto p = _ser.plot_info();
                tsa_assert(p.plot_it);
                // if(!p.plot_it) {
                //    return *this;
                //}
                auto t = p.type;
#ifdef _DEBUG
                /*color c = p.color;
                int w = p.weight;
                string n = p.name;
                double value = p.value;*/
#endif


                if(t == plot_type::line) {
                    *this << plot::line(_ser[0], p.clr, p.weight) << p.name;
                } else if(t == plot_type::area) {
                    *this << plot::area(_ser[0], p.clr) << p.name;
                } else if(t == plot_type::bar) {
                    *this << plot::bar(_ser[0], p.clr) << p.name;
                } else {
                    throw exception(class_name(), "unrecognized plot type", SLOC);
                }

                return *this;
            }
        };


    //}//namespace graphics

} //namespace tsa

#endif