TSASeriesTemplate.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_SERIES_TEMPLATE2__INCLUDED
#define TSA_SERIES_TEMPLATE2__INCLUDED

#include <vector>
#include <iostream>
#include <initializer_list>

#include "TSATypeDef.h"
#include "TSAVariant.h"
#include "TSAString.h"
#include "TSAError.h"
#include "TSASimBaseSeries.h"
#include "TSASeriesProxy.h"
#include "TSASeriesImp.h"
#include "TSAStrategyPtr.h"

namespace tsa {
    class in_stream;
    class out_stream;
    //class string;
    class date_time;
    class series_base;
    class strategy;
    class managed_series;
    class in_stream_adaptor;
    class column_defs;
    class auto_series;

    void verify_non_zero(size_t value);

    void verify_non_zero(double value);

    namespace functor {
        class functor_parent_base;
    }

    template<typename TYPE> class series_cref;

    /*
    ** ====================================================
    ** >>>           class series_core                  <<<
    ** ====================================================
    */
    // Internal
    class dll_export series_core : public tsa::object {
        tsa_declare_testable;
    protected:
        functor::functor_parent_base* m_functor_ptr = nullptr;
        size_t          m_functor_output_pos = 0;
        strategy*       m_strategy_ptr;
        identifier_t    m_id;
        managed_series* m_managed_series_ptr;
        type_t          m_type;
        date_time       m_timestamp_of_current_value;
    private:
        void verify_init() const;
    public:
        void reset(void);
    public:
        void copy_members(const series_core&);
        void push_front(const variant&, const date_time&);
        const date_time& most_recent_timestamp(void) const;
    public:
        series_core(void);
        series_core(size_t capacity, type_t _dt);
        explicit series_core(type_t);
    public:
        series_core(const series_core&);
        series_core(const series_core*);
        bool is_init(void) const;
        type_t type(void) const;
        virtual ~series_core(void);
        void Init(void);
        void verify_size(size_t) const;
        bool size_ok(size_t)const;
        size_t get_required_size(void) const;
    public:
        size_t Size(void) const;
        const variant& at(size_t idx) const;
        const variant& at__noexcept(size_t idx) const;

        void* data(void) const;
        const variant& operator()(void) const;
    public:
        const variant& operator[](size_t idx) const;
    public:
        functor::functor_parent_base* functor_ptr(void)const;
        size_t functor_output_pos(void)const;
    public:
        void SetSource(const std::string& _s);
        const std::string& name(void) const;
        identifier_t id(void) const;
    };

    class series_template_base : public tsa::object {
    public:
        virtual ~series_template_base(void) { ; }
        virtual variant at(size_t)const = 0;
        virtual bool size_ok(size_t)const = 0;
    };

    /*
    ** ====================================================
    ** >>>               plot_info                      <<<
    ** ====================================================
    */
    template<typename T> class series_cref;
    template<typename T> class series_tuple;

    struct h_line {
        tsa::color clr;
        double y_value;
        unsigned weight;
        h_line(void);
        h_line(const tsa::color& c, double y_value, int weight);
    };

    enum class plot_type {
        line,
        area,
        bar
    };

    struct plot_info {
        std::string name;
        bool plot_it = true;
        plot_type type = plot_type::line;
        tsa::color clr = tsa::color::auto_color;
        unsigned weight = 2;
        std::string period_to_string(const tsa::variant&);
    public:
        std::string period_string;
        void period(const tsa::variant& period0, const tsa::variant& period1 = variant(),
            const tsa::variant& period2 = variant(), const tsa::variant& period3 = variant());
    };

    class pane_format  {
    public:
        void pane_h_line(const h_line& hl)const { m_h_lines.push_back(hl); }
        void pane_h_line(const tsa::color& c, double y_value, int weight)const
        {
            m_h_lines.push_back({ c, y_value, weight });
        }
        void pane_y_max(double max)const { m_pane_y_max = max; }
        void pane_y_min(double min)const { m_pane_y_min = min; }
        void pane_show_grid(bool b)const { m_show_grid = b; }
        void pane_dotted_grid(bool b)const { m_dotted_grid = b; }
        void pane_grid_color(const tsa::color& c)const { m_grid_color = c; }
        void pane_auto_pane(bool b)const { m_auto_pane = b; }
        const std::vector<tsa::h_line>& pane_h_lines(void)const { return m_h_lines; }
        const variant& pane_y_max(void)const { return m_pane_y_max; }
        const variant& pane_y_min(void)const { return m_pane_y_min; }
        void copy_pane_format(const pane_format& other)const {
            m_h_lines = other.m_h_lines;
            m_pane_y_max = other.m_pane_y_max;
            m_pane_y_min = other.m_pane_y_min;
            m_show_grid = other.m_show_grid;
            m_dotted_grid = other.m_dotted_grid;
            m_grid_color = other.m_grid_color;
            m_auto_pane = other.m_auto_pane;
        }
    private:
        mutable std::vector<tsa::h_line> m_h_lines;
        mutable variant m_pane_y_max;
        mutable variant m_pane_y_min;
        mutable variant m_show_grid;
        mutable variant m_dotted_grid;
        mutable tsa::color m_grid_color;
        mutable variant m_auto_pane;

        template<typename T> friend class series_cref;
        template<typename T> friend class series_tuple;
    };

    /*
    ** ====================================================
    ** >>>               class series                   <<<
    ** ====================================================
    */

