FM / detail

/usr/include/boost/hof/detail

Name	Size	Mode	Actions
and.hpp	1359	0644	edit dl rm
callable_base.hpp	1862	0644	edit dl rm
can_be_called.hpp	3001	0644	edit dl rm
compressed_pair.hpp	3678	0644	edit dl rm
constexpr_deduce.hpp	2076	0644	edit dl rm
delegate.hpp	4193	0644	edit dl rm
forward.hpp	1163	0644	edit dl rm
holder.hpp	678	0644	edit dl rm
intrinsics.hpp	4550	0644	edit dl rm
join.hpp	1221	0644	edit dl rm
make.hpp	962	0644	edit dl rm
move.hpp	689	0644	edit dl rm
noexcept.hpp	637	0644	edit dl rm
pp.hpp	3674	0644	edit dl rm
recursive_constexpr_depth.hpp	666	0644	edit dl rm
remove_rvalue_reference.hpp	756	0644	edit dl rm
result_of.hpp	2447	0644	edit dl rm
result_type.hpp	1199	0644	edit dl rm
seq.hpp	1001	0644	edit dl rm
static_const_var.hpp	2035	0644	edit dl rm
unpack_tuple.hpp	2652	0644	edit dl rm
unwrap.hpp	735	0644	edit dl rm
using.hpp	827	0644	edit dl rm

Edit: /usr/include/boost/hof/detail/unpack_tuple.hpp (2652B)

#ifndef BOOST_HOF_GUARD_UNPACK_TUPLE_HPP
#define BOOST_HOF_GUARD_UNPACK_TUPLE_HPP

#include <boost/hof/unpack_sequence.hpp>
#include <boost/hof/returns.hpp>
#include <boost/hof/detail/forward.hpp>
#include <boost/hof/detail/seq.hpp>
#include <tuple>
#include <array>

namespace boost { namespace hof {

namespace detail {

template<class Sequence>
constexpr typename gens<std::tuple_size<Sequence>::value>::type 
make_tuple_gens(const Sequence&)
{
    return {};
}

#if (defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ < 7)

template<std::size_t I, class Tuple>
struct tuple_element_return
: std::tuple_element<I, Tuple>
{};

template<std::size_t I, class Tuple>
struct tuple_element_return<I, Tuple&>
: std::add_lvalue_reference<typename tuple_element_return<I, Tuple>::type>
{};

template<std::size_t I, class Tuple>
struct tuple_element_return<I, Tuple&&>
: std::add_rvalue_reference<typename tuple_element_return<I, Tuple>::type>
{};

template<std::size_t I, class Tuple>
struct tuple_element_return<I, const Tuple>
: std::add_const<typename tuple_element_return<I, Tuple>::type>
{};

template< std::size_t I, class Tuple, class R = typename tuple_element_return<I, Tuple&&>::type >
R tuple_get( Tuple&& t ) 
{ 
    return (R&&)(std::get<I>(boost::hof::forward<Tuple>(t))); 
}
#define BOOST_HOF_UNPACK_TUPLE_GET boost::hof::detail::tuple_get
#else
#define BOOST_HOF_UNPACK_TUPLE_GET std::get

#endif

template<class F, class T, std::size_t ...N>
constexpr auto unpack_tuple(F&& f, T&& t, seq<N...>) BOOST_HOF_RETURNS
(
    f(
        BOOST_HOF_AUTO_FORWARD(BOOST_HOF_UNPACK_TUPLE_GET<N>(BOOST_HOF_AUTO_FORWARD(t)))...
    )
);

struct unpack_tuple_apply
{
    template<class F, class S>
    constexpr static auto apply(F&& f, S&& t) BOOST_HOF_RETURNS
    (
        boost::hof::detail::unpack_tuple(BOOST_HOF_FORWARD(F)(f), BOOST_HOF_FORWARD(S)(t), boost::hof::detail::make_tuple_gens(t))
    );
};

}

template<class... Ts>
struct unpack_sequence<std::tuple<Ts...>>
: detail::unpack_tuple_apply
{};

template<class T, class U>
struct unpack_sequence<std::pair<T, U>>
: detail::unpack_tuple_apply
{};

template<class T, std::size_t N>
struct unpack_sequence<std::array<T, N>>
: detail::unpack_tuple_apply
{};

}} // namespace boost::hof

#endif

/*============================================================================= Copyright (c) 2016 Paul Fultz II unpack_tuple.hpp Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) ==============================================================================*/ #ifndef BOOST_HOF_GUARD_UNPACK_TUPLE_HPP #define BOOST_HOF_GUARD_UNPACK_TUPLE_HPP #include #include #include #include #include #include namespace boost { namespace hof { namespace detail { template constexpr typename gens::value>::type make_tuple_gens(const Sequence&) { return {}; } #if (defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ < 7) template struct tuple_element_return : std::tuple_element {}; template struct tuple_element_return : std::add_lvalue_reference::type> {}; template struct tuple_element_return : std::add_rvalue_reference::type> {}; template struct tuple_element_return : std::add_const::type> {}; template< std::size_t I, class Tuple, class R = typename tuple_element_return::type > R tuple_get( Tuple&& t ) { return (R&&)(std::get(boost::hof::forward(t))); } #define BOOST_HOF_UNPACK_TUPLE_GET boost::hof::detail::tuple_get #else #define BOOST_HOF_UNPACK_TUPLE_GET std::get #endif template constexpr auto unpack_tuple(F&& f, T&& t, seq) BOOST_HOF_RETURNS ( f( BOOST_HOF_AUTO_FORWARD(BOOST_HOF_UNPACK_TUPLE_GET(BOOST_HOF_AUTO_FORWARD(t)))... ) ); struct unpack_tuple_apply { template constexpr static auto apply(F&& f, S&& t) BOOST_HOF_RETURNS ( boost::hof::detail::unpack_tuple(BOOST_HOF_FORWARD(F)(f), BOOST_HOF_FORWARD(S)(t), boost::hof::detail::make_tuple_gens(t)) ); }; } template struct unpack_sequence> : detail::unpack_tuple_apply {}; template struct unpack_sequence> : detail::unpack_tuple_apply {}; template struct unpack_sequence> : detail::unpack_tuple_apply {}; }} // namespace boost::hof #endif