1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
|
/*!
@file
Forward declares `boost::hana::value`.
@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_FWD_VALUE_HPP
#define BOOST_HANA_FWD_VALUE_HPP
#include <boost/hana/config.hpp>
#include <boost/hana/core/when.hpp>
BOOST_HANA_NAMESPACE_BEGIN
//! Return the compile-time value associated to a constant.
//! @ingroup group-Constant
//!
//! This function returns the value associated to a `Constant`. That
//! value is always a constant expression. The normal way of using
//! `value` on an object `c` is
//! @code
//! constexpr auto result = hana::value<decltype(c)>();
//! @endcode
//!
//! However, for convenience, an overload of `value` is provided so that
//! it can be called as:
//! @code
//! constexpr auto result = hana::value(c);
//! @endcode
//!
//! This overload works by taking a `const&` to its argument, and then
//! forwarding to the first version of `value`. Since it does not use
//! its argument, the result can still be a constant expression, even
//! if the argument is not a constant expression.
//!
//! @note
//! `value<T>()` is tag-dispatched as `value_impl<C>::%apply<T>()`, where
//! `C` is the tag of `T`.
//!
//! @note
//! `hana::value` is an overloaded function, not a function object.
//! Hence, it can't be passed to higher-order algorithms. If you need
//! an equivalent function object, use `hana::value_of` instead.
//!
//!
//! Example
//! -------
//! @include example/value.cpp
#ifdef BOOST_HANA_DOXYGEN_INVOKED
template <typename T>
constexpr auto value = []() -> decltype(auto) {
return tag-dispatched;
};
#else
template <typename C, typename = void>
struct value_impl : value_impl<C, when<true>> { };
template <typename T>
constexpr decltype(auto) value();
template <typename T>
constexpr decltype(auto) value(T const&)
{ return hana::value<T>(); }
#endif
//! Equivalent to `value`, but can be passed to higher-order algorithms.
//! @ingroup group-Constant
//!
//! This function object is equivalent to `value`, except it can be passed
//! to higher order algorithms because it is a function object. `value`
//! can't be passed to higher-order algorithms because it is implemented
//! as an overloaded function.
//!
//! @note
//! This function is a simple alias to `value`, and hence it is not
//! tag-dispatched and can't be customized.
//!
//!
//! Example
//! -------
//! @include example/value_of.cpp
#ifdef BOOST_HANA_DOXYGEN_INVOKED
constexpr auto value_of = [](auto const& c) -> decltype(auto) {
return hana::value(c);
};
#else
struct value_of_t {
template <typename T>
constexpr decltype(auto) operator()(T const&) const
{ return hana::value<T>(); }
};
constexpr value_of_t value_of{};
#endif
BOOST_HANA_NAMESPACE_END
#endif // !BOOST_HANA_FWD_VALUE_HPP
|
