FM / core

/usr/include/boost/hana/core

Name	Size	Mode	Actions
common.hpp	3477	0644	edit dl rm
default.hpp	767	0644	edit dl rm
dispatch.hpp	520	0644	edit dl rm
is_a.hpp	1135	0644	edit dl rm
make.hpp	1350	0644	edit dl rm
tag_of.hpp	1389	0644	edit dl rm
to.hpp	8156	0644	edit dl rm
when.hpp	391	0644	edit dl rm

Edit: /usr/include/boost/hana/core/to.hpp (8156B)

/*!
@file
Defines `boost::hana::to` and related utilities.

@copyright Louis Dionne 2013-2017
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
 */

#ifndef BOOST_HANA_CORE_TO_HPP
#define BOOST_HANA_CORE_TO_HPP

#include <boost/hana/fwd/core/to.hpp>

#include <boost/hana/concept/constant.hpp>
#include <boost/hana/concept/foldable.hpp>
#include <boost/hana/concept/sequence.hpp>
#include <boost/hana/config.hpp>
#include <boost/hana/core/common.hpp>
#include <boost/hana/core/dispatch.hpp>
#include <boost/hana/core/make.hpp>
#include <boost/hana/detail/wrong.hpp>
#include <boost/hana/unpack.hpp>
#include <boost/hana/value.hpp>

#include <type_traits>
#include <utility>

BOOST_HANA_NAMESPACE_BEGIN
    //////////////////////////////////////////////////////////////////////////
    // to
    //////////////////////////////////////////////////////////////////////////
    //! @cond
    template <typename To, typename From, typename>
    struct to_impl : to_impl<To, From, when<true>> { };
    //! @endcond

namespace convert_detail {
        struct no_conversion { };

template <typename To, typename From, typename = void>
        struct maybe_static_cast : no_conversion {
            template <typename X>
            static constexpr auto apply(X const&) {
                static_assert(detail::wrong<to_impl<To, From>, X>{},
                "no conversion is available between the provided types");
            }
        };

template <typename To, typename From>
        struct maybe_static_cast<To, From, decltype((void)
            static_cast<To>(std::declval<From>())
        )> {
            template <typename X>
            static constexpr To apply(X&& x)
            { return static_cast<To>(static_cast<X&&>(x)); }
        };
    } // end namespace convert_detail

template <typename To, typename From, bool condition>
    struct to_impl<To, From, when<condition>>
        : convert_detail::maybe_static_cast<To, From>
    { };

template <typename To>
    struct to_impl<To, To> : embedding<> {
        template <typename X>
        static constexpr X apply(X&& x)
        { return static_cast<X&&>(x); }
    };

//! @cond
    template <typename To>
    template <typename X>
    constexpr decltype(auto) to_t<To>::operator()(X&& x) const {
        using From = typename hana::tag_of<X>::type;
        return to_impl<To, From>::apply(static_cast<X&&>(x));
    }
    //! @endcond

#define BOOST_HANA_DEFINE_EMBEDDING_IMPL(TO, FROM)                          \
    template <>                                                             \
    struct to_impl<TO, FROM> : embedding<>                                  \
    { static constexpr TO apply(FROM x) { return x; } }                     \
/**/
    BOOST_HANA_DEFINE_EMBEDDING_IMPL(long double, double);
    BOOST_HANA_DEFINE_EMBEDDING_IMPL(long double, float);
    BOOST_HANA_DEFINE_EMBEDDING_IMPL(double     , float);

BOOST_HANA_DEFINE_EMBEDDING_IMPL(signed long long, signed long);
    BOOST_HANA_DEFINE_EMBEDDING_IMPL(signed long long, signed int);
    BOOST_HANA_DEFINE_EMBEDDING_IMPL(signed long long, signed short);
    BOOST_HANA_DEFINE_EMBEDDING_IMPL(signed long long, signed char);
    BOOST_HANA_DEFINE_EMBEDDING_IMPL(signed long     , signed int);
    BOOST_HANA_DEFINE_EMBEDDING_IMPL(signed long     , signed short);
    BOOST_HANA_DEFINE_EMBEDDING_IMPL(signed long     , signed char);
    BOOST_HANA_DEFINE_EMBEDDING_IMPL(signed int      , signed short);
    BOOST_HANA_DEFINE_EMBEDDING_IMPL(signed int      , signed char);
    BOOST_HANA_DEFINE_EMBEDDING_IMPL(signed short    , signed char);

