TSATypeDef.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_TYPEDEF__INCLUDED
#define TSA_TYPEDEF__INCLUDED

#ifdef _MSC_VER

#if defined(min) || defined(max)
#error "min() and/or max() are defined as preprocessor macros.\
Define NOMINMAX macro before including any system headers!"
#endif

#ifndef NOMINMAX
#define NOMINMAX
#endif

#endif    // _MSC_VER

#include <stddef.h>
#include <cstddef>
#include <iostream>
#include <vector>

// Note: See Doxygen PREDEFINED command
#if defined (_MSC_VER)
#   if TSA_COMPILING_DLL
#       define dll_export __declspec(dllexport)
#   elif TSA_USING_DLL
#       define dll_export __declspec(dllimport)
#   else
#       define dll_export
#   endif
#else
#       define dll_export
#endif

#if defined (_MSC_VER)
typedef __int64 int64_t;
typedef __int32 int32_t;
typedef unsigned __int64 uint64_t;
typedef unsigned __int32 uint32_t;
#else
#   include <stdint.h>
#endif

#ifdef _MSC_VER
#if _MSC_VER <= 1800 // VS 2013
#define noexcept throw()
#endif
#endif

//#if !defined NDEBUG
//#if !defined TSA_DEBUG
//#   define TSA_DEBUG
//#endif
//#endif

#if defined (_MSC_VER)
#   pragma warning(disable: 4800)  //warning C4800: 'int' : forcing value to bool 'true' or 'false'
#   pragma warning(disable: 4100)  //warning C4100: unreferenced formal parameter
#endif


namespace tsa {
    typedef unsigned char Byte;
    const size_t print_no_limit = std::numeric_limits<size_t>::max();

    const size_t max_size_limit = std::numeric_limits<size_t>::max();

    enum class strategy_state_type
    {
        undefined = 0, 
        created,
        initializing,
        preparing_managed_code,
        running,
        finalized
    };

    enum class strategy_end_type {
        normal,
        ctrl_c,
        server_request,
        exception
    };

    std::string to_string(strategy_end_type);

    enum replace_flag_type {
        no_replace_existing = 0, 
        replace_existing = 1 
    };

    enum missing_table_flag_type {
        silent_on_missing = 0, 
        throw_on_missing = 1 
    };

    typedef int64_t identifier_t;

    const identifier_t undefined_id = (identifier_t)std::pow(2, 53); //largest integer that can safely be stored in a double (as stored by json format)

    size_t identifier_to_size_t(identifier_t);

    int identifier_to_int(identifier_t);

    int size_type_to_int(size_t);

    const size_t NPOS = ~(size_t)0;

#define DB_NIL (-1L)                    //IU
    const size_t DB_NPOS = ~(size_t)0;  //IU
    typedef long TSEstoredValue;        //IU
    typedef long TSEoffset;             //IU
    typedef unsigned long TSEspace;     //IU

    
    struct library {
        static const char* copyright;

        static const char* version;
    };

    enum seek_result {
        ok,
        request_below_table_range,
        request_above_table_range,
    };

    enum class _value_types_type { //Note: do not make enum 'class'
        // Note: do not change sequence nor values!
        // >> NUMERIC START <<
        float32    = 1,      
        uint32     = 2,      
        int32      = 3,      
        int64      = 4,      
        float64    = 5,      
        // >> NUMERIC END <<
        boolean    = 6,      
        datetime   = 7,      
        date       = 8,      
        // >> PTR START <<
        void_ptr   = 9,      
        object_ptr = 10,     
        string     = 11,     
        BLOB       = 13,     
        // >> PTR STOP <<

        vt_undefined = 100  // IU - used internally only
    };

    typedef _value_types_type type_t;

    // internal use
    size_t binary_write_size(type_t);

    std::string to_string(type_t type);

    bool is_numeric(type_t);

    bool is_ptr_type(type_t);

    enum trade_grouping {
        long_only = 0,  
        short_only = 1, 
        all_trades = 2,  
        other = 3
    };

