TSAFunctorParent.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_FUNCTOR_PARENT__INCLUDED
#define TSA_FUNCTOR_PARENT__INCLUDED

#include <vector>
#include <memory>

#include "TSASeriesTemplate.h"
#include "TSAString.h"
#include "TSASeriesVariant.h"
#include "TSASeriesImp.h"
#include "TSAFunctions.h"
#include "TSAStrategy.h"
#include "TSAFunctorParent.h"

namespace tsa {
    namespace functor {

        class functor_parent_base : public tsa::object {
            strategy* m_strategy_ptr = nullptr;
          public:
            bool first_bar_completed(void) const { return m_first_bar_is_completed; }
            void set_first_bar_completed(void) { m_first_bar_is_completed = true; }
            bool m_first_bar_is_completed = false;
          public:
            functor_parent_base(void) { ; }
            virtual ~functor_parent_base(void){ ; }
            virtual bool input_data_is_ok(void) { return true; }
            virtual void evaluate(void) { ; };// { return false; }
            void set_strategy_ptr(strategy* ptr) { m_strategy_ptr = ptr; }
            strategy* strategy_ptr(void)const { return m_strategy_ptr; }
        };

        /*
        ** ====================================================
        ** >>>          class functor::parent               <<<
        ** ====================================================
        */

        template<typename T>
        class parent : public functor_parent_base {
            tsa_declare_testable;
          private:
            bool m_out_series_has_data = false;

          public:
            std::vector<h_line> m_h_lines;
          public:
            variant pane_y_max;
            variant pane_y_min;
            bool show_grid;
            bool dotted_grid;
            bool config_pane;
            color grid_color;
            std::vector<plot_info> m_plots;
          public:
            std::vector<series<T>*> m_outputs;
            date_time m_last_update_timestamp;
          public:
            void check_for_duplicate_invocation(void);
            void create_outputs(size_t num_outputs);
            void verify_class_member_declaration(void) const;
          public:
            parent(void);
            parent(size_t num_outputs);
            virtual ~parent(void);
            operator variant(void) const;
            operator series<T>& (void) const;
            operator  series_cref<T> (void) const;
            series_cref<T> output(size_t position) const;
            void push(T value);
            void push(size_t position, T value);
            operator T(void) const;
            T value(void) const;
            T value(size_t position) const;
            size_t output_count(void) const;
          public:
            void add_h_line(const h_line& _l);
            void add_h_line(double _y_value, const color& _color, int _weight);
            void add_plot(const plot_info& _p);
            plot_info& get_plot_info(size_t pos);
            const plot_info& get_plot_info(size_t pos) const;
        };


        template<typename T>
        void parent<T>::check_for_duplicate_invocation(void) {
#ifdef TSA_DEBUG
            date_time strategy_timestamp = strategy_context::strategy_ptr()->bar_timestamp();
            if(strategy_timestamp == parent<T>::m_last_update_timestamp)
                throw exception(this, "functor invoked twice on same strategy during_bar; timestamp: "
                                + strategy_timestamp.to_string(), SLOC);
            parent<T>::m_last_update_timestamp = strategy_timestamp;
#endif
        }

        template<typename T>
        void parent<T>::create_outputs(size_t num_outputs) {
            for(size_t c = 0; c < num_outputs; c++) {
                auto ptr = new series<T>(this);
                tsa_assert(ptr->owning_functor_ptr() == this);
                tsa_assert(!ptr->is_managed());
                m_outputs.push_back(ptr);
                m_plots.push_back(plot_info());
            }
        }

        template<typename T>
        parent<T>::parent(void) {
            verify_class_member_declaration();
            create_outputs(1);
        }

        template<typename T>
        parent<T>::parent(size_t num_outputs) {
            verify_class_member_declaration();
            create_outputs(num_outputs);
        }

        template<typename T>
        void parent<T>::verify_class_member_declaration(void)const {
            strategy* strat_ptr = strategy_context::strategy_ptr(true);
            if(strat_ptr && strat_ptr->state() != strategy_state_type::preparing_managed_code) {
                throw tsa::exception(this, "'Managed functions' must be invoked as part of strategy::on_prepare(). "
                                     " 'Functor objects' must be declared as strategy class members!", SLOC);
            }
        }

