var.hpp

// Copyright (C) Calum Grant 2008

namespace dynamic
{
        namespace internal 
        { 
                template<typename T> class var_member; 
        }


        typedef var (*f0)();
        typedef var (*f1)(var);
        typedef var (*f2)(var,var);
        typedef var (*f3)(var,var,var);
        typedef var (*f4)(var,var,var,var);
        typedef var (*f5)(var,var,var,var,var);
        typedef var (*f6)(var,var,var,var,var,var);
        typedef var (*f7)(var,var,var,var,var,var,var);
        typedef var (*f8)(var,var,var,var,var,var,var,var);
        typedef var (*f9)(var,var,var,var,var,var,var,var,var);
        typedef var (*f10)(var,var,var,var,var,var,var,var,var,var);


        typedef void (*vf0)();
        typedef void (*vf1)(var);
        typedef void (*vf2)(var,var);
        typedef void (*vf3)(var,var,var);
        typedef void (*vf4)(var,var,var,var);
        typedef void (*vf5)(var,var,var,var,var);
        typedef void (*vf6)(var,var,var,var,var,var);
        typedef void (*vf7)(var,var,var,var,var,var,var);
        typedef void (*vf8)(var,var,var,var,var,var,var,var);
        typedef void (*vf9)(var,var,var,var,var,var,var,var,var);
        typedef void (*vf10)(var,var,var,var,var,var,var,var,var,var);



        class DYNAMIC_API var : public internal::var_methods<var, const var &>
        {
        public:
                mutable var_variant m_variant;

        public:
                template<typename T>
                var(const internal::var_member<T>&);

                var();

                var(shared_var_impl * i);

                struct assign_impl { };


                template<typename T>
                var(const T & impl, assign_impl) : m_variant(impl)
                {
                }

                var(const char * str);

                var(const std::string & str);

                var(const wchar_t * str);

                var(const wstring & str);

                var(int i);

                var(double d);

                var(char ch);

                var(wchar_t wc);

                var(bool b);

                var(f0);

                var(f1);

                var(f2);

                var(f3);

                var(f4);

                var(f5);

                var(f6);

                var(f7);

                var(f8);

                var(f9);

                var(f10);

                var(vf0);

                var(vf1);

                var(vf2);

                var(vf3);

                var(vf4);

                var(vf5);

                var(vf6);

                var(vf7);

                var(vf8);

                var(vf9);

                var(vf10);

                template<std::size_t N>
                var(var(&list)[N]) : m_variant(array_it(list, list+N).m_variant)
                { }

                var(const internal::extender&);

                template<typename T>
                var & operator=(T const & t)
                {
                        *this = var(t);
                        return *this;
                }

                internal::var_member<const char*> operator[](const char * m) const;

                internal::var_member<var> operator[](const var &) const;

                internal::var_member<int> operator[](int) const;

                typedef var iterator;

                typedef var const_iterator;

                typedef std::size_t size_type;

                typedef std::ptrdiff_t difference_type;

                typedef var reverse_iterator;

                typedef var const_reverse_iterator;

                var_impl & impl() const 
                { return *m_variant; }

                const var & deref() const 
                { return *this; }


                typedef std::bidirectional_iterator_tag iterator_category;

                typedef var value_type;

                typedef var * pointer;

                typedef var & reference;

                var operator+() const 
                { return impl().op_pos(); }
                
                var operator-() const 
                { return impl().op_neg(); }
                
                var operator~() const 
                { return impl().op_inv(); }

                template<typename T> var operator+(const T&t) const
                { return impl().op_add(t); }

                template<typename T> var operator-(const T&t) const
                { return impl().op_sub(t); }

                template<typename T> var operator/(const T&t) const
                { return impl().op_div(t); }

                template<typename T> var operator%(const T&t) const
                { return impl().op_mod(t); }

                template<typename T> var operator|(const T&t) const
                { return impl().op_or(t); }

                template<typename T> var operator&(const T&t) const
                { return impl().op_and(t); }

                template<typename T> var operator^(const T&t) const
                { return impl().op_xor(t); }

                template<typename T> var operator<<(const T&t) const
                { return impl().op_lshift(t); }

                template<typename T> var operator>>(const T&t) const
                { return impl().op_rshift(t); }

                template<typename T> var & operator+=(const T&t)
                { impl().assign_add(t); return *this; }

                template<typename T> var & operator-=(const T&t)
                { impl().assign_sub(t); return *this; }

                template<typename T> var & operator*=(const T&t)
                { impl().assign_mul(t); return *this; }

                template<typename T> var & operator/=(const T&t)
                { impl().assign_div(t); return *this; }

                template<typename T> var & operator%=(const T&t)
                { impl().assign_mod(t); return *this; }

                template<typename T> var & operator<<=(const T&t)
                { impl().assign_lshift(t); return *this; }

                template<typename T> var & operator>>=(const T&t)
                { impl().assign_rshift(t); return *this; }

                template<typename T> var & operator&=(const T&t)
                { impl().assign_and(t); return *this; }

                template<typename T> var & operator|=(const T&t)
                { impl().assign_or(t); return *this; }

                template<typename T> var & operator^=(const T&t)
                { impl().assign_xor(t); return *this; }
        };


        typedef std::basic_ostream<wchar_t> wostream;
        
        DYNAMIC_API std::ostream & operator<<(std::ostream & os, var const & a);

        DYNAMIC_API wostream & operator<<(wostream & os, var const & a);


        namespace internal
        {

                class var_deref
                {
                        var m_v;
                public:
                        var_deref(const var & v) : m_v(v) 
                        { }
                        
                        var * operator->() 
                        { return &m_v; }
                };
        }
}

---