BOOST_HANA_DEFINE_EMBEDDING_IMPL(unsigned long long, unsigned long);
    BOOST_HANA_DEFINE_EMBEDDING_IMPL(unsigned long long, unsigned int);
    BOOST_HANA_DEFINE_EMBEDDING_IMPL(unsigned long long, unsigned short);
    BOOST_HANA_DEFINE_EMBEDDING_IMPL(unsigned long long, unsigned char);
    BOOST_HANA_DEFINE_EMBEDDING_IMPL(unsigned long     , unsigned int);
    BOOST_HANA_DEFINE_EMBEDDING_IMPL(unsigned long     , unsigned short);
    BOOST_HANA_DEFINE_EMBEDDING_IMPL(unsigned long     , unsigned char);
    BOOST_HANA_DEFINE_EMBEDDING_IMPL(unsigned int      , unsigned short);
    BOOST_HANA_DEFINE_EMBEDDING_IMPL(unsigned int      , unsigned char);
    BOOST_HANA_DEFINE_EMBEDDING_IMPL(unsigned short    , unsigned char);
#undef BOOST_HANA_DEFINE_EMBEDDING_IMPL

namespace detail {
        template <typename T>
        struct copy_char_signedness {
            using type = typename std::conditional<std::is_signed<char>::value,
                std::make_signed<T>, std::make_unsigned<T>
            >::type::type;
        };
    }

// If `char` is signed, we define an embedding from `char` to any signed
    // integral type. Otherwise, we define one from `char` to any unsigned
    // integral type.
#define BOOST_HANA_DEFINE_CHAR_EMBEDDING_IMPL(TO)                           \
    template <>                                                             \
    struct to_impl<detail::copy_char_signedness<TO>::type, char>            \
        : embedding<>                                                       \
    {                                                                       \
        static constexpr detail::copy_char_signedness<TO>::type             \
        apply(char x)                                                       \
        { return x; }                                                       \
    }                                                                       \
/**/
    BOOST_HANA_DEFINE_CHAR_EMBEDDING_IMPL(long long);
    BOOST_HANA_DEFINE_CHAR_EMBEDDING_IMPL(long);
    BOOST_HANA_DEFINE_CHAR_EMBEDDING_IMPL(int);
    BOOST_HANA_DEFINE_CHAR_EMBEDDING_IMPL(short);
#undef BOOST_HANA_DEFINE_CHAR_EMBEDDING_IMPL

template <typename T>
    struct to_impl<T*, decltype(nullptr)> : embedding<> {
        static constexpr T* apply(decltype(nullptr)) { return nullptr; }
    };

//////////////////////////////////////////////////////////////////////////
    // is_convertible
    //////////////////////////////////////////////////////////////////////////
    template <typename From, typename To, typename>
    struct is_convertible : std::true_type { };

template <typename From, typename To>
    struct is_convertible<From, To, decltype((void)
        static_cast<convert_detail::no_conversion>(*(to_impl<To, From>*)0)
    )> : std::false_type { };

//////////////////////////////////////////////////////////////////////////
    // is_embedded
    //////////////////////////////////////////////////////////////////////////
    template <typename From, typename To, typename>
    struct is_embedded : std::false_type { };

template <typename From, typename To>
    struct is_embedded<From, To, decltype((void)
        static_cast<embedding<true>>(*(to_impl<To, From>*)0)
    )> : std::true_type { };

//////////////////////////////////////////////////////////////////////////
    // Conversion for Constants
    //////////////////////////////////////////////////////////////////////////
    template <typename To, typename From>
    struct to_impl<To, From, when<
        hana::Constant<From>::value &&
        is_convertible<typename From::value_type, To>::value
    >> : embedding<is_embedded<typename From::value_type, To>::value> {
        template <typename X>
        static constexpr decltype(auto) apply(X const&)
        { return hana::to<To>(hana::value<X>()); }
    };

//////////////////////////////////////////////////////////////////////////
    // Foldable -> Sequence
    //////////////////////////////////////////////////////////////////////////
    template <typename S, typename F>
    struct to_impl<S, F, when<
        hana::Sequence<S>::value &&
        hana::Foldable<F>::value
    >> : embedding<Sequence<F>::value> {
        template <typename Xs>
        static constexpr decltype(auto) apply(Xs&& xs)
        { return hana::unpack(static_cast<Xs&&>(xs), hana::make<S>); }
    };
BOOST_HANA_NAMESPACE_END

#endif // !BOOST_HANA_CORE_TO_HPP