        template<typename T>
        parent<T>::~parent(void) {
            for(auto& ptr : m_outputs) {
                delete ptr;
            }
        }

        template<typename T>
        parent<T>::operator  series<T>& (void)const {
            return *m_outputs[0];
        }

        template<typename T>
        parent<T>::operator series_cref<T> (void)const {
            return series_cref<T>(*m_outputs[0]);
        }

        template<typename T>
        parent<T>::operator variant(void)const {
            return value(0);
        }

        template<typename T>
        series_cref<T> parent<T>::output(size_t position)const {
            series<T>* ser_ptr = m_outputs[position];
            tsa_assert(ser_ptr->owning_functor_ptr() == this);
            return series_cref<T>(*m_outputs[position]);
        }

        template<typename T>
        void parent<T>::push(T value) {
            m_outputs[0]->push(value);
            m_out_series_has_data = true;
        }

        template<typename T>
        void parent<T>::push(size_t position, T value) {
            m_outputs[position]->push(value);
            m_out_series_has_data = true;
        }

        template<typename T>
        parent<T>::operator T(void)const {
            return value();
        }

        template<typename T>
        T parent<T>::value(void)const {
#if TSA_DEBUG
            if(!m_out_series_has_data || m_outputs[0]->size() == 0) {
                throw tsa::exception(this, "no output value available; was functor invoked?", SLOC);
            }
#endif
            return m_outputs[0]->get_at(0);
        }

        template<typename T>
        T parent<T>::value(size_t position)const {
#if TSA_DEBUG
            if(!m_out_series_has_data || m_outputs[0]->size() == 0) {
                throw tsa::exception(class_name(), "no output value available; was functor invoked?", SLOC);
            }
#endif
            return m_outputs[position]->get_at(0);
        }

        template<typename T>
        size_t parent<T>::output_count(void)const { return m_outputs.size(); }

        template<typename T>
        void parent<T>::add_h_line(const h_line& _l) { m_h_lines.push_back(_l); }

        template<typename T>
        void parent<T>::add_h_line(double _y_value, const color& _color, int _weight) {
            h_line l;
            l.y_value = _y_value;
            l.weight = _weight;
            l.clr = _color;
            m_h_lines.push_back(l);
        }
        template<typename T>
        void parent<T>::add_plot(const plot_info& _p) { m_plots.push_back(_p); }

        template<typename T>
        plot_info& parent<T>::get_plot_info(size_t pos) { return m_plots[pos]; }

        template<typename T>
        const plot_info& parent<T>::get_plot_info(size_t pos) const { return m_plots[pos]; }

        /*
        ** ====================================================
        ** >>>        class functor::auto_plot              <<<
        ** ====================================================
        */

        class auto_plot : public object {
          public:
            struct h_line {
                color clr;
                double y_value;
                unsigned weight;

                h_line(void) : clr(color(200, 200, 200)), y_value(0.0), weight(1) { ; }
                h_line(const color& _color, double _y_value, int _weight)
                    : clr(_color), y_value(_y_value), weight(_weight) {
                    ;
                }
            };
            typedef std::vector<h_line> HLINEARR;
            HLINEARR m_h_lines;
          public:
            variant pane_y_max;
            variant pane_y_min;
            bool show_grid;
            bool dotted_grid;
            bool config_pane;
            color grid_color;
            struct plot_info {
                string name;
                variant period;
                plot_type type;
                color color;
                double value;
                unsigned weight;
                double get_value(void) {
                    return value;
                }
                void set_value(double _v) {
                    value = _v;
                }
                plot_info(void) { ; }
            };
            typedef std::vector<plot_info> PLOTARR;
            PLOTARR m_plots;
          public:
            auto_plot(void) { ; }
            void add_h_line(const h_line& _l) { m_h_lines.push_back(_l); }
            void add_h_line(double _y_value, const color& _color, int _weight) {
                h_line l;
                l.y_value = _y_value;
                l.weight = _weight;
                l.clr = _color;
                m_h_lines.push_back(l);
            }
            void add_plot(const plot_info& _p) { m_plots.push_back(_p); }
            plot_info& get_plot(size_t pos) { return m_plots[pos]; }
            const plot_info& get_plot(size_t pos) const { return m_plots[pos]; }
            size_t plot_count(void) const { return m_plots.size(); }
        };
    }
}

#endif