1/*!
2@file
3Defines `boost::hana::overload`.
4
5Copyright Louis Dionne 2013-2022
6Distributed under the Boost Software License, Version 1.0.
7(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
8 */
9
10#ifndef BOOST_HANA_FUNCTIONAL_OVERLOAD_HPP
11#define BOOST_HANA_FUNCTIONAL_OVERLOAD_HPP
12
13#include <boost/hana/config.hpp>
14#include <boost/hana/detail/decay.hpp>
15
16
17namespace boost { namespace hana {
18 //! @ingroup group-functional
19 //! Pick one of several functions to call based on overload resolution.
20 //!
21 //! Specifically, `overload(f1, f2, ..., fn)` is a function object such
22 //! that
23 //! @code
24 //! overload(f1, f2, ..., fn)(x...) == fk(x...)
25 //! @endcode
26 //!
27 //! where `fk` is the function of `f1, ..., fn` that would be called if
28 //! overload resolution was performed amongst that set of functions only.
29 //! If more than one function `fk` would be picked by overload resolution,
30 //! then the call is ambiguous.
31 //!
32 //! ### Example
33 //! @include example/functional/overload.cpp
34#ifdef BOOST_HANA_DOXYGEN_INVOKED
35 constexpr auto overload = [](auto&& f1, auto&& f2, ..., auto&& fn) {
36 return [perfect-capture](auto&& ...x) -> decltype(auto) {
37 return forwarded(fk)(forwarded(x)...);
38 };
39 };
40#else
41 template <typename F, typename ...G>
42 struct overload_t
43 : overload_t<F>::type
44 , overload_t<G...>::type
45 {
46 using type = overload_t;
47 using overload_t<F>::type::operator();
48 using overload_t<G...>::type::operator();
49
50 template <typename F_, typename ...G_>
51 constexpr explicit overload_t(F_&& f, G_&& ...g)
52 : overload_t<F>::type(static_cast<F_&&>(f))
53 , overload_t<G...>::type(static_cast<G_&&>(g)...)
54 { }
55 };
56
57 template <typename F>
58 struct overload_t<F> { using type = F; };
59
60 template <typename R, typename ...Args>
61 struct overload_t<R(*)(Args...)> {
62 using type = overload_t;
63 R (*fptr_)(Args...);
64
65 explicit constexpr overload_t(R (*fp)(Args...))
66 : fptr_(fp)
67 { }
68
69 constexpr R operator()(Args ...args) const
70 { return fptr_(static_cast<Args&&>(args)...); }
71 };
72
73 struct make_overload_t {
74 template <typename ...F,
75 typename Overload = typename overload_t<
76 typename detail::decay<F>::type...
77 >::type
78 >
79 constexpr Overload operator()(F&& ...f) const {
80 return Overload(static_cast<F&&>(f)...);
81 }
82 };
83
84 BOOST_HANA_INLINE_VARIABLE constexpr make_overload_t overload{};
85#endif
86}} // end namespace boost::hana
87
88#endif // !BOOST_HANA_FUNCTIONAL_OVERLOAD_HPP
89

source code of boost/libs/hana/include/boost/hana/functional/overload.hpp