/*! @file Defines `boost::hana::to` and related utilities. @copyright Louis Dionne 2013-2017 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_HANA_CORE_TO_HPP #define BOOST_HANA_CORE_TO_HPP #include #include #include #include #include #include #include #include #include #include #include #include #include BOOST_HANA_NAMESPACE_BEGIN ////////////////////////////////////////////////////////////////////////// // to ////////////////////////////////////////////////////////////////////////// //! @cond template struct to_impl : to_impl> { }; //! @endcond namespace convert_detail { struct no_conversion { }; template struct maybe_static_cast : no_conversion { template static constexpr auto apply(X const&) { static_assert(detail::wrong, X>{}, "no conversion is available between the provided types"); } }; template struct maybe_static_cast(std::declval()) )> { template static constexpr To apply(X&& x) { return static_cast(static_cast(x)); } }; } // end namespace convert_detail template struct to_impl> : convert_detail::maybe_static_cast { }; template struct to_impl : embedding<> { template static constexpr X apply(X&& x) { return static_cast(x); } }; //! @cond template template constexpr decltype(auto) to_t::operator()(X&& x) const { using From = typename hana::tag_of::type; return to_impl::apply(static_cast(x)); } //! @endcond #define BOOST_HANA_DEFINE_EMBEDDING_IMPL(TO, FROM) \ template <> \ struct to_impl : embedding<> \ { static constexpr TO apply(FROM x) { return x; } } \ /**/ BOOST_HANA_DEFINE_EMBEDDING_IMPL(long double, double); BOOST_HANA_DEFINE_EMBEDDING_IMPL(long double, float); BOOST_HANA_DEFINE_EMBEDDING_IMPL(double , float); BOOST_HANA_DEFINE_EMBEDDING_IMPL(signed long long, signed long); BOOST_HANA_DEFINE_EMBEDDING_IMPL(signed long long, signed int); BOOST_HANA_DEFINE_EMBEDDING_IMPL(signed long long, signed short); BOOST_HANA_DEFINE_EMBEDDING_IMPL(signed long long, signed char); BOOST_HANA_DEFINE_EMBEDDING_IMPL(signed long , signed int); BOOST_HANA_DEFINE_EMBEDDING_IMPL(signed long , signed short); BOOST_HANA_DEFINE_EMBEDDING_IMPL(signed long , signed char); BOOST_HANA_DEFINE_EMBEDDING_IMPL(signed int , signed short); BOOST_HANA_DEFINE_EMBEDDING_IMPL(signed int , signed char); BOOST_HANA_DEFINE_EMBEDDING_IMPL(signed short , signed char); BOOST_HANA_DEFINE_EMBEDDING_IMPL(unsigned long long, unsigned long); BOOST_HANA_DEFINE_EMBEDDING_IMPL(unsigned long long, unsigned int); BOOST_HANA_DEFINE_EMBEDDING_IMPL(unsigned long long, unsigned short); BOOST_HANA_DEFINE_EMBEDDING_IMPL(unsigned long long, unsigned char); BOOST_HANA_DEFINE_EMBEDDING_IMPL(unsigned long , unsigned int); BOOST_HANA_DEFINE_EMBEDDING_IMPL(unsigned long , unsigned short); BOOST_HANA_DEFINE_EMBEDDING_IMPL(unsigned long , unsigned char); BOOST_HANA_DEFINE_EMBEDDING_IMPL(unsigned int , unsigned short); BOOST_HANA_DEFINE_EMBEDDING_IMPL(unsigned int , unsigned char); BOOST_HANA_DEFINE_EMBEDDING_IMPL(unsigned short , unsigned char); #undef BOOST_HANA_DEFINE_EMBEDDING_IMPL namespace detail { template struct copy_char_signedness { using type = typename std::conditional::value, std::make_signed, std::make_unsigned >::type::type; }; } // If `char` is signed, we define an embedding from `char` to any signed // integral type. Otherwise, we define one from `char` to any unsigned // integral type. #define BOOST_HANA_DEFINE_CHAR_EMBEDDING_IMPL(TO) \ template <> \ struct to_impl::type, char> \ : embedding<> \ { \ static constexpr detail::copy_char_signedness::type \ apply(char x) \ { return x; } \ } \ /**/ BOOST_HANA_DEFINE_CHAR_EMBEDDING_IMPL(long long); BOOST_HANA_DEFINE_CHAR_EMBEDDING_IMPL(long); BOOST_HANA_DEFINE_CHAR_EMBEDDING_IMPL(int); BOOST_HANA_DEFINE_CHAR_EMBEDDING_IMPL(short); #undef BOOST_HANA_DEFINE_CHAR_EMBEDDING_IMPL template struct to_impl : embedding<> { static constexpr T* apply(decltype(nullptr)) { return nullptr; } }; ////////////////////////////////////////////////////////////////////////// // is_convertible ////////////////////////////////////////////////////////////////////////// template struct is_convertible : std::true_type { }; template struct is_convertible(*(to_impl*)0) )> : std::false_type { }; ////////////////////////////////////////////////////////////////////////// // is_embedded ////////////////////////////////////////////////////////////////////////// template struct is_embedded : std::false_type { }; template struct is_embedded>(*(to_impl*)0) )> : std::true_type { }; ////////////////////////////////////////////////////////////////////////// // Conversion for Constants ////////////////////////////////////////////////////////////////////////// template struct to_impl::value && is_convertible::value >> : embedding::value> { template static constexpr decltype(auto) apply(X const&) { return hana::to(hana::value()); } }; ////////////////////////////////////////////////////////////////////////// // Foldable -> Sequence ////////////////////////////////////////////////////////////////////////// template struct to_impl::value && hana::Foldable::value >> : embedding::value> { template static constexpr decltype(auto) apply(Xs&& xs) { return hana::unpack(static_cast(xs), hana::make~~); } }; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_CORE_TO_HPP~~