Ignore:
Timestamp:
Apr 22, 2008, 8:29:12 PM (10 years ago)
Author:
Eric Niebler
Message:

Merged revisions 44678-44679,44681-44689,44691-44692,44694,44697-44699,44704-44707,44711,44715,44717-44719,44722 via svnmerge from
https://svn.boost.org/svn/boost/trunk

........

r44678 | chris_kohlhoff | 2008-04-20 22:43:42 -0700 (Sun, 20 Apr 2008) | 3 lines


Add porthopper example to demonstrate applications that mix synchronous and
asynchronous operations.

........

r44679 | chris_kohlhoff | 2008-04-20 22:52:20 -0700 (Sun, 20 Apr 2008) | 3 lines


Remove a local variable that was hiding the ec parameter and preventing
error codes from being correctly propagated. Fixes #1820.

........

r44681 | chris_kohlhoff | 2008-04-20 23:14:29 -0700 (Sun, 20 Apr 2008) | 2 lines


Ensure all non-friend related functions are included in the documentation.

........

r44682 | chris_kohlhoff | 2008-04-20 23:15:17 -0700 (Sun, 20 Apr 2008) | 3 lines


Add UNIX domain sockets, POSIX stream-oriented descriptors and Windows
stream-oriented handles to the reference documentation.

........

r44683 | chris_kohlhoff | 2008-04-20 23:15:50 -0700 (Sun, 20 Apr 2008) | 2 lines


Regenerate documentation.

........

r44684 | chris_kohlhoff | 2008-04-20 23:20:32 -0700 (Sun, 20 Apr 2008) | 3 lines


Add documentation on the limits of the number of buffers that may be
transferred in individual operations.

........

r44685 | chris_kohlhoff | 2008-04-21 00:59:21 -0700 (Mon, 21 Apr 2008) | 3 lines


Add requirements for handle and descriptor services. Add new classes to the
quickref index page.

........

r44686 | jhunold | 2008-04-21 01:07:55 -0700 (Mon, 21 Apr 2008) | 2 lines


Remove trailing comma at end of enumerator list (gcc 4.x -pedantic error)

........

r44687 | johnmaddock | 2008-04-21 01:46:18 -0700 (Mon, 21 Apr 2008) | 1 line


Oops fix typo.

........

r44688 | johnmaddock | 2008-04-21 01:47:04 -0700 (Mon, 21 Apr 2008) | 1 line


Fix msvc warnings using new warning suppression header.

........

r44689 | johnmaddock | 2008-04-21 02:19:30 -0700 (Mon, 21 Apr 2008) | 1 line


Added new macro BOOST_NO_TEMPLATED_IOSTREAMS in response to issue #1765.

........

r44691 | speedsnail | 2008-04-21 04:46:03 -0700 (Mon, 21 Apr 2008) | 1 line


removed act-as-jamfile, which gives errors when boost.use-project is not invoked from Jamroot file.

........

r44692 | johnmaddock | 2008-04-21 05:06:02 -0700 (Mon, 21 Apr 2008) | 2 lines


Changed macro BOOST_PARTIAL_SPECIALIZATION_EXPLICIT_ARGS to BOOST_NO_PARTIAL_SPECIALIZATION_DEFAULT_ARGS.
Changed <utility> to <boost/config/no_tr1/utility.hpp> in order to prevent cyclic dependencies between Fusion Tuples and TR1.

........

r44694 | johnmaddock | 2008-04-21 06:00:16 -0700 (Mon, 21 Apr 2008) | 2 lines


Merged changes from the Sandbox, and rebuilt the docs.
Also added some missing files.

........

r44697 | danieljames | 2008-04-21 08:55:40 -0700 (Mon, 21 Apr 2008) | 1 line


Factor out the code for choosing the bucket count, and which bucket that hash values map to make it easier to experiment with alternative policies.

........

r44698 | anthonyw | 2008-04-21 09:20:31 -0700 (Mon, 21 Apr 2008) | 1 line


added private copy assignment operator and copy constructor to remove warnings

........

r44699 | anthonyw | 2008-04-21 09:22:16 -0700 (Mon, 21 Apr 2008) | 1 line