    enum class perf_metric_type {
        trade_count,                    
        loser_count,                    
        winner_count,                   
        percent_profitable,             
        avg_net_trade_pl,               
        avg_gross_trade_pl,             
        avg_winner,                     
        avg_loser,                      
        max_loser,                      
        max_winner,                     
        max_consec_winners,             
        max_consec_losers,              
        max_pos_excursion,              
        max_neg_excursion,              
        avg_pos_excursion,              
        avg_neg_excursion,              
        stddev_trade_pl,                
        total_winner_bar_count,         
        total_loser_bar_count,          
        avg_winner_bar_count,           
        avg_loser_bar_count,            
        avg_trade_bar_count,            
        num_bars_in_trade,              
        total_num_bars_processed,       
        percent_bars_in_trade,          
        net_profit,                     
        gross_profit,                   
        winners_net,                    
        losers_net,                     
        total_commission,               
        total_slippage,                 
        total_transaction_cost,         
        profit_factor,                  
        avg_gain_to_avg_loss_ratio,     
        max_closed_out_runup,           
        max_closed_out_rundown,         
        max_trade_transaction_count,    
        max_trade_position_size,        
        avg_trade_transaction_count,    
        avg_trade_position_size,        
        avg_trade_commission,           
        avg_trade_slippage,             
        avg_trade_cost,                 
        avg_slippage_per_unit,          
        avg_cost_per_unit,              
        percent_units_without_slippage, 
        avg_net_profit_per_unit,        
        avg_gross_profit_per_unit,      
        last_trade_is_open,             
        max_account_balance,            
        min_account_balance,            
        current_drawdown,               
        max_drawdown,                   
        max_drawdown_length,            
        avg_drawdown_length,            
        avg_drawdown,                   
        num_drawdowns,                  
        in_drawdown,                    
        num_transactions,               
        num_transactions_at_market,     
        num_transactions_on_stop,       
        num_transactions_at_limit,      
        avg_transaction_size,           
        num_units_traded,               
        num_units_traded_without_slippage,
        num_units_traded_at_market,     
        num_units_traded_on_stop,       
        num_units_traded_at_limit,      
        num_units_traded_other,         // internal use
        risk_free_annual_rate_of_return,
        start_capital,                  
        drawdown_multiplier,            
        sharpe_ratio,                   
        sortino_ratio                   
    };

    
    struct metric 
    {
        static const std::vector<std::string> trade_metric_names;

        static const std::string    trade_count;                    
        static const std::string    loser_count;                    
        static const std::string    winner_count;                   
        static const std::string    percent_profitable;             
        static const std::string    avg_net_trade_pl;               
        static const std::string    avg_gross_trade_pl;             
        static const std::string    avg_winner;                     
        static const std::string    avg_loser;                      
        static const std::string    max_loser;                      
        static const std::string    max_winner;                     
        static const std::string    max_consec_winners;             
        static const std::string    max_consec_losers;              
        static const std::string    sum_pos_excursion;              
        static const std::string    sum_neg_excursion;              
        static const std::string    max_pos_excursion;              
        static const std::string    max_neg_excursion;              
        static const std::string    avg_pos_excursion;              
        static const std::string    avg_neg_excursion;              
        static const std::string    stddev_trade_pl;                
        static const std::string    avg_winner_bar_count;           
        static const std::string    total_winner_bar_count;         
        static const std::string    total_loser_bar_count;          
        static const std::string    avg_loser_bar_count;            
        static const std::string    avg_trade_bar_count;            
        static const std::string    num_bars_in_trade;              
        static const std::string    total_num_bars_processed;       
        static const std::string    percent_bars_in_trade;          
        static const std::string    net_profit;                     
        static const std::string    gross_profit;                   
        static const std::string    winners_net;                    
        static const std::string    losers_net;                     
        static const std::string    total_commission;               
        static const std::string    total_slippage;                 
        static const std::string    total_transaction_cost;         
        static const std::string    profit_factor;                  
        static const std::string    avg_gain_to_avg_loss_ratio;     
        static const std::string    max_closed_out_runup;           
        static const std::string    max_closed_out_rundown;         
        static const std::string    max_trade_transaction_count;    
        static const std::string    max_trade_position_size;        
        static const std::string    avg_trade_transaction_count;    
        static const std::string    avg_trade_position_size;        
        static const std::string    avg_trade_commission;           
        static const std::string    avg_trade_slippage;             
        static const std::string    avg_trade_cost;                 
        static const std::string    avg_slippage_per_unit;          
        static const std::string    avg_cost_per_unit;              
        static const std::string    percent_units_without_slippage; 
        static const std::string    avg_net_profit_per_unit;        
        static const std::string    avg_gross_profit_per_unit;      
        static const std::string    last_trade_is_open;             