    template<typename T = double>
    class dll_export series
        : public series_template_base,
        public pane_format {
        tsa_declare_testable;
    private:
        series_core m_core;
        static  size_t m_default_capacity;
    public:

        static void reset_default_capacity(size_t new_capacity) {
            m_default_capacity = new_capacity;
            if (m_default_capacity == 0) { m_default_capacity = 1; }
        }
        static size_t default_capacity(void) { return m_default_capacity; }
    private:
        series_imp<T>* m_series_imp_ptr = nullptr;
        size_t m_shift;
        bool m_is_owner = false;
        bool m_is_nonexistant_auto_series = false;//false for auto_series with no source
        bool m_was_assigned_in_DSP = false;
        functor::functor_parent_base* m_functor_ptr = nullptr;
        mutable std::string m_auto_series_name;
    private:
        mutable plot_info m_plot_info;
    public:
        void plot_info(const plot_info& pi)const  { m_plot_info = pi; }
        const tsa::plot_info& plot_info(void)const { return m_plot_info; }

        void plot_as(const std::string& name, const tsa::variant& period = 0.0,
            plot_type type = plot_type::line, tsa::color clr = tsa::color::auto_color, unsigned weight = 2)const {
            tsa::plot_info pi;
            pi.name = name;
            pi.period(period);
            pi.type = type;
            pi.clr = clr;
            pi.weight = weight;
            plot_info(pi);
        }

        void plot_as(const std::string& name, const std::vector<tsa::variant>& periods,
            plot_type type = plot_type::line, tsa::color clr = tsa::color::auto_color, unsigned weight = 2)const {
            tsa::plot_info pi;
            pi.name = name;
            std::vector<tsa::variant> adj_periods = periods;
            adj_periods.resize(4, variant());
            tsa_assert(adj_periods.size() == 4);

            pi.period(adj_periods[0], adj_periods[1], adj_periods[2], adj_periods[3]);
            pi.type = type;
            pi.clr = clr;
            pi.weight = weight;
            plot_info(pi);
        }
    public:
        const series<T>&  name(const std::string& name)const;
        const std::string& name(void)const { return m_auto_series_name; }
    public:
        void set_owning_functor_ptr(functor::functor_parent_base* ptr) { m_functor_ptr = ptr; }
        functor::functor_parent_base* owning_functor_ptr(void)const { return m_functor_ptr; }
    public:
        // Internal use: Copy Constructor that shifts the series backward by @a shift_ places.
        series(const series& other, size_t shift_);
    public:

        series(const series_core&);
        void init_as_auto_series(const series_core&, const std::string& field_name);
    public:

        series(const std::string& auto_series_name) : series(nullptr, false) {
            m_auto_series_name = auto_series_name;
            m_is_nonexistant_auto_series = true;
        }

        series(const std::initializer_list<T>& init_list) : series(nullptr, false){
            for (auto i = std::rbegin(init_list); i != std::rend(init_list); i++){
                push(*i);
            }
        }

        series(void) : series(nullptr, false) { ; }
        // Internal
        series(functor::functor_parent_base* ftor_ptr, bool called_by_series_ref_constr = false);

        series(const series<T>& other);

        explicit series(size_t capacity);

        virtual ~series(void);
        type_t type(void) const { return m_core.type(); }
    public:
        void operator=(series_cref<T>&);
        void operator=(const series<T>& other);

        void reserve(size_t capacity);

        size_t capacity(void) const;

        bool is_managed(void) const;

        bool is_owner(void) const { return m_is_owner; }

        T get_at(size_t position) const;
        virtual variant at(size_t pos)const { return variant(get_at(pos)); }
        T get_at_no_exc(size_t position) const;

        T operator[](size_t position) const;

        series_cref<T> operator()(size_t shift_by) const { return SHIFT(*this, shift_by); }

        void push(T);

        void push(const variant&);
        // Internal use
        void _internal_push(T);

        const T* data(void) const;
        T* data_non_const(void);

        size_t size(void) const;

        const series<T> shift(size_t _shift_by) const;

        void set_size(size_t new_size);

        bool is_equal(const series<T>& other) const;

        void verify_size(size_t reqired_size) const;

        virtual bool size_ok(size_t _required_size)const;

        bool empty(void)const { return size() == 0; }

        void clear(void);

        void fill_to_capacity(T value);

        void copy(const series& other, size_t max_num_values = ~(size_t)0);
    public:

        bool crosses_above(const series<T>& other) const;

        bool crosses_below(const series<T>& other) const;

        bool crosses_above(double threshold) const;

        bool crosses_below(double threshold) const;

        type_t value_type(void) const;
        void raise_type_mismatch(void);

        //IU
        void CopyTo(std::vector<T>&, size_t);

        void print(std::ostream& stream, size_t max = 1000);

        void print_v(std::ostream& s, size_t max = 1000);
    public:
        class const_iterator;
        // iterator class
        class iterator : public std::iterator
            < std::random_access_iterator_tag, T > {
        private:
            T* m_ptr;
            friend class const_iterator;
        public:
            iterator() : m_ptr(NULL) {}
            iterator(T* p) : m_ptr(p) {}
            iterator(const iterator& other) : m_ptr(other.m_ptr) {}
            const iterator& operator= (const iterator& other) { m_ptr = other.m_ptr; return other; }

            iterator& operator++() { m_ptr++; return *this; } // prefix++
            iterator  operator++ (int) { iterator tmp(*this); ++(*this); return tmp; }        // postfix++
            iterator& operator--() { m_ptr--; return *this; } // prefix--
            iterator  operator-- (int) { iterator tmp(*this); --(*this); return tmp; }        // postfix--

            void     operator+= (const std::size_t& n) { m_ptr += n; }
            void     operator+= (const iterator& other) { m_ptr += other.m_ptr; }
            iterator operator+ (const std::size_t& n) { iterator tmp(*this); tmp += n; return tmp; }
            iterator operator+ (const iterator& other) { iterator tmp(*this); tmp += other; return tmp; }

            void        operator-= (const std::size_t& n) { m_ptr -= n; }
            void        operator-= (const iterator& other) { m_ptr -= other.m_ptr; }
            iterator    operator- (const std::size_t& n) { iterator tmp(*this); tmp -= n; return tmp; }
            std::size_t operator- (const iterator& other) { return m_ptr - other.m_ptr; }

            bool operator< (const iterator& other) { return (m_ptr - other.m_ptr) < 0; }
            bool operator<= (const iterator& other) { return (m_ptr - other.m_ptr) <= 0; }
            bool operator> (const iterator& other) { return (m_ptr - other.m_ptr) > 0; }
            bool operator>= (const iterator& other) { return (m_ptr - other.m_ptr) >= 0; }
            bool operator== (const iterator& other) { return  m_ptr == other.m_ptr; }
            bool operator!= (const iterator& other) { return  m_ptr != other.m_ptr; }

            T& operator[](const int& n) { return *(m_ptr + n); }
            T& operator*() { return *m_ptr; }
            T* operator->() { return  m_ptr; }
        };

        // const_iterator class
        class const_iterator : public std::iterator
            < std::random_access_iterator_tag, T > {
        private:
            const T* m_ptr;
        public:
            const_iterator() : m_ptr(NULL) {}
            const_iterator(const T* p) : m_ptr(p) {}
            const_iterator(const iterator& other) : m_ptr
                (other.p_) {}
            const_iterator(const const_iterator& other) : m_ptr
                (other.m_ptr) {}
            const const_iterator& operator= (const const_iterator&
                other) {
                m_ptr = other.m_ptr; return other;
            }
            const const_iterator& operator= (const iterator& other) { m_ptr = other.p_; return other; }

            const_iterator& operator++() { m_ptr++; return *this; } // prefix++
            const_iterator  operator++ (int) { const_iterator tmp(*this); ++(*this); return tmp; }        // postfix++
            const_iterator& operator--() { m_ptr--; return *this; } // prefix--
            const_iterator  operator-- (int) { const_iterator tmp(*this); --(*this); return tmp; }        // postfix--

            void           operator+= (const std::size_t& n) { m_ptr += n; }
            void           operator+= (const const_iterator& other) { m_ptr += other.m_ptr; }
            const_iterator operator+ (const std::size_t& n)
                const {
                const_iterator tmp(*this); tmp += n; return tmp;
            }
            const_iterator operator+ (const const_iterator& other)
                const {
                const_iterator tmp(*this); tmp += other; return tmp;
            }

            void           operator-= (const std::size_t& n) { m_ptr -= n; }
            void           operator-= (const const_iterator& other) { m_ptr -= other.m_ptr; }
            const_iterator operator- (const std::size_t& n)
                const {
                const_iterator tmp(*this); tmp -= n; return tmp;
            }
            std::size_t    operator- (const const_iterator& other)
                const {
                return m_ptr - other.m_ptr;
            }

            bool operator< (const const_iterator& other) const { return (m_ptr - other.m_ptr) < 0; }
            bool operator<= (const const_iterator& other) const { return (m_ptr - other.m_ptr) <= 0; }
            bool operator> (const const_iterator& other) const { return (m_ptr - other.m_ptr) > 0; }
            bool operator>= (const const_iterator& other) const { return (m_ptr - other.m_ptr) >= 0; }
            bool operator== (const const_iterator& other) const { return  m_ptr == other.m_ptr; }
            bool operator!= (const const_iterator& other) const { return  m_ptr != other.m_ptr; }

            const T& operator[](const int& n) const { return *(m_ptr + n); }
            const T& operator*()  const { return *m_ptr; }
            const T* operator->() const { return  m_ptr; }
        };

    public:
        iterator begin() { return iterator(data_non_const()); }
        iterator end() { return iterator(data_non_const() + size()); }
        const_iterator cbegin() const { return const_iterator(data()); }
        const_iterator cend() const { return const_iterator(data() + size()); }
    };

