TSAVariant.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_VARIANT__INCLUDED
#define TSA_VARIANT__INCLUDED

#include "TSATypeDef.h"
#include "TSATime.h"

#include <string>
#include <ostream>
#include <vector>

namespace tsa {
    class out_storage_stream;
    class in_storage_stream;
    class object;
    class string;

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

    class dll_export variant {
        tsa_declare_testable;
        static const unsigned SIZE_OF_LARGEST_TYPE;
        friend class variant_series;
    public:
        //IU
        static const char* class_name;
    private:
        union Data {
            bool          boolean;
            float         float32;
            unsigned      uint32;
            int           int32;
            int64_t       int64;
            double        float64;
            void*         void_ptr;
            tsa::object*  object_ptr;
            std::string*  string_ptr;
            date_time::bin_rep datetime;
        } m_data;
        char m_time_zone_half_hour_offset;
        unsigned char m_type;
        bool m_is_owner;
        bool m_is_null;
    public:
        //===================================
        //===================================

        variant(void);

        explicit variant(type_t type);
        variant(const variant& other);

        variant(const date_time& val);

        variant(const date& val);

        variant(double val);

        variant(int val);

        variant(int64_t val);

        variant(uint64_t val);

        variant(bool val);

        variant(unsigned val);

        variant(float val);

        variant(const tsa::string& val);

        variant(const std::string& val);

        variant(const char* val);

        variant(char val);

        // Deprecated. Type member is initialized to type_t::object_ptr and value to @a val. Does NOT assume ownership of the pointer.
        variant(const object* val);

        variant(const void* val);

        ~variant(void);

        //====================
        //====================
    public:
        
        void write_state(out_storage_stream&) const; //soon to be obsolete
        void read_state(in_storage_stream&);

        void write(std::ostream&) const;
        void read(std::istream&);

        template<class Archive>
        void save(Archive & ar) const
        {
            type_t t = type();
            ar(m_type);
            bool is_def = defined();
            ar(is_def);

            if (!defined()) {
                return;
            }

            if (is_ptr_type(t)) {
                if (t == type_t::string) {
                    ar(*(m_data.string_ptr));
                }
                else throw tsa::exception("cannot serialize variant with pointer sub-type; save(Archive&).");
                return;
            }

            tsa_assert(defined());
            ar.saveBinary((const char*)(this), sizeof(variant));
        }

        template<class Archive>
        void load(Archive & ar)
        {
            unsigned char tp;
            ar(tp);
            bool is_def;
            ar(is_def);

            if (!is_def) {
                reset_to_type((tsa::type_t)tp);
                tsa_assert(!defined());
                return;
            }
            tsa_assert(is_def);
            if ((type_t)tp == type_t::string)
            {
                std::string str;
                ar(str);
                *this = str;
            }
            else {
                ar.loadBinary((char*)(this), sizeof(variant));
                tsa_assert(defined());
                tsa_assert(type() == (tsa::type_t)tp);
            }
        }
    public:
        type_t type(void) const;

        bool is_numeric(void) const;

        bool defined(void) const;

        void clear(void);

        bool is_equal(const variant& other) const;

        bool operator==(const variant& other) const;
    private:
        bool not_defined(void) const;
        void set_null(void);
        void unset_null(void);
    public:
        void set_defined(bool);
        void reset_to_type(type_t type);
        void set_data_to_zero(void);

        bool is_owner(void) const;
    public:
        //===================================
        //===================================
        const variant& operator= (const variant& other);

        const variant& operator= (unsigned val);

        const variant& operator= (const date_time& val);

        const variant& operator= (const date& val);

        const variant& operator= (int val);

        const variant& operator= (int64_t val);

        const variant& operator= (uint64_t val);

        const variant& operator= (bool val);

        const variant& operator= (float val);

        const variant& operator= (double val);

        const variant& operator= (void* val);

        const variant& operator= (const char* val);

        // deprecated. Assignment operator. Type is set to type_t::string.
        const variant& operator= (const tsa::string& val);

        const variant& operator= (const std::string& val);

    public:
        // deprecated
        void assign__no_type_chg(object* val);

        void assign__no_type_chg(float value);

        void assign__no_type_chg(double value);

        void assign__no_type_chg(unsigned value);

        void assign__no_type_chg(int value);

        void assign__no_type_chg(int64_t value);

        void assign__no_type_chg(unsigned long int value);

        void assign__no_type_chg(bool value);

        void assign__no_type_chg(const variant& other);

        void assign__no_type_chg(void* value);

        void assign__no_type_chg(const tsa::string& val);

        void assign__no_type_chg(const std::string& val);

        void assign__no_type_chg(const char* val);

        void assign__no_type_chg(const date_time& val);

        void assign__no_type_chg(const date& val);

        //====================
        //====================
    public:
        const variant& operator= (object* val);
    private:
        void raise_nil(void) const;
        void raise_cast_error(type_t, type_t) const;
        void raise_type_error(type_t, type_t) const;
    public:
        double      to_double(void) const;