        //----------------
        // equity 
        //----------------
        static const std::string    in_drawdown;                    
        static const std::string    current_drawdown;               
        static const std::string    num_drawdowns;                  
        static const std::string    max_drawdown;                   
        static const std::string    max_drawdown_length;            
        static const std::string    avg_drawdown_length;            
        static const std::string    avg_drawdown;                   
        static const std::string    max_account_balance;            
        static const std::string    min_account_balance;            

        //----------------
        // equity  (daily combo data)
        //----------------                                                              
        static const std::string    max_drawdown__eod;              
        static const std::string    max_drawdown_length__eod;       
        static const std::string    avg_drawdown_length__eod;       
        static const std::string    avg_drawdown__eod;              
        static const std::string    num_drawdowns__eod;             

        //----------------
        // Transactions
        //----------------
        static const std::string    num_transactions;               
        static const std::string    num_transactions_at_market;     
        static const std::string    num_transactions_on_stop;       
        static const std::string    num_transactions_at_limit;      
        static const std::string    avg_transaction_size;           

        //----------------
        // Units
        //----------------
        static const std::string    num_units_traded;               
        static const std::string    num_units_traded_without_slippage;
        static const std::string    num_units_traded_at_market;     
        static const std::string    num_units_traded_on_stop;       
        static const std::string    num_units_traded_at_limit;      
        static const std::string    num_units_traded_other;         // internal use

        //----------------
        // Strategy Metrics
        //----------------
    
        static const std::string    drawdown_multiplier;                 

        static const std::string    sharpe_ratio;                         
        static const std::string    sortino_ratio;                        

        static const std::string    basket_num_instruments;
        static const std::string    basket_num_strategies;
        static const std::string    basket_instrument_num_bars_processed;
        static const std::string    basket_strategy_num_bars_processed;
        static const std::string    annual_risk_free_rate_of_return;
        static const std::string    begin_timestamp;
        static const std::string    end_timestamp;
        static const std::string    total_strategy_duration;
        static const std::string    total_instrument_duration;
        static const std::string    source_name;
        static const std::string    source_is_instrument;
    };


    enum cost_alloc_type {
        per_transaction,   
        per_unit           
    };

    enum log_type_t {
        no_logs = 0X0,       
        trades = 0X2,        
        transactions = 0X4,  
        bars = 0X8,          
        orders = 0X10,       
        drawdowns = 0X20,    
        all_reports = 0X40   
    };

    log_type_t operator| (log_type_t lhs, log_type_t rhs);


    typedef int64_t quantity_t;

    typedef int64_t position_t;


    
    /*
    ** ====================================================
    ** >>>              class object                    <<<
    ** ====================================================
    */

    class object {
    public:

        object(void) { ; }

        virtual ~object(void) { ; }//retain virtual for derived rtti info
    public:

        const char* class_name(void) const;

        bool has_same_class_as(const object& other) const;
    };

    void assert_failure(const char* msg, const char* file, int line);
    void verify_failure(const char* msg, const char* file, int line);

}  // namespace tsa

#define TSA__IS_KIND_OF(class_name, pObj) ( dynamic_cast<class_name*>( pObj ) != nullptr )