    template<typename T>
    const series<T>& series<T>::name(const std::string& name)const {
        m_auto_series_name = name;
        return *this;
    }

    template<typename T>  std::ostream& operator<<(std::ostream& s, series<T>& ser) {
        s << ser[0];
        return s;
    }

    template<> type_t series<double>::value_type(void) const;
    template<> type_t series<int>::value_type(void) const;
    template<> type_t series<unsigned>::value_type(void) const;
    template<> type_t series<float>::value_type(void) const;
    template<> type_t series<bool>::value_type(void) const;
    template<> type_t series<int64_t>::value_type(void) const;
    template<> type_t series<uint64_t>::value_type(void) const;
    template<> type_t series<string>::value_type(void) const;
    template<> type_t series<std::string>::value_type(void) const;
    template<> type_t series<date>::value_type(void) const;
    template<> type_t series<date_time>::value_type(void) const;

    template<typename T> size_t series<T>::m_default_capacity = 3000;

    template<typename T>
    series<T>::series(functor::functor_parent_base* ftor_ptr, bool called_by_series_ref_constr)
        : m_core(value_type()), m_shift(0),
        m_is_owner(true), m_series_imp_ptr(nullptr) {
        set_owning_functor_ptr(ftor_ptr);
        // When series are declare as strategy class members the strategy_state
        // is 'undefined' (as there is no 'context'). When series are created
        // automatically, the strategy state is 'initializing', and when they are
        // created inside event-handlers, the strategy state is 'running'.
        // Automatically created series are 'managed' whereas user declared ones
        // are always 'unmanaged'.
        strategy_state_type ss = strategy_context::state();
        if (ss == strategy_state_type::running
            || ss == strategy_state_type::undefined
            || ss == strategy_state_type::preparing_managed_code)  {
            m_series_imp_ptr = new series_imp<T>();
            m_series_imp_ptr->init_with_capacity(
                m_default_capacity);  //default capacity
            tsa_assert(m_series_imp_ptr);
            tsa_assert(!is_managed());
        }
    }

    template<typename T>
    series<T>::series(const series<T>& other) :
        m_core(other.m_core),
        m_series_imp_ptr(nullptr),
        m_shift(0) {
        if (other.is_managed()) {
            tsa_assert(m_core.is_init());
            if (strategy_context::state() != strategy_state_type::preparing_managed_code) {
                throw exception(class_name(), "Series<T> assignment operator can only be used as part of strategy::on_prepare().", SLOC);
            }
        }
        else {
            if (strategy_context::state() != strategy_state_type::preparing_managed_code) {
                throw exception(class_name(),
                    "Do not use series copy constructor for 'unmanaged' series. "
                    "Use copy member function instead for deep copy.", SLOC);
            }
            m_series_imp_ptr = other.m_series_imp_ptr;
            m_is_owner = false;
        }
    }

    template<typename T>
    void series<T>::operator=(const series<T>& other) {
        auto strat_state = strategy_context::state();
        if (strat_state != strategy_state_type::preparing_managed_code) {
            throw tsa::exception(class_name(), "series<T>::operator=() can only be used as part"
                " of strategy::on_prepare()", SLOC);
        }else{
            if (m_was_assigned_in_DSP){
                throw tsa::exception("series<T>::operator=()",
                    "Cannot assign a value to same series<T> object twice in the definition of strategy::on_prepare() (DSL)", SLOC);
            }
             m_was_assigned_in_DSP = true;
        }
        if (is_managed()) {
            m_core.reset();
            m_core.copy_members(other.m_core);
        }
        else {
            tsa_assert(!is_managed());
            tsa_assert(!m_core.is_init());
            tsa_assert(m_series_imp_ptr);

            if (m_is_owner) {
                delete m_series_imp_ptr;
                m_is_owner = false;
                m_series_imp_ptr = other.m_series_imp_ptr;
                tsa_assert(m_series_imp_ptr);
                m_functor_ptr = other.m_functor_ptr;
                tsa_assert(m_series_imp_ptr != nullptr);
                tsa_assert(!m_is_owner);
            }
            else {
                tsa_assert(!m_is_owner);
                m_series_imp_ptr = other.m_series_imp_ptr;
                tsa_assert(m_series_imp_ptr);
                m_functor_ptr = other.m_functor_ptr;
                tsa_assert(m_series_imp_ptr != nullptr);
                tsa_assert(!m_is_owner);
            }
            m_auto_series_name = other.m_auto_series_name;
            copy_pane_format(other);
            plot_info(other.plot_info());
        }
    }

