TSASupport.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_SUPPORT__INCLUDED
#define TSA_SUPPORT__INCLUDED

#include <vector>
#include <ostream>
#include <mutex>
#include <chrono>
#include <map>
#include <atomic>
#include <queue>

#include "TSATypeDef.h"
#include "TSAString.h"
#include "TSAFile.h"
#include "TSAError.h"

namespace tsa {

    /*
    ** ====================================================
    ** > > >          class spin_lock                 < < <
    ** ====================================================
    */
    class spin_lock
    {
    private:
        std::atomic<bool> m_value;
    public:
        spin_lock() : m_value(false) { };
        void lock(){while (m_value.exchange(true));}
        void unlock(){m_value.store(false);}
        bool is_locked(){return m_value.load();}
    };

    /*
    ** ====================================================
    ** > > >          atomic queue                    < < <
    ** ====================================================
    */
    namespace atomic {

        template<typename T>
        class queue : public object {
        private:
            mutable std::mutex m_mutex;
            std::queue<T> m_data_queue;
            std::condition_variable m_data_cond;
        public:
            queue(void) {}
            void push(T& value) {
                std::lock_guard<std::mutex> lk(m_mutex);
                m_data_queue.push(value);
                m_data_cond.notify_one();
            }

            void wait_and_pop(T& value) {
                std::unique_lock<std::mutex> lk(m_mutex);
                m_data_cond.wait(lk, [this] {return !m_data_queue.empty(); });
                value = m_data_queue.front();
                m_data_queue.pop();
            }

            bool wait_until_and_pop(T& value, const std::chrono::microseconds& usec) {
                std::unique_lock<std::mutex> lk(m_mutex);
                auto now = std::chrono::system_clock::now();
                if (m_data_cond.wait_until(lk,
                    now + usec, [this] {return !m_data_queue.empty(); }))
                {
                    tsa_assert(!m_data_queue.empty());
                    value = m_data_queue.front();
                    m_data_queue.pop();
                    return true;
                }
                else { return false; }
            }

            bool try_pop(T& value) {
                std::lock_guard<std::mutex> lk(m_mutex);
                if (m_data_queue.empty()) {
                    return false;
                }
                value = m_data_queue.front();
                m_data_queue.pop();
                return true;
            }
        };
    }

    /*
    ** ====================================================
    ** > > >          class named_values              < < <
    ** ====================================================
    */

    class dll_export named_values : public tsa::object{
        std::map<std::string, variant> m_map;
    public:
        named_values(void);
        named_values(const named_values& other);
        named_values(named_values&& other);
        virtual ~named_values(void);
        void operator=(const named_values& other);
        void operator=(named_values&& other);
        void from_string(const std::string& property_string);
        void from_file(const os::path&);
         variant& operator[](const std::string& key);
        const variant& operator[](const std::string& key)const;
        void set(const std::string& key, const variant& value);
        void add(const std::string& key, const variant& value);
        void add(const std::pair<std::string, variant>& pair);
        const variant& value(const std::string& key)const;
        
        variant& value(const std::string& key);
        bool exists(const std::string& key)const;
        void remove(const std::string& key, bool error_on_missing_key = true);
        size_t size(void)const;
        void print(std::ostream&)const;
        void clear(void);
    public:
        void print_values(std::ostream& stream)const;
    };

    typedef named_values named_args;

    /*
    ** ====================================================
    ** > > >              class timer                 < < <
    ** ====================================================
    */
    class dll_export timer : public object {
        std::chrono::steady_clock::time_point m_Begin;
        std::chrono::steady_clock::time_point m_End;
        bool m_is_running;
    public:

        enum init_flag {
            stopped,
            started
        };
    public:

        timer(init_flag flag = timer::started);

        ~timer(void);

        void start(void);

        const timer& stop(void);

        double seconds(void)const;

        double milliseconds(void)const;
        // Internal
        static clock_t machine_cycles(void);
    };

    std::ostream& operator<<(std::ostream&, const timer&);

    class Initializer {
    public:
        Initializer() { ; }
        virtual ~Initializer() { ; }
        virtual void Initialize() { ; }
    };

    class ref_count {
        size_t m_ref_count;
    public:
        ref_count(void) :
            m_ref_count(0) {
            ;
        }
        void incr_ref(void) {
            ++m_ref_count;
        }
        void decr_ref(void) {
            tsa_assert(m_ref_count > 0);
            --m_ref_count;
        }
        size_t num_ref(void) {
            return m_ref_count;
        }
    };

    // internal
    template<typename TYPE>
    class dll_export singleton : public object {
        tsa_declare_testable;
        static std::mutex m_mutex;
    public:
        singleton() {}
        ~singleton() {}
        static TYPE* get(bool bCreate = true);
        static void set(TYPE*);
        static void reset(void);
    private:
        static TYPE* m_object_ptr;
    };

    template<typename TYPE>
    TYPE* singleton<TYPE>::m_object_ptr = nullptr;

    template<typename TYPE>
    std::mutex singleton<TYPE>::m_mutex;