#include <cassert>

namespace tsa {
    namespace unit_test {
        class DBTests;
        class CoreTests;
    }
}

#include "TSAGlobal.h"

#define tsa_declare_testable friend class tsa::unit_test::CoreTests; friend class tsa::unit_test::DBTests;

#define tsa_verify(condition) if (condition); \
else tsa::verify_failure("___failed: a(" #condition ") ", __FILE__, __LINE__)

#define tsa_throw_not_implemented tsa::assert_failure("not implemented", __FILE__, __LINE__);

#ifdef TSA_DEBUG

#define tsa_assert_kind_of(class_name, object_ptr)  \
    assert(dynamic_cast<class_name*>( object_ptr ) != nullptr)

#define tsa_assert_instance_of(class_name, object_ptr) \
    assert(( object_ptr )->IsInstanceOfClass(#class_name))

#define tsa_assert(condition) if (condition); \
else tsa::assert_failure("___failed: a(" #condition ") ", __FILE__, __LINE__)

#define tsa_fp_are_equal_3(a, b) float64_comparison(a, b, 1e-3)
#define tsa_fp_are_equal_6(a, b) float64_comparison(a, b, 1e-6)
#define tsa_fp_are_equal_9(a, b) float64_comparison(a, b, 1e-9)
#define tsa_fp_are_equal_12(a, b) float64_comparison(a, b, 1e-12)
#else
#define tsa_assert_kind_of(class_name, pObject) ((void)0)
#define tsa_assert_instance_of(class_name, object) ((void)0)
#define tsa_assert(x)  ((void)0)
#define EVAL_ASSERT(x)  ((void)0)
#define tsa_fp_are_equal_3(a, b)  ((void)0)
#define tsa_fp_are_equal_6(a, b)  ((void)0)
#define tsa_fp_are_equal_9(a, b)  ((void)0)
#endif

namespace tsa {
    
    /*
    ** ====================================================
    ** >>>         security_parser                      <<<
    ** ====================================================
    */

    //Represents a symbol.exchange combination
    class symbol_exchange_pair_parser : public tsa::object
    {
        std::string m_symbol;
        std::string m_exchange;
    public:
        symbol_exchange_pair_parser(void);
        symbol_exchange_pair_parser(const std::string&);
        ~symbol_exchange_pair_parser(void);
        void symbol(const std::string&);
        void exchange(const std::string&);
        const std::string& symbol(void)const;
        const std::string& exchange(void)const;
        operator std::string(void)const;
    };

    /*
    ** ====================================================
    ** >>>         symbol_parser                      <<<
    ** ====================================================
    */

    class symbol_parser : public tsa::object
    {
    private:
        static const std::string m_expiry_month_codes;
        static const std::vector<std::string> m_expiry_months;
        std::string m_input_string;
        std::string m_symbol;
        char m_expiry_code;
        int m_expiry_year = 0;
        int m_expiry_month = 0;
        std::string m_expiry_str;
        std::string m_expiry_str_yyyymm;
        std::string m_expiry_month_str;
        bool m_expires = false;
        bool m_is_valid = false;
        void reset(void);
    protected:
        bool parse(const std::string& symbol_str);
        bool only_last_2_char_are_digit(const std::string&)const;
        int expiry_str_to_expiry_year(const std::string&)const;
        int month_str_to_month(const std::string& month_str);
        int expiry_code_to_month(char expiry_code);
        void verify_expires(void)const;
        void verify_is_valid(void)const;
    public:
        symbol_parser(const std::string& symbol_str);

        bool expires(void)const;

        char expiry_month_code(void)const;

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

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

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

        int expiry_year(void)const;

        int expiry_month(void)const;

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

        std::string product(void)const;

        std::string db_table_name_part(void)const;
    };

    /*
    ** ====================================================
    ** >>>         exchange_parser                      <<<
    ** ====================================================
    */

    class exchange_parser : public tsa::object
    {
        std::string m_exchange;
        std::string m_ccy;
        bool m_has_ccy = false;
        void verify_exchange_valid(void)const;
    public:
        exchange_parser(const std::string& exchange_str);

        bool parse(const std::string& exchange_str);

        bool has_currency(void)const { return m_has_ccy; }

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

        const std::string& currency(void)const;
    };

    /*
    ** ====================================================
    ** >>>         bar_type                             <<<
    ** ====================================================
    */

    enum class bar_interval_type {
        undefined = 0,
        volume = 10,
        tick,
        range,
        fixed_time_bar_type_start = 100,
        millisecond,
        second,
        minute,
        //hour,
        day,
        week,
        month,
        year
    };

    bool is_fixed_time_bar_type(tsa::bar_interval_type);

    tsa::bar_interval_type string_to_bar_interval_type(const std::string&);

    std::string bar_interval_type_to_string(tsa::bar_interval_type);


    /*
    ** ====================================================
    ** >>>         bar_def_parser                      <<<
    ** ====================================================
    */

    class bar_type_parser : public tsa::object
    {
        std::string m_bar_type;
        bar_interval_type m_bar_interval_type = bar_interval_type::undefined;
        size_t m_bar_interval_size = 0;
        static std::string class_name;
    public:
        bar_type_parser(const std::string& bar_def_str);
        bool parse(const std::string& bar_def_str);
        std::string to_string(void)const;
        void interval_size(size_t sz) { m_bar_interval_size = sz; }
        void interval_type(tsa::bar_interval_type type) { m_bar_interval_type = type; }
        bool is_intraday(void)const;
        tsa::bar_interval_type interval_type(void)const { return m_bar_interval_type; }
        size_t interval_size(void)const { return m_bar_interval_size; }
    public:
        bool parse_bar_type_string(const std::string& bar_type,
            tsa::bar_interval_type& bar_interval_type, size_t& bar_interval_size);
        static std::string make_string(
            tsa::bar_interval_type bar_ival_type, size_t bar_ival_size);
    };

    /*
    ** ====================================================
    ** >>>         ticker_def                           <<<
    ** ====================================================
    */
    //Represents a 'ticker', a series of quotes from a datafeed

    class ticker_def { 
        friend class series_def;
    private:
        std::string m_type;
        std::string m_symbol;
        std::string m_exchange;
        std::string m_currency;
        std::string m_feed;
        std::string m_quote_type = "QTSTD";
    private:
        mutable std::string m_combined;
        bool make_combined(void)const;
        mutable bool m_string_rep_is_valid = false;
    public:
        ticker_def(void);
        ticker_def(const std::string& symbol,
            const std::string& exchange, const std::string& feed);
        ticker_def(const ticker_def&);
        void operator=(const ticker_def&);
        ~ticker_def(void);

        bool is_valid(void)const;
        const std::string& to_string(void)const;
        bool expires(void)const;
        void type(const std::string&);
        void symbol(const std::string&);
        std::string expiry_yyyymm(void)const;
        void exchange(const std::string&);
        void feed(const std::string&);
        void quote_type(const std::string&);
        const std::string& type(void) const;
        std::string symbol(void) const;
        std::string exchange(void) const;
        bool has_currency(void)const;
        std::string currency(void) const;
        const std::string& feed(void) const;
        const std::string& quote_type() const;
        bool operator== (const ticker_def& other) const;
        bool operator!= (const ticker_def& other) const;
    };

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

    // Represents the information required to represent a series
    // as managed by series_manager on tsa-server. 
    // It essentially combines a ticker_def with information
    // on how to aggregate bars

    class series_def : public tsa::object {
        tsa_declare_testable;
    private:
        std::string m_symbol;
        std::string m_root_symbol;
        std::string m_expiry;
        std::string m_exchange;
        std::string m_exchange_ccy;
        std::string m_feed;
        std::string m_quote_type = "QTSTD";
        std::string m_bar_type;
        bar_interval_type m_bar_interval_type = bar_interval_type::undefined;
        size_t m_bar_interval_size = 0;
    public:
        series_def(void);
        series_def(const std::string& series_def_str);
        bool operator== (const series_def&) const;
        std::string to_string(char sep = '|') const;
        std::string to_server_table_name(void)const;
        void from_string(const std::string&);
        bool is_complete(void) const;
        void bar_interval_size(size_t sz) { m_bar_interval_size = sz; }
        void bar_interval_type(tsa::bar_interval_type type) { m_bar_interval_type = type; }
        bool bar_interval_type_is_intraday(void)const;
        tsa::bar_interval_type bar_interval_type(void)const { return m_bar_interval_type; }
        size_t bar_interval_size(void)const { return m_bar_interval_size; }
        std::string expiry(void)const;
        std::string expiry_yyyymm(void)const;
        bool expires(void)const;
        std::string exchange_ccy(void)const;
        void exchange_ccy(const std::string&);
        bool exchange_has_ccy(void)const;
    public:
        void symbol(const std::string& s);
        void expiry(const std::string& s);
        void exchange(const std::string& s);
        void feed(const std::string& s);
        void quote_type(const std::string& s);
        void bar_type(const std::string& s);
    public:
        const std::string& symbol(void) const;
        const std::string& root_symbol(void) const;
        std::string exchange(void) const;
        const std::string& feed(void) const;
        const std::string& quote_type(void) const;
        std::string bar_type(void) const;
    public:
        tsa::ticker_def to_ticker_def(void)const;
    };

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

    class instrument_def : public tsa::object {
        tsa_declare_testable;
        static std::string class_name;
    private:
        std::string m_symbol;
        std::string m_exchange;
        std::string m_platform;
    public:
        instrument_def(void);
        instrument_def(const std::string& instr_def_str);
        bool operator== (const instrument_def&) const;
        std::string to_string(char sep = '|') const;
        void from_string(const std::string&);
        bool is_complete(void) const;
        std::string symbol_expiry(void)const;
        bool symbol_expires(void)const;
        std::string exchange_ccy(void)const;
        bool exchange_has_ccy(void)const;
    public:
        void symbol(const std::string&);
        void exchange(const std::string&);
        void platform(const std::string&);
    public:
        const std::string& symbol(void) const;
        std::string exchange(void) const;
        const std::string& platform(void) const;

        struct properties {
            std::string symbol;
            std::string symbol_expiry;
            std::string exchange;
            std::string exchange_ccy;
            std::string platform;
        };

        static std::string make_str(const properties&);
    };

    enum ColorCode {
        c_green,
        c_snow,
        c_snow2,
        c_snow3,
        c_snow4,
        c_ghost_white,
        c_white_smoke,
        c_gainsboro,
        c_floral_white,
        c_old_lace,
        c_linen,
        c_antique_white,
        c_antique_white_2,
        c_antique_white_3,
        c_antique_white_4,
        c_papaya_whip,
        c_blanched_almond,
        c_bisque,
        c_bisque_2,
        c_bisque_3,
        c_bisque_4,
        c_peach_puff,
        c_peach_puff_2,
        c_peach_puff_3,
        c_peach_puff_4,
        c_navajo_white,
        c_moccasin,
        c_cornsilk,
        c_cornsilk_2,
        c_cornsilk_3,
        c_cornsilk_4,
        c_ivory,
        c_ivory_2,
        c_ivory_3,
        c_ivory_4,
        c_lemon_chiffon,
        c_seashell,
        c_seashell_2,
        c_seashell_3,
        c_seashell_4,
        c_honeydew,
        c_honeydew_2,
        c_honeydew_3,
        c_honeydew_4,
        c_mint_cream,
        c_azure,
        c_alice_blue,
        c_lavender,
        c_lavender_blush,
        c_misty_rose,
        c_white,
        c_black,
        c_dark_slate_gray,
        c_dim_gray,
        c_slate_gray,
        c_light_slate_gray,
        c_gray,
        c_light_gray,
        c_midnight_blue,
        c_navy,
        c_cornflower_blue,
        c_dark_slate_blue,
        c_slate_blue,
        c_medium_slate_blue,
        c_light_slate_blue,
        c_medium_blue,
        c_royal_blue,
        c_blue,
        c_dodger_blue,
        c_deep_sky_blue,
        c_sky_blue,
        c_light_sky_blue,
        c_steel_blue,
        c_light_steel_blue,
        c_light_blue,
        c_powder_blue,
        c_pale_turquoise,
        c_dark_turquoise,
        c_medium_turquoise,
        c_turquoise,
        c_cyan,
        c_light_cyan,
        c_cadet_blue,
        c_medium_aquamarine,
        c_aquamarine,
        c_dark_green,
        c_dark_olive_green,
        c_dark_sea_green,
        c_sea_green,
        c_medium_sea_green,
        c_light_sea_green,
        c_pale_green,
        c_spring_green,
        c_lawn_green,
        c_chartreuse,
        c_medium_spring_green,
        c_green_yellow,
        c_lime_green,
        c_yellow_green,
        c_forest_green,
        c_olive_drab,
        c_dark_khaki,
        c_khaki,
        c_pale_goldenrod,
        c_light_goldenrod_yellow,
        c_light_yellow,
        c_yellow,
        c_gold,
        c_light_goldenrod,
        c_goldenrod,
        c_dark_goldenrod,
        c_rosy_brown,
        c_indian_red,
        c_saddle_brown,
        c_sienna,
        c_peru,
        c_burlywood,
        c_beige,
        c_wheat,
        c_sandy_brown,
        c_tan,
        c_chocolate,
        c_firebrick,
        c_brown,
        c_dark_salmon,
        c_salmon,
        c_light_salmon,
        c_orange,
        c_dark_orange,
        c_coral,
        c_light_coral,
        c_tomato,
        c_orange_red,
        c_red,
        c_hot_pink,
        c_deep_pink,
        c_pink,
        c_light_pink,
        c_pale_violet_red,
        c_maroon,
        c_medium_violet_red,
        c_violet_red,
        c_violet,
        c_plum,
        c_orchid,
        c_medium_orchid,
        c_dark_orchid,
        c_dark_violet,
        c_blue_violet,
        c_purple,
        c_medium_purple,
        c_thistle,
        //============
        c_auto_color
        //============
    };

    class color_id;
    class variant;

    class dll_export color : public tsa::object
    {
        friend class color_manager;
    private:
        bool m_use_default_instead;
    private:
        int m_red;    //0-255
        int m_green;  //0-255
        int m_blue;   //0-255
    public:
        int R(void)const { return m_red; }

        int G(void)const { return m_green; }

        int B(void)const { return m_blue; }

        enum use_default_t { use_default };
    public:
        color(void);
        //IU
        color(const tsa::variant&);

        explicit color(unsigned char red, unsigned char green, unsigned char blue);

        explicit color(use_default_t);

        color(const color&);

        explicit color(tsa::ColorCode);

        ~color(void);
    public:

        bool  IsValid(void)const;
        bool  UseDefaultInstead(void)const;
        int   as_int(void)const;
        int   Difference(const color&)const;
        void  Rand(void);
        color Differentiate(double dPercent)const;
        void  InitFromInt(int);
        bool  HasEqualColors(const color& _other)const;
        bool  IsEqual(const color& _other)const;

        void operator=(const color& _other);
    public:
        void CopyRGB(const color& _other);
    public:
        static const color auto_color;
        static const color green;
        static const color snow;
        static const color snow2;
        static const color snow3;
        static const color snow4;
        static const color ghost_white;
        static const color white_smoke;
        static const color gainsboro;
        static const color floral_white;
        static const color old_lace;
        static const color linen;
        static const color antique_white;
        static const color antique_white_2;
        static const color antique_white_3;
        static const color antique_white_4;
        static const color papaya_whip;
        static const color blanched_almond;
        static const color bisque;
        static const color bisque_2;
        static const color bisque_3;
        static const color bisque_4;
        static const color peach_puff;
        static const color peach_puff_2;
        static const color peach_puff_3;
        static const color peach_puff_4;
        static const color navajo_white;
        static const color moccasin;
        static const color cornsilk;
        static const color cornsilk_2;
        static const color cornsilk_3;
        static const color cornsilk_4;
        static const color ivory;
        static const color ivory_2;
        static const color ivory_3;
        static const color ivory_4;
        static const color lemon_chiffon;
        static const color seashell;
        static const color seashell_2;
        static const color seashell_3;
        static const color seashell_4;
        static const color honeydew;
        static const color honeydew_2;
        static const color honeydew_3;
        static const color honeydew_4;
        static const color mint_cream;
        static const color azure;
        static const color alice_blue;
        static const color lavender;
        static const color lavender_blush;
        static const color misty_rose;
        static const color white;
        static const color black;
        static const color dark_slate_gray;
        static const color dim_gray;
        static const color slate_gray;
        static const color light_slate_gray;
        static const color gray;
        static const color light_gray;
        static const color midnight_blue;
        static const color navy;
        static const color cornflower_blue;
        static const color dark_slate_blue;
        static const color slate_blue;
        static const color medium_slate_blue;
        static const color light_slate_blue;
        static const color medium_blue;
        static const color royal_blue;
        static const color blue;
        static const color dodger_blue;
        static const color deep_sky_blue;
        static const color sky_blue;
        static const color light_sky_blue;
        static const color steel_blue;
        static const color light_steel_blue;
        static const color light_blue;
        static const color powder_blue;
        static const color pale_turquoise;
        static const color dark_turquoise;
        static const color medium_turquoise;
        static const color turquoise;
        static const color cyan;
        static const color light_cyan;
        static const color cadet_blue;
        static const color medium_aquamarine;
        static const color aquamarine;
        static const color dark_green;
        static const color dark_olive_green;
        static const color dark_sea_green;
        static const color sea_green;
        static const color medium_sea_green;
        static const color light_sea_green;
        static const color pale_green;
        static const color spring_green;
        static const color lawn_green;
        static const color chartreuse;
        static const color medium_spring_green;
        static const color green_yellow;
        static const color lime_green;
        static const color yellow_green;
        static const color forest_green;
        static const color olive_drab;
        static const color dark_khaki;
        static const color khaki;
        static const color pale_goldenrod;
        static const color light_goldenrod_yellow;
        static const color light_yellow;
        static const color yellow;
        static const color gold;
        static const color light_goldenrod;
        static const color goldenrod;
        static const color dark_goldenrod;
        static const color rosy_brown;
        static const color indian_red;
        static const color saddle_brown;
        static const color sienna;
        static const color peru;
        static const color burlywood;
        static const color beige;
        static const color wheat;
        static const color sandy_brown;
        static const color tan;
        static const color chocolate;
        static const color firebrick;
        static const color brown;
        static const color dark_salmon;
        static const color salmon;
        static const color light_salmon;
        static const color orange;
        static const color dark_orange;
        static const color coral;
        static const color light_coral;
        static const color tomato;
        static const color orange_red;
        static const color red;
        static const color hot_pink;
        static const color deep_pink;
        static const color pink;
        static const color light_pink;
        static const color pale_violet_red;
        static const color maroon;
        static const color medium_violet_red;
        static const color violet_red;
        static const color violet;
        static const color plum;
        static const color orchid;
        static const color medium_orchid;
        static const color dark_orchid;
        static const color dark_violet;
        static const color blue_violet;
        static const color purple;
        static const color medium_purple;
        static const color thistle;
    };

} // namespace tsa


namespace std {

    //hash operator for ticker_def
    template <>
    struct hash <tsa::ticker_def> {
        std::size_t operator()(const tsa::ticker_def& td) const {
            return std::hash<std::string>()(td.to_string());
        }
    };

} //namespace std


#endif