    template<typename T>
    series<T>::series(size_t capacity)
        : m_core(value_type()), m_shift(0),
        m_is_owner(true) {
        tsa_assert(strategy_context::state() == strategy_state_type::running
            || strategy_context::state() == strategy_state_type::undefined);
        m_series_imp_ptr = new series_imp<T>();
        m_series_imp_ptr->reserve(capacity);
        m_is_owner = true;
        tsa_assert(m_series_imp_ptr);
        tsa_assert(!is_managed());
    }

    template<typename T>
    series<T>::series(const series<T>& _ser, size_t _shift) :
        m_core(_ser.m_core), m_series_imp_ptr(nullptr),
        m_is_owner(false) {
        tsa_assert(strategy_context::state() == strategy_state_type::running);
        if (_ser.m_shift != 0)
        {
            throw exception(class_name(), "cannot 'shift' a series that is itself 'shifted'", SLOC);
        }
        if (!_ser.is_managed()) {
            m_series_imp_ptr = _ser.m_series_imp_ptr;
            m_is_owner = false;
        }
        m_shift = _shift + _ser.m_shift;
    }

    template<typename T>
    void series<T>::reserve(size_t _capacity) {
        if (m_core.is_init()) {
            throw exception(class_name(), "capacity is managed internally for 'managed' series", SLOC);
        }
        if (!m_series_imp_ptr) {
            throw exception(class_name(), "series has not been initialized - capacity not yet set", SLOC);
        }
        tsa_assert(!is_managed());
        tsa_assert(m_series_imp_ptr);
        if (m_shift != 0) {
            throw exception(class_name(), "cannot reset capacity on a 'shifted' series", SLOC);
        }
        m_series_imp_ptr->reserve(_capacity);
        tsa_assert(m_series_imp_ptr->capacity() >= _capacity);
    }

    template<typename T>
    size_t series<T>::capacity(void) const {
        if (m_core.is_init())
        {
            throw exception(class_name(), "capacity is managed internally for 'managed' series", SLOC);
        }
        if (!m_series_imp_ptr)
        {
            throw exception(class_name(), "series has not been initialized - capacity not yet set", SLOC);
        }
        if (m_shift != 0)
        {
            throw exception(class_name(), "cannot get capacity from a 'shifted' series", SLOC);
        }
        return m_series_imp_ptr->capacity();
    }

    template<typename T>
    void series<T>::copy(const series<T>& _other, size_t _max_num_values) {
        size_t sz = _other.size();
        m_series_imp_ptr->copy(*_other.m_series_imp_ptr, _max_num_values);
        tsa_assert(size() == _other.size());
    }

    template<typename T>
    bool series<T>::is_equal(const series<T>& _other) const {
        size_t sz = size();
        if (sz != _other.size())
        {
            return false;
        }
        const T* data_a = _other.data();
        const T* data_b = data();
        return std::equal(data_a, data_a + sz, data_b);
        //return ::memcmp((const void*)data_a, (const void*)data_b, size() * sizeof(T)) == 0;
    }

    //This is for exclusive use in the strategy::on_prepare
    template<typename T>
    void series<T>::operator=(series_cref<T>& other) {
        if (strategy_context::state() != strategy_state_type::preparing_managed_code)
            throw tsa::exception(class_name(), "series<T>::operator=() can only be used as part"
            " of strategy::on_prepare()", SLOC);
        if (is_managed()) {
            m_core.reset();
            m_core.copy_members(other.series_ptr()->m_core);
        }
        else {
            tsa_assert(!is_managed());
            tsa_assert(!m_core.is_init());
            tsa_assert(m_series_imp_ptr);

            if (m_is_owner) {
                delete m_series_imp_ptr;
                m_is_owner = false;
                m_series_imp_ptr = other.series_ptr()->m_series_imp_ptr;
                tsa_assert(m_series_imp_ptr);
                m_functor_ptr = other.series_ptr()->m_functor_ptr;
                tsa_assert(m_series_imp_ptr != nullptr);
                tsa_assert(!m_is_owner);
            }
            else {
                tsa_assert(!m_is_owner);
                m_series_imp_ptr = other.series_ptr()->m_series_imp_ptr;
                tsa_assert(m_series_imp_ptr);
                m_functor_ptr = other.series_ptr()->m_functor_ptr;
                tsa_assert(m_series_imp_ptr != nullptr);
                tsa_assert(!m_is_owner);
            }
        }
    }

    template<typename T>
    void series<T>::raise_type_mismatch(void) {
        throw tsa::exception(class_name(),
            "series type mismatch - check series-type matches parameter type", SLOC);
    }

    template<typename T>
    series<T>::series(const series_core& core) :
        m_core(core),
        m_series_imp_ptr(nullptr),
        m_shift(0),
        m_is_owner(false) {
        if (!core.is_init())
        {
            throw exception(class_name(), "series constructor argument is not initialized", SLOC);
        }
        if (value_type() != core.type())
        {
            raise_type_mismatch();
        }
    }

    template<typename T>
    void series<T>::init_as_auto_series(const series_core& core,
        const std::string& field_name)
    {
        if (m_series_imp_ptr){
            delete m_series_imp_ptr;
            m_series_imp_ptr = nullptr;
        }
        if (!is_numeric(core.type()))
        {
            return;
        }

        if (!core.is_init()) {
            //Note: Move initialization away from here
            ((series_core&)core).Init();
            ((series_core&)core).SetSource(field_name);
        }
        tsa_assert(core.is_init());
        if (core.name() != field_name) {
            throw exception(class_name(),
                "field name mismatch: " + core.name() + " vs " + field_name, SLOC);
        }
        m_is_nonexistant_auto_series = false;
        m_core.copy_members(core);
        m_shift = 0;
        m_is_owner = false;

        if (value_type() != core.type()) {
            raise_type_mismatch();
        }
        tsa_assert(is_managed());
    }