Revamped condition variable to try and fix swallowed-notify problems (trac issue #1834)

........

r44704 | pdimov | 2008-04-21 14:29:28 -0700 (Mon, 21 Apr 2008) | 1 line


Add ref_fn_test.cpp per #1846.

........

r44705 | pdimov | 2008-04-21 14:42:29 -0700 (Mon, 21 Apr 2008) | 1 line


Fix #1846.

........

r44706 | emildotchevski | 2008-04-21 15:42:54 -0700 (Mon, 21 Apr 2008) | 1 line


Fixed MSVC-specific compile errors when /Za command-line option is used, due to lack of throw() in std::~exception().

........

r44707 | pdimov | 2008-04-21 16:01:51 -0700 (Mon, 21 Apr 2008) | 1 line


Honor BOOST_NO_TEMPLATED_IOSTREAMS.

........

r44711 | daniel_frey | 2008-04-21 23:31:32 -0700 (Mon, 21 Apr 2008) | 1 line


Avoid unneccessary increment/decrement of reference count

........

r44715 | johnmaddock | 2008-04-22 01:34:43 -0700 (Tue, 22 Apr 2008) | 1 line


Added new files.

........

r44717 | dgregor | 2008-04-22 05:24:25 -0700 (Tue, 22 Apr 2008) | 1 line


Resource-constrained shortest paths, from Michael Drexl

........

r44718 | hkaiser | 2008-04-22 07:13:58 -0700 (Tue, 22 Apr 2008) | 2 lines


Spirit: Started to add '#include <boost/config/warning_disable.hpp>' to tests and examples.

........

r44719 | hkaiser | 2008-04-22 08:10:52 -0700 (Tue, 22 Apr 2008) | 1 line


Spirit.Support: Minor change

........

r44722 | hkaiser | 2008-04-22 10:23:21 -0700 (Tue, 22 Apr 2008) | 1 line


Wave: fixed #1843

........

Location:
branches/proto/v4
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • branches/proto/v4

  • branches/proto/v4/libs/asio/doc/reference.qbk

    r43473 r44725  
    2020[include requirements/ConvertibleToMutableBuffer.qbk]
    2121[include requirements/DatagramSocketService.qbk]
     22[include requirements/DescriptorService.qbk]
    2223[include requirements/Endpoint.qbk]
    2324[include requirements/GettableSocketOption.qbk]
    2425[include requirements/Handler.qbk]
     26[include requirements/HandleService.qbk]
    2527[include requirements/InternetProtocol.qbk]
    2628[include requirements/IoControlCommand.qbk]
     
    3537[include requirements/SocketAcceptorService.qbk]
    3638[include requirements/SocketService.qbk]
     39[include requirements/StreamDescriptorService.qbk]
     40[include requirements/StreamHandleService.qbk]
    3741[include requirements/StreamSocketService.qbk]
    3842[include requirements/SyncReadStream.qbk]
     
    14961500]
    14971501
     1502[heading Protected Data Members]
     1503[table
     1504  [[Name][Description]]
     1505
     1506  [
     1507    [[link boost_asio.reference.basic_datagram_socket.implementation [*implementation]]]
     1508    [The underlying implementation of the I/O object. ]
     1509  ]
     1510
     1511  [
     1512    [[link boost_asio.reference.basic_datagram_socket.service [*service]]]
     1513    [The service associated with the I/O object. ]
     1514  ]
     1515
     1516]
     1517
    14981518The basic_datagram_socket class template provides asynchronous and blocking datagram-oriented socket functionality.
    14991519
     
    32083228
    32093229
     3230[section:implementation basic_datagram_socket::implementation]
     3231
     3232
     3233['Inherited from basic_io_object.]
     3234
     3235The underlying implementation of the I/O object.
     3236
     3237  implementation_type implementation;
     3238
     3239
     3240
     3241[endsect]
     3242
     3243
     3244
    32103245[section:implementation_type basic_datagram_socket::implementation_type]
    32113246
     
    38633898]
    38643899
     3900[heading Protected Member Functions]
     3901[table
     3902  [[Name][Description]]
     3903
     3904  [
     3905    [[link boost_asio.reference.basic_socket._basic_socket [*~basic_socket]]]
     3906    [Protected destructor to prevent deletion through this type. ]
     3907  ]
     3908 
     3909]
     3910
    38653911[heading Data Members]
    38663912[table
     
    38853931    [[link boost_asio.reference.basic_socket.message_peek [*message_peek]]]
    38863932    [Peek at incoming data without removing it from the input queue. ]
     3933  ]
     3934
     3935]
     3936
     3937[heading Protected Data Members]
     3938[table
     3939  [[Name][Description]]
     3940
     3941  [
     3942    [[link boost_asio.reference.basic_socket.implementation [*implementation]]]
     3943    [The underlying implementation of the I/O object. ]
     3944  ]
     3945
     3946  [
     3947    [[link boost_asio.reference.basic_socket.service [*service]]]
     3948    [The service associated with the I/O object. ]
    38873949  ]
    38883950
     
    51645226
    51655227[endsect]
     5228
     5229
     5230[section:service basic_datagram_socket::service]
     5231
     5232
     5233['Inherited from basic_io_object.]
     5234
     5235The service associated with the I/O object.
     5236
     5237  service_type & service;
     5238
     5239
     5240
     5241[endsect]
     5242
    51665243
    51675244
     
    55385615  ]
    55395616 
     5617]
     5618
     5619[heading Protected Data Members]
     5620[table
     5621  [[Name][Description]]
     5622
     5623  [
     5624    [[link boost_asio.reference.basic_deadline_timer.implementation [*implementation]]]
     5625    [The underlying implementation of the I/O object. ]
     5626  ]
     5627
     5628  [
     5629    [[link boost_asio.reference.basic_deadline_timer.service [*service]]]
     5630    [The service associated with the I/O object. ]
     5631  ]
     5632
    55405633]
    55415634
     
    60826175
    60836176
     6177[section:implementation basic_deadline_timer::implementation]
     6178
     6179
     6180['Inherited from basic_io_object.]
     6181
     6182The underlying implementation of the I/O object.
     6183
     6184  implementation_type implementation;
     6185
     6186
     6187
     6188[endsect]
     6189
     6190
     6191
    60846192[section:implementation_type basic_deadline_timer::implementation_type]
    60856193
     
    61146222     
    61156223A reference to the io_service object that the I/O object will use to dispatch handlers. Ownership is not transferred to the caller.
     6224
     6225
     6226
     6227[endsect]
     6228
     6229
     6230
     6231[section:service basic_deadline_timer::service]
     6232
     6233
     6234['Inherited from basic_io_object.]
     6235
     6236The service associated with the I/O object.
     6237
     6238  service_type & service;
    61166239
    61176240
     
    62736396]
    62746397
     6398[heading Protected Member Functions]
     6399[table
     6400  [[Name][Description]]
     6401
     6402  [
     6403    [[link boost_asio.reference.basic_io_object.basic_io_object [*basic_io_object]]]
     6404    [Construct a basic_io_object. ]
     6405  ]
     6406 
     6407  [
     6408    [[link boost_asio.reference.basic_io_object._basic_io_object [*~basic_io_object]]]
     6409    [Protected destructor to prevent deletion through this type. ]
     6410  ]
     6411 
     6412]
     6413
     6414[heading Protected Data Members]
     6415[table
     6416  [[Name][Description]]
     6417
     6418  [
     6419    [[link boost_asio.reference.basic_io_object.implementation [*implementation]]]
     6420    [The underlying implementation of the I/O object. ]
     6421  ]
     6422
     6423  [
     6424    [[link boost_asio.reference.basic_io_object.service [*service]]]
     6425    [The service associated with the I/O object. ]
     6426  ]
     6427
     6428]
     6429
     6430
     6431[section:basic_io_object basic_io_object::basic_io_object]
     6432
     6433Construct a basic_io_object.
     6434
     6435  basic_io_object(
     6436      boost::asio::io_service & io_service);
     6437
     6438
     6439Performs:
     6440
     6441   service.construct(implementation);
     6442
     6443
     6444
     6445
     6446
     6447[endsect]
     6448
     6449
    62756450
    62766451[section:get_io_service basic_io_object::get_io_service]
     
    62946469
    62956470
     6471[section:implementation basic_io_object::implementation]
     6472
     6473The underlying implementation of the I/O object.
     6474
     6475  implementation_type implementation;
     6476
     6477
     6478
     6479[endsect]
     6480
     6481
     6482
    62966483[section:implementation_type basic_io_object::implementation_type]
    62976484
     
    63276514
    63286515
     6516[section:service basic_io_object::service]
     6517
     6518The service associated with the I/O object.
     6519
     6520  service_type & service;
     6521
     6522
     6523
     6524[endsect]
     6525
     6526
     6527
    63296528[section:service_type basic_io_object::service_type]
    63306529
     
    63326531
    63336532  typedef IoObjectService service_type;
     6533
     6534
     6535
     6536
     6537[endsect]
     6538
     6539
     6540
     6541[section:_basic_io_object basic_io_object::~basic_io_object]
     6542
     6543Protected destructor to prevent deletion through this type.
     6544
     6545  ~basic_io_object();
     6546
     6547
     6548Performs:
     6549
     6550   service.destroy(implementation);
     6551
    63346552
    63356553
     
    66186836]
    66196837
     6838[heading Protected Member Functions]
     6839[table
     6840  [[Name][Description]]
     6841
     6842  [
     6843    [[link boost_asio.reference.basic_socket._basic_socket [*~basic_socket]]]
     6844    [Protected destructor to prevent deletion through this type. ]
     6845  ]
     6846 
     6847]
     6848
    66206849[heading Data Members]
    66216850[table
     
    66406869    [[link boost_asio.reference.basic_socket.message_peek [*message_peek]]]
    66416870    [Peek at incoming data without removing it from the input queue. ]
     6871  ]
     6872
     6873]
     6874
     6875[heading Protected Data Members]
     6876[table
     6877  [[Name][Description]]
     6878
     6879  [
     6880    [[link boost_asio.reference.basic_socket.implementation [*implementation]]]
     6881    [The underlying implementation of the I/O object. ]
     6882  ]
     6883
     6884  [
     6885    [[link boost_asio.reference.basic_socket.service [*service]]]
     6886    [The service associated with the I/O object. ]
    66426887  ]
    66436888
     
    78198064
    78208065
     8066[section:implementation basic_socket::implementation]
     8067
     8068
     8069['Inherited from basic_io_object.]
     8070
     8071The underlying implementation of the I/O object.
     8072
     8073  implementation_type implementation;
     8074
     8075
     8076
     8077[endsect]
     8078
     8079
     8080
    78218081[section:implementation_type basic_socket::implementation_type]
    78228082
     
    84618721]
    84628722
     8723[heading Protected Member Functions]
     8724[table
     8725  [[Name][Description]]
     8726
     8727  [
     8728    [[link boost_asio.reference.basic_socket._basic_socket [*~basic_socket]]]
     8729    [Protected destructor to prevent deletion through this type. ]
     8730  ]
     8731 
     8732]
     8733
    84638734[heading Data Members]
    84648735[table
     
    84838754    [[link boost_asio.reference.basic_socket.message_peek [*message_peek]]]
    84848755    [Peek at incoming data without removing it from the input queue. ]
     8756  ]
     8757
     8758]
     8759
     8760[heading Protected Data Members]
     8761[table
     8762  [[Name][Description]]
     8763
     8764  [
     8765    [[link boost_asio.reference.basic_socket.implementation [*implementation]]]
     8766    [The underlying implementation of the I/O object. ]
     8767  ]
     8768
     8769  [
     8770    [[link boost_asio.reference.basic_socket.service [*service]]]
     8771    [The service associated with the I/O object. ]
    84858772  ]
    84868773
     
    90589345
    90599346
     9347
     9348
     9349
     9350[endsect]
     9351
     9352
     9353
     9354[section:service basic_socket::service]
     9355
     9356
     9357['Inherited from basic_io_object.]
     9358
     9359The service associated with the I/O object.
     9360
     9361  service_type & service;
    90609362
    90619363
     
    93349636
    93359637
     9638[section:_basic_socket basic_socket::~basic_socket]
     9639
     9640Protected destructor to prevent deletion through this type.
     9641
     9642  ~basic_socket();
     9643
     9644
     9645
     9646[endsect]
     9647
     9648
     9649
    93369650[endsect]
    93379651
     
    96029916    [[link boost_asio.reference.basic_socket_acceptor.message_peek [*message_peek]]]
    96039917    [Peek at incoming data without removing it from the input queue. ]
     9918  ]
     9919
     9920]
     9921
     9922[heading Protected Data Members]
     9923[table
     9924  [[Name][Description]]
     9925
     9926  [
     9927    [[link boost_asio.reference.basic_socket_acceptor.implementation [*implementation]]]
     9928    [The underlying implementation of the I/O object. ]
     9929  ]
     9930
     9931  [
     9932    [[link boost_asio.reference.basic_socket_acceptor.service [*service]]]
     9933    [The service associated with the I/O object. ]
    96049934  ]
    96059935
     
    1081911149
    1082011150
     11151[section:implementation basic_socket_acceptor::implementation]
     11152
     11153
     11154['Inherited from basic_io_object.]
     11155
     11156The underlying implementation of the I/O object.
     11157
     11158  implementation_type implementation;
     11159
     11160
     11161
     11162[endsect]
     11163
     11164
     11165
    1082111166[section:implementation_type basic_socket_acceptor::implementation_type]
    1082211167
     
    1160511950
    1160611951
     11952
     11953
     11954
     11955[endsect]
     11956
     11957
     11958
     11959[section:service basic_socket_acceptor::service]
     11960
     11961
     11962['Inherited from basic_io_object.]
     11963
     11964The service associated with the I/O object.
     11965
     11966  service_type & service;
    1160711967
    1160811968
     
    1219312553]
    1219412554
     12555[heading Protected Member Functions]
     12556[table
     12557  [[Name][Description]]
     12558
     12559  [
     12560    [[link boost_asio.reference.basic_socket_streambuf.overflow [*overflow]]]
     12561    []
     12562  ]
     12563 
     12564  [
     12565    [[link boost_asio.reference.basic_socket_streambuf.setbuf [*setbuf]]]
     12566    []
     12567  ]
     12568 
     12569  [
     12570    [[link boost_asio.reference.basic_socket_streambuf.sync [*sync]]]
     12571    []
     12572  ]
     12573 
     12574  [
     12575    [[link boost_asio.reference.basic_socket_streambuf.underflow [*underflow]]]
     12576    []
     12577  ]
     12578 
     12579]
     12580
    1219512581[heading Data Members]
    1219612582[table
     
    1221512601    [[link boost_asio.reference.basic_socket_streambuf.message_peek [*message_peek]]]
    1221612602    [Peek at incoming data without removing it from the input queue. ]
     12603  ]
     12604
     12605]
     12606
     12607[heading Protected Data Members]
     12608[table
     12609  [[Name][Description]]
     12610
     12611  [
     12612    [[link boost_asio.reference.basic_socket_streambuf.implementation [*implementation]]]
     12613    [The underlying implementation of the I/O object. ]
     12614  ]
     12615
     12616  [
     12617    [[link boost_asio.reference.basic_socket_streambuf.service [*service]]]
     12618    [The service associated with the I/O object. ]
    1221712619  ]
    1221812620
     
    1326313665
    1326413666
     13667[section:implementation basic_socket_streambuf::implementation]
     13668
     13669
     13670['Inherited from basic_io_object.]
     13671
     13672The underlying implementation of the I/O object.
     13673
     13674  implementation_type implementation;
     13675
     13676
     13677
     13678[endsect]
     13679
     13680
     13681
    1326513682[section:implementation_type basic_socket_streambuf::implementation_type]
    1326613683
     
    1391814335]
    1391914336
     14337[heading Protected Member Functions]
     14338[table
     14339  [[Name][Description]]
     14340
     14341  [
     14342    [[link boost_asio.reference.basic_socket._basic_socket [*~basic_socket]]]
     14343    [Protected destructor to prevent deletion through this type. ]
     14344  ]
     14345 
     14346]
     14347
    1392014348[heading Data Members]
    1392114349[table
     
    1394014368    [[link boost_asio.reference.basic_socket.message_peek [*message_peek]]]
    1394114369    [Peek at incoming data without removing it from the input queue. ]
     14370  ]
     14371
     14372]
     14373
     14374[heading Protected Data Members]
     14375[table
     14376  [[Name][Description]]
     14377
     14378  [
     14379    [[link boost_asio.reference.basic_socket.implementation [*implementation]]]
     14380    [The underlying implementation of the I/O object. ]
     14381  ]
     14382
     14383  [
     14384    [[link boost_asio.reference.basic_socket.service [*service]]]
     14385    [The service associated with the I/O object. ]
    1394214386  ]
    1394314387
     
    1420714651
    1420814652[endsect]
     14653
     14654
     14655[section:overflow basic_socket_streambuf::overflow]
     14656
     14657
     14658
     14659  int_type overflow(
     14660      int_type c);
     14661
     14662
     14663
     14664[endsect]
     14665
    1420914666
    1421014667
     
    1453614993
    1453714994
     14995
     14996
     14997
     14998[endsect]
     14999
     15000
     15001
     15002[section:service basic_socket_streambuf::service]
     15003
     15004
     15005['Inherited from basic_io_object.]
     15006
     15007The service associated with the I/O object.
     15008
     15009  service_type & service;
    1453815010
    1453915011
     
    1467015142[endsect]
    1467115143
     15144
     15145[section:setbuf basic_socket_streambuf::setbuf]
     15146
     15147
     15148
     15149  std::streambuf * setbuf(
     15150      char_type * s,
     15151      std::streamsize n);
     15152
     15153
     15154
     15155[endsect]
     15156
     15157
    1467215158[section:shutdown basic_socket_streambuf::shutdown]
    1467315159
     
    1481615302
    1481715303
     15304[section:sync basic_socket_streambuf::sync]
     15305
     15306
     15307
     15308  int sync();
     15309
     15310
     15311
     15312[endsect]
     15313
     15314
     15315
     15316[section:underflow basic_socket_streambuf::underflow]
     15317
     15318
     15319
     15320  int_type underflow();
     15321
     15322
     15323
     15324[endsect]
     15325
     15326
     15327
    1481815328[section:_basic_socket_streambuf basic_socket_streambuf::~basic_socket_streambuf]
    1481915329
     
    1516715677    [[link boost_asio.reference.basic_stream_socket.message_peek [*message_peek]]]
    1516815678    [Peek at incoming data without removing it from the input queue. ]
     15679  ]
     15680
     15681]
     15682
     15683[heading Protected Data Members]
     15684[table
     15685  [[Name][Description]]
     15686
     15687  [
     15688    [[link boost_asio.reference.basic_stream_socket.implementation [*implementation]]]
     15689    [The underlying implementation of the I/O object. ]
     15690  ]
     15691
     15692  [
     15693    [[link boost_asio.reference.basic_stream_socket.service [*service]]]
     15694    [The service associated with the I/O object. ]
    1516915695  ]
    1517015696
     
    1677117297
    1677217298
     17299[section:implementation basic_stream_socket::implementation]
     17300
     17301
     17302['Inherited from basic_io_object.]
     17303
     17304The underlying implementation of the I/O object.
     17305
     17306  implementation_type implementation;
     17307
     17308
     17309
     17310[endsect]
     17311
     17312
     17313
    1677317314[section:implementation_type basic_stream_socket::implementation_type]
    1677417315
     
    1742617967]
    1742717968
     17969[heading Protected Member Functions]
     17970[table
     17971  [[Name][Description]]
     17972
     17973  [
     17974    [[link boost_asio.reference.basic_socket._basic_socket [*~basic_socket]]]
     17975    [Protected destructor to prevent deletion through this type. ]
     17976  ]
     17977 
     17978]
     17979
    1742817980[heading Data Members]
    1742917981[table
     
    1744818000    [[link boost_asio.reference.basic_socket.message_peek [*message_peek]]]
    1744918001    [Peek at incoming data without removing it from the input queue. ]
     18002  ]
     18003
     18004]
     18005
     18006[heading Protected Data Members]
     18007[table
     18008  [[Name][Description]]
     18009
     18010  [
     18011    [[link boost_asio.reference.basic_socket.implementation [*implementation]]]
     18012    [The underlying implementation of the I/O object. ]
     18013  ]
     18014
     18015  [
     18016    [[link boost_asio.reference.basic_socket.service [*service]]]
     18017    [The service associated with the I/O object. ]
    1745018018  ]
    1745118019
     
    1852019088
    1852119089
     19090
     19091
     19092
     19093[endsect]
     19094
     19095
     19096
     19097[section:service basic_stream_socket::service]
     19098
     19099
     19100['Inherited from basic_io_object.]
     19101
     19102The service associated with the I/O object.
     19103
     19104  service_type & service;
    1852219105
    1852319106
     
    1898719570]
    1898819571
     19572[heading Protected Member Functions]
     19573[table
     19574  [[Name][Description]]
     19575
     19576  [
     19577    [[link boost_asio.reference.basic_streambuf.overflow [*overflow]]]
     19578    []
     19579  ]
     19580 
     19581  [
     19582    [[link boost_asio.reference.basic_streambuf.reserve [*reserve]]]
     19583    []
     19584  ]
     19585 
     19586  [
     19587    [[link boost_asio.reference.basic_streambuf.underflow [*underflow]]]
     19588    []
     19589  ]
     19590 
     19591]
     19592
    1898919593
    1899019594[section:basic_streambuf basic_streambuf::basic_streambuf]
     
    1907819682
    1907919683
     19684[section:overflow basic_streambuf::overflow]
     19685
     19686
     19687
     19688  int_type overflow(
     19689      int_type c);
     19690
     19691
     19692
     19693[endsect]
     19694
     19695
     19696
    1908019697[section:prepare basic_streambuf::prepare]
    1908119698
     
    1909119708
    1909219709
     19710[section:reserve basic_streambuf::reserve]
     19711
     19712
     19713
     19714  void reserve(
     19715      std::size_t n);
     19716
     19717
     19718
     19719[endsect]
     19720
     19721
     19722
    1909319723[section:size basic_streambuf::size]
    1909419724
     
    1909619726
    1909719727  std::size_t size() const;
     19728
     19729
     19730
     19731[endsect]
     19732
     19733
     19734
     19735[section:underflow basic_streambuf::underflow]
     19736
     19737
     19738
     19739  int_type underflow();
    1909819740
    1909919741
     
    2141022052]
    2141122053
    21412 [heading Friends]
     22054[heading Related Functions]
    2141322055[table
    2141422056  [[Name][Description]]
    2141522057
    2141622058  [
    21417     [[link boost_asio.reference.const_buffer.buffer_cast_helper [*buffer_cast_helper]]]
    21418     []
    21419   ]
    21420  
    21421   [
    21422     [[link boost_asio.reference.const_buffer.buffer_size_helper [*buffer_size_helper]]]
    21423     []
     22059    [[link boost_asio.reference.const_buffer.buffer_cast [*buffer_cast]]]
     22060    [Cast a non-modifiable buffer to a specified pointer to POD type. ]
     22061  ]
     22062 
     22063  [
     22064    [[link boost_asio.reference.const_buffer.buffer_size [*buffer_size]]]
     22065    [Get the number of bytes in a non-modifiable buffer. ]
     22066  ]
     22067 
     22068  [
     22069    [[link boost_asio.reference.const_buffer.operator_plus_ [*operator+]]]
     22070    [Create a new non-modifiable buffer that is offset from the start of another. ]
    2142422071  ]
    2142522072 
     
    2142922076
    2143022077
    21431 [section:buffer_cast_helper const_buffer::buffer_cast_helper]
    21432 
    21433 
    21434 
    21435   friend const void * buffer_cast_helper(
     22078[section:buffer_cast const_buffer::buffer_cast]
     22079
     22080Cast a non-modifiable buffer to a specified pointer to POD type.
     22081
     22082  template<
     22083      typename ``[link boost_asio.reference.PointerToPodType PointerToPodType]``>
     22084  PointerToPodType buffer_cast(
    2143622085      const const_buffer & b);
    2143722086
     
    2144222091
    2144322092
    21444 [section:buffer_size_helper const_buffer::buffer_size_helper]
    21445 
    21446 
    21447 
    21448   friend std::size_t buffer_size_helper(
     22093[section:buffer_size const_buffer::buffer_size]
     22094
     22095Get the number of bytes in a non-modifiable buffer.
     22096
     22097  std::size_t buffer_size(
    2144922098      const const_buffer & b);
    2145022099
     
    2150822157[endsect]
    2150922158
     22159[section:operator_plus_ const_buffer::operator+]
     22160
     22161Create a new non-modifiable buffer that is offset from the start of another.
     22162
     22163  const_buffer ``[link boost_asio.reference.const_buffer.operator_plus_.overload1 operator+]``(
     22164      const const_buffer & b,
     22165      std::size_t start);
     22166
     22167  const_buffer ``[link boost_asio.reference.const_buffer.operator_plus_.overload2 operator+]``(
     22168      std::size_t start,
     22169      const const_buffer & b);
     22170
     22171
     22172[section:overload1 const_buffer::operator+ (1 of 2 overloads)]
     22173
     22174Create a new non-modifiable buffer that is offset from the start of another.
     22175
     22176  const_buffer operator+(
     22177      const const_buffer & b,
     22178      std::size_t start);
     22179
     22180
     22181
     22182[endsect]
     22183
     22184
     22185
     22186[section:overload2 const_buffer::operator+ (2 of 2 overloads)]
     22187
     22188Create a new non-modifiable buffer that is offset from the start of another.
     22189
     22190  const_buffer operator+(
     22191      std::size_t start,
     22192      const const_buffer & b);
     22193
     22194
     22195
     22196[endsect]
     22197
     22198
     22199[endsect]
     22200
    2151022201
    2151122202[endsect]
     
    2156022251]
    2156122252
     22253[heading Related Functions]
     22254[table
     22255  [[Name][Description]]
     22256
     22257  [
     22258    [[link boost_asio.reference.const_buffers_1.buffer_cast [*buffer_cast]]]
     22259    [Cast a non-modifiable buffer to a specified pointer to POD type. ]
     22260  ]
     22261 
     22262  [
     22263    [[link boost_asio.reference.const_buffers_1.buffer_size [*buffer_size]]]
     22264    [Get the number of bytes in a non-modifiable buffer. ]
     22265  ]
     22266 
     22267  [
     22268    [[link boost_asio.reference.const_buffers_1.operator_plus_ [*operator+]]]
     22269    [Create a new non-modifiable buffer that is offset from the start of another. ]
     22270  ]
     22271 
     22272]
     22273
    2156222274
    2156322275[section:begin const_buffers_1::begin]
     
    2156622278
    2156722279  const_iterator begin() const;
     22280
     22281
     22282
     22283[endsect]
     22284
     22285
     22286
     22287[section:buffer_cast const_buffers_1::buffer_cast]
     22288
     22289
     22290['Inherited from const_buffer.]
     22291
     22292Cast a non-modifiable buffer to a specified pointer to POD type.
     22293
     22294  template<
     22295      typename ``[link boost_asio.reference.PointerToPodType PointerToPodType]``>
     22296  PointerToPodType buffer_cast(
     22297      const const_buffer & b);
     22298
     22299
     22300
     22301[endsect]
     22302
     22303
     22304
     22305[section:buffer_size const_buffers_1::buffer_size]
     22306
     22307
     22308['Inherited from const_buffer.]
     22309
     22310Get the number of bytes in a non-modifiable buffer.
     22311
     22312  std::size_t buffer_size(
     22313      const const_buffer & b);
    2156822314
    2156922315
     
    2160922355[endsect]
    2161022356
     22357
     22358[section:operator_plus_ const_buffers_1::operator+]
     22359
     22360Create a new non-modifiable buffer that is offset from the start of another.
     22361
     22362  const_buffer ``[link boost_asio.reference.const_buffers_1.operator_plus_.overload1 operator+]``(
     22363      const const_buffer & b,
     22364      std::size_t start);
     22365
     22366  const_buffer ``[link boost_asio.reference.const_buffers_1.operator_plus_.overload2 operator+]``(
     22367      std::size_t start,
     22368      const const_buffer & b);
     22369
     22370
     22371[section:overload1 const_buffers_1::operator+ (1 of 2 overloads)]
     22372
     22373
     22374['Inherited from const_buffer.]
     22375
     22376Create a new non-modifiable buffer that is offset from the start of another.
     22377
     22378  const_buffer operator+(
     22379      const const_buffer & b,
     22380      std::size_t start);
     22381
     22382
     22383
     22384[endsect]
     22385
     22386
     22387
     22388[section:overload2 const_buffers_1::operator+ (2 of 2 overloads)]
     22389
     22390
     22391['Inherited from const_buffer.]
     22392
     22393Create a new non-modifiable buffer that is offset from the start of another.
     22394
     22395  const_buffer operator+(
     22396      std::size_t start,
     22397      const const_buffer & b);
     22398
     22399
     22400
     22401[endsect]
     22402
     22403
     22404[endsect]
    2161122405
    2161222406
     
    2162922423]
    2163022424
    21631 [heading Friends]
     22425[heading Related Functions]
    2163222426[table
    2163322427  [[Name][Description]]
    2163422428
    2163522429  [
    21636     [[link boost_asio.reference.const_buffer.buffer_cast_helper [*buffer_cast_helper]]]
    21637     []
    21638   ]
    21639  
    21640   [
    21641     [[link boost_asio.reference.const_buffer.buffer_size_helper [*buffer_size_helper]]]
    21642     []
     22430    [[link boost_asio.reference.const_buffer.buffer_cast [*buffer_cast]]]
     22431    [Cast a non-modifiable buffer to a specified pointer to POD type. ]
     22432  ]
     22433 
     22434  [
     22435    [[link boost_asio.reference.const_buffer.buffer_size [*buffer_size]]]
     22436    [Get the number of bytes in a non-modifiable buffer. ]
     22437  ]
     22438 
     22439  [
     22440    [[link boost_asio.reference.const_buffer.operator_plus_ [*operator+]]]
     22441    [Create a new non-modifiable buffer that is offset from the start of another. ]
    2164322442  ]
    2164422443 
     
    2251823317  ]
    2251923318 
     23319]
     23320
     23321[heading Protected Data Members]
     23322[table
     23323  [[Name][Description]]
     23324
     23325  [
     23326    [[link boost_asio.reference.basic_deadline_timer.implementation [*implementation]]]
     23327    [The underlying implementation of the I/O object. ]
     23328  ]
     23329
     23330  [
     23331    [[link boost_asio.reference.basic_deadline_timer.service [*service]]]
     23332    [The service associated with the I/O object. ]
     23333  ]
     23334
    2252023335]
    2252123336
     
    2313223947    [message_size]
    2313323948    [Message too long. ]
     23949  ]
     23950
     23951  [
     23952    [name_too_long]
     23953    [The name was too long. ]
    2313423954  ]
    2313523955
     
    2442325243]
    2442425244
     25245[heading Protected Member Functions]
     25246[table
     25247  [[Name][Description]]
     25248
     25249  [
     25250    [[link boost_asio.reference.io_service__service.service [*service]]]
     25251    [Constructor. ]
     25252  ]
     25253 
     25254  [
     25255    [[link boost_asio.reference.io_service__service._service [*~service]]]
     25256    [Destructor. ]
     25257  ]
     25258 
     25259]
     25260
    2442525261
    2442625262[section:get_io_service io_service::service::get_io_service]
     
    2444125277
    2444225278  boost::asio::io_service & io_service();
     25279
     25280
     25281
     25282[endsect]
     25283
     25284
     25285
     25286[section:service io_service::service::service]
     25287
     25288Constructor.
     25289
     25290  service(
     25291      boost::asio::io_service & owner);
     25292
     25293
     25294
     25295[heading Parameters]
     25296   
     25297
     25298[variablelist
     25299 
     25300[[owner][The io\_service object that owns the service. ]]
     25301
     25302]
     25303
     25304
     25305
     25306[endsect]
     25307
     25308
     25309
     25310[section:_service io_service::service::~service]
     25311
     25312Destructor.
     25313
     25314  virtual ~service();
    2444325315
    2444425316
     
    2491625788]
    2491725789
     25790[heading Related Functions]
     25791[table
     25792  [[Name][Description]]
     25793
     25794  [
     25795    [[link boost_asio.reference.ip__address.operator_lt__lt_ [*operator<<]]]
     25796    [Output an address as a string. ]
     25797  ]
     25798 
     25799]
     25800
    2491825801The
    2491925802[link boost_asio.reference.ip__address ip::address] class provides the ability to use either IP version 4 or version 6 addresses.
     
    2512126004
    2512226005
     26006
     26007[section:operator_lt__lt_ ip::address::operator<<]
     26008
     26009Output an address as a string.
     26010
     26011  template<
     26012      typename ``[link boost_asio.reference.Elem Elem]``,
     26013      typename ``[link boost_asio.reference.Traits Traits]``>
     26014  std::basic_ostream< Elem, Traits > & operator<<(
     26015      std::basic_ostream< Elem, Traits > & os,
     26016      const address & addr);
     26017
     26018
     26019Used to output a human-readable string for a specified address.
     26020
     26021
     26022[heading Parameters]
     26023   
     26024
     26025[variablelist
     26026 
     26027[[os][The output stream to which the string will be written.]]
     26028
     26029[[addr][The address to be written.]]
     26030
     26031]
     26032
     26033[heading Return Value]
     26034     
     26035The output stream.
     26036
     26037
     26038
     26039[endsect]
     26040
     26041
    2512326042[section:operator_eq_ ip::address::operator=]
    2512426043
     
    2538426303]
    2538526304
     26305[heading Related Functions]
     26306[table
     26307  [[Name][Description]]
     26308
     26309  [
     26310    [[link boost_asio.reference.ip__address_v4.operator_lt__lt_ [*operator<<]]]
     26311    [Output an address as a string. ]
     26312  ]
     26313 
     26314]
     26315
    2538626316The
    2538726317[link boost_asio.reference.ip__address_v4 ip::address_v4] class provides the ability to use and manipulate IP version 4 addresses.
     
    2570226632
    2570326633
     26634[section:operator_lt__lt_ ip::address_v4::operator<<]
     26635
     26636Output an address as a string.
     26637
     26638  template<
     26639      typename ``[link boost_asio.reference.Elem Elem]``,
     26640      typename ``[link boost_asio.reference.Traits Traits]``>
     26641  std::basic_ostream< Elem, Traits > & operator<<(
     26642      std::basic_ostream< Elem, Traits > & os,
     26643      const address_v4 & addr);
     26644
     26645
     26646Used to output a human-readable string for a specified address.
     26647
     26648
     26649[heading Parameters]
     26650   
     26651
     26652[variablelist
     26653 
     26654[[os][The output stream to which the string will be written.]]
     26655
     26656[[addr][The address to be written.]]
     26657
     26658]
     26659
     26660[heading Return Value]
     26661     
     26662The output stream.
     26663
     26664
     26665
     26666[endsect]
     26667
     26668
     26669
    2570426670[section:operator_lt__eq_ ip::address_v4::operator<=]
    2570526671
     
    2601026976]
    2601126977
     26978[heading Related Functions]
     26979[table
     26980  [[Name][Description]]
     26981
     26982  [
     26983    [[link boost_asio.reference.ip__address_v6.operator_lt__lt_ [*operator<<]]]
     26984    [Output an address as a string. ]
     26985  ]
     26986 
     26987]
     26988
    2601226989The
    2601326990[link boost_asio.reference.ip__address_v6 ip::address_v6] class provides the ability to use and manipulate IP version 6 addresses.
     
    2635927336
    2636027337
     27338[section:operator_lt__lt_ ip::address_v6::operator<<]
     27339
     27340Output an address as a string.
     27341
     27342  template<
     27343      typename ``[link boost_asio.reference.Elem Elem]``,
     27344      typename ``[link boost_asio.reference.Traits Traits]``>
     27345  std::basic_ostream< Elem, Traits > & operator<<(
     27346      std::basic_ostream< Elem, Traits > & os,
     27347      const address_v6 & addr);
     27348
     27349
     27350Used to output a human-readable string for a specified address.
     27351
     27352
     27353[heading Parameters]
     27354   
     27355
     27356[variablelist
     27357 
     27358[[os][The output stream to which the string will be written.]]
     27359
     27360[[addr][The address to be written.]]
     27361
     27362]
     27363
     27364[heading Return Value]
     27365     
     27366The output stream.
     27367
     27368
     27369
     27370[endsect]
     27371
     27372
     27373
    2636127374[section:operator_lt__eq_ ip::address_v6::operator<=]
    2636227375
     
    2665727670]
    2665827671
     27672[heading Related Functions]
     27673[table
     27674  [[Name][Description]]
     27675
     27676  [
     27677    [[link boost_asio.reference.ip__basic_endpoint.operator_lt__lt_ [*operator<<]]]
     27678    [Output an endpoint as a string. ]
     27679  ]
     27680 
     27681]
     27682
    2665927683The
    2666027684[link boost_asio.reference.ip__basic_endpoint ip::basic_endpoint] class template describes an endpoint that may be associated with a particular socket.
     
    2687427898      const basic_endpoint< InternetProtocol > & e1,
    2687527899      const basic_endpoint< InternetProtocol > & e2);
     27900
     27901
     27902
     27903[endsect]
     27904
     27905
     27906
     27907[section:operator_lt__lt_ ip::basic_endpoint::operator<<]
     27908
     27909Output an endpoint as a string.
     27910
     27911  std::basic_ostream< Elem, Traits > & operator<<(
     27912      std::basic_ostream< Elem, Traits > & os,
     27913      const basic_endpoint< InternetProtocol > & endpoint);
     27914
     27915
     27916Used to output a human-readable string for a specified endpoint.
     27917
     27918
     27919[heading Parameters]
     27920   
     27921
     27922[variablelist
     27923 
     27924[[os][The output stream to which the string will be written.]]
     27925
     27926[[endpoint][The endpoint to be written.]]
     27927
     27928]
     27929
     27930[heading Return Value]
     27931     
     27932The output stream.
    2687627933
    2687727934
     
    2708928146  ]
    2709028147 
     28148]
     28149
     28150[heading Protected Data Members]
     28151[table
     28152  [[Name][Description]]
     28153
     28154  [
     28155    [[link boost_asio.reference.ip__basic_resolver.implementation [*implementation]]]
     28156    [The underlying implementation of the I/O object. ]
     28157  ]
     28158
     28159  [
     28160    [[link boost_asio.reference.ip__basic_resolver.service [*service]]]
     28161    [The service associated with the I/O object. ]
     28162  ]
     28163
    2709128164]
    2709228165
     
    2728828361
    2728928362
     28363[section:implementation ip::basic_resolver::implementation]
     28364
     28365
     28366['Inherited from basic_io_object.]
     28367
     28368The underlying implementation of the I/O object.
     28369
     28370  implementation_type implementation;
     28371
     28372
     28373
     28374[endsect]
     28375
     28376
     28377
    2729028378[section:implementation_type ip::basic_resolver::implementation_type]
    2729128379
     
    2754828636
    2754928637[endsect]
     28638
     28639
     28640[section:service ip::basic_resolver::service]
     28641
     28642
     28643['Inherited from basic_io_object.]
     28644
     28645The service associated with the I/O object.
     28646
     28647  service_type & service;
     28648
     28649
     28650
     28651[endsect]
     28652
    2755028653
    2755128654
     
    2842029523
    2842129524
     29525[heading Protected Member Functions]
     29526[table
     29527  [[Name][Description]]
     29528
     29529  [
     29530    [[link boost_asio.reference.ip__resolver_query_base._resolver_query_base [*~resolver_query_base]]]
     29531    [Protected destructor to prevent deletion through this type. ]
     29532  ]
     29533 
     29534]
     29535
    2842229536[heading Data Members]
    2842329537[table
     
    2853929653
    2854029654  static const int v4_mapped = implementation_defined;
     29655
     29656
     29657
     29658[endsect]
     29659
     29660
     29661
     29662[section:_resolver_query_base ip::resolver_query_base::~resolver_query_base]
     29663
     29664Protected destructor to prevent deletion through this type.
     29665
     29666  ~resolver_query_base();
    2854129667
    2854229668
     
    2932830454]
    2932930455
     30456[heading Protected Data Members]
     30457[table
     30458  [[Name][Description]]
     30459
     30460  [
     30461    [[link boost_asio.reference.basic_socket_acceptor.implementation [*implementation]]]
     30462    [The underlying implementation of the I/O object. ]
     30463  ]
     30464
     30465  [
     30466    [[link boost_asio.reference.basic_socket_acceptor.service [*service]]]
     30467    [The service associated with the I/O object. ]
     30468  ]
     30469
     30470]
     30471
    2933030472The basic_socket_acceptor class template is used for accepting new socket connections.
    2933130473
     
    2945730599]
    2945830600
     30601[heading Related Functions]
     30602[table
     30603  [[Name][Description]]
     30604
     30605  [
     30606    [[link boost_asio.reference.ip__basic_endpoint.operator_lt__lt_ [*operator<<]]]
     30607    [Output an endpoint as a string. ]
     30608  ]
     30609 
     30610]
     30611
    2945930612The
    2946030613[link boost_asio.reference.ip__basic_endpoint ip::basic_endpoint] class template describes an endpoint that may be associated with a particular socket.
     
    2969630849]
    2969730850
     30851[heading Protected Data Members]
     30852[table
     30853  [[Name][Description]]
     30854
     30855  [
     30856    [[link boost_asio.reference.ip__basic_resolver.implementation [*implementation]]]
     30857    [The underlying implementation of the I/O object. ]
     30858  ]
     30859
     30860  [
     30861    [[link boost_asio.reference.ip__basic_resolver.service [*service]]]
     30862    [The service associated with the I/O object. ]
     30863  ]
     30864
     30865]
     30866
    2969830867The basic_resolver class template provides the ability to resolve a query to a list of endpoints.
    2969930868
     
    3020031369]
    3020131370
     31371[heading Protected Data Members]
     31372[table
     31373  [[Name][Description]]
     31374
     31375  [
     31376    [[link boost_asio.reference.basic_stream_socket.implementation [*implementation]]]
     31377    [The underlying implementation of the I/O object. ]
     31378  ]
     31379
     31380  [
     31381    [[link boost_asio.reference.basic_stream_socket.service [*service]]]
     31382    [The service associated with the I/O object. ]
     31383  ]
     31384
     31385]
     31386
    3020231387The basic_stream_socket class template provides asynchronous and blocking stream-oriented socket functionality.
    3020331388
     
    3046031645]
    3046131646
     31647[heading Related Functions]
     31648[table
     31649  [[Name][Description]]
     31650
     31651  [
     31652    [[link boost_asio.reference.ip__basic_endpoint.operator_lt__lt_ [*operator<<]]]
     31653    [Output an endpoint as a string. ]
     31654  ]
     31655 
     31656]
     31657
    3046231658The
    3046331659[link boost_asio.reference.ip__basic_endpoint ip::basic_endpoint] class template describes an endpoint that may be associated with a particular socket.
     
    3062031816]
    3062131817
     31818[heading Protected Data Members]
     31819[table
     31820  [[Name][Description]]
     31821
     31822  [
     31823    [[link boost_asio.reference.ip__basic_resolver.implementation [*implementation]]]
     31824    [The underlying implementation of the I/O object. ]
     31825  ]
     31826
     31827  [
     31828    [[link boost_asio.reference.ip__basic_resolver.service [*service]]]
     31829    [The service associated with the I/O object. ]
     31830  ]
     31831
     31832]
     31833
    3062231834The basic_resolver class template provides the ability to resolve a query to a list of endpoints.
    3062331835
     
    3112032332    [[link boost_asio.reference.basic_datagram_socket.message_peek [*message_peek]]]
    3112132333    [Peek at incoming data without removing it from the input queue. ]
     32334  ]
     32335
     32336]
     32337
     32338[heading Protected Data Members]
     32339[table
     32340  [[Name][Description]]
     32341
     32342  [
     32343    [[link boost_asio.reference.basic_datagram_socket.implementation [*implementation]]]
     32344    [The underlying implementation of the I/O object. ]
     32345  ]
     32346
     32347  [
     32348    [[link boost_asio.reference.basic_datagram_socket.service [*service]]]
     32349    [The service associated with the I/O object. ]
    3112232350  ]
    3112332351
     
    3132832556[endsect]
    3132932557
    31330 [section:mutable_buffer mutable_buffer]
    31331 
    31332 Holds a buffer that can be modified.
    31333 
    31334   class mutable_buffer
    31335 
     32558[section:local__basic_endpoint local::basic_endpoint]
     32559
     32560Describes an endpoint for a UNIX socket.
     32561
     32562  template<
     32563      typename ``[link boost_asio.reference.Protocol Protocol]``>
     32564  class basic_endpoint
     32565
     32566
     32567[heading Types]
     32568[table
     32569  [[Name][Description]]
     32570
     32571  [
     32572
     32573    [[link boost_asio.reference.local__basic_endpoint.data_type [*data_type]]]
     32574    [The type of the endpoint structure. This type is dependent on the underlying implementation of the socket layer. ]
     32575 
     32576  ]
     32577
     32578  [
     32579
     32580    [[link boost_asio.reference.local__basic_endpoint.protocol_type [*protocol_type]]]
     32581    [The protocol type associated with the endpoint. ]
     32582 
     32583  ]
     32584
     32585]
    3133632586
    3133732587[heading Member Functions]
     
    3134032590
    3134132591  [
    31342     [[link boost_asio.reference.mutable_buffer.mutable_buffer [*mutable_buffer]]]
    31343     [Construct an empty buffer. ]
     32592    [[link boost_asio.reference.local__basic_endpoint.basic_endpoint [*basic_endpoint]]]
     32593    [Default constructor. ]
     32594  ]
     32595 
     32596  [
     32597    [[link boost_asio.reference.local__basic_endpoint.capacity [*capacity]]]
     32598    [Get the capacity of the endpoint in the native type. ]
     32599  ]
     32600 
     32601  [
     32602    [[link boost_asio.reference.local__basic_endpoint.data [*data]]]
     32603    [Get the underlying endpoint in the native type. ]
     32604  ]
     32605 
     32606  [
     32607    [[link boost_asio.reference.local__basic_endpoint.operator_eq_ [*operator=]]]
     32608    [Assign from another endpoint. ]
     32609  ]
     32610 
     32611  [
     32612    [[link boost_asio.reference.local__basic_endpoint.path [*path]]]
     32613    [Get the path associated with the endpoint. ]
     32614  ]
     32615 
     32616  [
     32617    [[link boost_asio.reference.local__basic_endpoint.protocol [*protocol]]]
     32618    [The protocol associated with the endpoint. ]
     32619  ]
     32620 
     32621  [
     32622    [[link boost_asio.reference.local__basic_endpoint.resize [*resize]]]
     32623    [Set the underlying size of the endpoint in the native type. ]
     32624  ]
     32625 
     32626  [
     32627    [[link boost_asio.reference.local__basic_endpoint.size [*size]]]
     32628    [Get the underlying size of the endpoint in the native type. ]
    3134432629  ]
    3134532630 
     
    3135132636
    3135232637  [
    31353     [[link boost_asio.reference.mutable_buffer.buffer_cast_helper [*buffer_cast_helper]]]
    31354     []
    31355   ]
    31356  
    31357   [
    31358     [[link boost_asio.reference.mutable_buffer.buffer_size_helper [*buffer_size_helper]]]
    31359     []
     32638    [[link boost_asio.reference.local__basic_endpoint.operator_not__eq_ [*operator!=]]]
     32639    [Compare two endpoints for inequality. ]
     32640  ]
     32641 
     32642  [
     32643    [[link boost_asio.reference.local__basic_endpoint.operator_lt_ [*operator<]]]
     32644    [Compare endpoints for ordering. ]
     32645  ]
     32646 
     32647  [
     32648    [[link boost_asio.reference.local__basic_endpoint.operator_eq__eq_ [*operator==]]]
     32649    [Compare two endpoints for equality. ]
     32650  ]
     32651 
     32652]
     32653
     32654[heading Related Functions]
     32655[table
     32656  [[Name][Description]]
     32657
     32658  [
     32659    [[link boost_asio.reference.local__basic_endpoint.operator_lt__lt_ [*operator<<]]]
     32660    [Output an endpoint as a string. ]
     32661  ]
     32662 
     32663]
     32664
     32665The
     32666[link boost_asio.reference.local__basic_endpoint local::basic_endpoint] class template describes an endpoint that may be associated with a particular UNIX socket.
     32667
     32668
     32669[heading Thread Safety]
     32670 
     32671[*Distinct] [*objects:]  Safe.
     32672
     32673[*Shared] [*objects:]  Unsafe.
     32674
     32675
     32676[section:basic_endpoint local::basic_endpoint::basic_endpoint]
     32677
     32678Default constructor.
     32679
     32680  ``[link boost_asio.reference.local__basic_endpoint.basic_endpoint.overload1 basic_endpoint]``();
     32681
     32682  ``[link boost_asio.reference.local__basic_endpoint.basic_endpoint.overload2 basic_endpoint]``(
     32683      const char * path);
     32684
     32685  ``[link boost_asio.reference.local__basic_endpoint.basic_endpoint.overload3 basic_endpoint]``(
     32686      const std::string & path);
     32687
     32688  ``[link boost_asio.reference.local__basic_endpoint.basic_endpoint.overload4 basic_endpoint]``(
     32689      const basic_endpoint & other);
     32690
     32691
     32692[section:overload1 local::basic_endpoint::basic_endpoint (1 of 4 overloads)]
     32693
     32694Default constructor.
     32695
     32696  basic_endpoint();
     32697
     32698
     32699
     32700[endsect]
     32701
     32702
     32703
     32704[section:overload2 local::basic_endpoint::basic_endpoint (2 of 4 overloads)]
     32705
     32706Construct an endpoint using the specified path name.
     32707
     32708  basic_endpoint(
     32709      const char * path);
     32710
     32711
     32712
     32713[endsect]
     32714
     32715
     32716
     32717[section:overload3 local::basic_endpoint::basic_endpoint (3 of 4 overloads)]
     32718
     32719Construct an endpoint using the specified path name.
     32720
     32721  basic_endpoint(
     32722      const std::string & path);
     32723
     32724
     32725
     32726[endsect]
     32727
     32728
     32729
     32730[section:overload4 local::basic_endpoint::basic_endpoint (4 of 4 overloads)]
     32731
     32732Copy constructor.
     32733
     32734  basic_endpoint(
     32735      const basic_endpoint & other);
     32736
     32737
     32738
     32739[endsect]
     32740
     32741
     32742[endsect]
     32743
     32744
     32745[section:capacity local::basic_endpoint::capacity]
     32746
     32747Get the capacity of the endpoint in the native type.
     32748
     32749  std::size_t capacity() const;
     32750
     32751
     32752
     32753[endsect]
     32754
     32755
     32756[section:data local::basic_endpoint::data]
     32757
     32758Get the underlying endpoint in the native type.
     32759
     32760  data_type * ``[link boost_asio.reference.local__basic_endpoint.data.overload1 data]``();
     32761
     32762  const data_type * ``[link boost_asio.reference.local__basic_endpoint.data.overload2 data]``() const;
     32763
     32764
     32765[section:overload1 local::basic_endpoint::data (1 of 2 overloads)]
     32766
     32767Get the underlying endpoint in the native type.
     32768
     32769  data_type * data();
     32770
     32771
     32772
     32773[endsect]
     32774
     32775
     32776
     32777[section:overload2 local::basic_endpoint::data (2 of 2 overloads)]
     32778
     32779Get the underlying endpoint in the native type.
     32780
     32781  const data_type * data() const;
     32782
     32783
     32784
     32785[endsect]
     32786
     32787
     32788[endsect]
     32789
     32790
     32791[section:data_type local::basic_endpoint::data_type]
     32792
     32793The type of the endpoint structure. This type is dependent on the underlying implementation of the socket layer.
     32794
     32795  typedef implementation_defined data_type;
     32796
     32797
     32798
     32799
     32800[endsect]
     32801
     32802
     32803
     32804[section:operator_not__eq_ local::basic_endpoint::operator!=]
     32805
     32806Compare two endpoints for inequality.
     32807
     32808  friend bool operator!=(
     32809      const basic_endpoint< Protocol > & e1,
     32810      const basic_endpoint< Protocol > & e2);
     32811
     32812
     32813
     32814[endsect]
     32815
     32816
     32817
     32818[section:operator_lt_ local::basic_endpoint::operator<]
     32819
     32820Compare endpoints for ordering.
     32821
     32822  friend bool operator<(
     32823      const basic_endpoint< Protocol > & e1,
     32824      const basic_endpoint< Protocol > & e2);
     32825
     32826
     32827
     32828[endsect]
     32829
     32830
     32831
     32832[section:operator_lt__lt_ local::basic_endpoint::operator<<]
     32833
     32834Output an endpoint as a string.
     32835
     32836  std::basic_ostream< Elem, Traits > & operator<<(
     32837      std::basic_ostream< Elem, Traits > & os,
     32838      const basic_endpoint< Protocol > & endpoint);
     32839
     32840
     32841Used to output a human-readable string for a specified endpoint.
     32842
     32843
     32844[heading Parameters]
     32845   
     32846
     32847[variablelist
     32848 
     32849[[os][The output stream to which the string will be written.]]
     32850
     32851[[endpoint][The endpoint to be written.]]
     32852
     32853]
     32854
     32855[heading Return Value]
     32856     
     32857The output stream.
     32858
     32859
     32860
     32861[endsect]
     32862
     32863
     32864
     32865[section:operator_eq_ local::basic_endpoint::operator=]
     32866
     32867Assign from another endpoint.
     32868
     32869  basic_endpoint & operator=(
     32870      const basic_endpoint & other);
     32871
     32872
     32873
     32874[endsect]
     32875
     32876
     32877
     32878[section:operator_eq__eq_ local::basic_endpoint::operator==]
     32879
     32880Compare two endpoints for equality.
     32881
     32882  friend bool operator==(
     32883      const basic_endpoint< Protocol > & e1,
     32884      const basic_endpoint< Protocol > & e2);
     32885
     32886
     32887
     32888[endsect]
     32889
     32890
     32891[section:path local::basic_endpoint::path]
     32892
     32893Get the path associated with the endpoint.
     32894
     32895  std::string ``[link boost_asio.reference.local__basic_endpoint.path.overload1 path]``() const;
     32896
     32897  void ``[link boost_asio.reference.local__basic_endpoint.path.overload2 path]``(
     32898      const char * p);
     32899
     32900  void ``[link boost_asio.reference.local__basic_endpoint.path.overload3 path]``(
     32901      const std::string & p);
     32902
     32903
     32904[section:overload1 local::basic_endpoint::path (1 of 3 overloads)]
     32905
     32906Get the path associated with the endpoint.
     32907
     32908  std::string path() const;
     32909
     32910
     32911
     32912[endsect]
     32913
     32914
     32915
     32916[section:overload2 local::basic_endpoint::path (2 of 3 overloads)]
     32917
     32918Set the path associated with the endpoint.
     32919
     32920  void path(
     32921      const char * p);
     32922
     32923
     32924
     32925[endsect]
     32926
     32927
     32928
     32929[section:overload3 local::basic_endpoint::path (3 of 3 overloads)]
     32930
     32931Set the path associated with the endpoint.
     32932
     32933  void path(
     32934      const std::string & p);
     32935
     32936
     32937
     32938[endsect]
     32939
     32940
     32941[endsect]
     32942
     32943
     32944[section:protocol local::basic_endpoint::protocol]
     32945
     32946The protocol associated with the endpoint.
     32947
     32948  protocol_type protocol() const;
     32949
     32950
     32951
     32952[endsect]
     32953
     32954
     32955
     32956[section:protocol_type local::basic_endpoint::protocol_type]
     32957
     32958The protocol type associated with the endpoint.
     32959
     32960  typedef Protocol protocol_type;
     32961
     32962
     32963
     32964
     32965[endsect]
     32966
     32967
     32968
     32969[section:resize local::basic_endpoint::resize]
     32970
     32971Set the underlying size of the endpoint in the native type.
     32972
     32973  void resize(
     32974      std::size_t size);
     32975
     32976
     32977
     32978[endsect]
     32979
     32980
     32981
     32982[section:size local::basic_endpoint::size]
     32983
     32984Get the underlying size of the endpoint in the native type.
     32985
     32986  std::size_t size() const;
     32987
     32988
     32989
     32990[endsect]
     32991
     32992
     32993
     32994[endsect]
     32995
     32996[section:local__connect_pair local::connect_pair]
     32997
     32998Create a pair of connected sockets.
     32999
     33000  template<
     33001      typename ``[link boost_asio.reference.Protocol Protocol]``,
     33002      typename ``[link boost_asio.reference.SocketService1 SocketService1]``,
     33003      typename ``[link boost_asio.reference.SocketService2 SocketService2]``>
     33004  void ``[link boost_asio.reference.local__connect_pair.overload1 connect_pair]``(
     33005      basic_socket< Protocol, SocketService1 > & socket1,
     33006      basic_socket< Protocol, SocketService2 > & socket2);
     33007
     33008  template<
     33009      typename ``[link boost_asio.reference.Protocol Protocol]``,
     33010      typename ``[link boost_asio.reference.SocketService1 SocketService1]``,
     33011      typename ``[link boost_asio.reference.SocketService2 SocketService2]``>
     33012  boost::system::error_code ``[link boost_asio.reference.local__connect_pair.overload2 connect_pair]``(
     33013      basic_socket< Protocol, SocketService1 > & socket1,
     33014      basic_socket< Protocol, SocketService2 > & socket2,
     33015      boost::system::error_code & ec);
     33016
     33017
     33018[section:overload1 local::connect_pair (1 of 2 overloads)]
     33019
     33020Create a pair of connected sockets.
     33021
     33022  template<
     33023      typename ``[link boost_asio.reference.Protocol Protocol]``,
     33024      typename ``[link boost_asio.reference.SocketService1 SocketService1]``,
     33025      typename ``[link boost_asio.reference.SocketService2 SocketService2]``>
     33026  void connect_pair(
     33027      basic_socket< Protocol, SocketService1 > & socket1,
     33028      basic_socket< Protocol, SocketService2 > & socket2);
     33029
     33030
     33031
     33032[endsect]
     33033
     33034
     33035
     33036[section:overload2 local::connect_pair (2 of 2 overloads)]
     33037
     33038Create a pair of connected sockets.
     33039
     33040  template<
     33041      typename ``[link boost_asio.reference.Protocol Protocol]``,
     33042      typename ``[link boost_asio.reference.SocketService1 SocketService1]``,
     33043      typename ``[link boost_asio.reference.SocketService2 SocketService2]``>
     33044  boost::system::error_code connect_pair(
     33045      basic_socket< Protocol, SocketService1 > & socket1,
     33046      basic_socket< Protocol, SocketService2 > & socket2,
     33047      boost::system::error_code & ec);
     33048
     33049
     33050
     33051[endsect]
     33052
     33053
     33054[endsect]
     33055
     33056[section:local__datagram_protocol local::datagram_protocol]
     33057
     33058Encapsulates the flags needed for datagram-oriented UNIX sockets.
     33059
     33060  class datagram_protocol
     33061
     33062
     33063[heading Types]
     33064[table
     33065  [[Name][Description]]
     33066
     33067  [
     33068
     33069    [[link boost_asio.reference.local__datagram_protocol.endpoint [*endpoint]]]
     33070    [The type of a UNIX domain endpoint. ]
     33071 
     33072  ]
     33073
     33074  [
     33075
     33076    [[link boost_asio.reference.local__datagram_protocol.socket [*socket]]]
     33077    [The UNIX domain socket type. ]
     33078 
     33079  ]
     33080
     33081]
     33082
     33083[heading Member Functions]
     33084[table
     33085  [[Name][Description]]
     33086
     33087  [
     33088    [[link boost_asio.reference.local__datagram_protocol.family [*family]]]
     33089    [Obtain an identifier for the protocol family. ]
     33090  ]
     33091 
     33092  [
     33093    [[link boost_asio.reference.local__datagram_protocol.protocol [*protocol]]]
     33094    [Obtain an identifier for the protocol. ]
     33095  ]
     33096 
     33097  [
     33098    [[link boost_asio.reference.local__datagram_protocol.type [*type]]]
     33099    [Obtain an identifier for the type of the protocol. ]
     33100  ]
     33101 
     33102]
     33103
     33104The
     33105[link boost_asio.reference.local__datagram_protocol local::datagram_protocol] class contains flags necessary for datagram-oriented UNIX domain sockets.
     33106
     33107
     33108[heading Thread Safety]
     33109 
     33110[*Distinct] [*objects:]  Safe.
     33111
     33112[*Shared] [*objects:]  Safe.
     33113
     33114
     33115
     33116[section:endpoint local::datagram_protocol::endpoint]
     33117
     33118The type of a UNIX domain endpoint.
     33119
     33120  typedef basic_endpoint< datagram_protocol > endpoint;
     33121
     33122
     33123[heading Types]
     33124[table
     33125  [[Name][Description]]
     33126
     33127  [
     33128
     33129    [[link boost_asio.reference.local__basic_endpoint.data_type [*data_type]]]
     33130    [The type of the endpoint structure. This type is dependent on the underlying implementation of the socket layer. ]
     33131 
     33132  ]
     33133
     33134  [
     33135
     33136    [[link boost_asio.reference.local__basic_endpoint.protocol_type [*protocol_type]]]
     33137    [The protocol type associated with the endpoint. ]
     33138 
     33139  ]
     33140
     33141]
     33142
     33143[heading Member Functions]
     33144[table
     33145  [[Name][Description]]
     33146
     33147  [
     33148    [[link boost_asio.reference.local__basic_endpoint.basic_endpoint [*basic_endpoint]]]
     33149    [Default constructor. ]
     33150  ]
     33151 
     33152  [
     33153    [[link boost_asio.reference.local__basic_endpoint.capacity [*capacity]]]
     33154    [Get the capacity of the endpoint in the native type. ]
     33155  ]
     33156 
     33157  [
     33158    [[link boost_asio.reference.local__basic_endpoint.data [*data]]]
     33159    [Get the underlying endpoint in the native type. ]
     33160  ]
     33161 
     33162  [
     33163    [[link boost_asio.reference.local__basic_endpoint.operator_eq_ [*operator=]]]
     33164    [Assign from another endpoint. ]
     33165  ]
     33166 
     33167  [
     33168    [[link boost_asio.reference.local__basic_endpoint.path [*path]]]
     33169    [Get the path associated with the endpoint. ]
     33170  ]
     33171 
     33172  [
     33173    [[link boost_asio.reference.local__basic_endpoint.protocol [*protocol]]]
     33174    [The protocol associated with the endpoint. ]
     33175  ]
     33176 
     33177  [
     33178    [[link boost_asio.reference.local__basic_endpoint.resize [*resize]]]
     33179    [Set the underlying size of the endpoint in the native type. ]
     33180  ]
     33181 
     33182  [
     33183    [[link boost_asio.reference.local__basic_endpoint.size [*size]]]
     33184    [Get the underlying size of the endpoint in the native type. ]
     33185  ]
     33186 
     33187]
     33188
     33189[heading Friends]
     33190[table
     33191  [[Name][Description]]
     33192
     33193  [
     33194    [[link boost_asio.reference.local__basic_endpoint.operator_not__eq_ [*operator!=]]]
     33195    [Compare two endpoints for inequality. ]
     33196  ]
     33197 
     33198  [
     33199    [[link boost_asio.reference.local__basic_endpoint.operator_lt_ [*operator<]]]
     33200    [Compare endpoints for ordering. ]
     33201  ]
     33202 
     33203  [
     33204    [[link boost_asio.reference.local__basic_endpoint.operator_eq__eq_ [*operator==]]]
     33205    [Compare two endpoints for equality. ]
     33206  ]
     33207 
     33208]
     33209
     33210[heading Related Functions]
     33211[table
     33212  [[Name][Description]]
     33213
     33214  [
     33215    [[link boost_asio.reference.local__basic_endpoint.operator_lt__lt_ [*operator<<]]]
     33216    [Output an endpoint as a string. ]
     33217  ]
     33218 
     33219]
     33220
     33221The
     33222[link boost_asio.reference.local__basic_endpoint local::basic_endpoint] class template describes an endpoint that may be associated with a particular UNIX socket.
     33223
     33224
     33225[heading Thread Safety]
     33226 
     33227[*Distinct] [*objects:]  Safe.
     33228
     33229[*Shared] [*objects:]  Unsafe.
     33230
     33231
     33232
     33233
     33234[endsect]
     33235
     33236
     33237
     33238[section:family local::datagram_protocol::family]
     33239
     33240Obtain an identifier for the protocol family.
     33241
     33242  int family() const;
     33243
     33244
     33245
     33246[endsect]
     33247
     33248
     33249
     33250[section:protocol local::datagram_protocol::protocol]
     33251
     33252Obtain an identifier for the protocol.
     33253
     33254  int protocol() const;
     33255
     33256
     33257
     33258[endsect]
     33259
     33260
     33261
     33262[section:socket local::datagram_protocol::socket]
     33263
     33264The UNIX domain socket type.
     33265
     33266  typedef basic_datagram_socket< datagram_protocol > socket;
     33267
     33268
     33269[heading Types]
     33270[table
     33271  [[Name][Description]]
     33272
     33273  [
     33274
     33275    [[link boost_asio.reference.basic_datagram_socket.broadcast [*broadcast]]]
     33276    [Socket option to permit sending of broadcast messages. ]
     33277 
     33278  ]
     33279
     33280  [
     33281
     33282    [[link boost_asio.reference.basic_datagram_socket.bytes_readable [*bytes_readable]]]
     33283    [IO control command to get the amount of data that can be read without blocking. ]
     33284 
     33285  ]
     33286
     33287  [
     33288
     33289    [[link boost_asio.reference.basic_datagram_socket.debug [*debug]]]
     33290    [Socket option to enable socket-level debugging. ]
     33291 
     33292  ]
     33293
     33294  [
     33295
     33296    [[link boost_asio.reference.basic_datagram_socket.do_not_route [*do_not_route]]]
     33297    [Socket option to prevent routing, use local interfaces only. ]
     33298 
     33299  ]
     33300
     33301  [
     33302
     33303    [[link boost_asio.reference.basic_datagram_socket.enable_connection_aborted [*enable_connection_aborted]]]
     33304    [Socket option to report aborted connections on accept. ]
     33305 
     33306  ]
     33307
     33308  [
     33309
     33310    [[link boost_asio.reference.basic_datagram_socket.endpoint_type [*endpoint_type]]]
     33311    [The endpoint type. ]
     33312 
     33313  ]
     33314
     33315  [
     33316
     33317    [[link boost_asio.reference.basic_datagram_socket.implementation_type [*implementation_type]]]
     33318    [The underlying implementation type of I/O object. ]
     33319 
     33320  ]
     33321
     33322  [
     33323
     33324    [[link boost_asio.reference.basic_datagram_socket.keep_alive [*keep_alive]]]
     33325    [Socket option to send keep-alives. ]
     33326 
     33327  ]
     33328
     33329  [
     33330
     33331    [[link boost_asio.reference.basic_datagram_socket.linger [*linger]]]
     33332    [Socket option to specify whether the socket lingers on close if unsent data is present. ]
     33333 
     33334  ]
     33335
     33336  [
     33337
     33338    [[link boost_asio.reference.basic_datagram_socket.lowest_layer_type [*lowest_layer_type]]]
     33339    [A basic_socket is always the lowest layer. ]
     33340 
     33341  ]
     33342
     33343  [
     33344
     33345    [[link boost_asio.reference.basic_datagram_socket.message_flags [*message_flags]]]
     33346    [Bitmask type for flags that can be passed to send and receive operations. ]
     33347 
     33348  ]
     33349
     33350  [
     33351
     33352    [[link boost_asio.reference.basic_datagram_socket.native_type [*native_type]]]
     33353    [The native representation of a socket. ]
     33354 
     33355  ]
     33356
     33357  [
     33358
     33359    [[link boost_asio.reference.basic_datagram_socket.non_blocking_io [*non_blocking_io]]]
     33360    [IO control command to set the blocking mode of the socket. ]
     33361 
     33362  ]
     33363
     33364  [
     33365
     33366    [[link boost_asio.reference.basic_datagram_socket.protocol_type [*protocol_type]]]
     33367    [The protocol type. ]
     33368 
     33369  ]
     33370
     33371  [
     33372
     33373    [[link boost_asio.reference.basic_datagram_socket.receive_buffer_size [*receive_buffer_size]]]
     33374    [Socket option for the receive buffer size of a socket. ]
     33375 
     33376  ]
     33377
     33378  [
     33379
     33380    [[link boost_asio.reference.basic_datagram_socket.receive_low_watermark [*receive_low_watermark]]]
     33381    [Socket option for the receive low watermark. ]
     33382 
     33383  ]
     33384
     33385  [
     33386
     33387    [[link boost_asio.reference.basic_datagram_socket.reuse_address [*reuse_address]]]
     33388    [Socket option to allow the socket to be bound to an address that is already in use. ]
     33389 
     33390  ]
     33391
     33392  [
     33393
     33394    [[link boost_asio.reference.basic_datagram_socket.send_buffer_size [*send_buffer_size]]]
     33395    [Socket option for the send buffer size of a socket. ]
     33396 
     33397  ]
     33398
     33399  [
     33400
     33401    [[link boost_asio.reference.basic_datagram_socket.send_low_watermark [*send_low_watermark]]]
     33402    [Socket option for the send low watermark. ]
     33403 
     33404  ]
     33405
     33406  [
     33407
     33408    [[link boost_asio.reference.basic_datagram_socket.service_type [*service_type]]]
     33409    [The type of the service that will be used to provide I/O operations. ]
     33410 
     33411  ]
     33412
     33413  [
     33414
     33415    [[link boost_asio.reference.basic_datagram_socket.shutdown_type [*shutdown_type]]]
     33416    [Different ways a socket may be shutdown. ]
     33417 
     33418  ]
     33419
     33420]
     33421
     33422[heading Member Functions]
     33423[table
     33424  [[Name][Description]]
     33425
     33426  [
     33427    [[link boost_asio.reference.basic_datagram_socket.assign [*assign]]]
     33428    [Assign an existing native socket to the socket. ]
     33429  ]
     33430 
     33431  [
     33432    [[link boost_asio.reference.basic_datagram_socket.async_connect [*async_connect]]]
     33433    [Start an asynchronous connect. ]
     33434  ]
     33435 
     33436  [
     33437    [[link boost_asio.reference.basic_datagram_socket.async_receive [*async_receive]]]
     33438    [Start an asynchronous receive on a connected socket. ]
     33439  ]
     33440 
     33441  [
     33442    [[link boost_asio.reference.basic_datagram_socket.async_receive_from [*async_receive_from]]]
     33443    [Start an asynchronous receive. ]
     33444  ]
     33445 
     33446  [
     33447    [[link boost_asio.reference.basic_datagram_socket.async_send [*async_send]]]
     33448    [Start an asynchronous send on a connected socket. ]
     33449  ]
     33450 
     33451  [
     33452    [[link boost_asio.reference.basic_datagram_socket.async_send_to [*async_send_to]]]
     33453    [Start an asynchronous send. ]
     33454  ]
     33455 
     33456  [
     33457    [[link boost_asio.reference.basic_datagram_socket.at_mark [*at_mark]]]
     33458    [Determine whether the socket is at the out-of-band data mark. ]
     33459  ]
     33460 
     33461  [
     33462    [[link boost_asio.reference.basic_datagram_socket.available [*available]]]
     33463    [Determine the number of bytes available for reading. ]
     33464  ]
     33465 
     33466  [
     33467    [[link boost_asio.reference.basic_datagram_socket.basic_datagram_socket [*basic_datagram_socket]]]
     33468    [Construct a basic_datagram_socket without opening it. ]
     33469  ]
     33470 
     33471  [
     33472    [[link boost_asio.reference.basic_datagram_socket.bind [*bind]]]
     33473    [Bind the socket to the given local endpoint. ]
     33474  ]
     33475 
     33476  [
     33477    [[link boost_asio.reference.basic_datagram_socket.cancel [*cancel]]]
     33478    [Cancel all asynchronous operations associated with the socket. ]
     33479  ]
     33480 
     33481  [
     33482    [[link boost_asio.reference.basic_datagram_socket.close [*close]]]
     33483    [Close the socket. ]
     33484  ]
     33485 
     33486  [
     33487    [[link boost_asio.reference.basic_datagram_socket.connect [*connect]]]
     33488    [Connect the socket to the specified endpoint. ]
     33489  ]
     33490 
     33491  [
     33492    [[link boost_asio.reference.basic_datagram_socket.get_io_service [*get_io_service]]]
     33493    [Get the io_service associated with the object. ]
     33494  ]
     33495 
     33496  [
     33497    [[link boost_asio.reference.basic_datagram_socket.get_option [*get_option]]]
     33498    [Get an option from the socket. ]
     33499  ]
     33500 
     33501  [
     33502    [[link boost_asio.reference.basic_datagram_socket.io_control [*io_control]]]
     33503    [Perform an IO control command on the socket. ]
     33504  ]
     33505 
     33506  [
     33507    [[link boost_asio.reference.basic_datagram_socket.io_service [*io_service]]]
     33508    [(Deprecated: use get_io_service().) Get the io_service associated with the object. ]
     33509  ]
     33510 
     33511  [
     33512    [[link boost_asio.reference.basic_datagram_socket.is_open [*is_open]]]
     33513    [Determine whether the socket is open. ]
     33514  ]
     33515 
     33516  [
     33517    [[link boost_asio.reference.basic_datagram_socket.local_endpoint [*local_endpoint]]]
     33518    [Get the local endpoint of the socket. ]
     33519  ]
     33520 
     33521  [
     33522    [[link boost_asio.reference.basic_datagram_socket.lowest_layer [*lowest_layer]]]
     33523    [Get a reference to the lowest layer. ]
     33524  ]
     33525 
     33526  [
     33527    [[link boost_asio.reference.basic_datagram_socket.native [*native]]]
     33528    [Get the native socket representation. ]
     33529  ]
     33530 
     33531  [
     33532    [[link boost_asio.reference.basic_datagram_socket.open [*open]]]
     33533    [Open the socket using the specified protocol. ]
     33534  ]
     33535 
     33536  [
     33537    [[link boost_asio.reference.basic_datagram_socket.receive [*receive]]]
     33538    [Receive some data on a connected socket. ]
     33539  ]
     33540 
     33541  [
     33542    [[link boost_asio.reference.basic_datagram_socket.receive_from [*receive_from]]]
     33543    [Receive a datagram with the endpoint of the sender. ]
     33544  ]
     33545 
     33546  [
     33547    [[link boost_asio.reference.basic_datagram_socket.remote_endpoint [*remote_endpoint]]]
     33548    [Get the remote endpoint of the socket. ]
     33549  ]
     33550 
     33551  [
     33552    [[link boost_asio.reference.basic_datagram_socket.send [*send]]]
     33553    [Send some data on a connected socket. ]
     33554  ]
     33555 
     33556  [
     33557    [[link boost_asio.reference.basic_datagram_socket.send_to [*send_to]]]
     33558    [Send a datagram to the specified endpoint. ]
     33559  ]
     33560 
     33561  [
     33562    [[link boost_asio.reference.basic_datagram_socket.set_option [*set_option]]]
     33563    [Set an option on the socket. ]
     33564  ]
     33565 
     33566  [
     33567    [[link boost_asio.reference.basic_datagram_socket.shutdown [*shutdown]]]
     33568    [Disable sends or receives on the socket. ]
     33569  ]
     33570 
     33571]
     33572
     33573[heading Data Members]
     33574[table
     33575  [[Name][Description]]
     33576
     33577  [
     33578    [[link boost_asio.reference.basic_datagram_socket.max_connections [*max_connections]]]
     33579    [The maximum length of the queue of pending incoming connections. ]
     33580  ]
     33581
     33582  [
     33583    [[link boost_asio.reference.basic_datagram_socket.message_do_not_route [*message_do_not_route]]]
     33584    [Specify that the data should not be subject to routing. ]
     33585  ]
     33586
     33587  [
     33588    [[link boost_asio.reference.basic_datagram_socket.message_out_of_band [*message_out_of_band]]]
     33589    [Process out-of-band data. ]
     33590  ]
     33591
     33592  [
     33593    [[link boost_asio.reference.basic_datagram_socket.message_peek [*message_peek]]]
     33594    [Peek at incoming data without removing it from the input queue. ]
     33595  ]
     33596
     33597]
     33598
     33599[heading Protected Data Members]
     33600[table
     33601  [[Name][Description]]
     33602
     33603  [
     33604    [[link boost_asio.reference.basic_datagram_socket.implementation [*implementation]]]
     33605    [The underlying implementation of the I/O object. ]
     33606  ]
     33607
     33608  [
     33609    [[link boost_asio.reference.basic_datagram_socket.service [*service]]]
     33610    [The service associated with the I/O object. ]
     33611  ]
     33612
     33613]
     33614
     33615The basic_datagram_socket class template provides asynchronous and blocking datagram-oriented socket functionality.
     33616
     33617
     33618[heading Thread Safety]
     33619 
     33620[*Distinct] [*objects:]  Safe.
     33621
     33622[*Shared] [*objects:]  Unsafe.
     33623
     33624
     33625
     33626
     33627[endsect]
     33628
     33629
     33630
     33631[section:type local::datagram_protocol::type]
     33632
     33633Obtain an identifier for the type of the protocol.
     33634
     33635  int type() const;
     33636
     33637
     33638
     33639[endsect]
     33640
     33641
     33642
     33643[endsect]
     33644
     33645[section:local__stream_protocol local::stream_protocol]
     33646
     33647Encapsulates the flags needed for stream-oriented UNIX sockets.
     33648
     33649  class stream_protocol
     33650
     33651
     33652[heading Types]
     33653[table
     33654  [[Name][Description]]
     33655
     33656  [
     33657
     33658    [[link boost_asio.reference.local__stream_protocol.acceptor [*acceptor]]]
     33659    [The UNIX domain acceptor type. ]
     33660 
     33661  ]
     33662
     33663  [
     33664
     33665    [[link boost_asio.reference.local__stream_protocol.endpoint [*endpoint]]]
     33666    [The type of a UNIX domain endpoint. ]
     33667 
     33668  ]
     33669
     33670  [
     33671
     33672    [[link boost_asio.reference.local__stream_protocol.iostream [*iostream]]]
     33673    [The UNIX domain iostream type. ]
     33674 
     33675  ]
     33676
     33677  [
     33678
     33679    [[link boost_asio.reference.local__stream_protocol.socket [*socket]]]
     33680    [The UNIX domain socket type. ]
     33681 
     33682  ]
     33683
     33684]
     33685
     33686[heading Member Functions]
     33687[table
     33688  [[Name][Description]]
     33689
     33690  [
     33691    [[link boost_asio.reference.local__stream_protocol.family [*family]]]
     33692    [Obtain an identifier for the protocol family. ]
     33693  ]
     33694 
     33695  [
     33696    [[link boost_asio.reference.local__stream_protocol.protocol [*protocol]]]
     33697    [Obtain an identifier for the protocol. ]
     33698  ]
     33699 
     33700  [
     33701    [[link boost_asio.reference.local__stream_protocol.type [*type]]]
     33702    [Obtain an identifier for the type of the protocol. ]
     33703  ]
     33704 
     33705]
     33706
     33707The
     33708[link boost_asio.reference.local__stream_protocol local::stream_protocol] class contains flags necessary for stream-oriented UNIX domain sockets.
     33709
     33710
     33711[heading Thread Safety]
     33712 
     33713[*Distinct] [*objects:]  Safe.
     33714
     33715[*Shared] [*objects:]  Safe.
     33716
     33717
     33718
     33719[section:acceptor local::stream_protocol::acceptor]
     33720
     33721The UNIX domain acceptor type.
     33722
     33723  typedef basic_socket_acceptor< stream_protocol > acceptor;
     33724
     33725
     33726[heading Types]
     33727[table
     33728  [[Name][Description]]
     33729
     33730  [
     33731
     33732    [[link boost_asio.reference.basic_socket_acceptor.broadcast [*broadcast]]]
     33733    [Socket option to permit sending of broadcast messages. ]
     33734 
     33735  ]
     33736
     33737  [
     33738
     33739    [[link boost_asio.reference.basic_socket_acceptor.bytes_readable [*bytes_readable]]]
     33740    [IO control command to get the amount of data that can be read without blocking. ]
     33741 
     33742  ]
     33743
     33744  [
     33745
     33746    [[link boost_asio.reference.basic_socket_acceptor.debug [*debug]]]
     33747    [Socket option to enable socket-level debugging. ]
     33748 
     33749  ]
     33750
     33751  [
     33752
     33753    [[link boost_asio.reference.basic_socket_acceptor.do_not_route [*do_not_route]]]
     33754    [Socket option to prevent routing, use local interfaces only. ]
     33755 
     33756  ]
     33757
     33758  [
     33759
     33760    [[link boost_asio.reference.basic_socket_acceptor.enable_connection_aborted [*enable_connection_aborted]]]
     33761    [Socket option to report aborted connections on accept. ]
     33762 
     33763  ]
     33764
     33765  [
     33766
     33767    [[link boost_asio.reference.basic_socket_acceptor.endpoint_type [*endpoint_type]]]
     33768    [The endpoint type. ]
     33769 
     33770  ]
     33771
     33772  [
     33773
     33774    [[link boost_asio.reference.basic_socket_acceptor.implementation_type [*implementation_type]]]
     33775    [The underlying implementation type of I/O object. ]
     33776 
     33777  ]
     33778
     33779  [
     33780
     33781    [[link boost_asio.reference.basic_socket_acceptor.keep_alive [*keep_alive]]]
     33782    [Socket option to send keep-alives. ]
     33783 
     33784  ]
     33785
     33786  [
     33787
     33788    [[link boost_asio.reference.basic_socket_acceptor.linger [*linger]]]
     33789    [Socket option to specify whether the socket lingers on close if unsent data is present. ]
     33790 
     33791  ]
     33792
     33793  [
     33794
     33795    [[link boost_asio.reference.basic_socket_acceptor.message_flags [*message_flags]]]
     33796    [Bitmask type for flags that can be passed to send and receive operations. ]
     33797 
     33798  ]
     33799
     33800  [
     33801
     33802    [[link boost_asio.reference.basic_socket_acceptor.native_type [*native_type]]]
     33803    [The native representation of an acceptor. ]
     33804 
     33805  ]
     33806
     33807  [
     33808
     33809    [[link boost_asio.reference.basic_socket_acceptor.non_blocking_io [*non_blocking_io]]]
     33810    [IO control command to set the blocking mode of the socket. ]
     33811 
     33812  ]
     33813
     33814  [
     33815
     33816    [[link boost_asio.reference.basic_socket_acceptor.protocol_type [*protocol_type]]]
     33817    [The protocol type. ]
     33818 
     33819  ]
     33820
     33821  [
     33822
     33823    [[link boost_asio.reference.basic_socket_acceptor.receive_buffer_size [*receive_buffer_size]]]
     33824    [Socket option for the receive buffer size of a socket. ]
     33825 
     33826  ]
     33827
     33828  [
     33829
     33830    [[link boost_asio.reference.basic_socket_acceptor.receive_low_watermark [*receive_low_watermark]]]
     33831    [Socket option for the receive low watermark. ]
     33832 
     33833  ]
     33834
     33835  [
     33836
     33837    [[link boost_asio.reference.basic_socket_acceptor.reuse_address [*reuse_address]]]
     33838    [Socket option to allow the socket to be bound to an address that is already in use. ]
     33839 
     33840  ]
     33841
     33842  [
     33843
     33844    [[link boost_asio.reference.basic_socket_acceptor.send_buffer_size [*send_buffer_size]]]
     33845    [Socket option for the send buffer size of a socket. ]
     33846 
     33847  ]
     33848
     33849  [
     33850
     33851    [[link boost_asio.reference.basic_socket_acceptor.send_low_watermark [*send_low_watermark]]]
     33852    [Socket option for the send low watermark. ]
     33853 
     33854  ]
     33855
     33856  [
     33857
     33858    [[link boost_asio.reference.basic_socket_acceptor.service_type [*service_type]]]
     33859    [The type of the service that will be used to provide I/O operations. ]
     33860 
     33861  ]
     33862
     33863  [
     33864
     33865    [[link boost_asio.reference.basic_socket_acceptor.shutdown_type [*shutdown_type]]]
     33866    [Different ways a socket may be shutdown. ]
     33867 
     33868  ]
     33869
     33870]
     33871
     33872[heading Member Functions]
     33873[table
     33874  [[Name][Description]]
     33875
     33876  [
     33877    [[link boost_asio.reference.basic_socket_acceptor.accept [*accept]]]
     33878    [Accept a new connection. ]
     33879  ]
     33880 
     33881  [
     33882    [[link boost_asio.reference.basic_socket_acceptor.assign [*assign]]]
     33883    [Assigns an existing native acceptor to the acceptor. ]
     33884  ]
     33885 
     33886  [
     33887    [[link boost_asio.reference.basic_socket_acceptor.async_accept [*async_accept]]]
     33888    [Start an asynchronous accept. ]
     33889  ]
     33890 
     33891  [
     33892    [[link boost_asio.reference.basic_socket_acceptor.basic_socket_acceptor [*basic_socket_acceptor]]]
     33893    [Construct an acceptor without opening it. ]
     33894  ]
     33895 
     33896  [
     33897    [[link boost_asio.reference.basic_socket_acceptor.bind [*bind]]]
     33898    [Bind the acceptor to the given local endpoint. ]
     33899  ]
     33900 
     33901  [
     33902    [[link boost_asio.reference.basic_socket_acceptor.cancel [*cancel]]]
     33903    [Cancel all asynchronous operations associated with the acceptor. ]
     33904  ]
     33905 
     33906  [
     33907    [[link boost_asio.reference.basic_socket_acceptor.close [*close]]]
     33908    [Close the acceptor. ]
     33909  ]
     33910 
     33911  [
     33912    [[link boost_asio.reference.basic_socket_acceptor.get_io_service [*get_io_service]]]
     33913    [Get the io_service associated with the object. ]
     33914  ]
     33915 
     33916  [
     33917    [[link boost_asio.reference.basic_socket_acceptor.get_option [*get_option]]]
     33918    [Get an option from the acceptor. ]
     33919  ]
     33920 
     33921  [
     33922    [[link boost_asio.reference.basic_socket_acceptor.io_service [*io_service]]]
     33923    [(Deprecated: use get_io_service().) Get the io_service associated with the object. ]
     33924  ]
     33925 
     33926  [
     33927    [[link boost_asio.reference.basic_socket_acceptor.is_open [*is_open]]]
     33928    [Determine whether the acceptor is open. ]
     33929  ]
     33930 
     33931  [
     33932    [[link boost_asio.reference.basic_socket_acceptor.listen [*listen]]]
     33933    [Place the acceptor into the state where it will listen for new connections. ]
     33934  ]
     33935 
     33936  [
     33937    [[link boost_asio.reference.basic_socket_acceptor.local_endpoint [*local_endpoint]]]
     33938    [Get the local endpoint of the acceptor. ]
     33939  ]
     33940 
     33941  [
     33942    [[link boost_asio.reference.basic_socket_acceptor.native [*native]]]
     33943    [Get the native acceptor representation. ]
     33944  ]
     33945 
     33946  [
     33947    [[link boost_asio.reference.basic_socket_acceptor.open [*open]]]
     33948    [Open the acceptor using the specified protocol. ]
     33949  ]
     33950 
     33951  [
     33952    [[link boost_asio.reference.basic_socket_acceptor.set_option [*set_option]]]
     33953    [Set an option on the acceptor. ]
     33954  ]
     33955 
     33956]
     33957
     33958[heading Data Members]
     33959[table
     33960  [[Name][Description]]
     33961
     33962  [
     33963    [[link boost_asio.reference.basic_socket_acceptor.max_connections [*max_connections]]]
     33964    [The maximum length of the queue of pending incoming connections. ]
     33965  ]
     33966
     33967  [
     33968    [[link boost_asio.reference.basic_socket_acceptor.message_do_not_route [*message_do_not_route]]]
     33969    [Specify that the data should not be subject to routing. ]
     33970  ]
     33971
     33972  [
     33973    [[link boost_asio.reference.basic_socket_acceptor.message_out_of_band [*message_out_of_band]]]
     33974    [Process out-of-band data. ]
     33975  ]
     33976
     33977  [
     33978    [[link boost_asio.reference.basic_socket_acceptor.message_peek [*message_peek]]]
     33979    [Peek at incoming data without removing it from the input queue. ]
     33980  ]
     33981
     33982]
     33983
     33984[heading Protected Data Members]
     33985[table
     33986  [[Name][Description]]
     33987
     33988  [
     33989    [[link boost_asio.reference.basic_socket_acceptor.implementation [*implementation]]]
     33990    [The underlying implementation of the I/O object. ]
     33991  ]
     33992
     33993  [
     33994    [[link boost_asio.reference.basic_socket_acceptor.service [*service]]]
     33995    [The service associated with the I/O object. ]
     33996  ]
     33997
     33998]
     33999
     34000The basic_socket_acceptor class template is used for accepting new socket connections.
     34001
     34002
     34003[heading Thread Safety]
     34004 
     34005[*Distinct] [*objects:]  Safe.
     34006
     34007[*Shared] [*objects:]  Unsafe.
     34008
     34009[heading Example]
     34010 
     34011Opening a socket acceptor with the SO\_REUSEADDR option enabled:
     34012
     34013   boost::asio::ip::tcp::acceptor acceptor(io_service);
     34014   boost::asio::ip::tcp::endpoint endpoint(boost::asio::ip::tcp::v4(), port);
     34015   acceptor.open(endpoint.protocol());
     34016   acceptor.set_option(boost::asio::ip::tcp::acceptor::reuse_address(true));
     34017   acceptor.bind(endpoint);
     34018   acceptor.listen();
     34019
     34020
     34021
     34022
     34023
     34024
     34025
     34026[endsect]
     34027
     34028
     34029
     34030[section:endpoint local::stream_protocol::endpoint]
     34031
     34032The type of a UNIX domain endpoint.
     34033
     34034  typedef basic_endpoint< stream_protocol > endpoint;
     34035
     34036
     34037[heading Types]
     34038[table
     34039  [[Name][Description]]
     34040
     34041  [
     34042
     34043    [[link boost_asio.reference.local__basic_endpoint.data_type [*data_type]]]
     34044    [The type of the endpoint structure. This type is dependent on the underlying implementation of the socket layer. ]
     34045 
     34046  ]
     34047
     34048  [
     34049
     34050    [[link boost_asio.reference.local__basic_endpoint.protocol_type [*protocol_type]]]
     34051    [The protocol type associated with the endpoint. ]
     34052 
     34053  ]
     34054
     34055]
     34056
     34057[heading Member Functions]
     34058[table
     34059  [[Name][Description]]
     34060
     34061  [
     34062    [[link boost_asio.reference.local__basic_endpoint.basic_endpoint [*basic_endpoint]]]
     34063    [Default constructor. ]
     34064  ]
     34065 
     34066  [
     34067    [[link boost_asio.reference.local__basic_endpoint.capacity [*capacity]]]
     34068    [Get the capacity of the endpoint in the native type. ]
     34069  ]
     34070 
     34071  [
     34072    [[link boost_asio.reference.local__basic_endpoint.data [*data]]]
     34073    [Get the underlying endpoint in the native type. ]
     34074  ]
     34075 
     34076  [
     34077    [[link boost_asio.reference.local__basic_endpoint.operator_eq_ [*operator=]]]
     34078    [Assign from another endpoint. ]
     34079  ]
     34080 
     34081  [
     34082    [[link boost_asio.reference.local__basic_endpoint.path [*path]]]
     34083    [Get the path associated with the endpoint. ]
     34084  ]
     34085 
     34086  [
     34087    [[link boost_asio.reference.local__basic_endpoint.protocol [*protocol]]]
     34088    [The protocol associated with the endpoint. ]
     34089  ]
     34090 
     34091  [
     34092    [[link boost_asio.reference.local__basic_endpoint.resize [*resize]]]
     34093    [Set the underlying size of the endpoint in the native type. ]
     34094  ]
     34095 
     34096  [
     34097    [[link boost_asio.reference.local__basic_endpoint.size [*size]]]
     34098    [Get the underlying size of the endpoint in the native type. ]
     34099  ]
     34100 
     34101]
     34102
     34103[heading Friends]
     34104[table
     34105  [[Name][Description]]
     34106
     34107  [
     34108    [[link boost_asio.reference.local__basic_endpoint.operator_not__eq_ [*operator!=]]]
     34109    [Compare two endpoints for inequality. ]
     34110  ]
     34111 
     34112  [
     34113    [[link boost_asio.reference.local__basic_endpoint.operator_lt_ [*operator<]]]
     34114    [Compare endpoints for ordering. ]
     34115  ]
     34116 
     34117  [
     34118    [[link boost_asio.reference.local__basic_endpoint.operator_eq__eq_ [*operator==]]]
     34119    [Compare two endpoints for equality. ]
     34120  ]
     34121 
     34122]
     34123
     34124[heading Related Functions]
     34125[table
     34126  [[Name][Description]]
     34127
     34128  [
     34129    [[link boost_asio.reference.local__basic_endpoint.operator_lt__lt_ [*operator<<]]]
     34130    [Output an endpoint as a string. ]
     34131  ]
     34132 
     34133]
     34134
     34135The
     34136[link boost_asio.reference.local__basic_endpoint local::basic_endpoint] class template describes an endpoint that may be associated with a particular UNIX socket.
     34137
     34138
     34139[heading Thread Safety]
     34140 
     34141[*Distinct] [*objects:]  Safe.
     34142
     34143[*Shared] [*objects:]  Unsafe.
     34144
     34145
     34146
     34147
     34148[endsect]
     34149
     34150
     34151
     34152[section:family local::stream_protocol::family]
     34153
     34154Obtain an identifier for the protocol family.
     34155
     34156  int family() const;
     34157
     34158
     34159
     34160[endsect]
     34161
     34162
     34163
     34164[section:iostream local::stream_protocol::iostream]
     34165
     34166The UNIX domain iostream type.
     34167
     34168  typedef basic_socket_iostream< stream_protocol > iostream;
     34169
     34170
     34171[heading Member Functions]
     34172[table
     34173  [[Name][Description]]
     34174
     34175  [
     34176    [[link boost_asio.reference.basic_socket_iostream.basic_socket_iostream [*basic_socket_iostream]]]
     34177    [Construct a basic_socket_iostream without establishing a connection. ]
     34178  ]
     34179 
     34180  [
     34181    [[link boost_asio.reference.basic_socket_iostream.close [*close]]]
     34182    [Close the connection. ]
     34183  ]
     34184 
     34185  [
     34186    [[link boost_asio.reference.basic_socket_iostream.connect [*connect]]]
     34187    [Establish a connection to an endpoint corresponding to a resolver query. ]
     34188  ]
     34189 
     34190  [
     34191    [[link boost_asio.reference.basic_socket_iostream.rdbuf [*rdbuf]]]
     34192    [Return a pointer to the underlying streambuf. ]
     34193  ]
     34194 
     34195]
     34196
     34197
     34198
     34199[endsect]
     34200
     34201
     34202
     34203[section:protocol local::stream_protocol::protocol]
     34204
     34205Obtain an identifier for the protocol.
     34206
     34207  int protocol() const;
     34208
     34209
     34210
     34211[endsect]
     34212
     34213
     34214
     34215[section:socket local::stream_protocol::socket]
     34216
     34217The UNIX domain socket type.
     34218
     34219  typedef basic_stream_socket< stream_protocol > socket;
     34220
     34221
     34222[heading Types]
     34223[table
     34224  [[Name][Description]]
     34225
     34226  [
     34227
     34228    [[link boost_asio.reference.basic_stream_socket.broadcast [*broadcast]]]
     34229    [Socket option to permit sending of broadcast messages. ]
     34230 
     34231  ]
     34232
     34233  [
     34234
     34235    [[link boost_asio.reference.basic_stream_socket.bytes_readable [*bytes_readable]]]
     34236    [IO control command to get the amount of data that can be read without blocking. ]
     34237 
     34238  ]
     34239
     34240  [
     34241
     34242    [[link boost_asio.reference.basic_stream_socket.debug [*debug]]]
     34243    [Socket option to enable socket-level debugging. ]
     34244 
     34245  ]
     34246
     34247  [
     34248
     34249    [[link boost_asio.reference.basic_stream_socket.do_not_route [*do_not_route]]]
     34250    [Socket option to prevent routing, use local interfaces only. ]
     34251 
     34252  ]
     34253
     34254  [
     34255
     34256    [[link boost_asio.reference.basic_stream_socket.enable_connection_aborted [*enable_connection_aborted]]]
     34257    [Socket option to report aborted connections on accept. ]
     34258 
     34259  ]
     34260
     34261  [
     34262
     34263    [[link boost_asio.reference.basic_stream_socket.endpoint_type [*endpoint_type]]]
     34264    [The endpoint type. ]
     34265 
     34266  ]
     34267
     34268  [
     34269
     34270    [[link boost_asio.reference.basic_stream_socket.implementation_type [*implementation_type]]]
     34271    [The underlying implementation type of I/O object. ]
     34272 
     34273  ]
     34274
     34275  [
     34276
     34277    [[link boost_asio.reference.basic_stream_socket.keep_alive [*keep_alive]]]
     34278    [Socket option to send keep-alives. ]
     34279 
     34280  ]
     34281
     34282  [
     34283
     34284    [[link boost_asio.reference.basic_stream_socket.linger [*linger]]]
     34285    [Socket option to specify whether the socket lingers on close if unsent data is present. ]
     34286 
     34287  ]
     34288
     34289  [
     34290
     34291    [[link boost_asio.reference.basic_stream_socket.lowest_layer_type [*lowest_layer_type]]]
     34292    [A basic_socket is always the lowest layer. ]
     34293 
     34294  ]
     34295
     34296  [
     34297
     34298    [[link boost_asio.reference.basic_stream_socket.message_flags [*message_flags]]]
     34299    [Bitmask type for flags that can be passed to send and receive operations. ]
     34300 
     34301  ]
     34302
     34303  [
     34304
     34305    [[link boost_asio.reference.basic_stream_socket.native_type [*native_type]]]
     34306    [The native representation of a socket. ]
     34307 
     34308  ]
     34309
     34310  [
     34311
     34312    [[link boost_asio.reference.basic_stream_socket.non_blocking_io [*non_blocking_io]]]
     34313    [IO control command to set the blocking mode of the socket. ]
     34314 
     34315  ]
     34316
     34317  [
     34318
     34319    [[link boost_asio.reference.basic_stream_socket.protocol_type [*protocol_type]]]
     34320    [The protocol type. ]
     34321 
     34322  ]
     34323
     34324  [
     34325
     34326    [[link boost_asio.reference.basic_stream_socket.receive_buffer_size [*receive_buffer_size]]]
     34327    [Socket option for the receive buffer size of a socket. ]
     34328 
     34329  ]
     34330
     34331  [
     34332
     34333    [[link boost_asio.reference.basic_stream_socket.receive_low_watermark [*receive_low_watermark]]]
     34334    [Socket option for the receive low watermark. ]
     34335 
     34336  ]
     34337
     34338  [
     34339
     34340    [[link boost_asio.reference.basic_stream_socket.reuse_address [*reuse_address]]]
     34341    [Socket option to allow the socket to be bound to an address that is already in use. ]
     34342 
     34343  ]
     34344
     34345  [
     34346
     34347    [[link boost_asio.reference.basic_stream_socket.send_buffer_size [*send_buffer_size]]]
     34348    [Socket option for the send buffer size of a socket. ]
     34349 
     34350  ]
     34351
     34352  [
     34353
     34354    [[link boost_asio.reference.basic_stream_socket.send_low_watermark [*send_low_watermark]]]
     34355    [Socket option for the send low watermark. ]
     34356 
     34357  ]
     34358
     34359  [
     34360
     34361    [[link boost_asio.reference.basic_stream_socket.service_type [*service_type]]]
     34362    [The type of the service that will be used to provide I/O operations. ]
     34363 
     34364  ]
     34365
     34366  [
     34367
     34368    [[link boost_asio.reference.basic_stream_socket.shutdown_type [*shutdown_type]]]
     34369    [Different ways a socket may be shutdown. ]
     34370 
     34371  ]
     34372
     34373]
     34374
     34375[heading Member Functions]
     34376[table
     34377  [[Name][Description]]
     34378
     34379  [
     34380    [[link boost_asio.reference.basic_stream_socket.assign [*assign]]]
     34381    [Assign an existing native socket to the socket. ]
     34382  ]
     34383 
     34384  [
     34385    [[link boost_asio.reference.basic_stream_socket.async_connect [*async_connect]]]
     34386    [Start an asynchronous connect. ]
     34387  ]
     34388 
     34389  [
     34390    [[link boost_asio.reference.basic_stream_socket.async_read_some [*async_read_some]]]
     34391    [Start an asynchronous read. ]
     34392  ]
     34393 
     34394  [
     34395    [[link boost_asio.reference.basic_stream_socket.async_receive [*async_receive]]]
     34396    [Start an asynchronous receive. ]
     34397  ]
     34398 
     34399  [
     34400    [[link boost_asio.reference.basic_stream_socket.async_send [*async_send]]]
     34401    [Start an asynchronous send. ]
     34402  ]
     34403 
     34404  [
     34405    [[link boost_asio.reference.basic_stream_socket.async_write_some [*async_write_some]]]
     34406    [Start an asynchronous write. ]
     34407  ]
     34408 
     34409  [
     34410    [[link boost_asio.reference.basic_stream_socket.at_mark [*at_mark]]]
     34411    [Determine whether the socket is at the out-of-band data mark. ]
     34412  ]
     34413 
     34414  [
     34415    [[link boost_asio.reference.basic_stream_socket.available [*available]]]
     34416    [Determine the number of bytes available for reading. ]
     34417  ]
     34418 
     34419  [
     34420    [[link boost_asio.reference.basic_stream_socket.basic_stream_socket [*basic_stream_socket]]]
     34421    [Construct a basic_stream_socket without opening it. ]
     34422  ]
     34423 
     34424  [
     34425    [[link boost_asio.reference.basic_stream_socket.bind [*bind]]]
     34426    [Bind the socket to the given local endpoint. ]
     34427  ]
     34428 
     34429  [
     34430    [[link boost_asio.reference.basic_stream_socket.cancel [*cancel]]]
     34431    [Cancel all asynchronous operations associated with the socket. ]
     34432  ]
     34433 
     34434  [
     34435    [[link boost_asio.reference.basic_stream_socket.close [*close]]]
     34436    [Close the socket. ]
     34437  ]
     34438 
     34439  [
     34440    [[link boost_asio.reference.basic_stream_socket.connect [*connect]]]
     34441    [Connect the socket to the specified endpoint. ]
     34442  ]
     34443 
     34444  [
     34445    [[link boost_asio.reference.basic_stream_socket.get_io_service [*get_io_service]]]
     34446    [Get the io_service associated with the object. ]
     34447  ]
     34448 
     34449  [
     34450    [[link boost_asio.reference.basic_stream_socket.get_option [*get_option]]]
     34451    [Get an option from the socket. ]
     34452  ]
     34453 
     34454  [
     34455    [[link boost_asio.reference.basic_stream_socket.io_control [*io_control]]]
     34456    [Perform an IO control command on the socket. ]
     34457  ]
     34458 
     34459  [
     34460    [[link boost_asio.reference.basic_stream_socket.io_service [*io_service]]]
     34461    [(Deprecated: use get_io_service().) Get the io_service associated with the object. ]
     34462  ]
     34463 
     34464  [
     34465    [[link boost_asio.reference.basic_stream_socket.is_open [*is_open]]]
     34466    [Determine whether the socket is open. ]
     34467  ]
     34468 
     34469  [
     34470    [[link boost_asio.reference.basic_stream_socket.local_endpoint [*local_endpoint]]]
     34471    [Get the local endpoint of the socket. ]
     34472  ]
     34473 
     34474  [
     34475    [[link boost_asio.reference.basic_stream_socket.lowest_layer [*lowest_layer]]]
     34476    [Get a reference to the lowest layer. ]
     34477  ]
     34478 
     34479  [
     34480    [[link boost_asio.reference.basic_stream_socket.native [*native]]]
     34481    [Get the native socket representation. ]
     34482  ]
     34483 
     34484  [
     34485    [[link boost_asio.reference.basic_stream_socket.open [*open]]]
     34486    [Open the socket using the specified protocol. ]
     34487  ]
     34488 
     34489  [
     34490    [[link boost_asio.reference.basic_stream_socket.read_some [*read_some]]]
     34491    [Read some data from the socket. ]
     34492  ]
     34493 
     34494  [
     34495    [[link boost_asio.reference.basic_stream_socket.receive [*receive]]]
     34496    [Receive some data on the socket. ]
     34497  ]
     34498 
     34499  [
     34500    [[link boost_asio.reference.basic_stream_socket.remote_endpoint [*remote_endpoint]]]
     34501    [Get the remote endpoint of the socket. ]
     34502  ]
     34503 
     34504  [
     34505    [[link boost_asio.reference.basic_stream_socket.send [*send]]]
     34506    [Send some data on the socket. ]
     34507  ]
     34508 
     34509  [
     34510    [[link boost_asio.reference.basic_stream_socket.set_option [*set_option]]]
     34511    [Set an option on the socket. ]
     34512  ]
     34513 
     34514  [
     34515    [[link boost_asio.reference.basic_stream_socket.shutdown [*shutdown]]]
     34516    [Disable sends or receives on the socket. ]
     34517  ]
     34518 
     34519  [
     34520    [[link boost_asio.reference.basic_stream_socket.write_some [*write_some]]]
     34521    [Write some data to the socket. ]
     34522  ]
     34523 
     34524]
     34525
     34526[heading Data Members]
     34527[table
     34528  [[Name][Description]]
     34529
     34530  [
     34531    [[link boost_asio.reference.basic_stream_socket.max_connections [*max_connections]]]
     34532    [The maximum length of the queue of pending incoming connections. ]
     34533  ]
     34534
     34535  [
     34536    [[link boost_asio.reference.basic_stream_socket.message_do_not_route [*message_do_not_route]]]
     34537    [Specify that the data should not be subject to routing. ]
     34538  ]
     34539
     34540  [
     34541    [[link boost_asio.reference.basic_stream_socket.message_out_of_band [*message_out_of_band]]]
     34542    [Process out-of-band data. ]
     34543  ]
     34544
     34545  [
     34546    [[link boost_asio.reference.basic_stream_socket.message_peek [*message_peek]]]
     34547    [Peek at incoming data without removing it from the input queue. ]
     34548  ]
     34549
     34550]
     34551
     34552[heading Protected Data Members]
     34553[table
     34554  [[Name][Description]]
     34555
     34556  [
     34557    [[link boost_asio.reference.basic_stream_socket.implementation [*implementation]]]
     34558    [The underlying implementation of the I/O object. ]
     34559  ]
     34560
     34561  [
     34562    [[link boost_asio.reference.basic_stream_socket.service [*service]]]
     34563    [The service associated with the I/O object. ]
     34564  ]
     34565
     34566]
     34567
     34568The basic_stream_socket class template provides asynchronous and blocking stream-oriented socket functionality.
     34569
     34570
     34571[heading Thread Safety]
     34572 
     34573[*Distinct] [*objects:]  Safe.
     34574
     34575[*Shared] [*objects:]  Unsafe.
     34576
     34577
     34578
     34579
     34580[endsect]
     34581
     34582
     34583
     34584[section:type local::stream_protocol::type]
     34585
     34586Obtain an identifier for the type of the protocol.
     34587
     34588  int type() const;
     34589
     34590
     34591
     34592[endsect]
     34593
     34594
     34595
     34596[endsect]
     34597
     34598[section:mutable_buffer mutable_buffer]
     34599
     34600Holds a buffer that can be modified.
     34601
     34602  class mutable_buffer
     34603
     34604
     34605[heading Member Functions]
     34606[table
     34607  [[Name][Description]]
     34608
     34609  [
     34610    [[link boost_asio.reference.mutable_buffer.mutable_buffer [*mutable_buffer]]]
     34611    [Construct an empty buffer. ]
     34612  ]
     34613 
     34614]
     34615
     34616[heading Related Functions]
     34617[table
     34618  [[Name][Description]]
     34619
     34620  [
     34621    [[link boost_asio.reference.mutable_buffer.buffer_cast [*buffer_cast]]]
     34622    [Cast a non-modifiable buffer to a specified pointer to POD type. ]
     34623  ]
     34624 
     34625  [
     34626    [[link boost_asio.reference.mutable_buffer.buffer_size [*buffer_size]]]
     34627    [Get the number of bytes in a non-modifiable buffer. ]
     34628  ]
     34629 
     34630  [
     34631    [[link boost_asio.reference.mutable_buffer.operator_plus_ [*operator+]]]
     34632    [Create a new modifiable buffer that is offset from the start of another. ]
    3136034633  ]
    3136134634 
     
    3136534638
    3136634639
    31367 [section:buffer_cast_helper mutable_buffer::buffer_cast_helper]
    31368 
    31369 
    31370 
    31371   friend void * buffer_cast_helper(
     34640[section:buffer_cast mutable_buffer::buffer_cast]
     34641
     34642Cast a non-modifiable buffer to a specified pointer to POD type.
     34643
     34644  template<
     34645      typename ``[link boost_asio.reference.PointerToPodType PointerToPodType]``>
     34646  PointerToPodType buffer_cast(
    3137234647      const mutable_buffer & b);
    3137334648
     
    3137834653
    3137934654
    31380 [section:buffer_size_helper mutable_buffer::buffer_size_helper]
    31381 
    31382 
    31383 
    31384   friend std::size_t buffer_size_helper(
     34655[section:buffer_size mutable_buffer::buffer_size]
     34656
     34657Get the number of bytes in a non-modifiable buffer.
     34658
     34659  std::size_t buffer_size(
    3138534660      const mutable_buffer & b);
    3138634661
     
    3142834703[endsect]
    3142934704
     34705[section:operator_plus_ mutable_buffer::operator+]
     34706
     34707Create a new modifiable buffer that is offset from the start of another.
     34708
     34709  mutable_buffer ``[link boost_asio.reference.mutable_buffer.operator_plus_.overload1 operator+]``(
     34710      const mutable_buffer & b,
     34711      std::size_t start);
     34712
     34713  mutable_buffer ``[link boost_asio.reference.mutable_buffer.operator_plus_.overload2 operator+]``(
     34714      std::size_t start,
     34715      const mutable_buffer & b);
     34716
     34717
     34718[section:overload1 mutable_buffer::operator+ (1 of 2 overloads)]
     34719
     34720Create a new modifiable buffer that is offset from the start of another.
     34721
     34722  mutable_buffer operator+(
     34723      const mutable_buffer & b,
     34724      std::size_t start);
     34725
     34726
     34727
     34728[endsect]
     34729
     34730
     34731
     34732[section:overload2 mutable_buffer::operator+ (2 of 2 overloads)]
     34733
     34734Create a new modifiable buffer that is offset from the start of another.
     34735
     34736  mutable_buffer operator+(
     34737      std::size_t start,
     34738      const mutable_buffer & b);
     34739
     34740
     34741
     34742[endsect]
     34743
     34744
     34745[endsect]
     34746
    3143034747
    3143134748[endsect]
     
    3148034797]
    3148134798
     34799[heading Related Functions]
     34800[table
     34801  [[Name][Description]]
     34802
     34803  [
     34804    [[link boost_asio.reference.mutable_buffers_1.buffer_cast [*buffer_cast]]]
     34805    [Cast a non-modifiable buffer to a specified pointer to POD type. ]
     34806  ]
     34807 
     34808  [
     34809    [[link boost_asio.reference.mutable_buffers_1.buffer_size [*buffer_size]]]
     34810    [Get the number of bytes in a non-modifiable buffer. ]
     34811  ]
     34812 
     34813  [
     34814    [[link boost_asio.reference.mutable_buffers_1.operator_plus_ [*operator+]]]
     34815    [Create a new modifiable buffer that is offset from the start of another. ]
     34816  ]
     34817 
     34818]
     34819
    3148234820
    3148334821[section:begin mutable_buffers_1::begin]
     
    3148634824
    3148734825  const_iterator begin() const;
     34826
     34827
     34828
     34829[endsect]
     34830
     34831
     34832
     34833[section:buffer_cast mutable_buffers_1::buffer_cast]
     34834
     34835
     34836['Inherited from mutable_buffer.]
     34837
     34838Cast a non-modifiable buffer to a specified pointer to POD type.
     34839
     34840  template<
     34841      typename ``[link boost_asio.reference.PointerToPodType PointerToPodType]``>
     34842  PointerToPodType buffer_cast(
     34843      const mutable_buffer & b);
     34844
     34845
     34846
     34847[endsect]
     34848
     34849
     34850
     34851[section:buffer_size mutable_buffers_1::buffer_size]
     34852
     34853
     34854['Inherited from mutable_buffer.]
     34855
     34856Get the number of bytes in a non-modifiable buffer.
     34857
     34858  std::size_t buffer_size(
     34859      const mutable_buffer & b);
    3148834860
    3148934861
     
    3152934901[endsect]
    3153034902
     34903
     34904[section:operator_plus_ mutable_buffers_1::operator+]
     34905
     34906Create a new modifiable buffer that is offset from the start of another.
     34907
     34908  mutable_buffer ``[link boost_asio.reference.mutable_buffers_1.operator_plus_.overload1 operator+]``(
     34909      const mutable_buffer & b,
     34910      std::size_t start);
     34911
     34912  mutable_buffer ``[link boost_asio.reference.mutable_buffers_1.operator_plus_.overload2 operator+]``(
     34913      std::size_t start,
     34914      const mutable_buffer & b);
     34915
     34916
     34917[section:overload1 mutable_buffers_1::operator+ (1 of 2 overloads)]
     34918
     34919
     34920['Inherited from mutable_buffer.]
     34921
     34922Create a new modifiable buffer that is offset from the start of another.
     34923
     34924  mutable_buffer operator+(
     34925      const mutable_buffer & b,
     34926      std::size_t start);
     34927
     34928
     34929
     34930[endsect]
     34931
     34932
     34933
     34934[section:overload2 mutable_buffers_1::operator+ (2 of 2 overloads)]
     34935
     34936
     34937['Inherited from mutable_buffer.]
     34938
     34939Create a new modifiable buffer that is offset from the start of another.
     34940
     34941  mutable_buffer operator+(
     34942      std::size_t start,
     34943      const mutable_buffer & b);
     34944
     34945
     34946
     34947[endsect]
     34948
     34949
     34950[endsect]
    3153134951
    3153234952
     
    3154934969]
    3155034970
    31551 [heading Friends]
     34971[heading Related Functions]
    3155234972[table
    3155334973  [[Name][Description]]
    3155434974
    3155534975  [
    31556     [[link boost_asio.reference.mutable_buffer.buffer_cast_helper [*buffer_cast_helper]]]
    31557     []
    31558   ]
    31559  
    31560   [
    31561     [[link boost_asio.reference.mutable_buffer.buffer_size_helper [*buffer_size_helper]]]
    31562     []
     34976    [[link boost_asio.reference.mutable_buffer.buffer_cast [*buffer_cast]]]
     34977    [Cast a non-modifiable buffer to a specified pointer to POD type. ]
     34978  ]
     34979 
     34980  [
     34981    [[link boost_asio.reference.mutable_buffer.buffer_size [*buffer_size]]]
     34982    [Get the number of bytes in a non-modifiable buffer. ]
     34983  ]
     34984 
     34985  [
     34986    [[link boost_asio.reference.mutable_buffer.operator_plus_ [*operator+]]]
     34987    [Create a new modifiable buffer that is offset from the start of another. ]
    3156334988  ]
    3156434989 
     
    3157535000[endsect]
    3157635001
     35002[section:null_buffers null_buffers]
     35003
     35004An implementation of both the ConstBufferSequence and MutableBufferSequence concepts to represent a null buffer sequence.
     35005
     35006  class null_buffers
     35007
     35008
     35009[heading Types]
     35010[table
     35011  [[Name][Description]]
     35012
     35013  [
     35014
     35015    [[link boost_asio.reference.null_buffers.const_iterator [*const_iterator]]]
     35016    [A random-access iterator type that may be used to read elements. ]
     35017 
     35018  ]
     35019
     35020  [
     35021
     35022    [[link boost_asio.reference.null_buffers.value_type [*value_type]]]
     35023    [The type for each element in the list of buffers. ]
     35024 
     35025  ]
     35026
     35027]
     35028
     35029[heading Member Functions]
     35030[table
     35031  [[Name][Description]]
     35032
     35033  [
     35034    [[link boost_asio.reference.null_buffers.begin [*begin]]]
     35035    [Get a random-access iterator to the first element. ]
     35036  ]
     35037 
     35038  [
     35039    [[link boost_asio.reference.null_buffers.end [*end]]]
     35040    [Get a random-access iterator for one past the last element. ]
     35041  ]
     35042 
     35043]
     35044
     35045
     35046[section:begin null_buffers::begin]
     35047
     35048Get a random-access iterator to the first element.
     35049
     35050  const_iterator begin() const;
     35051
     35052
     35053
     35054[endsect]
     35055
     35056
     35057
     35058[section:const_iterator null_buffers::const_iterator]
     35059
     35060A random-access iterator type that may be used to read elements.
     35061
     35062  typedef const mutable_buffer * const_iterator;
     35063
     35064
     35065
     35066
     35067[endsect]
     35068
     35069
     35070
     35071[section:end null_buffers::end]
     35072
     35073Get a random-access iterator for one past the last element.
     35074
     35075  const_iterator end() const;
     35076
     35077
     35078
     35079[endsect]
     35080
     35081
     35082
     35083[section:value_type null_buffers::value_type]
     35084
     35085The type for each element in the list of buffers.
     35086
     35087  typedef mutable_buffer value_type;
     35088
     35089
     35090[heading Member Functions]
     35091[table
     35092  [[Name][Description]]
     35093
     35094  [
     35095    [[link boost_asio.reference.mutable_buffer.mutable_buffer [*mutable_buffer]]]
     35096    [Construct an empty buffer. ]
     35097  ]
     35098 
     35099]
     35100
     35101[heading Related Functions]
     35102[table
     35103  [[Name][Description]]
     35104
     35105  [
     35106    [[link boost_asio.reference.mutable_buffer.buffer_cast [*buffer_cast]]]
     35107    [Cast a non-modifiable buffer to a specified pointer to POD type. ]
     35108  ]
     35109 
     35110  [
     35111    [[link boost_asio.reference.mutable_buffer.buffer_size [*buffer_size]]]
     35112    [Get the number of bytes in a non-modifiable buffer. ]
     35113  ]
     35114 
     35115  [
     35116    [[link boost_asio.reference.mutable_buffer.operator_plus_ [*operator+]]]
     35117    [Create a new modifiable buffer that is offset from the start of another. ]
     35118  ]
     35119 
     35120]
     35121
     35122The mutable_buffer class provides a safe representation of a buffer that can be modified. It does not own the underlying data, and so is cheap to copy or assign.
     35123
     35124
     35125
     35126[endsect]
     35127
     35128
     35129
     35130[endsect]
     35131
    3157735132
    3157835133[section:placeholders__bytes_transferred placeholders::bytes_transferred]
     
    3161035165[endsect]
    3161135166
     35167
     35168[section:posix__basic_descriptor posix::basic_descriptor]
     35169
     35170Provides POSIX descriptor functionality.
     35171
     35172  template<
     35173      typename ``[link boost_asio.reference.DescriptorService DescriptorService]``>
     35174  class basic_descriptor :
     35175    public basic_io_object< DescriptorService >,
     35176    public posix::descriptor_base
     35177
     35178
     35179[heading Types]
     35180[table
     35181  [[Name][Description]]
     35182
     35183  [
     35184
     35185    [[link boost_asio.reference.posix__basic_descriptor.bytes_readable [*bytes_readable]]]
     35186    [IO control command to get the amount of data that can be read without blocking. ]
     35187 
     35188  ]
     35189
     35190  [
     35191
     35192    [[link boost_asio.reference.posix__basic_descriptor.implementation_type [*implementation_type]]]
     35193    [The underlying implementation type of I/O object. ]
     35194 
     35195  ]
     35196
     35197  [
     35198
     35199    [[link boost_asio.reference.posix__basic_descriptor.lowest_layer_type [*lowest_layer_type]]]
     35200    [A basic_descriptor is always the lowest layer. ]
     35201 
     35202  ]
     35203
     35204  [
     35205
     35206    [[link boost_asio.reference.posix__basic_descriptor.native_type [*native_type]]]
     35207    [The native representation of a descriptor. ]
     35208 
     35209  ]
     35210
     35211  [
     35212
     35213    [[link boost_asio.reference.posix__basic_descriptor.non_blocking_io [*non_blocking_io]]]
     35214    [IO control command to set the blocking mode of the descriptor. ]
     35215 
     35216  ]
     35217
     35218  [
     35219
     35220    [[link boost_asio.reference.posix__basic_descriptor.service_type [*service_type]]]
     35221    [The type of the service that will be used to provide I/O operations. ]
     35222 
     35223  ]
     35224
     35225]
     35226
     35227[heading Member Functions]
     35228[table
     35229  [[Name][Description]]
     35230
     35231  [
     35232    [[link boost_asio.reference.posix__basic_descriptor.assign [*assign]]]
     35233    [Assign an existing native descriptor to the descriptor. ]
     35234  ]
     35235 
     35236  [
     35237    [[link boost_asio.reference.posix__basic_descriptor.basic_descriptor [*basic_descriptor]]]
     35238    [Construct a basic_descriptor without opening it. ]
     35239  ]
     35240 
     35241  [
     35242    [[link boost_asio.reference.posix__basic_descriptor.cancel [*cancel]]]
     35243    [Cancel all asynchronous operations associated with the descriptor. ]
     35244  ]
     35245 
     35246  [
     35247    [[link boost_asio.reference.posix__basic_descriptor.close [*close]]]
     35248    [Close the descriptor. ]
     35249  ]
     35250 
     35251  [
     35252    [[link boost_asio.reference.posix__basic_descriptor.get_io_service [*get_io_service]]]
     35253    [Get the io_service associated with the object. ]
     35254  ]
     35255 
     35256  [
     35257    [[link boost_asio.reference.posix__basic_descriptor.io_control [*io_control]]]
     35258    [Perform an IO control command on the descriptor. ]
     35259  ]
     35260 
     35261  [
     35262    [[link boost_asio.reference.posix__basic_descriptor.io_service [*io_service]]]
     35263    [(Deprecated: use get_io_service().) Get the io_service associated with the object. ]
     35264  ]
     35265 
     35266  [
     35267    [[link boost_asio.reference.posix__basic_descriptor.is_open [*is_open]]]
     35268    [Determine whether the descriptor is open. ]
     35269  ]
     35270 
     35271  [
     35272    [[link boost_asio.reference.posix__basic_descriptor.lowest_layer [*lowest_layer]]]
     35273    [Get a reference to the lowest layer. ]
     35274  ]
     35275 
     35276  [
     35277    [[link boost_asio.reference.posix__basic_descriptor.native [*native]]]
     35278    [Get the native descriptor representation. ]
     35279  ]
     35280 
     35281]
     35282
     35283[heading Protected Member Functions]
     35284[table
     35285  [[Name][Description]]
     35286
     35287  [
     35288    [[link boost_asio.reference.posix__basic_descriptor._basic_descriptor [*~basic_descriptor]]]
     35289    [Protected destructor to prevent deletion through this type. ]
     35290  ]
     35291 
     35292]
     35293
     35294[heading Protected Data Members]
     35295[table
     35296  [[Name][Description]]
     35297
     35298  [
     35299    [[link boost_asio.reference.posix__basic_descriptor.implementation [*implementation]]]
     35300    [The underlying implementation of the I/O object. ]
     35301  ]
     35302
     35303  [
     35304    [[link boost_asio.reference.posix__basic_descriptor.service [*service]]]
     35305    [The service associated with the I/O object. ]
     35306  ]
     35307
     35308]
     35309
     35310The posix::basic_descriptor class template provides the ability to wrap a POSIX descriptor.
     35311
     35312
     35313[heading Thread Safety]
     35314 
     35315[*Distinct] [*objects:]  Safe.
     35316
     35317[*Shared] [*objects:]  Unsafe.
     35318
     35319
     35320[section:assign posix::basic_descriptor::assign]
     35321
     35322Assign an existing native descriptor to the descriptor.
     35323
     35324  void ``[link boost_asio.reference.posix__basic_descriptor.assign.overload1 assign]``(
     35325      const native_type & native_descriptor);
     35326
     35327  boost::system::error_code ``[link boost_asio.reference.posix__basic_descriptor.assign.overload2 assign]``(
     35328      const native_type & native_descriptor,
     35329      boost::system::error_code & ec);
     35330
     35331
     35332[section:overload1 posix::basic_descriptor::assign (1 of 2 overloads)]
     35333
     35334Assign an existing native descriptor to the descriptor.
     35335
     35336  void assign(
     35337      const native_type & native_descriptor);
     35338
     35339
     35340
     35341[endsect]
     35342
     35343
     35344
     35345[section:overload2 posix::basic_descriptor::assign (2 of 2 overloads)]
     35346
     35347Assign an existing native descriptor to the descriptor.
     35348
     35349  boost::system::error_code assign(
     35350      const native_type & native_descriptor,
     35351      boost::system::error_code & ec);
     35352
     35353
     35354
     35355[endsect]
     35356
     35357
     35358[endsect]
     35359
     35360[section:basic_descriptor posix::basic_descriptor::basic_descriptor]
     35361
     35362Construct a basic_descriptor without opening it.
     35363
     35364  ``[link boost_asio.reference.posix__basic_descriptor.basic_descriptor.overload1 basic_descriptor]``(
     35365      boost::asio::io_service & io_service);
     35366
     35367  ``[link boost_asio.reference.posix__basic_descriptor.basic_descriptor.overload2 basic_descriptor]``(
     35368      boost::asio::io_service & io_service,
     35369      const native_type & native_descriptor);
     35370
     35371
     35372[section:overload1 posix::basic_descriptor::basic_descriptor (1 of 2 overloads)]
     35373
     35374Construct a basic_descriptor without opening it.
     35375
     35376  basic_descriptor(
     35377      boost::asio::io_service & io_service);
     35378
     35379
     35380This constructor creates a descriptor without opening it.
     35381
     35382
     35383[heading Parameters]
     35384   
     35385
     35386[variablelist
     35387 
     35388[[io_service][The io\_service object that the descriptor will use to dispatch handlers for any asynchronous operations performed on the descriptor. ]]
     35389
     35390]
     35391
     35392
     35393
     35394[endsect]
     35395
     35396
     35397
     35398[section:overload2 posix::basic_descriptor::basic_descriptor (2 of 2 overloads)]
     35399
     35400Construct a basic_descriptor on an existing native descriptor.
     35401
     35402  basic_descriptor(
     35403      boost::asio::io_service & io_service,
     35404      const native_type & native_descriptor);
     35405
     35406
     35407This constructor creates a descriptor object to hold an existing native descriptor.
     35408
     35409
     35410[heading Parameters]
     35411   
     35412
     35413[variablelist
     35414 
     35415[[io_service][The io\_service object that the descriptor will use to dispatch handlers for any asynchronous operations performed on the descriptor.]]
     35416
     35417[[native_descriptor][A native descriptor.]]
     35418
     35419]
     35420
     35421[heading Exceptions]
     35422   
     35423
     35424[variablelist
     35425 
     35426[[boost::system::system_error][Thrown on failure. ]]
     35427
     35428]
     35429
     35430
     35431
     35432[endsect]
     35433
     35434
     35435[endsect]
     35436
     35437
     35438[section:bytes_readable posix::basic_descriptor::bytes_readable]
     35439
     35440
     35441['Inherited from posix::descriptor_base.]
     35442
     35443IO control command to get the amount of data that can be read without blocking.
     35444
     35445  typedef implementation_defined bytes_readable;
     35446
     35447
     35448
     35449Implements the FIONREAD IO control command.
     35450
     35451
     35452[heading Example]
     35453 
     35454
     35455
     35456   boost::asio::posix::stream_descriptor descriptor(io_service);
     35457   ...
     35458   boost::asio::descriptor_base::bytes_readable command(true);
     35459   descriptor.io_control(command);
     35460   std::size_t bytes_readable = command.get();
     35461
     35462
     35463
     35464
     35465
     35466
     35467[endsect]
     35468
     35469
     35470[section:cancel posix::basic_descriptor::cancel]
     35471
     35472Cancel all asynchronous operations associated with the descriptor.
     35473
     35474  void ``[link boost_asio.reference.posix__basic_descriptor.cancel.overload1 cancel]``();
     35475
     35476  boost::system::error_code ``[link boost_asio.reference.posix__basic_descriptor.cancel.overload2 cancel]``(
     35477      boost::system::error_code & ec);
     35478
     35479
     35480[section:overload1 posix::basic_descriptor::cancel (1 of 2 overloads)]
     35481
     35482Cancel all asynchronous operations associated with the descriptor.
     35483
     35484  void cancel();
     35485
     35486
     35487This function causes all outstanding asynchronous read or write operations to finish immediately, and the handlers for cancelled operations will be passed the boost::asio::error::operation\_aborted error.
     35488
     35489
     35490[heading Exceptions]
     35491   
     35492
     35493[variablelist
     35494 
     35495[[boost::system::system_error][Thrown on failure. ]]
     35496
     35497]
     35498
     35499
     35500
     35501[endsect]
     35502
     35503
     35504
     35505[section:overload2 posix::basic_descriptor::cancel (2 of 2 overloads)]
     35506
     35507Cancel all asynchronous operations associated with the descriptor.
     35508
     35509  boost::system::error_code cancel(
     35510      boost::system::error_code & ec);
     35511
     35512
     35513This function causes all outstanding asynchronous read or write operations to finish immediately, and the handlers for cancelled operations will be passed the boost::asio::error::operation\_aborted error.
     35514
     35515
     35516[heading Parameters]
     35517   
     35518
     35519[variablelist
     35520 
     35521[[ec][Set to indicate what error occurred, if any. ]]
     35522
     35523]
     35524
     35525
     35526
     35527[endsect]
     35528
     35529
     35530[endsect]
     35531
     35532[section:close posix::basic_descriptor::close]
     35533
     35534Close the descriptor.
     35535
     35536  void ``[link boost_asio.reference.posix__basic_descriptor.close.overload1 close]``();
     35537
     35538  boost::system::error_code ``[link boost_asio.reference.posix__basic_descriptor.close.overload2 close]``(
     35539      boost::system::error_code & ec);
     35540
     35541
     35542[section:overload1 posix::basic_descriptor::close (1 of 2 overloads)]
     35543
     35544Close the descriptor.
     35545
     35546  void close();
     35547
     35548
     35549This function is used to close the descriptor. Any asynchronous read or write operations will be cancelled immediately, and will complete with the boost::asio::error::operation\_aborted error.
     35550
     35551
     35552[heading Exceptions]
     35553   
     35554
     35555[variablelist
     35556 
     35557[[boost::system::system_error][Thrown on failure. ]]
     35558
     35559]
     35560
     35561
     35562
     35563[endsect]
     35564
     35565
     35566
     35567[section:overload2 posix::basic_descriptor::close (2 of 2 overloads)]
     35568
     35569Close the descriptor.
     35570
     35571  boost::system::error_code close(
     35572      boost::system::error_code & ec);
     35573
     35574
     35575This function is used to close the descriptor. Any asynchronous read or write operations will be cancelled immediately, and will complete with the boost::asio::error::operation\_aborted error.
     35576
     35577
     35578[heading Parameters]
     35579   
     35580
     35581[variablelist
     35582 
     35583[[ec][Set to indicate what error occurred, if any. ]]
     35584
     35585]
     35586
     35587
     35588
     35589[endsect]
     35590
     35591
     35592[endsect]
     35593
     35594
     35595[section:get_io_service posix::basic_descriptor::get_io_service]
     35596
     35597
     35598['Inherited from basic_io_object.]
     35599
     35600Get the io_service associated with the object.
     35601
     35602  boost::asio::io_service & get_io_service();
     35603
     35604
     35605This function may be used to obtain the io_service object that the I/O object uses to dispatch handlers for asynchronous operations.
     35606
     35607
     35608[heading Return Value]
     35609     
     35610A reference to the io_service object that the I/O object will use to dispatch handlers. Ownership is not transferred to the caller.
     35611
     35612
     35613
     35614[endsect]
     35615
     35616
     35617
     35618[section:implementation posix::basic_descriptor::implementation]
     35619
     35620
     35621['Inherited from basic_io_object.]
     35622
     35623The underlying implementation of the I/O object.
     35624
     35625  implementation_type implementation;
     35626
     35627
     35628
     35629[endsect]
     35630
     35631
     35632
     35633[section:implementation_type posix::basic_descriptor::implementation_type]
     35634
     35635
     35636['Inherited from basic_io_object.]
     35637
     35638The underlying implementation type of I/O object.
     35639
     35640  typedef service_type::implementation_type implementation_type;
     35641
     35642
     35643
     35644
     35645[endsect]
     35646
     35647
     35648[section:io_control posix::basic_descriptor::io_control]
     35649
     35650Perform an IO control command on the descriptor.
     35651
     35652  template<
     35653      typename ``[link boost_asio.reference.IoControlCommand IoControlCommand]``>
     35654  void ``[link boost_asio.reference.posix__basic_descriptor.io_control.overload1 io_control]``(
     35655      IoControlCommand & command);
     35656
     35657  template<
     35658      typename ``[link boost_asio.reference.IoControlCommand IoControlCommand]``>
     35659  boost::system::error_code ``[link boost_asio.reference.posix__basic_descriptor.io_control.overload2 io_control]``(
     35660      IoControlCommand & command,
     35661      boost::system::error_code & ec);
     35662
     35663
     35664[section:overload1 posix::basic_descriptor::io_control (1 of 2 overloads)]
     35665
     35666Perform an IO control command on the descriptor.
     35667
     35668  template<
     35669      typename ``[link boost_asio.reference.IoControlCommand IoControlCommand]``>
     35670  void io_control(
     35671      IoControlCommand & command);
     35672
     35673
     35674This function is used to execute an IO control command on the descriptor.
     35675
     35676
     35677[heading Parameters]
     35678   
     35679
     35680[variablelist
     35681 
     35682[[command][The IO control command to be performed on the descriptor.]]
     35683
     35684]
     35685
     35686[heading Exceptions]
     35687   
     35688
     35689[variablelist
     35690 
     35691[[boost::system::system_error][Thrown on failure.]]
     35692
     35693]
     35694
     35695[heading Example]
     35696 
     35697Getting the number of bytes ready to read:
     35698
     35699   boost::asio::posix::stream_descriptor descriptor(io_service);
     35700   ...
     35701   boost::asio::posix::stream_descriptor::bytes_readable command;
     35702   descriptor.io_control(command);
     35703   std::size_t bytes_readable = command.get();
     35704
     35705
     35706
     35707
     35708
     35709
     35710[endsect]
     35711
     35712
     35713
     35714[section:overload2 posix::basic_descriptor::io_control (2 of 2 overloads)]
     35715
     35716Perform an IO control command on the descriptor.
     35717
     35718  template<
     35719      typename ``[link boost_asio.reference.IoControlCommand IoControlCommand]``>
     35720  boost::system::error_code io_control(
     35721      IoControlCommand & command,
     35722      boost::system::error_code & ec);
     35723
     35724
     35725This function is used to execute an IO control command on the descriptor.
     35726
     35727
     35728[heading Parameters]
     35729   
     35730
     35731[variablelist
     35732 
     35733[[command][The IO control command to be performed on the descriptor.]]
     35734
     35735[[ec][Set to indicate what error occurred, if any.]]
     35736
     35737]
     35738
     35739[heading Example]
     35740 
     35741Getting the number of bytes ready to read:
     35742
     35743   boost::asio::posix::stream_descriptor descriptor(io_service);
     35744   ...
     35745   boost::asio::posix::stream_descriptor::bytes_readable command;
     35746   boost::system::error_code ec;
     35747   descriptor.io_control(command, ec);
     35748   if (ec)
     35749   {
     35750     // An error occurred.
     35751   }
     35752   std::size_t bytes_readable = command.get();
     35753
     35754
     35755
     35756
     35757
     35758
     35759[endsect]
     35760
     35761
     35762[endsect]
     35763
     35764
     35765[section:io_service posix::basic_descriptor::io_service]
     35766
     35767
     35768['Inherited from basic_io_object.]
     35769
     35770(Deprecated: use get_io_service().) Get the io_service associated with the object.
     35771
     35772  boost::asio::io_service & io_service();
     35773
     35774
     35775This function may be used to obtain the io_service object that the I/O object uses to dispatch handlers for asynchronous operations.
     35776
     35777
     35778[heading Return Value]
     35779     
     35780A reference to the io_service object that the I/O object will use to dispatch handlers. Ownership is not transferred to the caller.
     35781
     35782
     35783
     35784[endsect]
     35785
     35786
     35787
     35788[section:is_open posix::basic_descriptor::is_open]
     35789
     35790Determine whether the descriptor is open.
     35791
     35792  bool is_open() const;
     35793
     35794
     35795
     35796[endsect]
     35797
     35798
     35799
     35800[section:lowest_layer posix::basic_descriptor::lowest_layer]
     35801
     35802Get a reference to the lowest layer.
     35803
     35804  lowest_layer_type & lowest_layer();
     35805
     35806
     35807This function returns a reference to the lowest layer in a stack of layers. Since a basic_descriptor cannot contain any further layers, it simply returns a reference to itself.
     35808
     35809
     35810[heading Return Value]
     35811     
     35812A reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller.
     35813
     35814
     35815
     35816[endsect]
     35817
     35818
     35819
     35820[section:lowest_layer_type posix::basic_descriptor::lowest_layer_type]
     35821
     35822A basic_descriptor is always the lowest layer.
     35823
     35824  typedef basic_descriptor< DescriptorService > lowest_layer_type;
     35825
     35826
     35827[heading Types]
     35828[table
     35829  [[Name][Description]]
     35830
     35831  [
     35832
     35833    [[link boost_asio.reference.posix__basic_descriptor.bytes_readable [*bytes_readable]]]
     35834    [IO control command to get the amount of data that can be read without blocking. ]
     35835 
     35836  ]
     35837
     35838  [
     35839
     35840    [[link boost_asio.reference.posix__basic_descriptor.implementation_type [*implementation_type]]]
     35841    [The underlying implementation type of I/O object. ]
     35842 
     35843  ]
     35844
     35845  [
     35846
     35847    [[link boost_asio.reference.posix__basic_descriptor.lowest_layer_type [*lowest_layer_type]]]
     35848    [A basic_descriptor is always the lowest layer. ]
     35849 
     35850  ]
     35851
     35852  [
     35853
     35854    [[link boost_asio.reference.posix__basic_descriptor.native_type [*native_type]]]
     35855    [The native representation of a descriptor. ]
     35856 
     35857  ]
     35858
     35859  [
     35860
     35861    [[link boost_asio.reference.posix__basic_descriptor.non_blocking_io [*non_blocking_io]]]
     35862    [IO control command to set the blocking mode of the descriptor. ]
     35863 
     35864  ]
     35865
     35866  [
     35867
     35868    [[link boost_asio.reference.posix__basic_descriptor.service_type [*service_type]]]
     35869    [The type of the service that will be used to provide I/O operations. ]
     35870 
     35871  ]
     35872
     35873]
     35874
     35875[heading Member Functions]
     35876[table
     35877  [[Name][Description]]
     35878
     35879  [
     35880    [[link boost_asio.reference.posix__basic_descriptor.assign [*assign]]]
     35881    [Assign an existing native descriptor to the descriptor. ]
     35882  ]
     35883 
     35884  [
     35885    [[link boost_asio.reference.posix__basic_descriptor.basic_descriptor [*basic_descriptor]]]
     35886    [Construct a basic_descriptor without opening it. ]
     35887  ]
     35888 
     35889  [
     35890    [[link boost_asio.reference.posix__basic_descriptor.cancel [*cancel]]]
     35891    [Cancel all asynchronous operations associated with the descriptor. ]
     35892  ]
     35893 
     35894  [
     35895    [[link boost_asio.reference.posix__basic_descriptor.close [*close]]]
     35896    [Close the descriptor. ]
     35897  ]
     35898 
     35899  [
     35900    [[link boost_asio.reference.posix__basic_descriptor.get_io_service [*get_io_service]]]
     35901    [Get the io_service associated with the object. ]
     35902  ]
     35903 
     35904  [
     35905    [[link boost_asio.reference.posix__basic_descriptor.io_control [*io_control]]]
     35906    [Perform an IO control command on the descriptor. ]
     35907  ]
     35908 
     35909  [
     35910    [[link boost_asio.reference.posix__basic_descriptor.io_service [*io_service]]]
     35911    [(Deprecated: use get_io_service().) Get the io_service associated with the object. ]
     35912  ]
     35913 
     35914  [
     35915    [[link boost_asio.reference.posix__basic_descriptor.is_open [*is_open]]]
     35916    [Determine whether the descriptor is open. ]
     35917  ]
     35918 
     35919  [
     35920    [[link boost_asio.reference.posix__basic_descriptor.lowest_layer [*lowest_layer]]]
     35921    [Get a reference to the lowest layer. ]
     35922  ]
     35923 
     35924  [
     35925    [[link boost_asio.reference.posix__basic_descriptor.native [*native]]]
     35926    [Get the native descriptor representation. ]
     35927  ]
     35928 
     35929]
     35930
     35931[heading Protected Member Functions]
     35932[table
     35933  [[Name][Description]]
     35934
     35935  [
     35936    [[link boost_asio.reference.posix__basic_descriptor._basic_descriptor [*~basic_descriptor]]]
     35937    [Protected destructor to prevent deletion through this type. ]
     35938  ]
     35939 
     35940]
     35941
     35942[heading Protected Data Members]
     35943[table
     35944  [[Name][Description]]
     35945
     35946  [
     35947    [[link boost_asio.reference.posix__basic_descriptor.implementation [*implementation]]]
     35948    [The underlying implementation of the I/O object. ]
     35949  ]
     35950
     35951  [
     35952    [[link boost_asio.reference.posix__basic_descriptor.service [*service]]]
     35953    [The service associated with the I/O object. ]
     35954  ]
     35955
     35956]
     35957
     35958The posix::basic_descriptor class template provides the ability to wrap a POSIX descriptor.
     35959
     35960
     35961[heading Thread Safety]
     35962 
     35963[*Distinct] [*objects:]  Safe.
     35964
     35965[*Shared] [*objects:]  Unsafe.
     35966
     35967
     35968
     35969
     35970[endsect]
     35971
     35972
     35973
     35974[section:native posix::basic_descriptor::native]
     35975
     35976Get the native descriptor representation.
     35977
     35978  native_type native();
     35979
     35980
     35981This function may be used to obtain the underlying representation of the descriptor. This is intended to allow access to native descriptor functionality that is not otherwise provided.
     35982
     35983
     35984[endsect]
     35985
     35986
     35987
     35988[section:native_type posix::basic_descriptor::native_type]
     35989
     35990The native representation of a descriptor.
     35991
     35992  typedef DescriptorService::native_type native_type;
     35993
     35994
     35995
     35996
     35997[endsect]
     35998
     35999
     36000
     36001[section:non_blocking_io posix::basic_descriptor::non_blocking_io]
     36002
     36003
     36004['Inherited from posix::descriptor_base.]
     36005
     36006IO control command to set the blocking mode of the descriptor.
     36007
     36008  typedef implementation_defined non_blocking_io;
     36009
     36010
     36011
     36012Implements the FIONBIO IO control command.
     36013
     36014
     36015[heading Example]
     36016 
     36017
     36018
     36019   boost::asio::posix::stream_descriptor descriptor(io_service);
     36020   ...
     36021   boost::asio::descriptor_base::non_blocking_io command(true);
     36022   descriptor.io_control(command);
     36023
     36024
     36025
     36026
     36027
     36028
     36029[endsect]
     36030
     36031
     36032
     36033[section:service posix::basic_descriptor::service]
     36034
     36035
     36036['Inherited from basic_io_object.]
     36037
     36038The service associated with the I/O object.
     36039
     36040  service_type & service;
     36041
     36042
     36043
     36044[endsect]
     36045
     36046
     36047
     36048[section:service_type posix::basic_descriptor::service_type]
     36049
     36050
     36051['Inherited from basic_io_object.]
     36052
     36053The type of the service that will be used to provide I/O operations.
     36054
     36055  typedef DescriptorService service_type;
     36056
     36057
     36058
     36059
     36060[endsect]
     36061
     36062
     36063
     36064[section:_basic_descriptor posix::basic_descriptor::~basic_descriptor]
     36065
     36066Protected destructor to prevent deletion through this type.
     36067
     36068  ~basic_descriptor();
     36069
     36070
     36071
     36072[endsect]
     36073
     36074
     36075
     36076[endsect]
     36077
     36078[section:posix__basic_stream_descriptor posix::basic_stream_descriptor]
     36079
     36080Provides stream-oriented descriptor functionality.
     36081
     36082  template<
     36083      typename ``[link boost_asio.reference.StreamDescriptorService StreamDescriptorService]`` = stream_descriptor_service>
     36084  class basic_stream_descriptor :
     36085    public posix::basic_descriptor< StreamDescriptorService >
     36086
     36087
     36088[heading Types]
     36089[table
     36090  [[Name][Description]]
     36091
     36092  [
     36093
     36094    [[link boost_asio.reference.posix__basic_stream_descriptor.bytes_readable [*bytes_readable]]]
     36095    [IO control command to get the amount of data that can be read without blocking. ]
     36096 
     36097  ]
     36098
     36099  [
     36100
     36101    [[link boost_asio.reference.posix__basic_stream_descriptor.implementation_type [*implementation_type]]]
     36102    [The underlying implementation type of I/O object. ]
     36103 
     36104  ]
     36105
     36106  [
     36107
     36108    [[link boost_asio.reference.posix__basic_stream_descriptor.lowest_layer_type [*lowest_layer_type]]]
     36109    [A basic_descriptor is always the lowest layer. ]
     36110 
     36111  ]
     36112
     36113  [
     36114
     36115    [[link boost_asio.reference.posix__basic_stream_descriptor.native_type [*native_type]]]
     36116    [The native representation of a descriptor. ]
     36117 
     36118  ]
     36119
     36120  [
     36121
     36122    [[link boost_asio.reference.posix__basic_stream_descriptor.non_blocking_io [*non_blocking_io]]]
     36123    [IO control command to set the blocking mode of the descriptor. ]
     36124 
     36125  ]
     36126
     36127  [
     36128
     36129    [[link boost_asio.reference.posix__basic_stream_descriptor.service_type [*service_type]]]
     36130    [The type of the service that will be used to provide I/O operations. ]
     36131 
     36132  ]
     36133
     36134]
     36135
     36136[heading Member Functions]
     36137[table
     36138  [[Name][Description]]
     36139
     36140  [
     36141    [[link boost_asio.reference.posix__basic_stream_descriptor.assign [*assign]]]
     36142    [Assign an existing native descriptor to the descriptor. ]
     36143  ]
     36144 
     36145  [
     36146    [[link boost_asio.reference.posix__basic_stream_descriptor.async_read_some [*async_read_some]]]
     36147    [Start an asynchronous read. ]
     36148  ]
     36149 
     36150  [
     36151    [[link boost_asio.reference.posix__basic_stream_descriptor.async_write_some [*async_write_some]]]
     36152    [Start an asynchronous write. ]
     36153  ]
     36154 
     36155  [
     36156    [[link boost_asio.reference.posix__basic_stream_descriptor.basic_stream_descriptor [*basic_stream_descriptor]]]
     36157    [Construct a basic_stream_descriptor without opening it. ]
     36158  ]
     36159 
     36160  [
     36161    [[link boost_asio.reference.posix__basic_stream_descriptor.cancel [*cancel]]]
     36162    [Cancel all asynchronous operations associated with the descriptor. ]
     36163  ]
     36164 
     36165  [
     36166    [[link boost_asio.reference.posix__basic_stream_descriptor.close [*close]]]
     36167    [Close the descriptor. ]
     36168  ]
     36169 
     36170  [
     36171    [[link boost_asio.reference.posix__basic_stream_descriptor.get_io_service [*get_io_service]]]
     36172    [Get the io_service associated with the object. ]
     36173  ]
     36174 
     36175  [
     36176    [[link boost_asio.reference.posix__basic_stream_descriptor.io_control [*io_control]]]
     36177    [Perform an IO control command on the descriptor. ]
     36178  ]
     36179 
     36180  [
     36181    [[link boost_asio.reference.posix__basic_stream_descriptor.io_service [*io_service]]]
     36182    [(Deprecated: use get_io_service().) Get the io_service associated with the object. ]
     36183  ]
     36184 
     36185  [
     36186    [[link boost_asio.reference.posix__basic_stream_descriptor.is_open [*is_open]]]
     36187    [Determine whether the descriptor is open. ]
     36188  ]
     36189 
     36190  [
     36191    [[link boost_asio.reference.posix__basic_stream_descriptor.lowest_layer [*lowest_layer]]]
     36192    [Get a reference to the lowest layer. ]
     36193  ]
     36194 
     36195  [
     36196    [[link boost_asio.reference.posix__basic_stream_descriptor.native [*native]]]
     36197    [Get the native descriptor representation. ]
     36198  ]
     36199 
     36200  [
     36201    [[link boost_asio.reference.posix__basic_stream_descriptor.read_some [*read_some]]]
     36202    [Read some data from the descriptor. ]
     36203  ]
     36204 
     36205  [
     36206    [[link boost_asio.reference.posix__basic_stream_descriptor.write_some [*write_some]]]
     36207    [Write some data to the descriptor. ]
     36208  ]
     36209 
     36210]
     36211
     36212[heading Protected Data Members]
     36213[table
     36214  [[Name][Description]]
     36215
     36216  [
     36217    [[link boost_asio.reference.posix__basic_stream_descriptor.implementation [*implementation]]]
     36218    [The underlying implementation of the I/O object. ]
     36219  ]
     36220
     36221  [
     36222    [[link boost_asio.reference.posix__basic_stream_descriptor.service [*service]]]
     36223    [The service associated with the I/O object. ]
     36224  ]
     36225
     36226]
     36227
     36228The posix::basic_stream_descriptor class template provides asynchronous and blocking stream-oriented descriptor functionality.
     36229
     36230
     36231[heading Thread Safety]
     36232 
     36233[*Distinct] [*objects:]  Safe.
     36234
     36235[*Shared] [*objects:]  Unsafe.
     36236
     36237
     36238[section:assign posix::basic_stream_descriptor::assign]
     36239
     36240Assign an existing native descriptor to the descriptor.
     36241
     36242  void ``[link boost_asio.reference.posix__basic_stream_descriptor.assign.overload1 assign]``(
     36243      const native_type & native_descriptor);
     36244
     36245  boost::system::error_code ``[link boost_asio.reference.posix__basic_stream_descriptor.assign.overload2 assign]``(
     36246      const native_type & native_descriptor,
     36247      boost::system::error_code & ec);
     36248
     36249
     36250[section:overload1 posix::basic_stream_descriptor::assign (1 of 2 overloads)]
     36251
     36252
     36253['Inherited from posix::basic_descriptor.]
     36254
     36255Assign an existing native descriptor to the descriptor.
     36256
     36257  void assign(
     36258      const native_type & native_descriptor);
     36259
     36260
     36261
     36262[endsect]
     36263
     36264
     36265
     36266[section:overload2 posix::basic_stream_descriptor::assign (2 of 2 overloads)]
     36267
     36268
     36269['Inherited from posix::basic_descriptor.]
     36270
     36271Assign an existing native descriptor to the descriptor.
     36272
     36273  boost::system::error_code assign(
     36274      const native_type & native_descriptor,
     36275      boost::system::error_code & ec);
     36276
     36277
     36278
     36279[endsect]
     36280
     36281
     36282[endsect]
     36283
     36284
     36285[section:async_read_some posix::basic_stream_descriptor::async_read_some]
     36286
     36287Start an asynchronous read.
     36288
     36289  template<
     36290      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
     36291      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
     36292  void async_read_some(
     36293      const MutableBufferSequence & buffers,
     36294      ReadHandler handler);
     36295
     36296
     36297This function is used to asynchronously read data from the stream descriptor. The function call always returns immediately.
     36298
     36299
     36300[heading Parameters]
     36301   
     36302
     36303[variablelist
     36304 
     36305[[buffers][One or more buffers into which the data will be read. Although the buffers object may be copied as necessary, ownership of the underlying memory blocks is retained by the caller, which must guarantee that they remain valid until the handler is called.]]
     36306
     36307[[handler][The handler to be called when the read operation completes. Copies will be made of the handler as required. The function signature of the handler must be:
     36308``
     36309   void handler(
     36310     const boost::system::error_code& error, // Result of operation.
     36311     std::size_t bytes_transferred           // Number of bytes read.
     36312   );
     36313
     36314``
     36315Regardless 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().]]
     36316
     36317]
     36318
     36319[heading Remarks]
     36320     
     36321The read operation may not read all of the requested number of bytes. Consider using the
     36322[link boost_asio.reference.async_read async_read]  function if you need to ensure that the requested amount of data is read before the asynchronous operation completes.
     36323
     36324[heading Example]
     36325 
     36326To read into a single data buffer use the
     36327[link boost_asio.reference.buffer buffer]  function as follows:
     36328
     36329   descriptor.async_read_some(boost::asio::buffer(data, size), handler);
     36330
     36331
     36332See the
     36333[link boost_asio.reference.buffer buffer]  documentation for information on reading into multiple buffers in one go, and how to use it with arrays, boost::array or std::vector.
     36334
     36335
     36336
     36337[endsect]
     36338
     36339
     36340
     36341[section:async_write_some posix::basic_stream_descriptor::async_write_some]
     36342
     36343Start an asynchronous write.
     36344
     36345  template<
     36346      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
     36347      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
     36348  void async_write_some(
     36349      const ConstBufferSequence & buffers,
     36350      WriteHandler handler);
     36351
     36352
     36353This function is used to asynchronously write data to the stream descriptor. The function call always returns immediately.
     36354
     36355
     36356[heading Parameters]
     36357   
     36358
     36359[variablelist
     36360 
     36361[[buffers][One or more data buffers to be written to the descriptor. Although the buffers object may be copied as necessary, ownership of the underlying memory blocks is retained by the caller, which must guarantee that they remain valid until the handler is called.]]
     36362
     36363[[handler][The handler to be called when the write operation completes. Copies will be made of the handler as required. The function signature of the handler must be:
     36364``
     36365   void handler(
     36366     const boost::system::error_code& error, // Result of operation.
     36367     std::size_t bytes_transferred           // Number of bytes written.
     36368   );
     36369
     36370``
     36371Regardless 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().]]
     36372
     36373]
     36374
     36375[heading Remarks]
     36376     
     36377The write operation may not transmit all of the data to the peer. Consider using the
     36378[link boost_asio.reference.async_write async_write]  function if you need to ensure that all data is written before the asynchronous operation completes.
     36379
     36380[heading Example]
     36381 
     36382To write a single data buffer use the
     36383[link boost_asio.reference.buffer buffer]  function as follows:
     36384
     36385   descriptor.async_write_some(boost::asio::buffer(data, size), handler);
     36386
     36387
     36388See the
     36389[link boost_asio.reference.buffer buffer]  documentation for information on writing multiple buffers in one go, and how to use it with arrays, boost::array or std::vector.
     36390
     36391
     36392
     36393[endsect]
     36394
     36395
     36396[section:basic_stream_descriptor posix::basic_stream_descriptor::basic_stream_descriptor]
     36397
     36398Construct a basic_stream_descriptor without opening it.
     36399
     36400  ``[link boost_asio.reference.posix__basic_stream_descriptor.basic_stream_descriptor.overload1 basic_stream_descriptor]``(
     36401      boost::asio::io_service & io_service);
     36402
     36403  ``[link boost_asio.reference.posix__basic_stream_descriptor.basic_stream_descriptor.overload2 basic_stream_descriptor]``(
     36404      boost::asio::io_service & io_service,
     36405      const native_type & native_descriptor);
     36406
     36407
     36408[section:overload1 posix::basic_stream_descriptor::basic_stream_descriptor (1 of 2 overloads)]
     36409
     36410Construct a basic_stream_descriptor without opening it.
     36411
     36412  basic_stream_descriptor(
     36413      boost::asio::io_service & io_service);
     36414
     36415
     36416This constructor creates a stream descriptor without opening it. The descriptor needs to be opened and then connected or accepted before data can be sent or received on it.
     36417
     36418
     36419[heading Parameters]
     36420   
     36421
     36422[variablelist
     36423 
     36424[[io_service][The io\_service object that the stream descriptor will use to dispatch handlers for any asynchronous operations performed on the descriptor. ]]
     36425
     36426]
     36427
     36428
     36429
     36430[endsect]
     36431
     36432
     36433
     36434[section:overload2 posix::basic_stream_descriptor::basic_stream_descriptor (2 of 2 overloads)]
     36435
     36436Construct a basic_stream_descriptor on an existing native descriptor.
     36437
     36438  basic_stream_descriptor(
     36439      boost::asio::io_service & io_service,
     36440      const native_type & native_descriptor);
     36441
     36442
     36443This constructor creates a stream descriptor object to hold an existing native descriptor.
     36444
     36445
     36446[heading Parameters]
     36447   
     36448
     36449[variablelist
     36450 
     36451[[io_service][The io\_service object that the stream descriptor will use to dispatch handlers for any asynchronous operations performed on the descriptor.]]
     36452
     36453[[native_descriptor][The new underlying descriptor implementation.]]
     36454
     36455]
     36456
     36457[heading Exceptions]
     36458   
     36459
     36460[variablelist
     36461 
     36462[[boost::system::system_error][Thrown on failure. ]]
     36463
     36464]
     36465
     36466
     36467
     36468[endsect]
     36469
     36470
     36471[endsect]
     36472
     36473
     36474[section:bytes_readable posix::basic_stream_descriptor::bytes_readable]
     36475
     36476
     36477['Inherited from posix::descriptor_base.]
     36478
     36479IO control command to get the amount of data that can be read without blocking.
     36480
     36481  typedef implementation_defined bytes_readable;
     36482
     36483
     36484
     36485Implements the FIONREAD IO control command.
     36486
     36487
     36488[heading Example]
     36489 
     36490
     36491
     36492   boost::asio::posix::stream_descriptor descriptor(io_service);
     36493   ...
     36494   boost::asio::descriptor_base::bytes_readable command(true);
     36495   descriptor.io_control(command);
     36496   std::size_t bytes_readable = command.get();
     36497
     36498
     36499
     36500
     36501
     36502
     36503[endsect]
     36504
     36505
     36506[section:cancel posix::basic_stream_descriptor::cancel]
     36507
     36508Cancel all asynchronous operations associated with the descriptor.
     36509
     36510  void ``[link boost_asio.reference.posix__basic_stream_descriptor.cancel.overload1 cancel]``();
     36511
     36512  boost::system::error_code ``[link boost_asio.reference.posix__basic_stream_descriptor.cancel.overload2 cancel]``(
     36513      boost::system::error_code & ec);
     36514
     36515
     36516[section:overload1 posix::basic_stream_descriptor::cancel (1 of 2 overloads)]
     36517
     36518
     36519['Inherited from posix::basic_descriptor.]
     36520
     36521Cancel all asynchronous operations associated with the descriptor.
     36522
     36523  void cancel();
     36524
     36525
     36526This function causes all outstanding asynchronous read or write operations to finish immediately, and the handlers for cancelled operations will be passed the boost::asio::error::operation\_aborted error.
     36527
     36528
     36529[heading Exceptions]
     36530   
     36531
     36532[variablelist
     36533 
     36534[[boost::system::system_error][Thrown on failure. ]]
     36535
     36536]
     36537
     36538
     36539
     36540[endsect]
     36541
     36542
     36543
     36544[section:overload2 posix::basic_stream_descriptor::cancel (2 of 2 overloads)]
     36545
     36546
     36547['Inherited from posix::basic_descriptor.]
     36548
     36549Cancel all asynchronous operations associated with the descriptor.
     36550
     36551  boost::system::error_code cancel(
     36552      boost::system::error_code & ec);
     36553
     36554
     36555This function causes all outstanding asynchronous read or write operations to finish immediately, and the handlers for cancelled operations will be passed the boost::asio::error::operation\_aborted error.
     36556
     36557
     36558[heading Parameters]
     36559   
     36560
     36561[variablelist
     36562 
     36563[[ec][Set to indicate what error occurred, if any. ]]
     36564
     36565]
     36566
     36567
     36568
     36569[endsect]
     36570
     36571
     36572[endsect]
     36573
     36574[section:close posix::basic_stream_descriptor::close]
     36575
     36576Close the descriptor.
     36577
     36578  void ``[link boost_asio.reference.posix__basic_stream_descriptor.close.overload1 close]``();
     36579
     36580  boost::system::error_code ``[link boost_asio.reference.posix__basic_stream_descriptor.close.overload2 close]``(
     36581      boost::system::error_code & ec);
     36582
     36583
     36584[section:overload1 posix::basic_stream_descriptor::close (1 of 2 overloads)]
     36585
     36586
     36587['Inherited from posix::basic_descriptor.]
     36588
     36589Close the descriptor.
     36590
     36591  void close();
     36592
     36593
     36594This function is used to close the descriptor. Any asynchronous read or write operations will be cancelled immediately, and will complete with the boost::asio::error::operation\_aborted error.
     36595
     36596
     36597[heading Exceptions]
     36598   
     36599
     36600[variablelist
     36601 
     36602[[boost::system::system_error][Thrown on failure. ]]
     36603
     36604]
     36605
     36606
     36607
     36608[endsect]
     36609
     36610
     36611
     36612[section:overload2 posix::basic_stream_descriptor::close (2 of 2 overloads)]
     36613
     36614
     36615['Inherited from posix::basic_descriptor.]
     36616
     36617Close the descriptor.
     36618
     36619  boost::system::error_code close(
     36620      boost::system::error_code & ec);
     36621
     36622
     36623This function is used to close the descriptor. Any asynchronous read or write operations will be cancelled immediately, and will complete with the boost::asio::error::operation\_aborted error.
     36624
     36625
     36626[heading Parameters]
     36627   
     36628
     36629[variablelist
     36630 
     36631[[ec][Set to indicate what error occurred, if any. ]]
     36632
     36633]
     36634
     36635
     36636
     36637[endsect]
     36638
     36639
     36640[endsect]
     36641
     36642
     36643[section:get_io_service posix::basic_stream_descriptor::get_io_service]
     36644
     36645
     36646['Inherited from basic_io_object.]
     36647
     36648Get the io_service associated with the object.
     36649
     36650  boost::asio::io_service & get_io_service();
     36651
     36652
     36653This function may be used to obtain the io_service object that the I/O object uses to dispatch handlers for asynchronous operations.
     36654
     36655
     36656[heading Return Value]
     36657     
     36658A reference to the io_service object that the I/O object will use to dispatch handlers. Ownership is not transferred to the caller.
     36659
     36660
     36661
     36662[endsect]
     36663
     36664
     36665
     36666[section:implementation posix::basic_stream_descriptor::implementation]
     36667
     36668
     36669['Inherited from basic_io_object.]
     36670
     36671The underlying implementation of the I/O object.
     36672
     36673  implementation_type implementation;
     36674
     36675
     36676
     36677[endsect]
     36678
     36679
     36680
     36681[section:implementation_type posix::basic_stream_descriptor::implementation_type]
     36682
     36683
     36684['Inherited from basic_io_object.]
     36685
     36686The underlying implementation type of I/O object.
     36687
     36688  typedef service_type::implementation_type implementation_type;
     36689
     36690
     36691
     36692
     36693[endsect]
     36694
     36695
     36696[section:io_control posix::basic_stream_descriptor::io_control]
     36697
     36698Perform an IO control command on the descriptor.
     36699
     36700  void ``[link boost_asio.reference.posix__basic_stream_descriptor.io_control.overload1 io_control]``(
     36701      IoControlCommand & command);
     36702
     36703  boost::system::error_code ``[link boost_asio.reference.posix__basic_stream_descriptor.io_control.overload2 io_control]``(
     36704      IoControlCommand & command,
     36705      boost::system::error_code & ec);
     36706
     36707
     36708[section:overload1 posix::basic_stream_descriptor::io_control (1 of 2 overloads)]
     36709
     36710
     36711['Inherited from posix::basic_descriptor.]
     36712
     36713Perform an IO control command on the descriptor.
     36714
     36715  void io_control(
     36716      IoControlCommand & command);
     36717
     36718
     36719This function is used to execute an IO control command on the descriptor.
     36720
     36721
     36722[heading Parameters]
     36723   
     36724
     36725[variablelist
     36726 
     36727[[command][The IO control command to be performed on the descriptor.]]
     36728
     36729]
     36730
     36731[heading Exceptions]
     36732   
     36733
     36734[variablelist
     36735 
     36736[[boost::system::system_error][Thrown on failure.]]
     36737
     36738]
     36739
     36740[heading Example]
     36741 
     36742Getting the number of bytes ready to read:
     36743
     36744   boost::asio::posix::stream_descriptor descriptor(io_service);
     36745   ...
     36746   boost::asio::posix::stream_descriptor::bytes_readable command;
     36747   descriptor.io_control(command);
     36748   std::size_t bytes_readable = command.get();
     36749
     36750
     36751
     36752
     36753
     36754
     36755[endsect]
     36756
     36757
     36758
     36759[section:overload2 posix::basic_stream_descriptor::io_control (2 of 2 overloads)]
     36760
     36761
     36762['Inherited from posix::basic_descriptor.]
     36763
     36764Perform an IO control command on the descriptor.
     36765
     36766  boost::system::error_code io_control(
     36767      IoControlCommand & command,
     36768      boost::system::error_code & ec);
     36769
     36770
     36771This function is used to execute an IO control command on the descriptor.
     36772
     36773
     36774[heading Parameters]
     36775   
     36776
     36777[variablelist
     36778 
     36779[[command][The IO control command to be performed on the descriptor.]]
     36780
     36781[[ec][Set to indicate what error occurred, if any.]]
     36782
     36783]
     36784
     36785[heading Example]
     36786 
     36787Getting the number of bytes ready to read:
     36788
     36789   boost::asio::posix::stream_descriptor descriptor(io_service);
     36790   ...
     36791   boost::asio::posix::stream_descriptor::bytes_readable command;
     36792   boost::system::error_code ec;
     36793   descriptor.io_control(command, ec);
     36794   if (ec)
     36795   {
     36796     // An error occurred.
     36797   }
     36798   std::size_t bytes_readable = command.get();
     36799
     36800
     36801
     36802
     36803
     36804
     36805[endsect]
     36806
     36807
     36808[endsect]
     36809
     36810
     36811[section:io_service posix::basic_stream_descriptor::io_service]
     36812
     36813
     36814['Inherited from basic_io_object.]
     36815
     36816(Deprecated: use get_io_service().) Get the io_service associated with the object.
     36817
     36818  boost::asio::io_service & io_service();
     36819
     36820
     36821This function may be used to obtain the io_service object that the I/O object uses to dispatch handlers for asynchronous operations.
     36822
     36823
     36824[heading Return Value]
     36825     
     36826A reference to the io_service object that the I/O object will use to dispatch handlers. Ownership is not transferred to the caller.
     36827
     36828
     36829
     36830[endsect]
     36831
     36832
     36833
     36834[section:is_open posix::basic_stream_descriptor::is_open]
     36835
     36836
     36837['Inherited from posix::basic_descriptor.]
     36838
     36839Determine whether the descriptor is open.
     36840
     36841  bool is_open() const;
     36842
     36843
     36844
     36845[endsect]
     36846
     36847
     36848
     36849[section:lowest_layer posix::basic_stream_descriptor::lowest_layer]
     36850
     36851
     36852['Inherited from posix::basic_descriptor.]
     36853
     36854Get a reference to the lowest layer.
     36855
     36856  lowest_layer_type & lowest_layer();
     36857
     36858
     36859This function returns a reference to the lowest layer in a stack of layers. Since a basic_descriptor cannot contain any further layers, it simply returns a reference to itself.
     36860
     36861
     36862[heading Return Value]
     36863     
     36864A reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller.
     36865
     36866
     36867
     36868[endsect]
     36869
     36870
     36871
     36872[section:lowest_layer_type posix::basic_stream_descriptor::lowest_layer_type]
     36873
     36874
     36875['Inherited from posix::basic_descriptor.]
     36876
     36877A basic_descriptor is always the lowest layer.
     36878
     36879  typedef basic_descriptor< StreamDescriptorService > lowest_layer_type;
     36880
     36881
     36882[heading Types]
     36883[table
     36884  [[Name][Description]]
     36885
     36886  [
     36887
     36888    [[link boost_asio.reference.posix__basic_descriptor.bytes_readable [*bytes_readable]]]
     36889    [IO control command to get the amount of data that can be read without blocking. ]
     36890 
     36891  ]
     36892
     36893  [
     36894
     36895    [[link boost_asio.reference.posix__basic_descriptor.implementation_type [*implementation_type]]]
     36896    [The underlying implementation type of I/O object. ]
     36897 
     36898  ]
     36899
     36900  [
     36901
     36902    [[link boost_asio.reference.posix__basic_descriptor.lowest_layer_type [*lowest_layer_type]]]
     36903    [A basic_descriptor is always the lowest layer. ]
     36904 
     36905  ]
     36906
     36907  [
     36908
     36909    [[link boost_asio.reference.posix__basic_descriptor.native_type [*native_type]]]
     36910    [The native representation of a descriptor. ]
     36911 
     36912  ]
     36913
     36914  [
     36915
     36916    [[link boost_asio.reference.posix__basic_descriptor.non_blocking_io [*non_blocking_io]]]
     36917    [IO control command to set the blocking mode of the descriptor. ]
     36918 
     36919  ]
     36920
     36921  [
     36922
     36923    [[link boost_asio.reference.posix__basic_descriptor.service_type [*service_type]]]
     36924    [The type of the service that will be used to provide I/O operations. ]
     36925 
     36926  ]
     36927
     36928]
     36929
     36930[heading Member Functions]
     36931[table
     36932  [[Name][Description]]
     36933
     36934  [
     36935    [[link boost_asio.reference.posix__basic_descriptor.assign [*assign]]]
     36936    [Assign an existing native descriptor to the descriptor. ]
     36937  ]
     36938 
     36939  [
     36940    [[link boost_asio.reference.posix__basic_descriptor.basic_descriptor [*basic_descriptor]]]
     36941    [Construct a basic_descriptor without opening it. ]
     36942  ]
     36943 
     36944  [
     36945    [[link boost_asio.reference.posix__basic_descriptor.cancel [*cancel]]]
     36946    [Cancel all asynchronous operations associated with the descriptor. ]
     36947  ]
     36948 
     36949  [
     36950    [[link boost_asio.reference.posix__basic_descriptor.close [*close]]]
     36951    [Close the descriptor. ]
     36952  ]
     36953 
     36954  [
     36955    [[link boost_asio.reference.posix__basic_descriptor.get_io_service [*get_io_service]]]
     36956    [Get the io_service associated with the object. ]
     36957  ]
     36958 
     36959  [
     36960    [[link boost_asio.reference.posix__basic_descriptor.io_control [*io_control]]]
     36961    [Perform an IO control command on the descriptor. ]
     36962  ]
     36963 
     36964  [
     36965    [[link boost_asio.reference.posix__basic_descriptor.io_service [*io_service]]]
     36966    [(Deprecated: use get_io_service().) Get the io_service associated with the object. ]
     36967  ]
     36968 
     36969  [
     36970    [[link boost_asio.reference.posix__basic_descriptor.is_open [*is_open]]]
     36971    [Determine whether the descriptor is open. ]
     36972  ]
     36973 
     36974  [
     36975    [[link boost_asio.reference.posix__basic_descriptor.lowest_layer [*lowest_layer]]]
     36976    [Get a reference to the lowest layer. ]
     36977  ]
     36978 
     36979  [
     36980    [[link boost_asio.reference.posix__basic_descriptor.native [*native]]]
     36981    [Get the native descriptor representation. ]
     36982  ]
     36983 
     36984]
     36985
     36986[heading Protected Member Functions]
     36987[table
     36988  [[Name][Description]]
     36989
     36990  [
     36991    [[link boost_asio.reference.posix__basic_descriptor._basic_descriptor [*~basic_descriptor]]]
     36992    [Protected destructor to prevent deletion through this type. ]
     36993  ]
     36994 
     36995]
     36996
     36997[heading Protected Data Members]
     36998[table
     36999  [[Name][Description]]
     37000
     37001  [
     37002    [[link boost_asio.reference.posix__basic_descriptor.implementation [*implementation]]]
     37003    [The underlying implementation of the I/O object. ]
     37004  ]
     37005
     37006  [
     37007    [[link boost_asio.reference.posix__basic_descriptor.service [*service]]]
     37008    [The service associated with the I/O object. ]
     37009  ]
     37010
     37011]
     37012
     37013The posix::basic_descriptor class template provides the ability to wrap a POSIX descriptor.
     37014
     37015
     37016[heading Thread Safety]
     37017 
     37018[*Distinct] [*objects:]  Safe.
     37019
     37020[*Shared] [*objects:]  Unsafe.
     37021
     37022
     37023
     37024
     37025[endsect]
     37026
     37027
     37028
     37029[section:native posix::basic_stream_descriptor::native]
     37030
     37031
     37032['Inherited from posix::basic_descriptor.]
     37033
     37034Get the native descriptor representation.
     37035
     37036  native_type native();
     37037
     37038
     37039This function may be used to obtain the underlying representation of the descriptor. This is intended to allow access to native descriptor functionality that is not otherwise provided.
     37040
     37041
     37042[endsect]
     37043
     37044
     37045
     37046[section:native_type posix::basic_stream_descriptor::native_type]
     37047
     37048The native representation of a descriptor.
     37049
     37050  typedef StreamDescriptorService::native_type native_type;
     37051
     37052
     37053
     37054
     37055[endsect]
     37056
     37057
     37058
     37059[section:non_blocking_io posix::basic_stream_descriptor::non_blocking_io]
     37060
     37061
     37062['Inherited from posix::descriptor_base.]
     37063
     37064IO control command to set the blocking mode of the descriptor.
     37065
     37066  typedef implementation_defined non_blocking_io;
     37067
     37068
     37069
     37070Implements the FIONBIO IO control command.
     37071
     37072
     37073[heading Example]
     37074 
     37075
     37076
     37077   boost::asio::posix::stream_descriptor descriptor(io_service);
     37078   ...
     37079   boost::asio::descriptor_base::non_blocking_io command(true);
     37080   descriptor.io_control(command);
     37081
     37082
     37083
     37084
     37085
     37086
     37087[endsect]
     37088
     37089
     37090[section:read_some posix::basic_stream_descriptor::read_some]
     37091
     37092Read some data from the descriptor.
     37093
     37094  template<
     37095      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
     37096  std::size_t ``[link boost_asio.reference.posix__basic_stream_descriptor.read_some.overload1 read_some]``(
     37097      const MutableBufferSequence & buffers);
     37098
     37099  template<
     37100      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
     37101  std::size_t ``[link boost_asio.reference.posix__basic_stream_descriptor.read_some.overload2 read_some]``(
     37102      const MutableBufferSequence & buffers,
     37103      boost::system::error_code & ec);
     37104
     37105
     37106[section:overload1 posix::basic_stream_descriptor::read_some (1 of 2 overloads)]
     37107
     37108Read some data from the descriptor.
     37109
     37110  template<
     37111      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
     37112  std::size_t read_some(
     37113      const MutableBufferSequence & buffers);
     37114
     37115
     37116This function is used to read data from the stream descriptor. The function call will block until one or more bytes of data has been read successfully, or until an error occurs.
     37117
     37118
     37119[heading Parameters]
     37120   
     37121
     37122[variablelist
     37123 
     37124[[buffers][One or more buffers into which the data will be read.]]
     37125
     37126]
     37127
     37128[heading Return Value]
     37129     
     37130The number of bytes read.
     37131
     37132[heading Exceptions]
     37133   
     37134
     37135[variablelist
     37136 
     37137[[boost::system::system_error][Thrown on failure. An error code of boost::asio::error::eof indicates that the connection was closed by the peer.]]
     37138
     37139]
     37140
     37141[heading Remarks]
     37142     
     37143The read\_some operation may not read all of the requested number of bytes. Consider using the
     37144[link boost_asio.reference.read read]  function if you need to ensure that the requested amount of data is read before the blocking operation completes.
     37145
     37146[heading Example]
     37147 
     37148To read into a single data buffer use the
     37149[link boost_asio.reference.buffer buffer]  function as follows:
     37150
     37151   descriptor.read_some(boost::asio::buffer(data, size));
     37152
     37153
     37154See the
     37155[link boost_asio.reference.buffer buffer]  documentation for information on reading into multiple buffers in one go, and how to use it with arrays, boost::array or std::vector.
     37156
     37157
     37158
     37159[endsect]
     37160
     37161
     37162
     37163[section:overload2 posix::basic_stream_descriptor::read_some (2 of 2 overloads)]
     37164
     37165Read some data from the descriptor.
     37166
     37167  template<
     37168      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
     37169  std::size_t read_some(
     37170      const MutableBufferSequence & buffers,
     37171      boost::system::error_code & ec);
     37172
     37173
     37174This function is used to read data from the stream descriptor. The function call will block until one or more bytes of data has been read successfully, or until an error occurs.
     37175
     37176
     37177[heading Parameters]
     37178   
     37179
     37180[variablelist
     37181 
     37182[[buffers][One or more buffers into which the data will be read.]]
     37183
     37184[[ec][Set to indicate what error occurred, if any.]]
     37185
     37186]
     37187
     37188[heading Return Value]
     37189     
     37190The number of bytes read. Returns 0 if an error occurred.
     37191
     37192[heading Remarks]
     37193     
     37194The read\_some operation may not read all of the requested number of bytes. Consider using the
     37195[link boost_asio.reference.read read]  function if you need to ensure that the requested amount of data is read before the blocking operation completes.
     37196
     37197
     37198
     37199[endsect]
     37200
     37201
     37202[endsect]
     37203
     37204
     37205[section:service posix::basic_stream_descriptor::service]
     37206
     37207
     37208['Inherited from basic_io_object.]
     37209
     37210The service associated with the I/O object.
     37211
     37212  service_type & service;
     37213
     37214
     37215
     37216[endsect]
     37217
     37218
     37219
     37220[section:service_type posix::basic_stream_descriptor::service_type]
     37221
     37222
     37223['Inherited from basic_io_object.]
     37224
     37225The type of the service that will be used to provide I/O operations.
     37226
     37227  typedef StreamDescriptorService service_type;
     37228
     37229
     37230
     37231
     37232[endsect]
     37233
     37234
     37235[section:write_some posix::basic_stream_descriptor::write_some]
     37236
     37237Write some data to the descriptor.
     37238
     37239  template<
     37240      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
     37241  std::size_t ``[link boost_asio.reference.posix__basic_stream_descriptor.write_some.overload1 write_some]``(
     37242      const ConstBufferSequence & buffers);
     37243
     37244  template<
     37245      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
     37246  std::size_t ``[link boost_asio.reference.posix__basic_stream_descriptor.write_some.overload2 write_some]``(
     37247      const ConstBufferSequence & buffers,
     37248      boost::system::error_code & ec);
     37249
     37250
     37251[section:overload1 posix::basic_stream_descriptor::write_some (1 of 2 overloads)]
     37252
     37253Write some data to the descriptor.
     37254
     37255  template<
     37256      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
     37257  std::size_t write_some(
     37258      const ConstBufferSequence & buffers);
     37259
     37260
     37261This function is used to write data to the stream descriptor. The function call will block until one or more bytes of the data has been written successfully, or until an error occurs.
     37262
     37263
     37264[heading Parameters]
     37265   
     37266
     37267[variablelist
     37268 
     37269[[buffers][One or more data buffers to be written to the descriptor.]]
     37270
     37271]
     37272
     37273[heading Return Value]
     37274     
     37275The number of bytes written.
     37276
     37277[heading Exceptions]
     37278   
     37279
     37280[variablelist
     37281 
     37282[[boost::system::system_error][Thrown on failure. An error code of boost::asio::error::eof indicates that the connection was closed by the peer.]]
     37283
     37284]
     37285
     37286[heading Remarks]
     37287     
     37288The write\_some operation may not transmit all of the data to the peer. Consider using the
     37289[link boost_asio.reference.write write]  function if you need to ensure that all data is written before the blocking operation completes.
     37290
     37291[heading Example]
     37292 
     37293To write a single data buffer use the
     37294[link boost_asio.reference.buffer buffer]  function as follows:
     37295
     37296   descriptor.write_some(boost::asio::buffer(data, size));
     37297
     37298
     37299See the
     37300[link boost_asio.reference.buffer buffer]  documentation for information on writing multiple buffers in one go, and how to use it with arrays, boost::array or std::vector.
     37301
     37302
     37303
     37304[endsect]
     37305
     37306
     37307
     37308[section:overload2 posix::basic_stream_descriptor::write_some (2 of 2 overloads)]
     37309
     37310Write some data to the descriptor.
     37311
     37312  template<
     37313      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
     37314  std::size_t write_some(
     37315      const ConstBufferSequence & buffers,
     37316      boost::system::error_code & ec);
     37317
     37318
     37319This function is used to write data to the stream descriptor. The function call will block until one or more bytes of the data has been written successfully, or until an error occurs.
     37320
     37321
     37322[heading Parameters]
     37323   
     37324
     37325[variablelist
     37326 
     37327[[buffers][One or more data buffers to be written to the descriptor.]]
     37328
     37329[[ec][Set to indicate what error occurred, if any.]]
     37330
     37331]
     37332
     37333[heading Return Value]
     37334     
     37335The number of bytes written. Returns 0 if an error occurred.
     37336
     37337[heading Remarks]
     37338     
     37339The write\_some operation may not transmit all of the data to the peer. Consider using the
     37340[link boost_asio.reference.write write]  function if you need to ensure that all data is written before the blocking operation completes.
     37341
     37342
     37343
     37344[endsect]
     37345
     37346
     37347[endsect]
     37348
     37349
     37350[endsect]
     37351
     37352[section:posix__descriptor_base posix::descriptor_base]
     37353
     37354The descriptor_base class is used as a base for the basic_stream_descriptor class template so that we have a common place to define the associated IO control commands.
     37355
     37356  class descriptor_base
     37357
     37358
     37359[heading Types]
     37360[table
     37361  [[Name][Description]]
     37362
     37363  [
     37364
     37365    [[link boost_asio.reference.posix__descriptor_base.bytes_readable [*bytes_readable]]]
     37366    [IO control command to get the amount of data that can be read without blocking. ]
     37367 
     37368  ]
     37369
     37370  [
     37371
     37372    [[link boost_asio.reference.posix__descriptor_base.non_blocking_io [*non_blocking_io]]]
     37373    [IO control command to set the blocking mode of the descriptor. ]
     37374 
     37375  ]
     37376
     37377]
     37378
     37379[heading Protected Member Functions]
     37380[table
     37381  [[Name][Description]]
     37382
     37383  [
     37384    [[link boost_asio.reference.posix__descriptor_base._descriptor_base [*~descriptor_base]]]
     37385    [Protected destructor to prevent deletion through this type. ]
     37386  ]
     37387 
     37388]
     37389
     37390
     37391[section:bytes_readable posix::descriptor_base::bytes_readable]
     37392
     37393IO control command to get the amount of data that can be read without blocking.
     37394
     37395  typedef implementation_defined bytes_readable;
     37396
     37397
     37398
     37399Implements the FIONREAD IO control command.
     37400
     37401
     37402[heading Example]
     37403 
     37404
     37405
     37406   boost::asio::posix::stream_descriptor descriptor(io_service);
     37407   ...
     37408   boost::asio::descriptor_base::bytes_readable command(true);
     37409   descriptor.io_control(command);
     37410   std::size_t bytes_readable = command.get();
     37411
     37412
     37413
     37414
     37415
     37416
     37417[endsect]
     37418
     37419
     37420
     37421[section:non_blocking_io posix::descriptor_base::non_blocking_io]
     37422
     37423IO control command to set the blocking mode of the descriptor.
     37424
     37425  typedef implementation_defined non_blocking_io;
     37426
     37427
     37428
     37429Implements the FIONBIO IO control command.
     37430
     37431
     37432[heading Example]
     37433 
     37434
     37435
     37436   boost::asio::posix::stream_descriptor descriptor(io_service);
     37437   ...
     37438   boost::asio::descriptor_base::non_blocking_io command(true);
     37439   descriptor.io_control(command);
     37440
     37441
     37442
     37443
     37444
     37445
     37446[endsect]
     37447
     37448
     37449
     37450[section:_descriptor_base posix::descriptor_base::~descriptor_base]
     37451
     37452Protected destructor to prevent deletion through this type.
     37453
     37454  ~descriptor_base();
     37455
     37456
     37457
     37458[endsect]
     37459
     37460
     37461
     37462[endsect]
     37463
     37464
     37465[section:posix__stream_descriptor posix::stream_descriptor]
     37466
     37467Typedef for the typical usage of a stream-oriented descriptor.
     37468
     37469  typedef basic_stream_descriptor stream_descriptor;
     37470
     37471
     37472[heading Types]
     37473[table
     37474  [[Name][Description]]
     37475
     37476  [
     37477
     37478    [[link boost_asio.reference.posix__basic_stream_descriptor.bytes_readable [*bytes_readable]]]
     37479    [IO control command to get the amount of data that can be read without blocking. ]
     37480 
     37481  ]
     37482
     37483  [
     37484
     37485    [[link boost_asio.reference.posix__basic_stream_descriptor.implementation_type [*implementation_type]]]
     37486    [The underlying implementation type of I/O object. ]
     37487 
     37488  ]
     37489
     37490  [
     37491
     37492    [[link boost_asio.reference.posix__basic_stream_descriptor.lowest_layer_type [*lowest_layer_type]]]
     37493    [A basic_descriptor is always the lowest layer. ]
     37494 
     37495  ]
     37496
     37497  [
     37498
     37499    [[link boost_asio.reference.posix__basic_stream_descriptor.native_type [*native_type]]]
     37500    [The native representation of a descriptor. ]
     37501 
     37502  ]
     37503
     37504  [
     37505
     37506    [[link boost_asio.reference.posix__basic_stream_descriptor.non_blocking_io [*non_blocking_io]]]
     37507    [IO control command to set the blocking mode of the descriptor. ]
     37508 
     37509  ]
     37510
     37511  [
     37512
     37513    [[link boost_asio.reference.posix__basic_stream_descriptor.service_type [*service_type]]]
     37514    [The type of the service that will be used to provide I/O operations. ]
     37515 
     37516  ]
     37517
     37518]
     37519
     37520[heading Member Functions]
     37521[table
     37522  [[Name][Description]]
     37523
     37524  [
     37525    [[link boost_asio.reference.posix__basic_stream_descriptor.assign [*assign]]]
     37526    [Assign an existing native descriptor to the descriptor. ]
     37527  ]
     37528 
     37529  [
     37530    [[link boost_asio.reference.posix__basic_stream_descriptor.async_read_some [*async_read_some]]]
     37531    [Start an asynchronous read. ]
     37532  ]
     37533 
     37534  [
     37535    [[link boost_asio.reference.posix__basic_stream_descriptor.async_write_some [*async_write_some]]]
     37536    [Start an asynchronous write. ]
     37537  ]
     37538 
     37539  [
     37540    [[link boost_asio.reference.posix__basic_stream_descriptor.basic_stream_descriptor [*basic_stream_descriptor]]]
     37541    [Construct a basic_stream_descriptor without opening it. ]
     37542  ]
     37543 
     37544  [
     37545    [[link boost_asio.reference.posix__basic_stream_descriptor.cancel [*cancel]]]
     37546    [Cancel all asynchronous operations associated with the descriptor. ]
     37547  ]
     37548 
     37549  [
     37550    [[link boost_asio.reference.posix__basic_stream_descriptor.close [*close]]]
     37551    [Close the descriptor. ]
     37552  ]
     37553 
     37554  [
     37555    [[link boost_asio.reference.posix__basic_stream_descriptor.get_io_service [*get_io_service]]]
     37556    [Get the io_service associated with the object. ]
     37557  ]
     37558 
     37559  [
     37560    [[link boost_asio.reference.posix__basic_stream_descriptor.io_control [*io_control]]]
     37561    [Perform an IO control command on the descriptor. ]
     37562  ]
     37563 
     37564  [
     37565    [[link boost_asio.reference.posix__basic_stream_descriptor.io_service [*io_service]]]
     37566    [(Deprecated: use get_io_service().) Get the io_service associated with the object. ]
     37567  ]
     37568 
     37569  [
     37570    [[link boost_asio.reference.posix__basic_stream_descriptor.is_open [*is_open]]]
     37571    [Determine whether the descriptor is open. ]
     37572  ]
     37573 
     37574  [
     37575    [[link boost_asio.reference.posix__basic_stream_descriptor.lowest_layer [*lowest_layer]]]
     37576    [Get a reference to the lowest layer. ]
     37577  ]
     37578 
     37579  [
     37580    [[link boost_asio.reference.posix__basic_stream_descriptor.native [*native]]]
     37581    [Get the native descriptor representation. ]
     37582  ]
     37583 
     37584  [
     37585    [[link boost_asio.reference.posix__basic_stream_descriptor.read_some [*read_some]]]
     37586    [Read some data from the descriptor. ]
     37587  ]
     37588 
     37589  [
     37590    [[link boost_asio.reference.posix__basic_stream_descriptor.write_some [*write_some]]]
     37591    [Write some data to the descriptor. ]
     37592  ]
     37593 
     37594]
     37595
     37596[heading Protected Data Members]
     37597[table
     37598  [[Name][Description]]
     37599
     37600  [
     37601    [[link boost_asio.reference.posix__basic_stream_descriptor.implementation [*implementation]]]
     37602    [The underlying implementation of the I/O object. ]
     37603  ]
     37604
     37605  [
     37606    [[link boost_asio.reference.posix__basic_stream_descriptor.service [*service]]]
     37607    [The service associated with the I/O object. ]
     37608  ]
     37609
     37610]
     37611
     37612The posix::basic_stream_descriptor class template provides asynchronous and blocking stream-oriented descriptor functionality.
     37613
     37614
     37615[heading Thread Safety]
     37616 
     37617[*Distinct] [*objects:]  Safe.
     37618
     37619[*Shared] [*objects:]  Unsafe.
     37620
     37621
     37622
     37623
     37624[endsect]
     37625
     37626
     37627[section:posix__stream_descriptor_service posix::stream_descriptor_service]
     37628
     37629Default service implementation for a stream descriptor.
     37630
     37631  class stream_descriptor_service :
     37632    public io_service::service
     37633
     37634
     37635[heading Types]
     37636[table
     37637  [[Name][Description]]
     37638
     37639  [
     37640
     37641    [[link boost_asio.reference.posix__stream_descriptor_service.implementation_type [*implementation_type]]]
     37642    [The type of a stream descriptor implementation. ]
     37643 
     37644  ]
     37645
     37646  [
     37647
     37648    [[link boost_asio.reference.posix__stream_descriptor_service.native_type [*native_type]]]
     37649    [The native descriptor type. ]
     37650 
     37651  ]
     37652
     37653]
     37654
     37655[heading Member Functions]
     37656[table
     37657  [[Name][Description]]
     37658
     37659  [
     37660    [[link boost_asio.reference.posix__stream_descriptor_service.assign [*assign]]]
     37661    [Assign an existing native descriptor to a stream descriptor. ]
     37662  ]
     37663 
     37664  [
     37665    [[link boost_asio.reference.posix__stream_descriptor_service.async_read_some [*async_read_some]]]
     37666    [Start an asynchronous read. ]
     37667  ]
     37668 
     37669  [
     37670    [[link boost_asio.reference.posix__stream_descriptor_service.async_write_some [*async_write_some]]]
     37671    [Start an asynchronous write. ]
     37672  ]
     37673 
     37674  [
     37675    [[link boost_asio.reference.posix__stream_descriptor_service.cancel [*cancel]]]
     37676    [Cancel all asynchronous operations associated with the descriptor. ]
     37677  ]
     37678 
     37679  [
     37680    [[link boost_asio.reference.posix__stream_descriptor_service.close [*close]]]
     37681    [Close a stream descriptor implementation. ]
     37682  ]
     37683 
     37684  [
     37685    [[link boost_asio.reference.posix__stream_descriptor_service.construct [*construct]]]
     37686    [Construct a new stream descriptor implementation. ]
     37687  ]
     37688 
     37689  [
     37690    [[link boost_asio.reference.posix__stream_descriptor_service.destroy [*destroy]]]
     37691    [Destroy a stream descriptor implementation. ]
     37692  ]
     37693 
     37694  [
     37695    [[link boost_asio.reference.posix__stream_descriptor_service.get_io_service [*get_io_service]]]
     37696    [Get the io_service object that owns the service. ]
     37697  ]
     37698 
     37699  [
     37700    [[link boost_asio.reference.posix__stream_descriptor_service.io_control [*io_control]]]
     37701    [Perform an IO control command on the descriptor. ]
     37702  ]
     37703 
     37704  [
     37705    [[link boost_asio.reference.posix__stream_descriptor_service.io_service [*io_service]]]
     37706    [(Deprecated: use get_io_service().) Get the io_service object that owns the service. ]
     37707  ]
     37708 
     37709  [
     37710    [[link boost_asio.reference.posix__stream_descriptor_service.is_open [*is_open]]]
     37711    [Determine whether the descriptor is open. ]
     37712  ]
     37713 
     37714  [
     37715    [[link boost_asio.reference.posix__stream_descriptor_service.native [*native]]]
     37716    [Get the native descriptor implementation. ]
     37717  ]
     37718 
     37719  [
     37720    [[link boost_asio.reference.posix__stream_descriptor_service.read_some [*read_some]]]
     37721    [Read some data from the stream. ]
     37722  ]
     37723 
     37724  [
     37725    [[link boost_asio.reference.posix__stream_descriptor_service.shutdown_service [*shutdown_service]]]
     37726    [Destroy all user-defined descriptorr objects owned by the service. ]
     37727  ]
     37728 
     37729  [
     37730    [[link boost_asio.reference.posix__stream_descriptor_service.stream_descriptor_service [*stream_descriptor_service]]]
     37731    [Construct a new stream descriptor service for the specified io_service. ]
     37732  ]
     37733 
     37734  [
     37735    [[link boost_asio.reference.posix__stream_descriptor_service.write_some [*write_some]]]
     37736    [Write the given data to the stream. ]
     37737  ]
     37738 
     37739]
     37740
     37741[heading Data Members]
     37742[table
     37743  [[Name][Description]]
     37744
     37745  [
     37746    [[link boost_asio.reference.posix__stream_descriptor_service.id [*id]]]
     37747    [The unique service identifier. ]
     37748  ]
     37749
     37750]
     37751
     37752
     37753[section:assign posix::stream_descriptor_service::assign]
     37754
     37755Assign an existing native descriptor to a stream descriptor.
     37756
     37757  boost::system::error_code assign(
     37758      implementation_type & impl,
     37759      const native_type & native_descriptor,
     37760      boost::system::error_code & ec);
     37761
     37762
     37763
     37764[endsect]
     37765
     37766
     37767
     37768[section:async_read_some posix::stream_descriptor_service::async_read_some]
     37769
     37770Start an asynchronous read.
     37771
     37772  template<
     37773      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
     37774      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
     37775  void async_read_some(
     37776      implementation_type & impl,
     37777      const MutableBufferSequence & buffers,
     37778      ReadHandler descriptorr);
     37779
     37780
     37781
     37782[endsect]
     37783
     37784
     37785
     37786[section:async_write_some posix::stream_descriptor_service::async_write_some]
     37787
     37788Start an asynchronous write.
     37789
     37790  template<
     37791      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
     37792      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
     37793  void async_write_some(
     37794      implementation_type & impl,
     37795      const ConstBufferSequence & buffers,
     37796      WriteHandler descriptorr);
     37797
     37798
     37799
     37800[endsect]
     37801
     37802
     37803
     37804[section:cancel posix::stream_descriptor_service::cancel]
     37805
     37806Cancel all asynchronous operations associated with the descriptor.
     37807
     37808  boost::system::error_code cancel(
     37809      implementation_type & impl,
     37810      boost::system::error_code & ec);
     37811
     37812
     37813
     37814[endsect]
     37815
     37816
     37817
     37818[section:close posix::stream_descriptor_service::close]
     37819
     37820Close a stream descriptor implementation.
     37821
     37822  boost::system::error_code close(
     37823      implementation_type & impl,
     37824      boost::system::error_code & ec);
     37825
     37826
     37827
     37828[endsect]
     37829
     37830
     37831
     37832[section:construct posix::stream_descriptor_service::construct]
     37833
     37834Construct a new stream descriptor implementation.
     37835
     37836  void construct(
     37837      implementation_type & impl);
     37838
     37839
     37840
     37841[endsect]
     37842
     37843
     37844
     37845[section:destroy posix::stream_descriptor_service::destroy]
     37846
     37847Destroy a stream descriptor implementation.
     37848
     37849  void destroy(
     37850      implementation_type & impl);
     37851
     37852
     37853
     37854[endsect]
     37855
     37856
     37857
     37858[section:get_io_service posix::stream_descriptor_service::get_io_service]
     37859
     37860
     37861['Inherited from io_service.]
     37862
     37863Get the io_service object that owns the service.
     37864
     37865  boost::asio::io_service & get_io_service();
     37866
     37867
     37868
     37869[endsect]
     37870
     37871
     37872
     37873[section:id posix::stream_descriptor_service::id]
     37874
     37875The unique service identifier.
     37876
     37877  static boost::asio::io_service::id id;
     37878
     37879
     37880
     37881[endsect]
     37882
     37883
     37884
     37885[section:implementation_type posix::stream_descriptor_service::implementation_type]
     37886
     37887The type of a stream descriptor implementation.
     37888
     37889  typedef implementation_defined implementation_type;
     37890
     37891
     37892
     37893
     37894[endsect]
     37895
     37896
     37897
     37898[section:io_control posix::stream_descriptor_service::io_control]
     37899
     37900Perform an IO control command on the descriptor.
     37901
     37902  template<
     37903      typename ``[link boost_asio.reference.IoControlCommand IoControlCommand]``>
     37904  boost::system::error_code io_control(
     37905      implementation_type & impl,
     37906      IoControlCommand & command,
     37907      boost::system::error_code & ec);
     37908
     37909
     37910
     37911[endsect]
     37912
     37913
     37914
     37915[section:io_service posix::stream_descriptor_service::io_service]
     37916
     37917
     37918['Inherited from io_service.]
     37919
     37920(Deprecated: use get_io_service().) Get the io_service object that owns the service.
     37921
     37922  boost::asio::io_service & io_service();
     37923
     37924
     37925
     37926[endsect]
     37927
     37928
     37929
     37930[section:is_open posix::stream_descriptor_service::is_open]
     37931
     37932Determine whether the descriptor is open.
     37933
     37934  bool is_open(
     37935      const implementation_type & impl) const;
     37936
     37937
     37938
     37939[endsect]
     37940
     37941
     37942
     37943[section:native posix::stream_descriptor_service::native]
     37944
     37945Get the native descriptor implementation.
     37946
     37947  native_type native(
     37948      implementation_type & impl);
     37949
     37950
     37951
     37952[endsect]
     37953
     37954
     37955
     37956[section:native_type posix::stream_descriptor_service::native_type]
     37957
     37958The native descriptor type.
     37959
     37960  typedef implementation_defined native_type;
     37961
     37962
     37963
     37964
     37965[endsect]
     37966
     37967
     37968
     37969[section:read_some posix::stream_descriptor_service::read_some]
     37970
     37971Read some data from the stream.
     37972
     37973  template<
     37974      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
     37975  std::size_t read_some(
     37976      implementation_type & impl,
     37977      const MutableBufferSequence & buffers,
     37978      boost::system::error_code & ec);
     37979
     37980
     37981
     37982[endsect]
     37983
     37984
     37985
     37986[section:shutdown_service posix::stream_descriptor_service::shutdown_service]
     37987
     37988Destroy all user-defined descriptorr objects owned by the service.
     37989
     37990  void shutdown_service();
     37991
     37992
     37993
     37994[endsect]
     37995
     37996
     37997
     37998[section:stream_descriptor_service posix::stream_descriptor_service::stream_descriptor_service]
     37999
     38000Construct a new stream descriptor service for the specified io_service.
     38001
     38002  stream_descriptor_service(
     38003      boost::asio::io_service & io_service);
     38004
     38005
     38006
     38007[endsect]
     38008
     38009
     38010
     38011[section:write_some posix::stream_descriptor_service::write_some]
     38012
     38013Write the given data to the stream.
     38014
     38015  template<
     38016      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
     38017  std::size_t write_some(
     38018      implementation_type & impl,
     38019      const ConstBufferSequence & buffers,
     38020      boost::system::error_code & ec);
     38021
     38022
     38023
     38024[endsect]
     38025
     38026
     38027
     38028[endsect]
    3161238029
    3161338030[section:read read]
     
    3315339570]
    3315439571
     39572[heading Protected Member Functions]
     39573[table
     39574  [[Name][Description]]
     39575
     39576  [
     39577    [[link boost_asio.reference.socket_base._socket_base [*~socket_base]]]
     39578    [Protected destructor to prevent deletion through this type. ]
     39579  ]
     39580 
     39581]
     39582
    3315539583[heading Data Members]
    3315639584[table
     
    3377340201
    3377440202
     40203[section:_socket_base socket_base::~socket_base]
     40204
     40205Protected destructor to prevent deletion through this type.
     40206
     40207  ~socket_base();
     40208
     40209
     40210
     40211[endsect]
     40212
     40213
     40214
    3377540215[endsect]
    3377640216
     
    3539441834]
    3539541835
     41836[heading Protected Member Functions]
     41837[table
     41838  [[Name][Description]]
     41839
     41840  [
     41841    [[link boost_asio.reference.ssl__context_base._context_base [*~context_base]]]
     41842    [Protected destructor to prevent deletion through this type. ]
     41843  ]
     41844 
     41845]
     41846
    3539641847[heading Data Members]
    3539741848[table
     
    3570442155
    3570542156  static const int verify_peer = implementation_defined;
     42157
     42158
     42159
     42160[endsect]
     42161
     42162
     42163
     42164[section:_context_base ssl::context_base::~context_base]
     42165
     42166Protected destructor to prevent deletion through this type.
     42167
     42168  ~context_base();
    3570642169
    3570742170
     
    3718843651]
    3718943652
     43653[heading Protected Member Functions]
     43654[table
     43655  [[Name][Description]]
     43656
     43657  [
     43658    [[link boost_asio.reference.ssl__stream_base._stream_base [*~stream_base]]]
     43659    [Protected destructor to prevent deletion through this type. ]
     43660  ]
     43661 
     43662]
     43663
    3719043664
    3719143665[section:handshake_type ssl::stream_base::handshake_type]
     
    3720943683
    3721043684]
     43685
     43686
     43687
     43688[endsect]
     43689
     43690
     43691
     43692[section:_stream_base ssl::stream_base::~stream_base]
     43693
     43694Protected destructor to prevent deletion through this type.
     43695
     43696  ~stream_base();
    3721143697
    3721243698
     
    3845744943    [[link boost_asio.reference.basic_streambuf.size [*size]]]
    3845844944    [Return the size of the get area in characters. ]
     44945  ]
     44946 
     44947]
     44948
     44949[heading Protected Member Functions]
     44950[table
     44951  [[Name][Description]]
     44952
     44953  [
     44954    [[link boost_asio.reference.basic_streambuf.overflow [*overflow]]]
     44955    []
     44956  ]
     44957 
     44958  [
     44959    [[link boost_asio.reference.basic_streambuf.reserve [*reserve]]]
     44960    []
     44961  ]
     44962 
     44963  [
     44964    [[link boost_asio.reference.basic_streambuf.underflow [*underflow]]]
     44965    []
    3845944966  ]
    3846044967 
     
    3872845235
    3872945236
     45237[section:windows__basic_handle windows::basic_handle]
     45238
     45239Provides Windows handle functionality.
     45240
     45241  template<
     45242      typename ``[link boost_asio.reference.HandleService HandleService]``>
     45243  class basic_handle :
     45244    public basic_io_object< HandleService >
     45245
     45246
     45247[heading Types]
     45248[table
     45249  [[Name][Description]]
     45250
     45251  [
     45252
     45253    [[link boost_asio.reference.windows__basic_handle.implementation_type [*implementation_type]]]
     45254    [The underlying implementation type of I/O object. ]
     45255 
     45256  ]
     45257
     45258  [
     45259
     45260    [[link boost_asio.reference.windows__basic_handle.lowest_layer_type [*lowest_layer_type]]]
     45261    [A basic_handle is always the lowest layer. ]
     45262 
     45263  ]
     45264
     45265  [
     45266
     45267    [[link boost_asio.reference.windows__basic_handle.native_type [*native_type]]]
     45268    [The native representation of a handle. ]
     45269 
     45270  ]
     45271
     45272  [
     45273
     45274    [[link boost_asio.reference.windows__basic_handle.service_type [*service_type]]]
     45275    [The type of the service that will be used to provide I/O operations. ]
     45276 
     45277  ]
     45278
     45279]
     45280
     45281[heading Member Functions]
     45282[table
     45283  [[Name][Description]]
     45284
     45285  [
     45286    [[link boost_asio.reference.windows__basic_handle.assign [*assign]]]
     45287    [Assign an existing native handle to the handle. ]
     45288  ]
     45289 
     45290  [
     45291    [[link boost_asio.reference.windows__basic_handle.basic_handle [*basic_handle]]]
     45292    [Construct a basic_handle without opening it. ]
     45293  ]
     45294 
     45295  [
     45296    [[link boost_asio.reference.windows__basic_handle.cancel [*cancel]]]
     45297    [Cancel all asynchronous operations associated with the handle. ]
     45298  ]
     45299 
     45300  [
     45301    [[link boost_asio.reference.windows__basic_handle.close [*close]]]
     45302    [Close the handle. ]
     45303  ]
     45304 
     45305  [
     45306    [[link boost_asio.reference.windows__basic_handle.get_io_service [*get_io_service]]]
     45307    [Get the io_service associated with the object. ]
     45308  ]
     45309 
     45310  [
     45311    [[link boost_asio.reference.windows__basic_handle.io_service [*io_service]]]
     45312    [(Deprecated: use get_io_service().) Get the io_service associated with the object. ]
     45313  ]
     45314 
     45315  [
     45316    [[link boost_asio.reference.windows__basic_handle.is_open [*is_open]]]
     45317    [Determine whether the handle is open. ]
     45318  ]
     45319 
     45320  [
     45321    [[link boost_asio.reference.windows__basic_handle.lowest_layer [*lowest_layer]]]
     45322    [Get a reference to the lowest layer. ]
     45323  ]
     45324 
     45325  [
     45326    [[link boost_asio.reference.windows__basic_handle.native [*native]]]
     45327    [Get the native handle representation. ]
     45328  ]
     45329 
     45330]
     45331
     45332[heading Protected Member Functions]
     45333[table
     45334  [[Name][Description]]
     45335
     45336  [
     45337    [[link boost_asio.reference.windows__basic_handle._basic_handle [*~basic_handle]]]
     45338    [Protected destructor to prevent deletion through this type. ]
     45339  ]
     45340 
     45341]
     45342
     45343[heading Protected Data Members]
     45344[table
     45345  [[Name][Description]]
     45346
     45347  [
     45348    [[link boost_asio.reference.windows__basic_handle.implementation [*implementation]]]
     45349    [The underlying implementation of the I/O object. ]
     45350  ]
     45351
     45352  [
     45353    [[link boost_asio.reference.windows__basic_handle.service [*service]]]
     45354    [The service associated with the I/O object. ]
     45355  ]
     45356
     45357]
     45358
     45359The windows::basic_handle class template provides the ability to wrap a Windows handle.
     45360
     45361
     45362[heading Thread Safety]
     45363 
     45364[*Distinct] [*objects:]  Safe.
     45365
     45366[*Shared] [*objects:]  Unsafe.
     45367
     45368
     45369[section:assign windows::basic_handle::assign]
     45370
     45371Assign an existing native handle to the handle.
     45372
     45373  void ``[link boost_asio.reference.windows__basic_handle.assign.overload1 assign]``(
     45374      const native_type & native_handle);
     45375
     45376  boost::system::error_code ``[link boost_asio.reference.windows__basic_handle.assign.overload2 assign]``(
     45377      const native_type & native_handle,
     45378      boost::system::error_code & ec);
     45379
     45380
     45381[section:overload1 windows::basic_handle::assign (1 of 2 overloads)]
     45382
     45383Assign an existing native handle to the handle.
     45384
     45385  void assign(
     45386      const native_type & native_handle);
     45387
     45388
     45389
     45390[endsect]
     45391
     45392
     45393
     45394[section:overload2 windows::basic_handle::assign (2 of 2 overloads)]
     45395
     45396Assign an existing native handle to the handle.
     45397
     45398  boost::system::error_code assign(
     45399      const native_type &