variant.h

#pragma once
 
#include "operators.h"
#include <vector>
#include <map>
 
#include "lib_begin.h"
 
namespace cgv {
    namespace ppp {
 
        class ph_processor;
        struct namespace_info;
 
        enum ValueType {
            UNDEF_VALUE, BOOL_VALUE, INT_VALUE, DOUBLE_VALUE, STRING_VALUE,
            REFERENCE_VALUE, NAME_VALUE, LIST_VALUE, MAP_VALUE, FUNC_VALUE
        };
 
        struct func_type
        {
            unsigned block_begin;
            unsigned block_end;
            ph_processor* ph_proc;
            namespace_info* ns;
            func_type(unsigned _i, unsigned _j, ph_processor* _ph_proc = 0, namespace_info* _ns = 0);
        };
 
        class CGV_API variant
        {
        public:
            typedef std::vector<variant> list_type;
            typedef std::map<std::string, variant> map_type;
        protected:
            ValueType vt;
            union {
                bool bool_value;
                int int_value;
                double dbl_value;
                std::string* string_value;
                variant* reference_value;
                std::string* name_value;
                list_type* list_value;
                map_type* map_value;
                func_type* func_value;
            };
        public:
            variant();
            variant(const variant& v);
            variant(bool v);
            variant(int v);
            variant(double v);
            variant(const std::string& v);
            variant(variant* v);
            variant(ValueType vt, const std::string& v);
            variant(const list_type& v);
            variant(const map_type& v);
            variant(const func_type& v);
            void clear();
            variant& operator = (const variant& v);
            ~variant();
 
            bool is_unary_applicable(OperatorType ot);
            bool unary_check_defined(OperatorType ot);
            void apply_unary(OperatorType ot);
            bool is_binary_applicable(OperatorType ot, const variant& v2);
            bool binary_check_defined(OperatorType ot, const variant& v2);
            void apply_binary(OperatorType ot, const variant& v2);
 
            ValueType get_type() const;
            ValueType get_value_type() const;
            bool      is_undefined() const;
            bool      is_int() const;
            bool      is_double() const;
            bool      is_bool() const;
            bool      is_str() const;
            bool      is_list() const;
            bool      is_map() const;
            bool      is_func() const;
            bool      is_reference() const;
            bool      is_name() const;
 
            bool        get_bool() const;
            int         get_int() const;
            double      get_double() const;
            std::string get_str() const;
            const list_type& get_list() const;
            const map_type& get_map() const;
            void ensure_int_type();
            bool match_number_type(const variant& v2);
 
            bool&   ref_bool();
            int&    ref_int();
            double& ref_double();
            std::string& ref_str();
            list_type& ref_list();
            map_type& ref_map();
            func_type& ref_func();
 
            void set_bool(bool v);
            void set_int(int v);
            void set_double(double v);
            void set_str(const std::string& v);
            void set_name(const std::string& n);
            void set_list();
            void set_list(const std::vector<variant>& l);
            void set_map();
            void set_map(const std::map<std::string, variant>& m);
 
            const variant&     get_value() const;
            variant&           ref_value();
            variant*           get_reference() const;
            const std::string& get_name() const;
 
            unsigned int get_size() const;
            unsigned get_total_nr_elements() const;
            variant& ref_element(unsigned int i);
            const variant& get_element(unsigned int i) const;
 
            void append_to_list(const variant& v);
            void prepend_to_list(const variant& v);
            void pop_back_from_list();
            void pop_front_from_list();
 
            variant& ref_element(const std::string& name);
            const variant& get_element(const std::string& name);
            const std::string& get_element_name(unsigned int i) const;
            void insert(const std::string& name, const variant& v);
        };
 
        extern CGV_API std::ostream& operator << (std::ostream& os, const variant& v);
 
    }
}
#include <cgv/config/lib_end.h>