    template<typename T>
    series<T>::~series(void) {
        if (m_series_imp_ptr) {
            if (m_is_owner) {
                delete m_series_imp_ptr;
            }
        }
    }

    template<typename T>
    bool series<T>::is_managed(void) const {
        return !m_series_imp_ptr;
    }

    template<typename T>
    void series<T>::clear(void) {
        if (!m_series_imp_ptr)
        {
            throw exception(class_name(), "can only 'clear' unmanaged series", SLOC);
        }
        m_series_imp_ptr->clear();
        tsa_assert(m_series_imp_ptr->size() == 0);
    }

    template<typename T>
    void series<T>::fill_to_capacity(T _value) {
        if (!m_series_imp_ptr) {
            throw exception(class_name(), "cannot 'fill' managed series", SLOC);
        }
        else {
            if (m_shift != 0)
            {
                throw exception(class_name(), "cannot 'fill' a 'shifted' series", SLOC);
            }
            m_series_imp_ptr->fill(_value);
        }
    }

    template<typename T>
    void series<T>::set_size(size_t _new_size) {
        if (!m_series_imp_ptr) {
            throw exception(class_name(), "cannot 'set_size' managed series",
                SLOC);
        }
        else {
            if (m_shift != 0)
            {
                throw exception(class_name(), "cannot 'reset_size' of a 'shifted' series", SLOC);
            }
            m_series_imp_ptr->reset_size(_new_size);
        }
    }

    template<typename T>
    void series<T>::push(T _v) {
        if (m_shift != 0)
        {
            throw exception(class_name(), "cannot push values on a 'shifted' series", SLOC);
        }
        if (m_series_imp_ptr && m_is_owner) {
            m_series_imp_ptr->push(_v);
        }
        else {
            throw exception(class_name(), "cannot push values onto a 'managed' series", SLOC);
        }
    }

    template<typename T>
    void series<T>::_internal_push(T _v) {
        if (m_shift != 0)
        {
            throw exception(class_name(), "functionality not available for 'unmanaged' series", SLOC);
        }
        if (m_series_imp_ptr) {
            throw exception(class_name(), "cannot push values on a 'shifted' series", SLOC);
        }
        else {
            m_core.push_front(_v);
        }
    }

    template<typename T>
    void series<T>::push(const variant& _v) {
        if (m_series_imp_ptr) {
            m_series_imp_ptr->push(_v);
        }
        else {
            throw exception(class_name(), "cannot add values to an 'auto-series'", SLOC);
        }
    }

    template<typename T>
    T series<T>::get_at(size_t _idx) const {
        if (m_series_imp_ptr) {
            tsa_assert(m_shift == 0);
            return m_series_imp_ptr->at(_idx);
        }
        else {
            return m_core.at(_idx + m_shift).get<T>();
        }
    }

    template<typename T>
    T series<T>::get_at_no_exc(size_t _idx) const {
        if (m_series_imp_ptr) {
            throw exception(class_name(), "not implemented", SLOC);
        }
        else {
            return (T)m_core.at__noexcept(_idx + m_shift);
        }
    }

    template<typename T>
    const T* series<T>::data(void) const {
        if (m_series_imp_ptr) {
            tsa_assert(m_series_imp_ptr->size() >= m_shift);
            return ((T*)m_series_imp_ptr->data__as_void_ptr()) + m_shift;
        }
        else {
            return (T*)m_core.data() + m_shift;
        }
    }

    template<typename T>
    T* series<T>::data_non_const(void) {
        if (m_series_imp_ptr) {
            if (m_shift != 0)
            {
                throw exception(class_name(), "Cannot return non-const data pointer from 'shifted' series", SLOC);
            }
            return (T*)m_series_imp_ptr->data__as_void_ptr();
        }
        else {
            return (T*)m_core.data() + m_shift;
        }
    }

    template<typename T>
    T series<T>::operator[](size_t _idx) const {
        if (m_series_imp_ptr) {
            if (m_is_nonexistant_auto_series) {
                throw exception(class_name(), "Series not intitialized. Check if data-source has this field: "
                    + m_auto_series_name, SLOC);
            }
            return m_series_imp_ptr->at(_idx + m_shift);
        }
        else {
            const variant& v = m_core.at(_idx + m_shift);
            return v.get<T>();
        }
    }

    template<typename T>
    size_t series<T>::size(void) const {
        if (m_series_imp_ptr) {
            tsa_assert(m_series_imp_ptr->size() >= m_shift);
            return m_series_imp_ptr->size() - m_shift;
        }
        else {
            size_t core_sz = m_core.Size();
            if (core_sz < m_shift)
            {
                return 0;
            }
            else { return core_sz - m_shift; }
        }
    }

    template<typename T>
    const series<T> series<T>::shift(size_t _shift_by) const {
        verify_size(_shift_by + 1);
        tsa_assert(size() >= _shift_by);
        return series<T>(*this, _shift_by);
    }

    template<typename T>
    void series<T>::verify_size(size_t _required_size) const {
        if (_required_size == 0)
            throw tsa::exception("invalide size argument to verify_size: 0", SLOC);
        if (m_series_imp_ptr) {
            if (m_series_imp_ptr->size() < _required_size) {
                if (capacity() < _required_size) {
                    //Note: move this functionality to series_imp
                    ((series<T>*)this)->reserve(_required_size);
                    tsa_assert(capacity() == _required_size);
                }
                throw tsa::series_bounds_error("unmanaged-series: insufficient data in series", 0, 0);
            }
        }
        else {
            m_core.verify_size(_required_size + m_shift);
        }
    }

    template<typename T>
    bool series<T>::size_ok(size_t _required_size) const {
        if (m_series_imp_ptr) {
            if (m_series_imp_ptr->size() < _required_size) {
                if (capacity() < _required_size) {
                    //Note: move this functionality to series_imp
                    ((series<T>*)this)->reserve(_required_size);
                    tsa_assert(capacity() == _required_size);
                }
                return false;
            }
            return true;
        }
        else {
            return m_core.size_ok(_required_size + m_shift);
        }
    }

    template<typename T>
    void series<T>::CopyTo(std::vector<T>& _vec,
        size_t _size) {
        verify_size(_size);
        _vec.clear();
        _vec.resize(_size);
        for (size_t c = 0; c < _size; c++) {
            _vec[c] = get_at(c);
        }
        tsa_assert(_vec.size() == _size);
    }