    template<typename TYPE>
    TYPE* singleton<TYPE>::get(bool create_if_not_exist) {
        std::lock_guard<std::mutex> lock(singleton<TYPE>::m_mutex);
        if (m_object_ptr == nullptr && create_if_not_exist) {
            m_object_ptr = (TYPE*) new TYPE();
            tsa_assert(m_object_ptr != nullptr);
            ((TYPE&)*m_object_ptr).Initialize();
        }
        return m_object_ptr;
    }

    template<typename TYPE>
    void singleton<TYPE>::set(TYPE* pObj) {
        std::lock_guard<std::mutex> lock(singleton<TYPE>::m_mutex);
        m_object_ptr = pObj;
    }

    template<typename TYPE>
    void singleton<TYPE>::reset() {
        std::lock_guard<std::mutex> lock(singleton<TYPE>::m_mutex);
        if (m_object_ptr) {
            delete m_object_ptr;
            m_object_ptr = nullptr;
        }
    }

    // Internal
    class ASCII_LineGraph : public object {
        tsa_declare_testable;
    protected:
        int m_nMarginLeft;
        double m_dDataMax;
        double m_dDataMin;
        struct HL {
            int nH;
            int nL;
        };
        struct HLC {
            double dH;
            double dL;
        };
        double m_dLastClose;
        std::vector<HLC> m_DataHLC;
        std::vector<HL> m_BarArr;
        std::vector<HL> m_TmpBarArr;
        int m_nMatrixHeight;
        int m_nMatrixWidth;
        char* m_Matrix;
        double m_dCellHeight;
        int m_nYValueOfZero;
        std::vector<size_t> m_yValues;
        std::vector<string> m_yLegend;
        char m_CloseChar;
        char m_BarChar;
        date_time m_tStart;
        date_time m_tEnd;
        bool m_bAllDaily;
        string m_sName;
    protected:
        void ClearMatrix(void);
        void ClearData(void);
        void MakeYBarArray(void);
        void FindMinMax(void);
        void DeriveGraphMetrics(void);
        int CalcYValue(double dataValue);
        void SetPixels(void);
        void SetAt(int x, int y, char _Val);
        char at(int x, int y);
    public:
        ASCII_LineGraph(size_t height = 20, size_t width = 65);
        virtual ~ASCII_LineGraph(void);
        void SetBarChar(char close, char bar);
        void AddBar(double high, double low, double close, const date_time& timestamp);
        void AddDataItem(double close, const date_time& timestamp);
        void SetName(const tsa::string& name);
        void ProcessData(void);
        void SetLeftMargin(size_t);
        void Print(std::ostream& _s);
        void SetData(std::vector<double>& _data);
    };

    class dll_export TablePrinter : public object {
        tsa_declare_testable;
    public:
        enum Allignment { Left, Right };
    private:
        struct Field {
            string sDateFormat;
            string sName;
            type_t eType;
            size_t nContentSize;
            size_t precision;
            string sContent;
            Allignment eAllign;
            bool bDateOnly;
        };
        std::vector<Field> m_Fields;
        std::vector<string> m_Content;
        size_t m_nRightCellBuffer;
        size_t m_nLeftCellBuffer;
        size_t GetNumFields(void)const;
        string ConvertToString(size_t fieldIdx, const variant&)const;
        bool m_nUseSeparator;
        char m_nSeparatorChar;
        bool m_LineAfterTitle;
        size_t m_nNumRecPrinted;
        bool m_bDrawGrid;
        size_t m_nRecCnt;
        size_t m_nSeparatorInterval;
        size_t m_nHeaderReprintInterval;
        bool m_bPrintHeader;
        size_t m_LeftTableMargin;
        bool m_bSeparateThousands;
        bool m_bPrintBoolAsString;
        bool m_bOverrideIndividualPrecision;
        size_t m_nFPPrecision;
    public:
        static const size_t DEFAULT_PRECISION = 10;
    public:
        TablePrinter(void);
        virtual ~TablePrinter(void);
        void AddBoolField(const tsa::string& name, Allignment);
        void AddLongField(const tsa::string& name, Allignment);
        void AddStringField(const tsa::string& name, Allignment);
        void AddDoubleField(const tsa::string& name, Allignment,
            size_t precision = TablePrinter::DEFAULT_PRECISION);
        void AddDateTimeField(const tsa::string& name, Allignment allign, bool dateOnly = false,
            const tsa::string& format = "yyyy-mmm-dd");
        void AddDateField(const tsa::string& name, Allignment allign, const tsa::string& format = "yyyy-mmm-dd");
        void SetDrawBorders(bool);
        void SetPrintBoolAsString(bool bFlag);
        void SetSeparatorInterval(size_t);
        void SetHeaderReprintInterval(size_t);
        void SetCellBuffers(size_t left, size_t right);
        void SetPrintHeader(bool);
        void SetLeftTableMargin(size_t);
        void SetSeparateThousands(bool);
        void SetPrecision(size_t nPrecision);
        void AnalyzeRecord(const std::vector<variant>& record);
        void PrintHeader(std::ostream&, bool isReprint = false);
        void PrintTopGridLine(std::ostream&, char c = '_');
        void PrintBottomGridLine(std::ostream&, char c = '_');
        void PrintRecord(const std::vector<variant>& record, std::ostream& stream,
            const tsa::string& sSpecialEOLString = "");
    };
} //tsa

#endif