variant.h

Go to the documentation of this file.

/************************************************************************************
*                                                                                   *
*   Copyright (c) 2014, 2015 - 2016 Axel Menzel <info@rttr.org>                     *
*                                                                                   *
*   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/detail/base/core_prerequisites.h"
#include "rttr/detail/misc/misc_type_traits.h"
#include "rttr/detail/variant/variant_data.h"
#include "rttr/detail/misc/argument_wrapper.h"
#include "rttr/detail/variant/variant_compare_less.h"

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

namespace rttr
{

class variant_array_view;
class type;
class variant;
class argument;
class instance;

namespace detail
{
    struct data_address_container;
    template<typename T>
    struct empty_type_converter;

    template<typename T, typename Tp, typename Converter = empty_type_converter<T>>
    struct variant_data_base_policy;
    struct variant_data_policy_nullptr_t;

    enum class variant_policy_operation : uint8_t;

    template<typename T, typename Decayed = decay_except_array_t<T>>
    using decay_variant_t = enable_if_t<!std::is_same<Decayed, variant>::value &&
                                        !std::is_same<Decayed, variant_array_view>::value, Decayed>;

    using variant_policy_func = bool (*)(variant_policy_operation, const variant_data&, argument_wrapper);
}

class RTTR_API variant
{
    public:
        RTTR_INLINE variant();

        template<typename T, typename Tp = detail::decay_variant_t<T>>
        variant(T&& val);

        variant(const variant& other);

        variant(variant&& other);

        RTTR_INLINE ~variant();

        template<typename T, typename Tp = detail::decay_variant_t<T>>
        variant& operator=(T&& other);

        variant& operator=(variant&& other);

        variant& operator=(const variant& other);

        RTTR_INLINE bool operator==(const variant& other) const;

        RTTR_INLINE bool operator!=(const variant& other) const;

        RTTR_INLINE bool operator<(const variant& other) const;

        void clear();

        void swap(variant& other);
        
        template<typename T>
        bool is_type() const;

        type get_type() const;

        bool is_valid() const;

        explicit operator bool() const;

        bool is_array() const;

        template<typename T>
        const T& get_value() 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 convert(bool* ok = nullptr) const;

        template<typename T>
        bool convert(T& value) const;

        variant_array_view create_array_view() const;

        bool to_bool() const;

        int to_int(bool *ok = nullptr) const;

        float to_float(bool* ok = nullptr) const;

        double to_double(bool* ok = nullptr) const;

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

        int8_t to_int8(bool *ok = nullptr) const;

        int16_t to_int16(bool *ok = nullptr) const;

        int32_t to_int32(bool *ok = nullptr) const;

        int64_t to_int64(bool *ok = nullptr) const;

        uint8_t to_uint8(bool *ok = nullptr) const;

        uint16_t to_uint16(bool *ok = nullptr) const;

        uint32_t to_uint32(bool *ok = nullptr) const;

        uint64_t to_uint64(bool *ok = nullptr) const;

    private:


        RTTR_INLINE void* get_ptr() const;

        RTTR_INLINE type get_raw_type() const;

        RTTR_INLINE void* get_raw_ptr() const;

        template<typename T>
        detail::enable_if_t<std::is_arithmetic<T>::value, T> convert_impl(bool* ok = nullptr) const;

        template<typename T>
        detail::enable_if_t<!std::is_arithmetic<T>::value, T> convert_impl(bool* ok = nullptr) const;

        RTTR_INLINE detail::data_address_container get_data_address_container() const;

        bool convert(const type& target_type, variant& var) const;

        template<typename T>
        bool try_basic_type_conversion(T& to) const;

        template<typename T>
        typename std::enable_if<detail::pointer_count<T>::value == 1, bool>::type
        try_pointer_conversion(T& to, const type& source_type, const type& target_type) const;

        template<typename T>
        typename std::enable_if<detail::pointer_count<T>::value != 1, bool>::type
        try_pointer_conversion(T& to, const type& source_type, const type& target_type) const;

        bool compare_equal(const variant& other) const;

        bool compare_less(const variant& other) const;

        RTTR_INLINE bool is_nullptr() const;

    private:
        friend class argument;
        friend class instance;

        template<typename T, typename Tp, typename Converter>
        friend struct detail::variant_data_base_policy;
        friend struct detail::variant_data_policy_nullptr_t;
        friend RTTR_API bool detail::variant_compare_less(const variant&, const type&, const variant&, const type&);

        detail::variant_data            m_data;
        detail::variant_policy_func     m_policy;
};


} // end namespace rttr

#include "rttr/detail/variant/variant_impl.h"

#endif // RTTR_VARIANT_H_