    template<typename T>
    void series<T>::print(std::ostream& _s, size_t _max) {
        if (size() == 0) { _s << "[]"; return; }
        _s << "[";
        for (size_t c = 0; c < _max; c++) {
            if (c < size() && c < _max) {
                _s << get_at(c);
                if (c != (size() - 1) && c != (_max - 1))
                {
                    _s << ",";
                }
                else { _s << "]"; }
            }
        }
    }

    template<typename T>
    void series<T>::print_v(std::ostream& _s, size_t _max) {
        if (size() == 0) { return; }
        for (size_t c = 0; c < _max; c++) {
            if (c < size() && c < _max) {
                _s << "[" << c << "]:" << get_at(c) << std::endl;
            }
        }
    }

    template<typename T>
    type_t series<T>::value_type(void) const {
        throw tsa::exception("series<T>",
            "data type not supported by template", SLOC);
    }

    template<typename T>
    bool series<T>::crosses_above(const series<T>& _other)
        const {
        return get_at(0) > _other.get_at(0)
            && get_at(1) <= _other.get_at(1);
    }

    template<typename T>
    bool series<T>::crosses_below(const series<T>& _other)
        const {
        return get_at(0) < _other.get_at(0)
            && get_at(1) >= _other.get_at(1);
    }

    template<typename T>
    bool series<T>::crosses_above(double _threshold) const {
        return get_at(0) > _threshold
            && get_at(1) <= _threshold;
    }

    template<typename T>
    bool series<T>::crosses_below(double _threshold) const {
        return get_at(0) < _threshold
            && get_at(1) >= _threshold;
    }

    /*
    ** ====================================================
    ** >>>             class series_cref                 <<<
    ** ====================================================
    */

    template<typename T = double>
    class series_cref : public tsa::object {
    protected:
        const series<T>* m_series_ptr = nullptr;
    public:
        series_cref(void) : m_series_ptr(nullptr) { ; }
        series_cref(const series<T>& other) {
            m_series_ptr = &other;
        }
        series_cref(const series_cref<T>& other) {
            if (other.m_series_ptr == nullptr) {
                throw tsa::exception(class_name(), "series_ref not initialized", SLOC);
            }
            m_series_ptr = other.m_series_ptr;
        }
        void operator=(const series_cref<T>& other) {
            strategy* strat_ptr = strategy_context::strategy_ptr();
            if (strat_ptr->state() != strategy_state_type::preparing_managed_code)
                throw tsa::exception(class_name(), "series<T>::operator=() can only be used as part"
                " of strategy::on_prepare()", SLOC);
            m_series_ptr = other.m_series_ptr;
        }
        virtual ~series_cref(void) { ; }
        void operator=(const series<T>&) = delete;
        type_t type(void)const { return m_series_ptr->type(); }
        void push(T) = delete;
        void push(const variant&) = delete;
        operator const series<T>& (void) { tsa_assert(m_series_ptr); return *m_series_ptr; }
        T operator[](size_t pos)const {
            tsa_assert(m_series_ptr != nullptr);
            return m_series_ptr->operator[](pos);
        }
        series_cref<T> operator()(size_t shift_by)const {
            return SHIFT(*this, shift_by);
        }
        const T* data(void)const {
            tsa_assert(m_series_ptr != nullptr);
            return m_series_ptr->data();
        }
        void verify_size(size_t sz)const {
            tsa_assert(m_series_ptr != nullptr);
            return m_series_ptr->verify_size(sz);
        }
        bool size_ok(size_t sz)const {
            tsa_assert(m_series_ptr != nullptr);
            return m_series_ptr->size_ok(sz);
        }
        size_t size(void)const {
            tsa_assert(m_series_ptr != nullptr);
            return m_series_ptr->size();
        }
    public:
        const series<T>* series_ptr(void)const { return m_series_ptr; }
    public:
        void pane_h_line(const h_line& hl) { m_series_ptr->m_h_lines.push_back(hl); }
        void pane_h_line(const tsa::color& c, double y_value, int weight = 1) {
            m_series_ptr->m_h_lines.push_back(tsa::h_line(c, y_value, weight));
        }
        void pane_y_max(double max) { m_series_ptr->m_pane_y_max = max; }
        void pane_y_min(double min) { m_series_ptr->m_pane_y_min = min; }
        void pane_show_grid(bool b) { m_series_ptr->m_show_grid = b; }
        void pane_dotted_grid(bool b) { m_series_ptr->m_dotted_grid = b; }
        void pane_grid_color(const tsa::color& c) { m_series_ptr->m_grid_color = c; }
        void pane_auto_pane(bool b) { m_series_ptr->m_auto_pane = b; }
        const std::vector<tsa::h_line>& pane_h_lines(void)const { return m_series_ptr->m_h_lines; }
        const variant& pane_y_max(void)const { return m_series_ptr->m_pane_y_max; }
        const variant& pane_y_min(void)const { return m_series_ptr->m_pane_y_min; }
    public:
        const series_cref<T>&  name(const std::string& name)const {
            m_series_ptr->name(name);
            return *this;
        }
        std::string name(void)const { return m_series_ptr->name(); }
        series_cref<T>& plot_as(const plot_info& pi) {
            m_series_ptr->plot_info(pi);
            return *this;
        }
        const series_cref<T>& plot_as(const std::string& name, const tsa::variant& period = 0.0,
            plot_type type = plot_type::line, tsa::color clr = tsa::color::auto_color, unsigned weight = 2)const {
            plot_info pi;
            pi.name = name;
            pi.period(period);
            pi.type = type;
            pi.clr = clr;
            pi.weight = weight;
            m_series_ptr->plot_info(pi);
            return *this;
        }
        const series_cref<T>& plot_as(const std::string& name, const std::vector<tsa::variant>& periods,
            plot_type type = plot_type::line, tsa::color clr = tsa::color::auto_color, unsigned weight = 2)const {
            plot_info pi;
            pi.name = name;
            std::vector<tsa::variant> adj_periods = periods;
            adj_periods.resize(4, variant());
            tsa_assert(adj_periods.size() == 4);

            pi.period(adj_periods[0], adj_periods[1], adj_periods[2], adj_periods[3]);
            pi.type = type;
            pi.clr = clr;
            pi.weight = weight;
            m_series_ptr->plot_info(pi);
            return *this;
        }
    };

    template<typename T>
    using series_ref = series_cref < T > ; //alias