        date_time   to_datetime(void) const;

        date        to_date(void) const;

        float       to_float(void) const;

        unsigned    to_uint(void) const;

        int         to_int(void) const;

        int64_t to_int64(void) const;

        bool to_bool(void) const;

        //deprecated
        object* to_object_ptr(void) const;

        void* to_void_ptr(void) const;
    public:
        std::string& get_string_ref(void)const;

        std::string& str(void)const;
    public:
        std::string to_string(void) const;

        template<typename T> T to(void) const;
    public:
        //===================================
        //===================================

        template<typename T> T get(void) const;

        explicit operator float(void) const;

        explicit operator unsigned(void) const;

        explicit operator double(void) const;

        explicit operator int(void) const;

        explicit operator int64_t (void) const;

        // @brief Identical to to_float().
        explicit operator uint64_t (void) const;

        explicit operator bool(void) const;

        explicit operator void* (void) const;

        //====================
        //====================
        explicit operator object* (void) const;
    public:
        std::string to_storage_string(void) const;
        void from_storage_string(type_t type, const std::string& data);
    public:
        static char to_type_char(type_t);
        static type_t type_char_to_type(char);
        std::string to_typed_storage_string(void) const;
        void from_typed_storage_string(const std::string& data);
    public:
        static const std::string visual_rep_of_undefined;
        static const std::string string_placeholder_for_undefined;
        static tsa::string truncate_zeros_from_float(const tsa::string&);
    };

    //specializations of 'get' template function
    template<> double variant::get<double>(void) const;
    template<> float variant::get<float>(void) const;
    template<> int variant::get<int>(void) const;
    template<> int64_t variant::get<int64_t>(void) const;
    template<> uint64_t variant::get<uint64_t>(void) const;
    template<> unsigned variant::get<unsigned>(void) const;
    template<> bool variant::get<bool>(void) const;
    template<> date variant::get<date>(void) const;
    template<> date_time variant::get<date_time>(void) const;
    template<> tsa::string variant::get<string>(void) const;
    template<> std::string variant::get<std::string>(void) const;
    template<> tsa::object* variant::get<tsa::object*>(void) const;
    template<> void* variant::get<void*>(void) const;

    //specializations of 'to' template function
    template<> double variant::to<double>(void) const;
    template<> float variant::to<float>(void) const;
    template<> int variant::to<int>(void) const;
    template<> int64_t variant::to<int64_t>(void) const;
    template<> uint64_t variant::to<uint64_t>(void) const;
    template<> unsigned variant::to<unsigned>(void) const;
    template<> bool variant::to<bool>(void) const;
    template<> date variant::to<date>(void) const;
    template<> date_time variant::to<date_time>(void) const;
    template<> std::string variant::to<std::string>(void) const;
    template<> tsa::object* variant::to<tsa::object*>(void) const;
    template<> void* variant::to<void*>(void) const;

    std::ostream& operator<< (std::ostream& stream, const variant& var);

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

    class auto_cast_variant : public variant
    {
    public:
        auto_cast_variant(const variant& other) : variant(other) {}

        auto_cast_variant(const date_time& val) : variant(val) {}

        auto_cast_variant(const date& val) : variant(val) {}

        auto_cast_variant(double val) : variant(val) {}

        auto_cast_variant(int val) : variant(val) {}

        auto_cast_variant(int64_t val) : variant(val) {}

        auto_cast_variant(uint64_t val) : variant(val) {}

        auto_cast_variant(bool val) : variant(val) {}

        auto_cast_variant(unsigned val) : variant(val) {}

        auto_cast_variant(float val) : variant(val) {}

        auto_cast_variant(const tsa::string& val) : variant(val) {}

        auto_cast_variant(const std::string& val) : variant(val) {}

        auto_cast_variant(const char* val) : variant(val) {}

        auto_cast_variant(char val) : variant(val) {}
    public:
        operator float(void) const { return to<float>(); }

        operator unsigned(void) const { return to<unsigned>(); }

        operator double(void) const { return to<double>(); }

        operator int(void) const { return to<int>(); }

        operator int64_t (void) const { return to<int64_t>(); }

        // @brief Identical to to_float().
        operator uint64_t (void) const { return to<uint64_t>(); }

        operator bool(void) const { return to<bool>(); }

        operator date (void) const { return to<date>(); }

        operator date_time(void) const { return to<date_time>(); }

        operator std::string(void) const { return to<std::string>(); }
    };


    

    class variant_vector : public std::vector<variant>{
        static std::string class_name;
    public:
        variant_vector(void);
        ~variant_vector(void);
        const variant& operator[](size_t)const;
         variant& operator[](size_t);
        std::string to_string(void)const;
        void from_string(const std::string&);
        bool is_equal(const variant_vector&)const;
    };


}//tsa

#endif