mirror/utils/some_type.hpp

Go to the documentation of this file.

#ifndef MIRROR_UTILS_SOME_TYPE_1113061708_HPP
#define MIRROR_UTILS_SOME_TYPE_1113061708_HPP

#include <mirror/config.hpp>
#include <boost/any.hpp>
#include <type_traits>
#include <stdexcept>

MIRROR_NAMESPACE_BEGIN


class some
{
private:
    boost::any val_or_ptr;

    boost::any (*copier)(const boost::any&);

    template <typename T>
    static boost::any copy_or_throw(const boost::any& a, std::true_type)
    {
        return boost::any(*boost::any_cast<T*>(a));
    }

    static void do_throw(void)
    {
        throw std::runtime_error("some: Unable to copy stored value");
    }

    template <typename T>
    static boost::any copy_or_throw(const boost::any& a, std::false_type)
    {
        do_throw();
        return boost::any();
    }

    template <typename T>
    static boost::any do_copy(const boost::any& pointer)
    {
        return copy_or_throw<T>(
            pointer,
            typename mirror::is_copy_constructible<T>::type()
        );
    }

    bool const_;
    bool by_ptr;

    bool is_sane(void) const
    {
        return empty() || !by_ptr || (copier != nullptr);
    }

    void do_detach(void)
    {
        assert(copier != nullptr);
        val_or_ptr = copier(val_or_ptr);
        copier = nullptr;
        const_ = false;
        by_ptr = false;
        assert(is_sane());
    }

    some(const boost::any& a)
     : val_or_ptr(a)
     , copier(nullptr)
     , const_(false)
     , by_ptr(false)
    {
        assert(is_sane());
    }
public:

    some(void)
     : copier(nullptr)
     , const_(false)
     , by_ptr(false)
    {
        assert(is_sane());
    }


    template <typename T>
    some(T value, std::false_type = std::false_type())
     : val_or_ptr(value)
     , copier(nullptr)
     , const_(std::is_const<T>::value)
     , by_ptr(false)
    {
        assert(is_sane());
    }


    template <typename T>
    some(T& inst, std::true_type by_ptr)
     : val_or_ptr(&const_cast<typename std::remove_cv<T>::type&>(inst))
     , copier(&do_copy<typename std::remove_cv<T>::type>)
     , const_(false)
     , by_ptr(true)
    {
        assert(is_sane());
    }


    template <typename T>
    some(const T& inst, std::true_type by_ptr)
     : val_or_ptr(&const_cast<typename std::remove_cv<T>::type&>(inst))
     , copier(&do_copy<typename std::remove_cv<T>::type>)
     , const_(true)
     , by_ptr(true)
    {
        assert(is_sane());
    }

#ifdef MIRROR_DOCUMENTATION_ONLY


    bool empty(void) const;
#else
    inline auto empty(void) const ->
    decltype(val_or_ptr.empty())
    {
        return val_or_ptr.empty();
    }
#endif


    inline bool standalone(void) const
    {
        return !by_ptr;
    }


    inline some& detach(void)
    {
        if(by_ptr && !empty()) do_detach();
        return *this;
    }


    inline bool is_const(void) const
    {
        return const_;
    }


    inline bool is_reference(void) const
    {
        return by_ptr && !const_;
    }


    inline bool is_value(void) const
    {
        return !empty() && !is_reference();
    }


    template <typename T>
    inline bool is(void) const
    {
        return  val_or_ptr.type() == typeid(T*) ||
            val_or_ptr.type() == typeid(T);
    }

#ifdef MIRROR_DOCUMENTATION_ONLY


    template <typename T>
    friend T-or-T& some_cast(some& s);
#else
    template <typename T>
    friend typename std::remove_volatile<
        typename std::remove_reference<T>::type
    >::type& some_cast(some& s)
    {
        assert(!s.val_or_ptr.empty());
        assert(s.is_sane());
        typedef typename std::remove_volatile<
            typename std::remove_reference<T>::type
        >::type type;
        typedef typename std::remove_const<type>::type type_;
        bool const_ok = !s.const_ || std::is_const<type>::value;
        if(s.val_or_ptr.type() == typeid(type_*) && const_ok)
            return *boost::any_cast<type_*>(s.val_or_ptr);
        else return boost::any_cast<type&>(s.val_or_ptr);
    }
#endif

#ifdef MIRROR_DOCUMENTATION_ONLY


    template <typename T>
    friend T some_cast(const some& s);
#else
    template <typename T>
    friend const typename std::remove_cv<
        typename std::remove_reference<T>::type
    >::type& some_cast(const some& s)
    {
        assert(!s.val_or_ptr.empty());
        assert(s.is_sane());
        typedef typename std::remove_cv<
            typename std::remove_reference<T>::type
        >::type type;
        if(s.val_or_ptr.type() == typeid(type*))
            return *boost::any_cast<type*>(s.val_or_ptr);
        else return boost::any_cast<const type&>(s.val_or_ptr);
    }
#endif

#ifdef MIRROR_DOCUMENTATION_ONLY


    template <typename T>
    T as(const some& s) const;
#else
    template <typename T>
    inline const typename std::remove_cv<
        typename std::remove_reference<T>::type
    >::type& as(void) const
    {
        return some_cast<const T>(*this);
    }
#endif
};

template <typename T>
some some_ref(T& ref)
{
    return some(ref, std::true_type());
}

MIRROR_NAMESPACE_END

#endif //include guard