variant.h

Go to the documentation of this file.

/************************************************************************************
*                                                                                   *
*   Copyright (c) 2014 Axel Menzel <info@axelmenzel.de>                             *
*                                                                                   *
*   This file is part of RTTR (Run Time Type Reflection)                            *
*   License: MIT License                                                            *
*                                                                                   *
*   Permission is hereby granted, free of charge, to any person obtaining           *
*   a copy of this software and associated documentation files (the "Software"),    *
*   to deal in the Software without restriction, including without limitation       *
*   the rights to use, copy, modify, merge, publish, distribute, sublicense,        *
*   and/or sell copies of the Software, and to permit persons to whom the           *
*   Software is furnished to do so, subject to the following conditions:            *
*                                                                                   *
*   The above copyright notice and this permission notice shall be included in      *
*   all copies or substantial portions of the Software.                             *
*                                                                                   *
*   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR      *
*   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,        *
*   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE     *
*   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER          *
*   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,   *
*   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE   *
*   SOFTWARE.                                                                       *
*                                                                                   *
*************************************************************************************/

#ifndef __RTTR_VARIANT_H__
#define __RTTR_VARIANT_H__

#include "rttr/base/core_prerequisites.h"
#include "rttr/type.h"

#include <type_traits>
#include <cstddef>
#include <algorithm>

namespace rttr
{

class variant_array;

namespace detail
{
    RTTR_LOCAL variant create_void_variant();
    class argument;
    class instance;
    class array_container_base;
}

class RTTR_API variant
{
    public:
        variant();
       
        template<typename T>
        variant(const T& param);

        template<typename T>
        variant(T&& param 
#ifndef DOXYGEN
                , typename std::enable_if<!std::is_same<variant&, T>::value >::type* = 0
                , typename std::enable_if<!std::is_const<T>::value >::type* = 0
#endif
                );

        variant(const variant& other);

        variant(variant&& other);

        ~variant();

        void swap(variant& other);

        template<typename T>
        variant& operator=(T&& other);
       
        variant& operator=(variant&& other);

        variant& operator=(const variant& other);
        
        template<typename T>
        bool is_type() const;

        type get_type() const;

        bool is_valid() const;

        template<typename T>
        bool can_convert() const;

        bool can_convert(const type& target_type) const;

        bool convert(const type& target_type);

        template<typename T>
        T& get_value() const;


         template<typename T>
         T convert(bool* ok = nullptr) const;

        int to_int(bool *ok = nullptr) const;

        std::string to_string(bool *ok = nullptr) const;

        bool to_bool() const;

        float to_float(bool* ok = nullptr);

        double to_double(bool* ok = nullptr);

        variant_array to_array() const;


    private:
        template<typename T, typename SourceType>
        static T get_value_with_default_value(const SourceType& source, T default_value, bool* ok);

        void* get_ptr() const;

        void* get_raw_ptr() const;

        type get_raw_type() const;

        class variant_container_base
        {
            public:
                virtual ~variant_container_base();

                virtual type get_type() const = 0;
                
                virtual void* get_ptr() const = 0;

                virtual type get_raw_type() const = 0;
                
                virtual void* get_raw_ptr() const = 0;

                virtual bool is_array() const = 0;

                virtual detail::array_container_base* to_array() const = 0;

                virtual std::string to_string(bool* ok) const = 0;
                virtual int to_int(bool* ok) const = 0;
                virtual bool to_bool(bool* ok) const = 0;
                virtual float to_float(bool* ok) const = 0;
                virtual double to_double(bool* ok) const = 0;

                std::size_t to_size_t(bool* ok) const;

                virtual variant_container_base* clone() const = 0;

                virtual bool can_convert(const type& target_type) const = 0;
        };

        template<typename T, typename Enable = void>
        class variant_container : public variant_container_base
        {
            public:
                variant_container(const T& arg);

                variant_container(T&& arg);

                variant_container_base* clone() const;

                type get_type() const;

                void* get_ptr() const;

                type get_raw_type() const;
                
                void* get_raw_ptr() const;

                bool is_array() const;

                detail::array_container_base* to_array() const;
                
                bool can_convert(const type& target_type) const;

                std::string to_string(bool* ok) const;
                int to_int(bool* ok) const;
                bool to_bool(bool* ok) const;
                float to_float(bool* ok) const;
                double to_double(bool* ok) const;

                T _value; // the stored data

            private: // unimplemented
                variant_container & operator=(const variant_container &);
        };

        template<typename T>
        class variant_container<T, typename std::enable_if<detail::is_array_and_not_one_dim_char_array<T>::value>::type> : public variant_container_base
        {
            public:
                variant_container(const T& arg);

                variant_container_base* clone() const;

                type get_type() const;

                void* get_ptr() const;

                type get_raw_type() const;
                
                void* get_raw_ptr() const;

                bool can_convert(const type& target_type) const;

                bool is_array() const;

                detail::array_container_base* to_array() const;

                std::string to_string(bool* ok) const;
                int to_int(bool* ok) const;
                bool to_bool(bool* ok) const;
                float to_float(bool* ok) const;
                double to_double(bool* ok) const;

                T _value; // the stored data

            private: // unimplemented
                variant_container & operator=(const variant_container &);
        };

        template<std::size_t N>
        class variant_container<char[N]> : public variant_container_base
        {
            public:
                variant_container(const char (&arg)[N]);

                variant_container_base* clone() const;

                type get_type() const;

                void* get_ptr() const;

                type get_raw_type() const;
                
                void* get_raw_ptr() const;

                bool can_convert(const type& target_type) const;

                bool is_array() const;

                detail::array_container_base* to_array() const;

                std::string to_string(bool* ok) const;
                int to_int(bool* ok) const;
                bool to_bool(bool* ok) const;
                float to_float(bool* ok) const;
                double to_double(bool* ok) const;

                char _value[N]; // the stored data

            private: // unimplemented
                variant_container & operator=(const variant_container &);
        };

    private:
        friend variant detail::create_void_variant();
        friend detail::argument;
        friend detail::instance;
        variant_container_base*         _holder;
};

#ifndef DOXYGEN
template<> RTTR_API std::string variant::convert<std::string>(bool* ok) const;
template<> RTTR_API int variant::convert<int>(bool* ok) const;
template<> RTTR_API bool variant::convert<bool>(bool* ok) const;
template<> RTTR_API float variant::convert<float>(bool* ok) const;
template<> RTTR_API double variant::convert<double>(bool* ok) const;
template<> RTTR_API variant_array variant::convert<variant_array>(bool* ok) const;

template<> RTTR_API bool variant::can_convert<variant_array>() const;
#endif

namespace detail
{
    RTTR_API extern variant void_variant;
} // end namespace impl

} // end namespace rttr

#include "rttr/impl/variant_impl.h"
#include "rttr/impl/variant_default_types_impl.h"

#endif // __RTTR_VARIANT_H__