    template<typename T>
    using sref = series_cref < T >; //alias

    /*
    ** ====================================================
    ** >>>            class series_tuple                <<<
    ** ====================================================
    */

    template<typename T = double>
    class series_tuple : public tsa::object, public pane_format {
        std::vector<series_cref<T>> m_series_refs;
    public:
        series_tuple(void) { ; }
        series_tuple(const series_cref<T>& ser) {
            m_series_refs = { ser };
        }
        series_tuple(const series_cref<T>& a, const series_cref<T>& b) {
            m_series_refs = { a, b };
        }
        series_tuple(const series_cref<T>& a, const series_cref<T>& b, const series_cref<T>& c) {
            m_series_refs = { a, b, c };
        }
        void add(const series_cref<T>& ser){
            m_series_refs.push_back(ser);
        }
        size_t size(void)const { return m_series_refs.size(); }
        const series<T>& operator[](size_t pos)const {
            return *(m_series_refs[pos].series_ptr());
        }

        const series<T>& operator[](const std::string& name)const {
            return operator[](position(name));
        }

        size_t position(const std::string& name)const {
            size_t position=0; bool found = false;
            for(const auto& ref : m_series_refs){
                if (ref.series_ptr()->name() == name){
                    found = true; break;
                }else position++;
            }
            if (!found)
                throw tsa::exception("series_tuple","no items with name: " + name,SLOC);
            return position;
        }

        series_cref<T> operator()(size_t position) {
            return m_series_refs[position];
        }
        series_cref<T> operator()(const std::string& name) {
            for (size_t c(0); c < m_series_refs.size();c++){
                if (m_series_refs[c].series_ptr()->name() == name)
                {
                    return m_series_refs[c];
                }
            }
        /*  for (auto& s : m_series_refs) {
                if (s.series_ptr()->name() == name)
                {
                    return s;
                }
            }*/
            throw tsa::exception(class_name(), "No item with found with given name: " + name, SLOC);
        }
    };


    /*
    ** ====================================================
    ** >>>          class numeric_series_cref            <<<
    ** ====================================================
    */

    class numeric_series_cref : tsa::object {
        const series_template_base* m_series_ptr = nullptr;
    public:
        numeric_series_cref(void) = delete;
        numeric_series_cref(const numeric_series_cref& other) {
            m_series_ptr = other.m_series_ptr;
        }
         numeric_series_cref(double num);
         numeric_series_cref(int num);
         numeric_series_cref(int64_t num);
         numeric_series_cref(uint64_t num);
    public:
        numeric_series_cref(const series<double>& other)  {
            m_series_ptr = (const series_template_base*)(&other);
        }
        numeric_series_cref(const series<float>& other)  {
            m_series_ptr = (const series_template_base*)(&other);
        }
        numeric_series_cref(const series<int>& other)  {
            m_series_ptr = (const series_template_base*)(&other);
        }
        numeric_series_cref(const series<unsigned>& other)  {
            m_series_ptr = (const series_template_base*)(&other);
        }
        numeric_series_cref(const series<int64_t>& other)  {
            m_series_ptr = (const series_template_base*)(&other);
        }
        numeric_series_cref(const series<uint64_t>& other)  {
            m_series_ptr = (const series_template_base*)(&other);
        }
  
    public:
        numeric_series_cref(const series_cref<double>& other)  {
            m_series_ptr = (const series_template_base*)(other.series_ptr());
        }
        numeric_series_cref(const series_cref<float>& other)  {
            m_series_ptr = (const series_template_base*)(other.series_ptr());
        }
        numeric_series_cref(const series_cref<int>& other)  {
            m_series_ptr = (const series_template_base*)(other.series_ptr());
        }
        numeric_series_cref(const series_cref<unsigned>& other)  {
            m_series_ptr = (const series_template_base*)(other.series_ptr());
        }
        numeric_series_cref(const series_cref<int64_t>& other)  {
            m_series_ptr = (const series_template_base*)(other.series_ptr());
        }
        numeric_series_cref(const series_cref<uint64_t>& other) {
            m_series_ptr = (const series_template_base*)(other.series_ptr());
        }
    public:
        //numeric_series_cref(const scalar_assigner<double>& other) {
        //  m_series_ptr = (const series_template_base*)(sref<double>(other).series_ptr());
        //}
        //numeric_series_cref(const scalar_assigner<int>& assigner) {
        //  sref<int> ser = assigner;
        //  m_series_ptr = (const series_template_base*)(ser.series_ptr());
        //}
    public:
        const series_template_base* get(void)const {
            return m_series_ptr;
        }
        bool size_ok(size_t sz)const {
            tsa_assert(m_series_ptr != nullptr);
            return m_series_ptr->size_ok(sz);
        }
    };

    /*
    ** ====================================================
    ** >>>         class auto_cast_bool_cref             <<<
    ** ====================================================
    */

    class auto_cast_bool_series_cref : tsa::object {
        const series_template_base* m_series_ptr = nullptr;
    public:
    /*    template<typename T>
        auto_cast_bool_series_cref(T v)  {
            m_series_ptr = (const series_template_base*)CONST<T>(v).series_ptr();
        }*/
        auto_cast_bool_series_cref(void) = delete;

        auto_cast_bool_series_cref(bool value);

        template<typename T>
        auto_cast_bool_series_cref(const series<T>& other)  {
            m_series_ptr = (const series_template_base*)(&other);
        }
        template<typename T>
        auto_cast_bool_series_cref(const series_cref<T>& other) {
            if (other.series_ptr() == nullptr) {
                throw tsa::exception(class_name(), "series_ref not initialized", SLOC);
            }
            m_series_ptr = (const series_template_base*)other.series_ptr();
        }

        //template<typename T>
        //auto_cast_bool_series_cref(const scalar<T>& other)  {
        //    m_series_ptr = (const series_template_base*)(other.series_ptr());
        //}

        const series_template_base* get(void)const { return m_series_ptr; }
        bool operator[](size_t pos)const {
            return m_series_ptr->at(pos).to_bool();
        }
        bool size_ok(size_t sz)const {
            tsa_assert(m_series_ptr != nullptr);
            return m_series_ptr->size_ok(sz);
        }
    };

    /*
    ** ====================================================
    ** >>>          class bool_series_cref               <<<
    ** ====================================================
    */

