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 | // Copyright (C) 2011-2024 Internet Systems Consortium, Inc. ("ISC")
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef ASIOLINK_IO_SERVICE_H
#define ASIOLINK_IO_SERVICE_H
#include <boost/version.hpp><--- Include file: not found. Please note: Cppcheck does not need standard library headers to get proper results.
#include <boost/shared_ptr.hpp><--- Include file: not found. Please note: Cppcheck does not need standard library headers to get proper results.
#include <functional><--- Include file: not found. Please note: Cppcheck does not need standard library headers to get proper results.
#include <list><--- Include file: not found. Please note: Cppcheck does not need standard library headers to get proper results.
namespace boost {
namespace asio {
#if BOOST_VERSION < 106600
class io_service;
#else
class io_context;
typedef io_context io_service;
#endif
}
}
namespace isc {
namespace asiolink {
class IOServiceImpl;
class IOService;
/// @brief Defines a smart pointer to an IOService instance.
typedef boost::shared_ptr<IOService> IOServicePtr;
/// @brief The @ref IOService class is a wrapper for the ASIO @c io_service
/// class.
class IOService {
/// @brief Constructors and Destructor.
///
/// @note The copy constructor and the assignment operator are
/// intentionally defined as private, making this class non-copyable.
//@{
private:
IOService(const IOService& source);
IOService& operator=(const IOService& source);
public:
/// @brief The constructor.
IOService();
/// @brief The destructor.
~IOService();
//@}
/// @brief Start the underlying event loop.
///
/// This method does not return control to the caller until
/// the @ref stop() or @ref stopWork() method is called via some handler.
void run();
/// @brief Run the underlying event loop for a single event.
///
/// This method return control to the caller as soon as the
/// first handler has completed. (If no handlers are ready when
/// it is run, it will block until one is.)
///
/// @return The number of handlers that were executed.
size_t runOne();
/// @brief Run the underlying event loop for a ready events.
///
/// This method executes handlers for all ready events and returns.
/// It will return immediately if there are no ready events.
///
/// @return The number of handlers that were executed.
size_t poll();
/// @brief Run the underlying event loop for a ready events.
///
/// This method executes handlers for all ready events and returns.
/// It will return immediately if there are no ready events.
///
/// @return The number of handlers that were executed.
size_t pollOne();
/// @brief Stop the underlying event loop.
///
/// This will return the control to the caller of the @ref run() method.
void stop();
/// @brief Indicates if the IOService has been stopped.
///
/// @return true if the IOService has been stopped, false otherwise.
bool stopped() const;
/// @brief Restarts the IOService in preparation for a subsequent @ref run() invocation.
void restart();
/// @brief Removes IO service work object to let it finish running
/// when all handlers have been invoked.
void stopWork();
/// @brief Return the native @c io_service object used in this wrapper.
///
/// This is a short term work around to support other Kea modules
/// that share the same @c io_service with the authoritative server.
/// It will eventually be removed once the wrapper interface is
/// generalized.
///
/// @return The internal io_service object.
boost::asio::io_service& getInternalIOService();
/// @brief Post a callback to the end of the queue.
///
/// Requests the callback be called sometime later. It is not guaranteed
/// by the underlying asio, but it can reasonably be expected the callback
/// is put to the end of the callback queue. It is not called from within
/// this function.
///
/// It may be used to implement "background" work, for example (doing stuff
/// by small bits that are called from time to time).
void post(const std::function<void ()>& callback);
/// @brief Stop and poll to handle all registered events.
///
/// @param ignore_errors Flag which indicates if errors should be ignored.
void stopAndPoll(bool ignore_errors = true);
private:
/// @brief The implementation.
boost::shared_ptr<IOServiceImpl> io_impl_;
};
} // namespace asiolink
} // namespace isc
#endif // ASIOLINK_IO_SERVICE_H
|