]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | // |
2 | // use_future.hpp | |
3 | // ~~~~~~~~~~~~~~ | |
4 | // | |
5 | // Copyright (c) 2003-2016 Christopher M. Kohlhoff (chris at kohlhoff dot com) | |
6 | // | |
7 | // Distributed under the Boost Software License, Version 1.0. (See accompanying | |
8 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) | |
9 | // | |
10 | ||
11 | #ifndef BOOST_ASIO_USE_FUTURE_HPP | |
12 | #define BOOST_ASIO_USE_FUTURE_HPP | |
13 | ||
14 | #if defined(_MSC_VER) && (_MSC_VER >= 1200) | |
15 | # pragma once | |
16 | #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) | |
17 | ||
18 | #include <boost/asio/detail/config.hpp> | |
19 | #include <memory> | |
20 | ||
21 | #include <boost/asio/detail/push_options.hpp> | |
22 | ||
23 | namespace boost { | |
24 | namespace asio { | |
25 | ||
26 | /// Class used to specify that an asynchronous operation should return a future. | |
27 | /** | |
28 | * The use_future_t class is used to indicate that an asynchronous operation | |
29 | * should return a std::future object. A use_future_t object may be passed as a | |
30 | * handler to an asynchronous operation, typically using the special value @c | |
31 | * boost::asio::use_future. For example: | |
32 | * | |
33 | * @code std::future<std::size_t> my_future | |
34 | * = my_socket.async_read_some(my_buffer, boost::asio::use_future); @endcode | |
35 | * | |
36 | * The initiating function (async_read_some in the above example) returns a | |
37 | * future that will receive the result of the operation. If the operation | |
38 | * completes with an error_code indicating failure, it is converted into a | |
39 | * system_error and passed back to the caller via the future. | |
40 | */ | |
41 | template <typename Allocator = std::allocator<void> > | |
42 | class use_future_t | |
43 | { | |
44 | public: | |
45 | /// The allocator type. The allocator is used when constructing the | |
46 | /// @c std::promise object for a given asynchronous operation. | |
47 | typedef Allocator allocator_type; | |
48 | ||
49 | /// Construct using default-constructed allocator. | |
50 | BOOST_ASIO_CONSTEXPR use_future_t() | |
51 | { | |
52 | } | |
53 | ||
54 | /// Construct using specified allocator. | |
55 | explicit use_future_t(const Allocator& allocator) | |
56 | : allocator_(allocator) | |
57 | { | |
58 | } | |
59 | ||
60 | /// Specify an alternate allocator. | |
61 | template <typename OtherAllocator> | |
62 | use_future_t<OtherAllocator> operator[](const OtherAllocator& allocator) const | |
63 | { | |
64 | return use_future_t<OtherAllocator>(allocator); | |
65 | } | |
66 | ||
67 | /// Obtain allocator. | |
68 | allocator_type get_allocator() const | |
69 | { | |
70 | return allocator_; | |
71 | } | |
72 | ||
73 | private: | |
74 | Allocator allocator_; | |
75 | }; | |
76 | ||
77 | /// A special value, similar to std::nothrow. | |
78 | /** | |
79 | * See the documentation for boost::asio::use_future_t for a usage example. | |
80 | */ | |
81 | #if defined(BOOST_ASIO_HAS_CONSTEXPR) || defined(GENERATING_DOCUMENTATION) | |
82 | constexpr use_future_t<> use_future; | |
83 | #elif defined(BOOST_ASIO_MSVC) | |
84 | __declspec(selectany) use_future_t<> use_future; | |
85 | #endif | |
86 | ||
87 | } // namespace asio | |
88 | } // namespace boost | |
89 | ||
90 | #include <boost/asio/detail/pop_options.hpp> | |
91 | ||
92 | #include <boost/asio/impl/use_future.hpp> | |
93 | ||
94 | #endif // BOOST_ASIO_USE_FUTURE_HPP |