var_variant.hpp

// Copyright (C) Calum Grant 2008

namespace dynamic
{
        namespace internal
        {

                template<typename Base, std::size_t Bytes>
                class DYNAMIC_API variant
                {
                        union { cg::max_aligned m_aligned; char m_data[Bytes]; };

                public:
                        Base *get() 
                        { 
                                return reinterpret_cast<Base*>(m_data); 
                        }

                        const Base * get() const 
                        { 
                                return reinterpret_cast<const Base*>(m_data); 
                        }

                        Base * operator->() 
                        { 
                                return get(); 
                        }

                        const Base * operator->() const 
                        { 
                                return get(); 
                        }

                        Base & operator*() 
                        { 
                                return *get(); 
                        }

                        const Base & operator*() const 
                        { 
                                return *get(); 
                        }


                        template<typename T>
                        variant(const T & t) 
                        {
                                cg::static_assert<sizeof(T) <= Bytes>();
                                static_cast<const Base&>(t);
                                t.copy_to(m_data);
                        }

                        ~variant()
                        {
                                get()->~Base();
                        }

                        variant(const variant & other)
                        {
                                other.get()->copy_to(get());
                        }

                        variant & operator=(const variant & other)
                        {
                                if(this != &other)
                                {
                                        get()->~Base();
                                        other.get()->copy_to(get());    // Must not throw
                                }
                                return *this;
                        }

                        template<typename T>
                        variant & operator=(const T & other)
                        {
                                cg::static_assert<sizeof(T) <= Bytes>();
                                static_cast<const Base&>(other);
                                get()->~Base();
                                other.copy_to(get());   // Must not throw
                                return *this;
                        }
                };


                class DYNAMIC_API variant_base
                {
                public:
                        virtual ~variant_base() { }

                        virtual void copy_to(void*) const=0;
                };
        }

        typedef dynamic::internal::variant<var_impl, 16> var_variant;
}

---