Statistics
| Revision:

root / tmp / org.txm.statsengine.r.core.win32 / res / win32 / library / BH / include / boost / asio / detail / signal_set_service.hpp @ 2486

History | View | Annotate | Download (6.4 kB)

1
//
2
// detail/signal_set_service.hpp
3
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4
//
5
// Copyright (c) 2003-2015 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_DETAIL_SIGNAL_SET_SERVICE_HPP
12
#define BOOST_ASIO_DETAIL_SIGNAL_SET_SERVICE_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

    
20
#include <cstddef>
21
#include <signal.h>
22
#include <boost/asio/error.hpp>
23
#include <boost/asio/io_service.hpp>
24
#include <boost/asio/detail/addressof.hpp>
25
#include <boost/asio/detail/handler_alloc_helpers.hpp>
26
#include <boost/asio/detail/op_queue.hpp>
27
#include <boost/asio/detail/signal_handler.hpp>
28
#include <boost/asio/detail/signal_op.hpp>
29
#include <boost/asio/detail/socket_types.hpp>
30

    
31
#if !defined(BOOST_ASIO_WINDOWS) && !defined(__CYGWIN__)
32
# include <boost/asio/detail/reactor.hpp>
33
#endif // !defined(BOOST_ASIO_WINDOWS) && !defined(__CYGWIN__)
34

    
35
#include <boost/asio/detail/push_options.hpp>
36

    
37
namespace boost {
38
namespace asio {
39
namespace detail {
40

    
41
#if defined(NSIG) && (NSIG > 0)
42
enum { max_signal_number = NSIG };
43
#else
44
enum { max_signal_number = 128 };
45
#endif
46

    
47
extern BOOST_ASIO_DECL struct signal_state* get_signal_state();
48

    
49
extern "C" BOOST_ASIO_DECL void boost_asio_signal_handler(int signal_number);
50

    
51
class signal_set_service
52
{
53
public:
54
  // Type used for tracking an individual signal registration.
55
  class registration
56
  {
57
  public:
58
    // Default constructor.
59
    registration()
60
      : signal_number_(0),
61
        queue_(0),
62
        undelivered_(0),
63
        next_in_table_(0),
64
        prev_in_table_(0),
65
        next_in_set_(0)
66
    {
67
    }
68

    
69
  private:
70
    // Only this service will have access to the internal values.
71
    friend class signal_set_service;
72

    
73
    // The signal number that is registered.
74
    int signal_number_;
75

    
76
    // The waiting signal handlers.
77
    op_queue<signal_op>* queue_;
78

    
79
    // The number of undelivered signals.
80
    std::size_t undelivered_;
81

    
82
    // Pointers to adjacent registrations in the registrations_ table.
83
    registration* next_in_table_;
84
    registration* prev_in_table_;
85

    
86
    // Link to next registration in the signal set.
87
    registration* next_in_set_;
88
  };
89

    
90
  // The implementation type of the signal_set.
91
  class implementation_type
92
  {
93
  public:
94
    // Default constructor.
95
    implementation_type()
96
      : signals_(0)
97
    {
98
    }
99

    
100
  private:
101
    // Only this service will have access to the internal values.
102
    friend class signal_set_service;
103

    
104
    // The pending signal handlers.
105
    op_queue<signal_op> queue_;
106

    
107
    // Linked list of registered signals.
108
    registration* signals_;
109
  };
110

    
111
  // Constructor.
112
  BOOST_ASIO_DECL signal_set_service(boost::asio::io_service& io_service);
113

    
114
  // Destructor.
115
  BOOST_ASIO_DECL ~signal_set_service();
116

    
117
  // Destroy all user-defined handler objects owned by the service.
118
  BOOST_ASIO_DECL void shutdown_service();
119

    
120
  // Perform fork-related housekeeping.
121
  BOOST_ASIO_DECL void fork_service(
122
      boost::asio::io_service::fork_event fork_ev);
123

    
124
  // Construct a new signal_set implementation.
125
  BOOST_ASIO_DECL void construct(implementation_type& impl);
126

    
127
  // Destroy a signal_set implementation.
128
  BOOST_ASIO_DECL void destroy(implementation_type& impl);
129

    
130
  // Add a signal to a signal_set.
131
  BOOST_ASIO_DECL boost::system::error_code add(implementation_type& impl,
132
      int signal_number, boost::system::error_code& ec);
133

    
134
  // Remove a signal to a signal_set.
135
  BOOST_ASIO_DECL boost::system::error_code remove(implementation_type& impl,
136
      int signal_number, boost::system::error_code& ec);
137

    
138
  // Remove all signals from a signal_set.
139
  BOOST_ASIO_DECL boost::system::error_code clear(implementation_type& impl,
140
      boost::system::error_code& ec);
141

    
142
  // Cancel all operations associated with the signal set.
143
  BOOST_ASIO_DECL boost::system::error_code cancel(implementation_type& impl,
144
      boost::system::error_code& ec);
145

    
146
  // Start an asynchronous operation to wait for a signal to be delivered.
147
  template <typename Handler>
148
  void async_wait(implementation_type& impl, Handler& handler)
149
  {
150
    // Allocate and construct an operation to wrap the handler.
151
    typedef signal_handler<Handler> op;
152
    typename op::ptr p = { boost::asio::detail::addressof(handler),
153
      boost_asio_handler_alloc_helpers::allocate(
154
        sizeof(op), handler), 0 };
155
    p.p = new (p.v) op(handler);
156

    
157
    BOOST_ASIO_HANDLER_CREATION((p.p, "signal_set", &impl, "async_wait"));
158

    
159
    start_wait_op(impl, p.p);
160
    p.v = p.p = 0;
161
  }
162

    
163
  // Deliver notification that a particular signal occurred.
164
  BOOST_ASIO_DECL static void deliver_signal(int signal_number);
165

    
166
private:
167
  // Helper function to add a service to the global signal state.
168
  BOOST_ASIO_DECL static void add_service(signal_set_service* service);
169

    
170
  // Helper function to remove a service from the global signal state.
171
  BOOST_ASIO_DECL static void remove_service(signal_set_service* service);
172

    
173
  // Helper function to create the pipe descriptors.
174
  BOOST_ASIO_DECL static void open_descriptors();
175

    
176
  // Helper function to close the pipe descriptors.
177
  BOOST_ASIO_DECL static void close_descriptors();
178

    
179
  // Helper function to start a wait operation.
180
  BOOST_ASIO_DECL void start_wait_op(implementation_type& impl, signal_op* op);
181

    
182
  // The io_service instance used for dispatching handlers.
183
  io_service_impl& io_service_;
184

    
185
#if !defined(BOOST_ASIO_WINDOWS) \
186
  && !defined(BOOST_ASIO_WINDOWS_RUNTIME) \
187
  && !defined(__CYGWIN__)
188
  // The type used for registering for pipe reactor notifications.
189
  class pipe_read_op;
190

    
191
  // The reactor used for waiting for pipe readiness.
192
  reactor& reactor_;
193

    
194
  // The per-descriptor reactor data used for the pipe.
195
  reactor::per_descriptor_data reactor_data_;
196
#endif // !defined(BOOST_ASIO_WINDOWS)
197
       //   && !defined(BOOST_ASIO_WINDOWS_RUNTIME)
198
       //   && !defined(__CYGWIN__)
199

    
200
  // A mapping from signal number to the registered signal sets.
201
  registration* registrations_[max_signal_number];
202

    
203
  // Pointers to adjacent services in linked list.
204
  signal_set_service* next_;
205
  signal_set_service* prev_;
206
};
207

    
208
} // namespace detail
209
} // namespace asio
210
} // namespace boost
211

    
212
#include <boost/asio/detail/pop_options.hpp>
213

    
214
#if defined(BOOST_ASIO_HEADER_ONLY)
215
# include <boost/asio/detail/impl/signal_set_service.ipp>
216
#endif // defined(BOOST_ASIO_HEADER_ONLY)
217

    
218
#endif // BOOST_ASIO_DETAIL_SIGNAL_SET_SERVICE_HPP