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
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
|
//
// windows/basic_object_handle.hpp
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com)
// Copyright (c) 2011 Boris Schaeling (boris@highscore.de)
//
// 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_ASIO_WINDOWS_BASIC_OBJECT_HANDLE_HPP
#define BOOST_ASIO_WINDOWS_BASIC_OBJECT_HANDLE_HPP
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
# pragma once
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
#include <boost/asio/detail/config.hpp>
#if defined(BOOST_ASIO_HAS_WINDOWS_OBJECT_HANDLE) \
|| defined(GENERATING_DOCUMENTATION)
#include <boost/asio/detail/throw_error.hpp>
#include <boost/asio/error.hpp>
#include <boost/asio/windows/basic_handle.hpp>
#include <boost/asio/windows/object_handle_service.hpp>
#include <boost/asio/detail/push_options.hpp>
namespace boost {
namespace asio {
namespace windows {
/// Provides object-oriented handle functionality.
/**
* The windows::basic_object_handle class template provides asynchronous and
* blocking object-oriented handle functionality.
*
* @par Thread Safety
* @e Distinct @e objects: Safe.@n
* @e Shared @e objects: Unsafe.
*/
template <typename ObjectHandleService = object_handle_service>
class basic_object_handle
: public basic_handle<ObjectHandleService>
{
public:
/// The native representation of a handle.
typedef typename ObjectHandleService::native_handle_type native_handle_type;
/// Construct a basic_object_handle without opening it.
/**
* This constructor creates an object handle without opening it.
*
* @param io_service The io_service object that the object handle will use to
* dispatch handlers for any asynchronous operations performed on the handle.
*/
explicit basic_object_handle(boost::asio::io_service& io_service)
: basic_handle<ObjectHandleService>(io_service)
{
}
/// Construct a basic_object_handle on an existing native handle.
/**
* This constructor creates an object handle object to hold an existing native
* handle.
*
* @param io_service The io_service object that the object handle will use to
* dispatch handlers for any asynchronous operations performed on the handle.
*
* @param native_handle The new underlying handle implementation.
*
* @throws boost::system::system_error Thrown on failure.
*/
basic_object_handle(boost::asio::io_service& io_service,
const native_handle_type& native_handle)
: basic_handle<ObjectHandleService>(io_service, native_handle)
{
}
#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
/// Move-construct a basic_object_handle from another.
/**
* This constructor moves an object handle from one object to another.
*
* @param other The other basic_object_handle object from which the move will
* occur.
*
* @note Following the move, the moved-from object is in the same state as if
* constructed using the @c basic_object_handle(io_service&) constructor.
*/
basic_object_handle(basic_object_handle&& other)
: basic_handle<ObjectHandleService>(
BOOST_ASIO_MOVE_CAST(basic_object_handle)(other))
{
}
/// Move-assign a basic_object_handle from another.
/**
* This assignment operator moves an object handle from one object to another.
*
* @param other The other basic_object_handle object from which the move will
* occur.
*
* @note Following the move, the moved-from object is in the same state as if
* constructed using the @c basic_object_handle(io_service&) constructor.
*/
basic_object_handle& operator=(basic_object_handle&& other)
{
basic_handle<ObjectHandleService>::operator=(
BOOST_ASIO_MOVE_CAST(basic_object_handle)(other));
return *this;
}
#endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
/// Perform a blocking wait on the object handle.
/**
* This function is used to wait for the object handle to be set to the
* signalled state. This function blocks and does not return until the object
* handle has been set to the signalled state.
*
* @throws boost::system::system_error Thrown on failure.
*/
void wait()
{
boost::system::error_code ec;
this->get_service().wait(this->get_implementation(), ec);
boost::asio::detail::throw_error(ec, "wait");
}
/// Perform a blocking wait on the object handle.
/**
* This function is used to wait for the object handle to be set to the
* signalled state. This function blocks and does not return until the object
* handle has been set to the signalled state.
*
* @param ec Set to indicate what error occurred, if any.
*/
void wait(boost::system::error_code& ec)
{
this->get_service().wait(this->get_implementation(), ec);
}
/// Start an asynchronous wait on the object handle.
/**
* This function is be used to initiate an asynchronous wait against the
* object handle. It always returns immediately.
*
* @param handler The handler to be called when the object handle is set to
* the signalled state. Copies will be made of the handler as required. The
* function signature of the handler must be:
* @code void handler(
* const boost::system::error_code& error // Result of operation.
* ); @endcode
* Regardless of whether the asynchronous operation completes immediately or
* not, the handler will not be invoked from within this function. Invocation
* of the handler will be performed in a manner equivalent to using
* boost::asio::io_service::post().
*/
template <typename WaitHandler>
BOOST_ASIO_INITFN_RESULT_TYPE(WaitHandler,
void (boost::system::error_code))
async_wait(BOOST_ASIO_MOVE_ARG(WaitHandler) handler)
{
return this->get_service().async_wait(this->get_implementation(),
BOOST_ASIO_MOVE_CAST(WaitHandler)(handler));
}
};
} // namespace windows
} // namespace asio
} // namespace boost
#include <boost/asio/detail/pop_options.hpp>
#endif // defined(BOOST_ASIO_HAS_WINDOWS_OBJECT_HANDLE)
// || defined(GENERATING_DOCUMENTATION)
#endif // BOOST_ASIO_WINDOWS_BASIC_OBJECT_HANDLE_HPP
|
Swift