Statistics
| Revision:

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

History | View | Annotate | Download (6.2 kB)

1
//
2
// basic_io_object.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_BASIC_IO_OBJECT_HPP
12
#define BOOST_ASIO_BASIC_IO_OBJECT_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 <boost/asio/io_service.hpp>
20

    
21
#include <boost/asio/detail/push_options.hpp>
22

    
23
namespace boost {
24
namespace asio {
25

    
26
#if defined(BOOST_ASIO_HAS_MOVE)
27
namespace detail
28
{
29
  // Type trait used to determine whether a service supports move.
30
  template <typename IoObjectService>
31
  class service_has_move
32
  {
33
  private:
34
    typedef IoObjectService service_type;
35
    typedef typename service_type::implementation_type implementation_type;
36

    
37
    template <typename T, typename U>
38
    static auto eval(T* t, U* u) -> decltype(t->move_construct(*u, *u), char());
39
    static char (&eval(...))[2];
40

    
41
  public:
42
    static const bool value =
43
      sizeof(service_has_move::eval(
44
        static_cast<service_type*>(0),
45
        static_cast<implementation_type*>(0))) == 1;
46
  };
47
}
48
#endif // defined(BOOST_ASIO_HAS_MOVE)
49

    
50
/// Base class for all I/O objects.
51
/**
52
 * @note All I/O objects are non-copyable. However, when using C++0x, certain
53
 * I/O objects do support move construction and move assignment.
54
 */
55
#if !defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
56
template <typename IoObjectService>
57
#else
58
template <typename IoObjectService,
59
    bool Movable = detail::service_has_move<IoObjectService>::value>
60
#endif
61
class basic_io_object
62
{
63
public:
64
  /// The type of the service that will be used to provide I/O operations.
65
  typedef IoObjectService service_type;
66

    
67
  /// The underlying implementation type of I/O object.
68
  typedef typename service_type::implementation_type implementation_type;
69

    
70
  /// Get the io_service associated with the object.
71
  /**
72
   * This function may be used to obtain the io_service object that the I/O
73
   * object uses to dispatch handlers for asynchronous operations.
74
   *
75
   * @return A reference to the io_service object that the I/O object will use
76
   * to dispatch handlers. Ownership is not transferred to the caller.
77
   */
78
  boost::asio::io_service& get_io_service()
79
  {
80
    return service.get_io_service();
81
  }
82

    
83
protected:
84
  /// Construct a basic_io_object.
85
  /**
86
   * Performs:
87
   * @code get_service().construct(get_implementation()); @endcode
88
   */
89
  explicit basic_io_object(boost::asio::io_service& io_service)
90
    : service(boost::asio::use_service<IoObjectService>(io_service))
91
  {
92
    service.construct(implementation);
93
  }
94

    
95
#if defined(GENERATING_DOCUMENTATION)
96
  /// Move-construct a basic_io_object.
97
  /**
98
   * Performs:
99
   * @code get_service().move_construct(
100
   *     get_implementation(), other.get_implementation()); @endcode
101
   *
102
   * @note Available only for services that support movability,
103
   */
104
  basic_io_object(basic_io_object&& other);
105

    
106
  /// Move-assign a basic_io_object.
107
  /**
108
   * Performs:
109
   * @code get_service().move_assign(get_implementation(),
110
   *     other.get_service(), other.get_implementation()); @endcode
111
   *
112
   * @note Available only for services that support movability,
113
   */
114
  basic_io_object& operator=(basic_io_object&& other);
115
#endif // defined(GENERATING_DOCUMENTATION)
116

    
117
  /// Protected destructor to prevent deletion through this type.
118
  /**
119
   * Performs:
120
   * @code get_service().destroy(get_implementation()); @endcode
121
   */
122
  ~basic_io_object()
123
  {
124
    service.destroy(implementation);
125
  }
126

    
127
  /// Get the service associated with the I/O object.
128
  service_type& get_service()
129
  {
130
    return service;
131
  }
132

    
133
  /// Get the service associated with the I/O object.
134
  const service_type& get_service() const
135
  {
136
    return service;
137
  }
138

    
139
  /// (Deprecated: Use get_service().) The service associated with the I/O
140
  /// object.
141
  /**
142
   * @note Available only for services that do not support movability.
143
   */
144
  service_type& service;
145

    
146
  /// Get the underlying implementation of the I/O object.
147
  implementation_type& get_implementation()
148
  {
149
    return implementation;
150
  }
151

    
152
  /// Get the underlying implementation of the I/O object.
153
  const implementation_type& get_implementation() const
154
  {
155
    return implementation;
156
  }
157

    
158
  /// (Deprecated: Use get_implementation().) The underlying implementation of
159
  /// the I/O object.
160
  implementation_type implementation;
161

    
162
private:
163
  basic_io_object(const basic_io_object&);
164
  basic_io_object& operator=(const basic_io_object&);
165
};
166

    
167
#if defined(BOOST_ASIO_HAS_MOVE)
168
// Specialisation for movable objects.
169
template <typename IoObjectService>
170
class basic_io_object<IoObjectService, true>
171
{
172
public:
173
  typedef IoObjectService service_type;
174
  typedef typename service_type::implementation_type implementation_type;
175

    
176
  boost::asio::io_service& get_io_service()
177
  {
178
    return service_->get_io_service();
179
  }
180

    
181
protected:
182
  explicit basic_io_object(boost::asio::io_service& io_service)
183
    : service_(&boost::asio::use_service<IoObjectService>(io_service))
184
  {
185
    service_->construct(implementation);
186
  }
187

    
188
  basic_io_object(basic_io_object&& other)
189
    : service_(&other.get_service())
190
  {
191
    service_->move_construct(implementation, other.implementation);
192
  }
193

    
194
  ~basic_io_object()
195
  {
196
    service_->destroy(implementation);
197
  }
198

    
199
  basic_io_object& operator=(basic_io_object&& other)
200
  {
201
    service_->move_assign(implementation,
202
        *other.service_, other.implementation);
203
    service_ = other.service_;
204
    return *this;
205
  }
206

    
207
  service_type& get_service()
208
  {
209
    return *service_;
210
  }
211

    
212
  const service_type& get_service() const
213
  {
214
    return *service_;
215
  }
216

    
217
  implementation_type& get_implementation()
218
  {
219
    return implementation;
220
  }
221

    
222
  const implementation_type& get_implementation() const
223
  {
224
    return implementation;
225
  }
226

    
227
  implementation_type implementation;
228

    
229
private:
230
  basic_io_object(const basic_io_object&);
231
  void operator=(const basic_io_object&);
232

    
233
  IoObjectService* service_;
234
};
235
#endif // defined(BOOST_ASIO_HAS_MOVE)
236

    
237
} // namespace asio
238
} // namespace boost
239

    
240
#include <boost/asio/detail/pop_options.hpp>
241

    
242
#endif // BOOST_ASIO_BASIC_IO_OBJECT_HPP