    class bool_series_cref : tsa::object {
        const series_template_base* m_series_ptr = nullptr;
    public:
        bool_series_cref(void) = delete;
        bool_series_cref(const bool_series_cref& other) {
            m_series_ptr = other.m_series_ptr;
        }
        explicit bool_series_cref(const auto_cast_bool_series_cref& other) {
            m_series_ptr = other.get();
        }
        bool_series_cref(const series<bool>& other)  {
            m_series_ptr = (const series_template_base*)(&other);
        }
        const series_template_base* get(void)const { return m_series_ptr; }
        bool operator[](size_t pos)const {
            return (bool)m_series_ptr->at(pos);
        }
        bool size_ok(size_t sz)const {
            tsa_assert(m_series_ptr != nullptr);
            return m_series_ptr->size_ok(sz);
        }
    };

    /*
    ** ====================================================
    ** >>>          class string_series_cref               <<<
    ** ====================================================
    */

    class string_series_cref : tsa::object {
        const series_template_base* m_series_ptr = nullptr;
    public:
        string_series_cref(void) = delete;
        string_series_cref(const string_series_cref& other) {
            m_series_ptr = other.m_series_ptr;
        }
        string_series_cref(const series<std::string>& other)  {
            m_series_ptr = (const series_template_base*)(&other);
        }
        const series_template_base* get(void)const { return m_series_ptr; }
        std::string operator[](size_t pos)const {
            return m_series_ptr->at(pos).to_string();
        }
        bool size_ok(size_t sz)const {
            tsa_assert(m_series_ptr != nullptr);
            return m_series_ptr->size_ok(sz);
        }
    };

    /*
    ** ====================================================
    ** >>>          class date_series_cref               <<<
    ** ====================================================
    */

    class date_series_cref : tsa::object {
        const series_template_base* m_series_ptr = nullptr;
    public:
        date_series_cref(void) = delete;
        date_series_cref(const date_series_cref& other) {
            m_series_ptr = other.m_series_ptr;
        }
        date_series_cref(const series<tsa::date>& other)  {
            m_series_ptr = (const series_template_base*)(&other);
        }
        const series_template_base* get(void)const { return m_series_ptr; }
        tsa::date operator[](size_t pos)const {
            return m_series_ptr->at(pos).to_date();
        }
        bool size_ok(size_t sz)const {
            tsa_assert(m_series_ptr != nullptr);
            return m_series_ptr->size_ok(sz);
        }
    };

    /*
    ** ====================================================
    ** >>>          class date_series_cref               <<<
    ** ====================================================
    */

    class datetime_series_cref : tsa::object {
        const series_template_base* m_series_ptr = nullptr;
    public:
        datetime_series_cref(void) = delete;
        datetime_series_cref(const datetime_series_cref& other) {
            m_series_ptr = other.m_series_ptr;
        }
        datetime_series_cref(const series<tsa::date_time>& other)  {
            m_series_ptr = (const series_template_base*)(&other);
        }
        const series_template_base* get(void)const { return m_series_ptr; }
        tsa::date_time operator[](size_t pos)const {
            return m_series_ptr->at(pos).to_datetime();
        }
        bool size_ok(size_t sz)const {
            tsa_assert(m_series_ptr != nullptr);
            return m_series_ptr->size_ok(sz);
        }
    };

    /*
    ** ====================================================
    ** >>>          class any_series_cref               <<<
    ** ====================================================
    */

    class any_series_cref : tsa::object {
        const series_template_base* m_series_ptr = nullptr;
    public:
        any_series_cref(void) = delete;
        any_series_cref(const any_series_cref& other) {
            m_series_ptr = other.m_series_ptr;
        }
        explicit any_series_cref(const series_template_base* other_ptr) {
            m_series_ptr = other_ptr;
        }
        template<typename T>
        any_series_cref(const series<T>& other)  {
            m_series_ptr = (const series_template_base*)(&other);
        }
        //template<typename T>
        //any_series_cref(const scalar<T>& other)  {
        //    m_series_ptr = (const series_template_base*)(other.series_ptr());
        //}
        const series_template_base* get_ptr(void)const { return m_series_ptr; }

        template<typename T> any_series_cref(const series_cref<T>& other) {
            if (other.series_ptr() == nullptr) {
                throw tsa::exception(class_name(), "series_ref not initialized", SLOC);
            }
            m_series_ptr = (const series_template_base*)other.series_ptr();
        }
        variant operator[](size_t pos) {
            return variant(m_series_ptr->at(pos));
        }
        bool size_ok(size_t sz) {
            tsa_assert(m_series_ptr != nullptr);
            return m_series_ptr->size_ok(sz);
        }
        bool is_numeric(void)const {
            throw tsa::exception(class_name(), "is_numeric() member not implemented", SLOC);
            return true;
        }
    };

    /*
    ** ====================================================
    ** >>>            class CONTAINER                <<<
    ** ====================================================
    */

    class container : public tsa::object {
        std::vector<any_series_cref> m_series_refs;
    public:
        container(void) { ; }
        container(const container& other) {
            m_series_refs = other.m_series_refs;
        }
        container(any_series_cref ser) {
            m_series_refs = { ser };
        }
        container(any_series_cref a, any_series_cref b) {
            m_series_refs = { a, b };
        }
        container(any_series_cref a, any_series_cref b, any_series_cref c) {
            m_series_refs = { a, b, c };
        }
        container(any_series_cref a, any_series_cref b, any_series_cref c, any_series_cref d) {
            m_series_refs = { a, b, c, d };
        }
        size_t element_count(void)const { return m_series_refs.size(); }
        bool size_ok(size_t sz) {
            bool sz_ok = true;
            for (auto& r : m_series_refs) {
                sz_ok &= r.size_ok(sz);
            }
            return sz_ok;
        }
        size_t size(void)const { return m_series_refs.size(); }
        bool all_numeric(void) {
            bool numeric = true;
            for (auto& s : m_series_refs) {
                numeric &= s.is_numeric();
            }
            return numeric;
        }
        const any_series_cref& operator[](size_t pos)const {
            return m_series_refs[pos];
        }
        void push(any_series_cref new_item) {
            m_series_refs.push_back(new_item);
        }
        void fetch_variants(std::vector<variant>& arr) {
            size_t sz = m_series_refs.size();
            if (arr.size() != sz) {
                arr.resize(sz);
            }
            for (size_t c = 0; c < sz; c++) {
                arr[c] = m_series_refs[c][0];
            }
        }
    };

    

} //tsa

#endif