[/
 / Copyright (c) 2003-2008 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 /
 / Distributed under the Boost Software License, Version 1.0. (See accompanying
 / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 /]

[section:reference Reference]

[xinclude quickref.xml]

[include requirements/asynchronous_operations.qbk]
[include requirements/AcceptHandler.qbk]
[include requirements/AsyncRandomAccessReadDevice.qbk]
[include requirements/AsyncRandomAccessWriteDevice.qbk]
[include requirements/AsyncReadStream.qbk]
[include requirements/AsyncWriteStream.qbk]
[include requirements/CompletionHandler.qbk]
[include requirements/ConnectHandler.qbk]
[include requirements/ConstBufferSequence.qbk]
[include requirements/ConvertibleToConstBuffer.qbk]
[include requirements/ConvertibleToMutableBuffer.qbk]
[include requirements/DatagramSocketService.qbk]
[include requirements/DescriptorService.qbk]
[include requirements/Endpoint.qbk]
[include requirements/GettableSerialPortOption.qbk]
[include requirements/GettableSocketOption.qbk]
[include requirements/Handler.qbk]
[include requirements/HandleService.qbk]
[include requirements/InternetProtocol.qbk]
[include requirements/IoControlCommand.qbk]
[include requirements/IoObjectService.qbk]
[include requirements/MutableBufferSequence.qbk]
[include requirements/Protocol.qbk]
[include requirements/RandomAccessHandleService.qbk]
[include requirements/RawSocketService.qbk]
[include requirements/ReadHandler.qbk]
[include requirements/ResolveHandler.qbk]
[include requirements/ResolverService.qbk]
[include requirements/SerialPortService.qbk]
[include requirements/Service.qbk]
[include requirements/SettableSerialPortOption.qbk]
[include requirements/SettableSocketOption.qbk]
[include requirements/SocketAcceptorService.qbk]
[include requirements/SocketService.qbk]
[include requirements/StreamDescriptorService.qbk]
[include requirements/StreamHandleService.qbk]
[include requirements/StreamSocketService.qbk]
[include requirements/SyncRandomAccessReadDevice.qbk]
[include requirements/SyncRandomAccessWriteDevice.qbk]
[include requirements/SyncReadStream.qbk]
[include requirements/SyncWriteStream.qbk]
[include requirements/TimeTraits.qbk]
[include requirements/TimerService.qbk]
[include requirements/WaitHandler.qbk]
[include requirements/WriteHandler.qbk]



[section:add_service add_service]

[indexterm1 add_service] 

  template<
      typename ``[link boost_asio.reference.Service Service]``>
  void add_service(
      io_service & ios,
      Service * svc);


This function is used to add a service to the io_service.


[heading Parameters]
    

[variablelist
  
[[ios][The io\_service object that owns the service.]]

[[svc][The service object. On success, ownership of the service object is transferred to the io\_service. When the io\_service object is destroyed, it will destroy the service object by performing: 
``
   delete static_cast<io_service::service*>(svc) 
``
]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::asio::service_already_exists][Thrown if a service of the given type is already present in the io\_service.]]

[[boost::asio::invalid_service_owner][Thrown if the service's owning io\_service is not the io\_service object specified by the ios parameter. ]]

]



[endsect]



[section:asio_handler_allocate asio_handler_allocate]

[indexterm1 asio_handler_allocate] Default allocation function for handlers. 

  void * asio_handler_allocate(
      std::size_t size,
      ... );


Asynchronous operations may need to allocate temporary objects. Since asynchronous operations have a handler function object, these temporary objects can be said to be associated with the handler.

Implement asio\_handler\_allocate and asio\_handler\_deallocate for your own handlers to provide custom allocation for these temporary objects.

This default implementation is simply: 

   return ::operator new(size);





[heading Remarks]
      
All temporary objects associated with a handler will be deallocated before the upcall to the handler is performed. This allows the same memory to be reused for a subsequent asynchronous operation initiated by the handler.

[heading Example]
  


   class my_handler;

   void* asio_handler_allocate(std::size_t size, my_handler* context)
   {
     return ::operator new(size);
   }

   void asio_handler_deallocate(void* pointer, std::size_t size,
       my_handler* context)
   {
     ::operator delete(pointer);
   }






[endsect]



[section:asio_handler_deallocate asio_handler_deallocate]

[indexterm1 asio_handler_deallocate] Default deallocation function for handlers. 

  void asio_handler_deallocate(
      void * pointer,
      std::size_t size,
      ... );


Implement asio\_handler\_allocate and asio\_handler\_deallocate for your own handlers to provide custom allocation for the associated temporary objects.

This default implementation is simply: 

   ::operator delete(pointer);







[endsect]



[section:asio_handler_invoke asio_handler_invoke]

[indexterm1 asio_handler_invoke] Default invoke function for handlers. 

  template<
      typename Function>
  void asio_handler_invoke(
      Function function,
      ... );


Completion handlers for asynchronous operations are invoked by the io_service associated with the corresponding object (e.g. a socket or deadline\_timer). Certain guarantees are made on when the handler may be invoked, in particular that a handler can only be invoked from a thread that is currently calling boost::asio::io\_service::run() on the corresponding io_service object. Handlers may subsequently be invoked through other objects (such as boost::asio::strand objects) that provide additional guarantees.

When asynchronous operations are composed from other asynchronous operations, all intermediate handlers should be invoked using the same method as the final handler. This is required to ensure that user-defined objects are not accessed in a way that may violate the guarantees. This hooking function ensures that the invoked method used for the final handler is accessible at each intermediate step.

Implement asio\_handler\_invoke for your own handlers to specify a custom invocation strategy.

This default implementation is simply: 

   function();





[heading Example]
  


   class my_handler;

   template <typename Function>
   void asio_handler_invoke(Function function, my_handler* context)
   {
     context->strand_.dispatch(function);
   }






[endsect]


[section:async_read async_read]

[indexterm1 async_read] Start an asynchronous operation to read a certain amount of data from a stream. 
      
  template<
      typename ``[link boost_asio.reference.AsyncReadStream AsyncReadStream]``,
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
  void ``[link boost_asio.reference.async_read.overload1 async_read]``(
      AsyncReadStream & s,
      const MutableBufferSequence & buffers,
      ReadHandler handler);

  template<
      typename ``[link boost_asio.reference.AsyncReadStream AsyncReadStream]``,
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
      typename CompletionCondition,
      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
  void ``[link boost_asio.reference.async_read.overload2 async_read]``(
      AsyncReadStream & s,
      const MutableBufferSequence & buffers,
      CompletionCondition completion_condition,
      ReadHandler handler);

  template<
      typename ``[link boost_asio.reference.AsyncReadStream AsyncReadStream]``,
      typename Allocator,
      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
  void ``[link boost_asio.reference.async_read.overload3 async_read]``(
      AsyncReadStream & s,
      basic_streambuf< Allocator > & b,
      ReadHandler handler);

  template<
      typename ``[link boost_asio.reference.AsyncReadStream AsyncReadStream]``,
      typename Allocator,
      typename CompletionCondition,
      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
  void ``[link boost_asio.reference.async_read.overload4 async_read]``(
      AsyncReadStream & s,
      basic_streambuf< Allocator > & b,
      CompletionCondition completion_condition,
      ReadHandler handler);


[section:overload1 async_read (1 of 4 overloads)]

Start an asynchronous operation to read a certain amount of data from a stream. 

  template<
      typename ``[link boost_asio.reference.AsyncReadStream AsyncReadStream]``,
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
  void async_read(
      AsyncReadStream & s,
      const MutableBufferSequence & buffers,
      ReadHandler handler);


This function is used to asynchronously read a certain number of bytes of data from a stream. The function call always returns immediately. The asynchronous operation will continue until one of the following conditions is true:


* The supplied buffers are full. That is, the bytes transferred is equal to the sum of the buffer sizes.

* An error occurred.

This operation is implemented in terms of zero or more calls to the stream's async\_read\_some function.


[heading Parameters]
    

[variablelist
  
[[s][The stream from which the data is to be read. The type must support the AsyncReadStream concept.]]

[[buffers][One or more buffers into which the data will be read. The sum of the buffer sizes indicates the maximum number of bytes to read from the stream. 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.]]

[[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: 
``
   void handler(
     const boost::system::error_code& error, // Result of operation.

     std::size_t bytes_transferred           // Number of bytes copied into the
                                             // buffers. If an error occurred,
                                             // this will be the  number of
                                             // bytes successfully transferred
                                             // prior to the error.
   ); 
``
Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using boost::asio::io\_service::post().]]

]

[heading Example]
  
To read into a single data buffer use the 
[link boost_asio.reference.buffer buffer]  function as follows: 

   boost::asio::async_read(s, boost::asio::buffer(data, size), handler);


See the 
[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.

[heading Remarks]
      
This overload is equivalent to calling: 

   boost::asio::async_read(
       s, buffers,
       boost::asio::transfer_all(),
       handler); 






[endsect]



[section:overload2 async_read (2 of 4 overloads)]

Start an asynchronous operation to read a certain amount of data from a stream. 

  template<
      typename ``[link boost_asio.reference.AsyncReadStream AsyncReadStream]``,
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
      typename CompletionCondition,
      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
  void async_read(
      AsyncReadStream & s,
      const MutableBufferSequence & buffers,
      CompletionCondition completion_condition,
      ReadHandler handler);


This function is used to asynchronously read a certain number of bytes of data from a stream. The function call always returns immediately. The asynchronous operation will continue until one of the following conditions is true:


* The supplied buffers are full. That is, the bytes transferred is equal to the sum of the buffer sizes.

* The completion_condition function object returns 0.

[heading Parameters]
    

[variablelist
  
[[s][The stream from which the data is to be read. The type must support the AsyncReadStream concept.]]

[[buffers][One or more buffers into which the data will be read. The sum of the buffer sizes indicates the maximum number of bytes to read from the stream. 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.]]

[[completion_condition][The function object to be called to determine whether the read operation is complete. The signature of the function object must be: 
``
   std::size_t completion_condition(
     // Result of latest async_read_some operation.
     const boost::system::error_code& error,

     // Number of bytes transferred so far.
     std::size_t bytes_transferred
   ); 
``
A return value of 0 indicates that the read operation is complete. A non-zero return value indicates the maximum number of bytes to be read on the next call to the stream's async\_read\_some function.]]

[[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: 
``
   void handler(
     const boost::system::error_code& error, // Result of operation.

     std::size_t bytes_transferred           // Number of bytes copied into the
                                             // buffers. If an error occurred,
                                             // this will be the  number of
                                             // bytes successfully transferred
                                             // prior to the error.
   ); 
``
Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using boost::asio::io\_service::post().]]

]

[heading Example]
  
To read into a single data buffer use the 
[link boost_asio.reference.buffer buffer]  function as follows: 

   boost::asio::async_read(s,
       boost::asio::buffer(data, size),
       boost::asio::transfer_at_least(32),
       handler); 


See the 
[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. 



[endsect]



[section:overload3 async_read (3 of 4 overloads)]

Start an asynchronous operation to read a certain amount of data from a stream. 

  template<
      typename ``[link boost_asio.reference.AsyncReadStream AsyncReadStream]``,
      typename Allocator,
      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
  void async_read(
      AsyncReadStream & s,
      basic_streambuf< Allocator > & b,
      ReadHandler handler);


This function is used to asynchronously read a certain number of bytes of data from a stream. The function call always returns immediately. The asynchronous operation will continue until one of the following conditions is true:


* An error occurred.

This operation is implemented in terms of zero or more calls to the stream's async\_read\_some function.


[heading Parameters]
    

[variablelist
  
[[s][The stream from which the data is to be read. The type must support the AsyncReadStream concept.]]

[[b][A basic\_streambuf object into which the data will be read. Ownership of the streambuf is retained by the caller, which must guarantee that it remains valid until the handler is called.]]

[[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: 
``
   void handler(
     const boost::system::error_code& error, // Result of operation.

     std::size_t bytes_transferred           // Number of bytes copied into the
                                             // buffers. If an error occurred,
                                             // this will be the  number of
                                             // bytes successfully transferred
                                             // prior to the error.
   ); 
``
Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using boost::asio::io\_service::post().]]

]

[heading Remarks]
      
This overload is equivalent to calling: 

   boost::asio::async_read(
       s, b,
       boost::asio::transfer_all(),
       handler); 






[endsect]



[section:overload4 async_read (4 of 4 overloads)]

Start an asynchronous operation to read a certain amount of data from a stream. 

  template<
      typename ``[link boost_asio.reference.AsyncReadStream AsyncReadStream]``,
      typename Allocator,
      typename CompletionCondition,
      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
  void async_read(
      AsyncReadStream & s,
      basic_streambuf< Allocator > & b,
      CompletionCondition completion_condition,
      ReadHandler handler);


This function is used to asynchronously read a certain number of bytes of data from a stream. The function call always returns immediately. The asynchronous operation will continue until one of the following conditions is true:


* The completion_condition function object returns 0.

This operation is implemented in terms of zero or more calls to the stream's async\_read\_some function.


[heading Parameters]
    

[variablelist
  
[[s][The stream from which the data is to be read. The type must support the AsyncReadStream concept.]]

[[b][A basic\_streambuf object into which the data will be read. Ownership of the streambuf is retained by the caller, which must guarantee that it remains valid until the handler is called.]]

[[completion_condition][The function object to be called to determine whether the read operation is complete. The signature of the function object must be: 
``
   std::size_t completion_condition(
     // Result of latest async_read_some operation.
     const boost::system::error_code& error,

     // Number of bytes transferred so far.
     std::size_t bytes_transferred
   ); 
``
A return value of 0 indicates that the read operation is complete. A non-zero return value indicates the maximum number of bytes to be read on the next call to the stream's async\_read\_some function.]]

[[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: 
``
   void handler(
     const boost::system::error_code& error, // Result of operation.

     std::size_t bytes_transferred           // Number of bytes copied into the
                                             // buffers. If an error occurred,
                                             // this will be the  number of
                                             // bytes successfully transferred
                                             // prior to the error.
   ); 
``
Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using boost::asio::io\_service::post(). ]]

]



[endsect]


[endsect]

[section:async_read_at async_read_at]

[indexterm1 async_read_at] Start an asynchronous operation to read a certain amount of data at the specified offset. 
      
  template<
      typename ``[link boost_asio.reference.AsyncRandomAccessReadDevice AsyncRandomAccessReadDevice]``,
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
  void ``[link boost_asio.reference.async_read_at.overload1 async_read_at]``(
      AsyncRandomAccessReadDevice & d,
      boost::uint64_t offset,
      const MutableBufferSequence & buffers,
      ReadHandler handler);

  template<
      typename ``[link boost_asio.reference.AsyncRandomAccessReadDevice AsyncRandomAccessReadDevice]``,
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
      typename CompletionCondition,
      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
  void ``[link boost_asio.reference.async_read_at.overload2 async_read_at]``(
      AsyncRandomAccessReadDevice & d,
      boost::uint64_t offset,
      const MutableBufferSequence & buffers,
      CompletionCondition completion_condition,
      ReadHandler handler);

  template<
      typename ``[link boost_asio.reference.AsyncRandomAccessReadDevice AsyncRandomAccessReadDevice]``,
      typename Allocator,
      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
  void ``[link boost_asio.reference.async_read_at.overload3 async_read_at]``(
      AsyncRandomAccessReadDevice & d,
      boost::uint64_t offset,
      basic_streambuf< Allocator > & b,
      ReadHandler handler);

  template<
      typename ``[link boost_asio.reference.AsyncRandomAccessReadDevice AsyncRandomAccessReadDevice]``,
      typename Allocator,
      typename CompletionCondition,
      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
  void ``[link boost_asio.reference.async_read_at.overload4 async_read_at]``(
      AsyncRandomAccessReadDevice & d,
      boost::uint64_t offset,
      basic_streambuf< Allocator > & b,
      CompletionCondition completion_condition,
      ReadHandler handler);


[section:overload1 async_read_at (1 of 4 overloads)]

Start an asynchronous operation to read a certain amount of data at the specified offset. 

  template<
      typename ``[link boost_asio.reference.AsyncRandomAccessReadDevice AsyncRandomAccessReadDevice]``,
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
  void async_read_at(
      AsyncRandomAccessReadDevice & d,
      boost::uint64_t offset,
      const MutableBufferSequence & buffers,
      ReadHandler handler);


This function is used to asynchronously read a certain number of bytes of data from a random access device at the specified offset. The function call always returns immediately. The asynchronous operation will continue until one of the following conditions is true:


* The supplied buffers are full. That is, the bytes transferred is equal to the sum of the buffer sizes.

* An error occurred.

This operation is implemented in terms of zero or more calls to the device's async\_read\_some\_at function.


[heading Parameters]
    

[variablelist
  
[[d][The device from which the data is to be read. The type must support the AsyncRandomAccessReadDevice concept.]]

[[offset][The offset at which the data will be read.]]

[[buffers][One or more buffers into which the data will be read. The sum of the buffer sizes indicates the maximum number of bytes to read from the device. 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.]]

[[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: 
``
   void handler(
     // Result of operation.
     const boost::system::error_code& error,

     // Number of bytes copied into the buffers. If an error
     // occurred, this will be the number of bytes successfully
     // transferred prior to the error.
     std::size_t bytes_transferred
   ); 
``
Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using boost::asio::io\_service::post().]]

]

[heading Example]
  
To read into a single data buffer use the 
[link boost_asio.reference.buffer buffer]  function as follows: 

   boost::asio::async_read_at(d, 42, boost::asio::buffer(data, size), handler);


See the 
[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.

[heading Remarks]
      
This overload is equivalent to calling: 

   boost::asio::async_read_at(
       d, 42, buffers,
       boost::asio::transfer_all(),
       handler); 






[endsect]



[section:overload2 async_read_at (2 of 4 overloads)]

Start an asynchronous operation to read a certain amount of data at the specified offset. 

  template<
      typename ``[link boost_asio.reference.AsyncRandomAccessReadDevice AsyncRandomAccessReadDevice]``,
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
      typename CompletionCondition,
      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
  void async_read_at(
      AsyncRandomAccessReadDevice & d,
      boost::uint64_t offset,
      const MutableBufferSequence & buffers,
      CompletionCondition completion_condition,
      ReadHandler handler);


This function is used to asynchronously read a certain number of bytes of data from a random access device at the specified offset. The function call always returns immediately. The asynchronous operation will continue until one of the following conditions is true:


* The supplied buffers are full. That is, the bytes transferred is equal to the sum of the buffer sizes.

* The completion_condition function object returns 0.

[heading Parameters]
    

[variablelist
  
[[d][The device from which the data is to be read. The type must support the AsyncRandomAccessReadDevice concept.]]

[[offset][The offset at which the data will be read.]]

[[buffers][One or more buffers into which the data will be read. The sum of the buffer sizes indicates the maximum number of bytes to read from the device. 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.]]

[[completion_condition][The function object to be called to determine whether the read operation is complete. The signature of the function object must be: 
``
   std::size_t completion_condition(
     // Result of latest async_read_some_at operation.
     const boost::system::error_code& error,

     // Number of bytes transferred so far.
     std::size_t bytes_transferred
   ); 
``
A return value of 0 indicates that the read operation is complete. A non-zero return value indicates the maximum number of bytes to be read on the next call to the device's async\_read\_some\_at function.]]

[[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: 
``
   void handler(
     // Result of operation.
     const boost::system::error_code& error,

     // Number of bytes copied into the buffers. If an error
     // occurred, this will be the number of bytes successfully
     // transferred prior to the error.
     std::size_t bytes_transferred
   ); 
``
Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using boost::asio::io\_service::post().]]

]

[heading Example]
  
To read into a single data buffer use the 
[link boost_asio.reference.buffer buffer]  function as follows: 

   boost::asio::async_read_at(d, 42,
       boost::asio::buffer(data, size),
       boost::asio::transfer_at_least(32),
       handler); 


See the 
[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. 



[endsect]



[section:overload3 async_read_at (3 of 4 overloads)]

Start an asynchronous operation to read a certain amount of data at the specified offset. 

  template<
      typename ``[link boost_asio.reference.AsyncRandomAccessReadDevice AsyncRandomAccessReadDevice]``,
      typename Allocator,
      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
  void async_read_at(
      AsyncRandomAccessReadDevice & d,
      boost::uint64_t offset,
      basic_streambuf< Allocator > & b,
      ReadHandler handler);


This function is used to asynchronously read a certain number of bytes of data from a random access device at the specified offset. The function call always returns immediately. The asynchronous operation will continue until one of the following conditions is true:


* An error occurred.

This operation is implemented in terms of zero or more calls to the device's async\_read\_some\_at function.


[heading Parameters]
    

[variablelist
  
[[d][The device from which the data is to be read. The type must support the AsyncRandomAccessReadDevice concept.]]

[[offset][The offset at which the data will be read.]]

[[b][A basic\_streambuf object into which the data will be read. Ownership of the streambuf is retained by the caller, which must guarantee that it remains valid until the handler is called.]]

[[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: 
``
   void handler(
     // Result of operation.
     const boost::system::error_code& error,

     // Number of bytes copied into the buffers. If an error
     // occurred, this will be the number of bytes successfully
     // transferred prior to the error.
     std::size_t bytes_transferred
   ); 
``
Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using boost::asio::io\_service::post().]]

]

[heading Remarks]
      
This overload is equivalent to calling: 

   boost::asio::async_read_at(
       d, 42, b,
       boost::asio::transfer_all(),
       handler); 






[endsect]



[section:overload4 async_read_at (4 of 4 overloads)]

Start an asynchronous operation to read a certain amount of data at the specified offset. 

  template<
      typename ``[link boost_asio.reference.AsyncRandomAccessReadDevice AsyncRandomAccessReadDevice]``,
      typename Allocator,
      typename CompletionCondition,
      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
  void async_read_at(
      AsyncRandomAccessReadDevice & d,
      boost::uint64_t offset,
      basic_streambuf< Allocator > & b,
      CompletionCondition completion_condition,
      ReadHandler handler);


This function is used to asynchronously read a certain number of bytes of data from a random access device at the specified offset. The function call always returns immediately. The asynchronous operation will continue until one of the following conditions is true:


* The completion_condition function object returns 0.

This operation is implemented in terms of zero or more calls to the device's async\_read\_some\_at function.


[heading Parameters]
    

[variablelist
  
[[d][The device from which the data is to be read. The type must support the AsyncRandomAccessReadDevice concept.]]

[[offset][The offset at which the data will be read.]]

[[b][A basic\_streambuf object into which the data will be read. Ownership of the streambuf is retained by the caller, which must guarantee that it remains valid until the handler is called.]]

[[completion_condition][The function object to be called to determine whether the read operation is complete. The signature of the function object must be: 
``
   std::size_t completion_condition(
     // Result of latest async_read_some_at operation.
     const boost::system::error_code& error,

     // Number of bytes transferred so far.
     std::size_t bytes_transferred
   ); 
``
A return value of 0 indicates that the read operation is complete. A non-zero return value indicates the maximum number of bytes to be read on the next call to the device's async\_read\_some\_at function.]]

[[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: 
``
   void handler(
     // Result of operation.
     const boost::system::error_code& error,

     // Number of bytes copied into the buffers. If an error
     // occurred, this will be the number of bytes successfully
     // transferred prior to the error.
     std::size_t bytes_transferred
   ); 
``
Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using boost::asio::io\_service::post(). ]]

]



[endsect]


[endsect]

[section:async_read_until async_read_until]

[indexterm1 async_read_until] Start an asynchronous operation to read data into a streambuf until it contains a delimiter, matches a regular expression, or a function object indicates a match. 
      
  template<
      typename ``[link boost_asio.reference.AsyncReadStream AsyncReadStream]``,
      typename Allocator,
      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
  void ``[link boost_asio.reference.async_read_until.overload1 async_read_until]``(
      AsyncReadStream & s,
      boost::asio::basic_streambuf< Allocator > & b,
      char delim,
      ReadHandler handler);

  template<
      typename ``[link boost_asio.reference.AsyncReadStream AsyncReadStream]``,
      typename Allocator,
      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
  void ``[link boost_asio.reference.async_read_until.overload2 async_read_until]``(
      AsyncReadStream & s,
      boost::asio::basic_streambuf< Allocator > & b,
      const std::string & delim,
      ReadHandler handler);

  template<
      typename ``[link boost_asio.reference.AsyncReadStream AsyncReadStream]``,
      typename Allocator,
      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
  void ``[link boost_asio.reference.async_read_until.overload3 async_read_until]``(
      AsyncReadStream & s,
      boost::asio::basic_streambuf< Allocator > & b,
      const boost::regex & expr,
      ReadHandler handler);

  template<
      typename ``[link boost_asio.reference.AsyncReadStream AsyncReadStream]``,
      typename Allocator,
      typename MatchCondition,
      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
  void ``[link boost_asio.reference.async_read_until.overload4 async_read_until]``(
      AsyncReadStream & s,
      boost::asio::basic_streambuf< Allocator > & b,
      MatchCondition match_condition,
      ReadHandler handler,
      typename boost::enable_if< is_match_condition< MatchCondition > >::type *  = 0);


[section:overload1 async_read_until (1 of 4 overloads)]

Start an asynchronous operation to read data into a streambuf until it contains a specified delimiter. 

  template<
      typename ``[link boost_asio.reference.AsyncReadStream AsyncReadStream]``,
      typename Allocator,
      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
  void async_read_until(
      AsyncReadStream & s,
      boost::asio::basic_streambuf< Allocator > & b,
      char delim,
      ReadHandler handler);


This function is used to asynchronously read data into the specified streambuf until the streambuf's get area contains the specified delimiter. The function call always returns immediately. The asynchronous operation will continue until one of the following conditions is true:


* The get area of the streambuf contains the specified delimiter.

* An error occurred.

This operation is implemented in terms of zero or more calls to the stream's async\_read\_some function. If the streambuf's get area already contains the delimiter, the asynchronous operation completes immediately.


[heading Parameters]
    

[variablelist
  
[[s][The stream from which the data is to be read. The type must support the AsyncReadStream concept.]]

[[b][A streambuf object into which the data will be read. Ownership of the streambuf is retained by the caller, which must guarantee that it remains valid until the handler is called.]]

[[delim][The delimiter character.]]

[[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: 
``
   void handler(
     // Result of operation.
     const boost::system::error_code& error,

     // The number of bytes in the streambuf's get
     // area up to and including the delimiter.
     // 0 if an error occurred.
     std::size_t bytes_transferred
   ); 
``
Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using boost::asio::io\_service::post().]]

]

[heading Remarks]
      
After a successful async\_read\_until operation, the streambuf may contain additional data beyond the delimiter. An application will typically leave that data in the streambuf for a subsequent async\_read\_until operation to examine.

[heading Example]
  
To asynchronously read data into a streambuf until a newline is encountered: 

   boost::asio::streambuf b;
   ...
   void handler(const boost::system::error_code& e, std::size_t size)
   {
     if (!e)
     {
       std::istream is(&b);
       std::string line;
       std::getline(is, line);
       ...
     }
   }
   ...
   boost::asio::async_read_until(s, b, '\n', handler); 






[endsect]



[section:overload2 async_read_until (2 of 4 overloads)]

Start an asynchronous operation to read data into a streambuf until it contains a specified delimiter. 

  template<
      typename ``[link boost_asio.reference.AsyncReadStream AsyncReadStream]``,
      typename Allocator,
      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
  void async_read_until(
      AsyncReadStream & s,
      boost::asio::basic_streambuf< Allocator > & b,
      const std::string & delim,
      ReadHandler handler);


This function is used to asynchronously read data into the specified streambuf until the streambuf's get area contains the specified delimiter. The function call always returns immediately. The asynchronous operation will continue until one of the following conditions is true:


* The get area of the streambuf contains the specified delimiter.

* An error occurred.

This operation is implemented in terms of zero or more calls to the stream's async\_read\_some function. If the streambuf's get area already contains the delimiter, the asynchronous operation completes immediately.


[heading Parameters]
    

[variablelist
  
[[s][The stream from which the data is to be read. The type must support the AsyncReadStream concept.]]

[[b][A streambuf object into which the data will be read. Ownership of the streambuf is retained by the caller, which must guarantee that it remains valid until the handler is called.]]

[[delim][The delimiter string.]]

[[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: 
``
   void handler(
     // Result of operation.
     const boost::system::error_code& error,

     // The number of bytes in the streambuf's get
     // area up to and including the delimiter.
     // 0 if an error occurred.
     std::size_t bytes_transferred
   ); 
``
Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using boost::asio::io\_service::post().]]

]

[heading Remarks]
      
After a successful async\_read\_until operation, the streambuf may contain additional data beyond the delimiter. An application will typically leave that data in the streambuf for a subsequent async\_read\_until operation to examine.

[heading Example]
  
To asynchronously read data into a streambuf until a newline is encountered: 

   boost::asio::streambuf b;
   ...
   void handler(const boost::system::error_code& e, std::size_t size)
   {
     if (!e)
     {
       std::istream is(&b);
       std::string line;
       std::getline(is, line);
       ...
     }
   }
   ...
   boost::asio::async_read_until(s, b, "\r\n", handler); 






[endsect]



[section:overload3 async_read_until (3 of 4 overloads)]

Start an asynchronous operation to read data into a streambuf until some part of its data matches a regular expression. 

  template<
      typename ``[link boost_asio.reference.AsyncReadStream AsyncReadStream]``,
      typename Allocator,
      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
  void async_read_until(
      AsyncReadStream & s,
      boost::asio::basic_streambuf< Allocator > & b,
      const boost::regex & expr,
      ReadHandler handler);


This function is used to asynchronously read data into the specified streambuf until the streambuf's get area contains some data that matches a regular expression. The function call always returns immediately. The asynchronous operation will continue until one of the following conditions is true:


* A substring of the streambuf's get area matches the regular expression.

* An error occurred.

This operation is implemented in terms of zero or more calls to the stream's async\_read\_some function. If the streambuf's get area already contains data that matches the regular expression, the function returns immediately.


[heading Parameters]
    

[variablelist
  
[[s][The stream from which the data is to be read. The type must support the AsyncReadStream concept.]]

[[b][A streambuf object into which the data will be read. Ownership of the streambuf is retained by the caller, which must guarantee that it remains valid until the handler is called.]]

[[expr][The regular expression.]]

[[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: 
``
   void handler(
     // Result of operation.
     const boost::system::error_code& error,

     // The number of bytes in the streambuf's get
     // area up to and including the substring
     // that matches the regular. expression.
     // 0 if an error occurred.
     std::size_t bytes_transferred
   ); 
``
Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using boost::asio::io\_service::post().]]

]

[heading Remarks]
      
After a successful async\_read\_until operation, the streambuf may contain additional data beyond that which matched the regular expression. An application will typically leave that data in the streambuf for a subsequent async\_read\_until operation to examine.

[heading Example]
  
To asynchronously read data into a streambuf until a CR-LF sequence is encountered: 

   boost::asio::streambuf b;
   ...
   void handler(const boost::system::error_code& e, std::size_t size)
   {
     if (!e)
     {
       std::istream is(&b);
       std::string line;
       std::getline(is, line);
       ...
     }
   }
   ...
   boost::asio::async_read_until(s, b, boost::regex("\r\n"), handler); 






[endsect]



[section:overload4 async_read_until (4 of 4 overloads)]

Start an asynchronous operation to read data into a streambuf until a function object indicates a match. 

  template<
      typename ``[link boost_asio.reference.AsyncReadStream AsyncReadStream]``,
      typename Allocator,
      typename MatchCondition,
      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
  void async_read_until(
      AsyncReadStream & s,
      boost::asio::basic_streambuf< Allocator > & b,
      MatchCondition match_condition,
      ReadHandler handler,
      typename boost::enable_if< is_match_condition< MatchCondition > >::type *  = 0);


This function is used to asynchronously read data into the specified streambuf until a user-defined match condition function object, when applied to the data contained in the streambuf, indicates a successful match. The function call always returns immediately. The asynchronous operation will continue until one of the following conditions is true:


* The match condition function object returns a std::pair where the second element evaluates to true.

* An error occurred.

This operation is implemented in terms of zero or more calls to the stream's async\_read\_some function. If the match condition function object already indicates a match, the operation completes immediately.


[heading Parameters]
    

[variablelist
  
[[s][The stream from which the data is to be read. The type must support the AsyncReadStream concept.]]

[[b][A streambuf object into which the data will be read.]]

[[match_condition][The function object to be called to determine whether a match exists. The signature of the function object must be: 
``
   pair<iterator, bool> match_condition(iterator begin, iterator end);
``
where `iterator` represents the type: 
``
   buffers_iterator<basic_streambuf<Allocator>::const_buffers_type>
``
The iterator parameters `begin` and `end` define the range of bytes to be scanned to determine whether there is a match. The `first` member of the return value is an iterator marking one-past-the-end of the bytes that have been consumed by the match function. This iterator is used to calculate the `begin` parameter for any subsequent invocation of the match condition. The `second` member of the return value is true if a match has been found, false otherwise.]]

[[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: 
``
   void handler(
     // Result of operation.
     const boost::system::error_code& error,

     // The number of bytes in the streambuf's get
     // area that have been fully consumed by the
     // match function. O if an error occurred.
     std::size_t bytes_transferred
   ); 
``
Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using boost::asio::io\_service::post().]]

]

[heading Remarks]
      
After a successful async\_read\_until operation, the streambuf may contain additional data beyond that which matched the function object. An application will typically leave that data in the streambuf for a subsequent async\_read\_until operation to examine.

The default implementation of the `is_match_condition` type trait evaluates to true for function pointers and function objects with a `result_type` typedef. It must be specialised for other user-defined function objects.

[heading Examples]
  
To asynchronously read data into a streambuf until whitespace is encountered: 

   typedef boost::asio::buffers_iterator<
       boost::asio::streambuf::const_buffers_type> iterator;

   std::pair<iterator, bool>
   match_whitespace(iterator begin, iterator end)
   {
     iterator i = begin;
     while (i != end)
       if (std::isspace(*i++))
         return std::make_pair(i, true);
     return std::make_pair(i, false);
   }
   ...
   void handler(const boost::system::error_code& e, std::size_t size);
   ...
   boost::asio::streambuf b;
   boost::asio::async_read_until(s, b, match_whitespace, handler);




To asynchronously read data into a streambuf until a matching character is found: 

   class match_char
   {
   public:
     explicit match_char(char c) : c_(c) {}

     template <typename Iterator>
     std::pair<Iterator, bool> operator()(
         Iterator begin, Iterator end) const
     {
       Iterator i = begin;
       while (i != end)
         if (c_ == *i++)
           return std::make_pair(i, true);
       return std::make_pair(i, false);
     }

   private:
     char c_;
   };

   namespace asio {
     template <> struct is_match_condition<match_char>
       : public boost::true_type {};
   } // namespace asio
   ...
   void handler(const boost::system::error_code& e, std::size_t size);
   ...
   boost::asio::streambuf b;
   boost::asio::async_read_until(s, b, match_char('a'), handler);





[endsect]


[endsect]

[section:async_write async_write]

[indexterm1 async_write] Start an asynchronous operation to write a certain amount of data to a stream. 
      
  template<
      typename ``[link boost_asio.reference.AsyncWriteStream AsyncWriteStream]``,
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
  void ``[link boost_asio.reference.async_write.overload1 async_write]``(
      AsyncWriteStream & s,
      const ConstBufferSequence & buffers,
      WriteHandler handler);

  template<
      typename ``[link boost_asio.reference.AsyncWriteStream AsyncWriteStream]``,
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
      typename CompletionCondition,
      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
  void ``[link boost_asio.reference.async_write.overload2 async_write]``(
      AsyncWriteStream & s,
      const ConstBufferSequence & buffers,
      CompletionCondition completion_condition,
      WriteHandler handler);

  template<
      typename ``[link boost_asio.reference.AsyncWriteStream AsyncWriteStream]``,
      typename Allocator,
      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
  void ``[link boost_asio.reference.async_write.overload3 async_write]``(
      AsyncWriteStream & s,
      basic_streambuf< Allocator > & b,
      WriteHandler handler);

  template<
      typename ``[link boost_asio.reference.AsyncWriteStream AsyncWriteStream]``,
      typename Allocator,
      typename CompletionCondition,
      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
  void ``[link boost_asio.reference.async_write.overload4 async_write]``(
      AsyncWriteStream & s,
      basic_streambuf< Allocator > & b,
      CompletionCondition completion_condition,
      WriteHandler handler);


[section:overload1 async_write (1 of 4 overloads)]

Start an asynchronous operation to write all of the supplied data to a stream. 

  template<
      typename ``[link boost_asio.reference.AsyncWriteStream AsyncWriteStream]``,
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
  void async_write(
      AsyncWriteStream & s,
      const ConstBufferSequence & buffers,
      WriteHandler handler);


This function is used to asynchronously write a certain number of bytes of data to a stream. The function call always returns immediately. The asynchronous operation will continue until one of the following conditions is true:


* All of the data in the supplied buffers has been written. That is, the bytes transferred is equal to the sum of the buffer sizes.

* An error occurred.

This operation is implemented in terms of zero or more calls to the stream's async\_write\_some function.


[heading Parameters]
    

[variablelist
  
[[s][The stream to which the data is to be written. The type must support the AsyncWriteStream concept.]]

[[buffers][One or more buffers containing the data to be written. 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.]]

[[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: 
``
   void handler(
     const boost::system::error_code& error, // Result of operation.

     std::size_t bytes_transferred           // Number of bytes written from the
                                             // buffers. If an error occurred,
                                             // this will be less than the sum
                                             // of the buffer sizes.
   ); 
``
Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using boost::asio::io\_service::post().]]

]

[heading Example]
  
To write a single data buffer use the 
[link boost_asio.reference.buffer buffer]  function as follows: 

   boost::asio::async_write(s, boost::asio::buffer(data, size), handler);


See the 
[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. 



[endsect]



[section:overload2 async_write (2 of 4 overloads)]

Start an asynchronous operation to write a certain amount of data to a stream. 

  template<
      typename ``[link boost_asio.reference.AsyncWriteStream AsyncWriteStream]``,
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
      typename CompletionCondition,
      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
  void async_write(
      AsyncWriteStream & s,
      const ConstBufferSequence & buffers,
      CompletionCondition completion_condition,
      WriteHandler handler);


This function is used to asynchronously write a certain number of bytes of data to a stream. The function call always returns immediately. The asynchronous operation will continue until one of the following conditions is true:


* All of the data in the supplied buffers has been written. That is, the bytes transferred is equal to the sum of the buffer sizes.

* The completion_condition function object returns 0.

This operation is implemented in terms of zero or more calls to the stream's async\_write\_some function.


[heading Parameters]
    

[variablelist
  
[[s][The stream to which the data is to be written. The type must support the AsyncWriteStream concept.]]

[[buffers][One or more buffers containing the data to be written. 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.]]

[[completion_condition][The function object to be called to determine whether the write operation is complete. The signature of the function object must be: 
``
   std::size_t completion_condition(
     // Result of latest async_write_some operation.
     const boost::system::error_code& error,

     // Number of bytes transferred so far.
     std::size_t bytes_transferred
   ); 
``
A return value of 0 indicates that the write operation is complete. A non-zero return value indicates the maximum number of bytes to be written on the next call to the stream's async\_write\_some function.]]

[[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: 
``
   void handler(
     const boost::system::error_code& error, // Result of operation.

     std::size_t bytes_transferred           // Number of bytes written from the
                                             // buffers. If an error occurred,
                                             // this will be less than the sum
                                             // of the buffer sizes.
   ); 
``
Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using boost::asio::io\_service::post().]]

]

[heading Example]
  
To write a single data buffer use the 
[link boost_asio.reference.buffer buffer]  function as follows: 

   boost::asio::async_write(s,
       boost::asio::buffer(data, size),
       boost::asio::transfer_at_least(32),
       handler); 


See the 
[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. 



[endsect]



[section:overload3 async_write (3 of 4 overloads)]

Start an asynchronous operation to write all of the supplied data to a stream. 

  template<
      typename ``[link boost_asio.reference.AsyncWriteStream AsyncWriteStream]``,
      typename Allocator,
      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
  void async_write(
      AsyncWriteStream & s,
      basic_streambuf< Allocator > & b,
      WriteHandler handler);


This function is used to asynchronously write a certain number of bytes of data to a stream. The function call always returns immediately. The asynchronous operation will continue until one of the following conditions is true:


* All of the data in the supplied basic_streambuf has been written.

* An error occurred.

This operation is implemented in terms of zero or more calls to the stream's async\_write\_some function.


[heading Parameters]
    

[variablelist
  
[[s][The stream to which the data is to be written. The type must support the AsyncWriteStream concept.]]

[[b][A basic\_streambuf object from which data will be written. Ownership of the streambuf is retained by the caller, which must guarantee that it remains valid until the handler is called.]]

[[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: 
``
   void handler(
     const boost::system::error_code& error, // Result of operation.

     std::size_t bytes_transferred           // Number of bytes written from the
                                             // buffers. If an error occurred,
                                             // this will be less than the sum
                                             // of the buffer sizes.
   ); 
``
Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using boost::asio::io\_service::post(). ]]

]



[endsect]



[section:overload4 async_write (4 of 4 overloads)]

Start an asynchronous operation to write a certain amount of data to a stream. 

  template<
      typename ``[link boost_asio.reference.AsyncWriteStream AsyncWriteStream]``,
      typename Allocator,
      typename CompletionCondition,
      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
  void async_write(
      AsyncWriteStream & s,
      basic_streambuf< Allocator > & b,
      CompletionCondition completion_condition,
      WriteHandler handler);


This function is used to asynchronously write a certain number of bytes of data to a stream. The function call always returns immediately. The asynchronous operation will continue until one of the following conditions is true:


* All of the data in the supplied basic_streambuf has been written.

* The completion_condition function object returns 0.

This operation is implemented in terms of zero or more calls to the stream's async\_write\_some function.


[heading Parameters]
    

[variablelist
  
[[s][The stream to which the data is to be written. The type must support the AsyncWriteStream concept.]]

[[b][A basic\_streambuf object from which data will be written. Ownership of the streambuf is retained by the caller, which must guarantee that it remains valid until the handler is called.]]

[[completion_condition][The function object to be called to determine whether the write operation is complete. The signature of the function object must be: 
``
   std::size_t completion_condition(
     // Result of latest async_write_some operation.
     const boost::system::error_code& error,

     // Number of bytes transferred so far.
     std::size_t bytes_transferred
   ); 
``
A return value of 0 indicates that the write operation is complete. A non-zero return value indicates the maximum number of bytes to be written on the next call to the stream's async\_write\_some function.]]

[[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: 
``
   void handler(
     const boost::system::error_code& error, // Result of operation.

     std::size_t bytes_transferred           // Number of bytes written from the
                                             // buffers. If an error occurred,
                                             // this will be less than the sum
                                             // of the buffer sizes.
   ); 
``
Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using boost::asio::io\_service::post(). ]]

]



[endsect]


[endsect]

[section:async_write_at async_write_at]

[indexterm1 async_write_at] Start an asynchronous operation to write a certain amount of data at the specified offset. 
      
  template<
      typename ``[link boost_asio.reference.AsyncRandomAccessWriteDevice AsyncRandomAccessWriteDevice]``,
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
  void ``[link boost_asio.reference.async_write_at.overload1 async_write_at]``(
      AsyncRandomAccessWriteDevice & d,
      boost::uint64_t offset,
      const ConstBufferSequence & buffers,
      WriteHandler handler);

  template<
      typename ``[link boost_asio.reference.AsyncRandomAccessWriteDevice AsyncRandomAccessWriteDevice]``,
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
      typename CompletionCondition,
      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
  void ``[link boost_asio.reference.async_write_at.overload2 async_write_at]``(
      AsyncRandomAccessWriteDevice & d,
      boost::uint64_t offset,
      const ConstBufferSequence & buffers,
      CompletionCondition completion_condition,
      WriteHandler handler);

  template<
      typename ``[link boost_asio.reference.AsyncRandomAccessWriteDevice AsyncRandomAccessWriteDevice]``,
      typename Allocator,
      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
  void ``[link boost_asio.reference.async_write_at.overload3 async_write_at]``(
      AsyncRandomAccessWriteDevice & d,
      boost::uint64_t offset,
      basic_streambuf< Allocator > & b,
      WriteHandler handler);

  template<
      typename ``[link boost_asio.reference.AsyncRandomAccessWriteDevice AsyncRandomAccessWriteDevice]``,
      typename Allocator,
      typename CompletionCondition,
      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
  void ``[link boost_asio.reference.async_write_at.overload4 async_write_at]``(
      AsyncRandomAccessWriteDevice & d,
      boost::uint64_t offset,
      basic_streambuf< Allocator > & b,
      CompletionCondition completion_condition,
      WriteHandler handler);


[section:overload1 async_write_at (1 of 4 overloads)]

Start an asynchronous operation to write all of the supplied data at the specified offset. 

  template<
      typename ``[link boost_asio.reference.AsyncRandomAccessWriteDevice AsyncRandomAccessWriteDevice]``,
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
  void async_write_at(
      AsyncRandomAccessWriteDevice & d,
      boost::uint64_t offset,
      const ConstBufferSequence & buffers,
      WriteHandler handler);


This function is used to asynchronously write a certain number of bytes of data to a random access device at a specified offset. The function call always returns immediately. The asynchronous operation will continue until one of the following conditions is true:


* All of the data in the supplied buffers has been written. That is, the bytes transferred is equal to the sum of the buffer sizes.

* An error occurred.

This operation is implemented in terms of zero or more calls to the device's async\_write\_some\_at function.


[heading Parameters]
    

[variablelist
  
[[d][The device to which the data is to be written. The type must support the AsyncRandomAccessWriteDevice concept.]]

[[offset][The offset at which the data will be written.]]

[[buffers][One or more buffers containing the data to be written. 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.]]

[[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: 
``
   void handler(
     // Result of operation.
     const boost::system::error_code& error,

     // Number of bytes written from the buffers. If an error
     // occurred, this will be less than the sum of the buffer sizes.
     std::size_t bytes_transferred
   ); 
``
Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using boost::asio::io\_service::post().]]

]

[heading Example]
  
To write a single data buffer use the 
[link boost_asio.reference.buffer buffer]  function as follows: 

   boost::asio::async_write_at(d, 42, boost::asio::buffer(data, size), handler);


See the 
[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. 



[endsect]



[section:overload2 async_write_at (2 of 4 overloads)]

Start an asynchronous operation to write a certain amount of data at the specified offset. 

  template<
      typename ``[link boost_asio.reference.AsyncRandomAccessWriteDevice AsyncRandomAccessWriteDevice]``,
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
      typename CompletionCondition,
      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
  void async_write_at(
      AsyncRandomAccessWriteDevice & d,
      boost::uint64_t offset,
      const ConstBufferSequence & buffers,
      CompletionCondition completion_condition,
      WriteHandler handler);


This function is used to asynchronously write a certain number of bytes of data to a random access device at a specified offset. The function call always returns immediately. The asynchronous operation will continue until one of the following conditions is true:


* All of the data in the supplied buffers has been written. That is, the bytes transferred is equal to the sum of the buffer sizes.

* The completion_condition function object returns 0.

This operation is implemented in terms of zero or more calls to the device's async\_write\_some\_at function.


[heading Parameters]
    

[variablelist
  
[[d][The device to which the data is to be written. The type must support the AsyncRandomAccessWriteDevice concept.]]

[[offset][The offset at which the data will be written.]]

[[buffers][One or more buffers containing the data to be written. 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.]]

[[completion_condition][The function object to be called to determine whether the write operation is complete. The signature of the function object must be: 
``
   std::size_t completion_condition(
     // Result of latest async_write_some_at operation.
     const boost::system::error_code& error,

     // Number of bytes transferred so far.
     std::size_t bytes_transferred
   ); 
``
A return value of 0 indicates that the write operation is complete. A non-zero return value indicates the maximum number of bytes to be written on the next call to the device's async\_write\_some\_at function.]]

[[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: 
``
   void handler(
     // Result of operation.
     const boost::system::error_code& error,

     // Number of bytes written from the buffers. If an error
     // occurred, this will be less than the sum of the buffer sizes.
     std::size_t bytes_transferred
   ); 
``
Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using boost::asio::io\_service::post().]]

]

[heading Example]
  
To write a single data buffer use the 
[link boost_asio.reference.buffer buffer]  function as follows: 

   boost::asio::async_write_at(d, 42,
       boost::asio::buffer(data, size),
       boost::asio::transfer_at_least(32),
       handler); 


See the 
[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. 



[endsect]



[section:overload3 async_write_at (3 of 4 overloads)]

Start an asynchronous operation to write all of the supplied data at the specified offset. 

  template<
      typename ``[link boost_asio.reference.AsyncRandomAccessWriteDevice AsyncRandomAccessWriteDevice]``,
      typename Allocator,
      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
  void async_write_at(
      AsyncRandomAccessWriteDevice & d,
      boost::uint64_t offset,
      basic_streambuf< Allocator > & b,
      WriteHandler handler);


This function is used to asynchronously write a certain number of bytes of data to a random access device at a specified offset. The function call always returns immediately. The asynchronous operation will continue until one of the following conditions is true:


* All of the data in the supplied basic_streambuf has been written.

* An error occurred.

This operation is implemented in terms of zero or more calls to the device's async\_write\_some\_at function.


[heading Parameters]
    

[variablelist
  
[[d][The device to which the data is to be written. The type must support the AsyncRandomAccessWriteDevice concept.]]

[[offset][The offset at which the data will be written.]]

[[b][A basic\_streambuf object from which data will be written. Ownership of the streambuf is retained by the caller, which must guarantee that it remains valid until the handler is called.]]

[[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: 
``
   void handler(
     // Result of operation.
     const boost::system::error_code& error,

     // Number of bytes written from the buffers. If an error
     // occurred, this will be less than the sum of the buffer sizes.
     std::size_t bytes_transferred
   ); 
``
Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using boost::asio::io\_service::post(). ]]

]



[endsect]



[section:overload4 async_write_at (4 of 4 overloads)]

Start an asynchronous operation to write a certain amount of data at the specified offset. 

  template<
      typename ``[link boost_asio.reference.AsyncRandomAccessWriteDevice AsyncRandomAccessWriteDevice]``,
      typename Allocator,
      typename CompletionCondition,
      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
  void async_write_at(
      AsyncRandomAccessWriteDevice & d,
      boost::uint64_t offset,
      basic_streambuf< Allocator > & b,
      CompletionCondition completion_condition,
      WriteHandler handler);


This function is used to asynchronously write a certain number of bytes of data to a random access device at a specified offset. The function call always returns immediately. The asynchronous operation will continue until one of the following conditions is true:


* All of the data in the supplied basic_streambuf has been written.

* The completion_condition function object returns 0.

This operation is implemented in terms of zero or more calls to the device's async\_write\_some\_at function.


[heading Parameters]
    

[variablelist
  
[[d][The device to which the data is to be written. The type must support the AsyncRandomAccessWriteDevice concept.]]

[[offset][The offset at which the data will be written.]]

[[b][A basic\_streambuf object from which data will be written. Ownership of the streambuf is retained by the caller, which must guarantee that it remains valid until the handler is called.]]

[[completion_condition][The function object to be called to determine whether the write operation is complete. The signature of the function object must be: 
``
   std::size_t completion_condition(
     // Result of latest async_write_some_at operation.
     const boost::system::error_code& error,

     // Number of bytes transferred so far.
     std::size_t bytes_transferred
   ); 
``
A return value of 0 indicates that the write operation is complete. A non-zero return value indicates the maximum number of bytes to be written on the next call to the device's async\_write\_some\_at function.]]

[[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: 
``
   void handler(
     // Result of operation.
     const boost::system::error_code& error,

     // Number of bytes written from the buffers. If an error
     // occurred, this will be less than the sum of the buffer sizes.
     std::size_t bytes_transferred
   ); 
``
Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using boost::asio::io\_service::post(). ]]

]



[endsect]


[endsect]

[section:basic_datagram_socket basic_datagram_socket]

Provides datagram-oriented socket functionality. 

  template<
      typename ``[link boost_asio.reference.Protocol Protocol]``,
      typename ``[link boost_asio.reference.DatagramSocketService DatagramSocketService]`` = datagram_socket_service<Protocol>>
  class basic_datagram_socket :
    public basic_socket< Protocol, DatagramSocketService >


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.basic_datagram_socket.broadcast [*broadcast]]]
    [Socket option to permit sending of broadcast messages. ]
  
  ]

  [

    [[link boost_asio.reference.basic_datagram_socket.bytes_readable [*bytes_readable]]]
    [IO control command to get the amount of data that can be read without blocking. ]
  
  ]

  [

    [[link boost_asio.reference.basic_datagram_socket.debug [*debug]]]
    [Socket option to enable socket-level debugging. ]
  
  ]

  [

    [[link boost_asio.reference.basic_datagram_socket.do_not_route [*do_not_route]]]
    [Socket option to prevent routing, use local interfaces only. ]
  
  ]

  [

    [[link boost_asio.reference.basic_datagram_socket.enable_connection_aborted [*enable_connection_aborted]]]
    [Socket option to report aborted connections on accept. ]
  
  ]

  [

    [[link boost_asio.reference.basic_datagram_socket.endpoint_type [*endpoint_type]]]
    [The endpoint type. ]
  
  ]

  [

    [[link boost_asio.reference.basic_datagram_socket.implementation_type [*implementation_type]]]
    [The underlying implementation type of I/O object. ]
  
  ]

  [

    [[link boost_asio.reference.basic_datagram_socket.keep_alive [*keep_alive]]]
    [Socket option to send keep-alives. ]
  
  ]

  [

    [[link boost_asio.reference.basic_datagram_socket.linger [*linger]]]
    [Socket option to specify whether the socket lingers on close if unsent data is present. ]
  
  ]

  [

    [[link boost_asio.reference.basic_datagram_socket.lowest_layer_type [*lowest_layer_type]]]
    [A basic_socket is always the lowest layer. ]
  
  ]

  [

    [[link boost_asio.reference.basic_datagram_socket.message_flags [*message_flags]]]
    [Bitmask type for flags that can be passed to send and receive operations. ]
  
  ]

  [

    [[link boost_asio.reference.basic_datagram_socket.native_type [*native_type]]]
    [The native representation of a socket. ]
  
  ]

  [

    [[link boost_asio.reference.basic_datagram_socket.non_blocking_io [*non_blocking_io]]]
    [IO control command to set the blocking mode of the socket. ]
  
  ]

  [

    [[link boost_asio.reference.basic_datagram_socket.protocol_type [*protocol_type]]]
    [The protocol type. ]
  
  ]

  [

    [[link boost_asio.reference.basic_datagram_socket.receive_buffer_size [*receive_buffer_size]]]
    [Socket option for the receive buffer size of a socket. ]
  
  ]

  [

    [[link boost_asio.reference.basic_datagram_socket.receive_low_watermark [*receive_low_watermark]]]
    [Socket option for the receive low watermark. ]
  
  ]

  [

    [[link boost_asio.reference.basic_datagram_socket.reuse_address [*reuse_address]]]
    [Socket option to allow the socket to be bound to an address that is already in use. ]
  
  ]

  [

    [[link boost_asio.reference.basic_datagram_socket.send_buffer_size [*send_buffer_size]]]
    [Socket option for the send buffer size of a socket. ]
  
  ]

  [

    [[link boost_asio.reference.basic_datagram_socket.send_low_watermark [*send_low_watermark]]]
    [Socket option for the send low watermark. ]
  
  ]

  [

    [[link boost_asio.reference.basic_datagram_socket.service_type [*service_type]]]
    [The type of the service that will be used to provide I/O operations. ]
  
  ]

  [

    [[link boost_asio.reference.basic_datagram_socket.shutdown_type [*shutdown_type]]]
    [Different ways a socket may be shutdown. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_datagram_socket.assign [*assign]]]
    [Assign an existing native socket to the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.async_connect [*async_connect]]]
    [Start an asynchronous connect. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.async_receive [*async_receive]]]
    [Start an asynchronous receive on a connected socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.async_receive_from [*async_receive_from]]]
    [Start an asynchronous receive. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.async_send [*async_send]]]
    [Start an asynchronous send on a connected socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.async_send_to [*async_send_to]]]
    [Start an asynchronous send. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.at_mark [*at_mark]]]
    [Determine whether the socket is at the out-of-band data mark. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.available [*available]]]
    [Determine the number of bytes available for reading. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.basic_datagram_socket [*basic_datagram_socket]]]
    [Construct a basic_datagram_socket without opening it. 

     Construct and open a basic_datagram_socket. 

     Construct a basic_datagram_socket, opening it and binding it to the given local endpoint. 

     Construct a basic_datagram_socket on an existing native socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.bind [*bind]]]
    [Bind the socket to the given local endpoint. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.cancel [*cancel]]]
    [Cancel all asynchronous operations associated with the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.close [*close]]]
    [Close the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.connect [*connect]]]
    [Connect the socket to the specified endpoint. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.get_io_service [*get_io_service]]]
    [Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.get_option [*get_option]]]
    [Get an option from the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.io_control [*io_control]]]
    [Perform an IO control command on the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.io_service [*io_service]]]
    [(Deprecated: use get_io_service().) Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.is_open [*is_open]]]
    [Determine whether the socket is open. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.local_endpoint [*local_endpoint]]]
    [Get the local endpoint of the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.lowest_layer [*lowest_layer]]]
    [Get a reference to the lowest layer. 

     Get a const reference to the lowest layer. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.native [*native]]]
    [Get the native socket representation. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.open [*open]]]
    [Open the socket using the specified protocol. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.receive [*receive]]]
    [Receive some data on a connected socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.receive_from [*receive_from]]]
    [Receive a datagram with the endpoint of the sender. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.remote_endpoint [*remote_endpoint]]]
    [Get the remote endpoint of the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.send [*send]]]
    [Send some data on a connected socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.send_to [*send_to]]]
    [Send a datagram to the specified endpoint. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.set_option [*set_option]]]
    [Set an option on the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.shutdown [*shutdown]]]
    [Disable sends or receives on the socket. ]
  ]
  
]

[heading Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_datagram_socket.max_connections [*max_connections]]]
    [The maximum length of the queue of pending incoming connections. ]
  ]

  [
    [[link boost_asio.reference.basic_datagram_socket.message_do_not_route [*message_do_not_route]]]
    [Specify that the data should not be subject to routing. ]
  ]

  [
    [[link boost_asio.reference.basic_datagram_socket.message_out_of_band [*message_out_of_band]]]
    [Process out-of-band data. ]
  ]

  [
    [[link boost_asio.reference.basic_datagram_socket.message_peek [*message_peek]]]
    [Peek at incoming data without removing it from the input queue. ]
  ]

]

[heading Protected Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_datagram_socket.implementation [*implementation]]]
    [The underlying implementation of the I/O object. ]
  ]

  [
    [[link boost_asio.reference.basic_datagram_socket.service [*service]]]
    [The service associated with the I/O object. ]
  ]

]

The basic_datagram_socket class template provides asynchronous and blocking datagram-oriented socket functionality.


[heading Thread Safety]
  
[*Distinct] [*objects:]  Safe.

[*Shared] [*objects:]  Unsafe. 


[section:assign basic_datagram_socket::assign]

[indexterm2 assign..basic_datagram_socket] Assign an existing native socket to the socket. 

  void ``[link boost_asio.reference.basic_datagram_socket.assign.overload1 assign]``(
      const protocol_type & protocol,
      const native_type & native_socket);

  boost::system::error_code ``[link boost_asio.reference.basic_datagram_socket.assign.overload2 assign]``(
      const protocol_type & protocol,
      const native_type & native_socket,
      boost::system::error_code & ec);


[section:overload1 basic_datagram_socket::assign (1 of 2 overloads)]


['Inherited from basic_socket.]

Assign an existing native socket to the socket. 

  void assign(
      const protocol_type & protocol,
      const native_type & native_socket);



[endsect]



[section:overload2 basic_datagram_socket::assign (2 of 2 overloads)]


['Inherited from basic_socket.]

Assign an existing native socket to the socket. 

  boost::system::error_code assign(
      const protocol_type & protocol,
      const native_type & native_socket,
      boost::system::error_code & ec);



[endsect]


[endsect]


[section:async_connect basic_datagram_socket::async_connect]


['Inherited from basic_socket.]

[indexterm2 async_connect..basic_datagram_socket] Start an asynchronous connect. 

  void async_connect(
      const endpoint_type & peer_endpoint,
      ConnectHandler handler);


This function is used to asynchronously connect a socket to the specified remote endpoint. The function call always returns immediately.

The socket is automatically opened if it is not already open. If the connect fails, and the socket was automatically opened, the socket is not returned to the closed state.


[heading Parameters]
    

[variablelist
  
[[peer_endpoint][The remote endpoint to which the socket will be connected. Copies will be made of the endpoint object as required.]]

[[handler][The handler to be called when the connection operation completes. Copies will be made of the handler as required. The function signature of the handler must be: 
``
   void handler(
     const boost::system::error_code& error // Result of operation
   ); 
``
Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using boost::asio::io\_service::post().]]

]

[heading Example]
  


   void connect_handler(const boost::system::error_code& error)
   {
     if (!error)
     {
       // Connect succeeded.
     }
   }

   ...

   boost::asio::ip::tcp::socket socket(io_service);
   boost::asio::ip::tcp::endpoint endpoint(
       boost::asio::ip::address::from_string("1.2.3.4"), 12345);
   socket.async_connect(endpoint, connect_handler);






[endsect]


[section:async_receive basic_datagram_socket::async_receive]

[indexterm2 async_receive..basic_datagram_socket] Start an asynchronous receive on a connected socket. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
  void ``[link boost_asio.reference.basic_datagram_socket.async_receive.overload1 async_receive]``(
      const MutableBufferSequence & buffers,
      ReadHandler handler);

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
  void ``[link boost_asio.reference.basic_datagram_socket.async_receive.overload2 async_receive]``(
      const MutableBufferSequence & buffers,
      socket_base::message_flags flags,
      ReadHandler handler);


[section:overload1 basic_datagram_socket::async_receive (1 of 2 overloads)]

Start an asynchronous receive on a connected socket. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
  void async_receive(
      const MutableBufferSequence & buffers,
      ReadHandler handler);


This function is used to asynchronously receive data from the datagram socket. The function call always returns immediately.


[heading Parameters]
    

[variablelist
  
[[buffers][One or more buffers into which the data will be received. 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.]]

[[handler][The handler to be called when the receive operation completes. Copies will be made of the handler as required. The function signature of the handler must be: 
``
   void handler(
     const boost::system::error_code& error, // Result of operation.
     std::size_t bytes_transferred           // Number of bytes received.
   ); 
``
Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using boost::asio::io\_service::post().]]

]

[heading Remarks]
      
The async\_receive operation can only be used with a connected socket. Use the async\_receive\_from function to receive data on an unconnected datagram socket.

[heading Example]
  
To receive into a single data buffer use the 
[link boost_asio.reference.buffer buffer]  function as follows: 

   socket.async_receive(boost::asio::buffer(data, size), handler);


See the 
[link boost_asio.reference.buffer buffer]  documentation for information on receiving into multiple buffers in one go, and how to use it with arrays, boost::array or std::vector. 



[endsect]



[section:overload2 basic_datagram_socket::async_receive (2 of 2 overloads)]

Start an asynchronous receive on a connected socket. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
  void async_receive(
      const MutableBufferSequence & buffers,
      socket_base::message_flags flags,
      ReadHandler handler);


This function is used to asynchronously receive data from the datagram socket. The function call always returns immediately.


[heading Parameters]
    

[variablelist
  
[[buffers][One or more buffers into which the data will be received. 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.]]

[[flags][Flags specifying how the receive call is to be made.]]

[[handler][The handler to be called when the receive operation completes. Copies will be made of the handler as required. The function signature of the handler must be: 
``
   void handler(
     const boost::system::error_code& error, // Result of operation.
     std::size_t bytes_transferred           // Number of bytes received.
   ); 
``
Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using boost::asio::io\_service::post().]]

]

[heading Remarks]
      
The async\_receive operation can only be used with a connected socket. Use the async\_receive\_from function to receive data on an unconnected datagram socket. 



[endsect]


[endsect]

[section:async_receive_from basic_datagram_socket::async_receive_from]

[indexterm2 async_receive_from..basic_datagram_socket] Start an asynchronous receive. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
  void ``[link boost_asio.reference.basic_datagram_socket.async_receive_from.overload1 async_receive_from]``(
      const MutableBufferSequence & buffers,
      endpoint_type & sender_endpoint,
      ReadHandler handler);

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
  void ``[link boost_asio.reference.basic_datagram_socket.async_receive_from.overload2 async_receive_from]``(
      const MutableBufferSequence & buffers,
      endpoint_type & sender_endpoint,
      socket_base::message_flags flags,
      ReadHandler handler);


[section:overload1 basic_datagram_socket::async_receive_from (1 of 2 overloads)]

Start an asynchronous receive. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
  void async_receive_from(
      const MutableBufferSequence & buffers,
      endpoint_type & sender_endpoint,
      ReadHandler handler);


This function is used to asynchronously receive a datagram. The function call always returns immediately.


[heading Parameters]
    

[variablelist
  
[[buffers][One or more buffers into which the data will be received. 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.]]

[[sender_endpoint][An endpoint object that receives the endpoint of the remote sender of the datagram. Ownership of the sender\_endpoint object is retained by the caller, which must guarantee that it is valid until the handler is called.]]

[[handler][The handler to be called when the receive operation completes. Copies will be made of the handler as required. The function signature of the handler must be: 
``
   void handler(
     const boost::system::error_code& error, // Result of operation.
     std::size_t bytes_transferred           // Number of bytes received.
   ); 
``
Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using boost::asio::io\_service::post().]]

]

[heading Example]
  
To receive into a single data buffer use the 
[link boost_asio.reference.buffer buffer]  function as follows: 

   socket.async_receive_from(
       boost::asio::buffer(data, size), 0, sender_endpoint, handler); 


See the 
[link boost_asio.reference.buffer buffer]  documentation for information on receiving into multiple buffers in one go, and how to use it with arrays, boost::array or std::vector. 



[endsect]



[section:overload2 basic_datagram_socket::async_receive_from (2 of 2 overloads)]

Start an asynchronous receive. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
  void async_receive_from(
      const MutableBufferSequence & buffers,
      endpoint_type & sender_endpoint,
      socket_base::message_flags flags,
      ReadHandler handler);


This function is used to asynchronously receive a datagram. The function call always returns immediately.


[heading Parameters]
    

[variablelist
  
[[buffers][One or more buffers into which the data will be received. 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.]]

[[sender_endpoint][An endpoint object that receives the endpoint of the remote sender of the datagram. Ownership of the sender\_endpoint object is retained by the caller, which must guarantee that it is valid until the handler is called.]]

[[flags][Flags specifying how the receive call is to be made.]]

[[handler][The handler to be called when the receive operation completes. Copies will be made of the handler as required. The function signature of the handler must be: 
``
   void handler(
     const boost::system::error_code& error, // Result of operation.
     std::size_t bytes_transferred           // Number of bytes received.
   ); 
``
Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using boost::asio::io\_service::post(). ]]

]



[endsect]


[endsect]

[section:async_send basic_datagram_socket::async_send]

[indexterm2 async_send..basic_datagram_socket] Start an asynchronous send on a connected socket. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
  void ``[link boost_asio.reference.basic_datagram_socket.async_send.overload1 async_send]``(
      const ConstBufferSequence & buffers,
      WriteHandler handler);

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
  void ``[link boost_asio.reference.basic_datagram_socket.async_send.overload2 async_send]``(
      const ConstBufferSequence & buffers,
      socket_base::message_flags flags,
      WriteHandler handler);


[section:overload1 basic_datagram_socket::async_send (1 of 2 overloads)]

Start an asynchronous send on a connected socket. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
  void async_send(
      const ConstBufferSequence & buffers,
      WriteHandler handler);


This function is used to send data on the datagram socket. The function call will block until the data has been sent successfully or an error occurs.


[heading Parameters]
    

[variablelist
  
[[buffers][One or more data buffers to be sent on the socket. 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.]]

[[handler][The handler to be called when the send operation completes. Copies will be made of the handler as required. The function signature of the handler must be: 
``
   void handler(
     const boost::system::error_code& error, // Result of operation.
     std::size_t bytes_transferred           // Number of bytes sent.
   ); 
``
Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using boost::asio::io\_service::post().]]

]

[heading Remarks]
      
The async\_send operation can only be used with a connected socket. Use the async\_send\_to function to send data on an unconnected datagram socket.

[heading Example]
  
To send a single data buffer use the 
[link boost_asio.reference.buffer buffer]  function as follows: 

   socket.async_send(boost::asio::buffer(data, size), handler);


See the 
[link boost_asio.reference.buffer buffer]  documentation for information on sending multiple buffers in one go, and how to use it with arrays, boost::array or std::vector. 



[endsect]



[section:overload2 basic_datagram_socket::async_send (2 of 2 overloads)]

Start an asynchronous send on a connected socket. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
  void async_send(
      const ConstBufferSequence & buffers,
      socket_base::message_flags flags,
      WriteHandler handler);


This function is used to send data on the datagram socket. The function call will block until the data has been sent successfully or an error occurs.


[heading Parameters]
    

[variablelist
  
[[buffers][One or more data buffers to be sent on the socket. 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.]]

[[flags][Flags specifying how the send call is to be made.]]

[[handler][The handler to be called when the send operation completes. Copies will be made of the handler as required. The function signature of the handler must be: 
``
   void handler(
     const boost::system::error_code& error, // Result of operation.
     std::size_t bytes_transferred           // Number of bytes sent.
   ); 
``
Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using boost::asio::io\_service::post().]]

]

[heading Remarks]
      
The async\_send operation can only be used with a connected socket. Use the async\_send\_to function to send data on an unconnected datagram socket. 



[endsect]


[endsect]

[section:async_send_to basic_datagram_socket::async_send_to]

[indexterm2 async_send_to..basic_datagram_socket] Start an asynchronous send. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
  void ``[link boost_asio.reference.basic_datagram_socket.async_send_to.overload1 async_send_to]``(
      const ConstBufferSequence & buffers,
      const endpoint_type & destination,
      WriteHandler handler);

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
  void ``[link boost_asio.reference.basic_datagram_socket.async_send_to.overload2 async_send_to]``(
      const ConstBufferSequence & buffers,
      const endpoint_type & destination,
      socket_base::message_flags flags,
      WriteHandler handler);


[section:overload1 basic_datagram_socket::async_send_to (1 of 2 overloads)]

Start an asynchronous send. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
  void async_send_to(
      const ConstBufferSequence & buffers,
      const endpoint_type & destination,
      WriteHandler handler);


This function is used to asynchronously send a datagram to the specified remote endpoint. The function call always returns immediately.


[heading Parameters]
    

[variablelist
  
[[buffers][One or more data buffers to be sent to the remote endpoint. 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.]]

[[destination][The remote endpoint to which the data will be sent. Copies will be made of the endpoint as required.]]

[[handler][The handler to be called when the send operation completes. Copies will be made of the handler as required. The function signature of the handler must be: 
``
   void handler(
     const boost::system::error_code& error, // Result of operation.
     std::size_t bytes_transferred           // Number of bytes sent.
   ); 
``
Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using boost::asio::io\_service::post().]]

]

[heading Example]
  
To send a single data buffer use the 
[link boost_asio.reference.buffer buffer]  function as follows: 

   boost::asio::ip::udp::endpoint destination(
       boost::asio::ip::address::from_string("1.2.3.4"), 12345);
   socket.async_send_to(
       boost::asio::buffer(data, size), destination, handler);


See the 
[link boost_asio.reference.buffer buffer]  documentation for information on sending multiple buffers in one go, and how to use it with arrays, boost::array or std::vector. 



[endsect]



[section:overload2 basic_datagram_socket::async_send_to (2 of 2 overloads)]

Start an asynchronous send. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
  void async_send_to(
      const ConstBufferSequence & buffers,
      const endpoint_type & destination,
      socket_base::message_flags flags,
      WriteHandler handler);


This function is used to asynchronously send a datagram to the specified remote endpoint. The function call always returns immediately.


[heading Parameters]
    

[variablelist
  
[[buffers][One or more data buffers to be sent to the remote endpoint. 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.]]

[[flags][Flags specifying how the send call is to be made.]]

[[destination][The remote endpoint to which the data will be sent. Copies will be made of the endpoint as required.]]

[[handler][The handler to be called when the send operation completes. Copies will be made of the handler as required. The function signature of the handler must be: 
``
   void handler(
     const boost::system::error_code& error, // Result of operation.
     std::size_t bytes_transferred           // Number of bytes sent.
   ); 
``
Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using boost::asio::io\_service::post(). ]]

]



[endsect]


[endsect]

[section:at_mark basic_datagram_socket::at_mark]

[indexterm2 at_mark..basic_datagram_socket] Determine whether the socket is at the out-of-band data mark. 

  bool ``[link boost_asio.reference.basic_datagram_socket.at_mark.overload1 at_mark]``() const;

  bool ``[link boost_asio.reference.basic_datagram_socket.at_mark.overload2 at_mark]``(
      boost::system::error_code & ec) const;


[section:overload1 basic_datagram_socket::at_mark (1 of 2 overloads)]


['Inherited from basic_socket.]

Determine whether the socket is at the out-of-band data mark. 

  bool at_mark() const;


This function is used to check whether the socket input is currently positioned at the out-of-band data mark.


[heading Return Value]
      
A bool indicating whether the socket is at the out-of-band data mark.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. ]]

]



[endsect]



[section:overload2 basic_datagram_socket::at_mark (2 of 2 overloads)]


['Inherited from basic_socket.]

Determine whether the socket is at the out-of-band data mark. 

  bool at_mark(
      boost::system::error_code & ec) const;


This function is used to check whether the socket input is currently positioned at the out-of-band data mark.


[heading Parameters]
    

[variablelist
  
[[ec][Set to indicate what error occurred, if any.]]

]

[heading Return Value]
      
A bool indicating whether the socket is at the out-of-band data mark. 



[endsect]


[endsect]

[section:available basic_datagram_socket::available]

[indexterm2 available..basic_datagram_socket] Determine the number of bytes available for reading. 

  std::size_t ``[link boost_asio.reference.basic_datagram_socket.available.overload1 available]``() const;

  std::size_t ``[link boost_asio.reference.basic_datagram_socket.available.overload2 available]``(
      boost::system::error_code & ec) const;


[section:overload1 basic_datagram_socket::available (1 of 2 overloads)]


['Inherited from basic_socket.]

Determine the number of bytes available for reading. 

  std::size_t available() const;


This function is used to determine the number of bytes that may be read without blocking.


[heading Return Value]
      
The number of bytes that may be read without blocking, or 0 if an error occurs.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. ]]

]



[endsect]



[section:overload2 basic_datagram_socket::available (2 of 2 overloads)]


['Inherited from basic_socket.]

Determine the number of bytes available for reading. 

  std::size_t available(
      boost::system::error_code & ec) const;


This function is used to determine the number of bytes that may be read without blocking.


[heading Parameters]
    

[variablelist
  
[[ec][Set to indicate what error occurred, if any.]]

]

[heading Return Value]
      
The number of bytes that may be read without blocking, or 0 if an error occurs. 



[endsect]


[endsect]

[section:basic_datagram_socket basic_datagram_socket::basic_datagram_socket]

[indexterm2 basic_datagram_socket..basic_datagram_socket] Construct a basic_datagram_socket without opening it. 

  ``[link boost_asio.reference.basic_datagram_socket.basic_datagram_socket.overload1 basic_datagram_socket]``(
      boost::asio::io_service & io_service);

Construct and open a basic_datagram_socket. 

  ``[link boost_asio.reference.basic_datagram_socket.basic_datagram_socket.overload2 basic_datagram_socket]``(
      boost::asio::io_service & io_service,
      const protocol_type & protocol);

Construct a basic_datagram_socket, opening it and binding it to the given local endpoint. 

  ``[link boost_asio.reference.basic_datagram_socket.basic_datagram_socket.overload3 basic_datagram_socket]``(
      boost::asio::io_service & io_service,
      const endpoint_type & endpoint);

Construct a basic_datagram_socket on an existing native socket. 

  ``[link boost_asio.reference.basic_datagram_socket.basic_datagram_socket.overload4 basic_datagram_socket]``(
      boost::asio::io_service & io_service,
      const protocol_type & protocol,
      const native_type & native_socket);


[section:overload1 basic_datagram_socket::basic_datagram_socket (1 of 4 overloads)]

Construct a basic_datagram_socket without opening it. 

  basic_datagram_socket(
      boost::asio::io_service & io_service);


This constructor creates a datagram socket without opening it. The open() function must be called before data can be sent or received on the socket.


[heading Parameters]
    

[variablelist
  
[[io_service][The io\_service object that the datagram socket will use to dispatch handlers for any asynchronous operations performed on the socket. ]]

]



[endsect]



[section:overload2 basic_datagram_socket::basic_datagram_socket (2 of 4 overloads)]

Construct and open a basic_datagram_socket. 

  basic_datagram_socket(
      boost::asio::io_service & io_service,
      const protocol_type & protocol);


This constructor creates and opens a datagram socket.


[heading Parameters]
    

[variablelist
  
[[io_service][The io\_service object that the datagram socket will use to dispatch handlers for any asynchronous operations performed on the socket.]]

[[protocol][An object specifying protocol parameters to be used.]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. ]]

]



[endsect]



[section:overload3 basic_datagram_socket::basic_datagram_socket (3 of 4 overloads)]

Construct a basic_datagram_socket, opening it and binding it to the given local endpoint. 

  basic_datagram_socket(
      boost::asio::io_service & io_service,
      const endpoint_type & endpoint);


This constructor creates a datagram socket and automatically opens it bound to the specified endpoint on the local machine. The protocol used is the protocol associated with the given endpoint.


[heading Parameters]
    

[variablelist
  
[[io_service][The io\_service object that the datagram socket will use to dispatch handlers for any asynchronous operations performed on the socket.]]

[[endpoint][An endpoint on the local machine to which the datagram socket will be bound.]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. ]]

]



[endsect]



[section:overload4 basic_datagram_socket::basic_datagram_socket (4 of 4 overloads)]

Construct a basic_datagram_socket on an existing native socket. 

  basic_datagram_socket(
      boost::asio::io_service & io_service,
      const protocol_type & protocol,
      const native_type & native_socket);


This constructor creates a datagram socket object to hold an existing native socket.


[heading Parameters]
    

[variablelist
  
[[io_service][The io\_service object that the datagram socket will use to dispatch handlers for any asynchronous operations performed on the socket.]]

[[protocol][An object specifying protocol parameters to be used.]]

[[native_socket][The new underlying socket implementation.]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. ]]

]



[endsect]


[endsect]

[section:bind basic_datagram_socket::bind]

[indexterm2 bind..basic_datagram_socket] Bind the socket to the given local endpoint. 

  void ``[link boost_asio.reference.basic_datagram_socket.bind.overload1 bind]``(
      const endpoint_type & endpoint);

  boost::system::error_code ``[link boost_asio.reference.basic_datagram_socket.bind.overload2 bind]``(
      const endpoint_type & endpoint,
      boost::system::error_code & ec);


[section:overload1 basic_datagram_socket::bind (1 of 2 overloads)]


['Inherited from basic_socket.]

Bind the socket to the given local endpoint. 

  void bind(
      const endpoint_type & endpoint);


This function binds the socket to the specified endpoint on the local machine.


[heading Parameters]
    

[variablelist
  
[[endpoint][An endpoint on the local machine to which the socket will be bound.]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Example]
  


   boost::asio::ip::tcp::socket socket(io_service);
   socket.open(boost::asio::ip::tcp::v4());
   socket.bind(boost::asio::ip::tcp::endpoint(
         boost::asio::ip::tcp::v4(), 12345));






[endsect]



[section:overload2 basic_datagram_socket::bind (2 of 2 overloads)]


['Inherited from basic_socket.]

Bind the socket to the given local endpoint. 

  boost::system::error_code bind(
      const endpoint_type & endpoint,
      boost::system::error_code & ec);


This function binds the socket to the specified endpoint on the local machine.


[heading Parameters]
    

[variablelist
  
[[endpoint][An endpoint on the local machine to which the socket will be bound.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Example]
  


   boost::asio::ip::tcp::socket socket(io_service);
   socket.open(boost::asio::ip::tcp::v4());
   boost::system::error_code ec;
   socket.bind(boost::asio::ip::tcp::endpoint(
         boost::asio::ip::tcp::v4(), 12345), ec);
   if (ec)
   {
     // An error occurred.
   }






[endsect]


[endsect]


[section:broadcast basic_datagram_socket::broadcast]


['Inherited from socket_base.]

[indexterm2 broadcast..basic_datagram_socket] Socket option to permit sending of broadcast messages. 

  typedef implementation_defined broadcast;



Implements the SOL\_SOCKET/SO\_BROADCAST socket option.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::udp::socket socket(io_service); 
   ...
   boost::asio::socket_base::broadcast option(true);
   socket.set_option(option);




Getting the current option value: 

   boost::asio::ip::udp::socket socket(io_service); 
   ...
   boost::asio::socket_base::broadcast option;
   socket.get_option(option);
   bool is_set = option.value();






[endsect]



[section:bytes_readable basic_datagram_socket::bytes_readable]


['Inherited from socket_base.]

[indexterm2 bytes_readable..basic_datagram_socket] IO control command to get the amount of data that can be read without blocking. 

  typedef implementation_defined bytes_readable;



Implements the FIONREAD IO control command.


[heading Example]
  


   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::bytes_readable command(true);
   socket.io_control(command);
   std::size_t bytes_readable = command.get();






[endsect]


[section:cancel basic_datagram_socket::cancel]

[indexterm2 cancel..basic_datagram_socket] Cancel all asynchronous operations associated with the socket. 

  void ``[link boost_asio.reference.basic_datagram_socket.cancel.overload1 cancel]``();

  boost::system::error_code ``[link boost_asio.reference.basic_datagram_socket.cancel.overload2 cancel]``(
      boost::system::error_code & ec);


[section:overload1 basic_datagram_socket::cancel (1 of 2 overloads)]


['Inherited from basic_socket.]

Cancel all asynchronous operations associated with the socket. 

  void cancel();


This function causes all outstanding asynchronous connect, send and receive operations to finish immediately, and the handlers for cancelled operations will be passed the boost::asio::error::operation\_aborted error.


[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Remarks]
      
Calls to cancel() will always fail with boost::asio::error::operation\_not\_supported when run on Windows XP, Windows Server 2003, and earlier versions of Windows, unless BOOST\_ASIO\_ENABLE\_CANCELIO is defined. However, the CancelIo function has two issues that should be considered before enabling its use:

* It will only cancel asynchronous operations that were initiated in the current thread.

* It can appear to complete without error, but the request to cancel the unfinished operations may be silently ignored by the operating system. Whether it works or not seems to depend on the drivers that are installed.

For portable cancellation, consider using one of the following alternatives:


* Disable asio's I/O completion port backend by defining BOOST_ASIO_DISABLE_IOCP.

* Use the close() function to simultaneously cancel the outstanding operations and close the socket.

When running on Windows Vista, Windows Server 2008, and later, the CancelIoEx function is always used. This function does not have the problems described above. 


[endsect]



[section:overload2 basic_datagram_socket::cancel (2 of 2 overloads)]


['Inherited from basic_socket.]

Cancel all asynchronous operations associated with the socket. 

  boost::system::error_code cancel(
      boost::system::error_code & ec);


This function causes all outstanding asynchronous connect, send and receive operations to finish immediately, and the handlers for cancelled operations will be passed the boost::asio::error::operation\_aborted error.


[heading Parameters]
    

[variablelist
  
[[ec][Set to indicate what error occurred, if any.]]

]

[heading Remarks]
      
Calls to cancel() will always fail with boost::asio::error::operation\_not\_supported when run on Windows XP, Windows Server 2003, and earlier versions of Windows, unless BOOST\_ASIO\_ENABLE\_CANCELIO is defined. However, the CancelIo function has two issues that should be considered before enabling its use:

* It will only cancel asynchronous operations that were initiated in the current thread.

* It can appear to complete without error, but the request to cancel the unfinished operations may be silently ignored by the operating system. Whether it works or not seems to depend on the drivers that are installed.

For portable cancellation, consider using one of the following alternatives:


* Disable asio's I/O completion port backend by defining BOOST_ASIO_DISABLE_IOCP.

* Use the close() function to simultaneously cancel the outstanding operations and close the socket.

When running on Windows Vista, Windows Server 2008, and later, the CancelIoEx function is always used. This function does not have the problems described above. 


[endsect]


[endsect]

[section:close basic_datagram_socket::close]

[indexterm2 close..basic_datagram_socket] Close the socket. 

  void ``[link boost_asio.reference.basic_datagram_socket.close.overload1 close]``();

  boost::system::error_code ``[link boost_asio.reference.basic_datagram_socket.close.overload2 close]``(
      boost::system::error_code & ec);


[section:overload1 basic_datagram_socket::close (1 of 2 overloads)]


['Inherited from basic_socket.]

Close the socket. 

  void close();


This function is used to close the socket. Any asynchronous send, receive or connect operations will be cancelled immediately, and will complete with the boost::asio::error::operation\_aborted error.


[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Remarks]
      
For portable behaviour with respect to graceful closure of a connected socket, call shutdown() before closing the socket. 



[endsect]



[section:overload2 basic_datagram_socket::close (2 of 2 overloads)]


['Inherited from basic_socket.]

Close the socket. 

  boost::system::error_code close(
      boost::system::error_code & ec);


This function is used to close the socket. Any asynchronous send, receive or connect operations will be cancelled immediately, and will complete with the boost::asio::error::operation\_aborted error.


[heading Parameters]
    

[variablelist
  
[[ec][Set to indicate what error occurred, if any.]]

]

[heading Example]
  


   boost::asio::ip::tcp::socket socket(io_service);
   ...
   boost::system::error_code ec;
   socket.close(ec);
   if (ec)
   {
     // An error occurred.
   }




[heading Remarks]
      
For portable behaviour with respect to graceful closure of a connected socket, call shutdown() before closing the socket. 



[endsect]


[endsect]

[section:connect basic_datagram_socket::connect]

[indexterm2 connect..basic_datagram_socket] Connect the socket to the specified endpoint. 

  void ``[link boost_asio.reference.basic_datagram_socket.connect.overload1 connect]``(
      const endpoint_type & peer_endpoint);

  boost::system::error_code ``[link boost_asio.reference.basic_datagram_socket.connect.overload2 connect]``(
      const endpoint_type & peer_endpoint,
      boost::system::error_code & ec);


[section:overload1 basic_datagram_socket::connect (1 of 2 overloads)]


['Inherited from basic_socket.]

Connect the socket to the specified endpoint. 

  void connect(
      const endpoint_type & peer_endpoint);


This function is used to connect a socket to the specified remote endpoint. The function call will block until the connection is successfully made or an error occurs.

The socket is automatically opened if it is not already open. If the connect fails, and the socket was automatically opened, the socket is not returned to the closed state.


[heading Parameters]
    

[variablelist
  
[[peer_endpoint][The remote endpoint to which the socket will be connected.]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Example]
  


   boost::asio::ip::tcp::socket socket(io_service);
   boost::asio::ip::tcp::endpoint endpoint(
       boost::asio::ip::address::from_string("1.2.3.4"), 12345);
   socket.connect(endpoint);






[endsect]



[section:overload2 basic_datagram_socket::connect (2 of 2 overloads)]


['Inherited from basic_socket.]

Connect the socket to the specified endpoint. 

  boost::system::error_code connect(
      const endpoint_type & peer_endpoint,
      boost::system::error_code & ec);


This function is used to connect a socket to the specified remote endpoint. The function call will block until the connection is successfully made or an error occurs.

The socket is automatically opened if it is not already open. If the connect fails, and the socket was automatically opened, the socket is not returned to the closed state.


[heading Parameters]
    

[variablelist
  
[[peer_endpoint][The remote endpoint to which the socket will be connected.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Example]
  


   boost::asio::ip::tcp::socket socket(io_service);
   boost::asio::ip::tcp::endpoint endpoint(
       boost::asio::ip::address::from_string("1.2.3.4"), 12345);
   boost::system::error_code ec;
   socket.connect(endpoint, ec);
   if (ec)
   {
     // An error occurred.
   }






[endsect]


[endsect]


[section:debug basic_datagram_socket::debug]


['Inherited from socket_base.]

[indexterm2 debug..basic_datagram_socket] Socket option to enable socket-level debugging. 

  typedef implementation_defined debug;



Implements the SOL\_SOCKET/SO\_DEBUG socket option.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::debug option(true);
   socket.set_option(option);




Getting the current option value: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::debug option;
   socket.get_option(option);
   bool is_set = option.value();






[endsect]



[section:do_not_route basic_datagram_socket::do_not_route]


['Inherited from socket_base.]

[indexterm2 do_not_route..basic_datagram_socket] Socket option to prevent routing, use local interfaces only. 

  typedef implementation_defined do_not_route;



Implements the SOL\_SOCKET/SO\_DONTROUTE socket option.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::udp::socket socket(io_service); 
   ...
   boost::asio::socket_base::do_not_route option(true);
   socket.set_option(option);




Getting the current option value: 

   boost::asio::ip::udp::socket socket(io_service); 
   ...
   boost::asio::socket_base::do_not_route option;
   socket.get_option(option);
   bool is_set = option.value();






[endsect]



[section:enable_connection_aborted basic_datagram_socket::enable_connection_aborted]


['Inherited from socket_base.]

[indexterm2 enable_connection_aborted..basic_datagram_socket] Socket option to report aborted connections on accept. 

  typedef implementation_defined enable_connection_aborted;



Implements a custom socket option that determines whether or not an accept operation is permitted to fail with boost::asio::error::connection\_aborted. By default the option is false.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::tcp::acceptor acceptor(io_service); 
   ...
   boost::asio::socket_base::enable_connection_aborted option(true);
   acceptor.set_option(option);




Getting the current option value: 

   boost::asio::ip::tcp::acceptor acceptor(io_service); 
   ...
   boost::asio::socket_base::enable_connection_aborted option;
   acceptor.get_option(option);
   bool is_set = option.value();






[endsect]



[section:endpoint_type basic_datagram_socket::endpoint_type]

[indexterm2 endpoint_type..basic_datagram_socket] The endpoint type. 

  typedef Protocol::endpoint endpoint_type;




[endsect]



[section:get_io_service basic_datagram_socket::get_io_service]


['Inherited from basic_io_object.]

[indexterm2 get_io_service..basic_datagram_socket] Get the io_service associated with the object. 

  boost::asio::io_service & get_io_service();


This function may be used to obtain the io_service object that the I/O object uses to dispatch handlers for asynchronous operations.


[heading Return Value]
      
A reference to the io_service object that the I/O object will use to dispatch handlers. Ownership is not transferred to the caller. 



[endsect]


[section:get_option basic_datagram_socket::get_option]

[indexterm2 get_option..basic_datagram_socket] Get an option from the socket. 

  void ``[link boost_asio.reference.basic_datagram_socket.get_option.overload1 get_option]``(
      GettableSocketOption & option) const;

  boost::system::error_code ``[link boost_asio.reference.basic_datagram_socket.get_option.overload2 get_option]``(
      GettableSocketOption & option,
      boost::system::error_code & ec) const;


[section:overload1 basic_datagram_socket::get_option (1 of 2 overloads)]


['Inherited from basic_socket.]

Get an option from the socket. 

  void get_option(
      GettableSocketOption & option) const;


This function is used to get the current value of an option on the socket.


[heading Parameters]
    

[variablelist
  
[[option][The option value to be obtained from the socket.]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Example]
  
Getting the value of the SOL\_SOCKET/SO\_KEEPALIVE option: 

   boost::asio::ip::tcp::socket socket(io_service);
   ...
   boost::asio::ip::tcp::socket::keep_alive option;
   socket.get_option(option);
   bool is_set = option.get();






[endsect]



[section:overload2 basic_datagram_socket::get_option (2 of 2 overloads)]


['Inherited from basic_socket.]

Get an option from the socket. 

  boost::system::error_code get_option(
      GettableSocketOption & option,
      boost::system::error_code & ec) const;


This function is used to get the current value of an option on the socket.


[heading Parameters]
    

[variablelist
  
[[option][The option value to be obtained from the socket.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Example]
  
Getting the value of the SOL\_SOCKET/SO\_KEEPALIVE option: 

   boost::asio::ip::tcp::socket socket(io_service);
   ...
   boost::asio::ip::tcp::socket::keep_alive option;
   boost::system::error_code ec;
   socket.get_option(option, ec);
   if (ec)
   {
     // An error occurred.
   }
   bool is_set = option.get();






[endsect]


[endsect]


[section:implementation basic_datagram_socket::implementation]


['Inherited from basic_io_object.]

[indexterm2 implementation..basic_datagram_socket] The underlying implementation of the I/O object. 

  implementation_type implementation;



[endsect]



[section:implementation_type basic_datagram_socket::implementation_type]


['Inherited from basic_io_object.]

[indexterm2 implementation_type..basic_datagram_socket] The underlying implementation type of I/O object. 

  typedef service_type::implementation_type implementation_type;




[endsect]


[section:io_control basic_datagram_socket::io_control]

[indexterm2 io_control..basic_datagram_socket] Perform an IO control command on the socket. 

  void ``[link boost_asio.reference.basic_datagram_socket.io_control.overload1 io_control]``(
      IoControlCommand & command);

  boost::system::error_code ``[link boost_asio.reference.basic_datagram_socket.io_control.overload2 io_control]``(
      IoControlCommand & command,
      boost::system::error_code & ec);


[section:overload1 basic_datagram_socket::io_control (1 of 2 overloads)]


['Inherited from basic_socket.]

Perform an IO control command on the socket. 

  void io_control(
      IoControlCommand & command);


This function is used to execute an IO control command on the socket.


[heading Parameters]
    

[variablelist
  
[[command][The IO control command to be performed on the socket.]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Example]
  
Getting the number of bytes ready to read: 

   boost::asio::ip::tcp::socket socket(io_service);
   ...
   boost::asio::ip::tcp::socket::bytes_readable command;
   socket.io_control(command);
   std::size_t bytes_readable = command.get();






[endsect]



[section:overload2 basic_datagram_socket::io_control (2 of 2 overloads)]


['Inherited from basic_socket.]

Perform an IO control command on the socket. 

  boost::system::error_code io_control(
      IoControlCommand & command,
      boost::system::error_code & ec);


This function is used to execute an IO control command on the socket.


[heading Parameters]
    

[variablelist
  
[[command][The IO control command to be performed on the socket.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Example]
  
Getting the number of bytes ready to read: 

   boost::asio::ip::tcp::socket socket(io_service);
   ...
   boost::asio::ip::tcp::socket::bytes_readable command;
   boost::system::error_code ec;
   socket.io_control(command, ec);
   if (ec)
   {
     // An error occurred.
   }
   std::size_t bytes_readable = command.get();






[endsect]


[endsect]


[section:io_service basic_datagram_socket::io_service]


['Inherited from basic_io_object.]

[indexterm2 io_service..basic_datagram_socket] (Deprecated: use get_io_service().) Get the io_service associated with the object. 

  boost::asio::io_service & io_service();


This function may be used to obtain the io_service object that the I/O object uses to dispatch handlers for asynchronous operations.


[heading Return Value]
      
A reference to the io_service object that the I/O object will use to dispatch handlers. Ownership is not transferred to the caller. 



[endsect]



[section:is_open basic_datagram_socket::is_open]


['Inherited from basic_socket.]

[indexterm2 is_open..basic_datagram_socket] Determine whether the socket is open. 

  bool is_open() const;



[endsect]



[section:keep_alive basic_datagram_socket::keep_alive]


['Inherited from socket_base.]

[indexterm2 keep_alive..basic_datagram_socket] Socket option to send keep-alives. 

  typedef implementation_defined keep_alive;



Implements the SOL\_SOCKET/SO\_KEEPALIVE socket option.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::keep_alive option(true);
   socket.set_option(option);




Getting the current option value: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::keep_alive option;
   socket.get_option(option);
   bool is_set = option.value();






[endsect]



[section:linger basic_datagram_socket::linger]


['Inherited from socket_base.]

[indexterm2 linger..basic_datagram_socket] Socket option to specify whether the socket lingers on close if unsent data is present. 

  typedef implementation_defined linger;



Implements the SOL\_SOCKET/SO\_LINGER socket option.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::linger option(true, 30);
   socket.set_option(option);




Getting the current option value: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::linger option;
   socket.get_option(option);
   bool is_set = option.enabled();
   unsigned short timeout = option.timeout();






[endsect]


[section:local_endpoint basic_datagram_socket::local_endpoint]

[indexterm2 local_endpoint..basic_datagram_socket] Get the local endpoint of the socket. 

  endpoint_type ``[link boost_asio.reference.basic_datagram_socket.local_endpoint.overload1 local_endpoint]``() const;

  endpoint_type ``[link boost_asio.reference.basic_datagram_socket.local_endpoint.overload2 local_endpoint]``(
      boost::system::error_code & ec) const;


[section:overload1 basic_datagram_socket::local_endpoint (1 of 2 overloads)]


['Inherited from basic_socket.]

Get the local endpoint of the socket. 

  endpoint_type local_endpoint() const;


This function is used to obtain the locally bound endpoint of the socket.


[heading Return Value]
      
An object that represents the local endpoint of the socket.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Example]
  


   boost::asio::ip::tcp::socket socket(io_service);
   ...
   boost::asio::ip::tcp::endpoint endpoint = socket.local_endpoint();






[endsect]



[section:overload2 basic_datagram_socket::local_endpoint (2 of 2 overloads)]


['Inherited from basic_socket.]

Get the local endpoint of the socket. 

  endpoint_type local_endpoint(
      boost::system::error_code & ec) const;


This function is used to obtain the locally bound endpoint of the socket.


[heading Parameters]
    

[variablelist
  
[[ec][Set to indicate what error occurred, if any.]]

]

[heading Return Value]
      
An object that represents the local endpoint of the socket. Returns a default-constructed endpoint object if an error occurred.

[heading Example]
  


   boost::asio::ip::tcp::socket socket(io_service);
   ...
   boost::system::error_code ec;
   boost::asio::ip::tcp::endpoint endpoint = socket.local_endpoint(ec);
   if (ec)
   {
     // An error occurred.
   }






[endsect]


[endsect]

[section:lowest_layer basic_datagram_socket::lowest_layer]

[indexterm2 lowest_layer..basic_datagram_socket] Get a reference to the lowest layer. 

  lowest_layer_type & ``[link boost_asio.reference.basic_datagram_socket.lowest_layer.overload1 lowest_layer]``();

Get a const reference to the lowest layer. 

  const lowest_layer_type & ``[link boost_asio.reference.basic_datagram_socket.lowest_layer.overload2 lowest_layer]``() const;


[section:overload1 basic_datagram_socket::lowest_layer (1 of 2 overloads)]


['Inherited from basic_socket.]

Get a reference to the lowest layer. 

  lowest_layer_type & lowest_layer();


This function returns a reference to the lowest layer in a stack of layers. Since a basic_socket cannot contain any further layers, it simply returns a reference to itself.


[heading Return Value]
      
A reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller. 



[endsect]



[section:overload2 basic_datagram_socket::lowest_layer (2 of 2 overloads)]


['Inherited from basic_socket.]

Get a const reference to the lowest layer. 

  const lowest_layer_type & lowest_layer() const;


This function returns a const reference to the lowest layer in a stack of layers. Since a basic_socket cannot contain any further layers, it simply returns a reference to itself.


[heading Return Value]
      
A const reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller. 



[endsect]


[endsect]


[section:lowest_layer_type basic_datagram_socket::lowest_layer_type]


['Inherited from basic_socket.]

[indexterm2 lowest_layer_type..basic_datagram_socket] A basic_socket is always the lowest layer. 

  typedef basic_socket< Protocol, DatagramSocketService > lowest_layer_type;


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.basic_socket.broadcast [*broadcast]]]
    [Socket option to permit sending of broadcast messages. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.bytes_readable [*bytes_readable]]]
    [IO control command to get the amount of data that can be read without blocking. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.debug [*debug]]]
    [Socket option to enable socket-level debugging. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.do_not_route [*do_not_route]]]
    [Socket option to prevent routing, use local interfaces only. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.enable_connection_aborted [*enable_connection_aborted]]]
    [Socket option to report aborted connections on accept. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.endpoint_type [*endpoint_type]]]
    [The endpoint type. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.implementation_type [*implementation_type]]]
    [The underlying implementation type of I/O object. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.keep_alive [*keep_alive]]]
    [Socket option to send keep-alives. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.linger [*linger]]]
    [Socket option to specify whether the socket lingers on close if unsent data is present. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.lowest_layer_type [*lowest_layer_type]]]
    [A basic_socket is always the lowest layer. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.message_flags [*message_flags]]]
    [Bitmask type for flags that can be passed to send and receive operations. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.native_type [*native_type]]]
    [The native representation of a socket. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.non_blocking_io [*non_blocking_io]]]
    [IO control command to set the blocking mode of the socket. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.protocol_type [*protocol_type]]]
    [The protocol type. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.receive_buffer_size [*receive_buffer_size]]]
    [Socket option for the receive buffer size of a socket. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.receive_low_watermark [*receive_low_watermark]]]
    [Socket option for the receive low watermark. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.reuse_address [*reuse_address]]]
    [Socket option to allow the socket to be bound to an address that is already in use. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.send_buffer_size [*send_buffer_size]]]
    [Socket option for the send buffer size of a socket. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.send_low_watermark [*send_low_watermark]]]
    [Socket option for the send low watermark. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.service_type [*service_type]]]
    [The type of the service that will be used to provide I/O operations. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.shutdown_type [*shutdown_type]]]
    [Different ways a socket may be shutdown. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_socket.assign [*assign]]]
    [Assign an existing native socket to the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.async_connect [*async_connect]]]
    [Start an asynchronous connect. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.at_mark [*at_mark]]]
    [Determine whether the socket is at the out-of-band data mark. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.available [*available]]]
    [Determine the number of bytes available for reading. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.basic_socket [*basic_socket]]]
    [Construct a basic_socket without opening it. 

     Construct and open a basic_socket. 

     Construct a basic_socket, opening it and binding it to the given local endpoint. 

     Construct a basic_socket on an existing native socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.bind [*bind]]]
    [Bind the socket to the given local endpoint. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.cancel [*cancel]]]
    [Cancel all asynchronous operations associated with the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.close [*close]]]
    [Close the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.connect [*connect]]]
    [Connect the socket to the specified endpoint. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.get_io_service [*get_io_service]]]
    [Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.get_option [*get_option]]]
    [Get an option from the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.io_control [*io_control]]]
    [Perform an IO control command on the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.io_service [*io_service]]]
    [(Deprecated: use get_io_service().) Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.is_open [*is_open]]]
    [Determine whether the socket is open. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.local_endpoint [*local_endpoint]]]
    [Get the local endpoint of the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.lowest_layer [*lowest_layer]]]
    [Get a reference to the lowest layer. 

     Get a const reference to the lowest layer. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.native [*native]]]
    [Get the native socket representation. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.open [*open]]]
    [Open the socket using the specified protocol. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.remote_endpoint [*remote_endpoint]]]
    [Get the remote endpoint of the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.set_option [*set_option]]]
    [Set an option on the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.shutdown [*shutdown]]]
    [Disable sends or receives on the socket. ]
  ]
  
]

[heading Protected Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_socket._basic_socket [*~basic_socket]]]
    [Protected destructor to prevent deletion through this type. ]
  ]
  
]

[heading Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_socket.max_connections [*max_connections]]]
    [The maximum length of the queue of pending incoming connections. ]
  ]

  [
    [[link boost_asio.reference.basic_socket.message_do_not_route [*message_do_not_route]]]
    [Specify that the data should not be subject to routing. ]
  ]

  [
    [[link boost_asio.reference.basic_socket.message_out_of_band [*message_out_of_band]]]
    [Process out-of-band data. ]
  ]

  [
    [[link boost_asio.reference.basic_socket.message_peek [*message_peek]]]
    [Peek at incoming data without removing it from the input queue. ]
  ]

]

[heading Protected Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_socket.implementation [*implementation]]]
    [The underlying implementation of the I/O object. ]
  ]

  [
    [[link boost_asio.reference.basic_socket.service [*service]]]
    [The service associated with the I/O object. ]
  ]

]

The basic_socket class template provides functionality that is common to both stream-oriented and datagram-oriented sockets.


[heading Thread Safety]
  
[*Distinct] [*objects:]  Safe.

[*Shared] [*objects:]  Unsafe. 




[endsect]



[section:max_connections basic_datagram_socket::max_connections]


['Inherited from socket_base.]

[indexterm2 max_connections..basic_datagram_socket] The maximum length of the queue of pending incoming connections. 

  static const int max_connections = implementation_defined;



[endsect]



[section:message_do_not_route basic_datagram_socket::message_do_not_route]


['Inherited from socket_base.]

[indexterm2 message_do_not_route..basic_datagram_socket] Specify that the data should not be subject to routing. 

  static const int message_do_not_route = implementation_defined;



[endsect]



[section:message_flags basic_datagram_socket::message_flags]


['Inherited from socket_base.]

[indexterm2 message_flags..basic_datagram_socket] Bitmask type for flags that can be passed to send and receive operations. 

  typedef int message_flags;




[endsect]



[section:message_out_of_band basic_datagram_socket::message_out_of_band]


['Inherited from socket_base.]

[indexterm2 message_out_of_band..basic_datagram_socket] Process out-of-band data. 

  static const int message_out_of_band = implementation_defined;



[endsect]



[section:message_peek basic_datagram_socket::message_peek]


['Inherited from socket_base.]

[indexterm2 message_peek..basic_datagram_socket] Peek at incoming data without removing it from the input queue. 

  static const int message_peek = implementation_defined;



[endsect]



[section:native basic_datagram_socket::native]


['Inherited from basic_socket.]

[indexterm2 native..basic_datagram_socket] Get the native socket representation. 

  native_type native();


This function may be used to obtain the underlying representation of the socket. This is intended to allow access to native socket functionality that is not otherwise provided. 


[endsect]



[section:native_type basic_datagram_socket::native_type]

[indexterm2 native_type..basic_datagram_socket] The native representation of a socket. 

  typedef DatagramSocketService::native_type native_type;




[endsect]



[section:non_blocking_io basic_datagram_socket::non_blocking_io]


['Inherited from socket_base.]

[indexterm2 non_blocking_io..basic_datagram_socket] IO control command to set the blocking mode of the socket. 

  typedef implementation_defined non_blocking_io;



Implements the FIONBIO IO control command.


[heading Example]
  


   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::non_blocking_io command(true);
   socket.io_control(command);






[endsect]


[section:open basic_datagram_socket::open]

[indexterm2 open..basic_datagram_socket] Open the socket using the specified protocol. 

  void ``[link boost_asio.reference.basic_datagram_socket.open.overload1 open]``(
      const protocol_type & protocol = protocol_type());

  boost::system::error_code ``[link boost_asio.reference.basic_datagram_socket.open.overload2 open]``(
      const protocol_type & protocol,
      boost::system::error_code & ec);


[section:overload1 basic_datagram_socket::open (1 of 2 overloads)]


['Inherited from basic_socket.]

Open the socket using the specified protocol. 

  void open(
      const protocol_type & protocol = protocol_type());


This function opens the socket so that it will use the specified protocol.


[heading Parameters]
    

[variablelist
  
[[protocol][An object specifying protocol parameters to be used.]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Example]
  


   boost::asio::ip::tcp::socket socket(io_service);
   socket.open(boost::asio::ip::tcp::v4());






[endsect]



[section:overload2 basic_datagram_socket::open (2 of 2 overloads)]


['Inherited from basic_socket.]

Open the socket using the specified protocol. 

  boost::system::error_code open(
      const protocol_type & protocol,
      boost::system::error_code & ec);


This function opens the socket so that it will use the specified protocol.


[heading Parameters]
    

[variablelist
  
[[protocol][An object specifying which protocol is to be used.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Example]
  


   boost::asio::ip::tcp::socket socket(io_service);
   boost::system::error_code ec;
   socket.open(boost::asio::ip::tcp::v4(), ec);
   if (ec)
   {
     // An error occurred.
   }






[endsect]


[endsect]


[section:protocol_type basic_datagram_socket::protocol_type]

[indexterm2 protocol_type..basic_datagram_socket] The protocol type. 

  typedef Protocol protocol_type;




[endsect]


[section:receive basic_datagram_socket::receive]

[indexterm2 receive..basic_datagram_socket] Receive some data on a connected socket. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t ``[link boost_asio.reference.basic_datagram_socket.receive.overload1 receive]``(
      const MutableBufferSequence & buffers);

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t ``[link boost_asio.reference.basic_datagram_socket.receive.overload2 receive]``(
      const MutableBufferSequence & buffers,
      socket_base::message_flags flags);

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t ``[link boost_asio.reference.basic_datagram_socket.receive.overload3 receive]``(
      const MutableBufferSequence & buffers,
      socket_base::message_flags flags,
      boost::system::error_code & ec);


[section:overload1 basic_datagram_socket::receive (1 of 3 overloads)]

Receive some data on a connected socket. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t receive(
      const MutableBufferSequence & buffers);


This function is used to receive data on the datagram socket. The function call will block until data has been received successfully or an error occurs.


[heading Parameters]
    

[variablelist
  
[[buffers][One or more buffers into which the data will be received.]]

]

[heading Return Value]
      
The number of bytes received.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Remarks]
      
The receive operation can only be used with a connected socket. Use the receive\_from function to receive data on an unconnected datagram socket.

[heading Example]
  
To receive into a single data buffer use the 
[link boost_asio.reference.buffer buffer]  function as follows: 

   socket.receive(boost::asio::buffer(data, size)); 


See the 
[link boost_asio.reference.buffer buffer]  documentation for information on receiving into multiple buffers in one go, and how to use it with arrays, boost::array or std::vector. 



[endsect]



[section:overload2 basic_datagram_socket::receive (2 of 3 overloads)]

Receive some data on a connected socket. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t receive(
      const MutableBufferSequence & buffers,
      socket_base::message_flags flags);


This function is used to receive data on the datagram socket. The function call will block until data has been received successfully or an error occurs.


[heading Parameters]
    

[variablelist
  
[[buffers][One or more buffers into which the data will be received.]]

[[flags][Flags specifying how the receive call is to be made.]]

]

[heading Return Value]
      
The number of bytes received.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Remarks]
      
The receive operation can only be used with a connected socket. Use the receive\_from function to receive data on an unconnected datagram socket. 



[endsect]



[section:overload3 basic_datagram_socket::receive (3 of 3 overloads)]

Receive some data on a connected socket. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t receive(
      const MutableBufferSequence & buffers,
      socket_base::message_flags flags,
      boost::system::error_code & ec);


This function is used to receive data on the datagram socket. The function call will block until data has been received successfully or an error occurs.


[heading Parameters]
    

[variablelist
  
[[buffers][One or more buffers into which the data will be received.]]

[[flags][Flags specifying how the receive call is to be made.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Return Value]
      
The number of bytes received.

[heading Remarks]
      
The receive operation can only be used with a connected socket. Use the receive\_from function to receive data on an unconnected datagram socket. 



[endsect]


[endsect]


[section:receive_buffer_size basic_datagram_socket::receive_buffer_size]


['Inherited from socket_base.]

[indexterm2 receive_buffer_size..basic_datagram_socket] Socket option for the receive buffer size of a socket. 

  typedef implementation_defined receive_buffer_size;



Implements the SOL\_SOCKET/SO\_RCVBUF socket option.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::receive_buffer_size option(8192);
   socket.set_option(option);




Getting the current option value: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::receive_buffer_size option;
   socket.get_option(option);
   int size = option.value();






[endsect]


[section:receive_from basic_datagram_socket::receive_from]

[indexterm2 receive_from..basic_datagram_socket] Receive a datagram with the endpoint of the sender. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t ``[link boost_asio.reference.basic_datagram_socket.receive_from.overload1 receive_from]``(
      const MutableBufferSequence & buffers,
      endpoint_type & sender_endpoint);

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t ``[link boost_asio.reference.basic_datagram_socket.receive_from.overload2 receive_from]``(
      const MutableBufferSequence & buffers,
      endpoint_type & sender_endpoint,
      socket_base::message_flags flags);

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t ``[link boost_asio.reference.basic_datagram_socket.receive_from.overload3 receive_from]``(
      const MutableBufferSequence & buffers,
      endpoint_type & sender_endpoint,
      socket_base::message_flags flags,
      boost::system::error_code & ec);


[section:overload1 basic_datagram_socket::receive_from (1 of 3 overloads)]

Receive a datagram with the endpoint of the sender. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t receive_from(
      const MutableBufferSequence & buffers,
      endpoint_type & sender_endpoint);


This function is used to receive a datagram. The function call will block until data has been received successfully or an error occurs.


[heading Parameters]
    

[variablelist
  
[[buffers][One or more buffers into which the data will be received.]]

[[sender_endpoint][An endpoint object that receives the endpoint of the remote sender of the datagram.]]

]

[heading Return Value]
      
The number of bytes received.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Example]
  
To receive into a single data buffer use the 
[link boost_asio.reference.buffer buffer]  function as follows: 

   boost::asio::ip::udp::endpoint sender_endpoint;
   socket.receive_from(
       boost::asio::buffer(data, size), sender_endpoint);


See the 
[link boost_asio.reference.buffer buffer]  documentation for information on receiving into multiple buffers in one go, and how to use it with arrays, boost::array or std::vector. 



[endsect]



[section:overload2 basic_datagram_socket::receive_from (2 of 3 overloads)]

Receive a datagram with the endpoint of the sender. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t receive_from(
      const MutableBufferSequence & buffers,
      endpoint_type & sender_endpoint,
      socket_base::message_flags flags);


This function is used to receive a datagram. The function call will block until data has been received successfully or an error occurs.


[heading Parameters]
    

[variablelist
  
[[buffers][One or more buffers into which the data will be received.]]

[[sender_endpoint][An endpoint object that receives the endpoint of the remote sender of the datagram.]]

[[flags][Flags specifying how the receive call is to be made.]]

]

[heading Return Value]
      
The number of bytes received.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. ]]

]



[endsect]



[section:overload3 basic_datagram_socket::receive_from (3 of 3 overloads)]

Receive a datagram with the endpoint of the sender. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t receive_from(
      const MutableBufferSequence & buffers,
      endpoint_type & sender_endpoint,
      socket_base::message_flags flags,
      boost::system::error_code & ec);


This function is used to receive a datagram. The function call will block until data has been received successfully or an error occurs.


[heading Parameters]
    

[variablelist
  
[[buffers][One or more buffers into which the data will be received.]]

[[sender_endpoint][An endpoint object that receives the endpoint of the remote sender of the datagram.]]

[[flags][Flags specifying how the receive call is to be made.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Return Value]
      
The number of bytes received. 



[endsect]


[endsect]


[section:receive_low_watermark basic_datagram_socket::receive_low_watermark]


['Inherited from socket_base.]

[indexterm2 receive_low_watermark..basic_datagram_socket] Socket option for the receive low watermark. 

  typedef implementation_defined receive_low_watermark;



Implements the SOL\_SOCKET/SO\_RCVLOWAT socket option.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::receive_low_watermark option(1024);
   socket.set_option(option);




Getting the current option value: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::receive_low_watermark option;
   socket.get_option(option);
   int size = option.value();






[endsect]


[section:remote_endpoint basic_datagram_socket::remote_endpoint]

[indexterm2 remote_endpoint..basic_datagram_socket] Get the remote endpoint of the socket. 

  endpoint_type ``[link boost_asio.reference.basic_datagram_socket.remote_endpoint.overload1 remote_endpoint]``() const;

  endpoint_type ``[link boost_asio.reference.basic_datagram_socket.remote_endpoint.overload2 remote_endpoint]``(
      boost::system::error_code & ec) const;


[section:overload1 basic_datagram_socket::remote_endpoint (1 of 2 overloads)]


['Inherited from basic_socket.]

Get the remote endpoint of the socket. 

  endpoint_type remote_endpoint() const;


This function is used to obtain the remote endpoint of the socket.


[heading Return Value]
      
An object that represents the remote endpoint of the socket.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Example]
  


   boost::asio::ip::tcp::socket socket(io_service);
   ...
   boost::asio::ip::tcp::endpoint endpoint = socket.remote_endpoint();






[endsect]



[section:overload2 basic_datagram_socket::remote_endpoint (2 of 2 overloads)]


['Inherited from basic_socket.]

Get the remote endpoint of the socket. 

  endpoint_type remote_endpoint(
      boost::system::error_code & ec) const;


This function is used to obtain the remote endpoint of the socket.


[heading Parameters]
    

[variablelist
  
[[ec][Set to indicate what error occurred, if any.]]

]

[heading Return Value]
      
An object that represents the remote endpoint of the socket. Returns a default-constructed endpoint object if an error occurred.

[heading Example]
  


   boost::asio::ip::tcp::socket socket(io_service);
   ...
   boost::system::error_code ec;
   boost::asio::ip::tcp::endpoint endpoint = socket.remote_endpoint(ec);
   if (ec)
   {
     // An error occurred.
   }






[endsect]


[endsect]


[section:reuse_address basic_datagram_socket::reuse_address]


['Inherited from socket_base.]

[indexterm2 reuse_address..basic_datagram_socket] Socket option to allow the socket to be bound to an address that is already in use. 

  typedef implementation_defined reuse_address;



Implements the SOL\_SOCKET/SO\_REUSEADDR socket option.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::tcp::acceptor acceptor(io_service); 
   ...
   boost::asio::socket_base::reuse_address option(true);
   acceptor.set_option(option);




Getting the current option value: 

   boost::asio::ip::tcp::acceptor acceptor(io_service); 
   ...
   boost::asio::socket_base::reuse_address option;
   acceptor.get_option(option);
   bool is_set = option.value();






[endsect]


[section:send basic_datagram_socket::send]

[indexterm2 send..basic_datagram_socket] Send some data on a connected socket. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t ``[link boost_asio.reference.basic_datagram_socket.send.overload1 send]``(
      const ConstBufferSequence & buffers);

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t ``[link boost_asio.reference.basic_datagram_socket.send.overload2 send]``(
      const ConstBufferSequence & buffers,
      socket_base::message_flags flags);

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t ``[link boost_asio.reference.basic_datagram_socket.send.overload3 send]``(
      const ConstBufferSequence & buffers,
      socket_base::message_flags flags,
      boost::system::error_code & ec);


[section:overload1 basic_datagram_socket::send (1 of 3 overloads)]

Send some data on a connected socket. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t send(
      const ConstBufferSequence & buffers);


This function is used to send data on the datagram socket. The function call will block until the data has been sent successfully or an error occurs.


[heading Parameters]
    

[variablelist
  
[[buffers][One ore more data buffers to be sent on the socket.]]

]

[heading Return Value]
      
The number of bytes sent.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Remarks]
      
The send operation can only be used with a connected socket. Use the send\_to function to send data on an unconnected datagram socket.

[heading Example]
  
To send a single data buffer use the 
[link boost_asio.reference.buffer buffer]  function as follows: 

   socket.send(boost::asio::buffer(data, size)); 


See the 
[link boost_asio.reference.buffer buffer]  documentation for information on sending multiple buffers in one go, and how to use it with arrays, boost::array or std::vector. 



[endsect]



[section:overload2 basic_datagram_socket::send (2 of 3 overloads)]

Send some data on a connected socket. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t send(
      const ConstBufferSequence & buffers,
      socket_base::message_flags flags);


This function is used to send data on the datagram socket. The function call will block until the data has been sent successfully or an error occurs.


[heading Parameters]
    

[variablelist
  
[[buffers][One ore more data buffers to be sent on the socket.]]

[[flags][Flags specifying how the send call is to be made.]]

]

[heading Return Value]
      
The number of bytes sent.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Remarks]
      
The send operation can only be used with a connected socket. Use the send\_to function to send data on an unconnected datagram socket. 



[endsect]



[section:overload3 basic_datagram_socket::send (3 of 3 overloads)]

Send some data on a connected socket. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t send(
      const ConstBufferSequence & buffers,
      socket_base::message_flags flags,
      boost::system::error_code & ec);


This function is used to send data on the datagram socket. The function call will block until the data has been sent successfully or an error occurs.


[heading Parameters]
    

[variablelist
  
[[buffers][One or more data buffers to be sent on the socket.]]

[[flags][Flags specifying how the send call is to be made.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Return Value]
      
The number of bytes sent.

[heading Remarks]
      
The send operation can only be used with a connected socket. Use the send\_to function to send data on an unconnected datagram socket. 



[endsect]


[endsect]


[section:send_buffer_size basic_datagram_socket::send_buffer_size]


['Inherited from socket_base.]

[indexterm2 send_buffer_size..basic_datagram_socket] Socket option for the send buffer size of a socket. 

  typedef implementation_defined send_buffer_size;



Implements the SOL\_SOCKET/SO\_SNDBUF socket option.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::send_buffer_size option(8192);
   socket.set_option(option);




Getting the current option value: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::send_buffer_size option;
   socket.get_option(option);
   int size = option.value();






[endsect]



[section:send_low_watermark basic_datagram_socket::send_low_watermark]


['Inherited from socket_base.]

[indexterm2 send_low_watermark..basic_datagram_socket] Socket option for the send low watermark. 

  typedef implementation_defined send_low_watermark;



Implements the SOL\_SOCKET/SO\_SNDLOWAT socket option.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::send_low_watermark option(1024);
   socket.set_option(option);




Getting the current option value: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::send_low_watermark option;
   socket.get_option(option);
   int size = option.value();






[endsect]


[section:send_to basic_datagram_socket::send_to]

[indexterm2 send_to..basic_datagram_socket] Send a datagram to the specified endpoint. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t ``[link boost_asio.reference.basic_datagram_socket.send_to.overload1 send_to]``(
      const ConstBufferSequence & buffers,
      const endpoint_type & destination);

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t ``[link boost_asio.reference.basic_datagram_socket.send_to.overload2 send_to]``(
      const ConstBufferSequence & buffers,
      const endpoint_type & destination,
      socket_base::message_flags flags);

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t ``[link boost_asio.reference.basic_datagram_socket.send_to.overload3 send_to]``(
      const ConstBufferSequence & buffers,
      const endpoint_type & destination,
      socket_base::message_flags flags,
      boost::system::error_code & ec);


[section:overload1 basic_datagram_socket::send_to (1 of 3 overloads)]

Send a datagram to the specified endpoint. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t send_to(
      const ConstBufferSequence & buffers,
      const endpoint_type & destination);


This function is used to send a datagram to the specified remote endpoint. The function call will block until the data has been sent successfully or an error occurs.


[heading Parameters]
    

[variablelist
  
[[buffers][One or more data buffers to be sent to the remote endpoint.]]

[[destination][The remote endpoint to which the data will be sent.]]

]

[heading Return Value]
      
The number of bytes sent.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Example]
  
To send a single data buffer use the 
[link boost_asio.reference.buffer buffer]  function as follows: 

   boost::asio::ip::udp::endpoint destination(
       boost::asio::ip::address::from_string("1.2.3.4"), 12345);
   socket.send_to(boost::asio::buffer(data, size), destination);


See the 
[link boost_asio.reference.buffer buffer]  documentation for information on sending multiple buffers in one go, and how to use it with arrays, boost::array or std::vector. 



[endsect]



[section:overload2 basic_datagram_socket::send_to (2 of 3 overloads)]

Send a datagram to the specified endpoint. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t send_to(
      const ConstBufferSequence & buffers,
      const endpoint_type & destination,
      socket_base::message_flags flags);


This function is used to send a datagram to the specified remote endpoint. The function call will block until the data has been sent successfully or an error occurs.


[heading Parameters]
    

[variablelist
  
[[buffers][One or more data buffers to be sent to the remote endpoint.]]

[[destination][The remote endpoint to which the data will be sent.]]

[[flags][Flags specifying how the send call is to be made.]]

]

[heading Return Value]
      
The number of bytes sent.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. ]]

]



[endsect]



[section:overload3 basic_datagram_socket::send_to (3 of 3 overloads)]

Send a datagram to the specified endpoint. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t send_to(
      const ConstBufferSequence & buffers,
      const endpoint_type & destination,
      socket_base::message_flags flags,
      boost::system::error_code & ec);


This function is used to send a datagram to the specified remote endpoint. The function call will block until the data has been sent successfully or an error occurs.


[heading Parameters]
    

[variablelist
  
[[buffers][One or more data buffers to be sent to the remote endpoint.]]

[[destination][The remote endpoint to which the data will be sent.]]

[[flags][Flags specifying how the send call is to be made.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Return Value]
      
The number of bytes sent. 



[endsect]


[endsect]


[section:service basic_datagram_socket::service]


['Inherited from basic_io_object.]

[indexterm2 service..basic_datagram_socket] The service associated with the I/O object. 

  service_type & service;



[endsect]



[section:service_type basic_datagram_socket::service_type]


['Inherited from basic_io_object.]

[indexterm2 service_type..basic_datagram_socket] The type of the service that will be used to provide I/O operations. 

  typedef DatagramSocketService service_type;




[endsect]


[section:set_option basic_datagram_socket::set_option]

[indexterm2 set_option..basic_datagram_socket] Set an option on the socket. 

  void ``[link boost_asio.reference.basic_datagram_socket.set_option.overload1 set_option]``(
      const SettableSocketOption & option);

  boost::system::error_code ``[link boost_asio.reference.basic_datagram_socket.set_option.overload2 set_option]``(
      const SettableSocketOption & option,
      boost::system::error_code & ec);


[section:overload1 basic_datagram_socket::set_option (1 of 2 overloads)]


['Inherited from basic_socket.]

Set an option on the socket. 

  void set_option(
      const SettableSocketOption & option);


This function is used to set an option on the socket.


[heading Parameters]
    

[variablelist
  
[[option][The new option value to be set on the socket.]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Example]
  
Setting the IPPROTO\_TCP/TCP\_NODELAY option: 

   boost::asio::ip::tcp::socket socket(io_service);
   ...
   boost::asio::ip::tcp::no_delay option(true);
   socket.set_option(option);






[endsect]



[section:overload2 basic_datagram_socket::set_option (2 of 2 overloads)]


['Inherited from basic_socket.]

Set an option on the socket. 

  boost::system::error_code set_option(
      const SettableSocketOption & option,
      boost::system::error_code & ec);


This function is used to set an option on the socket.


[heading Parameters]
    

[variablelist
  
[[option][The new option value to be set on the socket.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Example]
  
Setting the IPPROTO\_TCP/TCP\_NODELAY option: 

   boost::asio::ip::tcp::socket socket(io_service);
   ...
   boost::asio::ip::tcp::no_delay option(true);
   boost::system::error_code ec;
   socket.set_option(option, ec);
   if (ec)
   {
     // An error occurred.
   }






[endsect]


[endsect]

[section:shutdown basic_datagram_socket::shutdown]

[indexterm2 shutdown..basic_datagram_socket] Disable sends or receives on the socket. 

  void ``[link boost_asio.reference.basic_datagram_socket.shutdown.overload1 shutdown]``(
      shutdown_type what);

  boost::system::error_code ``[link boost_asio.reference.basic_datagram_socket.shutdown.overload2 shutdown]``(
      shutdown_type what,
      boost::system::error_code & ec);


[section:overload1 basic_datagram_socket::shutdown (1 of 2 overloads)]


['Inherited from basic_socket.]

Disable sends or receives on the socket. 

  void shutdown(
      shutdown_type what);


This function is used to disable send operations, receive operations, or both.


[heading Parameters]
    

[variablelist
  
[[what][Determines what types of operation will no longer be allowed.]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Example]
  
Shutting down the send side of the socket: 

   boost::asio::ip::tcp::socket socket(io_service);
   ...
   socket.shutdown(boost::asio::ip::tcp::socket::shutdown_send);






[endsect]



[section:overload2 basic_datagram_socket::shutdown (2 of 2 overloads)]


['Inherited from basic_socket.]

Disable sends or receives on the socket. 

  boost::system::error_code shutdown(
      shutdown_type what,
      boost::system::error_code & ec);


This function is used to disable send operations, receive operations, or both.


[heading Parameters]
    

[variablelist
  
[[what][Determines what types of operation will no longer be allowed.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Example]
  
Shutting down the send side of the socket: 

   boost::asio::ip::tcp::socket socket(io_service);
   ...
   boost::system::error_code ec;
   socket.shutdown(boost::asio::ip::tcp::socket::shutdown_send, ec);
   if (ec)
   {
     // An error occurred.
   }






[endsect]


[endsect]


[section:shutdown_type basic_datagram_socket::shutdown_type]


['Inherited from socket_base.]

[indexterm2 shutdown_type..basic_datagram_socket] Different ways a socket may be shutdown. 

  enum shutdown_type

[heading Values]
[variablelist

  [
    [shutdown_receive]
    [Shutdown the receive side of the socket. ]
  ]

  [
    [shutdown_send]
    [Shutdown the send side of the socket. ]
  ]

  [
    [shutdown_both]
    [Shutdown both send and receive on the socket. ]
  ]

]



[endsect]



[endsect]

[section:basic_deadline_timer basic_deadline_timer]

Provides waitable timer functionality. 

  template<
      typename Time,
      typename ``[link boost_asio.reference.TimeTraits TimeTraits]`` = boost::asio::time_traits<Time>,
      typename ``[link boost_asio.reference.TimerService TimerService]`` = deadline_timer_service<Time, TimeTraits>>
  class basic_deadline_timer :
    public basic_io_object< TimerService >


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.basic_deadline_timer.duration_type [*duration_type]]]
    [The duration type. ]
  
  ]

  [

    [[link boost_asio.reference.basic_deadline_timer.implementation_type [*implementation_type]]]
    [The underlying implementation type of I/O object. ]
  
  ]

  [

    [[link boost_asio.reference.basic_deadline_timer.service_type [*service_type]]]
    [The type of the service that will be used to provide I/O operations. ]
  
  ]

  [

    [[link boost_asio.reference.basic_deadline_timer.time_type [*time_type]]]
    [The time type. ]
  
  ]

  [

    [[link boost_asio.reference.basic_deadline_timer.traits_type [*traits_type]]]
    [The time traits type. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_deadline_timer.async_wait [*async_wait]]]
    [Start an asynchronous wait on the timer. ]
  ]
  
  [
    [[link boost_asio.reference.basic_deadline_timer.basic_deadline_timer [*basic_deadline_timer]]]
    [Constructor. 

     Constructor to set a particular expiry time as an absolute time. 

     Constructor to set a particular expiry time relative to now. ]
  ]
  
  [
    [[link boost_asio.reference.basic_deadline_timer.cancel [*cancel]]]
    [Cancel any asynchronous operations that are waiting on the timer. ]
  ]
  
  [
    [[link boost_asio.reference.basic_deadline_timer.expires_at [*expires_at]]]
    [Get the timer's expiry time as an absolute time. 

     Set the timer's expiry time as an absolute time. ]
  ]
  
  [
    [[link boost_asio.reference.basic_deadline_timer.expires_from_now [*expires_from_now]]]
    [Get the timer's expiry time relative to now. 

     Set the timer's expiry time relative to now. ]
  ]
  
  [
    [[link boost_asio.reference.basic_deadline_timer.get_io_service [*get_io_service]]]
    [Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.basic_deadline_timer.io_service [*io_service]]]
    [(Deprecated: use get_io_service().) Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.basic_deadline_timer.wait [*wait]]]
    [Perform a blocking wait on the timer. ]
  ]
  
]

[heading Protected Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_deadline_timer.implementation [*implementation]]]
    [The underlying implementation of the I/O object. ]
  ]

  [
    [[link boost_asio.reference.basic_deadline_timer.service [*service]]]
    [The service associated with the I/O object. ]
  ]

]

The basic_deadline_timer class template provides the ability to perform a blocking or asynchronous wait for a timer to expire.

Most applications will use the boost::asio::deadline\_timer typedef.


[heading Thread Safety]
  
[*Distinct] [*objects:]  Safe.

[*Shared] [*objects:]  Unsafe.

[heading Examples]
  
Performing a blocking wait: 

   // Construct a timer without setting an expiry time.
   boost::asio::deadline_timer timer(io_service);

   // Set an expiry time relative to now.
   timer.expires_from_now(boost::posix_time::seconds(5));

   // Wait for the timer to expire.
   timer.wait();




Performing an asynchronous wait: 

   void handler(const boost::system::error_code& error)
   {
     if (!error)
     {
       // Timer expired.
     }
   }

   ...

   // Construct a timer with an absolute expiry time.
   boost::asio::deadline_timer timer(io_service,
       boost::posix_time::time_from_string("2005-12-07 23:59:59.000"));

   // Start an asynchronous wait.
   timer.async_wait(handler);




[heading Changing an active deadline_timer's expiry time]
  


Changing the expiry time of a timer while there are pending asynchronous waits causes those wait operations to be cancelled. To ensure that the action associated with the timer is performed only once, use something like this: used:



   void on_some_event()
   {
     if (my_timer.expires_from_now(seconds(5)) > 0)
     {
       // We managed to cancel the timer. Start new asynchronous wait.
       my_timer.async_wait(on_timeout);
     }
     else
     {
       // Too late, timer has already expired!
     }
   }

   void on_timeout(const boost::system::error_code& e)
   {
     if (e != boost::asio::error::operation_aborted)
     {
       // Timer was not cancelled, take necessary action.
     }
   }





* The boost::asio::basic_deadline_timer::expires_from_now() function cancels any pending asynchronous waits, and returns the number of asynchronous waits that were cancelled. If it returns 0 then you were too late and the wait handler has already been executed, or will soon be executed. If it returns 1 then the wait handler was successfully cancelled.

* If a wait handler is cancelled, the boost::system::error_code passed to it contains the value boost::asio::error::operation_aborted. 



[section:async_wait basic_deadline_timer::async_wait]

[indexterm2 async_wait..basic_deadline_timer] Start an asynchronous wait on the timer. 

  template<
      typename ``[link boost_asio.reference.WaitHandler WaitHandler]``>
  void async_wait(
      WaitHandler handler);


This function may be used to initiate an asynchronous wait against the timer. It always returns immediately.

For each call to async\_wait(), the supplied handler will be called exactly once. The handler will be called when:


* The timer has expired.

* The timer was cancelled, in which case the handler is passed the error code boost::asio::error::operation_aborted.

[heading Parameters]
    

[variablelist
  
[[handler][The handler to be called when the timer expires. Copies will be made of the handler as required. The function signature of the handler must be: 
``
   void handler(
     const boost::system::error_code& error // Result of operation.
   ); 
``
Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using boost::asio::io\_service::post(). ]]

]



[endsect]


[section:basic_deadline_timer basic_deadline_timer::basic_deadline_timer]

[indexterm2 basic_deadline_timer..basic_deadline_timer] Constructor. 

  ``[link boost_asio.reference.basic_deadline_timer.basic_deadline_timer.overload1 basic_deadline_timer]``(
      boost::asio::io_service & io_service);

Constructor to set a particular expiry time as an absolute time. 

  ``[link boost_asio.reference.basic_deadline_timer.basic_deadline_timer.overload2 basic_deadline_timer]``(
      boost::asio::io_service & io_service,
      const time_type & expiry_time);

Constructor to set a particular expiry time relative to now. 

  ``[link boost_asio.reference.basic_deadline_timer.basic_deadline_timer.overload3 basic_deadline_timer]``(
      boost::asio::io_service & io_service,
      const duration_type & expiry_time);


[section:overload1 basic_deadline_timer::basic_deadline_timer (1 of 3 overloads)]

Constructor. 

  basic_deadline_timer(
      boost::asio::io_service & io_service);


This constructor creates a timer without setting an expiry time. The expires\_at() or expires\_from\_now() functions must be called to set an expiry time before the timer can be waited on.


[heading Parameters]
    

[variablelist
  
[[io_service][The io\_service object that the timer will use to dispatch handlers for any asynchronous operations performed on the timer. ]]

]



[endsect]



[section:overload2 basic_deadline_timer::basic_deadline_timer (2 of 3 overloads)]

Constructor to set a particular expiry time as an absolute time. 

  basic_deadline_timer(
      boost::asio::io_service & io_service,
      const time_type & expiry_time);


This constructor creates a timer and sets the expiry time.


[heading Parameters]
    

[variablelist
  
[[io_service][The io\_service object that the timer will use to dispatch handlers for any asynchronous operations performed on the timer.]]

[[expiry_time][The expiry time to be used for the timer, expressed as an absolute time. ]]

]



[endsect]



[section:overload3 basic_deadline_timer::basic_deadline_timer (3 of 3 overloads)]

Constructor to set a particular expiry time relative to now. 

  basic_deadline_timer(
      boost::asio::io_service & io_service,
      const duration_type & expiry_time);


This constructor creates a timer and sets the expiry time.


[heading Parameters]
    

[variablelist
  
[[io_service][The io\_service object that the timer will use to dispatch handlers for any asynchronous operations performed on the timer.]]

[[expiry_time][The expiry time to be used for the timer, relative to now. ]]

]



[endsect]


[endsect]

[section:cancel basic_deadline_timer::cancel]

[indexterm2 cancel..basic_deadline_timer] Cancel any asynchronous operations that are waiting on the timer. 

  std::size_t ``[link boost_asio.reference.basic_deadline_timer.cancel.overload1 cancel]``();

  std::size_t ``[link boost_asio.reference.basic_deadline_timer.cancel.overload2 cancel]``(
      boost::system::error_code & ec);


[section:overload1 basic_deadline_timer::cancel (1 of 2 overloads)]

Cancel any asynchronous operations that are waiting on the timer. 

  std::size_t cancel();


This function forces the completion of any pending asynchronous wait operations against the timer. The handler for each cancelled operation will be invoked with the boost::asio::error::operation\_aborted error code.

Cancelling the timer does not change the expiry time.


[heading Return Value]
      
The number of asynchronous operations that were cancelled.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. ]]

]



[endsect]



[section:overload2 basic_deadline_timer::cancel (2 of 2 overloads)]

Cancel any asynchronous operations that are waiting on the timer. 

  std::size_t cancel(
      boost::system::error_code & ec);


This function forces the completion of any pending asynchronous wait operations against the timer. The handler for each cancelled operation will be invoked with the boost::asio::error::operation\_aborted error code.

Cancelling the timer does not change the expiry time.


[heading Parameters]
    

[variablelist
  
[[ec][Set to indicate what error occurred, if any.]]

]

[heading Return Value]
      
The number of asynchronous operations that were cancelled. 



[endsect]


[endsect]


[section:duration_type basic_deadline_timer::duration_type]

[indexterm2 duration_type..basic_deadline_timer] The duration type. 

  typedef traits_type::duration_type duration_type;




[endsect]


[section:expires_at basic_deadline_timer::expires_at]

[indexterm2 expires_at..basic_deadline_timer] Get the timer's expiry time as an absolute time. 

  time_type ``[link boost_asio.reference.basic_deadline_timer.expires_at.overload1 expires_at]``() const;

Set the timer's expiry time as an absolute time. 

  std::size_t ``[link boost_asio.reference.basic_deadline_timer.expires_at.overload2 expires_at]``(
      const time_type & expiry_time);

  std::size_t ``[link boost_asio.reference.basic_deadline_timer.expires_at.overload3 expires_at]``(
      const time_type & expiry_time,
      boost::system::error_code & ec);


[section:overload1 basic_deadline_timer::expires_at (1 of 3 overloads)]

Get the timer's expiry time as an absolute time. 

  time_type expires_at() const;


This function may be used to obtain the timer's current expiry time. Whether the timer has expired or not does not affect this value. 


[endsect]



[section:overload2 basic_deadline_timer::expires_at (2 of 3 overloads)]

Set the timer's expiry time as an absolute time. 

  std::size_t expires_at(
      const time_type & expiry_time);


This function sets the expiry time. Any pending asynchronous wait operations will be cancelled. The handler for each cancelled operation will be invoked with the boost::asio::error::operation\_aborted error code.


[heading Parameters]
    

[variablelist
  
[[expiry_time][The expiry time to be used for the timer.]]

]

[heading Return Value]
      
The number of asynchronous operations that were cancelled.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. ]]

]



[endsect]



[section:overload3 basic_deadline_timer::expires_at (3 of 3 overloads)]

Set the timer's expiry time as an absolute time. 

  std::size_t expires_at(
      const time_type & expiry_time,
      boost::system::error_code & ec);


This function sets the expiry time. Any pending asynchronous wait operations will be cancelled. The handler for each cancelled operation will be invoked with the boost::asio::error::operation\_aborted error code.


[heading Parameters]
    

[variablelist
  
[[expiry_time][The expiry time to be used for the timer.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Return Value]
      
The number of asynchronous operations that were cancelled. 



[endsect]


[endsect]

[section:expires_from_now basic_deadline_timer::expires_from_now]

[indexterm2 expires_from_now..basic_deadline_timer] Get the timer's expiry time relative to now. 

  duration_type ``[link boost_asio.reference.basic_deadline_timer.expires_from_now.overload1 expires_from_now]``() const;

Set the timer's expiry time relative to now. 

  std::size_t ``[link boost_asio.reference.basic_deadline_timer.expires_from_now.overload2 expires_from_now]``(
      const duration_type & expiry_time);

  std::size_t ``[link boost_asio.reference.basic_deadline_timer.expires_from_now.overload3 expires_from_now]``(
      const duration_type & expiry_time,
      boost::system::error_code & ec);


[section:overload1 basic_deadline_timer::expires_from_now (1 of 3 overloads)]

Get the timer's expiry time relative to now. 

  duration_type expires_from_now() const;


This function may be used to obtain the timer's current expiry time. Whether the timer has expired or not does not affect this value. 


[endsect]



[section:overload2 basic_deadline_timer::expires_from_now (2 of 3 overloads)]

Set the timer's expiry time relative to now. 

  std::size_t expires_from_now(
      const duration_type & expiry_time);


This function sets the expiry time. Any pending asynchronous wait operations will be cancelled. The handler for each cancelled operation will be invoked with the boost::asio::error::operation\_aborted error code.


[heading Parameters]
    

[variablelist
  
[[expiry_time][The expiry time to be used for the timer.]]

]

[heading Return Value]
      
The number of asynchronous operations that were cancelled.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. ]]

]



[endsect]



[section:overload3 basic_deadline_timer::expires_from_now (3 of 3 overloads)]

Set the timer's expiry time relative to now. 

  std::size_t expires_from_now(
      const duration_type & expiry_time,
      boost::system::error_code & ec);


This function sets the expiry time. Any pending asynchronous wait operations will be cancelled. The handler for each cancelled operation will be invoked with the boost::asio::error::operation\_aborted error code.


[heading Parameters]
    

[variablelist
  
[[expiry_time][The expiry time to be used for the timer.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Return Value]
      
The number of asynchronous operations that were cancelled. 



[endsect]


[endsect]


[section:get_io_service basic_deadline_timer::get_io_service]


['Inherited from basic_io_object.]

[indexterm2 get_io_service..basic_deadline_timer] Get the io_service associated with the object. 

  boost::asio::io_service & get_io_service();


This function may be used to obtain the io_service object that the I/O object uses to dispatch handlers for asynchronous operations.


[heading Return Value]
      
A reference to the io_service object that the I/O object will use to dispatch handlers. Ownership is not transferred to the caller. 



[endsect]



[section:implementation basic_deadline_timer::implementation]


['Inherited from basic_io_object.]

[indexterm2 implementation..basic_deadline_timer] The underlying implementation of the I/O object. 

  implementation_type implementation;



[endsect]



[section:implementation_type basic_deadline_timer::implementation_type]


['Inherited from basic_io_object.]

[indexterm2 implementation_type..basic_deadline_timer] The underlying implementation type of I/O object. 

  typedef service_type::implementation_type implementation_type;




[endsect]



[section:io_service basic_deadline_timer::io_service]


['Inherited from basic_io_object.]

[indexterm2 io_service..basic_deadline_timer] (Deprecated: use get_io_service().) Get the io_service associated with the object. 

  boost::asio::io_service & io_service();


This function may be used to obtain the io_service object that the I/O object uses to dispatch handlers for asynchronous operations.


[heading Return Value]
      
A reference to the io_service object that the I/O object will use to dispatch handlers. Ownership is not transferred to the caller. 



[endsect]



[section:service basic_deadline_timer::service]


['Inherited from basic_io_object.]

[indexterm2 service..basic_deadline_timer] The service associated with the I/O object. 

  service_type & service;



[endsect]



[section:service_type basic_deadline_timer::service_type]


['Inherited from basic_io_object.]

[indexterm2 service_type..basic_deadline_timer] The type of the service that will be used to provide I/O operations. 

  typedef TimerService service_type;




[endsect]



[section:time_type basic_deadline_timer::time_type]

[indexterm2 time_type..basic_deadline_timer] The time type. 

  typedef traits_type::time_type time_type;




[endsect]



[section:traits_type basic_deadline_timer::traits_type]

[indexterm2 traits_type..basic_deadline_timer] The time traits type. 

  typedef TimeTraits traits_type;




[endsect]


[section:wait basic_deadline_timer::wait]

[indexterm2 wait..basic_deadline_timer] Perform a blocking wait on the timer. 

  void ``[link boost_asio.reference.basic_deadline_timer.wait.overload1 wait]``();

  void ``[link boost_asio.reference.basic_deadline_timer.wait.overload2 wait]``(
      boost::system::error_code & ec);


[section:overload1 basic_deadline_timer::wait (1 of 2 overloads)]

Perform a blocking wait on the timer. 

  void wait();


This function is used to wait for the timer to expire. This function blocks and does not return until the timer has expired.


[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. ]]

]



[endsect]



[section:overload2 basic_deadline_timer::wait (2 of 2 overloads)]

Perform a blocking wait on the timer. 

  void wait(
      boost::system::error_code & ec);


This function is used to wait for the timer to expire. This function blocks and does not return until the timer has expired.


[heading Parameters]
    

[variablelist
  
[[ec][Set to indicate what error occurred, if any. ]]

]



[endsect]


[endsect]


[endsect]

[section:basic_io_object basic_io_object]

Base class for all I/O objects. 

  template<
      typename ``[link boost_asio.reference.IoObjectService IoObjectService]``>
  class basic_io_object :
    noncopyable


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.basic_io_object.implementation_type [*implementation_type]]]
    [The underlying implementation type of I/O object. ]
  
  ]

  [

    [[link boost_asio.reference.basic_io_object.service_type [*service_type]]]
    [The type of the service that will be used to provide I/O operations. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_io_object.get_io_service [*get_io_service]]]
    [Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.basic_io_object.io_service [*io_service]]]
    [(Deprecated: use get_io_service().) Get the io_service associated with the object. ]
  ]
  
]

[heading Protected Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_io_object.basic_io_object [*basic_io_object]]]
    [Construct a basic_io_object. ]
  ]
  
  [
    [[link boost_asio.reference.basic_io_object._basic_io_object [*~basic_io_object]]]
    [Protected destructor to prevent deletion through this type. ]
  ]
  
]

[heading Protected Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_io_object.implementation [*implementation]]]
    [The underlying implementation of the I/O object. ]
  ]

  [
    [[link boost_asio.reference.basic_io_object.service [*service]]]
    [The service associated with the I/O object. ]
  ]

]


[section:basic_io_object basic_io_object::basic_io_object]

[indexterm2 basic_io_object..basic_io_object] Construct a basic_io_object. 

  basic_io_object(
      boost::asio::io_service & io_service);


Performs: 

   service.construct(implementation); 





[endsect]



[section:get_io_service basic_io_object::get_io_service]

[indexterm2 get_io_service..basic_io_object] Get the io_service associated with the object. 

  boost::asio::io_service & get_io_service();


This function may be used to obtain the io_service object that the I/O object uses to dispatch handlers for asynchronous operations.


[heading Return Value]
      
A reference to the io_service object that the I/O object will use to dispatch handlers. Ownership is not transferred to the caller. 



[endsect]



[section:implementation basic_io_object::implementation]

[indexterm2 implementation..basic_io_object] The underlying implementation of the I/O object. 

  implementation_type implementation;



[endsect]



[section:implementation_type basic_io_object::implementation_type]

[indexterm2 implementation_type..basic_io_object] The underlying implementation type of I/O object. 

  typedef service_type::implementation_type implementation_type;




[endsect]



[section:io_service basic_io_object::io_service]

[indexterm2 io_service..basic_io_object] (Deprecated: use get_io_service().) Get the io_service associated with the object. 

  boost::asio::io_service & io_service();


This function may be used to obtain the io_service object that the I/O object uses to dispatch handlers for asynchronous operations.


[heading Return Value]
      
A reference to the io_service object that the I/O object will use to dispatch handlers. Ownership is not transferred to the caller. 



[endsect]



[section:service basic_io_object::service]

[indexterm2 service..basic_io_object] The service associated with the I/O object. 

  service_type & service;



[endsect]



[section:service_type basic_io_object::service_type]

[indexterm2 service_type..basic_io_object] The type of the service that will be used to provide I/O operations. 

  typedef IoObjectService service_type;




[endsect]



[section:_basic_io_object basic_io_object::~basic_io_object]

[indexterm2 ~basic_io_object..basic_io_object] Protected destructor to prevent deletion through this type. 

  ~basic_io_object();


Performs: 

   service.destroy(implementation); 





[endsect]



[endsect]

[section:basic_raw_socket basic_raw_socket]

Provides raw-oriented socket functionality. 

  template<
      typename ``[link boost_asio.reference.Protocol Protocol]``,
      typename ``[link boost_asio.reference.RawSocketService RawSocketService]`` = raw_socket_service<Protocol>>
  class basic_raw_socket :
    public basic_socket< Protocol, RawSocketService >


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.basic_raw_socket.broadcast [*broadcast]]]
    [Socket option to permit sending of broadcast messages. ]
  
  ]

  [

    [[link boost_asio.reference.basic_raw_socket.bytes_readable [*bytes_readable]]]
    [IO control command to get the amount of data that can be read without blocking. ]
  
  ]

  [

    [[link boost_asio.reference.basic_raw_socket.debug [*debug]]]
    [Socket option to enable socket-level debugging. ]
  
  ]

  [

    [[link boost_asio.reference.basic_raw_socket.do_not_route [*do_not_route]]]
    [Socket option to prevent routing, use local interfaces only. ]
  
  ]

  [

    [[link boost_asio.reference.basic_raw_socket.enable_connection_aborted [*enable_connection_aborted]]]
    [Socket option to report aborted connections on accept. ]
  
  ]

  [

    [[link boost_asio.reference.basic_raw_socket.endpoint_type [*endpoint_type]]]
    [The endpoint type. ]
  
  ]

  [

    [[link boost_asio.reference.basic_raw_socket.implementation_type [*implementation_type]]]
    [The underlying implementation type of I/O object. ]
  
  ]

  [

    [[link boost_asio.reference.basic_raw_socket.keep_alive [*keep_alive]]]
    [Socket option to send keep-alives. ]
  
  ]

  [

    [[link boost_asio.reference.basic_raw_socket.linger [*linger]]]
    [Socket option to specify whether the socket lingers on close if unsent data is present. ]
  
  ]

  [

    [[link boost_asio.reference.basic_raw_socket.lowest_layer_type [*lowest_layer_type]]]
    [A basic_socket is always the lowest layer. ]
  
  ]

  [

    [[link boost_asio.reference.basic_raw_socket.message_flags [*message_flags]]]
    [Bitmask type for flags that can be passed to send and receive operations. ]
  
  ]

  [

    [[link boost_asio.reference.basic_raw_socket.native_type [*native_type]]]
    [The native representation of a socket. ]
  
  ]

  [

    [[link boost_asio.reference.basic_raw_socket.non_blocking_io [*non_blocking_io]]]
    [IO control command to set the blocking mode of the socket. ]
  
  ]

  [

    [[link boost_asio.reference.basic_raw_socket.protocol_type [*protocol_type]]]
    [The protocol type. ]
  
  ]

  [

    [[link boost_asio.reference.basic_raw_socket.receive_buffer_size [*receive_buffer_size]]]
    [Socket option for the receive buffer size of a socket. ]
  
  ]

  [

    [[link boost_asio.reference.basic_raw_socket.receive_low_watermark [*receive_low_watermark]]]
    [Socket option for the receive low watermark. ]
  
  ]

  [

    [[link boost_asio.reference.basic_raw_socket.reuse_address [*reuse_address]]]
    [Socket option to allow the socket to be bound to an address that is already in use. ]
  
  ]

  [

    [[link boost_asio.reference.basic_raw_socket.send_buffer_size [*send_buffer_size]]]
    [Socket option for the send buffer size of a socket. ]
  
  ]

  [

    [[link boost_asio.reference.basic_raw_socket.send_low_watermark [*send_low_watermark]]]
    [Socket option for the send low watermark. ]
  
  ]

  [

    [[link boost_asio.reference.basic_raw_socket.service_type [*service_type]]]
    [The type of the service that will be used to provide I/O operations. ]
  
  ]

  [

    [[link boost_asio.reference.basic_raw_socket.shutdown_type [*shutdown_type]]]
    [Different ways a socket may be shutdown. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_raw_socket.assign [*assign]]]
    [Assign an existing native socket to the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_raw_socket.async_connect [*async_connect]]]
    [Start an asynchronous connect. ]
  ]
  
  [
    [[link boost_asio.reference.basic_raw_socket.async_receive [*async_receive]]]
    [Start an asynchronous receive on a connected socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_raw_socket.async_receive_from [*async_receive_from]]]
    [Start an asynchronous receive. ]
  ]
  
  [
    [[link boost_asio.reference.basic_raw_socket.async_send [*async_send]]]
    [Start an asynchronous send on a connected socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_raw_socket.async_send_to [*async_send_to]]]
    [Start an asynchronous send. ]
  ]
  
  [
    [[link boost_asio.reference.basic_raw_socket.at_mark [*at_mark]]]
    [Determine whether the socket is at the out-of-band data mark. ]
  ]
  
  [
    [[link boost_asio.reference.basic_raw_socket.available [*available]]]
    [Determine the number of bytes available for reading. ]
  ]
  
  [
    [[link boost_asio.reference.basic_raw_socket.basic_raw_socket [*basic_raw_socket]]]
    [Construct a basic_raw_socket without opening it. 

     Construct and open a basic_raw_socket. 

     Construct a basic_raw_socket, opening it and binding it to the given local endpoint. 

     Construct a basic_raw_socket on an existing native socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_raw_socket.bind [*bind]]]
    [Bind the socket to the given local endpoint. ]
  ]
  
  [
    [[link boost_asio.reference.basic_raw_socket.cancel [*cancel]]]
    [Cancel all asynchronous operations associated with the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_raw_socket.close [*close]]]
    [Close the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_raw_socket.connect [*connect]]]
    [Connect the socket to the specified endpoint. ]
  ]
  
  [
    [[link boost_asio.reference.basic_raw_socket.get_io_service [*get_io_service]]]
    [Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.basic_raw_socket.get_option [*get_option]]]
    [Get an option from the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_raw_socket.io_control [*io_control]]]
    [Perform an IO control command on the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_raw_socket.io_service [*io_service]]]
    [(Deprecated: use get_io_service().) Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.basic_raw_socket.is_open [*is_open]]]
    [Determine whether the socket is open. ]
  ]
  
  [
    [[link boost_asio.reference.basic_raw_socket.local_endpoint [*local_endpoint]]]
    [Get the local endpoint of the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_raw_socket.lowest_layer [*lowest_layer]]]
    [Get a reference to the lowest layer. 

     Get a const reference to the lowest layer. ]
  ]
  
  [
    [[link boost_asio.reference.basic_raw_socket.native [*native]]]
    [Get the native socket representation. ]
  ]
  
  [
    [[link boost_asio.reference.basic_raw_socket.open [*open]]]
    [Open the socket using the specified protocol. ]
  ]
  
  [
    [[link boost_asio.reference.basic_raw_socket.receive [*receive]]]
    [Receive some data on a connected socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_raw_socket.receive_from [*receive_from]]]
    [Receive raw data with the endpoint of the sender. ]
  ]
  
  [
    [[link boost_asio.reference.basic_raw_socket.remote_endpoint [*remote_endpoint]]]
    [Get the remote endpoint of the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_raw_socket.send [*send]]]
    [Send some data on a connected socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_raw_socket.send_to [*send_to]]]
    [Send raw data to the specified endpoint. ]
  ]
  
  [
    [[link boost_asio.reference.basic_raw_socket.set_option [*set_option]]]
    [Set an option on the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_raw_socket.shutdown [*shutdown]]]
    [Disable sends or receives on the socket. ]
  ]
  
]

[heading Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_raw_socket.max_connections [*max_connections]]]
    [The maximum length of the queue of pending incoming connections. ]
  ]

  [
    [[link boost_asio.reference.basic_raw_socket.message_do_not_route [*message_do_not_route]]]
    [Specify that the data should not be subject to routing. ]
  ]

  [
    [[link boost_asio.reference.basic_raw_socket.message_out_of_band [*message_out_of_band]]]
    [Process out-of-band data. ]
  ]

  [
    [[link boost_asio.reference.basic_raw_socket.message_peek [*message_peek]]]
    [Peek at incoming data without removing it from the input queue. ]
  ]

]

[heading Protected Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_raw_socket.implementation [*implementation]]]
    [The underlying implementation of the I/O object. ]
  ]

  [
    [[link boost_asio.reference.basic_raw_socket.service [*service]]]
    [The service associated with the I/O object. ]
  ]

]

The basic_raw_socket class template provides asynchronous and blocking raw-oriented socket functionality.


[heading Thread Safety]
  
[*Distinct] [*objects:]  Safe.

[*Shared] [*objects:]  Unsafe. 


[section:assign basic_raw_socket::assign]

[indexterm2 assign..basic_raw_socket] Assign an existing native socket to the socket. 

  void ``[link boost_asio.reference.basic_raw_socket.assign.overload1 assign]``(
      const protocol_type & protocol,
      const native_type & native_socket);

  boost::system::error_code ``[link boost_asio.reference.basic_raw_socket.assign.overload2 assign]``(
      const protocol_type & protocol,
      const native_type & native_socket,
      boost::system::error_code & ec);


[section:overload1 basic_raw_socket::assign (1 of 2 overloads)]


['Inherited from basic_socket.]

Assign an existing native socket to the socket. 

  void assign(
      const protocol_type & protocol,
      const native_type & native_socket);



[endsect]



[section:overload2 basic_raw_socket::assign (2 of 2 overloads)]


['Inherited from basic_socket.]

Assign an existing native socket to the socket. 

  boost::system::error_code assign(
      const protocol_type & protocol,
      const native_type & native_socket,
      boost::system::error_code & ec);



[endsect]


[endsect]


[section:async_connect basic_raw_socket::async_connect]


['Inherited from basic_socket.]

[indexterm2 async_connect..basic_raw_socket] Start an asynchronous connect. 

  void async_connect(
      const endpoint_type & peer_endpoint,
      ConnectHandler handler);


This function is used to asynchronously connect a socket to the specified remote endpoint. The function call always returns immediately.

The socket is automatically opened if it is not already open. If the connect fails, and the socket was automatically opened, the socket is not returned to the closed state.


[heading Parameters]
    

[variablelist
  
[[peer_endpoint][The remote endpoint to which the socket will be connected. Copies will be made of the endpoint object as required.]]

[[handler][The handler to be called when the connection operation completes. Copies will be made of the handler as required. The function signature of the handler must be: 
``
   void handler(
     const boost::system::error_code& error // Result of operation
   ); 
``
Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using boost::asio::io\_service::post().]]

]

[heading Example]
  


   void connect_handler(const boost::system::error_code& error)
   {
     if (!error)
     {
       // Connect succeeded.
     }
   }

   ...

   boost::asio::ip::tcp::socket socket(io_service);
   boost::asio::ip::tcp::endpoint endpoint(
       boost::asio::ip::address::from_string("1.2.3.4"), 12345);
   socket.async_connect(endpoint, connect_handler);






[endsect]


[section:async_receive basic_raw_socket::async_receive]

[indexterm2 async_receive..basic_raw_socket] Start an asynchronous receive on a connected socket. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
  void ``[link boost_asio.reference.basic_raw_socket.async_receive.overload1 async_receive]``(
      const MutableBufferSequence & buffers,
      ReadHandler handler);

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
  void ``[link boost_asio.reference.basic_raw_socket.async_receive.overload2 async_receive]``(
      const MutableBufferSequence & buffers,
      socket_base::message_flags flags,
      ReadHandler handler);


[section:overload1 basic_raw_socket::async_receive (1 of 2 overloads)]

Start an asynchronous receive on a connected socket. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
  void async_receive(
      const MutableBufferSequence & buffers,
      ReadHandler handler);


This function is used to asynchronously receive data from the raw socket. The function call always returns immediately.


[heading Parameters]
    

[variablelist
  
[[buffers][One or more buffers into which the data will be received. 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.]]

[[handler][The handler to be called when the receive operation completes. Copies will be made of the handler as required. The function signature of the handler must be: 
``
   void handler(
     const boost::system::error_code& error, // Result of operation.
     std::size_t bytes_transferred           // Number of bytes received.
   ); 
``
Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using boost::asio::io\_service::post().]]

]

[heading Remarks]
      
The async\_receive operation can only be used with a connected socket. Use the async\_receive\_from function to receive data on an unconnected raw socket.

[heading Example]
  
To receive into a single data buffer use the 
[link boost_asio.reference.buffer buffer]  function as follows: 

   socket.async_receive(boost::asio::buffer(data, size), handler);


See the 
[link boost_asio.reference.buffer buffer]  documentation for information on receiving into multiple buffers in one go, and how to use it with arrays, boost::array or std::vector. 



[endsect]



[section:overload2 basic_raw_socket::async_receive (2 of 2 overloads)]

Start an asynchronous receive on a connected socket. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
  void async_receive(
      const MutableBufferSequence & buffers,
      socket_base::message_flags flags,
      ReadHandler handler);


This function is used to asynchronously receive data from the raw socket. The function call always returns immediately.


[heading Parameters]
    

[variablelist
  
[[buffers][One or more buffers into which the data will be received. 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.]]

[[flags][Flags specifying how the receive call is to be made.]]

[[handler][The handler to be called when the receive operation completes. Copies will be made of the handler as required. The function signature of the handler must be: 
``
   void handler(
     const boost::system::error_code& error, // Result of operation.
     std::size_t bytes_transferred           // Number of bytes received.
   ); 
``
Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using boost::asio::io\_service::post().]]

]

[heading Remarks]
      
The async\_receive operation can only be used with a connected socket. Use the async\_receive\_from function to receive data on an unconnected raw socket. 



[endsect]


[endsect]

[section:async_receive_from basic_raw_socket::async_receive_from]

[indexterm2 async_receive_from..basic_raw_socket] Start an asynchronous receive. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
  void ``[link boost_asio.reference.basic_raw_socket.async_receive_from.overload1 async_receive_from]``(
      const MutableBufferSequence & buffers,
      endpoint_type & sender_endpoint,
      ReadHandler handler);

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
  void ``[link boost_asio.reference.basic_raw_socket.async_receive_from.overload2 async_receive_from]``(
      const MutableBufferSequence & buffers,
      endpoint_type & sender_endpoint,
      socket_base::message_flags flags,
      ReadHandler handler);


[section:overload1 basic_raw_socket::async_receive_from (1 of 2 overloads)]

Start an asynchronous receive. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
  void async_receive_from(
      const MutableBufferSequence & buffers,
      endpoint_type & sender_endpoint,
      ReadHandler handler);


This function is used to asynchronously receive raw data. The function call always returns immediately.


[heading Parameters]
    

[variablelist
  
[[buffers][One or more buffers into which the data will be received. 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.]]

[[sender_endpoint][An endpoint object that receives the endpoint of the remote sender of the data. Ownership of the sender\_endpoint object is retained by the caller, which must guarantee that it is valid until the handler is called.]]

[[handler][The handler to be called when the receive operation completes. Copies will be made of the handler as required. The function signature of the handler must be: 
``
   void handler(
     const boost::system::error_code& error, // Result of operation.
     std::size_t bytes_transferred           // Number of bytes received.
   ); 
``
Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using boost::asio::io\_service::post().]]

]

[heading Example]
  
To receive into a single data buffer use the 
[link boost_asio.reference.buffer buffer]  function as follows: 

   socket.async_receive_from(
       boost::asio::buffer(data, size), 0, sender_endpoint, handler); 


See the 
[link boost_asio.reference.buffer buffer]  documentation for information on receiving into multiple buffers in one go, and how to use it with arrays, boost::array or std::vector. 



[endsect]



[section:overload2 basic_raw_socket::async_receive_from (2 of 2 overloads)]

Start an asynchronous receive. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
  void async_receive_from(
      const MutableBufferSequence & buffers,
      endpoint_type & sender_endpoint,
      socket_base::message_flags flags,
      ReadHandler handler);


This function is used to asynchronously receive raw data. The function call always returns immediately.


[heading Parameters]
    

[variablelist
  
[[buffers][One or more buffers into which the data will be received. 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.]]

[[sender_endpoint][An endpoint object that receives the endpoint of the remote sender of the data. Ownership of the sender\_endpoint object is retained by the caller, which must guarantee that it is valid until the handler is called.]]

[[flags][Flags specifying how the receive call is to be made.]]

[[handler][The handler to be called when the receive operation completes. Copies will be made of the handler as required. The function signature of the handler must be: 
``
   void handler(
     const boost::system::error_code& error, // Result of operation.
     std::size_t bytes_transferred           // Number of bytes received.
   ); 
``
Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using boost::asio::io\_service::post(). ]]

]



[endsect]


[endsect]

[section:async_send basic_raw_socket::async_send]

[indexterm2 async_send..basic_raw_socket] Start an asynchronous send on a connected socket. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
  void ``[link boost_asio.reference.basic_raw_socket.async_send.overload1 async_send]``(
      const ConstBufferSequence & buffers,
      WriteHandler handler);

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
  void ``[link boost_asio.reference.basic_raw_socket.async_send.overload2 async_send]``(
      const ConstBufferSequence & buffers,
      socket_base::message_flags flags,
      WriteHandler handler);


[section:overload1 basic_raw_socket::async_send (1 of 2 overloads)]

Start an asynchronous send on a connected socket. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
  void async_send(
      const ConstBufferSequence & buffers,
      WriteHandler handler);


This function is used to send data on the raw socket. The function call will block until the data has been sent successfully or an error occurs.


[heading Parameters]
    

[variablelist
  
[[buffers][One or more data buffers to be sent on the socket. 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.]]

[[handler][The handler to be called when the send operation completes. Copies will be made of the handler as required. The function signature of the handler must be: 
``
   void handler(
     const boost::system::error_code& error, // Result of operation.
     std::size_t bytes_transferred           // Number of bytes sent.
   ); 
``
Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using boost::asio::io\_service::post().]]

]

[heading Remarks]
      
The async\_send operation can only be used with a connected socket. Use the async\_send\_to function to send data on an unconnected raw socket.

[heading Example]
  
To send a single data buffer use the 
[link boost_asio.reference.buffer buffer]  function as follows: 

   socket.async_send(boost::asio::buffer(data, size), handler);


See the 
[link boost_asio.reference.buffer buffer]  documentation for information on sending multiple buffers in one go, and how to use it with arrays, boost::array or std::vector. 



[endsect]



[section:overload2 basic_raw_socket::async_send (2 of 2 overloads)]

Start an asynchronous send on a connected socket. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
  void async_send(
      const ConstBufferSequence & buffers,
      socket_base::message_flags flags,
      WriteHandler handler);


This function is used to send data on the raw socket. The function call will block until the data has been sent successfully or an error occurs.


[heading Parameters]
    

[variablelist
  
[[buffers][One or more data buffers to be sent on the socket. 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.]]

[[flags][Flags specifying how the send call is to be made.]]

[[handler][The handler to be called when the send operation completes. Copies will be made of the handler as required. The function signature of the handler must be: 
``
   void handler(
     const boost::system::error_code& error, // Result of operation.
     std::size_t bytes_transferred           // Number of bytes sent.
   ); 
``
Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using boost::asio::io\_service::post().]]

]

[heading Remarks]
      
The async\_send operation can only be used with a connected socket. Use the async\_send\_to function to send data on an unconnected raw socket. 



[endsect]


[endsect]

[section:async_send_to basic_raw_socket::async_send_to]

[indexterm2 async_send_to..basic_raw_socket] Start an asynchronous send. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
  void ``[link boost_asio.reference.basic_raw_socket.async_send_to.overload1 async_send_to]``(
      const ConstBufferSequence & buffers,
      const endpoint_type & destination,
      WriteHandler handler);

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
  void ``[link boost_asio.reference.basic_raw_socket.async_send_to.overload2 async_send_to]``(
      const ConstBufferSequence & buffers,
      const endpoint_type & destination,
      socket_base::message_flags flags,
      WriteHandler handler);


[section:overload1 basic_raw_socket::async_send_to (1 of 2 overloads)]

Start an asynchronous send. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
  void async_send_to(
      const ConstBufferSequence & buffers,
      const endpoint_type & destination,
      WriteHandler handler);


This function is used to asynchronously send raw data to the specified remote endpoint. The function call always returns immediately.


[heading Parameters]
    

[variablelist
  
[[buffers][One or more data buffers to be sent to the remote endpoint. 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.]]

[[destination][The remote endpoint to which the data will be sent. Copies will be made of the endpoint as required.]]

[[handler][The handler to be called when the send operation completes. Copies will be made of the handler as required. The function signature of the handler must be: 
``
   void handler(
     const boost::system::error_code& error, // Result of operation.
     std::size_t bytes_transferred           // Number of bytes sent.
   ); 
``
Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using boost::asio::io\_service::post().]]

]

[heading Example]
  
To send a single data buffer use the 
[link boost_asio.reference.buffer buffer]  function as follows: 

   boost::asio::ip::udp::endpoint destination(
       boost::asio::ip::address::from_string("1.2.3.4"), 12345);
   socket.async_send_to(
       boost::asio::buffer(data, size), destination, handler);


See the 
[link boost_asio.reference.buffer buffer]  documentation for information on sending multiple buffers in one go, and how to use it with arrays, boost::array or std::vector. 



[endsect]



[section:overload2 basic_raw_socket::async_send_to (2 of 2 overloads)]

Start an asynchronous send. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
  void async_send_to(
      const ConstBufferSequence & buffers,
      const endpoint_type & destination,
      socket_base::message_flags flags,
      WriteHandler handler);


This function is used to asynchronously send raw data to the specified remote endpoint. The function call always returns immediately.


[heading Parameters]
    

[variablelist
  
[[buffers][One or more data buffers to be sent to the remote endpoint. 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.]]

[[flags][Flags specifying how the send call is to be made.]]

[[destination][The remote endpoint to which the data will be sent. Copies will be made of the endpoint as required.]]

[[handler][The handler to be called when the send operation completes. Copies will be made of the handler as required. The function signature of the handler must be: 
``
   void handler(
     const boost::system::error_code& error, // Result of operation.
     std::size_t bytes_transferred           // Number of bytes sent.
   ); 
``
Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using boost::asio::io\_service::post(). ]]

]



[endsect]


[endsect]

[section:at_mark basic_raw_socket::at_mark]

[indexterm2 at_mark..basic_raw_socket] Determine whether the socket is at the out-of-band data mark. 

  bool ``[link boost_asio.reference.basic_raw_socket.at_mark.overload1 at_mark]``() const;

  bool ``[link boost_asio.reference.basic_raw_socket.at_mark.overload2 at_mark]``(
      boost::system::error_code & ec) const;


[section:overload1 basic_raw_socket::at_mark (1 of 2 overloads)]


['Inherited from basic_socket.]

Determine whether the socket is at the out-of-band data mark. 

  bool at_mark() const;


This function is used to check whether the socket input is currently positioned at the out-of-band data mark.


[heading Return Value]
      
A bool indicating whether the socket is at the out-of-band data mark.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. ]]

]



[endsect]



[section:overload2 basic_raw_socket::at_mark (2 of 2 overloads)]


['Inherited from basic_socket.]

Determine whether the socket is at the out-of-band data mark. 

  bool at_mark(
      boost::system::error_code & ec) const;


This function is used to check whether the socket input is currently positioned at the out-of-band data mark.


[heading Parameters]
    

[variablelist
  
[[ec][Set to indicate what error occurred, if any.]]

]

[heading Return Value]
      
A bool indicating whether the socket is at the out-of-band data mark. 



[endsect]


[endsect]

[section:available basic_raw_socket::available]

[indexterm2 available..basic_raw_socket] Determine the number of bytes available for reading. 

  std::size_t ``[link boost_asio.reference.basic_raw_socket.available.overload1 available]``() const;

  std::size_t ``[link boost_asio.reference.basic_raw_socket.available.overload2 available]``(
      boost::system::error_code & ec) const;


[section:overload1 basic_raw_socket::available (1 of 2 overloads)]


['Inherited from basic_socket.]

Determine the number of bytes available for reading. 

  std::size_t available() const;


This function is used to determine the number of bytes that may be read without blocking.


[heading Return Value]
      
The number of bytes that may be read without blocking, or 0 if an error occurs.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. ]]

]



[endsect]



[section:overload2 basic_raw_socket::available (2 of 2 overloads)]


['Inherited from basic_socket.]

Determine the number of bytes available for reading. 

  std::size_t available(
      boost::system::error_code & ec) const;


This function is used to determine the number of bytes that may be read without blocking.


[heading Parameters]
    

[variablelist
  
[[ec][Set to indicate what error occurred, if any.]]

]

[heading Return Value]
      
The number of bytes that may be read without blocking, or 0 if an error occurs. 



[endsect]


[endsect]

[section:basic_raw_socket basic_raw_socket::basic_raw_socket]

[indexterm2 basic_raw_socket..basic_raw_socket] Construct a basic_raw_socket without opening it. 

  ``[link boost_asio.reference.basic_raw_socket.basic_raw_socket.overload1 basic_raw_socket]``(
      boost::asio::io_service & io_service);

Construct and open a basic_raw_socket. 

  ``[link boost_asio.reference.basic_raw_socket.basic_raw_socket.overload2 basic_raw_socket]``(
      boost::asio::io_service & io_service,
      const protocol_type & protocol);

Construct a basic_raw_socket, opening it and binding it to the given local endpoint. 

  ``[link boost_asio.reference.basic_raw_socket.basic_raw_socket.overload3 basic_raw_socket]``(
      boost::asio::io_service & io_service,
      const endpoint_type & endpoint);

Construct a basic_raw_socket on an existing native socket. 

  ``[link boost_asio.reference.basic_raw_socket.basic_raw_socket.overload4 basic_raw_socket]``(
      boost::asio::io_service & io_service,
      const protocol_type & protocol,
      const native_type & native_socket);


[section:overload1 basic_raw_socket::basic_raw_socket (1 of 4 overloads)]

Construct a basic_raw_socket without opening it. 

  basic_raw_socket(
      boost::asio::io_service & io_service);


This constructor creates a raw socket without opening it. The open() function must be called before data can be sent or received on the socket.


[heading Parameters]
    

[variablelist
  
[[io_service][The io\_service object that the raw socket will use to dispatch handlers for any asynchronous operations performed on the socket. ]]

]



[endsect]



[section:overload2 basic_raw_socket::basic_raw_socket (2 of 4 overloads)]

Construct and open a basic_raw_socket. 

  basic_raw_socket(
      boost::asio::io_service & io_service,
      const protocol_type & protocol);


This constructor creates and opens a raw socket.


[heading Parameters]
    

[variablelist
  
[[io_service][The io\_service object that the raw socket will use to dispatch handlers for any asynchronous operations performed on the socket.]]

[[protocol][An object specifying protocol parameters to be used.]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. ]]

]



[endsect]



[section:overload3 basic_raw_socket::basic_raw_socket (3 of 4 overloads)]

Construct a basic_raw_socket, opening it and binding it to the given local endpoint. 

  basic_raw_socket(
      boost::asio::io_service & io_service,
      const endpoint_type & endpoint);


This constructor creates a raw socket and automatically opens it bound to the specified endpoint on the local machine. The protocol used is the protocol associated with the given endpoint.


[heading Parameters]
    

[variablelist
  
[[io_service][The io\_service object that the raw socket will use to dispatch handlers for any asynchronous operations performed on the socket.]]

[[endpoint][An endpoint on the local machine to which the raw socket will be bound.]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. ]]

]



[endsect]



[section:overload4 basic_raw_socket::basic_raw_socket (4 of 4 overloads)]

Construct a basic_raw_socket on an existing native socket. 

  basic_raw_socket(
      boost::asio::io_service & io_service,
      const protocol_type & protocol,
      const native_type & native_socket);


This constructor creates a raw socket object to hold an existing native socket.


[heading Parameters]
    

[variablelist
  
[[io_service][The io\_service object that the raw socket will use to dispatch handlers for any asynchronous operations performed on the socket.]]

[[protocol][An object specifying protocol parameters to be used.]]

[[native_socket][The new underlying socket implementation.]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. ]]

]



[endsect]


[endsect]

[section:bind basic_raw_socket::bind]

[indexterm2 bind..basic_raw_socket] Bind the socket to the given local endpoint. 

  void ``[link boost_asio.reference.basic_raw_socket.bind.overload1 bind]``(
      const endpoint_type & endpoint);

  boost::system::error_code ``[link boost_asio.reference.basic_raw_socket.bind.overload2 bind]``(
      const endpoint_type & endpoint,
      boost::system::error_code & ec);


[section:overload1 basic_raw_socket::bind (1 of 2 overloads)]


['Inherited from basic_socket.]

Bind the socket to the given local endpoint. 

  void bind(
      const endpoint_type & endpoint);


This function binds the socket to the specified endpoint on the local machine.


[heading Parameters]
    

[variablelist
  
[[endpoint][An endpoint on the local machine to which the socket will be bound.]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Example]
  


   boost::asio::ip::tcp::socket socket(io_service);
   socket.open(boost::asio::ip::tcp::v4());
   socket.bind(boost::asio::ip::tcp::endpoint(
         boost::asio::ip::tcp::v4(), 12345));






[endsect]



[section:overload2 basic_raw_socket::bind (2 of 2 overloads)]


['Inherited from basic_socket.]

Bind the socket to the given local endpoint. 

  boost::system::error_code bind(
      const endpoint_type & endpoint,
      boost::system::error_code & ec);


This function binds the socket to the specified endpoint on the local machine.


[heading Parameters]
    

[variablelist
  
[[endpoint][An endpoint on the local machine to which the socket will be bound.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Example]
  


   boost::asio::ip::tcp::socket socket(io_service);
   socket.open(boost::asio::ip::tcp::v4());
   boost::system::error_code ec;
   socket.bind(boost::asio::ip::tcp::endpoint(
         boost::asio::ip::tcp::v4(), 12345), ec);
   if (ec)
   {
     // An error occurred.
   }






[endsect]


[endsect]


[section:broadcast basic_raw_socket::broadcast]


['Inherited from socket_base.]

[indexterm2 broadcast..basic_raw_socket] Socket option to permit sending of broadcast messages. 

  typedef implementation_defined broadcast;



Implements the SOL\_SOCKET/SO\_BROADCAST socket option.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::udp::socket socket(io_service); 
   ...
   boost::asio::socket_base::broadcast option(true);
   socket.set_option(option);




Getting the current option value: 

   boost::asio::ip::udp::socket socket(io_service); 
   ...
   boost::asio::socket_base::broadcast option;
   socket.get_option(option);
   bool is_set = option.value();






[endsect]



[section:bytes_readable basic_raw_socket::bytes_readable]


['Inherited from socket_base.]

[indexterm2 bytes_readable..basic_raw_socket] IO control command to get the amount of data that can be read without blocking. 

  typedef implementation_defined bytes_readable;



Implements the FIONREAD IO control command.


[heading Example]
  


   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::bytes_readable command(true);
   socket.io_control(command);
   std::size_t bytes_readable = command.get();






[endsect]


[section:cancel basic_raw_socket::cancel]

[indexterm2 cancel..basic_raw_socket] Cancel all asynchronous operations associated with the socket. 

  void ``[link boost_asio.reference.basic_raw_socket.cancel.overload1 cancel]``();

  boost::system::error_code ``[link boost_asio.reference.basic_raw_socket.cancel.overload2 cancel]``(
      boost::system::error_code & ec);


[section:overload1 basic_raw_socket::cancel (1 of 2 overloads)]


['Inherited from basic_socket.]

Cancel all asynchronous operations associated with the socket. 

  void cancel();


This function causes all outstanding asynchronous connect, send and receive operations to finish immediately, and the handlers for cancelled operations will be passed the boost::asio::error::operation\_aborted error.


[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Remarks]
      
Calls to cancel() will always fail with boost::asio::error::operation\_not\_supported when run on Windows XP, Windows Server 2003, and earlier versions of Windows, unless BOOST\_ASIO\_ENABLE\_CANCELIO is defined. However, the CancelIo function has two issues that should be considered before enabling its use:

* It will only cancel asynchronous operations that were initiated in the current thread.

* It can appear to complete without error, but the request to cancel the unfinished operations may be silently ignored by the operating system. Whether it works or not seems to depend on the drivers that are installed.

For portable cancellation, consider using one of the following alternatives:


* Disable asio's I/O completion port backend by defining BOOST_ASIO_DISABLE_IOCP.

* Use the close() function to simultaneously cancel the outstanding operations and close the socket.

When running on Windows Vista, Windows Server 2008, and later, the CancelIoEx function is always used. This function does not have the problems described above. 


[endsect]



[section:overload2 basic_raw_socket::cancel (2 of 2 overloads)]


['Inherited from basic_socket.]

Cancel all asynchronous operations associated with the socket. 

  boost::system::error_code cancel(
      boost::system::error_code & ec);


This function causes all outstanding asynchronous connect, send and receive operations to finish immediately, and the handlers for cancelled operations will be passed the boost::asio::error::operation\_aborted error.


[heading Parameters]
    

[variablelist
  
[[ec][Set to indicate what error occurred, if any.]]

]

[heading Remarks]
      
Calls to cancel() will always fail with boost::asio::error::operation\_not\_supported when run on Windows XP, Windows Server 2003, and earlier versions of Windows, unless BOOST\_ASIO\_ENABLE\_CANCELIO is defined. However, the CancelIo function has two issues that should be considered before enabling its use:

* It will only cancel asynchronous operations that were initiated in the current thread.

* It can appear to complete without error, but the request to cancel the unfinished operations may be silently ignored by the operating system. Whether it works or not seems to depend on the drivers that are installed.

For portable cancellation, consider using one of the following alternatives:


* Disable asio's I/O completion port backend by defining BOOST_ASIO_DISABLE_IOCP.

* Use the close() function to simultaneously cancel the outstanding operations and close the socket.

When running on Windows Vista, Windows Server 2008, and later, the CancelIoEx function is always used. This function does not have the problems described above. 


[endsect]


[endsect]

[section:close basic_raw_socket::close]

[indexterm2 close..basic_raw_socket] Close the socket. 

  void ``[link boost_asio.reference.basic_raw_socket.close.overload1 close]``();

  boost::system::error_code ``[link boost_asio.reference.basic_raw_socket.close.overload2 close]``(
      boost::system::error_code & ec);


[section:overload1 basic_raw_socket::close (1 of 2 overloads)]


['Inherited from basic_socket.]

Close the socket. 

  void close();


This function is used to close the socket. Any asynchronous send, receive or connect operations will be cancelled immediately, and will complete with the boost::asio::error::operation\_aborted error.


[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Remarks]
      
For portable behaviour with respect to graceful closure of a connected socket, call shutdown() before closing the socket. 



[endsect]



[section:overload2 basic_raw_socket::close (2 of 2 overloads)]


['Inherited from basic_socket.]

Close the socket. 

  boost::system::error_code close(
      boost::system::error_code & ec);


This function is used to close the socket. Any asynchronous send, receive or connect operations will be cancelled immediately, and will complete with the boost::asio::error::operation\_aborted error.


[heading Parameters]
    

[variablelist
  
[[ec][Set to indicate what error occurred, if any.]]

]

[heading Example]
  


   boost::asio::ip::tcp::socket socket(io_service);
   ...
   boost::system::error_code ec;
   socket.close(ec);
   if (ec)
   {
     // An error occurred.
   }




[heading Remarks]
      
For portable behaviour with respect to graceful closure of a connected socket, call shutdown() before closing the socket. 



[endsect]


[endsect]

[section:connect basic_raw_socket::connect]

[indexterm2 connect..basic_raw_socket] Connect the socket to the specified endpoint. 

  void ``[link boost_asio.reference.basic_raw_socket.connect.overload1 connect]``(
      const endpoint_type & peer_endpoint);

  boost::system::error_code ``[link boost_asio.reference.basic_raw_socket.connect.overload2 connect]``(
      const endpoint_type & peer_endpoint,
      boost::system::error_code & ec);


[section:overload1 basic_raw_socket::connect (1 of 2 overloads)]


['Inherited from basic_socket.]

Connect the socket to the specified endpoint. 

  void connect(
      const endpoint_type & peer_endpoint);


This function is used to connect a socket to the specified remote endpoint. The function call will block until the connection is successfully made or an error occurs.

The socket is automatically opened if it is not already open. If the connect fails, and the socket was automatically opened, the socket is not returned to the closed state.


[heading Parameters]
    

[variablelist
  
[[peer_endpoint][The remote endpoint to which the socket will be connected.]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Example]
  


   boost::asio::ip::tcp::socket socket(io_service);
   boost::asio::ip::tcp::endpoint endpoint(
       boost::asio::ip::address::from_string("1.2.3.4"), 12345);
   socket.connect(endpoint);






[endsect]



[section:overload2 basic_raw_socket::connect (2 of 2 overloads)]


['Inherited from basic_socket.]

Connect the socket to the specified endpoint. 

  boost::system::error_code connect(
      const endpoint_type & peer_endpoint,
      boost::system::error_code & ec);


This function is used to connect a socket to the specified remote endpoint. The function call will block until the connection is successfully made or an error occurs.

The socket is automatically opened if it is not already open. If the connect fails, and the socket was automatically opened, the socket is not returned to the closed state.


[heading Parameters]
    

[variablelist
  
[[peer_endpoint][The remote endpoint to which the socket will be connected.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Example]
  


   boost::asio::ip::tcp::socket socket(io_service);
   boost::asio::ip::tcp::endpoint endpoint(
       boost::asio::ip::address::from_string("1.2.3.4"), 12345);
   boost::system::error_code ec;
   socket.connect(endpoint, ec);
   if (ec)
   {
     // An error occurred.
   }






[endsect]


[endsect]


[section:debug basic_raw_socket::debug]


['Inherited from socket_base.]

[indexterm2 debug..basic_raw_socket] Socket option to enable socket-level debugging. 

  typedef implementation_defined debug;



Implements the SOL\_SOCKET/SO\_DEBUG socket option.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::debug option(true);
   socket.set_option(option);




Getting the current option value: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::debug option;
   socket.get_option(option);
   bool is_set = option.value();






[endsect]



[section:do_not_route basic_raw_socket::do_not_route]


['Inherited from socket_base.]

[indexterm2 do_not_route..basic_raw_socket] Socket option to prevent routing, use local interfaces only. 

  typedef implementation_defined do_not_route;



Implements the SOL\_SOCKET/SO\_DONTROUTE socket option.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::udp::socket socket(io_service); 
   ...
   boost::asio::socket_base::do_not_route option(true);
   socket.set_option(option);




Getting the current option value: 

   boost::asio::ip::udp::socket socket(io_service); 
   ...
   boost::asio::socket_base::do_not_route option;
   socket.get_option(option);
   bool is_set = option.value();






[endsect]



[section:enable_connection_aborted basic_raw_socket::enable_connection_aborted]


['Inherited from socket_base.]

[indexterm2 enable_connection_aborted..basic_raw_socket] Socket option to report aborted connections on accept. 

  typedef implementation_defined enable_connection_aborted;



Implements a custom socket option that determines whether or not an accept operation is permitted to fail with boost::asio::error::connection\_aborted. By default the option is false.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::tcp::acceptor acceptor(io_service); 
   ...
   boost::asio::socket_base::enable_connection_aborted option(true);
   acceptor.set_option(option);




Getting the current option value: 

   boost::asio::ip::tcp::acceptor acceptor(io_service); 
   ...
   boost::asio::socket_base::enable_connection_aborted option;
   acceptor.get_option(option);
   bool is_set = option.value();






[endsect]



[section:endpoint_type basic_raw_socket::endpoint_type]

[indexterm2 endpoint_type..basic_raw_socket] The endpoint type. 

  typedef Protocol::endpoint endpoint_type;




[endsect]



[section:get_io_service basic_raw_socket::get_io_service]


['Inherited from basic_io_object.]

[indexterm2 get_io_service..basic_raw_socket] Get the io_service associated with the object. 

  boost::asio::io_service & get_io_service();


This function may be used to obtain the io_service object that the I/O object uses to dispatch handlers for asynchronous operations.


[heading Return Value]
      
A reference to the io_service object that the I/O object will use to dispatch handlers. Ownership is not transferred to the caller. 



[endsect]


[section:get_option basic_raw_socket::get_option]

[indexterm2 get_option..basic_raw_socket] Get an option from the socket. 

  void ``[link boost_asio.reference.basic_raw_socket.get_option.overload1 get_option]``(
      GettableSocketOption & option) const;

  boost::system::error_code ``[link boost_asio.reference.basic_raw_socket.get_option.overload2 get_option]``(
      GettableSocketOption & option,
      boost::system::error_code & ec) const;


[section:overload1 basic_raw_socket::get_option (1 of 2 overloads)]


['Inherited from basic_socket.]

Get an option from the socket. 

  void get_option(
      GettableSocketOption & option) const;


This function is used to get the current value of an option on the socket.


[heading Parameters]
    

[variablelist
  
[[option][The option value to be obtained from the socket.]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Example]
  
Getting the value of the SOL\_SOCKET/SO\_KEEPALIVE option: 

   boost::asio::ip::tcp::socket socket(io_service);
   ...
   boost::asio::ip::tcp::socket::keep_alive option;
   socket.get_option(option);
   bool is_set = option.get();






[endsect]



[section:overload2 basic_raw_socket::get_option (2 of 2 overloads)]


['Inherited from basic_socket.]

Get an option from the socket. 

  boost::system::error_code get_option(
      GettableSocketOption & option,
      boost::system::error_code & ec) const;


This function is used to get the current value of an option on the socket.


[heading Parameters]
    

[variablelist
  
[[option][The option value to be obtained from the socket.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Example]
  
Getting the value of the SOL\_SOCKET/SO\_KEEPALIVE option: 

   boost::asio::ip::tcp::socket socket(io_service);
   ...
   boost::asio::ip::tcp::socket::keep_alive option;
   boost::system::error_code ec;
   socket.get_option(option, ec);
   if (ec)
   {
     // An error occurred.
   }
   bool is_set = option.get();






[endsect]


[endsect]


[section:implementation basic_raw_socket::implementation]


['Inherited from basic_io_object.]

[indexterm2 implementation..basic_raw_socket] The underlying implementation of the I/O object. 

  implementation_type implementation;



[endsect]



[section:implementation_type basic_raw_socket::implementation_type]


['Inherited from basic_io_object.]

[indexterm2 implementation_type..basic_raw_socket] The underlying implementation type of I/O object. 

  typedef service_type::implementation_type implementation_type;




[endsect]


[section:io_control basic_raw_socket::io_control]

[indexterm2 io_control..basic_raw_socket] Perform an IO control command on the socket. 

  void ``[link boost_asio.reference.basic_raw_socket.io_control.overload1 io_control]``(
      IoControlCommand & command);

  boost::system::error_code ``[link boost_asio.reference.basic_raw_socket.io_control.overload2 io_control]``(
      IoControlCommand & command,
      boost::system::error_code & ec);


[section:overload1 basic_raw_socket::io_control (1 of 2 overloads)]


['Inherited from basic_socket.]

Perform an IO control command on the socket. 

  void io_control(
      IoControlCommand & command);


This function is used to execute an IO control command on the socket.


[heading Parameters]
    

[variablelist
  
[[command][The IO control command to be performed on the socket.]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Example]
  
Getting the number of bytes ready to read: 

   boost::asio::ip::tcp::socket socket(io_service);
   ...
   boost::asio::ip::tcp::socket::bytes_readable command;
   socket.io_control(command);
   std::size_t bytes_readable = command.get();






[endsect]



[section:overload2 basic_raw_socket::io_control (2 of 2 overloads)]


['Inherited from basic_socket.]

Perform an IO control command on the socket. 

  boost::system::error_code io_control(
      IoControlCommand & command,
      boost::system::error_code & ec);


This function is used to execute an IO control command on the socket.


[heading Parameters]
    

[variablelist
  
[[command][The IO control command to be performed on the socket.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Example]
  
Getting the number of bytes ready to read: 

   boost::asio::ip::tcp::socket socket(io_service);
   ...
   boost::asio::ip::tcp::socket::bytes_readable command;
   boost::system::error_code ec;
   socket.io_control(command, ec);
   if (ec)
   {
     // An error occurred.
   }
   std::size_t bytes_readable = command.get();






[endsect]


[endsect]


[section:io_service basic_raw_socket::io_service]


['Inherited from basic_io_object.]

[indexterm2 io_service..basic_raw_socket] (Deprecated: use get_io_service().) Get the io_service associated with the object. 

  boost::asio::io_service & io_service();


This function may be used to obtain the io_service object that the I/O object uses to dispatch handlers for asynchronous operations.


[heading Return Value]
      
A reference to the io_service object that the I/O object will use to dispatch handlers. Ownership is not transferred to the caller. 



[endsect]



[section:is_open basic_raw_socket::is_open]


['Inherited from basic_socket.]

[indexterm2 is_open..basic_raw_socket] Determine whether the socket is open. 

  bool is_open() const;



[endsect]



[section:keep_alive basic_raw_socket::keep_alive]


['Inherited from socket_base.]

[indexterm2 keep_alive..basic_raw_socket] Socket option to send keep-alives. 

  typedef implementation_defined keep_alive;



Implements the SOL\_SOCKET/SO\_KEEPALIVE socket option.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::keep_alive option(true);
   socket.set_option(option);




Getting the current option value: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::keep_alive option;
   socket.get_option(option);
   bool is_set = option.value();






[endsect]



[section:linger basic_raw_socket::linger]


['Inherited from socket_base.]

[indexterm2 linger..basic_raw_socket] Socket option to specify whether the socket lingers on close if unsent data is present. 

  typedef implementation_defined linger;



Implements the SOL\_SOCKET/SO\_LINGER socket option.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::linger option(true, 30);
   socket.set_option(option);




Getting the current option value: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::linger option;
   socket.get_option(option);
   bool is_set = option.enabled();
   unsigned short timeout = option.timeout();






[endsect]


[section:local_endpoint basic_raw_socket::local_endpoint]

[indexterm2 local_endpoint..basic_raw_socket] Get the local endpoint of the socket. 

  endpoint_type ``[link boost_asio.reference.basic_raw_socket.local_endpoint.overload1 local_endpoint]``() const;

  endpoint_type ``[link boost_asio.reference.basic_raw_socket.local_endpoint.overload2 local_endpoint]``(
      boost::system::error_code & ec) const;


[section:overload1 basic_raw_socket::local_endpoint (1 of 2 overloads)]


['Inherited from basic_socket.]

Get the local endpoint of the socket. 

  endpoint_type local_endpoint() const;


This function is used to obtain the locally bound endpoint of the socket.


[heading Return Value]
      
An object that represents the local endpoint of the socket.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Example]
  


   boost::asio::ip::tcp::socket socket(io_service);
   ...
   boost::asio::ip::tcp::endpoint endpoint = socket.local_endpoint();






[endsect]



[section:overload2 basic_raw_socket::local_endpoint (2 of 2 overloads)]


['Inherited from basic_socket.]

Get the local endpoint of the socket. 

  endpoint_type local_endpoint(
      boost::system::error_code & ec) const;


This function is used to obtain the locally bound endpoint of the socket.


[heading Parameters]
    

[variablelist
  
[[ec][Set to indicate what error occurred, if any.]]

]

[heading Return Value]
      
An object that represents the local endpoint of the socket. Returns a default-constructed endpoint object if an error occurred.

[heading Example]
  


   boost::asio::ip::tcp::socket socket(io_service);
   ...
   boost::system::error_code ec;
   boost::asio::ip::tcp::endpoint endpoint = socket.local_endpoint(ec);
   if (ec)
   {
     // An error occurred.
   }






[endsect]


[endsect]

[section:lowest_layer basic_raw_socket::lowest_layer]

[indexterm2 lowest_layer..basic_raw_socket] Get a reference to the lowest layer. 

  lowest_layer_type & ``[link boost_asio.reference.basic_raw_socket.lowest_layer.overload1 lowest_layer]``();

Get a const reference to the lowest layer. 

  const lowest_layer_type & ``[link boost_asio.reference.basic_raw_socket.lowest_layer.overload2 lowest_layer]``() const;


[section:overload1 basic_raw_socket::lowest_layer (1 of 2 overloads)]


['Inherited from basic_socket.]

Get a reference to the lowest layer. 

  lowest_layer_type & lowest_layer();


This function returns a reference to the lowest layer in a stack of layers. Since a basic_socket cannot contain any further layers, it simply returns a reference to itself.


[heading Return Value]
      
A reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller. 



[endsect]



[section:overload2 basic_raw_socket::lowest_layer (2 of 2 overloads)]


['Inherited from basic_socket.]

Get a const reference to the lowest layer. 

  const lowest_layer_type & lowest_layer() const;


This function returns a const reference to the lowest layer in a stack of layers. Since a basic_socket cannot contain any further layers, it simply returns a reference to itself.


[heading Return Value]
      
A const reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller. 



[endsect]


[endsect]


[section:lowest_layer_type basic_raw_socket::lowest_layer_type]


['Inherited from basic_socket.]

[indexterm2 lowest_layer_type..basic_raw_socket] A basic_socket is always the lowest layer. 

  typedef basic_socket< Protocol, RawSocketService > lowest_layer_type;


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.basic_socket.broadcast [*broadcast]]]
    [Socket option to permit sending of broadcast messages. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.bytes_readable [*bytes_readable]]]
    [IO control command to get the amount of data that can be read without blocking. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.debug [*debug]]]
    [Socket option to enable socket-level debugging. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.do_not_route [*do_not_route]]]
    [Socket option to prevent routing, use local interfaces only. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.enable_connection_aborted [*enable_connection_aborted]]]
    [Socket option to report aborted connections on accept. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.endpoint_type [*endpoint_type]]]
    [The endpoint type. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.implementation_type [*implementation_type]]]
    [The underlying implementation type of I/O object. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.keep_alive [*keep_alive]]]
    [Socket option to send keep-alives. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.linger [*linger]]]
    [Socket option to specify whether the socket lingers on close if unsent data is present. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.lowest_layer_type [*lowest_layer_type]]]
    [A basic_socket is always the lowest layer. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.message_flags [*message_flags]]]
    [Bitmask type for flags that can be passed to send and receive operations. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.native_type [*native_type]]]
    [The native representation of a socket. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.non_blocking_io [*non_blocking_io]]]
    [IO control command to set the blocking mode of the socket. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.protocol_type [*protocol_type]]]
    [The protocol type. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.receive_buffer_size [*receive_buffer_size]]]
    [Socket option for the receive buffer size of a socket. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.receive_low_watermark [*receive_low_watermark]]]
    [Socket option for the receive low watermark. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.reuse_address [*reuse_address]]]
    [Socket option to allow the socket to be bound to an address that is already in use. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.send_buffer_size [*send_buffer_size]]]
    [Socket option for the send buffer size of a socket. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.send_low_watermark [*send_low_watermark]]]
    [Socket option for the send low watermark. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.service_type [*service_type]]]
    [The type of the service that will be used to provide I/O operations. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.shutdown_type [*shutdown_type]]]
    [Different ways a socket may be shutdown. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_socket.assign [*assign]]]
    [Assign an existing native socket to the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.async_connect [*async_connect]]]
    [Start an asynchronous connect. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.at_mark [*at_mark]]]
    [Determine whether the socket is at the out-of-band data mark. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.available [*available]]]
    [Determine the number of bytes available for reading. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.basic_socket [*basic_socket]]]
    [Construct a basic_socket without opening it. 

     Construct and open a basic_socket. 

     Construct a basic_socket, opening it and binding it to the given local endpoint. 

     Construct a basic_socket on an existing native socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.bind [*bind]]]
    [Bind the socket to the given local endpoint. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.cancel [*cancel]]]
    [Cancel all asynchronous operations associated with the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.close [*close]]]
    [Close the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.connect [*connect]]]
    [Connect the socket to the specified endpoint. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.get_io_service [*get_io_service]]]
    [Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.get_option [*get_option]]]
    [Get an option from the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.io_control [*io_control]]]
    [Perform an IO control command on the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.io_service [*io_service]]]
    [(Deprecated: use get_io_service().) Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.is_open [*is_open]]]
    [Determine whether the socket is open. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.local_endpoint [*local_endpoint]]]
    [Get the local endpoint of the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.lowest_layer [*lowest_layer]]]
    [Get a reference to the lowest layer. 

     Get a const reference to the lowest layer. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.native [*native]]]
    [Get the native socket representation. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.open [*open]]]
    [Open the socket using the specified protocol. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.remote_endpoint [*remote_endpoint]]]
    [Get the remote endpoint of the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.set_option [*set_option]]]
    [Set an option on the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.shutdown [*shutdown]]]
    [Disable sends or receives on the socket. ]
  ]
  
]

[heading Protected Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_socket._basic_socket [*~basic_socket]]]
    [Protected destructor to prevent deletion through this type. ]
  ]
  
]

[heading Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_socket.max_connections [*max_connections]]]
    [The maximum length of the queue of pending incoming connections. ]
  ]

  [
    [[link boost_asio.reference.basic_socket.message_do_not_route [*message_do_not_route]]]
    [Specify that the data should not be subject to routing. ]
  ]

  [
    [[link boost_asio.reference.basic_socket.message_out_of_band [*message_out_of_band]]]
    [Process out-of-band data. ]
  ]

  [
    [[link boost_asio.reference.basic_socket.message_peek [*message_peek]]]
    [Peek at incoming data without removing it from the input queue. ]
  ]

]

[heading Protected Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_socket.implementation [*implementation]]]
    [The underlying implementation of the I/O object. ]
  ]

  [
    [[link boost_asio.reference.basic_socket.service [*service]]]
    [The service associated with the I/O object. ]
  ]

]

The basic_socket class template provides functionality that is common to both stream-oriented and datagram-oriented sockets.


[heading Thread Safety]
  
[*Distinct] [*objects:]  Safe.

[*Shared] [*objects:]  Unsafe. 




[endsect]



[section:max_connections basic_raw_socket::max_connections]


['Inherited from socket_base.]

[indexterm2 max_connections..basic_raw_socket] The maximum length of the queue of pending incoming connections. 

  static const int max_connections = implementation_defined;



[endsect]



[section:message_do_not_route basic_raw_socket::message_do_not_route]


['Inherited from socket_base.]

[indexterm2 message_do_not_route..basic_raw_socket] Specify that the data should not be subject to routing. 

  static const int message_do_not_route = implementation_defined;



[endsect]



[section:message_flags basic_raw_socket::message_flags]


['Inherited from socket_base.]

[indexterm2 message_flags..basic_raw_socket] Bitmask type for flags that can be passed to send and receive operations. 

  typedef int message_flags;




[endsect]



[section:message_out_of_band basic_raw_socket::message_out_of_band]


['Inherited from socket_base.]

[indexterm2 message_out_of_band..basic_raw_socket] Process out-of-band data. 

  static const int message_out_of_band = implementation_defined;



[endsect]



[section:message_peek basic_raw_socket::message_peek]


['Inherited from socket_base.]

[indexterm2 message_peek..basic_raw_socket] Peek at incoming data without removing it from the input queue. 

  static const int message_peek = implementation_defined;



[endsect]



[section:native basic_raw_socket::native]


['Inherited from basic_socket.]

[indexterm2 native..basic_raw_socket] Get the native socket representation. 

  native_type native();


This function may be used to obtain the underlying representation of the socket. This is intended to allow access to native socket functionality that is not otherwise provided. 


[endsect]



[section:native_type basic_raw_socket::native_type]

[indexterm2 native_type..basic_raw_socket] The native representation of a socket. 

  typedef RawSocketService::native_type native_type;




[endsect]



[section:non_blocking_io basic_raw_socket::non_blocking_io]


['Inherited from socket_base.]

[indexterm2 non_blocking_io..basic_raw_socket] IO control command to set the blocking mode of the socket. 

  typedef implementation_defined non_blocking_io;



Implements the FIONBIO IO control command.


[heading Example]
  


   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::non_blocking_io command(true);
   socket.io_control(command);






[endsect]


[section:open basic_raw_socket::open]

[indexterm2 open..basic_raw_socket] Open the socket using the specified protocol. 

  void ``[link boost_asio.reference.basic_raw_socket.open.overload1 open]``(
      const protocol_type & protocol = protocol_type());

  boost::system::error_code ``[link boost_asio.reference.basic_raw_socket.open.overload2 open]``(
      const protocol_type & protocol,
      boost::system::error_code & ec);


[section:overload1 basic_raw_socket::open (1 of 2 overloads)]


['Inherited from basic_socket.]

Open the socket using the specified protocol. 

  void open(
      const protocol_type & protocol = protocol_type());


This function opens the socket so that it will use the specified protocol.


[heading Parameters]
    

[variablelist
  
[[protocol][An object specifying protocol parameters to be used.]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Example]
  


   boost::asio::ip::tcp::socket socket(io_service);
   socket.open(boost::asio::ip::tcp::v4());






[endsect]



[section:overload2 basic_raw_socket::open (2 of 2 overloads)]


['Inherited from basic_socket.]

Open the socket using the specified protocol. 

  boost::system::error_code open(
      const protocol_type & protocol,
      boost::system::error_code & ec);


This function opens the socket so that it will use the specified protocol.


[heading Parameters]
    

[variablelist
  
[[protocol][An object specifying which protocol is to be used.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Example]
  


   boost::asio::ip::tcp::socket socket(io_service);
   boost::system::error_code ec;
   socket.open(boost::asio::ip::tcp::v4(), ec);
   if (ec)
   {
     // An error occurred.
   }






[endsect]


[endsect]


[section:protocol_type basic_raw_socket::protocol_type]

[indexterm2 protocol_type..basic_raw_socket] The protocol type. 

  typedef Protocol protocol_type;




[endsect]


[section:receive basic_raw_socket::receive]

[indexterm2 receive..basic_raw_socket] Receive some data on a connected socket. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t ``[link boost_asio.reference.basic_raw_socket.receive.overload1 receive]``(
      const MutableBufferSequence & buffers);

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t ``[link boost_asio.reference.basic_raw_socket.receive.overload2 receive]``(
      const MutableBufferSequence & buffers,
      socket_base::message_flags flags);

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t ``[link boost_asio.reference.basic_raw_socket.receive.overload3 receive]``(
      const MutableBufferSequence & buffers,
      socket_base::message_flags flags,
      boost::system::error_code & ec);


[section:overload1 basic_raw_socket::receive (1 of 3 overloads)]

Receive some data on a connected socket. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t receive(
      const MutableBufferSequence & buffers);


This function is used to receive data on the raw socket. The function call will block until data has been received successfully or an error occurs.


[heading Parameters]
    

[variablelist
  
[[buffers][One or more buffers into which the data will be received.]]

]

[heading Return Value]
      
The number of bytes received.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Remarks]
      
The receive operation can only be used with a connected socket. Use the receive\_from function to receive data on an unconnected raw socket.

[heading Example]
  
To receive into a single data buffer use the 
[link boost_asio.reference.buffer buffer]  function as follows: 

   socket.receive(boost::asio::buffer(data, size)); 


See the 
[link boost_asio.reference.buffer buffer]  documentation for information on receiving into multiple buffers in one go, and how to use it with arrays, boost::array or std::vector. 



[endsect]



[section:overload2 basic_raw_socket::receive (2 of 3 overloads)]

Receive some data on a connected socket. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t receive(
      const MutableBufferSequence & buffers,
      socket_base::message_flags flags);


This function is used to receive data on the raw socket. The function call will block until data has been received successfully or an error occurs.


[heading Parameters]
    

[variablelist
  
[[buffers][One or more buffers into which the data will be received.]]

[[flags][Flags specifying how the receive call is to be made.]]

]

[heading Return Value]
      
The number of bytes received.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Remarks]
      
The receive operation can only be used with a connected socket. Use the receive\_from function to receive data on an unconnected raw socket. 



[endsect]



[section:overload3 basic_raw_socket::receive (3 of 3 overloads)]

Receive some data on a connected socket. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t receive(
      const MutableBufferSequence & buffers,
      socket_base::message_flags flags,
      boost::system::error_code & ec);


This function is used to receive data on the raw socket. The function call will block until data has been received successfully or an error occurs.


[heading Parameters]
    

[variablelist
  
[[buffers][One or more buffers into which the data will be received.]]

[[flags][Flags specifying how the receive call is to be made.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Return Value]
      
The number of bytes received.

[heading Remarks]
      
The receive operation can only be used with a connected socket. Use the receive\_from function to receive data on an unconnected raw socket. 



[endsect]


[endsect]


[section:receive_buffer_size basic_raw_socket::receive_buffer_size]


['Inherited from socket_base.]

[indexterm2 receive_buffer_size..basic_raw_socket] Socket option for the receive buffer size of a socket. 

  typedef implementation_defined receive_buffer_size;



Implements the SOL\_SOCKET/SO\_RCVBUF socket option.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::receive_buffer_size option(8192);
   socket.set_option(option);




Getting the current option value: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::receive_buffer_size option;
   socket.get_option(option);
   int size = option.value();






[endsect]


[section:receive_from basic_raw_socket::receive_from]

[indexterm2 receive_from..basic_raw_socket] Receive raw data with the endpoint of the sender. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t ``[link boost_asio.reference.basic_raw_socket.receive_from.overload1 receive_from]``(
      const MutableBufferSequence & buffers,
      endpoint_type & sender_endpoint);

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t ``[link boost_asio.reference.basic_raw_socket.receive_from.overload2 receive_from]``(
      const MutableBufferSequence & buffers,
      endpoint_type & sender_endpoint,
      socket_base::message_flags flags);

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t ``[link boost_asio.reference.basic_raw_socket.receive_from.overload3 receive_from]``(
      const MutableBufferSequence & buffers,
      endpoint_type & sender_endpoint,
      socket_base::message_flags flags,
      boost::system::error_code & ec);


[section:overload1 basic_raw_socket::receive_from (1 of 3 overloads)]

Receive raw data with the endpoint of the sender. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t receive_from(
      const MutableBufferSequence & buffers,
      endpoint_type & sender_endpoint);


This function is used to receive raw data. The function call will block until data has been received successfully or an error occurs.


[heading Parameters]
    

[variablelist
  
[[buffers][One or more buffers into which the data will be received.]]

[[sender_endpoint][An endpoint object that receives the endpoint of the remote sender of the data.]]

]

[heading Return Value]
      
The number of bytes received.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Example]
  
To receive into a single data buffer use the 
[link boost_asio.reference.buffer buffer]  function as follows: 

   boost::asio::ip::udp::endpoint sender_endpoint;
   socket.receive_from(
       boost::asio::buffer(data, size), sender_endpoint);


See the 
[link boost_asio.reference.buffer buffer]  documentation for information on receiving into multiple buffers in one go, and how to use it with arrays, boost::array or std::vector. 



[endsect]



[section:overload2 basic_raw_socket::receive_from (2 of 3 overloads)]

Receive raw data with the endpoint of the sender. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t receive_from(
      const MutableBufferSequence & buffers,
      endpoint_type & sender_endpoint,
      socket_base::message_flags flags);


This function is used to receive raw data. The function call will block until data has been received successfully or an error occurs.


[heading Parameters]
    

[variablelist
  
[[buffers][One or more buffers into which the data will be received.]]

[[sender_endpoint][An endpoint object that receives the endpoint of the remote sender of the data.]]

[[flags][Flags specifying how the receive call is to be made.]]

]

[heading Return Value]
      
The number of bytes received.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. ]]

]



[endsect]



[section:overload3 basic_raw_socket::receive_from (3 of 3 overloads)]

Receive raw data with the endpoint of the sender. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t receive_from(
      const MutableBufferSequence & buffers,
      endpoint_type & sender_endpoint,
      socket_base::message_flags flags,
      boost::system::error_code & ec);


This function is used to receive raw data. The function call will block until data has been received successfully or an error occurs.


[heading Parameters]
    

[variablelist
  
[[buffers][One or more buffers into which the data will be received.]]

[[sender_endpoint][An endpoint object that receives the endpoint of the remote sender of the data.]]

[[flags][Flags specifying how the receive call is to be made.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Return Value]
      
The number of bytes received. 



[endsect]


[endsect]


[section:receive_low_watermark basic_raw_socket::receive_low_watermark]


['Inherited from socket_base.]

[indexterm2 receive_low_watermark..basic_raw_socket] Socket option for the receive low watermark. 

  typedef implementation_defined receive_low_watermark;



Implements the SOL\_SOCKET/SO\_RCVLOWAT socket option.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::receive_low_watermark option(1024);
   socket.set_option(option);




Getting the current option value: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::receive_low_watermark option;
   socket.get_option(option);
   int size = option.value();






[endsect]


[section:remote_endpoint basic_raw_socket::remote_endpoint]

[indexterm2 remote_endpoint..basic_raw_socket] Get the remote endpoint of the socket. 

  endpoint_type ``[link boost_asio.reference.basic_raw_socket.remote_endpoint.overload1 remote_endpoint]``() const;

  endpoint_type ``[link boost_asio.reference.basic_raw_socket.remote_endpoint.overload2 remote_endpoint]``(
      boost::system::error_code & ec) const;


[section:overload1 basic_raw_socket::remote_endpoint (1 of 2 overloads)]


['Inherited from basic_socket.]

Get the remote endpoint of the socket. 

  endpoint_type remote_endpoint() const;


This function is used to obtain the remote endpoint of the socket.


[heading Return Value]
      
An object that represents the remote endpoint of the socket.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Example]
  


   boost::asio::ip::tcp::socket socket(io_service);
   ...
   boost::asio::ip::tcp::endpoint endpoint = socket.remote_endpoint();






[endsect]



[section:overload2 basic_raw_socket::remote_endpoint (2 of 2 overloads)]


['Inherited from basic_socket.]

Get the remote endpoint of the socket. 

  endpoint_type remote_endpoint(
      boost::system::error_code & ec) const;


This function is used to obtain the remote endpoint of the socket.


[heading Parameters]
    

[variablelist
  
[[ec][Set to indicate what error occurred, if any.]]

]

[heading Return Value]
      
An object that represents the remote endpoint of the socket. Returns a default-constructed endpoint object if an error occurred.

[heading Example]
  


   boost::asio::ip::tcp::socket socket(io_service);
   ...
   boost::system::error_code ec;
   boost::asio::ip::tcp::endpoint endpoint = socket.remote_endpoint(ec);
   if (ec)
   {
     // An error occurred.
   }






[endsect]


[endsect]


[section:reuse_address basic_raw_socket::reuse_address]


['Inherited from socket_base.]

[indexterm2 reuse_address..basic_raw_socket] Socket option to allow the socket to be bound to an address that is already in use. 

  typedef implementation_defined reuse_address;



Implements the SOL\_SOCKET/SO\_REUSEADDR socket option.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::tcp::acceptor acceptor(io_service); 
   ...
   boost::asio::socket_base::reuse_address option(true);
   acceptor.set_option(option);




Getting the current option value: 

   boost::asio::ip::tcp::acceptor acceptor(io_service); 
   ...
   boost::asio::socket_base::reuse_address option;
   acceptor.get_option(option);
   bool is_set = option.value();






[endsect]


[section:send basic_raw_socket::send]

[indexterm2 send..basic_raw_socket] Send some data on a connected socket. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t ``[link boost_asio.reference.basic_raw_socket.send.overload1 send]``(
      const ConstBufferSequence & buffers);

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t ``[link boost_asio.reference.basic_raw_socket.send.overload2 send]``(
      const ConstBufferSequence & buffers,
      socket_base::message_flags flags);

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t ``[link boost_asio.reference.basic_raw_socket.send.overload3 send]``(
      const ConstBufferSequence & buffers,
      socket_base::message_flags flags,
      boost::system::error_code & ec);


[section:overload1 basic_raw_socket::send (1 of 3 overloads)]

Send some data on a connected socket. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t send(
      const ConstBufferSequence & buffers);


This function is used to send data on the raw socket. The function call will block until the data has been sent successfully or an error occurs.


[heading Parameters]
    

[variablelist
  
[[buffers][One ore more data buffers to be sent on the socket.]]

]

[heading Return Value]
      
The number of bytes sent.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Remarks]
      
The send operation can only be used with a connected socket. Use the send\_to function to send data on an unconnected raw socket.

[heading Example]
  
To send a single data buffer use the 
[link boost_asio.reference.buffer buffer]  function as follows: 

   socket.send(boost::asio::buffer(data, size)); 


See the 
[link boost_asio.reference.buffer buffer]  documentation for information on sending multiple buffers in one go, and how to use it with arrays, boost::array or std::vector. 



[endsect]



[section:overload2 basic_raw_socket::send (2 of 3 overloads)]

Send some data on a connected socket. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t send(
      const ConstBufferSequence & buffers,
      socket_base::message_flags flags);


This function is used to send data on the raw socket. The function call will block until the data has been sent successfully or an error occurs.


[heading Parameters]
    

[variablelist
  
[[buffers][One ore more data buffers to be sent on the socket.]]

[[flags][Flags specifying how the send call is to be made.]]

]

[heading Return Value]
      
The number of bytes sent.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Remarks]
      
The send operation can only be used with a connected socket. Use the send\_to function to send data on an unconnected raw socket. 



[endsect]



[section:overload3 basic_raw_socket::send (3 of 3 overloads)]

Send some data on a connected socket. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t send(
      const ConstBufferSequence & buffers,
      socket_base::message_flags flags,
      boost::system::error_code & ec);


This function is used to send data on the raw socket. The function call will block until the data has been sent successfully or an error occurs.


[heading Parameters]
    

[variablelist
  
[[buffers][One or more data buffers to be sent on the socket.]]

[[flags][Flags specifying how the send call is to be made.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Return Value]
      
The number of bytes sent.

[heading Remarks]
      
The send operation can only be used with a connected socket. Use the send\_to function to send data on an unconnected raw socket. 



[endsect]


[endsect]


[section:send_buffer_size basic_raw_socket::send_buffer_size]


['Inherited from socket_base.]

[indexterm2 send_buffer_size..basic_raw_socket] Socket option for the send buffer size of a socket. 

  typedef implementation_defined send_buffer_size;



Implements the SOL\_SOCKET/SO\_SNDBUF socket option.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::send_buffer_size option(8192);
   socket.set_option(option);




Getting the current option value: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::send_buffer_size option;
   socket.get_option(option);
   int size = option.value();






[endsect]



[section:send_low_watermark basic_raw_socket::send_low_watermark]


['Inherited from socket_base.]

[indexterm2 send_low_watermark..basic_raw_socket] Socket option for the send low watermark. 

  typedef implementation_defined send_low_watermark;



Implements the SOL\_SOCKET/SO\_SNDLOWAT socket option.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::send_low_watermark option(1024);
   socket.set_option(option);




Getting the current option value: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::send_low_watermark option;
   socket.get_option(option);
   int size = option.value();






[endsect]


[section:send_to basic_raw_socket::send_to]

[indexterm2 send_to..basic_raw_socket] Send raw data to the specified endpoint. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t ``[link boost_asio.reference.basic_raw_socket.send_to.overload1 send_to]``(
      const ConstBufferSequence & buffers,
      const endpoint_type & destination);

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t ``[link boost_asio.reference.basic_raw_socket.send_to.overload2 send_to]``(
      const ConstBufferSequence & buffers,
      const endpoint_type & destination,
      socket_base::message_flags flags);

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t ``[link boost_asio.reference.basic_raw_socket.send_to.overload3 send_to]``(
      const ConstBufferSequence & buffers,
      const endpoint_type & destination,
      socket_base::message_flags flags,
      boost::system::error_code & ec);


[section:overload1 basic_raw_socket::send_to (1 of 3 overloads)]

Send raw data to the specified endpoint. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t send_to(
      const ConstBufferSequence & buffers,
      const endpoint_type & destination);


This function is used to send raw data to the specified remote endpoint. The function call will block until the data has been sent successfully or an error occurs.


[heading Parameters]
    

[variablelist
  
[[buffers][One or more data buffers to be sent to the remote endpoint.]]

[[destination][The remote endpoint to which the data will be sent.]]

]

[heading Return Value]
      
The number of bytes sent.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Example]
  
To send a single data buffer use the 
[link boost_asio.reference.buffer buffer]  function as follows: 

   boost::asio::ip::udp::endpoint destination(
       boost::asio::ip::address::from_string("1.2.3.4"), 12345);
   socket.send_to(boost::asio::buffer(data, size), destination);


See the 
[link boost_asio.reference.buffer buffer]  documentation for information on sending multiple buffers in one go, and how to use it with arrays, boost::array or std::vector. 



[endsect]



[section:overload2 basic_raw_socket::send_to (2 of 3 overloads)]

Send raw data to the specified endpoint. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t send_to(
      const ConstBufferSequence & buffers,
      const endpoint_type & destination,
      socket_base::message_flags flags);


This function is used to send raw data to the specified remote endpoint. The function call will block until the data has been sent successfully or an error occurs.


[heading Parameters]
    

[variablelist
  
[[buffers][One or more data buffers to be sent to the remote endpoint.]]

[[destination][The remote endpoint to which the data will be sent.]]

[[flags][Flags specifying how the send call is to be made.]]

]

[heading Return Value]
      
The number of bytes sent.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. ]]

]



[endsect]



[section:overload3 basic_raw_socket::send_to (3 of 3 overloads)]

Send raw data to the specified endpoint. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t send_to(
      const ConstBufferSequence & buffers,
      const endpoint_type & destination,
      socket_base::message_flags flags,
      boost::system::error_code & ec);


This function is used to send raw data to the specified remote endpoint. The function call will block until the data has been sent successfully or an error occurs.


[heading Parameters]
    

[variablelist
  
[[buffers][One or more data buffers to be sent to the remote endpoint.]]

[[destination][The remote endpoint to which the data will be sent.]]

[[flags][Flags specifying how the send call is to be made.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Return Value]
      
The number of bytes sent. 



[endsect]


[endsect]


[section:service basic_raw_socket::service]


['Inherited from basic_io_object.]

[indexterm2 service..basic_raw_socket] The service associated with the I/O object. 

  service_type & service;



[endsect]



[section:service_type basic_raw_socket::service_type]


['Inherited from basic_io_object.]

[indexterm2 service_type..basic_raw_socket] The type of the service that will be used to provide I/O operations. 

  typedef RawSocketService service_type;




[endsect]


[section:set_option basic_raw_socket::set_option]

[indexterm2 set_option..basic_raw_socket] Set an option on the socket. 

  void ``[link boost_asio.reference.basic_raw_socket.set_option.overload1 set_option]``(
      const SettableSocketOption & option);

  boost::system::error_code ``[link boost_asio.reference.basic_raw_socket.set_option.overload2 set_option]``(
      const SettableSocketOption & option,
      boost::system::error_code & ec);


[section:overload1 basic_raw_socket::set_option (1 of 2 overloads)]


['Inherited from basic_socket.]

Set an option on the socket. 

  void set_option(
      const SettableSocketOption & option);


This function is used to set an option on the socket.


[heading Parameters]
    

[variablelist
  
[[option][The new option value to be set on the socket.]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Example]
  
Setting the IPPROTO\_TCP/TCP\_NODELAY option: 

   boost::asio::ip::tcp::socket socket(io_service);
   ...
   boost::asio::ip::tcp::no_delay option(true);
   socket.set_option(option);






[endsect]



[section:overload2 basic_raw_socket::set_option (2 of 2 overloads)]


['Inherited from basic_socket.]

Set an option on the socket. 

  boost::system::error_code set_option(
      const SettableSocketOption & option,
      boost::system::error_code & ec);


This function is used to set an option on the socket.


[heading Parameters]
    

[variablelist
  
[[option][The new option value to be set on the socket.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Example]
  
Setting the IPPROTO\_TCP/TCP\_NODELAY option: 

   boost::asio::ip::tcp::socket socket(io_service);
   ...
   boost::asio::ip::tcp::no_delay option(true);
   boost::system::error_code ec;
   socket.set_option(option, ec);
   if (ec)
   {
     // An error occurred.
   }






[endsect]


[endsect]

[section:shutdown basic_raw_socket::shutdown]

[indexterm2 shutdown..basic_raw_socket] Disable sends or receives on the socket. 

  void ``[link boost_asio.reference.basic_raw_socket.shutdown.overload1 shutdown]``(
      shutdown_type what);

  boost::system::error_code ``[link boost_asio.reference.basic_raw_socket.shutdown.overload2 shutdown]``(
      shutdown_type what,
      boost::system::error_code & ec);


[section:overload1 basic_raw_socket::shutdown (1 of 2 overloads)]


['Inherited from basic_socket.]

Disable sends or receives on the socket. 

  void shutdown(
      shutdown_type what);


This function is used to disable send operations, receive operations, or both.


[heading Parameters]
    

[variablelist
  
[[what][Determines what types of operation will no longer be allowed.]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Example]
  
Shutting down the send side of the socket: 

   boost::asio::ip::tcp::socket socket(io_service);
   ...
   socket.shutdown(boost::asio::ip::tcp::socket::shutdown_send);






[endsect]



[section:overload2 basic_raw_socket::shutdown (2 of 2 overloads)]


['Inherited from basic_socket.]

Disable sends or receives on the socket. 

  boost::system::error_code shutdown(
      shutdown_type what,
      boost::system::error_code & ec);


This function is used to disable send operations, receive operations, or both.


[heading Parameters]
    

[variablelist
  
[[what][Determines what types of operation will no longer be allowed.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Example]
  
Shutting down the send side of the socket: 

   boost::asio::ip::tcp::socket socket(io_service);
   ...
   boost::system::error_code ec;
   socket.shutdown(boost::asio::ip::tcp::socket::shutdown_send, ec);
   if (ec)
   {
     // An error occurred.
   }






[endsect]


[endsect]


[section:shutdown_type basic_raw_socket::shutdown_type]


['Inherited from socket_base.]

[indexterm2 shutdown_type..basic_raw_socket] Different ways a socket may be shutdown. 

  enum shutdown_type

[heading Values]
[variablelist

  [
    [shutdown_receive]
    [Shutdown the receive side of the socket. ]
  ]

  [
    [shutdown_send]
    [Shutdown the send side of the socket. ]
  ]

  [
    [shutdown_both]
    [Shutdown both send and receive on the socket. ]
  ]

]



[endsect]



[endsect]

[section:basic_serial_port basic_serial_port]

Provides serial port functionality. 

  template<
      typename ``[link boost_asio.reference.SerialPortService SerialPortService]`` = serial_port_service>
  class basic_serial_port :
    public basic_io_object< SerialPortService >,
    public serial_port_base


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.basic_serial_port.implementation_type [*implementation_type]]]
    [The underlying implementation type of I/O object. ]
  
  ]

  [

    [[link boost_asio.reference.basic_serial_port.lowest_layer_type [*lowest_layer_type]]]
    [A basic_serial_port is always the lowest layer. ]
  
  ]

  [

    [[link boost_asio.reference.basic_serial_port.native_type [*native_type]]]
    [The native representation of a serial port. ]
  
  ]

  [

    [[link boost_asio.reference.basic_serial_port.service_type [*service_type]]]
    [The type of the service that will be used to provide I/O operations. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_serial_port.assign [*assign]]]
    [Assign an existing native serial port to the serial port. ]
  ]
  
  [
    [[link boost_asio.reference.basic_serial_port.async_read_some [*async_read_some]]]
    [Start an asynchronous read. ]
  ]
  
  [
    [[link boost_asio.reference.basic_serial_port.async_write_some [*async_write_some]]]
    [Start an asynchronous write. ]
  ]
  
  [
    [[link boost_asio.reference.basic_serial_port.basic_serial_port [*basic_serial_port]]]
    [Construct a basic_serial_port without opening it. 

     Construct and open a basic_serial_port. 

     Construct a basic_serial_port on an existing native serial port. ]
  ]
  
  [
    [[link boost_asio.reference.basic_serial_port.cancel [*cancel]]]
    [Cancel all asynchronous operations associated with the serial port. ]
  ]
  
  [
    [[link boost_asio.reference.basic_serial_port.close [*close]]]
    [Close the serial port. ]
  ]
  
  [
    [[link boost_asio.reference.basic_serial_port.get_io_service [*get_io_service]]]
    [Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.basic_serial_port.get_option [*get_option]]]
    [Get an option from the serial port. ]
  ]
  
  [
    [[link boost_asio.reference.basic_serial_port.io_service [*io_service]]]
    [(Deprecated: use get_io_service().) Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.basic_serial_port.is_open [*is_open]]]
    [Determine whether the serial port is open. ]
  ]
  
  [
    [[link boost_asio.reference.basic_serial_port.lowest_layer [*lowest_layer]]]
    [Get a reference to the lowest layer. 

     Get a const reference to the lowest layer. ]
  ]
  
  [
    [[link boost_asio.reference.basic_serial_port.native [*native]]]
    [Get the native serial port representation. ]
  ]
  
  [
    [[link boost_asio.reference.basic_serial_port.open [*open]]]
    [Open the serial port using the specified device name. ]
  ]
  
  [
    [[link boost_asio.reference.basic_serial_port.read_some [*read_some]]]
    [Read some data from the serial port. ]
  ]
  
  [
    [[link boost_asio.reference.basic_serial_port.send_break [*send_break]]]
    [Send a break sequence to the serial port. ]
  ]
  
  [
    [[link boost_asio.reference.basic_serial_port.set_option [*set_option]]]
    [Set an option on the serial port. ]
  ]
  
  [
    [[link boost_asio.reference.basic_serial_port.write_some [*write_some]]]
    [Write some data to the serial port. ]
  ]
  
]

[heading Protected Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_serial_port.implementation [*implementation]]]
    [The underlying implementation of the I/O object. ]
  ]

  [
    [[link boost_asio.reference.basic_serial_port.service [*service]]]
    [The service associated with the I/O object. ]
  ]

]

The basic_serial_port class template provides functionality that is common to all serial ports.


[heading Thread Safety]
  
[*Distinct] [*objects:]  Safe.

[*Shared] [*objects:]  Unsafe. 


[section:assign basic_serial_port::assign]

[indexterm2 assign..basic_serial_port] Assign an existing native serial port to the serial port. 

  void ``[link boost_asio.reference.basic_serial_port.assign.overload1 assign]``(
      const native_type & native_serial_port);

  boost::system::error_code ``[link boost_asio.reference.basic_serial_port.assign.overload2 assign]``(
      const native_type & native_serial_port,
      boost::system::error_code & ec);


[section:overload1 basic_serial_port::assign (1 of 2 overloads)]

Assign an existing native serial port to the serial port. 

  void assign(
      const native_type & native_serial_port);



[endsect]



[section:overload2 basic_serial_port::assign (2 of 2 overloads)]

Assign an existing native serial port to the serial port. 

  boost::system::error_code assign(
      const native_type & native_serial_port,
      boost::system::error_code & ec);



[endsect]


[endsect]


[section:async_read_some basic_serial_port::async_read_some]

[indexterm2 async_read_some..basic_serial_port] Start an asynchronous read. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
  void async_read_some(
      const MutableBufferSequence & buffers,
      ReadHandler handler);


This function is used to asynchronously read data from the serial port. The function call always returns immediately.


[heading Parameters]
    

[variablelist
  
[[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.]]

[[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: 
``
   void handler(
     const boost::system::error_code& error, // Result of operation.
     std::size_t bytes_transferred           // Number of bytes read.
   ); 
``
Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using boost::asio::io\_service::post().]]

]

[heading Remarks]
      
The read operation may not read all of the requested number of bytes. Consider using the 
[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.

[heading Example]
  
To read into a single data buffer use the 
[link boost_asio.reference.buffer buffer]  function as follows: 

   serial_port.async_read_some(boost::asio::buffer(data, size), handler);


See the 
[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. 



[endsect]



[section:async_write_some basic_serial_port::async_write_some]

[indexterm2 async_write_some..basic_serial_port] Start an asynchronous write. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
  void async_write_some(
      const ConstBufferSequence & buffers,
      WriteHandler handler);


This function is used to asynchronously write data to the serial port. The function call always returns immediately.


[heading Parameters]
    

[variablelist
  
[[buffers][One or more data buffers to be written to the serial port. 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.]]

[[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: 
``
   void handler(
     const boost::system::error_code& error, // Result of operation.
     std::size_t bytes_transferred           // Number of bytes written.
   ); 
``
Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using boost::asio::io\_service::post().]]

]

[heading Remarks]
      
The write operation may not transmit all of the data to the peer. Consider using the 
[link boost_asio.reference.async_write async_write]  function if you need to ensure that all data is written before the asynchronous operation completes.

[heading Example]
  
To write a single data buffer use the 
[link boost_asio.reference.buffer buffer]  function as follows: 

   serial_port.async_write_some(boost::asio::buffer(data, size), handler);


See the 
[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. 



[endsect]


[section:basic_serial_port basic_serial_port::basic_serial_port]

[indexterm2 basic_serial_port..basic_serial_port] Construct a basic_serial_port without opening it. 

  ``[link boost_asio.reference.basic_serial_port.basic_serial_port.overload1 basic_serial_port]``(
      boost::asio::io_service & io_service);

Construct and open a basic_serial_port. 

  ``[link boost_asio.reference.basic_serial_port.basic_serial_port.overload2 basic_serial_port]``(
      boost::asio::io_service & io_service,
      const char * device);

  ``[link boost_asio.reference.basic_serial_port.basic_serial_port.overload3 basic_serial_port]``(
      boost::asio::io_service & io_service,
      const std::string & device);

Construct a basic_serial_port on an existing native serial port. 

  ``[link boost_asio.reference.basic_serial_port.basic_serial_port.overload4 basic_serial_port]``(
      boost::asio::io_service & io_service,
      const native_type & native_serial_port);


[section:overload1 basic_serial_port::basic_serial_port (1 of 4 overloads)]

Construct a basic_serial_port without opening it. 

  basic_serial_port(
      boost::asio::io_service & io_service);


This constructor creates a serial port without opening it.


[heading Parameters]
    

[variablelist
  
[[io_service][The io\_service object that the serial port will use to dispatch handlers for any asynchronous operations performed on the port. ]]

]



[endsect]



[section:overload2 basic_serial_port::basic_serial_port (2 of 4 overloads)]

Construct and open a basic_serial_port. 

  basic_serial_port(
      boost::asio::io_service & io_service,
      const char * device);


This constructor creates and opens a serial port for the specified device name.


[heading Parameters]
    

[variablelist
  
[[io_service][The io\_service object that the serial port will use to dispatch handlers for any asynchronous operations performed on the port.]]

[[device][The platform-specific device name for this serial port. ]]

]



[endsect]



[section:overload3 basic_serial_port::basic_serial_port (3 of 4 overloads)]

Construct and open a basic_serial_port. 

  basic_serial_port(
      boost::asio::io_service & io_service,
      const std::string & device);


This constructor creates and opens a serial port for the specified device name.


[heading Parameters]
    

[variablelist
  
[[io_service][The io\_service object that the serial port will use to dispatch handlers for any asynchronous operations performed on the port.]]

[[device][The platform-specific device name for this serial port. ]]

]



[endsect]



[section:overload4 basic_serial_port::basic_serial_port (4 of 4 overloads)]

Construct a basic_serial_port on an existing native serial port. 

  basic_serial_port(
      boost::asio::io_service & io_service,
      const native_type & native_serial_port);


This constructor creates a serial port object to hold an existing native serial port.


[heading Parameters]
    

[variablelist
  
[[io_service][The io\_service object that the serial port will use to dispatch handlers for any asynchronous operations performed on the port.]]

[[native_serial_port][A native serial port.]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. ]]

]



[endsect]


[endsect]

[section:cancel basic_serial_port::cancel]

[indexterm2 cancel..basic_serial_port] Cancel all asynchronous operations associated with the serial port. 

  void ``[link boost_asio.reference.basic_serial_port.cancel.overload1 cancel]``();

  boost::system::error_code ``[link boost_asio.reference.basic_serial_port.cancel.overload2 cancel]``(
      boost::system::error_code & ec);


[section:overload1 basic_serial_port::cancel (1 of 2 overloads)]

Cancel all asynchronous operations associated with the serial port. 

  void cancel();


This 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.


[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. ]]

]



[endsect]



[section:overload2 basic_serial_port::cancel (2 of 2 overloads)]

Cancel all asynchronous operations associated with the serial port. 

  boost::system::error_code cancel(
      boost::system::error_code & ec);


This 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.


[heading Parameters]
    

[variablelist
  
[[ec][Set to indicate what error occurred, if any. ]]

]



[endsect]


[endsect]

[section:close basic_serial_port::close]

[indexterm2 close..basic_serial_port] Close the serial port. 

  void ``[link boost_asio.reference.basic_serial_port.close.overload1 close]``();

  boost::system::error_code ``[link boost_asio.reference.basic_serial_port.close.overload2 close]``(
      boost::system::error_code & ec);


[section:overload1 basic_serial_port::close (1 of 2 overloads)]

Close the serial port. 

  void close();


This function is used to close the serial port. Any asynchronous read or write operations will be cancelled immediately, and will complete with the boost::asio::error::operation\_aborted error.


[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. ]]

]



[endsect]



[section:overload2 basic_serial_port::close (2 of 2 overloads)]

Close the serial port. 

  boost::system::error_code close(
      boost::system::error_code & ec);


This function is used to close the serial port. Any asynchronous read or write operations will be cancelled immediately, and will complete with the boost::asio::error::operation\_aborted error.


[heading Parameters]
    

[variablelist
  
[[ec][Set to indicate what error occurred, if any. ]]

]



[endsect]


[endsect]


[section:get_io_service basic_serial_port::get_io_service]


['Inherited from basic_io_object.]

[indexterm2 get_io_service..basic_serial_port] Get the io_service associated with the object. 

  boost::asio::io_service & get_io_service();


This function may be used to obtain the io_service object that the I/O object uses to dispatch handlers for asynchronous operations.


[heading Return Value]
      
A reference to the io_service object that the I/O object will use to dispatch handlers. Ownership is not transferred to the caller. 



[endsect]


[section:get_option basic_serial_port::get_option]

[indexterm2 get_option..basic_serial_port] Get an option from the serial port. 

  template<
      typename ``[link boost_asio.reference.GettableSerialPortOption GettableSerialPortOption]``>
  void ``[link boost_asio.reference.basic_serial_port.get_option.overload1 get_option]``(
      GettableSerialPortOption & option);

  template<
      typename ``[link boost_asio.reference.GettableSerialPortOption GettableSerialPortOption]``>
  boost::system::error_code ``[link boost_asio.reference.basic_serial_port.get_option.overload2 get_option]``(
      GettableSerialPortOption & option,
      boost::system::error_code & ec);


[section:overload1 basic_serial_port::get_option (1 of 2 overloads)]

Get an option from the serial port. 

  template<
      typename ``[link boost_asio.reference.GettableSerialPortOption GettableSerialPortOption]``>
  void get_option(
      GettableSerialPortOption & option);


This function is used to get the current value of an option on the serial port.


[heading Parameters]
    

[variablelist
  
[[option][The option value to be obtained from the serial port.]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]



[endsect]



[section:overload2 basic_serial_port::get_option (2 of 2 overloads)]

Get an option from the serial port. 

  template<
      typename ``[link boost_asio.reference.GettableSerialPortOption GettableSerialPortOption]``>
  boost::system::error_code get_option(
      GettableSerialPortOption & option,
      boost::system::error_code & ec);


This function is used to get the current value of an option on the serial port.


[heading Parameters]
    

[variablelist
  
[[option][The option value to be obtained from the serial port.]]

[[ec][Set to indicate what error occured, if any.]]

]



[endsect]


[endsect]


[section:implementation basic_serial_port::implementation]


['Inherited from basic_io_object.]

[indexterm2 implementation..basic_serial_port] The underlying implementation of the I/O object. 

  implementation_type implementation;



[endsect]



[section:implementation_type basic_serial_port::implementation_type]


['Inherited from basic_io_object.]

[indexterm2 implementation_type..basic_serial_port] The underlying implementation type of I/O object. 

  typedef service_type::implementation_type implementation_type;




[endsect]



[section:io_service basic_serial_port::io_service]


['Inherited from basic_io_object.]

[indexterm2 io_service..basic_serial_port] (Deprecated: use get_io_service().) Get the io_service associated with the object. 

  boost::asio::io_service & io_service();


This function may be used to obtain the io_service object that the I/O object uses to dispatch handlers for asynchronous operations.


[heading Return Value]
      
A reference to the io_service object that the I/O object will use to dispatch handlers. Ownership is not transferred to the caller. 



[endsect]



[section:is_open basic_serial_port::is_open]

[indexterm2 is_open..basic_serial_port] Determine whether the serial port is open. 

  bool is_open() const;



[endsect]


[section:lowest_layer basic_serial_port::lowest_layer]

[indexterm2 lowest_layer..basic_serial_port] Get a reference to the lowest layer. 

  lowest_layer_type & ``[link boost_asio.reference.basic_serial_port.lowest_layer.overload1 lowest_layer]``();

Get a const reference to the lowest layer. 

  const lowest_layer_type & ``[link boost_asio.reference.basic_serial_port.lowest_layer.overload2 lowest_layer]``() const;


[section:overload1 basic_serial_port::lowest_layer (1 of 2 overloads)]

Get a reference to the lowest layer. 

  lowest_layer_type & lowest_layer();


This function returns a reference to the lowest layer in a stack of layers. Since a basic_serial_port cannot contain any further layers, it simply returns a reference to itself.


[heading Return Value]
      
A reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller. 



[endsect]



[section:overload2 basic_serial_port::lowest_layer (2 of 2 overloads)]

Get a const reference to the lowest layer. 

  const lowest_layer_type & lowest_layer() const;


This function returns a const reference to the lowest layer in a stack of layers. Since a basic_serial_port cannot contain any further layers, it simply returns a reference to itself.


[heading Return Value]
      
A const reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller. 



[endsect]


[endsect]


[section:lowest_layer_type basic_serial_port::lowest_layer_type]

[indexterm2 lowest_layer_type..basic_serial_port] A basic_serial_port is always the lowest layer. 

  typedef basic_serial_port< SerialPortService > lowest_layer_type;


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.basic_serial_port.implementation_type [*implementation_type]]]
    [The underlying implementation type of I/O object. ]
  
  ]

  [

    [[link boost_asio.reference.basic_serial_port.lowest_layer_type [*lowest_layer_type]]]
    [A basic_serial_port is always the lowest layer. ]
  
  ]

  [

    [[link boost_asio.reference.basic_serial_port.native_type [*native_type]]]
    [The native representation of a serial port. ]
  
  ]

  [

    [[link boost_asio.reference.basic_serial_port.service_type [*service_type]]]
    [The type of the service that will be used to provide I/O operations. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_serial_port.assign [*assign]]]
    [Assign an existing native serial port to the serial port. ]
  ]
  
  [
    [[link boost_asio.reference.basic_serial_port.async_read_some [*async_read_some]]]
    [Start an asynchronous read. ]
  ]
  
  [
    [[link boost_asio.reference.basic_serial_port.async_write_some [*async_write_some]]]
    [Start an asynchronous write. ]
  ]
  
  [
    [[link boost_asio.reference.basic_serial_port.basic_serial_port [*basic_serial_port]]]
    [Construct a basic_serial_port without opening it. 

     Construct and open a basic_serial_port. 

     Construct a basic_serial_port on an existing native serial port. ]
  ]
  
  [
    [[link boost_asio.reference.basic_serial_port.cancel [*cancel]]]
    [Cancel all asynchronous operations associated with the serial port. ]
  ]
  
  [
    [[link boost_asio.reference.basic_serial_port.close [*close]]]
    [Close the serial port. ]
  ]
  
  [
    [[link boost_asio.reference.basic_serial_port.get_io_service [*get_io_service]]]
    [Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.basic_serial_port.get_option [*get_option]]]
    [Get an option from the serial port. ]
  ]
  
  [
    [[link boost_asio.reference.basic_serial_port.io_service [*io_service]]]
    [(Deprecated: use get_io_service().) Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.basic_serial_port.is_open [*is_open]]]
    [Determine whether the serial port is open. ]
  ]
  
  [
    [[link boost_asio.reference.basic_serial_port.lowest_layer [*lowest_layer]]]
    [Get a reference to the lowest layer. 

     Get a const reference to the lowest layer. ]
  ]
  
  [
    [[link boost_asio.reference.basic_serial_port.native [*native]]]
    [Get the native serial port representation. ]
  ]
  
  [
    [[link boost_asio.reference.basic_serial_port.open [*open]]]
    [Open the serial port using the specified device name. ]
  ]
  
  [
    [[link boost_asio.reference.basic_serial_port.read_some [*read_some]]]
    [Read some data from the serial port. ]
  ]
  
  [
    [[link boost_asio.reference.basic_serial_port.send_break [*send_break]]]
    [Send a break sequence to the serial port. ]
  ]
  
  [
    [[link boost_asio.reference.basic_serial_port.set_option [*set_option]]]
    [Set an option on the serial port. ]
  ]
  
  [
    [[link boost_asio.reference.basic_serial_port.write_some [*write_some]]]
    [Write some data to the serial port. ]
  ]
  
]

[heading Protected Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_serial_port.implementation [*implementation]]]
    [The underlying implementation of the I/O object. ]
  ]

  [
    [[link boost_asio.reference.basic_serial_port.service [*service]]]
    [The service associated with the I/O object. ]
  ]

]

The basic_serial_port class template provides functionality that is common to all serial ports.


[heading Thread Safety]
  
[*Distinct] [*objects:]  Safe.

[*Shared] [*objects:]  Unsafe. 




[endsect]



[section:native basic_serial_port::native]

[indexterm2 native..basic_serial_port] Get the native serial port representation. 

  native_type native();


This function may be used to obtain the underlying representation of the serial port. This is intended to allow access to native serial port functionality that is not otherwise provided. 


[endsect]



[section:native_type basic_serial_port::native_type]

[indexterm2 native_type..basic_serial_port] The native representation of a serial port. 

  typedef SerialPortService::native_type native_type;




[endsect]


[section:open basic_serial_port::open]

[indexterm2 open..basic_serial_port] Open the serial port using the specified device name. 

  void ``[link boost_asio.reference.basic_serial_port.open.overload1 open]``(
      const std::string & device);

  boost::system::error_code ``[link boost_asio.reference.basic_serial_port.open.overload2 open]``(
      const std::string & device,
      boost::system::error_code & ec);


[section:overload1 basic_serial_port::open (1 of 2 overloads)]

Open the serial port using the specified device name. 

  void open(
      const std::string & device);


This function opens the serial port for the specified device name.


[heading Parameters]
    

[variablelist
  
[[device][The platform-specific device name.]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. ]]

]



[endsect]



[section:overload2 basic_serial_port::open (2 of 2 overloads)]

Open the serial port using the specified device name. 

  boost::system::error_code open(
      const std::string & device,
      boost::system::error_code & ec);


This function opens the serial port using the given platform-specific device name.


[heading Parameters]
    

[variablelist
  
[[device][The platform-specific device name.]]

[[ec][Set the indicate what error occurred, if any. ]]

]



[endsect]


[endsect]

[section:read_some basic_serial_port::read_some]

[indexterm2 read_some..basic_serial_port] Read some data from the serial port. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t ``[link boost_asio.reference.basic_serial_port.read_some.overload1 read_some]``(
      const MutableBufferSequence & buffers);

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t ``[link boost_asio.reference.basic_serial_port.read_some.overload2 read_some]``(
      const MutableBufferSequence & buffers,
      boost::system::error_code & ec);


[section:overload1 basic_serial_port::read_some (1 of 2 overloads)]

Read some data from the serial port. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t read_some(
      const MutableBufferSequence & buffers);


This function is used to read data from the serial port. The function call will block until one or more bytes of data has been read successfully, or until an error occurs.


[heading Parameters]
    

[variablelist
  
[[buffers][One or more buffers into which the data will be read.]]

]

[heading Return Value]
      
The number of bytes read.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. An error code of boost::asio::error::eof indicates that the connection was closed by the peer.]]

]

[heading Remarks]
      
The read\_some operation may not read all of the requested number of bytes. Consider using the 
[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.

[heading Example]
  
To read into a single data buffer use the 
[link boost_asio.reference.buffer buffer]  function as follows: 

   serial_port.read_some(boost::asio::buffer(data, size));


See the 
[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. 



[endsect]



[section:overload2 basic_serial_port::read_some (2 of 2 overloads)]

Read some data from the serial port. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t read_some(
      const MutableBufferSequence & buffers,
      boost::system::error_code & ec);


This function is used to read data from the serial port. The function call will block until one or more bytes of data has been read successfully, or until an error occurs.


[heading Parameters]
    

[variablelist
  
[[buffers][One or more buffers into which the data will be read.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Return Value]
      
The number of bytes read. Returns 0 if an error occurred.

[heading Remarks]
      
The read\_some operation may not read all of the requested number of bytes. Consider using the 
[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. 



[endsect]


[endsect]

[section:send_break basic_serial_port::send_break]

[indexterm2 send_break..basic_serial_port] Send a break sequence to the serial port. 

  void ``[link boost_asio.reference.basic_serial_port.send_break.overload1 send_break]``();

  boost::system::error_code ``[link boost_asio.reference.basic_serial_port.send_break.overload2 send_break]``(
      boost::system::error_code & ec);


[section:overload1 basic_serial_port::send_break (1 of 2 overloads)]

Send a break sequence to the serial port. 

  void send_break();


This function causes a break sequence of platform-specific duration to be sent out the serial port.


[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. ]]

]



[endsect]



[section:overload2 basic_serial_port::send_break (2 of 2 overloads)]

Send a break sequence to the serial port. 

  boost::system::error_code send_break(
      boost::system::error_code & ec);


This function causes a break sequence of platform-specific duration to be sent out the serial port.


[heading Parameters]
    

[variablelist
  
[[ec][Set to indicate what error occurred, if any. ]]

]



[endsect]


[endsect]


[section:service basic_serial_port::service]


['Inherited from basic_io_object.]

[indexterm2 service..basic_serial_port] The service associated with the I/O object. 

  service_type & service;



[endsect]



[section:service_type basic_serial_port::service_type]


['Inherited from basic_io_object.]

[indexterm2 service_type..basic_serial_port] The type of the service that will be used to provide I/O operations. 

  typedef SerialPortService service_type;




[endsect]


[section:set_option basic_serial_port::set_option]

[indexterm2 set_option..basic_serial_port] Set an option on the serial port. 

  template<
      typename ``[link boost_asio.reference.SettableSerialPortOption SettableSerialPortOption]``>
  void ``[link boost_asio.reference.basic_serial_port.set_option.overload1 set_option]``(
      const SettableSerialPortOption & option);

  template<
      typename ``[link boost_asio.reference.SettableSerialPortOption SettableSerialPortOption]``>
  boost::system::error_code ``[link boost_asio.reference.basic_serial_port.set_option.overload2 set_option]``(
      const SettableSerialPortOption & option,
      boost::system::error_code & ec);


[section:overload1 basic_serial_port::set_option (1 of 2 overloads)]

Set an option on the serial port. 

  template<
      typename ``[link boost_asio.reference.SettableSerialPortOption SettableSerialPortOption]``>
  void set_option(
      const SettableSerialPortOption & option);


This function is used to set an option on the serial port.


[heading Parameters]
    

[variablelist
  
[[option][The option value to be set on the serial port.]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]



[endsect]



[section:overload2 basic_serial_port::set_option (2 of 2 overloads)]

Set an option on the serial port. 

  template<
      typename ``[link boost_asio.reference.SettableSerialPortOption SettableSerialPortOption]``>
  boost::system::error_code set_option(
      const SettableSerialPortOption & option,
      boost::system::error_code & ec);


This function is used to set an option on the serial port.


[heading Parameters]
    

[variablelist
  
[[option][The option value to be set on the serial port.]]

[[ec][Set to indicate what error occurred, if any.]]

]



[endsect]


[endsect]

[section:write_some basic_serial_port::write_some]

[indexterm2 write_some..basic_serial_port] Write some data to the serial port. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t ``[link boost_asio.reference.basic_serial_port.write_some.overload1 write_some]``(
      const ConstBufferSequence & buffers);

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t ``[link boost_asio.reference.basic_serial_port.write_some.overload2 write_some]``(
      const ConstBufferSequence & buffers,
      boost::system::error_code & ec);


[section:overload1 basic_serial_port::write_some (1 of 2 overloads)]

Write some data to the serial port. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t write_some(
      const ConstBufferSequence & buffers);


This function is used to write data to the serial port. The function call will block until one or more bytes of the data has been written successfully, or until an error occurs.


[heading Parameters]
    

[variablelist
  
[[buffers][One or more data buffers to be written to the serial port.]]

]

[heading Return Value]
      
The number of bytes written.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. An error code of boost::asio::error::eof indicates that the connection was closed by the peer.]]

]

[heading Remarks]
      
The write\_some operation may not transmit all of the data to the peer. Consider using the 
[link boost_asio.reference.write write]  function if you need to ensure that all data is written before the blocking operation completes.

[heading Example]
  
To write a single data buffer use the 
[link boost_asio.reference.buffer buffer]  function as follows: 

   serial_port.write_some(boost::asio::buffer(data, size));


See the 
[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. 



[endsect]



[section:overload2 basic_serial_port::write_some (2 of 2 overloads)]

Write some data to the serial port. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t write_some(
      const ConstBufferSequence & buffers,
      boost::system::error_code & ec);


This function is used to write data to the serial port. The function call will block until one or more bytes of the data has been written successfully, or until an error occurs.


[heading Parameters]
    

[variablelist
  
[[buffers][One or more data buffers to be written to the serial port.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Return Value]
      
The number of bytes written. Returns 0 if an error occurred.

[heading Remarks]
      
The write\_some operation may not transmit all of the data to the peer. Consider using the 
[link boost_asio.reference.write write]  function if you need to ensure that all data is written before the blocking operation completes. 



[endsect]


[endsect]


[endsect]

[section:basic_socket basic_socket]

Provides socket functionality. 

  template<
      typename ``[link boost_asio.reference.Protocol Protocol]``,
      typename ``[link boost_asio.reference.SocketService SocketService]``>
  class basic_socket :
    public basic_io_object< SocketService >,
    public socket_base


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.basic_socket.broadcast [*broadcast]]]
    [Socket option to permit sending of broadcast messages. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.bytes_readable [*bytes_readable]]]
    [IO control command to get the amount of data that can be read without blocking. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.debug [*debug]]]
    [Socket option to enable socket-level debugging. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.do_not_route [*do_not_route]]]
    [Socket option to prevent routing, use local interfaces only. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.enable_connection_aborted [*enable_connection_aborted]]]
    [Socket option to report aborted connections on accept. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.endpoint_type [*endpoint_type]]]
    [The endpoint type. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.implementation_type [*implementation_type]]]
    [The underlying implementation type of I/O object. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.keep_alive [*keep_alive]]]
    [Socket option to send keep-alives. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.linger [*linger]]]
    [Socket option to specify whether the socket lingers on close if unsent data is present. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.lowest_layer_type [*lowest_layer_type]]]
    [A basic_socket is always the lowest layer. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.message_flags [*message_flags]]]
    [Bitmask type for flags that can be passed to send and receive operations. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.native_type [*native_type]]]
    [The native representation of a socket. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.non_blocking_io [*non_blocking_io]]]
    [IO control command to set the blocking mode of the socket. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.protocol_type [*protocol_type]]]
    [The protocol type. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.receive_buffer_size [*receive_buffer_size]]]
    [Socket option for the receive buffer size of a socket. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.receive_low_watermark [*receive_low_watermark]]]
    [Socket option for the receive low watermark. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.reuse_address [*reuse_address]]]
    [Socket option to allow the socket to be bound to an address that is already in use. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.send_buffer_size [*send_buffer_size]]]
    [Socket option for the send buffer size of a socket. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.send_low_watermark [*send_low_watermark]]]
    [Socket option for the send low watermark. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.service_type [*service_type]]]
    [The type of the service that will be used to provide I/O operations. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.shutdown_type [*shutdown_type]]]
    [Different ways a socket may be shutdown. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_socket.assign [*assign]]]
    [Assign an existing native socket to the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.async_connect [*async_connect]]]
    [Start an asynchronous connect. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.at_mark [*at_mark]]]
    [Determine whether the socket is at the out-of-band data mark. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.available [*available]]]
    [Determine the number of bytes available for reading. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.basic_socket [*basic_socket]]]
    [Construct a basic_socket without opening it. 

     Construct and open a basic_socket. 

     Construct a basic_socket, opening it and binding it to the given local endpoint. 

     Construct a basic_socket on an existing native socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.bind [*bind]]]
    [Bind the socket to the given local endpoint. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.cancel [*cancel]]]
    [Cancel all asynchronous operations associated with the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.close [*close]]]
    [Close the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.connect [*connect]]]
    [Connect the socket to the specified endpoint. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.get_io_service [*get_io_service]]]
    [Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.get_option [*get_option]]]
    [Get an option from the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.io_control [*io_control]]]
    [Perform an IO control command on the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.io_service [*io_service]]]
    [(Deprecated: use get_io_service().) Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.is_open [*is_open]]]
    [Determine whether the socket is open. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.local_endpoint [*local_endpoint]]]
    [Get the local endpoint of the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.lowest_layer [*lowest_layer]]]
    [Get a reference to the lowest layer. 

     Get a const reference to the lowest layer. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.native [*native]]]
    [Get the native socket representation. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.open [*open]]]
    [Open the socket using the specified protocol. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.remote_endpoint [*remote_endpoint]]]
    [Get the remote endpoint of the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.set_option [*set_option]]]
    [Set an option on the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.shutdown [*shutdown]]]
    [Disable sends or receives on the socket. ]
  ]
  
]

[heading Protected Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_socket._basic_socket [*~basic_socket]]]
    [Protected destructor to prevent deletion through this type. ]
  ]
  
]

[heading Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_socket.max_connections [*max_connections]]]
    [The maximum length of the queue of pending incoming connections. ]
  ]

  [
    [[link boost_asio.reference.basic_socket.message_do_not_route [*message_do_not_route]]]
    [Specify that the data should not be subject to routing. ]
  ]

  [
    [[link boost_asio.reference.basic_socket.message_out_of_band [*message_out_of_band]]]
    [Process out-of-band data. ]
  ]

  [
    [[link boost_asio.reference.basic_socket.message_peek [*message_peek]]]
    [Peek at incoming data without removing it from the input queue. ]
  ]

]

[heading Protected Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_socket.implementation [*implementation]]]
    [The underlying implementation of the I/O object. ]
  ]

  [
    [[link boost_asio.reference.basic_socket.service [*service]]]
    [The service associated with the I/O object. ]
  ]

]

The basic_socket class template provides functionality that is common to both stream-oriented and datagram-oriented sockets.


[heading Thread Safety]
  
[*Distinct] [*objects:]  Safe.

[*Shared] [*objects:]  Unsafe. 


[section:assign basic_socket::assign]

[indexterm2 assign..basic_socket] Assign an existing native socket to the socket. 

  void ``[link boost_asio.reference.basic_socket.assign.overload1 assign]``(
      const protocol_type & protocol,
      const native_type & native_socket);

  boost::system::error_code ``[link boost_asio.reference.basic_socket.assign.overload2 assign]``(
      const protocol_type & protocol,
      const native_type & native_socket,
      boost::system::error_code & ec);


[section:overload1 basic_socket::assign (1 of 2 overloads)]

Assign an existing native socket to the socket. 

  void assign(
      const protocol_type & protocol,
      const native_type & native_socket);



[endsect]



[section:overload2 basic_socket::assign (2 of 2 overloads)]

Assign an existing native socket to the socket. 

  boost::system::error_code assign(
      const protocol_type & protocol,
      const native_type & native_socket,
      boost::system::error_code & ec);



[endsect]


[endsect]


[section:async_connect basic_socket::async_connect]

[indexterm2 async_connect..basic_socket] Start an asynchronous connect. 

  template<
      typename ``[link boost_asio.reference.ConnectHandler ConnectHandler]``>
  void async_connect(
      const endpoint_type & peer_endpoint,
      ConnectHandler handler);


This function is used to asynchronously connect a socket to the specified remote endpoint. The function call always returns immediately.

The socket is automatically opened if it is not already open. If the connect fails, and the socket was automatically opened, the socket is not returned to the closed state.


[heading Parameters]
    

[variablelist
  
[[peer_endpoint][The remote endpoint to which the socket will be connected. Copies will be made of the endpoint object as required.]]

[[handler][The handler to be called when the connection operation completes. Copies will be made of the handler as required. The function signature of the handler must be: 
``
   void handler(
     const boost::system::error_code& error // Result of operation
   ); 
``
Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using boost::asio::io\_service::post().]]

]

[heading Example]
  


   void connect_handler(const boost::system::error_code& error)
   {
     if (!error)
     {
       // Connect succeeded.
     }
   }

   ...

   boost::asio::ip::tcp::socket socket(io_service);
   boost::asio::ip::tcp::endpoint endpoint(
       boost::asio::ip::address::from_string("1.2.3.4"), 12345);
   socket.async_connect(endpoint, connect_handler);






[endsect]


[section:at_mark basic_socket::at_mark]

[indexterm2 at_mark..basic_socket] Determine whether the socket is at the out-of-band data mark. 

  bool ``[link boost_asio.reference.basic_socket.at_mark.overload1 at_mark]``() const;

  bool ``[link boost_asio.reference.basic_socket.at_mark.overload2 at_mark]``(
      boost::system::error_code & ec) const;


[section:overload1 basic_socket::at_mark (1 of 2 overloads)]

Determine whether the socket is at the out-of-band data mark. 

  bool at_mark() const;


This function is used to check whether the socket input is currently positioned at the out-of-band data mark.


[heading Return Value]
      
A bool indicating whether the socket is at the out-of-band data mark.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. ]]

]



[endsect]



[section:overload2 basic_socket::at_mark (2 of 2 overloads)]

Determine whether the socket is at the out-of-band data mark. 

  bool at_mark(
      boost::system::error_code & ec) const;


This function is used to check whether the socket input is currently positioned at the out-of-band data mark.


[heading Parameters]
    

[variablelist
  
[[ec][Set to indicate what error occurred, if any.]]

]

[heading Return Value]
      
A bool indicating whether the socket is at the out-of-band data mark. 



[endsect]


[endsect]

[section:available basic_socket::available]

[indexterm2 available..basic_socket] Determine the number of bytes available for reading. 

  std::size_t ``[link boost_asio.reference.basic_socket.available.overload1 available]``() const;

  std::size_t ``[link boost_asio.reference.basic_socket.available.overload2 available]``(
      boost::system::error_code & ec) const;


[section:overload1 basic_socket::available (1 of 2 overloads)]

Determine the number of bytes available for reading. 

  std::size_t available() const;


This function is used to determine the number of bytes that may be read without blocking.


[heading Return Value]
      
The number of bytes that may be read without blocking, or 0 if an error occurs.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. ]]

]



[endsect]



[section:overload2 basic_socket::available (2 of 2 overloads)]

Determine the number of bytes available for reading. 

  std::size_t available(
      boost::system::error_code & ec) const;


This function is used to determine the number of bytes that may be read without blocking.


[heading Parameters]
    

[variablelist
  
[[ec][Set to indicate what error occurred, if any.]]

]

[heading Return Value]
      
The number of bytes that may be read without blocking, or 0 if an error occurs. 



[endsect]


[endsect]

[section:basic_socket basic_socket::basic_socket]

[indexterm2 basic_socket..basic_socket] Construct a basic_socket without opening it. 

  ``[link boost_asio.reference.basic_socket.basic_socket.overload1 basic_socket]``(
      boost::asio::io_service & io_service);

Construct and open a basic_socket. 

  ``[link boost_asio.reference.basic_socket.basic_socket.overload2 basic_socket]``(
      boost::asio::io_service & io_service,
      const protocol_type & protocol);

Construct a basic_socket, opening it and binding it to the given local endpoint. 

  ``[link boost_asio.reference.basic_socket.basic_socket.overload3 basic_socket]``(
      boost::asio::io_service & io_service,
      const endpoint_type & endpoint);

Construct a basic_socket on an existing native socket. 

  ``[link boost_asio.reference.basic_socket.basic_socket.overload4 basic_socket]``(
      boost::asio::io_service & io_service,
      const protocol_type & protocol,
      const native_type & native_socket);


[section:overload1 basic_socket::basic_socket (1 of 4 overloads)]

Construct a basic_socket without opening it. 

  basic_socket(
      boost::asio::io_service & io_service);


This constructor creates a socket without opening it.


[heading Parameters]
    

[variablelist
  
[[io_service][The io\_service object that the socket will use to dispatch handlers for any asynchronous operations performed on the socket. ]]

]



[endsect]



[section:overload2 basic_socket::basic_socket (2 of 4 overloads)]

Construct and open a basic_socket. 

  basic_socket(
      boost::asio::io_service & io_service,
      const protocol_type & protocol);


This constructor creates and opens a socket.


[heading Parameters]
    

[variablelist
  
[[io_service][The io\_service object that the socket will use to dispatch handlers for any asynchronous operations performed on the socket.]]

[[protocol][An object specifying protocol parameters to be used.]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. ]]

]



[endsect]



[section:overload3 basic_socket::basic_socket (3 of 4 overloads)]

Construct a basic_socket, opening it and binding it to the given local endpoint. 

  basic_socket(
      boost::asio::io_service & io_service,
      const endpoint_type & endpoint);


This constructor creates a socket and automatically opens it bound to the specified endpoint on the local machine. The protocol used is the protocol associated with the given endpoint.


[heading Parameters]
    

[variablelist
  
[[io_service][The io\_service object that the socket will use to dispatch handlers for any asynchronous operations performed on the socket.]]

[[endpoint][An endpoint on the local machine to which the socket will be bound.]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. ]]

]



[endsect]



[section:overload4 basic_socket::basic_socket (4 of 4 overloads)]

Construct a basic_socket on an existing native socket. 

  basic_socket(
      boost::asio::io_service & io_service,
      const protocol_type & protocol,
      const native_type & native_socket);


This constructor creates a socket object to hold an existing native socket.


[heading Parameters]
    

[variablelist
  
[[io_service][The io\_service object that the socket will use to dispatch handlers for any asynchronous operations performed on the socket.]]

[[protocol][An object specifying protocol parameters to be used.]]

[[native_socket][A native socket.]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. ]]

]



[endsect]


[endsect]

[section:bind basic_socket::bind]

[indexterm2 bind..basic_socket] Bind the socket to the given local endpoint. 

  void ``[link boost_asio.reference.basic_socket.bind.overload1 bind]``(
      const endpoint_type & endpoint);

  boost::system::error_code ``[link boost_asio.reference.basic_socket.bind.overload2 bind]``(
      const endpoint_type & endpoint,
      boost::system::error_code & ec);


[section:overload1 basic_socket::bind (1 of 2 overloads)]

Bind the socket to the given local endpoint. 

  void bind(
      const endpoint_type & endpoint);


This function binds the socket to the specified endpoint on the local machine.


[heading Parameters]
    

[variablelist
  
[[endpoint][An endpoint on the local machine to which the socket will be bound.]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Example]
  


   boost::asio::ip::tcp::socket socket(io_service);
   socket.open(boost::asio::ip::tcp::v4());
   socket.bind(boost::asio::ip::tcp::endpoint(
         boost::asio::ip::tcp::v4(), 12345));






[endsect]



[section:overload2 basic_socket::bind (2 of 2 overloads)]

Bind the socket to the given local endpoint. 

  boost::system::error_code bind(
      const endpoint_type & endpoint,
      boost::system::error_code & ec);


This function binds the socket to the specified endpoint on the local machine.


[heading Parameters]
    

[variablelist
  
[[endpoint][An endpoint on the local machine to which the socket will be bound.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Example]
  


   boost::asio::ip::tcp::socket socket(io_service);
   socket.open(boost::asio::ip::tcp::v4());
   boost::system::error_code ec;
   socket.bind(boost::asio::ip::tcp::endpoint(
         boost::asio::ip::tcp::v4(), 12345), ec);
   if (ec)
   {
     // An error occurred.
   }






[endsect]


[endsect]


[section:broadcast basic_socket::broadcast]


['Inherited from socket_base.]

[indexterm2 broadcast..basic_socket] Socket option to permit sending of broadcast messages. 

  typedef implementation_defined broadcast;



Implements the SOL\_SOCKET/SO\_BROADCAST socket option.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::udp::socket socket(io_service); 
   ...
   boost::asio::socket_base::broadcast option(true);
   socket.set_option(option);




Getting the current option value: 

   boost::asio::ip::udp::socket socket(io_service); 
   ...
   boost::asio::socket_base::broadcast option;
   socket.get_option(option);
   bool is_set = option.value();






[endsect]



[section:bytes_readable basic_socket::bytes_readable]


['Inherited from socket_base.]

[indexterm2 bytes_readable..basic_socket] IO control command to get the amount of data that can be read without blocking. 

  typedef implementation_defined bytes_readable;



Implements the FIONREAD IO control command.


[heading Example]
  


   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::bytes_readable command(true);
   socket.io_control(command);
   std::size_t bytes_readable = command.get();






[endsect]


[section:cancel basic_socket::cancel]

[indexterm2 cancel..basic_socket] Cancel all asynchronous operations associated with the socket. 

  void ``[link boost_asio.reference.basic_socket.cancel.overload1 cancel]``();

  boost::system::error_code ``[link boost_asio.reference.basic_socket.cancel.overload2 cancel]``(
      boost::system::error_code & ec);


[section:overload1 basic_socket::cancel (1 of 2 overloads)]

Cancel all asynchronous operations associated with the socket. 

  void cancel();


This function causes all outstanding asynchronous connect, send and receive operations to finish immediately, and the handlers for cancelled operations will be passed the boost::asio::error::operation\_aborted error.


[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Remarks]
      
Calls to cancel() will always fail with boost::asio::error::operation\_not\_supported when run on Windows XP, Windows Server 2003, and earlier versions of Windows, unless BOOST\_ASIO\_ENABLE\_CANCELIO is defined. However, the CancelIo function has two issues that should be considered before enabling its use:

* It will only cancel asynchronous operations that were initiated in the current thread.

* It can appear to complete without error, but the request to cancel the unfinished operations may be silently ignored by the operating system. Whether it works or not seems to depend on the drivers that are installed.

For portable cancellation, consider using one of the following alternatives:


* Disable asio's I/O completion port backend by defining BOOST_ASIO_DISABLE_IOCP.

* Use the close() function to simultaneously cancel the outstanding operations and close the socket.

When running on Windows Vista, Windows Server 2008, and later, the CancelIoEx function is always used. This function does not have the problems described above. 


[endsect]



[section:overload2 basic_socket::cancel (2 of 2 overloads)]

Cancel all asynchronous operations associated with the socket. 

  boost::system::error_code cancel(
      boost::system::error_code & ec);


This function causes all outstanding asynchronous connect, send and receive operations to finish immediately, and the handlers for cancelled operations will be passed the boost::asio::error::operation\_aborted error.


[heading Parameters]
    

[variablelist
  
[[ec][Set to indicate what error occurred, if any.]]

]

[heading Remarks]
      
Calls to cancel() will always fail with boost::asio::error::operation\_not\_supported when run on Windows XP, Windows Server 2003, and earlier versions of Windows, unless BOOST\_ASIO\_ENABLE\_CANCELIO is defined. However, the CancelIo function has two issues that should be considered before enabling its use:

* It will only cancel asynchronous operations that were initiated in the current thread.

* It can appear to complete without error, but the request to cancel the unfinished operations may be silently ignored by the operating system. Whether it works or not seems to depend on the drivers that are installed.

For portable cancellation, consider using one of the following alternatives:


* Disable asio's I/O completion port backend by defining BOOST_ASIO_DISABLE_IOCP.

* Use the close() function to simultaneously cancel the outstanding operations and close the socket.

When running on Windows Vista, Windows Server 2008, and later, the CancelIoEx function is always used. This function does not have the problems described above. 


[endsect]


[endsect]

[section:close basic_socket::close]

[indexterm2 close..basic_socket] Close the socket. 

  void ``[link boost_asio.reference.basic_socket.close.overload1 close]``();

  boost::system::error_code ``[link boost_asio.reference.basic_socket.close.overload2 close]``(
      boost::system::error_code & ec);


[section:overload1 basic_socket::close (1 of 2 overloads)]

Close the socket. 

  void close();


This function is used to close the socket. Any asynchronous send, receive or connect operations will be cancelled immediately, and will complete with the boost::asio::error::operation\_aborted error.


[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Remarks]
      
For portable behaviour with respect to graceful closure of a connected socket, call shutdown() before closing the socket. 



[endsect]



[section:overload2 basic_socket::close (2 of 2 overloads)]

Close the socket. 

  boost::system::error_code close(
      boost::system::error_code & ec);


This function is used to close the socket. Any asynchronous send, receive or connect operations will be cancelled immediately, and will complete with the boost::asio::error::operation\_aborted error.


[heading Parameters]
    

[variablelist
  
[[ec][Set to indicate what error occurred, if any.]]

]

[heading Example]
  


   boost::asio::ip::tcp::socket socket(io_service);
   ...
   boost::system::error_code ec;
   socket.close(ec);
   if (ec)
   {
     // An error occurred.
   }




[heading Remarks]
      
For portable behaviour with respect to graceful closure of a connected socket, call shutdown() before closing the socket. 



[endsect]


[endsect]

[section:connect basic_socket::connect]

[indexterm2 connect..basic_socket] Connect the socket to the specified endpoint. 

  void ``[link boost_asio.reference.basic_socket.connect.overload1 connect]``(
      const endpoint_type & peer_endpoint);

  boost::system::error_code ``[link boost_asio.reference.basic_socket.connect.overload2 connect]``(
      const endpoint_type & peer_endpoint,
      boost::system::error_code & ec);


[section:overload1 basic_socket::connect (1 of 2 overloads)]

Connect the socket to the specified endpoint. 

  void connect(
      const endpoint_type & peer_endpoint);


This function is used to connect a socket to the specified remote endpoint. The function call will block until the connection is successfully made or an error occurs.

The socket is automatically opened if it is not already open. If the connect fails, and the socket was automatically opened, the socket is not returned to the closed state.


[heading Parameters]
    

[variablelist
  
[[peer_endpoint][The remote endpoint to which the socket will be connected.]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Example]
  


   boost::asio::ip::tcp::socket socket(io_service);
   boost::asio::ip::tcp::endpoint endpoint(
       boost::asio::ip::address::from_string("1.2.3.4"), 12345);
   socket.connect(endpoint);






[endsect]



[section:overload2 basic_socket::connect (2 of 2 overloads)]

Connect the socket to the specified endpoint. 

  boost::system::error_code connect(
      const endpoint_type & peer_endpoint,
      boost::system::error_code & ec);


This function is used to connect a socket to the specified remote endpoint. The function call will block until the connection is successfully made or an error occurs.

The socket is automatically opened if it is not already open. If the connect fails, and the socket was automatically opened, the socket is not returned to the closed state.


[heading Parameters]
    

[variablelist
  
[[peer_endpoint][The remote endpoint to which the socket will be connected.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Example]
  


   boost::asio::ip::tcp::socket socket(io_service);
   boost::asio::ip::tcp::endpoint endpoint(
       boost::asio::ip::address::from_string("1.2.3.4"), 12345);
   boost::system::error_code ec;
   socket.connect(endpoint, ec);
   if (ec)
   {
     // An error occurred.
   }






[endsect]


[endsect]


[section:debug basic_socket::debug]


['Inherited from socket_base.]

[indexterm2 debug..basic_socket] Socket option to enable socket-level debugging. 

  typedef implementation_defined debug;



Implements the SOL\_SOCKET/SO\_DEBUG socket option.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::debug option(true);
   socket.set_option(option);




Getting the current option value: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::debug option;
   socket.get_option(option);
   bool is_set = option.value();






[endsect]



[section:do_not_route basic_socket::do_not_route]


['Inherited from socket_base.]

[indexterm2 do_not_route..basic_socket] Socket option to prevent routing, use local interfaces only. 

  typedef implementation_defined do_not_route;



Implements the SOL\_SOCKET/SO\_DONTROUTE socket option.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::udp::socket socket(io_service); 
   ...
   boost::asio::socket_base::do_not_route option(true);
   socket.set_option(option);




Getting the current option value: 

   boost::asio::ip::udp::socket socket(io_service); 
   ...
   boost::asio::socket_base::do_not_route option;
   socket.get_option(option);
   bool is_set = option.value();






[endsect]



[section:enable_connection_aborted basic_socket::enable_connection_aborted]


['Inherited from socket_base.]

[indexterm2 enable_connection_aborted..basic_socket] Socket option to report aborted connections on accept. 

  typedef implementation_defined enable_connection_aborted;



Implements a custom socket option that determines whether or not an accept operation is permitted to fail with boost::asio::error::connection\_aborted. By default the option is false.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::tcp::acceptor acceptor(io_service); 
   ...
   boost::asio::socket_base::enable_connection_aborted option(true);
   acceptor.set_option(option);




Getting the current option value: 

   boost::asio::ip::tcp::acceptor acceptor(io_service); 
   ...
   boost::asio::socket_base::enable_connection_aborted option;
   acceptor.get_option(option);
   bool is_set = option.value();






[endsect]



[section:endpoint_type basic_socket::endpoint_type]

[indexterm2 endpoint_type..basic_socket] The endpoint type. 

  typedef Protocol::endpoint endpoint_type;




[endsect]



[section:get_io_service basic_socket::get_io_service]


['Inherited from basic_io_object.]

[indexterm2 get_io_service..basic_socket] Get the io_service associated with the object. 

  boost::asio::io_service & get_io_service();


This function may be used to obtain the io_service object that the I/O object uses to dispatch handlers for asynchronous operations.


[heading Return Value]
      
A reference to the io_service object that the I/O object will use to dispatch handlers. Ownership is not transferred to the caller. 



[endsect]


[section:get_option basic_socket::get_option]

[indexterm2 get_option..basic_socket] Get an option from the socket. 

  template<
      typename ``[link boost_asio.reference.GettableSocketOption GettableSocketOption]``>
  void ``[link boost_asio.reference.basic_socket.get_option.overload1 get_option]``(
      GettableSocketOption & option) const;

  template<
      typename ``[link boost_asio.reference.GettableSocketOption GettableSocketOption]``>
  boost::system::error_code ``[link boost_asio.reference.basic_socket.get_option.overload2 get_option]``(
      GettableSocketOption & option,
      boost::system::error_code & ec) const;


[section:overload1 basic_socket::get_option (1 of 2 overloads)]

Get an option from the socket. 

  template<
      typename ``[link boost_asio.reference.GettableSocketOption GettableSocketOption]``>
  void get_option(
      GettableSocketOption & option) const;


This function is used to get the current value of an option on the socket.


[heading Parameters]
    

[variablelist
  
[[option][The option value to be obtained from the socket.]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Example]
  
Getting the value of the SOL\_SOCKET/SO\_KEEPALIVE option: 

   boost::asio::ip::tcp::socket socket(io_service);
   ...
   boost::asio::ip::tcp::socket::keep_alive option;
   socket.get_option(option);
   bool is_set = option.get();






[endsect]



[section:overload2 basic_socket::get_option (2 of 2 overloads)]

Get an option from the socket. 

  template<
      typename ``[link boost_asio.reference.GettableSocketOption GettableSocketOption]``>
  boost::system::error_code get_option(
      GettableSocketOption & option,
      boost::system::error_code & ec) const;


This function is used to get the current value of an option on the socket.


[heading Parameters]
    

[variablelist
  
[[option][The option value to be obtained from the socket.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Example]
  
Getting the value of the SOL\_SOCKET/SO\_KEEPALIVE option: 

   boost::asio::ip::tcp::socket socket(io_service);
   ...
   boost::asio::ip::tcp::socket::keep_alive option;
   boost::system::error_code ec;
   socket.get_option(option, ec);
   if (ec)
   {
     // An error occurred.
   }
   bool is_set = option.get();






[endsect]


[endsect]


[section:implementation basic_socket::implementation]


['Inherited from basic_io_object.]

[indexterm2 implementation..basic_socket] The underlying implementation of the I/O object. 

  implementation_type implementation;



[endsect]



[section:implementation_type basic_socket::implementation_type]


['Inherited from basic_io_object.]

[indexterm2 implementation_type..basic_socket] The underlying implementation type of I/O object. 

  typedef service_type::implementation_type implementation_type;




[endsect]


[section:io_control basic_socket::io_control]

[indexterm2 io_control..basic_socket] Perform an IO control command on the socket. 

  template<
      typename ``[link boost_asio.reference.IoControlCommand IoControlCommand]``>
  void ``[link boost_asio.reference.basic_socket.io_control.overload1 io_control]``(
      IoControlCommand & command);

  template<
      typename ``[link boost_asio.reference.IoControlCommand IoControlCommand]``>
  boost::system::error_code ``[link boost_asio.reference.basic_socket.io_control.overload2 io_control]``(
      IoControlCommand & command,
      boost::system::error_code & ec);


[section:overload1 basic_socket::io_control (1 of 2 overloads)]

Perform an IO control command on the socket. 

  template<
      typename ``[link boost_asio.reference.IoControlCommand IoControlCommand]``>
  void io_control(
      IoControlCommand & command);


This function is used to execute an IO control command on the socket.


[heading Parameters]
    

[variablelist
  
[[command][The IO control command to be performed on the socket.]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Example]
  
Getting the number of bytes ready to read: 

   boost::asio::ip::tcp::socket socket(io_service);
   ...
   boost::asio::ip::tcp::socket::bytes_readable command;
   socket.io_control(command);
   std::size_t bytes_readable = command.get();






[endsect]



[section:overload2 basic_socket::io_control (2 of 2 overloads)]

Perform an IO control command on the socket. 

  template<
      typename ``[link boost_asio.reference.IoControlCommand IoControlCommand]``>
  boost::system::error_code io_control(
      IoControlCommand & command,
      boost::system::error_code & ec);


This function is used to execute an IO control command on the socket.


[heading Parameters]
    

[variablelist
  
[[command][The IO control command to be performed on the socket.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Example]
  
Getting the number of bytes ready to read: 

   boost::asio::ip::tcp::socket socket(io_service);
   ...
   boost::asio::ip::tcp::socket::bytes_readable command;
   boost::system::error_code ec;
   socket.io_control(command, ec);
   if (ec)
   {
     // An error occurred.
   }
   std::size_t bytes_readable = command.get();






[endsect]


[endsect]


[section:io_service basic_socket::io_service]


['Inherited from basic_io_object.]

[indexterm2 io_service..basic_socket] (Deprecated: use get_io_service().) Get the io_service associated with the object. 

  boost::asio::io_service & io_service();


This function may be used to obtain the io_service object that the I/O object uses to dispatch handlers for asynchronous operations.


[heading Return Value]
      
A reference to the io_service object that the I/O object will use to dispatch handlers. Ownership is not transferred to the caller. 



[endsect]



[section:is_open basic_socket::is_open]

[indexterm2 is_open..basic_socket] Determine whether the socket is open. 

  bool is_open() const;



[endsect]



[section:keep_alive basic_socket::keep_alive]


['Inherited from socket_base.]

[indexterm2 keep_alive..basic_socket] Socket option to send keep-alives. 

  typedef implementation_defined keep_alive;



Implements the SOL\_SOCKET/SO\_KEEPALIVE socket option.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::keep_alive option(true);
   socket.set_option(option);




Getting the current option value: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::keep_alive option;
   socket.get_option(option);
   bool is_set = option.value();






[endsect]



[section:linger basic_socket::linger]


['Inherited from socket_base.]

[indexterm2 linger..basic_socket] Socket option to specify whether the socket lingers on close if unsent data is present. 

  typedef implementation_defined linger;



Implements the SOL\_SOCKET/SO\_LINGER socket option.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::linger option(true, 30);
   socket.set_option(option);




Getting the current option value: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::linger option;
   socket.get_option(option);
   bool is_set = option.enabled();
   unsigned short timeout = option.timeout();






[endsect]


[section:local_endpoint basic_socket::local_endpoint]

[indexterm2 local_endpoint..basic_socket] Get the local endpoint of the socket. 

  endpoint_type ``[link boost_asio.reference.basic_socket.local_endpoint.overload1 local_endpoint]``() const;

  endpoint_type ``[link boost_asio.reference.basic_socket.local_endpoint.overload2 local_endpoint]``(
      boost::system::error_code & ec) const;


[section:overload1 basic_socket::local_endpoint (1 of 2 overloads)]

Get the local endpoint of the socket. 

  endpoint_type local_endpoint() const;


This function is used to obtain the locally bound endpoint of the socket.


[heading Return Value]
      
An object that represents the local endpoint of the socket.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Example]
  


   boost::asio::ip::tcp::socket socket(io_service);
   ...
   boost::asio::ip::tcp::endpoint endpoint = socket.local_endpoint();






[endsect]



[section:overload2 basic_socket::local_endpoint (2 of 2 overloads)]

Get the local endpoint of the socket. 

  endpoint_type local_endpoint(
      boost::system::error_code & ec) const;


This function is used to obtain the locally bound endpoint of the socket.


[heading Parameters]
    

[variablelist
  
[[ec][Set to indicate what error occurred, if any.]]

]

[heading Return Value]
      
An object that represents the local endpoint of the socket. Returns a default-constructed endpoint object if an error occurred.

[heading Example]
  


   boost::asio::ip::tcp::socket socket(io_service);
   ...
   boost::system::error_code ec;
   boost::asio::ip::tcp::endpoint endpoint = socket.local_endpoint(ec);
   if (ec)
   {
     // An error occurred.
   }






[endsect]


[endsect]

[section:lowest_layer basic_socket::lowest_layer]

[indexterm2 lowest_layer..basic_socket] Get a reference to the lowest layer. 

  lowest_layer_type & ``[link boost_asio.reference.basic_socket.lowest_layer.overload1 lowest_layer]``();

Get a const reference to the lowest layer. 

  const lowest_layer_type & ``[link boost_asio.reference.basic_socket.lowest_layer.overload2 lowest_layer]``() const;


[section:overload1 basic_socket::lowest_layer (1 of 2 overloads)]

Get a reference to the lowest layer. 

  lowest_layer_type & lowest_layer();


This function returns a reference to the lowest layer in a stack of layers. Since a basic_socket cannot contain any further layers, it simply returns a reference to itself.


[heading Return Value]
      
A reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller. 



[endsect]



[section:overload2 basic_socket::lowest_layer (2 of 2 overloads)]

Get a const reference to the lowest layer. 

  const lowest_layer_type & lowest_layer() const;


This function returns a const reference to the lowest layer in a stack of layers. Since a basic_socket cannot contain any further layers, it simply returns a reference to itself.


[heading Return Value]
      
A const reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller. 



[endsect]


[endsect]


[section:lowest_layer_type basic_socket::lowest_layer_type]

[indexterm2 lowest_layer_type..basic_socket] A basic_socket is always the lowest layer. 

  typedef basic_socket< Protocol, SocketService > lowest_layer_type;


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.basic_socket.broadcast [*broadcast]]]
    [Socket option to permit sending of broadcast messages. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.bytes_readable [*bytes_readable]]]
    [IO control command to get the amount of data that can be read without blocking. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.debug [*debug]]]
    [Socket option to enable socket-level debugging. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.do_not_route [*do_not_route]]]
    [Socket option to prevent routing, use local interfaces only. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.enable_connection_aborted [*enable_connection_aborted]]]
    [Socket option to report aborted connections on accept. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.endpoint_type [*endpoint_type]]]
    [The endpoint type. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.implementation_type [*implementation_type]]]
    [The underlying implementation type of I/O object. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.keep_alive [*keep_alive]]]
    [Socket option to send keep-alives. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.linger [*linger]]]
    [Socket option to specify whether the socket lingers on close if unsent data is present. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.lowest_layer_type [*lowest_layer_type]]]
    [A basic_socket is always the lowest layer. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.message_flags [*message_flags]]]
    [Bitmask type for flags that can be passed to send and receive operations. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.native_type [*native_type]]]
    [The native representation of a socket. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.non_blocking_io [*non_blocking_io]]]
    [IO control command to set the blocking mode of the socket. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.protocol_type [*protocol_type]]]
    [The protocol type. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.receive_buffer_size [*receive_buffer_size]]]
    [Socket option for the receive buffer size of a socket. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.receive_low_watermark [*receive_low_watermark]]]
    [Socket option for the receive low watermark. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.reuse_address [*reuse_address]]]
    [Socket option to allow the socket to be bound to an address that is already in use. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.send_buffer_size [*send_buffer_size]]]
    [Socket option for the send buffer size of a socket. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.send_low_watermark [*send_low_watermark]]]
    [Socket option for the send low watermark. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.service_type [*service_type]]]
    [The type of the service that will be used to provide I/O operations. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.shutdown_type [*shutdown_type]]]
    [Different ways a socket may be shutdown. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_socket.assign [*assign]]]
    [Assign an existing native socket to the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.async_connect [*async_connect]]]
    [Start an asynchronous connect. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.at_mark [*at_mark]]]
    [Determine whether the socket is at the out-of-band data mark. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.available [*available]]]
    [Determine the number of bytes available for reading. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.basic_socket [*basic_socket]]]
    [Construct a basic_socket without opening it. 

     Construct and open a basic_socket. 

     Construct a basic_socket, opening it and binding it to the given local endpoint. 

     Construct a basic_socket on an existing native socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.bind [*bind]]]
    [Bind the socket to the given local endpoint. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.cancel [*cancel]]]
    [Cancel all asynchronous operations associated with the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.close [*close]]]
    [Close the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.connect [*connect]]]
    [Connect the socket to the specified endpoint. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.get_io_service [*get_io_service]]]
    [Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.get_option [*get_option]]]
    [Get an option from the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.io_control [*io_control]]]
    [Perform an IO control command on the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.io_service [*io_service]]]
    [(Deprecated: use get_io_service().) Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.is_open [*is_open]]]
    [Determine whether the socket is open. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.local_endpoint [*local_endpoint]]]
    [Get the local endpoint of the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.lowest_layer [*lowest_layer]]]
    [Get a reference to the lowest layer. 

     Get a const reference to the lowest layer. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.native [*native]]]
    [Get the native socket representation. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.open [*open]]]
    [Open the socket using the specified protocol. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.remote_endpoint [*remote_endpoint]]]
    [Get the remote endpoint of the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.set_option [*set_option]]]
    [Set an option on the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.shutdown [*shutdown]]]
    [Disable sends or receives on the socket. ]
  ]
  
]

[heading Protected Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_socket._basic_socket [*~basic_socket]]]
    [Protected destructor to prevent deletion through this type. ]
  ]
  
]

[heading Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_socket.max_connections [*max_connections]]]
    [The maximum length of the queue of pending incoming connections. ]
  ]

  [
    [[link boost_asio.reference.basic_socket.message_do_not_route [*message_do_not_route]]]
    [Specify that the data should not be subject to routing. ]
  ]

  [
    [[link boost_asio.reference.basic_socket.message_out_of_band [*message_out_of_band]]]
    [Process out-of-band data. ]
  ]

  [
    [[link boost_asio.reference.basic_socket.message_peek [*message_peek]]]
    [Peek at incoming data without removing it from the input queue. ]
  ]

]

[heading Protected Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_socket.implementation [*implementation]]]
    [The underlying implementation of the I/O object. ]
  ]

  [
    [[link boost_asio.reference.basic_socket.service [*service]]]
    [The service associated with the I/O object. ]
  ]

]

The basic_socket class template provides functionality that is common to both stream-oriented and datagram-oriented sockets.


[heading Thread Safety]
  
[*Distinct] [*objects:]  Safe.

[*Shared] [*objects:]  Unsafe. 




[endsect]



[section:max_connections basic_socket::max_connections]


['Inherited from socket_base.]

[indexterm2 max_connections..basic_socket] The maximum length of the queue of pending incoming connections. 

  static const int max_connections = implementation_defined;



[endsect]



[section:message_do_not_route basic_socket::message_do_not_route]


['Inherited from socket_base.]

[indexterm2 message_do_not_route..basic_socket] Specify that the data should not be subject to routing. 

  static const int message_do_not_route = implementation_defined;



[endsect]



[section:message_flags basic_socket::message_flags]


['Inherited from socket_base.]

[indexterm2 message_flags..basic_socket] Bitmask type for flags that can be passed to send and receive operations. 

  typedef int message_flags;




[endsect]



[section:message_out_of_band basic_socket::message_out_of_band]


['Inherited from socket_base.]

[indexterm2 message_out_of_band..basic_socket] Process out-of-band data. 

  static const int message_out_of_band = implementation_defined;



[endsect]



[section:message_peek basic_socket::message_peek]


['Inherited from socket_base.]

[indexterm2 message_peek..basic_socket] Peek at incoming data without removing it from the input queue. 

  static const int message_peek = implementation_defined;



[endsect]



[section:native basic_socket::native]

[indexterm2 native..basic_socket] Get the native socket representation. 

  native_type native();


This function may be used to obtain the underlying representation of the socket. This is intended to allow access to native socket functionality that is not otherwise provided. 


[endsect]



[section:native_type basic_socket::native_type]

[indexterm2 native_type..basic_socket] The native representation of a socket. 

  typedef SocketService::native_type native_type;




[endsect]



[section:non_blocking_io basic_socket::non_blocking_io]


['Inherited from socket_base.]

[indexterm2 non_blocking_io..basic_socket] IO control command to set the blocking mode of the socket. 

  typedef implementation_defined non_blocking_io;



Implements the FIONBIO IO control command.


[heading Example]
  


   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::non_blocking_io command(true);
   socket.io_control(command);






[endsect]


[section:open basic_socket::open]

[indexterm2 open..basic_socket] Open the socket using the specified protocol. 

  void ``[link boost_asio.reference.basic_socket.open.overload1 open]``(
      const protocol_type & protocol = protocol_type());

  boost::system::error_code ``[link boost_asio.reference.basic_socket.open.overload2 open]``(
      const protocol_type & protocol,
      boost::system::error_code & ec);


[section:overload1 basic_socket::open (1 of 2 overloads)]

Open the socket using the specified protocol. 

  void open(
      const protocol_type & protocol = protocol_type());


This function opens the socket so that it will use the specified protocol.


[heading Parameters]
    

[variablelist
  
[[protocol][An object specifying protocol parameters to be used.]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Example]
  


   boost::asio::ip::tcp::socket socket(io_service);
   socket.open(boost::asio::ip::tcp::v4());






[endsect]



[section:overload2 basic_socket::open (2 of 2 overloads)]

Open the socket using the specified protocol. 

  boost::system::error_code open(
      const protocol_type & protocol,
      boost::system::error_code & ec);


This function opens the socket so that it will use the specified protocol.


[heading Parameters]
    

[variablelist
  
[[protocol][An object specifying which protocol is to be used.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Example]
  


   boost::asio::ip::tcp::socket socket(io_service);
   boost::system::error_code ec;
   socket.open(boost::asio::ip::tcp::v4(), ec);
   if (ec)
   {
     // An error occurred.
   }






[endsect]


[endsect]


[section:protocol_type basic_socket::protocol_type]

[indexterm2 protocol_type..basic_socket] The protocol type. 

  typedef Protocol protocol_type;




[endsect]



[section:receive_buffer_size basic_socket::receive_buffer_size]


['Inherited from socket_base.]

[indexterm2 receive_buffer_size..basic_socket] Socket option for the receive buffer size of a socket. 

  typedef implementation_defined receive_buffer_size;



Implements the SOL\_SOCKET/SO\_RCVBUF socket option.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::receive_buffer_size option(8192);
   socket.set_option(option);




Getting the current option value: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::receive_buffer_size option;
   socket.get_option(option);
   int size = option.value();






[endsect]



[section:receive_low_watermark basic_socket::receive_low_watermark]


['Inherited from socket_base.]

[indexterm2 receive_low_watermark..basic_socket] Socket option for the receive low watermark. 

  typedef implementation_defined receive_low_watermark;



Implements the SOL\_SOCKET/SO\_RCVLOWAT socket option.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::receive_low_watermark option(1024);
   socket.set_option(option);




Getting the current option value: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::receive_low_watermark option;
   socket.get_option(option);
   int size = option.value();






[endsect]


[section:remote_endpoint basic_socket::remote_endpoint]

[indexterm2 remote_endpoint..basic_socket] Get the remote endpoint of the socket. 

  endpoint_type ``[link boost_asio.reference.basic_socket.remote_endpoint.overload1 remote_endpoint]``() const;

  endpoint_type ``[link boost_asio.reference.basic_socket.remote_endpoint.overload2 remote_endpoint]``(
      boost::system::error_code & ec) const;


[section:overload1 basic_socket::remote_endpoint (1 of 2 overloads)]

Get the remote endpoint of the socket. 

  endpoint_type remote_endpoint() const;


This function is used to obtain the remote endpoint of the socket.


[heading Return Value]
      
An object that represents the remote endpoint of the socket.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Example]
  


   boost::asio::ip::tcp::socket socket(io_service);
   ...
   boost::asio::ip::tcp::endpoint endpoint = socket.remote_endpoint();






[endsect]



[section:overload2 basic_socket::remote_endpoint (2 of 2 overloads)]

Get the remote endpoint of the socket. 

  endpoint_type remote_endpoint(
      boost::system::error_code & ec) const;


This function is used to obtain the remote endpoint of the socket.


[heading Parameters]
    

[variablelist
  
[[ec][Set to indicate what error occurred, if any.]]

]

[heading Return Value]
      
An object that represents the remote endpoint of the socket. Returns a default-constructed endpoint object if an error occurred.

[heading Example]
  


   boost::asio::ip::tcp::socket socket(io_service);
   ...
   boost::system::error_code ec;
   boost::asio::ip::tcp::endpoint endpoint = socket.remote_endpoint(ec);
   if (ec)
   {
     // An error occurred.
   }






[endsect]


[endsect]


[section:reuse_address basic_socket::reuse_address]


['Inherited from socket_base.]

[indexterm2 reuse_address..basic_socket] Socket option to allow the socket to be bound to an address that is already in use. 

  typedef implementation_defined reuse_address;



Implements the SOL\_SOCKET/SO\_REUSEADDR socket option.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::tcp::acceptor acceptor(io_service); 
   ...
   boost::asio::socket_base::reuse_address option(true);
   acceptor.set_option(option);




Getting the current option value: 

   boost::asio::ip::tcp::acceptor acceptor(io_service); 
   ...
   boost::asio::socket_base::reuse_address option;
   acceptor.get_option(option);
   bool is_set = option.value();






[endsect]



[section:send_buffer_size basic_socket::send_buffer_size]


['Inherited from socket_base.]

[indexterm2 send_buffer_size..basic_socket] Socket option for the send buffer size of a socket. 

  typedef implementation_defined send_buffer_size;



Implements the SOL\_SOCKET/SO\_SNDBUF socket option.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::send_buffer_size option(8192);
   socket.set_option(option);




Getting the current option value: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::send_buffer_size option;
   socket.get_option(option);
   int size = option.value();






[endsect]



[section:send_low_watermark basic_socket::send_low_watermark]


['Inherited from socket_base.]

[indexterm2 send_low_watermark..basic_socket] Socket option for the send low watermark. 

  typedef implementation_defined send_low_watermark;



Implements the SOL\_SOCKET/SO\_SNDLOWAT socket option.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::send_low_watermark option(1024);
   socket.set_option(option);




Getting the current option value: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::send_low_watermark option;
   socket.get_option(option);
   int size = option.value();






[endsect]



[section:service basic_socket::service]


['Inherited from basic_io_object.]

[indexterm2 service..basic_socket] The service associated with the I/O object. 

  service_type & service;



[endsect]



[section:service_type basic_socket::service_type]


['Inherited from basic_io_object.]

[indexterm2 service_type..basic_socket] The type of the service that will be used to provide I/O operations. 

  typedef SocketService service_type;




[endsect]


[section:set_option basic_socket::set_option]

[indexterm2 set_option..basic_socket] Set an option on the socket. 

  template<
      typename ``[link boost_asio.reference.SettableSocketOption SettableSocketOption]``>
  void ``[link boost_asio.reference.basic_socket.set_option.overload1 set_option]``(
      const SettableSocketOption & option);

  template<
      typename ``[link boost_asio.reference.SettableSocketOption SettableSocketOption]``>
  boost::system::error_code ``[link boost_asio.reference.basic_socket.set_option.overload2 set_option]``(
      const SettableSocketOption & option,
      boost::system::error_code & ec);


[section:overload1 basic_socket::set_option (1 of 2 overloads)]

Set an option on the socket. 

  template<
      typename ``[link boost_asio.reference.SettableSocketOption SettableSocketOption]``>
  void set_option(
      const SettableSocketOption & option);


This function is used to set an option on the socket.


[heading Parameters]
    

[variablelist
  
[[option][The new option value to be set on the socket.]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Example]
  
Setting the IPPROTO\_TCP/TCP\_NODELAY option: 

   boost::asio::ip::tcp::socket socket(io_service);
   ...
   boost::asio::ip::tcp::no_delay option(true);
   socket.set_option(option);






[endsect]



[section:overload2 basic_socket::set_option (2 of 2 overloads)]

Set an option on the socket. 

  template<
      typename ``[link boost_asio.reference.SettableSocketOption SettableSocketOption]``>
  boost::system::error_code set_option(
      const SettableSocketOption & option,
      boost::system::error_code & ec);


This function is used to set an option on the socket.


[heading Parameters]
    

[variablelist
  
[[option][The new option value to be set on the socket.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Example]
  
Setting the IPPROTO\_TCP/TCP\_NODELAY option: 

   boost::asio::ip::tcp::socket socket(io_service);
   ...
   boost::asio::ip::tcp::no_delay option(true);
   boost::system::error_code ec;
   socket.set_option(option, ec);
   if (ec)
   {
     // An error occurred.
   }






[endsect]


[endsect]

[section:shutdown basic_socket::shutdown]

[indexterm2 shutdown..basic_socket] Disable sends or receives on the socket. 

  void ``[link boost_asio.reference.basic_socket.shutdown.overload1 shutdown]``(
      shutdown_type what);

  boost::system::error_code ``[link boost_asio.reference.basic_socket.shutdown.overload2 shutdown]``(
      shutdown_type what,
      boost::system::error_code & ec);


[section:overload1 basic_socket::shutdown (1 of 2 overloads)]

Disable sends or receives on the socket. 

  void shutdown(
      shutdown_type what);


This function is used to disable send operations, receive operations, or both.


[heading Parameters]
    

[variablelist
  
[[what][Determines what types of operation will no longer be allowed.]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Example]
  
Shutting down the send side of the socket: 

   boost::asio::ip::tcp::socket socket(io_service);
   ...
   socket.shutdown(boost::asio::ip::tcp::socket::shutdown_send);






[endsect]



[section:overload2 basic_socket::shutdown (2 of 2 overloads)]

Disable sends or receives on the socket. 

  boost::system::error_code shutdown(
      shutdown_type what,
      boost::system::error_code & ec);


This function is used to disable send operations, receive operations, or both.


[heading Parameters]
    

[variablelist
  
[[what][Determines what types of operation will no longer be allowed.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Example]
  
Shutting down the send side of the socket: 

   boost::asio::ip::tcp::socket socket(io_service);
   ...
   boost::system::error_code ec;
   socket.shutdown(boost::asio::ip::tcp::socket::shutdown_send, ec);
   if (ec)
   {
     // An error occurred.
   }






[endsect]


[endsect]


[section:shutdown_type basic_socket::shutdown_type]


['Inherited from socket_base.]

[indexterm2 shutdown_type..basic_socket] Different ways a socket may be shutdown. 

  enum shutdown_type

[heading Values]
[variablelist

  [
    [shutdown_receive]
    [Shutdown the receive side of the socket. ]
  ]

  [
    [shutdown_send]
    [Shutdown the send side of the socket. ]
  ]

  [
    [shutdown_both]
    [Shutdown both send and receive on the socket. ]
  ]

]



[endsect]



[section:_basic_socket basic_socket::~basic_socket]

[indexterm2 ~basic_socket..basic_socket] Protected destructor to prevent deletion through this type. 

  ~basic_socket();



[endsect]



[endsect]

[section:basic_socket_acceptor basic_socket_acceptor]

Provides the ability to accept new connections. 

  template<
      typename ``[link boost_asio.reference.Protocol Protocol]``,
      typename ``[link boost_asio.reference.SocketAcceptorService SocketAcceptorService]`` = socket_acceptor_service<Protocol>>
  class basic_socket_acceptor :
    public basic_io_object< SocketAcceptorService >,
    public socket_base


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.basic_socket_acceptor.broadcast [*broadcast]]]
    [Socket option to permit sending of broadcast messages. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_acceptor.bytes_readable [*bytes_readable]]]
    [IO control command to get the amount of data that can be read without blocking. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_acceptor.debug [*debug]]]
    [Socket option to enable socket-level debugging. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_acceptor.do_not_route [*do_not_route]]]
    [Socket option to prevent routing, use local interfaces only. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_acceptor.enable_connection_aborted [*enable_connection_aborted]]]
    [Socket option to report aborted connections on accept. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_acceptor.endpoint_type [*endpoint_type]]]
    [The endpoint type. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_acceptor.implementation_type [*implementation_type]]]
    [The underlying implementation type of I/O object. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_acceptor.keep_alive [*keep_alive]]]
    [Socket option to send keep-alives. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_acceptor.linger [*linger]]]
    [Socket option to specify whether the socket lingers on close if unsent data is present. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_acceptor.message_flags [*message_flags]]]
    [Bitmask type for flags that can be passed to send and receive operations. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_acceptor.native_type [*native_type]]]
    [The native representation of an acceptor. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_acceptor.non_blocking_io [*non_blocking_io]]]
    [IO control command to set the blocking mode of the socket. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_acceptor.protocol_type [*protocol_type]]]
    [The protocol type. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_acceptor.receive_buffer_size [*receive_buffer_size]]]
    [Socket option for the receive buffer size of a socket. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_acceptor.receive_low_watermark [*receive_low_watermark]]]
    [Socket option for the receive low watermark. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_acceptor.reuse_address [*reuse_address]]]
    [Socket option to allow the socket to be bound to an address that is already in use. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_acceptor.send_buffer_size [*send_buffer_size]]]
    [Socket option for the send buffer size of a socket. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_acceptor.send_low_watermark [*send_low_watermark]]]
    [Socket option for the send low watermark. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_acceptor.service_type [*service_type]]]
    [The type of the service that will be used to provide I/O operations. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_acceptor.shutdown_type [*shutdown_type]]]
    [Different ways a socket may be shutdown. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_socket_acceptor.accept [*accept]]]
    [Accept a new connection. 

     Accept a new connection and obtain the endpoint of the peer. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket_acceptor.assign [*assign]]]
    [Assigns an existing native acceptor to the acceptor. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket_acceptor.async_accept [*async_accept]]]
    [Start an asynchronous accept. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket_acceptor.basic_socket_acceptor [*basic_socket_acceptor]]]
    [Construct an acceptor without opening it. 

     Construct an open acceptor. 

     Construct an acceptor opened on the given endpoint. 

     Construct a basic_socket_acceptor on an existing native acceptor. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket_acceptor.bind [*bind]]]
    [Bind the acceptor to the given local endpoint. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket_acceptor.cancel [*cancel]]]
    [Cancel all asynchronous operations associated with the acceptor. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket_acceptor.close [*close]]]
    [Close the acceptor. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket_acceptor.get_io_service [*get_io_service]]]
    [Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket_acceptor.get_option [*get_option]]]
    [Get an option from the acceptor. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket_acceptor.io_service [*io_service]]]
    [(Deprecated: use get_io_service().) Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket_acceptor.is_open [*is_open]]]
    [Determine whether the acceptor is open. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket_acceptor.listen [*listen]]]
    [Place the acceptor into the state where it will listen for new connections. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket_acceptor.local_endpoint [*local_endpoint]]]
    [Get the local endpoint of the acceptor. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket_acceptor.native [*native]]]
    [Get the native acceptor representation. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket_acceptor.open [*open]]]
    [Open the acceptor using the specified protocol. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket_acceptor.set_option [*set_option]]]
    [Set an option on the acceptor. ]
  ]
  
]

[heading Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_socket_acceptor.max_connections [*max_connections]]]
    [The maximum length of the queue of pending incoming connections. ]
  ]

  [
    [[link boost_asio.reference.basic_socket_acceptor.message_do_not_route [*message_do_not_route]]]
    [Specify that the data should not be subject to routing. ]
  ]

  [
    [[link boost_asio.reference.basic_socket_acceptor.message_out_of_band [*message_out_of_band]]]
    [Process out-of-band data. ]
  ]

  [
    [[link boost_asio.reference.basic_socket_acceptor.message_peek [*message_peek]]]
    [Peek at incoming data without removing it from the input queue. ]
  ]

]

[heading Protected Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_socket_acceptor.implementation [*implementation]]]
    [The underlying implementation of the I/O object. ]
  ]

  [
    [[link boost_asio.reference.basic_socket_acceptor.service [*service]]]
    [The service associated with the I/O object. ]
  ]

]

The basic_socket_acceptor class template is used for accepting new socket connections.


[heading Thread Safety]
  
[*Distinct] [*objects:]  Safe.

[*Shared] [*objects:]  Unsafe.

[heading Example]
  
Opening a socket acceptor with the SO\_REUSEADDR option enabled: 

   boost::asio::ip::tcp::acceptor acceptor(io_service);
   boost::asio::ip::tcp::endpoint endpoint(boost::asio::ip::tcp::v4(), port);
   acceptor.open(endpoint.protocol());
   acceptor.set_option(boost::asio::ip::tcp::acceptor::reuse_address(true));
   acceptor.bind(endpoint);
   acceptor.listen();





[section:accept basic_socket_acceptor::accept]

[indexterm2 accept..basic_socket_acceptor] Accept a new connection. 

  template<
      typename ``[link boost_asio.reference.SocketService SocketService]``>
  void ``[link boost_asio.reference.basic_socket_acceptor.accept.overload1 accept]``(
      basic_socket< protocol_type, SocketService > & peer);

  template<
      typename ``[link boost_asio.reference.SocketService SocketService]``>
  boost::system::error_code ``[link boost_asio.reference.basic_socket_acceptor.accept.overload2 accept]``(
      basic_socket< protocol_type, SocketService > & peer,
      boost::system::error_code & ec);

Accept a new connection and obtain the endpoint of the peer. 

  template<
      typename ``[link boost_asio.reference.SocketService SocketService]``>
  void ``[link boost_asio.reference.basic_socket_acceptor.accept.overload3 accept]``(
      basic_socket< protocol_type, SocketService > & peer,
      endpoint_type & peer_endpoint);

  template<
      typename ``[link boost_asio.reference.SocketService SocketService]``>
  boost::system::error_code ``[link boost_asio.reference.basic_socket_acceptor.accept.overload4 accept]``(
      basic_socket< protocol_type, SocketService > & peer,
      endpoint_type & peer_endpoint,
      boost::system::error_code & ec);


[section:overload1 basic_socket_acceptor::accept (1 of 4 overloads)]

Accept a new connection. 

  template<
      typename ``[link boost_asio.reference.SocketService SocketService]``>
  void accept(
      basic_socket< protocol_type, SocketService > & peer);


This function is used to accept a new connection from a peer into the given socket. The function call will block until a new connection has been accepted successfully or an error occurs.


[heading Parameters]
    

[variablelist
  
[[peer][The socket into which the new connection will be accepted.]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Example]
  


   boost::asio::ip::tcp::acceptor acceptor(io_service);
   ...
   boost::asio::ip::tcp::socket socket(io_service);
   acceptor.accept(socket);






[endsect]



[section:overload2 basic_socket_acceptor::accept (2 of 4 overloads)]

Accept a new connection. 

  template<
      typename ``[link boost_asio.reference.SocketService SocketService]``>
  boost::system::error_code accept(
      basic_socket< protocol_type, SocketService > & peer,
      boost::system::error_code & ec);


This function is used to accept a new connection from a peer into the given socket. The function call will block until a new connection has been accepted successfully or an error occurs.


[heading Parameters]
    

[variablelist
  
[[peer][The socket into which the new connection will be accepted.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Example]
  


   boost::asio::ip::tcp::acceptor acceptor(io_service);
   ...
   boost::asio::ip::tcp::soocket socket(io_service);
   boost::system::error_code ec;
   acceptor.accept(socket, ec);
   if (ec)
   {
     // An error occurred.
   }






[endsect]



[section:overload3 basic_socket_acceptor::accept (3 of 4 overloads)]

Accept a new connection and obtain the endpoint of the peer. 

  template<
      typename ``[link boost_asio.reference.SocketService SocketService]``>
  void accept(
      basic_socket< protocol_type, SocketService > & peer,
      endpoint_type & peer_endpoint);


This function is used to accept a new connection from a peer into the given socket, and additionally provide the endpoint of the remote peer. The function call will block until a new connection has been accepted successfully or an error occurs.


[heading Parameters]
    

[variablelist
  
[[peer][The socket into which the new connection will be accepted.]]

[[peer_endpoint][An endpoint object which will receive the endpoint of the remote peer.]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Example]
  


   boost::asio::ip::tcp::acceptor acceptor(io_service);
   ...
   boost::asio::ip::tcp::socket socket(io_service);
   boost::asio::ip::tcp::endpoint endpoint;
   acceptor.accept(socket, endpoint);






[endsect]



[section:overload4 basic_socket_acceptor::accept (4 of 4 overloads)]

Accept a new connection and obtain the endpoint of the peer. 

  template<
      typename ``[link boost_asio.reference.SocketService SocketService]``>
  boost::system::error_code accept(
      basic_socket< protocol_type, SocketService > & peer,
      endpoint_type & peer_endpoint,
      boost::system::error_code & ec);


This function is used to accept a new connection from a peer into the given socket, and additionally provide the endpoint of the remote peer. The function call will block until a new connection has been accepted successfully or an error occurs.


[heading Parameters]
    

[variablelist
  
[[peer][The socket into which the new connection will be accepted.]]

[[peer_endpoint][An endpoint object which will receive the endpoint of the remote peer.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Example]
  


   boost::asio::ip::tcp::acceptor acceptor(io_service);
   ...
   boost::asio::ip::tcp::socket socket(io_service);
   boost::asio::ip::tcp::endpoint endpoint;
   boost::system::error_code ec;
   acceptor.accept(socket, endpoint, ec);
   if (ec)
   {
     // An error occurred.
   }






[endsect]


[endsect]

[section:assign basic_socket_acceptor::assign]

[indexterm2 assign..basic_socket_acceptor] Assigns an existing native acceptor to the acceptor. 

  void ``[link boost_asio.reference.basic_socket_acceptor.assign.overload1 assign]``(
      const protocol_type & protocol,
      const native_type & native_acceptor);

  boost::system::error_code ``[link boost_asio.reference.basic_socket_acceptor.assign.overload2 assign]``(
      const protocol_type & protocol,
      const native_type & native_acceptor,
      boost::system::error_code & ec);


[section:overload1 basic_socket_acceptor::assign (1 of 2 overloads)]

Assigns an existing native acceptor to the acceptor. 

  void assign(
      const protocol_type & protocol,
      const native_type & native_acceptor);



[endsect]



[section:overload2 basic_socket_acceptor::assign (2 of 2 overloads)]

Assigns an existing native acceptor to the acceptor. 

  boost::system::error_code assign(
      const protocol_type & protocol,
      const native_type & native_acceptor,
      boost::system::error_code & ec);



[endsect]


[endsect]

[section:async_accept basic_socket_acceptor::async_accept]

[indexterm2 async_accept..basic_socket_acceptor] Start an asynchronous accept. 

  template<
      typename ``[link boost_asio.reference.SocketService SocketService]``,
      typename ``[link boost_asio.reference.AcceptHandler AcceptHandler]``>
  void ``[link boost_asio.reference.basic_socket_acceptor.async_accept.overload1 async_accept]``(
      basic_socket< protocol_type, SocketService > & peer,
      AcceptHandler handler);

  template<
      typename ``[link boost_asio.reference.SocketService SocketService]``,
      typename ``[link boost_asio.reference.AcceptHandler AcceptHandler]``>
  void ``[link boost_asio.reference.basic_socket_acceptor.async_accept.overload2 async_accept]``(
      basic_socket< protocol_type, SocketService > & peer,
      endpoint_type & peer_endpoint,
      AcceptHandler handler);


[section:overload1 basic_socket_acceptor::async_accept (1 of 2 overloads)]

Start an asynchronous accept. 

  template<
      typename ``[link boost_asio.reference.SocketService SocketService]``,
      typename ``[link boost_asio.reference.AcceptHandler AcceptHandler]``>
  void async_accept(
      basic_socket< protocol_type, SocketService > & peer,
      AcceptHandler handler);


This function is used to asynchronously accept a new connection into a socket. The function call always returns immediately.


[heading Parameters]
    

[variablelist
  
[[peer][The socket into which the new connection will be accepted. Ownership of the peer object is retained by the caller, which must guarantee that it is valid until the handler is called.]]

[[handler][The handler to be called when the accept operation completes. Copies will be made of the handler as required. The function signature of the handler must be: 
``
   void handler(
     const boost::system::error_code& error // Result of operation.
   ); 
``
Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using boost::asio::io\_service::post().]]

]

[heading Example]
  


   void accept_handler(const boost::system::error_code& error)
   {
     if (!error)
     {
       // Accept succeeded.
     }
   }

   ...

   boost::asio::ip::tcp::acceptor acceptor(io_service);
   ...
   boost::asio::ip::tcp::socket socket(io_service);
   acceptor.async_accept(socket, accept_handler);






[endsect]



[section:overload2 basic_socket_acceptor::async_accept (2 of 2 overloads)]

Start an asynchronous accept. 

  template<
      typename ``[link boost_asio.reference.SocketService SocketService]``,
      typename ``[link boost_asio.reference.AcceptHandler AcceptHandler]``>
  void async_accept(
      basic_socket< protocol_type, SocketService > & peer,
      endpoint_type & peer_endpoint,
      AcceptHandler handler);


This function is used to asynchronously accept a new connection into a socket, and additionally obtain the endpoint of the remote peer. The function call always returns immediately.


[heading Parameters]
    

[variablelist
  
[[peer][The socket into which the new connection will be accepted. Ownership of the peer object is retained by the caller, which must guarantee that it is valid until the handler is called.]]

[[peer_endpoint][An endpoint object into which the endpoint of the remote peer will be written. Ownership of the peer\_endpoint object is retained by the caller, which must guarantee that it is valid until the handler is called.]]

[[handler][The handler to be called when the accept operation completes. Copies will be made of the handler as required. The function signature of the handler must be: 
``
   void handler(
     const boost::system::error_code& error // Result of operation.
   ); 
``
Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using boost::asio::io\_service::post(). ]]

]



[endsect]


[endsect]

[section:basic_socket_acceptor basic_socket_acceptor::basic_socket_acceptor]

[indexterm2 basic_socket_acceptor..basic_socket_acceptor] Construct an acceptor without opening it. 

  ``[link boost_asio.reference.basic_socket_acceptor.basic_socket_acceptor.overload1 basic_socket_acceptor]``(
      boost::asio::io_service & io_service);

Construct an open acceptor. 

  ``[link boost_asio.reference.basic_socket_acceptor.basic_socket_acceptor.overload2 basic_socket_acceptor]``(
      boost::asio::io_service & io_service,
      const protocol_type & protocol);

Construct an acceptor opened on the given endpoint. 

  ``[link boost_asio.reference.basic_socket_acceptor.basic_socket_acceptor.overload3 basic_socket_acceptor]``(
      boost::asio::io_service & io_service,
      const endpoint_type & endpoint,
      bool reuse_addr = true);

Construct a basic_socket_acceptor on an existing native acceptor. 

  ``[link boost_asio.reference.basic_socket_acceptor.basic_socket_acceptor.overload4 basic_socket_acceptor]``(
      boost::asio::io_service & io_service,
      const protocol_type & protocol,
      const native_type & native_acceptor);


[section:overload1 basic_socket_acceptor::basic_socket_acceptor (1 of 4 overloads)]

Construct an acceptor without opening it. 

  basic_socket_acceptor(
      boost::asio::io_service & io_service);


This constructor creates an acceptor without opening it to listen for new connections. The open() function must be called before the acceptor can accept new socket connections.


[heading Parameters]
    

[variablelist
  
[[io_service][The io\_service object that the acceptor will use to dispatch handlers for any asynchronous operations performed on the acceptor. ]]

]



[endsect]



[section:overload2 basic_socket_acceptor::basic_socket_acceptor (2 of 4 overloads)]

Construct an open acceptor. 

  basic_socket_acceptor(
      boost::asio::io_service & io_service,
      const protocol_type & protocol);


This constructor creates an acceptor and automatically opens it.


[heading Parameters]
    

[variablelist
  
[[io_service][The io\_service object that the acceptor will use to dispatch handlers for any asynchronous operations performed on the acceptor.]]

[[protocol][An object specifying protocol parameters to be used.]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. ]]

]



[endsect]



[section:overload3 basic_socket_acceptor::basic_socket_acceptor (3 of 4 overloads)]

Construct an acceptor opened on the given endpoint. 

  basic_socket_acceptor(
      boost::asio::io_service & io_service,
      const endpoint_type & endpoint,
      bool reuse_addr = true);


This constructor creates an acceptor and automatically opens it to listen for new connections on the specified endpoint.


[heading Parameters]
    

[variablelist
  
[[io_service][The io\_service object that the acceptor will use to dispatch handlers for any asynchronous operations performed on the acceptor.]]

[[endpoint][An endpoint on the local machine on which the acceptor will listen for new connections.]]

[[reuse_addr][Whether the constructor should set the socket option socket\_base::reuse\_address.]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Remarks]
      
This constructor is equivalent to the following code: 

   basic_socket_acceptor<Protocol> acceptor(io_service);
   acceptor.open(endpoint.protocol());
   if (reuse_addr)
     acceptor.set_option(socket_base::reuse_address(true));
   acceptor.bind(endpoint);
   acceptor.listen(listen_backlog);






[endsect]



[section:overload4 basic_socket_acceptor::basic_socket_acceptor (4 of 4 overloads)]

Construct a basic_socket_acceptor on an existing native acceptor. 

  basic_socket_acceptor(
      boost::asio::io_service & io_service,
      const protocol_type & protocol,
      const native_type & native_acceptor);


This constructor creates an acceptor object to hold an existing native acceptor.


[heading Parameters]
    

[variablelist
  
[[io_service][The io\_service object that the acceptor will use to dispatch handlers for any asynchronous operations performed on the acceptor.]]

[[protocol][An object specifying protocol parameters to be used.]]

[[native_acceptor][A native acceptor.]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. ]]

]



[endsect]


[endsect]

[section:bind basic_socket_acceptor::bind]

[indexterm2 bind..basic_socket_acceptor] Bind the acceptor to the given local endpoint. 

  void ``[link boost_asio.reference.basic_socket_acceptor.bind.overload1 bind]``(
      const endpoint_type & endpoint);

  boost::system::error_code ``[link boost_asio.reference.basic_socket_acceptor.bind.overload2 bind]``(
      const endpoint_type & endpoint,
      boost::system::error_code & ec);


[section:overload1 basic_socket_acceptor::bind (1 of 2 overloads)]

Bind the acceptor to the given local endpoint. 

  void bind(
      const endpoint_type & endpoint);


This function binds the socket acceptor to the specified endpoint on the local machine.


[heading Parameters]
    

[variablelist
  
[[endpoint][An endpoint on the local machine to which the socket acceptor will be bound.]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Example]
  


   boost::asio::ip::tcp::acceptor acceptor(io_service);
   acceptor.open(boost::asio::ip::tcp::v4());
   acceptor.bind(boost::asio::ip::tcp::endpoint(12345));






[endsect]



[section:overload2 basic_socket_acceptor::bind (2 of 2 overloads)]

Bind the acceptor to the given local endpoint. 

  boost::system::error_code bind(
      const endpoint_type & endpoint,
      boost::system::error_code & ec);


This function binds the socket acceptor to the specified endpoint on the local machine.


[heading Parameters]
    

[variablelist
  
[[endpoint][An endpoint on the local machine to which the socket acceptor will be bound.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Example]
  


   boost::asio::ip::tcp::acceptor acceptor(io_service);
   acceptor.open(boost::asio::ip::tcp::v4());
   boost::system::error_code ec;
   acceptor.bind(boost::asio::ip::tcp::endpoint(12345), ec);
   if (ec)
   {
     // An error occurred.
   }






[endsect]


[endsect]


[section:broadcast basic_socket_acceptor::broadcast]


['Inherited from socket_base.]

[indexterm2 broadcast..basic_socket_acceptor] Socket option to permit sending of broadcast messages. 

  typedef implementation_defined broadcast;



Implements the SOL\_SOCKET/SO\_BROADCAST socket option.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::udp::socket socket(io_service); 
   ...
   boost::asio::socket_base::broadcast option(true);
   socket.set_option(option);




Getting the current option value: 

   boost::asio::ip::udp::socket socket(io_service); 
   ...
   boost::asio::socket_base::broadcast option;
   socket.get_option(option);
   bool is_set = option.value();






[endsect]



[section:bytes_readable basic_socket_acceptor::bytes_readable]


['Inherited from socket_base.]

[indexterm2 bytes_readable..basic_socket_acceptor] IO control command to get the amount of data that can be read without blocking. 

  typedef implementation_defined bytes_readable;



Implements the FIONREAD IO control command.


[heading Example]
  


   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::bytes_readable command(true);
   socket.io_control(command);
   std::size_t bytes_readable = command.get();






[endsect]


[section:cancel basic_socket_acceptor::cancel]

[indexterm2 cancel..basic_socket_acceptor] Cancel all asynchronous operations associated with the acceptor. 

  void ``[link boost_asio.reference.basic_socket_acceptor.cancel.overload1 cancel]``();

  boost::system::error_code ``[link boost_asio.reference.basic_socket_acceptor.cancel.overload2 cancel]``(
      boost::system::error_code & ec);


[section:overload1 basic_socket_acceptor::cancel (1 of 2 overloads)]

Cancel all asynchronous operations associated with the acceptor. 

  void cancel();


This function causes all outstanding asynchronous connect, send and receive operations to finish immediately, and the handlers for cancelled operations will be passed the boost::asio::error::operation\_aborted error.


[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. ]]

]



[endsect]



[section:overload2 basic_socket_acceptor::cancel (2 of 2 overloads)]

Cancel all asynchronous operations associated with the acceptor. 

  boost::system::error_code cancel(
      boost::system::error_code & ec);


This function causes all outstanding asynchronous connect, send and receive operations to finish immediately, and the handlers for cancelled operations will be passed the boost::asio::error::operation\_aborted error.


[heading Parameters]
    

[variablelist
  
[[ec][Set to indicate what error occurred, if any. ]]

]



[endsect]


[endsect]

[section:close basic_socket_acceptor::close]

[indexterm2 close..basic_socket_acceptor] Close the acceptor. 

  void ``[link boost_asio.reference.basic_socket_acceptor.close.overload1 close]``();

  boost::system::error_code ``[link boost_asio.reference.basic_socket_acceptor.close.overload2 close]``(
      boost::system::error_code & ec);


[section:overload1 basic_socket_acceptor::close (1 of 2 overloads)]

Close the acceptor. 

  void close();


This function is used to close the acceptor. Any asynchronous accept operations will be cancelled immediately.

A subsequent call to open() is required before the acceptor can again be used to again perform socket accept operations.


[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. ]]

]



[endsect]



[section:overload2 basic_socket_acceptor::close (2 of 2 overloads)]

Close the acceptor. 

  boost::system::error_code close(
      boost::system::error_code & ec);


This function is used to close the acceptor. Any asynchronous accept operations will be cancelled immediately.

A subsequent call to open() is required before the acceptor can again be used to again perform socket accept operations.


[heading Parameters]
    

[variablelist
  
[[ec][Set to indicate what error occurred, if any.]]

]

[heading Example]
  


   boost::asio::ip::tcp::acceptor acceptor(io_service);
   ...
   boost::system::error_code ec;
   acceptor.close(ec);
   if (ec)
   {
     // An error occurred.
   }






[endsect]


[endsect]


[section:debug basic_socket_acceptor::debug]


['Inherited from socket_base.]

[indexterm2 debug..basic_socket_acceptor] Socket option to enable socket-level debugging. 

  typedef implementation_defined debug;



Implements the SOL\_SOCKET/SO\_DEBUG socket option.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::debug option(true);
   socket.set_option(option);




Getting the current option value: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::debug option;
   socket.get_option(option);
   bool is_set = option.value();






[endsect]



[section:do_not_route basic_socket_acceptor::do_not_route]


['Inherited from socket_base.]

[indexterm2 do_not_route..basic_socket_acceptor] Socket option to prevent routing, use local interfaces only. 

  typedef implementation_defined do_not_route;



Implements the SOL\_SOCKET/SO\_DONTROUTE socket option.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::udp::socket socket(io_service); 
   ...
   boost::asio::socket_base::do_not_route option(true);
   socket.set_option(option);




Getting the current option value: 

   boost::asio::ip::udp::socket socket(io_service); 
   ...
   boost::asio::socket_base::do_not_route option;
   socket.get_option(option);
   bool is_set = option.value();






[endsect]



[section:enable_connection_aborted basic_socket_acceptor::enable_connection_aborted]


['Inherited from socket_base.]

[indexterm2 enable_connection_aborted..basic_socket_acceptor] Socket option to report aborted connections on accept. 

  typedef implementation_defined enable_connection_aborted;



Implements a custom socket option that determines whether or not an accept operation is permitted to fail with boost::asio::error::connection\_aborted. By default the option is false.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::tcp::acceptor acceptor(io_service); 
   ...
   boost::asio::socket_base::enable_connection_aborted option(true);
   acceptor.set_option(option);




Getting the current option value: 

   boost::asio::ip::tcp::acceptor acceptor(io_service); 
   ...
   boost::asio::socket_base::enable_connection_aborted option;
   acceptor.get_option(option);
   bool is_set = option.value();






[endsect]



[section:endpoint_type basic_socket_acceptor::endpoint_type]

[indexterm2 endpoint_type..basic_socket_acceptor] The endpoint type. 

  typedef Protocol::endpoint endpoint_type;




[endsect]



[section:get_io_service basic_socket_acceptor::get_io_service]


['Inherited from basic_io_object.]

[indexterm2 get_io_service..basic_socket_acceptor] Get the io_service associated with the object. 

  boost::asio::io_service & get_io_service();


This function may be used to obtain the io_service object that the I/O object uses to dispatch handlers for asynchronous operations.


[heading Return Value]
      
A reference to the io_service object that the I/O object will use to dispatch handlers. Ownership is not transferred to the caller. 



[endsect]


[section:get_option basic_socket_acceptor::get_option]

[indexterm2 get_option..basic_socket_acceptor] Get an option from the acceptor. 

  template<
      typename ``[link boost_asio.reference.GettableSocketOption GettableSocketOption]``>
  void ``[link boost_asio.reference.basic_socket_acceptor.get_option.overload1 get_option]``(
      GettableSocketOption & option);

  template<
      typename ``[link boost_asio.reference.GettableSocketOption GettableSocketOption]``>
  boost::system::error_code ``[link boost_asio.reference.basic_socket_acceptor.get_option.overload2 get_option]``(
      GettableSocketOption & option,
      boost::system::error_code & ec);


[section:overload1 basic_socket_acceptor::get_option (1 of 2 overloads)]

Get an option from the acceptor. 

  template<
      typename ``[link boost_asio.reference.GettableSocketOption GettableSocketOption]``>
  void get_option(
      GettableSocketOption & option);


This function is used to get the current value of an option on the acceptor.


[heading Parameters]
    

[variablelist
  
[[option][The option value to be obtained from the acceptor.]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Example]
  
Getting the value of the SOL\_SOCKET/SO\_REUSEADDR option: 

   boost::asio::ip::tcp::acceptor acceptor(io_service);
   ...
   boost::asio::ip::tcp::acceptor::reuse_address option;
   acceptor.get_option(option);
   bool is_set = option.get();






[endsect]



[section:overload2 basic_socket_acceptor::get_option (2 of 2 overloads)]

Get an option from the acceptor. 

  template<
      typename ``[link boost_asio.reference.GettableSocketOption GettableSocketOption]``>
  boost::system::error_code get_option(
      GettableSocketOption & option,
      boost::system::error_code & ec);


This function is used to get the current value of an option on the acceptor.


[heading Parameters]
    

[variablelist
  
[[option][The option value to be obtained from the acceptor.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Example]
  
Getting the value of the SOL\_SOCKET/SO\_REUSEADDR option: 

   boost::asio::ip::tcp::acceptor acceptor(io_service);
   ...
   boost::asio::ip::tcp::acceptor::reuse_address option;
   boost::system::error_code ec;
   acceptor.get_option(option, ec);
   if (ec)
   {
     // An error occurred.
   }
   bool is_set = option.get();






[endsect]


[endsect]


[section:implementation basic_socket_acceptor::implementation]


['Inherited from basic_io_object.]

[indexterm2 implementation..basic_socket_acceptor] The underlying implementation of the I/O object. 

  implementation_type implementation;



[endsect]



[section:implementation_type basic_socket_acceptor::implementation_type]


['Inherited from basic_io_object.]

[indexterm2 implementation_type..basic_socket_acceptor] The underlying implementation type of I/O object. 

  typedef service_type::implementation_type implementation_type;




[endsect]



[section:io_service basic_socket_acceptor::io_service]


['Inherited from basic_io_object.]

[indexterm2 io_service..basic_socket_acceptor] (Deprecated: use get_io_service().) Get the io_service associated with the object. 

  boost::asio::io_service & io_service();


This function may be used to obtain the io_service object that the I/O object uses to dispatch handlers for asynchronous operations.


[heading Return Value]
      
A reference to the io_service object that the I/O object will use to dispatch handlers. Ownership is not transferred to the caller. 



[endsect]



[section:is_open basic_socket_acceptor::is_open]

[indexterm2 is_open..basic_socket_acceptor] Determine whether the acceptor is open. 

  bool is_open() const;



[endsect]



[section:keep_alive basic_socket_acceptor::keep_alive]


['Inherited from socket_base.]

[indexterm2 keep_alive..basic_socket_acceptor] Socket option to send keep-alives. 

  typedef implementation_defined keep_alive;



Implements the SOL\_SOCKET/SO\_KEEPALIVE socket option.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::keep_alive option(true);
   socket.set_option(option);




Getting the current option value: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::keep_alive option;
   socket.get_option(option);
   bool is_set = option.value();






[endsect]



[section:linger basic_socket_acceptor::linger]


['Inherited from socket_base.]

[indexterm2 linger..basic_socket_acceptor] Socket option to specify whether the socket lingers on close if unsent data is present. 

  typedef implementation_defined linger;



Implements the SOL\_SOCKET/SO\_LINGER socket option.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::linger option(true, 30);
   socket.set_option(option);




Getting the current option value: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::linger option;
   socket.get_option(option);
   bool is_set = option.enabled();
   unsigned short timeout = option.timeout();






[endsect]


[section:listen basic_socket_acceptor::listen]

[indexterm2 listen..basic_socket_acceptor] Place the acceptor into the state where it will listen for new connections. 

  void ``[link boost_asio.reference.basic_socket_acceptor.listen.overload1 listen]``(
      int backlog = socket_base::max_connections);

  boost::system::error_code ``[link boost_asio.reference.basic_socket_acceptor.listen.overload2 listen]``(
      int backlog,
      boost::system::error_code & ec);


[section:overload1 basic_socket_acceptor::listen (1 of 2 overloads)]

Place the acceptor into the state where it will listen for new connections. 

  void listen(
      int backlog = socket_base::max_connections);


This function puts the socket acceptor into the state where it may accept new connections.


[heading Parameters]
    

[variablelist
  
[[backlog][The maximum length of the queue of pending connections.]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. ]]

]



[endsect]



[section:overload2 basic_socket_acceptor::listen (2 of 2 overloads)]

Place the acceptor into the state where it will listen for new connections. 

  boost::system::error_code listen(
      int backlog,
      boost::system::error_code & ec);


This function puts the socket acceptor into the state where it may accept new connections.


[heading Parameters]
    

[variablelist
  
[[backlog][The maximum length of the queue of pending connections.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Example]
  


   boost::asio::ip::tcp::acceptor acceptor(io_service);
   ...
   boost::system::error_code ec;
   acceptor.listen(boost::asio::socket_base::max_connections, ec);
   if (ec)
   {
     // An error occurred.
   }






[endsect]


[endsect]

[section:local_endpoint basic_socket_acceptor::local_endpoint]

[indexterm2 local_endpoint..basic_socket_acceptor] Get the local endpoint of the acceptor. 

  endpoint_type ``[link boost_asio.reference.basic_socket_acceptor.local_endpoint.overload1 local_endpoint]``() const;

  endpoint_type ``[link boost_asio.reference.basic_socket_acceptor.local_endpoint.overload2 local_endpoint]``(
      boost::system::error_code & ec) const;


[section:overload1 basic_socket_acceptor::local_endpoint (1 of 2 overloads)]

Get the local endpoint of the acceptor. 

  endpoint_type local_endpoint() const;


This function is used to obtain the locally bound endpoint of the acceptor.


[heading Return Value]
      
An object that represents the local endpoint of the acceptor.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Example]
  


   boost::asio::ip::tcp::acceptor acceptor(io_service);
   ...
   boost::asio::ip::tcp::endpoint endpoint = acceptor.local_endpoint();






[endsect]



[section:overload2 basic_socket_acceptor::local_endpoint (2 of 2 overloads)]

Get the local endpoint of the acceptor. 

  endpoint_type local_endpoint(
      boost::system::error_code & ec) const;


This function is used to obtain the locally bound endpoint of the acceptor.


[heading Parameters]
    

[variablelist
  
[[ec][Set to indicate what error occurred, if any.]]

]

[heading Return Value]
      
An object that represents the local endpoint of the acceptor. Returns a default-constructed endpoint object if an error occurred and the error handler did not throw an exception.

[heading Example]
  


   boost::asio::ip::tcp::acceptor acceptor(io_service);
   ...
   boost::system::error_code ec;
   boost::asio::ip::tcp::endpoint endpoint = acceptor.local_endpoint(ec);
   if (ec)
   {
     // An error occurred.
   }






[endsect]


[endsect]


[section:max_connections basic_socket_acceptor::max_connections]


['Inherited from socket_base.]

[indexterm2 max_connections..basic_socket_acceptor] The maximum length of the queue of pending incoming connections. 

  static const int max_connections = implementation_defined;



[endsect]



[section:message_do_not_route basic_socket_acceptor::message_do_not_route]


['Inherited from socket_base.]

[indexterm2 message_do_not_route..basic_socket_acceptor] Specify that the data should not be subject to routing. 

  static const int message_do_not_route = implementation_defined;



[endsect]



[section:message_flags basic_socket_acceptor::message_flags]


['Inherited from socket_base.]

[indexterm2 message_flags..basic_socket_acceptor] Bitmask type for flags that can be passed to send and receive operations. 

  typedef int message_flags;




[endsect]



[section:message_out_of_band basic_socket_acceptor::message_out_of_band]


['Inherited from socket_base.]

[indexterm2 message_out_of_band..basic_socket_acceptor] Process out-of-band data. 

  static const int message_out_of_band = implementation_defined;



[endsect]



[section:message_peek basic_socket_acceptor::message_peek]


['Inherited from socket_base.]

[indexterm2 message_peek..basic_socket_acceptor] Peek at incoming data without removing it from the input queue. 

  static const int message_peek = implementation_defined;



[endsect]



[section:native basic_socket_acceptor::native]

[indexterm2 native..basic_socket_acceptor] Get the native acceptor representation. 

  native_type native();


This function may be used to obtain the underlying representation of the acceptor. This is intended to allow access to native acceptor functionality that is not otherwise provided. 


[endsect]



[section:native_type basic_socket_acceptor::native_type]

[indexterm2 native_type..basic_socket_acceptor] The native representation of an acceptor. 

  typedef SocketAcceptorService::native_type native_type;




[endsect]



[section:non_blocking_io basic_socket_acceptor::non_blocking_io]


['Inherited from socket_base.]

[indexterm2 non_blocking_io..basic_socket_acceptor] IO control command to set the blocking mode of the socket. 

  typedef implementation_defined non_blocking_io;



Implements the FIONBIO IO control command.


[heading Example]
  


   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::non_blocking_io command(true);
   socket.io_control(command);






[endsect]


[section:open basic_socket_acceptor::open]

[indexterm2 open..basic_socket_acceptor] Open the acceptor using the specified protocol. 

  void ``[link boost_asio.reference.basic_socket_acceptor.open.overload1 open]``(
      const protocol_type & protocol = protocol_type());

  boost::system::error_code ``[link boost_asio.reference.basic_socket_acceptor.open.overload2 open]``(
      const protocol_type & protocol,
      boost::system::error_code & ec);


[section:overload1 basic_socket_acceptor::open (1 of 2 overloads)]

Open the acceptor using the specified protocol. 

  void open(
      const protocol_type & protocol = protocol_type());


This function opens the socket acceptor so that it will use the specified protocol.


[heading Parameters]
    

[variablelist
  
[[protocol][An object specifying which protocol is to be used.]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Example]
  


   boost::asio::ip::tcp::acceptor acceptor(io_service);
   acceptor.open(boost::asio::ip::tcp::v4());






[endsect]



[section:overload2 basic_socket_acceptor::open (2 of 2 overloads)]

Open the acceptor using the specified protocol. 

  boost::system::error_code open(
      const protocol_type & protocol,
      boost::system::error_code & ec);


This function opens the socket acceptor so that it will use the specified protocol.


[heading Parameters]
    

[variablelist
  
[[protocol][An object specifying which protocol is to be used.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Example]
  


   boost::asio::ip::tcp::acceptor acceptor(io_service);
   boost::system::error_code ec;
   acceptor.open(boost::asio::ip::tcp::v4(), ec);
   if (ec)
   {
     // An error occurred.
   }






[endsect]


[endsect]


[section:protocol_type basic_socket_acceptor::protocol_type]

[indexterm2 protocol_type..basic_socket_acceptor] The protocol type. 

  typedef Protocol protocol_type;




[endsect]



[section:receive_buffer_size basic_socket_acceptor::receive_buffer_size]


['Inherited from socket_base.]

[indexterm2 receive_buffer_size..basic_socket_acceptor] Socket option for the receive buffer size of a socket. 

  typedef implementation_defined receive_buffer_size;



Implements the SOL\_SOCKET/SO\_RCVBUF socket option.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::receive_buffer_size option(8192);
   socket.set_option(option);




Getting the current option value: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::receive_buffer_size option;
   socket.get_option(option);
   int size = option.value();






[endsect]



[section:receive_low_watermark basic_socket_acceptor::receive_low_watermark]


['Inherited from socket_base.]

[indexterm2 receive_low_watermark..basic_socket_acceptor] Socket option for the receive low watermark. 

  typedef implementation_defined receive_low_watermark;



Implements the SOL\_SOCKET/SO\_RCVLOWAT socket option.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::receive_low_watermark option(1024);
   socket.set_option(option);




Getting the current option value: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::receive_low_watermark option;
   socket.get_option(option);
   int size = option.value();






[endsect]



[section:reuse_address basic_socket_acceptor::reuse_address]


['Inherited from socket_base.]

[indexterm2 reuse_address..basic_socket_acceptor] Socket option to allow the socket to be bound to an address that is already in use. 

  typedef implementation_defined reuse_address;



Implements the SOL\_SOCKET/SO\_REUSEADDR socket option.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::tcp::acceptor acceptor(io_service); 
   ...
   boost::asio::socket_base::reuse_address option(true);
   acceptor.set_option(option);




Getting the current option value: 

   boost::asio::ip::tcp::acceptor acceptor(io_service); 
   ...
   boost::asio::socket_base::reuse_address option;
   acceptor.get_option(option);
   bool is_set = option.value();






[endsect]



[section:send_buffer_size basic_socket_acceptor::send_buffer_size]


['Inherited from socket_base.]

[indexterm2 send_buffer_size..basic_socket_acceptor] Socket option for the send buffer size of a socket. 

  typedef implementation_defined send_buffer_size;



Implements the SOL\_SOCKET/SO\_SNDBUF socket option.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::send_buffer_size option(8192);
   socket.set_option(option);




Getting the current option value: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::send_buffer_size option;
   socket.get_option(option);
   int size = option.value();






[endsect]



[section:send_low_watermark basic_socket_acceptor::send_low_watermark]


['Inherited from socket_base.]

[indexterm2 send_low_watermark..basic_socket_acceptor] Socket option for the send low watermark. 

  typedef implementation_defined send_low_watermark;



Implements the SOL\_SOCKET/SO\_SNDLOWAT socket option.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::send_low_watermark option(1024);
   socket.set_option(option);




Getting the current option value: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::send_low_watermark option;
   socket.get_option(option);
   int size = option.value();






[endsect]



[section:service basic_socket_acceptor::service]


['Inherited from basic_io_object.]

[indexterm2 service..basic_socket_acceptor] The service associated with the I/O object. 

  service_type & service;



[endsect]



[section:service_type basic_socket_acceptor::service_type]


['Inherited from basic_io_object.]

[indexterm2 service_type..basic_socket_acceptor] The type of the service that will be used to provide I/O operations. 

  typedef SocketAcceptorService service_type;




[endsect]


[section:set_option basic_socket_acceptor::set_option]

[indexterm2 set_option..basic_socket_acceptor] Set an option on the acceptor. 

  template<
      typename ``[link boost_asio.reference.SettableSocketOption SettableSocketOption]``>
  void ``[link boost_asio.reference.basic_socket_acceptor.set_option.overload1 set_option]``(
      const SettableSocketOption & option);

  template<
      typename ``[link boost_asio.reference.SettableSocketOption SettableSocketOption]``>
  boost::system::error_code ``[link boost_asio.reference.basic_socket_acceptor.set_option.overload2 set_option]``(
      const SettableSocketOption & option,
      boost::system::error_code & ec);


[section:overload1 basic_socket_acceptor::set_option (1 of 2 overloads)]

Set an option on the acceptor. 

  template<
      typename ``[link boost_asio.reference.SettableSocketOption SettableSocketOption]``>
  void set_option(
      const SettableSocketOption & option);


This function is used to set an option on the acceptor.


[heading Parameters]
    

[variablelist
  
[[option][The new option value to be set on the acceptor.]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Example]
  
Setting the SOL\_SOCKET/SO\_REUSEADDR option: 

   boost::asio::ip::tcp::acceptor acceptor(io_service);
   ...
   boost::asio::ip::tcp::acceptor::reuse_address option(true);
   acceptor.set_option(option);






[endsect]



[section:overload2 basic_socket_acceptor::set_option (2 of 2 overloads)]

Set an option on the acceptor. 

  template<
      typename ``[link boost_asio.reference.SettableSocketOption SettableSocketOption]``>
  boost::system::error_code set_option(
      const SettableSocketOption & option,
      boost::system::error_code & ec);


This function is used to set an option on the acceptor.


[heading Parameters]
    

[variablelist
  
[[option][The new option value to be set on the acceptor.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Example]
  
Setting the SOL\_SOCKET/SO\_REUSEADDR option: 

   boost::asio::ip::tcp::acceptor acceptor(io_service);
   ...
   boost::asio::ip::tcp::acceptor::reuse_address option(true);
   boost::system::error_code ec;
   acceptor.set_option(option, ec);
   if (ec)
   {
     // An error occurred.
   }






[endsect]


[endsect]


[section:shutdown_type basic_socket_acceptor::shutdown_type]


['Inherited from socket_base.]

[indexterm2 shutdown_type..basic_socket_acceptor] Different ways a socket may be shutdown. 

  enum shutdown_type

[heading Values]
[variablelist

  [
    [shutdown_receive]
    [Shutdown the receive side of the socket. ]
  ]

  [
    [shutdown_send]
    [Shutdown the send side of the socket. ]
  ]

  [
    [shutdown_both]
    [Shutdown both send and receive on the socket. ]
  ]

]



[endsect]



[endsect]

[section:basic_socket_iostream basic_socket_iostream]

Iostream interface for a socket. 

  template<
      typename ``[link boost_asio.reference.Protocol Protocol]``,
      typename ``[link boost_asio.reference.StreamSocketService StreamSocketService]`` = stream_socket_service<Protocol>>
  class basic_socket_iostream


[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_socket_iostream.basic_socket_iostream [*basic_socket_iostream]]]
    [Construct a basic_socket_iostream without establishing a connection. 

     Establish a connection to an endpoint corresponding to a resolver query. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket_iostream.close [*close]]]
    [Close the connection. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket_iostream.connect [*connect]]]
    [Establish a connection to an endpoint corresponding to a resolver query. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket_iostream.rdbuf [*rdbuf]]]
    [Return a pointer to the underlying streambuf. ]
  ]
  
]

[section:basic_socket_iostream basic_socket_iostream::basic_socket_iostream]

[indexterm2 basic_socket_iostream..basic_socket_iostream] Construct a basic_socket_iostream without establishing a connection. 

  ``[link boost_asio.reference.basic_socket_iostream.basic_socket_iostream.overload1 basic_socket_iostream]``();

Establish a connection to an endpoint corresponding to a resolver query. 

  template<
      typename T1,
      ... ,
      typename TN>
  ``[link boost_asio.reference.basic_socket_iostream.basic_socket_iostream.overload2 basic_socket_iostream]``(
      T1 t1,
      ... ,
      TN tn);


[section:overload1 basic_socket_iostream::basic_socket_iostream (1 of 2 overloads)]

Construct a basic_socket_iostream without establishing a connection. 

  basic_socket_iostream();



[endsect]



[section:overload2 basic_socket_iostream::basic_socket_iostream (2 of 2 overloads)]

Establish a connection to an endpoint corresponding to a resolver query. 

  template<
      typename T1,
      ... ,
      typename TN>
  basic_socket_iostream(
      T1 t1,
      ... ,
      TN tn);


This constructor automatically establishes a connection based on the supplied resolver query parameters. The arguments are used to construct a resolver query object. 


[endsect]


[endsect]


[section:close basic_socket_iostream::close]

[indexterm2 close..basic_socket_iostream] Close the connection. 

  void close();



[endsect]



[section:connect basic_socket_iostream::connect]

[indexterm2 connect..basic_socket_iostream] Establish a connection to an endpoint corresponding to a resolver query. 

  template<
      typename T1,
      ... ,
      typename TN>
  void connect(
      T1 t1,
      ... ,
      TN tn);


This function automatically establishes a connection based on the supplied resolver query parameters. The arguments are used to construct a resolver query object. 


[endsect]



[section:rdbuf basic_socket_iostream::rdbuf]

[indexterm2 rdbuf..basic_socket_iostream] Return a pointer to the underlying streambuf. 

  basic_socket_streambuf< Protocol, StreamSocketService > * rdbuf() const;



[endsect]



[endsect]

[section:basic_socket_streambuf basic_socket_streambuf]

Iostream streambuf for a socket. 

  template<
      typename ``[link boost_asio.reference.Protocol Protocol]``,
      typename ``[link boost_asio.reference.StreamSocketService StreamSocketService]`` = stream_socket_service<Protocol>>
  class basic_socket_streambuf :
    public basic_socket< Protocol, StreamSocketService >


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.basic_socket_streambuf.broadcast [*broadcast]]]
    [Socket option to permit sending of broadcast messages. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_streambuf.bytes_readable [*bytes_readable]]]
    [IO control command to get the amount of data that can be read without blocking. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_streambuf.debug [*debug]]]
    [Socket option to enable socket-level debugging. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_streambuf.do_not_route [*do_not_route]]]
    [Socket option to prevent routing, use local interfaces only. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_streambuf.enable_connection_aborted [*enable_connection_aborted]]]
    [Socket option to report aborted connections on accept. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_streambuf.endpoint_type [*endpoint_type]]]
    [The endpoint type. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_streambuf.implementation_type [*implementation_type]]]
    [The underlying implementation type of I/O object. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_streambuf.keep_alive [*keep_alive]]]
    [Socket option to send keep-alives. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_streambuf.linger [*linger]]]
    [Socket option to specify whether the socket lingers on close if unsent data is present. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_streambuf.lowest_layer_type [*lowest_layer_type]]]
    [A basic_socket is always the lowest layer. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_streambuf.message_flags [*message_flags]]]
    [Bitmask type for flags that can be passed to send and receive operations. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_streambuf.native_type [*native_type]]]
    [The native representation of a socket. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_streambuf.non_blocking_io [*non_blocking_io]]]
    [IO control command to set the blocking mode of the socket. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_streambuf.protocol_type [*protocol_type]]]
    [The protocol type. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_streambuf.receive_buffer_size [*receive_buffer_size]]]
    [Socket option for the receive buffer size of a socket. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_streambuf.receive_low_watermark [*receive_low_watermark]]]
    [Socket option for the receive low watermark. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_streambuf.reuse_address [*reuse_address]]]
    [Socket option to allow the socket to be bound to an address that is already in use. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_streambuf.send_buffer_size [*send_buffer_size]]]
    [Socket option for the send buffer size of a socket. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_streambuf.send_low_watermark [*send_low_watermark]]]
    [Socket option for the send low watermark. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_streambuf.service_type [*service_type]]]
    [The type of the service that will be used to provide I/O operations. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_streambuf.shutdown_type [*shutdown_type]]]
    [Different ways a socket may be shutdown. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_socket_streambuf.assign [*assign]]]
    [Assign an existing native socket to the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket_streambuf.async_connect [*async_connect]]]
    [Start an asynchronous connect. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket_streambuf.at_mark [*at_mark]]]
    [Determine whether the socket is at the out-of-band data mark. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket_streambuf.available [*available]]]
    [Determine the number of bytes available for reading. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket_streambuf.basic_socket_streambuf [*basic_socket_streambuf]]]
    [Construct a basic_socket_streambuf without establishing a connection. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket_streambuf.bind [*bind]]]
    [Bind the socket to the given local endpoint. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket_streambuf.cancel [*cancel]]]
    [Cancel all asynchronous operations associated with the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket_streambuf.close [*close]]]
    [Close the connection. 

     Close the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket_streambuf.connect [*connect]]]
    [Establish a connection. 

     Connect the socket to the specified endpoint. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket_streambuf.get_io_service [*get_io_service]]]
    [Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket_streambuf.get_option [*get_option]]]
    [Get an option from the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket_streambuf.io_control [*io_control]]]
    [Perform an IO control command on the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket_streambuf.io_service [*io_service]]]
    [(Deprecated: use get_io_service().) Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket_streambuf.is_open [*is_open]]]
    [Determine whether the socket is open. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket_streambuf.local_endpoint [*local_endpoint]]]
    [Get the local endpoint of the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket_streambuf.lowest_layer [*lowest_layer]]]
    [Get a reference to the lowest layer. 

     Get a const reference to the lowest layer. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket_streambuf.native [*native]]]
    [Get the native socket representation. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket_streambuf.open [*open]]]
    [Open the socket using the specified protocol. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket_streambuf.remote_endpoint [*remote_endpoint]]]
    [Get the remote endpoint of the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket_streambuf.set_option [*set_option]]]
    [Set an option on the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket_streambuf.shutdown [*shutdown]]]
    [Disable sends or receives on the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket_streambuf._basic_socket_streambuf [*~basic_socket_streambuf]]]
    [Destructor flushes buffered data. ]
  ]
  
]

[heading Protected Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_socket_streambuf.overflow [*overflow]]]
    []
  ]
  
  [
    [[link boost_asio.reference.basic_socket_streambuf.setbuf [*setbuf]]]
    []
  ]
  
  [
    [[link boost_asio.reference.basic_socket_streambuf.sync [*sync]]]
    []
  ]
  
  [
    [[link boost_asio.reference.basic_socket_streambuf.underflow [*underflow]]]
    []
  ]
  
]

[heading Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_socket_streambuf.max_connections [*max_connections]]]
    [The maximum length of the queue of pending incoming connections. ]
  ]

  [
    [[link boost_asio.reference.basic_socket_streambuf.message_do_not_route [*message_do_not_route]]]
    [Specify that the data should not be subject to routing. ]
  ]

  [
    [[link boost_asio.reference.basic_socket_streambuf.message_out_of_band [*message_out_of_band]]]
    [Process out-of-band data. ]
  ]

  [
    [[link boost_asio.reference.basic_socket_streambuf.message_peek [*message_peek]]]
    [Peek at incoming data without removing it from the input queue. ]
  ]

]

[heading Protected Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_socket_streambuf.implementation [*implementation]]]
    [The underlying implementation of the I/O object. ]
  ]

  [
    [[link boost_asio.reference.basic_socket_streambuf.service [*service]]]
    [The service associated with the I/O object. ]
  ]

]

[section:assign basic_socket_streambuf::assign]

[indexterm2 assign..basic_socket_streambuf] Assign an existing native socket to the socket. 

  void ``[link boost_asio.reference.basic_socket_streambuf.assign.overload1 assign]``(
      const protocol_type & protocol,
      const native_type & native_socket);

  boost::system::error_code ``[link boost_asio.reference.basic_socket_streambuf.assign.overload2 assign]``(
      const protocol_type & protocol,
      const native_type & native_socket,
      boost::system::error_code & ec);


[section:overload1 basic_socket_streambuf::assign (1 of 2 overloads)]


['Inherited from basic_socket.]

Assign an existing native socket to the socket. 

  void assign(
      const protocol_type & protocol,
      const native_type & native_socket);



[endsect]



[section:overload2 basic_socket_streambuf::assign (2 of 2 overloads)]


['Inherited from basic_socket.]

Assign an existing native socket to the socket. 

  boost::system::error_code assign(
      const protocol_type & protocol,
      const native_type & native_socket,
      boost::system::error_code & ec);



[endsect]


[endsect]


[section:async_connect basic_socket_streambuf::async_connect]


['Inherited from basic_socket.]

[indexterm2 async_connect..basic_socket_streambuf] Start an asynchronous connect. 

  void async_connect(
      const endpoint_type & peer_endpoint,
      ConnectHandler handler);


This function is used to asynchronously connect a socket to the specified remote endpoint. The function call always returns immediately.

The socket is automatically opened if it is not already open. If the connect fails, and the socket was automatically opened, the socket is not returned to the closed state.


[heading Parameters]
    

[variablelist
  
[[peer_endpoint][The remote endpoint to which the socket will be connected. Copies will be made of the endpoint object as required.]]

[[handler][The handler to be called when the connection operation completes. Copies will be made of the handler as required. The function signature of the handler must be: 
``
   void handler(
     const boost::system::error_code& error // Result of operation
   ); 
``
Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using boost::asio::io\_service::post().]]

]

[heading Example]
  


   void connect_handler(const boost::system::error_code& error)
   {
     if (!error)
     {
       // Connect succeeded.
     }
   }

   ...

   boost::asio::ip::tcp::socket socket(io_service);
   boost::asio::ip::tcp::endpoint endpoint(
       boost::asio::ip::address::from_string("1.2.3.4"), 12345);
   socket.async_connect(endpoint, connect_handler);






[endsect]


[section:at_mark basic_socket_streambuf::at_mark]

[indexterm2 at_mark..basic_socket_streambuf] Determine whether the socket is at the out-of-band data mark. 

  bool ``[link boost_asio.reference.basic_socket_streambuf.at_mark.overload1 at_mark]``() const;

  bool ``[link boost_asio.reference.basic_socket_streambuf.at_mark.overload2 at_mark]``(
      boost::system::error_code & ec) const;


[section:overload1 basic_socket_streambuf::at_mark (1 of 2 overloads)]


['Inherited from basic_socket.]

Determine whether the socket is at the out-of-band data mark. 

  bool at_mark() const;


This function is used to check whether the socket input is currently positioned at the out-of-band data mark.


[heading Return Value]
      
A bool indicating whether the socket is at the out-of-band data mark.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. ]]

]



[endsect]



[section:overload2 basic_socket_streambuf::at_mark (2 of 2 overloads)]


['Inherited from basic_socket.]

Determine whether the socket is at the out-of-band data mark. 

  bool at_mark(
      boost::system::error_code & ec) const;


This function is used to check whether the socket input is currently positioned at the out-of-band data mark.


[heading Parameters]
    

[variablelist
  
[[ec][Set to indicate what error occurred, if any.]]

]

[heading Return Value]
      
A bool indicating whether the socket is at the out-of-band data mark. 



[endsect]


[endsect]

[section:available basic_socket_streambuf::available]

[indexterm2 available..basic_socket_streambuf] Determine the number of bytes available for reading. 

  std::size_t ``[link boost_asio.reference.basic_socket_streambuf.available.overload1 available]``() const;

  std::size_t ``[link boost_asio.reference.basic_socket_streambuf.available.overload2 available]``(
      boost::system::error_code & ec) const;


[section:overload1 basic_socket_streambuf::available (1 of 2 overloads)]


['Inherited from basic_socket.]

Determine the number of bytes available for reading. 

  std::size_t available() const;


This function is used to determine the number of bytes that may be read without blocking.


[heading Return Value]
      
The number of bytes that may be read without blocking, or 0 if an error occurs.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. ]]

]



[endsect]



[section:overload2 basic_socket_streambuf::available (2 of 2 overloads)]


['Inherited from basic_socket.]

Determine the number of bytes available for reading. 

  std::size_t available(
      boost::system::error_code & ec) const;


This function is used to determine the number of bytes that may be read without blocking.


[heading Parameters]
    

[variablelist
  
[[ec][Set to indicate what error occurred, if any.]]

]

[heading Return Value]
      
The number of bytes that may be read without blocking, or 0 if an error occurs. 



[endsect]


[endsect]


[section:basic_socket_streambuf basic_socket_streambuf::basic_socket_streambuf]

[indexterm2 basic_socket_streambuf..basic_socket_streambuf] Construct a basic_socket_streambuf without establishing a connection. 

  basic_socket_streambuf();



[endsect]


[section:bind basic_socket_streambuf::bind]

[indexterm2 bind..basic_socket_streambuf] Bind the socket to the given local endpoint. 

  void ``[link boost_asio.reference.basic_socket_streambuf.bind.overload1 bind]``(
      const endpoint_type & endpoint);

  boost::system::error_code ``[link boost_asio.reference.basic_socket_streambuf.bind.overload2 bind]``(
      const endpoint_type & endpoint,
      boost::system::error_code & ec);


[section:overload1 basic_socket_streambuf::bind (1 of 2 overloads)]


['Inherited from basic_socket.]

Bind the socket to the given local endpoint. 

  void bind(
      const endpoint_type & endpoint);


This function binds the socket to the specified endpoint on the local machine.


[heading Parameters]
    

[variablelist
  
[[endpoint][An endpoint on the local machine to which the socket will be bound.]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Example]
  


   boost::asio::ip::tcp::socket socket(io_service);
   socket.open(boost::asio::ip::tcp::v4());
   socket.bind(boost::asio::ip::tcp::endpoint(
         boost::asio::ip::tcp::v4(), 12345));






[endsect]



[section:overload2 basic_socket_streambuf::bind (2 of 2 overloads)]


['Inherited from basic_socket.]

Bind the socket to the given local endpoint. 

  boost::system::error_code bind(
      const endpoint_type & endpoint,
      boost::system::error_code & ec);


This function binds the socket to the specified endpoint on the local machine.


[heading Parameters]
    

[variablelist
  
[[endpoint][An endpoint on the local machine to which the socket will be bound.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Example]
  


   boost::asio::ip::tcp::socket socket(io_service);
   socket.open(boost::asio::ip::tcp::v4());
   boost::system::error_code ec;
   socket.bind(boost::asio::ip::tcp::endpoint(
         boost::asio::ip::tcp::v4(), 12345), ec);
   if (ec)
   {
     // An error occurred.
   }






[endsect]


[endsect]


[section:broadcast basic_socket_streambuf::broadcast]


['Inherited from socket_base.]

[indexterm2 broadcast..basic_socket_streambuf] Socket option to permit sending of broadcast messages. 

  typedef implementation_defined broadcast;



Implements the SOL\_SOCKET/SO\_BROADCAST socket option.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::udp::socket socket(io_service); 
   ...
   boost::asio::socket_base::broadcast option(true);
   socket.set_option(option);




Getting the current option value: 

   boost::asio::ip::udp::socket socket(io_service); 
   ...
   boost::asio::socket_base::broadcast option;
   socket.get_option(option);
   bool is_set = option.value();






[endsect]



[section:bytes_readable basic_socket_streambuf::bytes_readable]


['Inherited from socket_base.]

[indexterm2 bytes_readable..basic_socket_streambuf] IO control command to get the amount of data that can be read without blocking. 

  typedef implementation_defined bytes_readable;



Implements the FIONREAD IO control command.


[heading Example]
  


   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::bytes_readable command(true);
   socket.io_control(command);
   std::size_t bytes_readable = command.get();






[endsect]


[section:cancel basic_socket_streambuf::cancel]

[indexterm2 cancel..basic_socket_streambuf] Cancel all asynchronous operations associated with the socket. 

  void ``[link boost_asio.reference.basic_socket_streambuf.cancel.overload1 cancel]``();

  boost::system::error_code ``[link boost_asio.reference.basic_socket_streambuf.cancel.overload2 cancel]``(
      boost::system::error_code & ec);


[section:overload1 basic_socket_streambuf::cancel (1 of 2 overloads)]


['Inherited from basic_socket.]

Cancel all asynchronous operations associated with the socket. 

  void cancel();


This function causes all outstanding asynchronous connect, send and receive operations to finish immediately, and the handlers for cancelled operations will be passed the boost::asio::error::operation\_aborted error.


[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Remarks]
      
Calls to cancel() will always fail with boost::asio::error::operation\_not\_supported when run on Windows XP, Windows Server 2003, and earlier versions of Windows, unless BOOST\_ASIO\_ENABLE\_CANCELIO is defined. However, the CancelIo function has two issues that should be considered before enabling its use:

* It will only cancel asynchronous operations that were initiated in the current thread.

* It can appear to complete without error, but the request to cancel the unfinished operations may be silently ignored by the operating system. Whether it works or not seems to depend on the drivers that are installed.

For portable cancellation, consider using one of the following alternatives:


* Disable asio's I/O completion port backend by defining BOOST_ASIO_DISABLE_IOCP.

* Use the close() function to simultaneously cancel the outstanding operations and close the socket.

When running on Windows Vista, Windows Server 2008, and later, the CancelIoEx function is always used. This function does not have the problems described above. 


[endsect]



[section:overload2 basic_socket_streambuf::cancel (2 of 2 overloads)]


['Inherited from basic_socket.]

Cancel all asynchronous operations associated with the socket. 

  boost::system::error_code cancel(
      boost::system::error_code & ec);


This function causes all outstanding asynchronous connect, send and receive operations to finish immediately, and the handlers for cancelled operations will be passed the boost::asio::error::operation\_aborted error.


[heading Parameters]
    

[variablelist
  
[[ec][Set to indicate what error occurred, if any.]]

]

[heading Remarks]
      
Calls to cancel() will always fail with boost::asio::error::operation\_not\_supported when run on Windows XP, Windows Server 2003, and earlier versions of Windows, unless BOOST\_ASIO\_ENABLE\_CANCELIO is defined. However, the CancelIo function has two issues that should be considered before enabling its use:

* It will only cancel asynchronous operations that were initiated in the current thread.

* It can appear to complete without error, but the request to cancel the unfinished operations may be silently ignored by the operating system. Whether it works or not seems to depend on the drivers that are installed.

For portable cancellation, consider using one of the following alternatives:


* Disable asio's I/O completion port backend by defining BOOST_ASIO_DISABLE_IOCP.

* Use the close() function to simultaneously cancel the outstanding operations and close the socket.

When running on Windows Vista, Windows Server 2008, and later, the CancelIoEx function is always used. This function does not have the problems described above. 


[endsect]


[endsect]

[section:close basic_socket_streambuf::close]

[indexterm2 close..basic_socket_streambuf] Close the connection. 

  basic_socket_streambuf< Protocol, StreamSocketService > * ``[link boost_asio.reference.basic_socket_streambuf.close.overload1 close]``();

Close the socket. 

  boost::system::error_code ``[link boost_asio.reference.basic_socket_streambuf.close.overload2 close]``(
      boost::system::error_code & ec);


[section:overload1 basic_socket_streambuf::close (1 of 2 overloads)]

Close the connection. 

  basic_socket_streambuf< Protocol, StreamSocketService > * close();



[heading Return Value]
      
`this` if a connection was successfully established, a null pointer otherwise. 



[endsect]



[section:overload2 basic_socket_streambuf::close (2 of 2 overloads)]


['Inherited from basic_socket.]

Close the socket. 

  boost::system::error_code close(
      boost::system::error_code & ec);


This function is used to close the socket. Any asynchronous send, receive or connect operations will be cancelled immediately, and will complete with the boost::asio::error::operation\_aborted error.


[heading Parameters]
    

[variablelist
  
[[ec][Set to indicate what error occurred, if any.]]

]

[heading Example]
  


   boost::asio::ip::tcp::socket socket(io_service);
   ...
   boost::system::error_code ec;
   socket.close(ec);
   if (ec)
   {
     // An error occurred.
   }




[heading Remarks]
      
For portable behaviour with respect to graceful closure of a connected socket, call shutdown() before closing the socket. 



[endsect]


[endsect]

[section:connect basic_socket_streambuf::connect]

[indexterm2 connect..basic_socket_streambuf] Establish a connection. 

  basic_socket_streambuf< Protocol, StreamSocketService > * ``[link boost_asio.reference.basic_socket_streambuf.connect.overload1 connect]``(
      const endpoint_type & endpoint);

  template<
      typename T1,
      ... ,
      typename TN>
  basic_socket_streambuf< Protocol, StreamSocketService > * ``[link boost_asio.reference.basic_socket_streambuf.connect.overload2 connect]``(
      T1 t1,
      ... ,
      TN tn);

Connect the socket to the specified endpoint. 

  boost::system::error_code ``[link boost_asio.reference.basic_socket_streambuf.connect.overload3 connect]``(
      const endpoint_type & peer_endpoint,
      boost::system::error_code & ec);


[section:overload1 basic_socket_streambuf::connect (1 of 3 overloads)]

Establish a connection. 

  basic_socket_streambuf< Protocol, StreamSocketService > * connect(
      const endpoint_type & endpoint);


This function establishes a connection to the specified endpoint.


[heading Return Value]
      
`this` if a connection was successfully established, a null pointer otherwise. 



[endsect]



[section:overload2 basic_socket_streambuf::connect (2 of 3 overloads)]

Establish a connection. 

  template<
      typename T1,
      ... ,
      typename TN>
  basic_socket_streambuf< Protocol, StreamSocketService > * connect(
      T1 t1,
      ... ,
      TN tn);


This function automatically establishes a connection based on the supplied resolver query parameters. The arguments are used to construct a resolver query object.


[heading Return Value]
      
`this` if a connection was successfully established, a null pointer otherwise. 



[endsect]



[section:overload3 basic_socket_streambuf::connect (3 of 3 overloads)]


['Inherited from basic_socket.]

Connect the socket to the specified endpoint. 

  boost::system::error_code connect(
      const endpoint_type & peer_endpoint,
      boost::system::error_code & ec);


This function is used to connect a socket to the specified remote endpoint. The function call will block until the connection is successfully made or an error occurs.

The socket is automatically opened if it is not already open. If the connect fails, and the socket was automatically opened, the socket is not returned to the closed state.


[heading Parameters]
    

[variablelist
  
[[peer_endpoint][The remote endpoint to which the socket will be connected.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Example]
  


   boost::asio::ip::tcp::socket socket(io_service);
   boost::asio::ip::tcp::endpoint endpoint(
       boost::asio::ip::address::from_string("1.2.3.4"), 12345);
   boost::system::error_code ec;
   socket.connect(endpoint, ec);
   if (ec)
   {
     // An error occurred.
   }






[endsect]


[endsect]


[section:debug basic_socket_streambuf::debug]


['Inherited from socket_base.]

[indexterm2 debug..basic_socket_streambuf] Socket option to enable socket-level debugging. 

  typedef implementation_defined debug;



Implements the SOL\_SOCKET/SO\_DEBUG socket option.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::debug option(true);
   socket.set_option(option);




Getting the current option value: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::debug option;
   socket.get_option(option);
   bool is_set = option.value();






[endsect]



[section:do_not_route basic_socket_streambuf::do_not_route]


['Inherited from socket_base.]

[indexterm2 do_not_route..basic_socket_streambuf] Socket option to prevent routing, use local interfaces only. 

  typedef implementation_defined do_not_route;



Implements the SOL\_SOCKET/SO\_DONTROUTE socket option.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::udp::socket socket(io_service); 
   ...
   boost::asio::socket_base::do_not_route option(true);
   socket.set_option(option);




Getting the current option value: 

   boost::asio::ip::udp::socket socket(io_service); 
   ...
   boost::asio::socket_base::do_not_route option;
   socket.get_option(option);
   bool is_set = option.value();






[endsect]



[section:enable_connection_aborted basic_socket_streambuf::enable_connection_aborted]


['Inherited from socket_base.]

[indexterm2 enable_connection_aborted..basic_socket_streambuf] Socket option to report aborted connections on accept. 

  typedef implementation_defined enable_connection_aborted;



Implements a custom socket option that determines whether or not an accept operation is permitted to fail with boost::asio::error::connection\_aborted. By default the option is false.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::tcp::acceptor acceptor(io_service); 
   ...
   boost::asio::socket_base::enable_connection_aborted option(true);
   acceptor.set_option(option);




Getting the current option value: 

   boost::asio::ip::tcp::acceptor acceptor(io_service); 
   ...
   boost::asio::socket_base::enable_connection_aborted option;
   acceptor.get_option(option);
   bool is_set = option.value();






[endsect]



[section:endpoint_type basic_socket_streambuf::endpoint_type]

[indexterm2 endpoint_type..basic_socket_streambuf] The endpoint type. 

  typedef Protocol::endpoint endpoint_type;




[endsect]



[section:get_io_service basic_socket_streambuf::get_io_service]


['Inherited from basic_io_object.]

[indexterm2 get_io_service..basic_socket_streambuf] Get the io_service associated with the object. 

  boost::asio::io_service & get_io_service();


This function may be used to obtain the io_service object that the I/O object uses to dispatch handlers for asynchronous operations.


[heading Return Value]
      
A reference to the io_service object that the I/O object will use to dispatch handlers. Ownership is not transferred to the caller. 



[endsect]


[section:get_option basic_socket_streambuf::get_option]

[indexterm2 get_option..basic_socket_streambuf] Get an option from the socket. 

  void ``[link boost_asio.reference.basic_socket_streambuf.get_option.overload1 get_option]``(
      GettableSocketOption & option) const;

  boost::system::error_code ``[link boost_asio.reference.basic_socket_streambuf.get_option.overload2 get_option]``(
      GettableSocketOption & option,
      boost::system::error_code & ec) const;


[section:overload1 basic_socket_streambuf::get_option (1 of 2 overloads)]


['Inherited from basic_socket.]

Get an option from the socket. 

  void get_option(
      GettableSocketOption & option) const;


This function is used to get the current value of an option on the socket.


[heading Parameters]
    

[variablelist
  
[[option][The option value to be obtained from the socket.]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Example]
  
Getting the value of the SOL\_SOCKET/SO\_KEEPALIVE option: 

   boost::asio::ip::tcp::socket socket(io_service);
   ...
   boost::asio::ip::tcp::socket::keep_alive option;
   socket.get_option(option);
   bool is_set = option.get();






[endsect]



[section:overload2 basic_socket_streambuf::get_option (2 of 2 overloads)]


['Inherited from basic_socket.]

Get an option from the socket. 

  boost::system::error_code get_option(
      GettableSocketOption & option,
      boost::system::error_code & ec) const;


This function is used to get the current value of an option on the socket.


[heading Parameters]
    

[variablelist
  
[[option][The option value to be obtained from the socket.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Example]
  
Getting the value of the SOL\_SOCKET/SO\_KEEPALIVE option: 

   boost::asio::ip::tcp::socket socket(io_service);
   ...
   boost::asio::ip::tcp::socket::keep_alive option;
   boost::system::error_code ec;
   socket.get_option(option, ec);
   if (ec)
   {
     // An error occurred.
   }
   bool is_set = option.get();






[endsect]


[endsect]


[section:implementation basic_socket_streambuf::implementation]


['Inherited from basic_io_object.]

[indexterm2 implementation..basic_socket_streambuf] The underlying implementation of the I/O object. 

  implementation_type implementation;



[endsect]



[section:implementation_type basic_socket_streambuf::implementation_type]


['Inherited from basic_io_object.]

[indexterm2 implementation_type..basic_socket_streambuf] The underlying implementation type of I/O object. 

  typedef service_type::implementation_type implementation_type;




[endsect]


[section:io_control basic_socket_streambuf::io_control]

[indexterm2 io_control..basic_socket_streambuf] Perform an IO control command on the socket. 

  void ``[link boost_asio.reference.basic_socket_streambuf.io_control.overload1 io_control]``(
      IoControlCommand & command);

  boost::system::error_code ``[link boost_asio.reference.basic_socket_streambuf.io_control.overload2 io_control]``(
      IoControlCommand & command,
      boost::system::error_code & ec);


[section:overload1 basic_socket_streambuf::io_control (1 of 2 overloads)]


['Inherited from basic_socket.]

Perform an IO control command on the socket. 

  void io_control(
      IoControlCommand & command);


This function is used to execute an IO control command on the socket.


[heading Parameters]
    

[variablelist
  
[[command][The IO control command to be performed on the socket.]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Example]
  
Getting the number of bytes ready to read: 

   boost::asio::ip::tcp::socket socket(io_service);
   ...
   boost::asio::ip::tcp::socket::bytes_readable command;
   socket.io_control(command);
   std::size_t bytes_readable = command.get();






[endsect]



[section:overload2 basic_socket_streambuf::io_control (2 of 2 overloads)]


['Inherited from basic_socket.]

Perform an IO control command on the socket. 

  boost::system::error_code io_control(
      IoControlCommand & command,
      boost::system::error_code & ec);


This function is used to execute an IO control command on the socket.


[heading Parameters]
    

[variablelist
  
[[command][The IO control command to be performed on the socket.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Example]
  
Getting the number of bytes ready to read: 

   boost::asio::ip::tcp::socket socket(io_service);
   ...
   boost::asio::ip::tcp::socket::bytes_readable command;
   boost::system::error_code ec;
   socket.io_control(command, ec);
   if (ec)
   {
     // An error occurred.
   }
   std::size_t bytes_readable = command.get();






[endsect]


[endsect]


[section:io_service basic_socket_streambuf::io_service]


['Inherited from basic_io_object.]

[indexterm2 io_service..basic_socket_streambuf] (Deprecated: use get_io_service().) Get the io_service associated with the object. 

  boost::asio::io_service & io_service();


This function may be used to obtain the io_service object that the I/O object uses to dispatch handlers for asynchronous operations.


[heading Return Value]
      
A reference to the io_service object that the I/O object will use to dispatch handlers. Ownership is not transferred to the caller. 



[endsect]



[section:is_open basic_socket_streambuf::is_open]


['Inherited from basic_socket.]

[indexterm2 is_open..basic_socket_streambuf] Determine whether the socket is open. 

  bool is_open() const;



[endsect]



[section:keep_alive basic_socket_streambuf::keep_alive]


['Inherited from socket_base.]

[indexterm2 keep_alive..basic_socket_streambuf] Socket option to send keep-alives. 

  typedef implementation_defined keep_alive;



Implements the SOL\_SOCKET/SO\_KEEPALIVE socket option.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::keep_alive option(true);
   socket.set_option(option);




Getting the current option value: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::keep_alive option;
   socket.get_option(option);
   bool is_set = option.value();






[endsect]



[section:linger basic_socket_streambuf::linger]


['Inherited from socket_base.]

[indexterm2 linger..basic_socket_streambuf] Socket option to specify whether the socket lingers on close if unsent data is present. 

  typedef implementation_defined linger;



Implements the SOL\_SOCKET/SO\_LINGER socket option.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::linger option(true, 30);
   socket.set_option(option);




Getting the current option value: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::linger option;
   socket.get_option(option);
   bool is_set = option.enabled();
   unsigned short timeout = option.timeout();






[endsect]


[section:local_endpoint basic_socket_streambuf::local_endpoint]

[indexterm2 local_endpoint..basic_socket_streambuf] Get the local endpoint of the socket. 

  endpoint_type ``[link boost_asio.reference.basic_socket_streambuf.local_endpoint.overload1 local_endpoint]``() const;

  endpoint_type ``[link boost_asio.reference.basic_socket_streambuf.local_endpoint.overload2 local_endpoint]``(
      boost::system::error_code & ec) const;


[section:overload1 basic_socket_streambuf::local_endpoint (1 of 2 overloads)]


['Inherited from basic_socket.]

Get the local endpoint of the socket. 

  endpoint_type local_endpoint() const;


This function is used to obtain the locally bound endpoint of the socket.


[heading Return Value]
      
An object that represents the local endpoint of the socket.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Example]
  


   boost::asio::ip::tcp::socket socket(io_service);
   ...
   boost::asio::ip::tcp::endpoint endpoint = socket.local_endpoint();






[endsect]



[section:overload2 basic_socket_streambuf::local_endpoint (2 of 2 overloads)]


['Inherited from basic_socket.]

Get the local endpoint of the socket. 

  endpoint_type local_endpoint(
      boost::system::error_code & ec) const;


This function is used to obtain the locally bound endpoint of the socket.


[heading Parameters]
    

[variablelist
  
[[ec][Set to indicate what error occurred, if any.]]

]

[heading Return Value]
      
An object that represents the local endpoint of the socket. Returns a default-constructed endpoint object if an error occurred.

[heading Example]
  


   boost::asio::ip::tcp::socket socket(io_service);
   ...
   boost::system::error_code ec;
   boost::asio::ip::tcp::endpoint endpoint = socket.local_endpoint(ec);
   if (ec)
   {
     // An error occurred.
   }






[endsect]


[endsect]

[section:lowest_layer basic_socket_streambuf::lowest_layer]

[indexterm2 lowest_layer..basic_socket_streambuf] Get a reference to the lowest layer. 

  lowest_layer_type & ``[link boost_asio.reference.basic_socket_streambuf.lowest_layer.overload1 lowest_layer]``();

Get a const reference to the lowest layer. 

  const lowest_layer_type & ``[link boost_asio.reference.basic_socket_streambuf.lowest_layer.overload2 lowest_layer]``() const;


[section:overload1 basic_socket_streambuf::lowest_layer (1 of 2 overloads)]


['Inherited from basic_socket.]

Get a reference to the lowest layer. 

  lowest_layer_type & lowest_layer();


This function returns a reference to the lowest layer in a stack of layers. Since a basic_socket cannot contain any further layers, it simply returns a reference to itself.


[heading Return Value]
      
A reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller. 



[endsect]



[section:overload2 basic_socket_streambuf::lowest_layer (2 of 2 overloads)]


['Inherited from basic_socket.]

Get a const reference to the lowest layer. 

  const lowest_layer_type & lowest_layer() const;


This function returns a const reference to the lowest layer in a stack of layers. Since a basic_socket cannot contain any further layers, it simply returns a reference to itself.


[heading Return Value]
      
A const reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller. 



[endsect]


[endsect]


[section:lowest_layer_type basic_socket_streambuf::lowest_layer_type]


['Inherited from basic_socket.]

[indexterm2 lowest_layer_type..basic_socket_streambuf] A basic_socket is always the lowest layer. 

  typedef basic_socket< Protocol, StreamSocketService > lowest_layer_type;


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.basic_socket.broadcast [*broadcast]]]
    [Socket option to permit sending of broadcast messages. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.bytes_readable [*bytes_readable]]]
    [IO control command to get the amount of data that can be read without blocking. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.debug [*debug]]]
    [Socket option to enable socket-level debugging. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.do_not_route [*do_not_route]]]
    [Socket option to prevent routing, use local interfaces only. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.enable_connection_aborted [*enable_connection_aborted]]]
    [Socket option to report aborted connections on accept. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.endpoint_type [*endpoint_type]]]
    [The endpoint type. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.implementation_type [*implementation_type]]]
    [The underlying implementation type of I/O object. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.keep_alive [*keep_alive]]]
    [Socket option to send keep-alives. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.linger [*linger]]]
    [Socket option to specify whether the socket lingers on close if unsent data is present. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.lowest_layer_type [*lowest_layer_type]]]
    [A basic_socket is always the lowest layer. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.message_flags [*message_flags]]]
    [Bitmask type for flags that can be passed to send and receive operations. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.native_type [*native_type]]]
    [The native representation of a socket. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.non_blocking_io [*non_blocking_io]]]
    [IO control command to set the blocking mode of the socket. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.protocol_type [*protocol_type]]]
    [The protocol type. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.receive_buffer_size [*receive_buffer_size]]]
    [Socket option for the receive buffer size of a socket. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.receive_low_watermark [*receive_low_watermark]]]
    [Socket option for the receive low watermark. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.reuse_address [*reuse_address]]]
    [Socket option to allow the socket to be bound to an address that is already in use. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.send_buffer_size [*send_buffer_size]]]
    [Socket option for the send buffer size of a socket. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.send_low_watermark [*send_low_watermark]]]
    [Socket option for the send low watermark. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.service_type [*service_type]]]
    [The type of the service that will be used to provide I/O operations. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.shutdown_type [*shutdown_type]]]
    [Different ways a socket may be shutdown. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_socket.assign [*assign]]]
    [Assign an existing native socket to the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.async_connect [*async_connect]]]
    [Start an asynchronous connect. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.at_mark [*at_mark]]]
    [Determine whether the socket is at the out-of-band data mark. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.available [*available]]]
    [Determine the number of bytes available for reading. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.basic_socket [*basic_socket]]]
    [Construct a basic_socket without opening it. 

     Construct and open a basic_socket. 

     Construct a basic_socket, opening it and binding it to the given local endpoint. 

     Construct a basic_socket on an existing native socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.bind [*bind]]]
    [Bind the socket to the given local endpoint. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.cancel [*cancel]]]
    [Cancel all asynchronous operations associated with the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.close [*close]]]
    [Close the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.connect [*connect]]]
    [Connect the socket to the specified endpoint. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.get_io_service [*get_io_service]]]
    [Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.get_option [*get_option]]]
    [Get an option from the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.io_control [*io_control]]]
    [Perform an IO control command on the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.io_service [*io_service]]]
    [(Deprecated: use get_io_service().) Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.is_open [*is_open]]]
    [Determine whether the socket is open. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.local_endpoint [*local_endpoint]]]
    [Get the local endpoint of the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.lowest_layer [*lowest_layer]]]
    [Get a reference to the lowest layer. 

     Get a const reference to the lowest layer. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.native [*native]]]
    [Get the native socket representation. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.open [*open]]]
    [Open the socket using the specified protocol. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.remote_endpoint [*remote_endpoint]]]
    [Get the remote endpoint of the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.set_option [*set_option]]]
    [Set an option on the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.shutdown [*shutdown]]]
    [Disable sends or receives on the socket. ]
  ]
  
]

[heading Protected Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_socket._basic_socket [*~basic_socket]]]
    [Protected destructor to prevent deletion through this type. ]
  ]
  
]

[heading Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_socket.max_connections [*max_connections]]]
    [The maximum length of the queue of pending incoming connections. ]
  ]

  [
    [[link boost_asio.reference.basic_socket.message_do_not_route [*message_do_not_route]]]
    [Specify that the data should not be subject to routing. ]
  ]

  [
    [[link boost_asio.reference.basic_socket.message_out_of_band [*message_out_of_band]]]
    [Process out-of-band data. ]
  ]

  [
    [[link boost_asio.reference.basic_socket.message_peek [*message_peek]]]
    [Peek at incoming data without removing it from the input queue. ]
  ]

]

[heading Protected Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_socket.implementation [*implementation]]]
    [The underlying implementation of the I/O object. ]
  ]

  [
    [[link boost_asio.reference.basic_socket.service [*service]]]
    [The service associated with the I/O object. ]
  ]

]

The basic_socket class template provides functionality that is common to both stream-oriented and datagram-oriented sockets.


[heading Thread Safety]
  
[*Distinct] [*objects:]  Safe.

[*Shared] [*objects:]  Unsafe. 




[endsect]



[section:max_connections basic_socket_streambuf::max_connections]


['Inherited from socket_base.]

[indexterm2 max_connections..basic_socket_streambuf] The maximum length of the queue of pending incoming connections. 

  static const int max_connections = implementation_defined;



[endsect]



[section:message_do_not_route basic_socket_streambuf::message_do_not_route]


['Inherited from socket_base.]

[indexterm2 message_do_not_route..basic_socket_streambuf] Specify that the data should not be subject to routing. 

  static const int message_do_not_route = implementation_defined;



[endsect]



[section:message_flags basic_socket_streambuf::message_flags]


['Inherited from socket_base.]

[indexterm2 message_flags..basic_socket_streambuf] Bitmask type for flags that can be passed to send and receive operations. 

  typedef int message_flags;




[endsect]



[section:message_out_of_band basic_socket_streambuf::message_out_of_band]


['Inherited from socket_base.]

[indexterm2 message_out_of_band..basic_socket_streambuf] Process out-of-band data. 

  static const int message_out_of_band = implementation_defined;



[endsect]



[section:message_peek basic_socket_streambuf::message_peek]


['Inherited from socket_base.]

[indexterm2 message_peek..basic_socket_streambuf] Peek at incoming data without removing it from the input queue. 

  static const int message_peek = implementation_defined;



[endsect]



[section:native basic_socket_streambuf::native]


['Inherited from basic_socket.]

[indexterm2 native..basic_socket_streambuf] Get the native socket representation. 

  native_type native();


This function may be used to obtain the underlying representation of the socket. This is intended to allow access to native socket functionality that is not otherwise provided. 


[endsect]



[section:native_type basic_socket_streambuf::native_type]


['Inherited from basic_socket.]

[indexterm2 native_type..basic_socket_streambuf] The native representation of a socket. 

  typedef StreamSocketService::native_type native_type;




[endsect]



[section:non_blocking_io basic_socket_streambuf::non_blocking_io]


['Inherited from socket_base.]

[indexterm2 non_blocking_io..basic_socket_streambuf] IO control command to set the blocking mode of the socket. 

  typedef implementation_defined non_blocking_io;



Implements the FIONBIO IO control command.


[heading Example]
  


   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::non_blocking_io command(true);
   socket.io_control(command);






[endsect]


[section:open basic_socket_streambuf::open]

[indexterm2 open..basic_socket_streambuf] Open the socket using the specified protocol. 

  void ``[link boost_asio.reference.basic_socket_streambuf.open.overload1 open]``(
      const protocol_type & protocol = protocol_type());

  boost::system::error_code ``[link boost_asio.reference.basic_socket_streambuf.open.overload2 open]``(
      const protocol_type & protocol,
      boost::system::error_code & ec);


[section:overload1 basic_socket_streambuf::open (1 of 2 overloads)]


['Inherited from basic_socket.]

Open the socket using the specified protocol. 

  void open(
      const protocol_type & protocol = protocol_type());


This function opens the socket so that it will use the specified protocol.


[heading Parameters]
    

[variablelist
  
[[protocol][An object specifying protocol parameters to be used.]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Example]
  


   boost::asio::ip::tcp::socket socket(io_service);
   socket.open(boost::asio::ip::tcp::v4());






[endsect]



[section:overload2 basic_socket_streambuf::open (2 of 2 overloads)]


['Inherited from basic_socket.]

Open the socket using the specified protocol. 

  boost::system::error_code open(
      const protocol_type & protocol,
      boost::system::error_code & ec);


This function opens the socket so that it will use the specified protocol.


[heading Parameters]
    

[variablelist
  
[[protocol][An object specifying which protocol is to be used.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Example]
  


   boost::asio::ip::tcp::socket socket(io_service);
   boost::system::error_code ec;
   socket.open(boost::asio::ip::tcp::v4(), ec);
   if (ec)
   {
     // An error occurred.
   }






[endsect]


[endsect]


[section:overflow basic_socket_streambuf::overflow]

[indexterm2 overflow..basic_socket_streambuf] 

  int_type overflow(
      int_type c);



[endsect]



[section:protocol_type basic_socket_streambuf::protocol_type]


['Inherited from basic_socket.]

[indexterm2 protocol_type..basic_socket_streambuf] The protocol type. 

  typedef Protocol protocol_type;




[endsect]



[section:receive_buffer_size basic_socket_streambuf::receive_buffer_size]


['Inherited from socket_base.]

[indexterm2 receive_buffer_size..basic_socket_streambuf] Socket option for the receive buffer size of a socket. 

  typedef implementation_defined receive_buffer_size;



Implements the SOL\_SOCKET/SO\_RCVBUF socket option.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::receive_buffer_size option(8192);
   socket.set_option(option);




Getting the current option value: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::receive_buffer_size option;
   socket.get_option(option);
   int size = option.value();






[endsect]



[section:receive_low_watermark basic_socket_streambuf::receive_low_watermark]


['Inherited from socket_base.]

[indexterm2 receive_low_watermark..basic_socket_streambuf] Socket option for the receive low watermark. 

  typedef implementation_defined receive_low_watermark;



Implements the SOL\_SOCKET/SO\_RCVLOWAT socket option.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::receive_low_watermark option(1024);
   socket.set_option(option);




Getting the current option value: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::receive_low_watermark option;
   socket.get_option(option);
   int size = option.value();






[endsect]


[section:remote_endpoint basic_socket_streambuf::remote_endpoint]

[indexterm2 remote_endpoint..basic_socket_streambuf] Get the remote endpoint of the socket. 

  endpoint_type ``[link boost_asio.reference.basic_socket_streambuf.remote_endpoint.overload1 remote_endpoint]``() const;

  endpoint_type ``[link boost_asio.reference.basic_socket_streambuf.remote_endpoint.overload2 remote_endpoint]``(
      boost::system::error_code & ec) const;


[section:overload1 basic_socket_streambuf::remote_endpoint (1 of 2 overloads)]


['Inherited from basic_socket.]

Get the remote endpoint of the socket. 

  endpoint_type remote_endpoint() const;


This function is used to obtain the remote endpoint of the socket.


[heading Return Value]
      
An object that represents the remote endpoint of the socket.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Example]
  


   boost::asio::ip::tcp::socket socket(io_service);
   ...
   boost::asio::ip::tcp::endpoint endpoint = socket.remote_endpoint();






[endsect]



[section:overload2 basic_socket_streambuf::remote_endpoint (2 of 2 overloads)]


['Inherited from basic_socket.]

Get the remote endpoint of the socket. 

  endpoint_type remote_endpoint(
      boost::system::error_code & ec) const;


This function is used to obtain the remote endpoint of the socket.


[heading Parameters]
    

[variablelist
  
[[ec][Set to indicate what error occurred, if any.]]

]

[heading Return Value]
      
An object that represents the remote endpoint of the socket. Returns a default-constructed endpoint object if an error occurred.

[heading Example]
  


   boost::asio::ip::tcp::socket socket(io_service);
   ...
   boost::system::error_code ec;
   boost::asio::ip::tcp::endpoint endpoint = socket.remote_endpoint(ec);
   if (ec)
   {
     // An error occurred.
   }






[endsect]


[endsect]


[section:reuse_address basic_socket_streambuf::reuse_address]


['Inherited from socket_base.]

[indexterm2 reuse_address..basic_socket_streambuf] Socket option to allow the socket to be bound to an address that is already in use. 

  typedef implementation_defined reuse_address;



Implements the SOL\_SOCKET/SO\_REUSEADDR socket option.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::tcp::acceptor acceptor(io_service); 
   ...
   boost::asio::socket_base::reuse_address option(true);
   acceptor.set_option(option);




Getting the current option value: 

   boost::asio::ip::tcp::acceptor acceptor(io_service); 
   ...
   boost::asio::socket_base::reuse_address option;
   acceptor.get_option(option);
   bool is_set = option.value();






[endsect]



[section:send_buffer_size basic_socket_streambuf::send_buffer_size]


['Inherited from socket_base.]

[indexterm2 send_buffer_size..basic_socket_streambuf] Socket option for the send buffer size of a socket. 

  typedef implementation_defined send_buffer_size;



Implements the SOL\_SOCKET/SO\_SNDBUF socket option.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::send_buffer_size option(8192);
   socket.set_option(option);




Getting the current option value: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::send_buffer_size option;
   socket.get_option(option);
   int size = option.value();






[endsect]



[section:send_low_watermark basic_socket_streambuf::send_low_watermark]


['Inherited from socket_base.]

[indexterm2 send_low_watermark..basic_socket_streambuf] Socket option for the send low watermark. 

  typedef implementation_defined send_low_watermark;



Implements the SOL\_SOCKET/SO\_SNDLOWAT socket option.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::send_low_watermark option(1024);
   socket.set_option(option);




Getting the current option value: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::send_low_watermark option;
   socket.get_option(option);
   int size = option.value();






[endsect]



[section:service basic_socket_streambuf::service]


['Inherited from basic_io_object.]

[indexterm2 service..basic_socket_streambuf] The service associated with the I/O object. 

  service_type & service;



[endsect]



[section:service_type basic_socket_streambuf::service_type]


['Inherited from basic_io_object.]

[indexterm2 service_type..basic_socket_streambuf] The type of the service that will be used to provide I/O operations. 

  typedef StreamSocketService service_type;




[endsect]


[section:set_option basic_socket_streambuf::set_option]

[indexterm2 set_option..basic_socket_streambuf] Set an option on the socket. 

  void ``[link boost_asio.reference.basic_socket_streambuf.set_option.overload1 set_option]``(
      const SettableSocketOption & option);

  boost::system::error_code ``[link boost_asio.reference.basic_socket_streambuf.set_option.overload2 set_option]``(
      const SettableSocketOption & option,
      boost::system::error_code & ec);


[section:overload1 basic_socket_streambuf::set_option (1 of 2 overloads)]


['Inherited from basic_socket.]

Set an option on the socket. 

  void set_option(
      const SettableSocketOption & option);


This function is used to set an option on the socket.


[heading Parameters]
    

[variablelist
  
[[option][The new option value to be set on the socket.]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Example]
  
Setting the IPPROTO\_TCP/TCP\_NODELAY option: 

   boost::asio::ip::tcp::socket socket(io_service);
   ...
   boost::asio::ip::tcp::no_delay option(true);
   socket.set_option(option);






[endsect]



[section:overload2 basic_socket_streambuf::set_option (2 of 2 overloads)]


['Inherited from basic_socket.]

Set an option on the socket. 

  boost::system::error_code set_option(
      const SettableSocketOption & option,
      boost::system::error_code & ec);


This function is used to set an option on the socket.


[heading Parameters]
    

[variablelist
  
[[option][The new option value to be set on the socket.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Example]
  
Setting the IPPROTO\_TCP/TCP\_NODELAY option: 

   boost::asio::ip::tcp::socket socket(io_service);
   ...
   boost::asio::ip::tcp::no_delay option(true);
   boost::system::error_code ec;
   socket.set_option(option, ec);
   if (ec)
   {
     // An error occurred.
   }






[endsect]


[endsect]


[section:setbuf basic_socket_streambuf::setbuf]

[indexterm2 setbuf..basic_socket_streambuf] 

  std::streambuf * setbuf(
      char_type * s,
      std::streamsize n);



[endsect]


[section:shutdown basic_socket_streambuf::shutdown]

[indexterm2 shutdown..basic_socket_streambuf] Disable sends or receives on the socket. 

  void ``[link boost_asio.reference.basic_socket_streambuf.shutdown.overload1 shutdown]``(
      shutdown_type what);

  boost::system::error_code ``[link boost_asio.reference.basic_socket_streambuf.shutdown.overload2 shutdown]``(
      shutdown_type what,
      boost::system::error_code & ec);


[section:overload1 basic_socket_streambuf::shutdown (1 of 2 overloads)]


['Inherited from basic_socket.]

Disable sends or receives on the socket. 

  void shutdown(
      shutdown_type what);


This function is used to disable send operations, receive operations, or both.


[heading Parameters]
    

[variablelist
  
[[what][Determines what types of operation will no longer be allowed.]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Example]
  
Shutting down the send side of the socket: 

   boost::asio::ip::tcp::socket socket(io_service);
   ...
   socket.shutdown(boost::asio::ip::tcp::socket::shutdown_send);






[endsect]



[section:overload2 basic_socket_streambuf::shutdown (2 of 2 overloads)]


['Inherited from basic_socket.]

Disable sends or receives on the socket. 

  boost::system::error_code shutdown(
      shutdown_type what,
      boost::system::error_code & ec);


This function is used to disable send operations, receive operations, or both.


[heading Parameters]
    

[variablelist
  
[[what][Determines what types of operation will no longer be allowed.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Example]
  
Shutting down the send side of the socket: 

   boost::asio::ip::tcp::socket socket(io_service);
   ...
   boost::system::error_code ec;
   socket.shutdown(boost::asio::ip::tcp::socket::shutdown_send, ec);
   if (ec)
   {
     // An error occurred.
   }






[endsect]


[endsect]


[section:shutdown_type basic_socket_streambuf::shutdown_type]


['Inherited from socket_base.]

[indexterm2 shutdown_type..basic_socket_streambuf] Different ways a socket may be shutdown. 

  enum shutdown_type

[heading Values]
[variablelist

  [
    [shutdown_receive]
    [Shutdown the receive side of the socket. ]
  ]

  [
    [shutdown_send]
    [Shutdown the send side of the socket. ]
  ]

  [
    [shutdown_both]
    [Shutdown both send and receive on the socket. ]
  ]

]



[endsect]



[section:sync basic_socket_streambuf::sync]

[indexterm2 sync..basic_socket_streambuf] 

  int sync();



[endsect]



[section:underflow basic_socket_streambuf::underflow]

[indexterm2 underflow..basic_socket_streambuf] 

  int_type underflow();



[endsect]



[section:_basic_socket_streambuf basic_socket_streambuf::~basic_socket_streambuf]

[indexterm2 ~basic_socket_streambuf..basic_socket_streambuf] Destructor flushes buffered data. 

  virtual ~basic_socket_streambuf();



[endsect]



[endsect]

[section:basic_stream_socket basic_stream_socket]

Provides stream-oriented socket functionality. 

  template<
      typename ``[link boost_asio.reference.Protocol Protocol]``,
      typename ``[link boost_asio.reference.StreamSocketService StreamSocketService]`` = stream_socket_service<Protocol>>
  class basic_stream_socket :
    public basic_socket< Protocol, StreamSocketService >


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.basic_stream_socket.broadcast [*broadcast]]]
    [Socket option to permit sending of broadcast messages. ]
  
  ]

  [

    [[link boost_asio.reference.basic_stream_socket.bytes_readable [*bytes_readable]]]
    [IO control command to get the amount of data that can be read without blocking. ]
  
  ]

  [

    [[link boost_asio.reference.basic_stream_socket.debug [*debug]]]
    [Socket option to enable socket-level debugging. ]
  
  ]

  [

    [[link boost_asio.reference.basic_stream_socket.do_not_route [*do_not_route]]]
    [Socket option to prevent routing, use local interfaces only. ]
  
  ]

  [

    [[link boost_asio.reference.basic_stream_socket.enable_connection_aborted [*enable_connection_aborted]]]
    [Socket option to report aborted connections on accept. ]
  
  ]

  [

    [[link boost_asio.reference.basic_stream_socket.endpoint_type [*endpoint_type]]]
    [The endpoint type. ]
  
  ]

  [

    [[link boost_asio.reference.basic_stream_socket.implementation_type [*implementation_type]]]
    [The underlying implementation type of I/O object. ]
  
  ]

  [

    [[link boost_asio.reference.basic_stream_socket.keep_alive [*keep_alive]]]
    [Socket option to send keep-alives. ]
  
  ]

  [

    [[link boost_asio.reference.basic_stream_socket.linger [*linger]]]
    [Socket option to specify whether the socket lingers on close if unsent data is present. ]
  
  ]

  [

    [[link boost_asio.reference.basic_stream_socket.lowest_layer_type [*lowest_layer_type]]]
    [A basic_socket is always the lowest layer. ]
  
  ]

  [

    [[link boost_asio.reference.basic_stream_socket.message_flags [*message_flags]]]
    [Bitmask type for flags that can be passed to send and receive operations. ]
  
  ]

  [

    [[link boost_asio.reference.basic_stream_socket.native_type [*native_type]]]
    [The native representation of a socket. ]
  
  ]

  [

    [[link boost_asio.reference.basic_stream_socket.non_blocking_io [*non_blocking_io]]]
    [IO control command to set the blocking mode of the socket. ]
  
  ]

  [

    [[link boost_asio.reference.basic_stream_socket.protocol_type [*protocol_type]]]
    [The protocol type. ]
  
  ]

  [

    [[link boost_asio.reference.basic_stream_socket.receive_buffer_size [*receive_buffer_size]]]
    [Socket option for the receive buffer size of a socket. ]
  
  ]

  [

    [[link boost_asio.reference.basic_stream_socket.receive_low_watermark [*receive_low_watermark]]]
    [Socket option for the receive low watermark. ]
  
  ]

  [

    [[link boost_asio.reference.basic_stream_socket.reuse_address [*reuse_address]]]
    [Socket option to allow the socket to be bound to an address that is already in use. ]
  
  ]

  [

    [[link boost_asio.reference.basic_stream_socket.send_buffer_size [*send_buffer_size]]]
    [Socket option for the send buffer size of a socket. ]
  
  ]

  [

    [[link boost_asio.reference.basic_stream_socket.send_low_watermark [*send_low_watermark]]]
    [Socket option for the send low watermark. ]
  
  ]

  [

    [[link boost_asio.reference.basic_stream_socket.service_type [*service_type]]]
    [The type of the service that will be used to provide I/O operations. ]
  
  ]

  [

    [[link boost_asio.reference.basic_stream_socket.shutdown_type [*shutdown_type]]]
    [Different ways a socket may be shutdown. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_stream_socket.assign [*assign]]]
    [Assign an existing native socket to the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.async_connect [*async_connect]]]
    [Start an asynchronous connect. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.async_read_some [*async_read_some]]]
    [Start an asynchronous read. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.async_receive [*async_receive]]]
    [Start an asynchronous receive. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.async_send [*async_send]]]
    [Start an asynchronous send. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.async_write_some [*async_write_some]]]
    [Start an asynchronous write. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.at_mark [*at_mark]]]
    [Determine whether the socket is at the out-of-band data mark. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.available [*available]]]
    [Determine the number of bytes available for reading. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.basic_stream_socket [*basic_stream_socket]]]
    [Construct a basic_stream_socket without opening it. 

     Construct and open a basic_stream_socket. 

     Construct a basic_stream_socket, opening it and binding it to the given local endpoint. 

     Construct a basic_stream_socket on an existing native socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.bind [*bind]]]
    [Bind the socket to the given local endpoint. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.cancel [*cancel]]]
    [Cancel all asynchronous operations associated with the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.close [*close]]]
    [Close the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.connect [*connect]]]
    [Connect the socket to the specified endpoint. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.get_io_service [*get_io_service]]]
    [Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.get_option [*get_option]]]
    [Get an option from the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.io_control [*io_control]]]
    [Perform an IO control command on the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.io_service [*io_service]]]
    [(Deprecated: use get_io_service().) Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.is_open [*is_open]]]
    [Determine whether the socket is open. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.local_endpoint [*local_endpoint]]]
    [Get the local endpoint of the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.lowest_layer [*lowest_layer]]]
    [Get a reference to the lowest layer. 

     Get a const reference to the lowest layer. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.native [*native]]]
    [Get the native socket representation. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.open [*open]]]
    [Open the socket using the specified protocol. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.read_some [*read_some]]]
    [Read some data from the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.receive [*receive]]]
    [Receive some data on the socket. 

     Receive some data on a connected socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.remote_endpoint [*remote_endpoint]]]
    [Get the remote endpoint of the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.send [*send]]]
    [Send some data on the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.set_option [*set_option]]]
    [Set an option on the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.shutdown [*shutdown]]]
    [Disable sends or receives on the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.write_some [*write_some]]]
    [Write some data to the socket. ]
  ]
  
]

[heading Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_stream_socket.max_connections [*max_connections]]]
    [The maximum length of the queue of pending incoming connections. ]
  ]

  [
    [[link boost_asio.reference.basic_stream_socket.message_do_not_route [*message_do_not_route]]]
    [Specify that the data should not be subject to routing. ]
  ]

  [
    [[link boost_asio.reference.basic_stream_socket.message_out_of_band [*message_out_of_band]]]
    [Process out-of-band data. ]
  ]

  [
    [[link boost_asio.reference.basic_stream_socket.message_peek [*message_peek]]]
    [Peek at incoming data without removing it from the input queue. ]
  ]

]

[heading Protected Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_stream_socket.implementation [*implementation]]]
    [The underlying implementation of the I/O object. ]
  ]

  [
    [[link boost_asio.reference.basic_stream_socket.service [*service]]]
    [The service associated with the I/O object. ]
  ]

]

The basic_stream_socket class template provides asynchronous and blocking stream-oriented socket functionality.


[heading Thread Safety]
  
[*Distinct] [*objects:]  Safe.

[*Shared] [*objects:]  Unsafe.


[section:assign basic_stream_socket::assign]

[indexterm2 assign..basic_stream_socket] Assign an existing native socket to the socket. 

  void ``[link boost_asio.reference.basic_stream_socket.assign.overload1 assign]``(
      const protocol_type & protocol,
      const native_type & native_socket);

  boost::system::error_code ``[link boost_asio.reference.basic_stream_socket.assign.overload2 assign]``(
      const protocol_type & protocol,
      const native_type & native_socket,
      boost::system::error_code & ec);


[section:overload1 basic_stream_socket::assign (1 of 2 overloads)]


['Inherited from basic_socket.]

Assign an existing native socket to the socket. 

  void assign(
      const protocol_type & protocol,
      const native_type & native_socket);



[endsect]



[section:overload2 basic_stream_socket::assign (2 of 2 overloads)]


['Inherited from basic_socket.]

Assign an existing native socket to the socket. 

  boost::system::error_code assign(
      const protocol_type & protocol,
      const native_type & native_socket,
      boost::system::error_code & ec);



[endsect]


[endsect]


[section:async_connect basic_stream_socket::async_connect]


['Inherited from basic_socket.]

[indexterm2 async_connect..basic_stream_socket] Start an asynchronous connect. 

  void async_connect(
      const endpoint_type & peer_endpoint,
      ConnectHandler handler);


This function is used to asynchronously connect a socket to the specified remote endpoint. The function call always returns immediately.

The socket is automatically opened if it is not already open. If the connect fails, and the socket was automatically opened, the socket is not returned to the closed state.


[heading Parameters]
    

[variablelist
  
[[peer_endpoint][The remote endpoint to which the socket will be connected. Copies will be made of the endpoint object as required.]]

[[handler][The handler to be called when the connection operation completes. Copies will be made of the handler as required. The function signature of the handler must be: 
``
   void handler(
     const boost::system::error_code& error // Result of operation
   ); 
``
Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using boost::asio::io\_service::post().]]

]

[heading Example]
  


   void connect_handler(const boost::system::error_code& error)
   {
     if (!error)
     {
       // Connect succeeded.
     }
   }

   ...

   boost::asio::ip::tcp::socket socket(io_service);
   boost::asio::ip::tcp::endpoint endpoint(
       boost::asio::ip::address::from_string("1.2.3.4"), 12345);
   socket.async_connect(endpoint, connect_handler);






[endsect]



[section:async_read_some basic_stream_socket::async_read_some]

[indexterm2 async_read_some..basic_stream_socket] Start an asynchronous read. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
  void async_read_some(
      const MutableBufferSequence & buffers,
      ReadHandler handler);


This function is used to asynchronously read data from the stream socket. The function call always returns immediately.


[heading Parameters]
    

[variablelist
  
[[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.]]

[[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: 
``
   void handler(
     const boost::system::error_code& error, // Result of operation.
     std::size_t bytes_transferred           // Number of bytes read.
   ); 
``
Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using boost::asio::io\_service::post().]]

]

[heading Remarks]
      
The read operation may not read all of the requested number of bytes. Consider using the 
[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.

[heading Example]
  
To read into a single data buffer use the 
[link boost_asio.reference.buffer buffer]  function as follows: 

   socket.async_read_some(boost::asio::buffer(data, size), handler);


See the 
[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. 



[endsect]


[section:async_receive basic_stream_socket::async_receive]

[indexterm2 async_receive..basic_stream_socket] Start an asynchronous receive. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
  void ``[link boost_asio.reference.basic_stream_socket.async_receive.overload1 async_receive]``(
      const MutableBufferSequence & buffers,
      ReadHandler handler);

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
  void ``[link boost_asio.reference.basic_stream_socket.async_receive.overload2 async_receive]``(
      const MutableBufferSequence & buffers,
      socket_base::message_flags flags,
      ReadHandler handler);


[section:overload1 basic_stream_socket::async_receive (1 of 2 overloads)]

Start an asynchronous receive. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
  void async_receive(
      const MutableBufferSequence & buffers,
      ReadHandler handler);


This function is used to asynchronously receive data from the stream socket. The function call always returns immediately.


[heading Parameters]
    

[variablelist
  
[[buffers][One or more buffers into which the data will be received. 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.]]

[[handler][The handler to be called when the receive operation completes. Copies will be made of the handler as required. The function signature of the handler must be: 
``
   void handler(
     const boost::system::error_code& error, // Result of operation.
     std::size_t bytes_transferred           // Number of bytes received.
   ); 
``
Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using boost::asio::io\_service::post().]]

]

[heading Remarks]
      
The receive operation may not receive all of the requested number of bytes. Consider using the 
[link boost_asio.reference.async_read async_read]  function if you need to ensure that the requested amount of data is received before the asynchronous operation completes.

[heading Example]
  
To receive into a single data buffer use the 
[link boost_asio.reference.buffer buffer]  function as follows: 

   socket.async_receive(boost::asio::buffer(data, size), handler);


See the 
[link boost_asio.reference.buffer buffer]  documentation for information on receiving into multiple buffers in one go, and how to use it with arrays, boost::array or std::vector. 



[endsect]



[section:overload2 basic_stream_socket::async_receive (2 of 2 overloads)]

Start an asynchronous receive. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
  void async_receive(
      const MutableBufferSequence & buffers,
      socket_base::message_flags flags,
      ReadHandler handler);


This function is used to asynchronously receive data from the stream socket. The function call always returns immediately.


[heading Parameters]
    

[variablelist
  
[[buffers][One or more buffers into which the data will be received. 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.]]

[[flags][Flags specifying how the receive call is to be made.]]

[[handler][The handler to be called when the receive operation completes. Copies will be made of the handler as required. The function signature of the handler must be: 
``
   void handler(
     const boost::system::error_code& error, // Result of operation.
     std::size_t bytes_transferred           // Number of bytes received.
   ); 
``
Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using boost::asio::io\_service::post().]]

]

[heading Remarks]
      
The receive operation may not receive all of the requested number of bytes. Consider using the 
[link boost_asio.reference.async_read async_read]  function if you need to ensure that the requested amount of data is received before the asynchronous operation completes.

[heading Example]
  
To receive into a single data buffer use the 
[link boost_asio.reference.buffer buffer]  function as follows: 

   socket.async_receive(boost::asio::buffer(data, size), 0, handler);


See the 
[link boost_asio.reference.buffer buffer]  documentation for information on receiving into multiple buffers in one go, and how to use it with arrays, boost::array or std::vector. 



[endsect]


[endsect]

[section:async_send basic_stream_socket::async_send]

[indexterm2 async_send..basic_stream_socket] Start an asynchronous send. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
  void ``[link boost_asio.reference.basic_stream_socket.async_send.overload1 async_send]``(
      const ConstBufferSequence & buffers,
      WriteHandler handler);

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
  void ``[link boost_asio.reference.basic_stream_socket.async_send.overload2 async_send]``(
      const ConstBufferSequence & buffers,
      socket_base::message_flags flags,
      WriteHandler handler);


[section:overload1 basic_stream_socket::async_send (1 of 2 overloads)]

Start an asynchronous send. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
  void async_send(
      const ConstBufferSequence & buffers,
      WriteHandler handler);


This function is used to asynchronously send data on the stream socket. The function call always returns immediately.


[heading Parameters]
    

[variablelist
  
[[buffers][One or more data buffers to be sent on the socket. 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.]]

[[handler][The handler to be called when the send operation completes. Copies will be made of the handler as required. The function signature of the handler must be: 
``
   void handler(
     const boost::system::error_code& error, // Result of operation.
     std::size_t bytes_transferred           // Number of bytes sent.
   ); 
``
Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using boost::asio::io\_service::post().]]

]

[heading Remarks]
      
The send operation may not transmit all of the data to the peer. Consider using the 
[link boost_asio.reference.async_write async_write]  function if you need to ensure that all data is written before the asynchronous operation completes.

[heading Example]
  
To send a single data buffer use the 
[link boost_asio.reference.buffer buffer]  function as follows: 

   socket.async_send(boost::asio::buffer(data, size), handler);


See the 
[link boost_asio.reference.buffer buffer]  documentation for information on sending multiple buffers in one go, and how to use it with arrays, boost::array or std::vector. 



[endsect]



[section:overload2 basic_stream_socket::async_send (2 of 2 overloads)]

Start an asynchronous send. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
  void async_send(
      const ConstBufferSequence & buffers,
      socket_base::message_flags flags,
      WriteHandler handler);


This function is used to asynchronously send data on the stream socket. The function call always returns immediately.


[heading Parameters]
    

[variablelist
  
[[buffers][One or more data buffers to be sent on the socket. 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.]]

[[flags][Flags specifying how the send call is to be made.]]

[[handler][The handler to be called when the send operation completes. Copies will be made of the handler as required. The function signature of the handler must be: 
``
   void handler(
     const boost::system::error_code& error, // Result of operation.
     std::size_t bytes_transferred           // Number of bytes sent.
   ); 
``
Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using boost::asio::io\_service::post().]]

]

[heading Remarks]
      
The send operation may not transmit all of the data to the peer. Consider using the 
[link boost_asio.reference.async_write async_write]  function if you need to ensure that all data is written before the asynchronous operation completes.

[heading Example]
  
To send a single data buffer use the 
[link boost_asio.reference.buffer buffer]  function as follows: 

   socket.async_send(boost::asio::buffer(data, size), 0, handler);


See the 
[link boost_asio.reference.buffer buffer]  documentation for information on sending multiple buffers in one go, and how to use it with arrays, boost::array or std::vector. 



[endsect]


[endsect]


[section:async_write_some basic_stream_socket::async_write_some]

[indexterm2 async_write_some..basic_stream_socket] Start an asynchronous write. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
  void async_write_some(
      const ConstBufferSequence & buffers,
      WriteHandler handler);


This function is used to asynchronously write data to the stream socket. The function call always returns immediately.


[heading Parameters]
    

[variablelist
  
[[buffers][One or more data buffers to be written to the socket. 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.]]

[[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: 
``
   void handler(
     const boost::system::error_code& error, // Result of operation.
     std::size_t bytes_transferred           // Number of bytes written.
   ); 
``
Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using boost::asio::io\_service::post().]]

]

[heading Remarks]
      
The write operation may not transmit all of the data to the peer. Consider using the 
[link boost_asio.reference.async_write async_write]  function if you need to ensure that all data is written before the asynchronous operation completes.

[heading Example]
  
To write a single data buffer use the 
[link boost_asio.reference.buffer buffer]  function as follows: 

   socket.async_write_some(boost::asio::buffer(data, size), handler);


See the 
[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. 



[endsect]


[section:at_mark basic_stream_socket::at_mark]

[indexterm2 at_mark..basic_stream_socket] Determine whether the socket is at the out-of-band data mark. 

  bool ``[link boost_asio.reference.basic_stream_socket.at_mark.overload1 at_mark]``() const;

  bool ``[link boost_asio.reference.basic_stream_socket.at_mark.overload2 at_mark]``(
      boost::system::error_code & ec) const;


[section:overload1 basic_stream_socket::at_mark (1 of 2 overloads)]


['Inherited from basic_socket.]

Determine whether the socket is at the out-of-band data mark. 

  bool at_mark() const;


This function is used to check whether the socket input is currently positioned at the out-of-band data mark.


[heading Return Value]
      
A bool indicating whether the socket is at the out-of-band data mark.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. ]]

]



[endsect]



[section:overload2 basic_stream_socket::at_mark (2 of 2 overloads)]


['Inherited from basic_socket.]

Determine whether the socket is at the out-of-band data mark. 

  bool at_mark(
      boost::system::error_code & ec) const;


This function is used to check whether the socket input is currently positioned at the out-of-band data mark.


[heading Parameters]
    

[variablelist
  
[[ec][Set to indicate what error occurred, if any.]]

]

[heading Return Value]
      
A bool indicating whether the socket is at the out-of-band data mark. 



[endsect]


[endsect]

[section:available basic_stream_socket::available]

[indexterm2 available..basic_stream_socket] Determine the number of bytes available for reading. 

  std::size_t ``[link boost_asio.reference.basic_stream_socket.available.overload1 available]``() const;

  std::size_t ``[link boost_asio.reference.basic_stream_socket.available.overload2 available]``(
      boost::system::error_code & ec) const;


[section:overload1 basic_stream_socket::available (1 of 2 overloads)]


['Inherited from basic_socket.]

Determine the number of bytes available for reading. 

  std::size_t available() const;


This function is used to determine the number of bytes that may be read without blocking.


[heading Return Value]
      
The number of bytes that may be read without blocking, or 0 if an error occurs.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. ]]

]



[endsect]



[section:overload2 basic_stream_socket::available (2 of 2 overloads)]


['Inherited from basic_socket.]

Determine the number of bytes available for reading. 

  std::size_t available(
      boost::system::error_code & ec) const;


This function is used to determine the number of bytes that may be read without blocking.


[heading Parameters]
    

[variablelist
  
[[ec][Set to indicate what error occurred, if any.]]

]

[heading Return Value]
      
The number of bytes that may be read without blocking, or 0 if an error occurs. 



[endsect]


[endsect]

[section:basic_stream_socket basic_stream_socket::basic_stream_socket]

[indexterm2 basic_stream_socket..basic_stream_socket] Construct a basic_stream_socket without opening it. 

  ``[link boost_asio.reference.basic_stream_socket.basic_stream_socket.overload1 basic_stream_socket]``(
      boost::asio::io_service & io_service);

Construct and open a basic_stream_socket. 

  ``[link boost_asio.reference.basic_stream_socket.basic_stream_socket.overload2 basic_stream_socket]``(
      boost::asio::io_service & io_service,
      const protocol_type & protocol);

Construct a basic_stream_socket, opening it and binding it to the given local endpoint. 

  ``[link boost_asio.reference.basic_stream_socket.basic_stream_socket.overload3 basic_stream_socket]``(
      boost::asio::io_service & io_service,
      const endpoint_type & endpoint);

Construct a basic_stream_socket on an existing native socket. 

  ``[link boost_asio.reference.basic_stream_socket.basic_stream_socket.overload4 basic_stream_socket]``(
      boost::asio::io_service & io_service,
      const protocol_type & protocol,
      const native_type & native_socket);


[section:overload1 basic_stream_socket::basic_stream_socket (1 of 4 overloads)]

Construct a basic_stream_socket without opening it. 

  basic_stream_socket(
      boost::asio::io_service & io_service);


This constructor creates a stream socket without opening it. The socket needs to be opened and then connected or accepted before data can be sent or received on it.


[heading Parameters]
    

[variablelist
  
[[io_service][The io\_service object that the stream socket will use to dispatch handlers for any asynchronous operations performed on the socket. ]]

]



[endsect]



[section:overload2 basic_stream_socket::basic_stream_socket (2 of 4 overloads)]

Construct and open a basic_stream_socket. 

  basic_stream_socket(
      boost::asio::io_service & io_service,
      const protocol_type & protocol);


This constructor creates and opens a stream socket. The socket needs to be connected or accepted before data can be sent or received on it.


[heading Parameters]
    

[variablelist
  
[[io_service][The io\_service object that the stream socket will use to dispatch handlers for any asynchronous operations performed on the socket.]]

[[protocol][An object specifying protocol parameters to be used.]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. ]]

]



[endsect]



[section:overload3 basic_stream_socket::basic_stream_socket (3 of 4 overloads)]

Construct a basic_stream_socket, opening it and binding it to the given local endpoint. 

  basic_stream_socket(
      boost::asio::io_service & io_service,
      const endpoint_type & endpoint);


This constructor creates a stream socket and automatically opens it bound to the specified endpoint on the local machine. The protocol used is the protocol associated with the given endpoint.


[heading Parameters]
    

[variablelist
  
[[io_service][The io\_service object that the stream socket will use to dispatch handlers for any asynchronous operations performed on the socket.]]

[[endpoint][An endpoint on the local machine to which the stream socket will be bound.]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. ]]

]



[endsect]



[section:overload4 basic_stream_socket::basic_stream_socket (4 of 4 overloads)]

Construct a basic_stream_socket on an existing native socket. 

  basic_stream_socket(
      boost::asio::io_service & io_service,
      const protocol_type & protocol,
      const native_type & native_socket);


This constructor creates a stream socket object to hold an existing native socket.


[heading Parameters]
    

[variablelist
  
[[io_service][The io\_service object that the stream socket will use to dispatch handlers for any asynchronous operations performed on the socket.]]

[[protocol][An object specifying protocol parameters to be used.]]

[[native_socket][The new underlying socket implementation.]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. ]]

]



[endsect]


[endsect]

[section:bind basic_stream_socket::bind]

[indexterm2 bind..basic_stream_socket] Bind the socket to the given local endpoint. 

  void ``[link boost_asio.reference.basic_stream_socket.bind.overload1 bind]``(
      const endpoint_type & endpoint);

  boost::system::error_code ``[link boost_asio.reference.basic_stream_socket.bind.overload2 bind]``(
      const endpoint_type & endpoint,
      boost::system::error_code & ec);


[section:overload1 basic_stream_socket::bind (1 of 2 overloads)]


['Inherited from basic_socket.]

Bind the socket to the given local endpoint. 

  void bind(
      const endpoint_type & endpoint);


This function binds the socket to the specified endpoint on the local machine.


[heading Parameters]
    

[variablelist
  
[[endpoint][An endpoint on the local machine to which the socket will be bound.]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Example]
  


   boost::asio::ip::tcp::socket socket(io_service);
   socket.open(boost::asio::ip::tcp::v4());
   socket.bind(boost::asio::ip::tcp::endpoint(
         boost::asio::ip::tcp::v4(), 12345));






[endsect]



[section:overload2 basic_stream_socket::bind (2 of 2 overloads)]


['Inherited from basic_socket.]

Bind the socket to the given local endpoint. 

  boost::system::error_code bind(
      const endpoint_type & endpoint,
      boost::system::error_code & ec);


This function binds the socket to the specified endpoint on the local machine.


[heading Parameters]
    

[variablelist
  
[[endpoint][An endpoint on the local machine to which the socket will be bound.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Example]
  


   boost::asio::ip::tcp::socket socket(io_service);
   socket.open(boost::asio::ip::tcp::v4());
   boost::system::error_code ec;
   socket.bind(boost::asio::ip::tcp::endpoint(
         boost::asio::ip::tcp::v4(), 12345), ec);
   if (ec)
   {
     // An error occurred.
   }






[endsect]


[endsect]


[section:broadcast basic_stream_socket::broadcast]


['Inherited from socket_base.]

[indexterm2 broadcast..basic_stream_socket] Socket option to permit sending of broadcast messages. 

  typedef implementation_defined broadcast;



Implements the SOL\_SOCKET/SO\_BROADCAST socket option.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::udp::socket socket(io_service); 
   ...
   boost::asio::socket_base::broadcast option(true);
   socket.set_option(option);




Getting the current option value: 

   boost::asio::ip::udp::socket socket(io_service); 
   ...
   boost::asio::socket_base::broadcast option;
   socket.get_option(option);
   bool is_set = option.value();






[endsect]



[section:bytes_readable basic_stream_socket::bytes_readable]


['Inherited from socket_base.]

[indexterm2 bytes_readable..basic_stream_socket] IO control command to get the amount of data that can be read without blocking. 

  typedef implementation_defined bytes_readable;



Implements the FIONREAD IO control command.


[heading Example]
  


   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::bytes_readable command(true);
   socket.io_control(command);
   std::size_t bytes_readable = command.get();






[endsect]


[section:cancel basic_stream_socket::cancel]

[indexterm2 cancel..basic_stream_socket] Cancel all asynchronous operations associated with the socket. 

  void ``[link boost_asio.reference.basic_stream_socket.cancel.overload1 cancel]``();

  boost::system::error_code ``[link boost_asio.reference.basic_stream_socket.cancel.overload2 cancel]``(
      boost::system::error_code & ec);


[section:overload1 basic_stream_socket::cancel (1 of 2 overloads)]


['Inherited from basic_socket.]

Cancel all asynchronous operations associated with the socket. 

  void cancel();


This function causes all outstanding asynchronous connect, send and receive operations to finish immediately, and the handlers for cancelled operations will be passed the boost::asio::error::operation\_aborted error.


[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Remarks]
      
Calls to cancel() will always fail with boost::asio::error::operation\_not\_supported when run on Windows XP, Windows Server 2003, and earlier versions of Windows, unless BOOST\_ASIO\_ENABLE\_CANCELIO is defined. However, the CancelIo function has two issues that should be considered before enabling its use:

* It will only cancel asynchronous operations that were initiated in the current thread.

* It can appear to complete without error, but the request to cancel the unfinished operations may be silently ignored by the operating system. Whether it works or not seems to depend on the drivers that are installed.

For portable cancellation, consider using one of the following alternatives:


* Disable asio's I/O completion port backend by defining BOOST_ASIO_DISABLE_IOCP.

* Use the close() function to simultaneously cancel the outstanding operations and close the socket.

When running on Windows Vista, Windows Server 2008, and later, the CancelIoEx function is always used. This function does not have the problems described above. 


[endsect]



[section:overload2 basic_stream_socket::cancel (2 of 2 overloads)]


['Inherited from basic_socket.]

Cancel all asynchronous operations associated with the socket. 

  boost::system::error_code cancel(
      boost::system::error_code & ec);


This function causes all outstanding asynchronous connect, send and receive operations to finish immediately, and the handlers for cancelled operations will be passed the boost::asio::error::operation\_aborted error.


[heading Parameters]
    

[variablelist
  
[[ec][Set to indicate what error occurred, if any.]]

]

[heading Remarks]
      
Calls to cancel() will always fail with boost::asio::error::operation\_not\_supported when run on Windows XP, Windows Server 2003, and earlier versions of Windows, unless BOOST\_ASIO\_ENABLE\_CANCELIO is defined. However, the CancelIo function has two issues that should be considered before enabling its use:

* It will only cancel asynchronous operations that were initiated in the current thread.

* It can appear to complete without error, but the request to cancel the unfinished operations may be silently ignored by the operating system. Whether it works or not seems to depend on the drivers that are installed.

For portable cancellation, consider using one of the following alternatives:


* Disable asio's I/O completion port backend by defining BOOST_ASIO_DISABLE_IOCP.

* Use the close() function to simultaneously cancel the outstanding operations and close the socket.

When running on Windows Vista, Windows Server 2008, and later, the CancelIoEx function is always used. This function does not have the problems described above. 


[endsect]


[endsect]

[section:close basic_stream_socket::close]

[indexterm2 close..basic_stream_socket] Close the socket. 

  void ``[link boost_asio.reference.basic_stream_socket.close.overload1 close]``();

  boost::system::error_code ``[link boost_asio.reference.basic_stream_socket.close.overload2 close]``(
      boost::system::error_code & ec);


[section:overload1 basic_stream_socket::close (1 of 2 overloads)]


['Inherited from basic_socket.]

Close the socket. 

  void close();


This function is used to close the socket. Any asynchronous send, receive or connect operations will be cancelled immediately, and will complete with the boost::asio::error::operation\_aborted error.


[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Remarks]
      
For portable behaviour with respect to graceful closure of a connected socket, call shutdown() before closing the socket. 



[endsect]



[section:overload2 basic_stream_socket::close (2 of 2 overloads)]


['Inherited from basic_socket.]

Close the socket. 

  boost::system::error_code close(
      boost::system::error_code & ec);


This function is used to close the socket. Any asynchronous send, receive or connect operations will be cancelled immediately, and will complete with the boost::asio::error::operation\_aborted error.


[heading Parameters]
    

[variablelist
  
[[ec][Set to indicate what error occurred, if any.]]

]

[heading Example]
  


   boost::asio::ip::tcp::socket socket(io_service);
   ...
   boost::system::error_code ec;
   socket.close(ec);
   if (ec)
   {
     // An error occurred.
   }




[heading Remarks]
      
For portable behaviour with respect to graceful closure of a connected socket, call shutdown() before closing the socket. 



[endsect]


[endsect]

[section:connect basic_stream_socket::connect]

[indexterm2 connect..basic_stream_socket] Connect the socket to the specified endpoint. 

  void ``[link boost_asio.reference.basic_stream_socket.connect.overload1 connect]``(
      const endpoint_type & peer_endpoint);

  boost::system::error_code ``[link boost_asio.reference.basic_stream_socket.connect.overload2 connect]``(
      const endpoint_type & peer_endpoint,
      boost::system::error_code & ec);


[section:overload1 basic_stream_socket::connect (1 of 2 overloads)]


['Inherited from basic_socket.]

Connect the socket to the specified endpoint. 

  void connect(
      const endpoint_type & peer_endpoint);


This function is used to connect a socket to the specified remote endpoint. The function call will block until the connection is successfully made or an error occurs.

The socket is automatically opened if it is not already open. If the connect fails, and the socket was automatically opened, the socket is not returned to the closed state.


[heading Parameters]
    

[variablelist
  
[[peer_endpoint][The remote endpoint to which the socket will be connected.]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Example]
  


   boost::asio::ip::tcp::socket socket(io_service);
   boost::asio::ip::tcp::endpoint endpoint(
       boost::asio::ip::address::from_string("1.2.3.4"), 12345);
   socket.connect(endpoint);






[endsect]



[section:overload2 basic_stream_socket::connect (2 of 2 overloads)]


['Inherited from basic_socket.]

Connect the socket to the specified endpoint. 

  boost::system::error_code connect(
      const endpoint_type & peer_endpoint,
      boost::system::error_code & ec);


This function is used to connect a socket to the specified remote endpoint. The function call will block until the connection is successfully made or an error occurs.

The socket is automatically opened if it is not already open. If the connect fails, and the socket was automatically opened, the socket is not returned to the closed state.


[heading Parameters]
    

[variablelist
  
[[peer_endpoint][The remote endpoint to which the socket will be connected.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Example]
  


   boost::asio::ip::tcp::socket socket(io_service);
   boost::asio::ip::tcp::endpoint endpoint(
       boost::asio::ip::address::from_string("1.2.3.4"), 12345);
   boost::system::error_code ec;
   socket.connect(endpoint, ec);
   if (ec)
   {
     // An error occurred.
   }






[endsect]


[endsect]


[section:debug basic_stream_socket::debug]


['Inherited from socket_base.]

[indexterm2 debug..basic_stream_socket] Socket option to enable socket-level debugging. 

  typedef implementation_defined debug;



Implements the SOL\_SOCKET/SO\_DEBUG socket option.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::debug option(true);
   socket.set_option(option);




Getting the current option value: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::debug option;
   socket.get_option(option);
   bool is_set = option.value();






[endsect]



[section:do_not_route basic_stream_socket::do_not_route]


['Inherited from socket_base.]

[indexterm2 do_not_route..basic_stream_socket] Socket option to prevent routing, use local interfaces only. 

  typedef implementation_defined do_not_route;



Implements the SOL\_SOCKET/SO\_DONTROUTE socket option.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::udp::socket socket(io_service); 
   ...
   boost::asio::socket_base::do_not_route option(true);
   socket.set_option(option);




Getting the current option value: 

   boost::asio::ip::udp::socket socket(io_service); 
   ...
   boost::asio::socket_base::do_not_route option;
   socket.get_option(option);
   bool is_set = option.value();






[endsect]



[section:enable_connection_aborted basic_stream_socket::enable_connection_aborted]


['Inherited from socket_base.]

[indexterm2 enable_connection_aborted..basic_stream_socket] Socket option to report aborted connections on accept. 

  typedef implementation_defined enable_connection_aborted;



Implements a custom socket option that determines whether or not an accept operation is permitted to fail with boost::asio::error::connection\_aborted. By default the option is false.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::tcp::acceptor acceptor(io_service); 
   ...
   boost::asio::socket_base::enable_connection_aborted option(true);
   acceptor.set_option(option);




Getting the current option value: 

   boost::asio::ip::tcp::acceptor acceptor(io_service); 
   ...
   boost::asio::socket_base::enable_connection_aborted option;
   acceptor.get_option(option);
   bool is_set = option.value();






[endsect]



[section:endpoint_type basic_stream_socket::endpoint_type]

[indexterm2 endpoint_type..basic_stream_socket] The endpoint type. 

  typedef Protocol::endpoint endpoint_type;




[endsect]



[section:get_io_service basic_stream_socket::get_io_service]


['Inherited from basic_io_object.]

[indexterm2 get_io_service..basic_stream_socket] Get the io_service associated with the object. 

  boost::asio::io_service & get_io_service();


This function may be used to obtain the io_service object that the I/O object uses to dispatch handlers for asynchronous operations.


[heading Return Value]
      
A reference to the io_service object that the I/O object will use to dispatch handlers. Ownership is not transferred to the caller. 



[endsect]


[section:get_option basic_stream_socket::get_option]

[indexterm2 get_option..basic_stream_socket] Get an option from the socket. 

  void ``[link boost_asio.reference.basic_stream_socket.get_option.overload1 get_option]``(
      GettableSocketOption & option) const;

  boost::system::error_code ``[link boost_asio.reference.basic_stream_socket.get_option.overload2 get_option]``(
      GettableSocketOption & option,
      boost::system::error_code & ec) const;


[section:overload1 basic_stream_socket::get_option (1 of 2 overloads)]


['Inherited from basic_socket.]

Get an option from the socket. 

  void get_option(
      GettableSocketOption & option) const;


This function is used to get the current value of an option on the socket.


[heading Parameters]
    

[variablelist
  
[[option][The option value to be obtained from the socket.]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Example]
  
Getting the value of the SOL\_SOCKET/SO\_KEEPALIVE option: 

   boost::asio::ip::tcp::socket socket(io_service);
   ...
   boost::asio::ip::tcp::socket::keep_alive option;
   socket.get_option(option);
   bool is_set = option.get();






[endsect]



[section:overload2 basic_stream_socket::get_option (2 of 2 overloads)]


['Inherited from basic_socket.]

Get an option from the socket. 

  boost::system::error_code get_option(
      GettableSocketOption & option,
      boost::system::error_code & ec) const;


This function is used to get the current value of an option on the socket.


[heading Parameters]
    

[variablelist
  
[[option][The option value to be obtained from the socket.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Example]
  
Getting the value of the SOL\_SOCKET/SO\_KEEPALIVE option: 

   boost::asio::ip::tcp::socket socket(io_service);
   ...
   boost::asio::ip::tcp::socket::keep_alive option;
   boost::system::error_code ec;
   socket.get_option(option, ec);
   if (ec)
   {
     // An error occurred.
   }
   bool is_set = option.get();






[endsect]


[endsect]


[section:implementation basic_stream_socket::implementation]


['Inherited from basic_io_object.]

[indexterm2 implementation..basic_stream_socket] The underlying implementation of the I/O object. 

  implementation_type implementation;



[endsect]



[section:implementation_type basic_stream_socket::implementation_type]


['Inherited from basic_io_object.]

[indexterm2 implementation_type..basic_stream_socket] The underlying implementation type of I/O object. 

  typedef service_type::implementation_type implementation_type;




[endsect]


[section:io_control basic_stream_socket::io_control]

[indexterm2 io_control..basic_stream_socket] Perform an IO control command on the socket. 

  void ``[link boost_asio.reference.basic_stream_socket.io_control.overload1 io_control]``(
      IoControlCommand & command);

  boost::system::error_code ``[link boost_asio.reference.basic_stream_socket.io_control.overload2 io_control]``(
      IoControlCommand & command,
      boost::system::error_code & ec);


[section:overload1 basic_stream_socket::io_control (1 of 2 overloads)]


['Inherited from basic_socket.]

Perform an IO control command on the socket. 

  void io_control(
      IoControlCommand & command);


This function is used to execute an IO control command on the socket.


[heading Parameters]
    

[variablelist
  
[[command][The IO control command to be performed on the socket.]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Example]
  
Getting the number of bytes ready to read: 

   boost::asio::ip::tcp::socket socket(io_service);
   ...
   boost::asio::ip::tcp::socket::bytes_readable command;
   socket.io_control(command);
   std::size_t bytes_readable = command.get();






[endsect]



[section:overload2 basic_stream_socket::io_control (2 of 2 overloads)]


['Inherited from basic_socket.]

Perform an IO control command on the socket. 

  boost::system::error_code io_control(
      IoControlCommand & command,
      boost::system::error_code & ec);


This function is used to execute an IO control command on the socket.


[heading Parameters]
    

[variablelist
  
[[command][The IO control command to be performed on the socket.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Example]
  
Getting the number of bytes ready to read: 

   boost::asio::ip::tcp::socket socket(io_service);
   ...
   boost::asio::ip::tcp::socket::bytes_readable command;
   boost::system::error_code ec;
   socket.io_control(command, ec);
   if (ec)
   {
     // An error occurred.
   }
   std::size_t bytes_readable = command.get();






[endsect]


[endsect]


[section:io_service basic_stream_socket::io_service]


['Inherited from basic_io_object.]

[indexterm2 io_service..basic_stream_socket] (Deprecated: use get_io_service().) Get the io_service associated with the object. 

  boost::asio::io_service & io_service();


This function may be used to obtain the io_service object that the I/O object uses to dispatch handlers for asynchronous operations.


[heading Return Value]
      
A reference to the io_service object that the I/O object will use to dispatch handlers. Ownership is not transferred to the caller. 



[endsect]



[section:is_open basic_stream_socket::is_open]


['Inherited from basic_socket.]

[indexterm2 is_open..basic_stream_socket] Determine whether the socket is open. 

  bool is_open() const;



[endsect]



[section:keep_alive basic_stream_socket::keep_alive]


['Inherited from socket_base.]

[indexterm2 keep_alive..basic_stream_socket] Socket option to send keep-alives. 

  typedef implementation_defined keep_alive;



Implements the SOL\_SOCKET/SO\_KEEPALIVE socket option.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::keep_alive option(true);
   socket.set_option(option);




Getting the current option value: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::keep_alive option;
   socket.get_option(option);
   bool is_set = option.value();






[endsect]



[section:linger basic_stream_socket::linger]


['Inherited from socket_base.]

[indexterm2 linger..basic_stream_socket] Socket option to specify whether the socket lingers on close if unsent data is present. 

  typedef implementation_defined linger;



Implements the SOL\_SOCKET/SO\_LINGER socket option.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::linger option(true, 30);
   socket.set_option(option);




Getting the current option value: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::linger option;
   socket.get_option(option);
   bool is_set = option.enabled();
   unsigned short timeout = option.timeout();






[endsect]


[section:local_endpoint basic_stream_socket::local_endpoint]

[indexterm2 local_endpoint..basic_stream_socket] Get the local endpoint of the socket. 

  endpoint_type ``[link boost_asio.reference.basic_stream_socket.local_endpoint.overload1 local_endpoint]``() const;

  endpoint_type ``[link boost_asio.reference.basic_stream_socket.local_endpoint.overload2 local_endpoint]``(
      boost::system::error_code & ec) const;


[section:overload1 basic_stream_socket::local_endpoint (1 of 2 overloads)]


['Inherited from basic_socket.]

Get the local endpoint of the socket. 

  endpoint_type local_endpoint() const;


This function is used to obtain the locally bound endpoint of the socket.


[heading Return Value]
      
An object that represents the local endpoint of the socket.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Example]
  


   boost::asio::ip::tcp::socket socket(io_service);
   ...
   boost::asio::ip::tcp::endpoint endpoint = socket.local_endpoint();






[endsect]



[section:overload2 basic_stream_socket::local_endpoint (2 of 2 overloads)]


['Inherited from basic_socket.]

Get the local endpoint of the socket. 

  endpoint_type local_endpoint(
      boost::system::error_code & ec) const;


This function is used to obtain the locally bound endpoint of the socket.


[heading Parameters]
    

[variablelist
  
[[ec][Set to indicate what error occurred, if any.]]

]

[heading Return Value]
      
An object that represents the local endpoint of the socket. Returns a default-constructed endpoint object if an error occurred.

[heading Example]
  


   boost::asio::ip::tcp::socket socket(io_service);
   ...
   boost::system::error_code ec;
   boost::asio::ip::tcp::endpoint endpoint = socket.local_endpoint(ec);
   if (ec)
   {
     // An error occurred.
   }






[endsect]


[endsect]

[section:lowest_layer basic_stream_socket::lowest_layer]

[indexterm2 lowest_layer..basic_stream_socket] Get a reference to the lowest layer. 

  lowest_layer_type & ``[link boost_asio.reference.basic_stream_socket.lowest_layer.overload1 lowest_layer]``();

Get a const reference to the lowest layer. 

  const lowest_layer_type & ``[link boost_asio.reference.basic_stream_socket.lowest_layer.overload2 lowest_layer]``() const;


[section:overload1 basic_stream_socket::lowest_layer (1 of 2 overloads)]


['Inherited from basic_socket.]

Get a reference to the lowest layer. 

  lowest_layer_type & lowest_layer();


This function returns a reference to the lowest layer in a stack of layers. Since a basic_socket cannot contain any further layers, it simply returns a reference to itself.


[heading Return Value]
      
A reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller. 



[endsect]



[section:overload2 basic_stream_socket::lowest_layer (2 of 2 overloads)]


['Inherited from basic_socket.]

Get a const reference to the lowest layer. 

  const lowest_layer_type & lowest_layer() const;


This function returns a const reference to the lowest layer in a stack of layers. Since a basic_socket cannot contain any further layers, it simply returns a reference to itself.


[heading Return Value]
      
A const reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller. 



[endsect]


[endsect]


[section:lowest_layer_type basic_stream_socket::lowest_layer_type]


['Inherited from basic_socket.]

[indexterm2 lowest_layer_type..basic_stream_socket] A basic_socket is always the lowest layer. 

  typedef basic_socket< Protocol, StreamSocketService > lowest_layer_type;


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.basic_socket.broadcast [*broadcast]]]
    [Socket option to permit sending of broadcast messages. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.bytes_readable [*bytes_readable]]]
    [IO control command to get the amount of data that can be read without blocking. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.debug [*debug]]]
    [Socket option to enable socket-level debugging. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.do_not_route [*do_not_route]]]
    [Socket option to prevent routing, use local interfaces only. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.enable_connection_aborted [*enable_connection_aborted]]]
    [Socket option to report aborted connections on accept. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.endpoint_type [*endpoint_type]]]
    [The endpoint type. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.implementation_type [*implementation_type]]]
    [The underlying implementation type of I/O object. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.keep_alive [*keep_alive]]]
    [Socket option to send keep-alives. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.linger [*linger]]]
    [Socket option to specify whether the socket lingers on close if unsent data is present. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.lowest_layer_type [*lowest_layer_type]]]
    [A basic_socket is always the lowest layer. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.message_flags [*message_flags]]]
    [Bitmask type for flags that can be passed to send and receive operations. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.native_type [*native_type]]]
    [The native representation of a socket. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.non_blocking_io [*non_blocking_io]]]
    [IO control command to set the blocking mode of the socket. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.protocol_type [*protocol_type]]]
    [The protocol type. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.receive_buffer_size [*receive_buffer_size]]]
    [Socket option for the receive buffer size of a socket. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.receive_low_watermark [*receive_low_watermark]]]
    [Socket option for the receive low watermark. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.reuse_address [*reuse_address]]]
    [Socket option to allow the socket to be bound to an address that is already in use. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.send_buffer_size [*send_buffer_size]]]
    [Socket option for the send buffer size of a socket. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.send_low_watermark [*send_low_watermark]]]
    [Socket option for the send low watermark. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.service_type [*service_type]]]
    [The type of the service that will be used to provide I/O operations. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket.shutdown_type [*shutdown_type]]]
    [Different ways a socket may be shutdown. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_socket.assign [*assign]]]
    [Assign an existing native socket to the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.async_connect [*async_connect]]]
    [Start an asynchronous connect. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.at_mark [*at_mark]]]
    [Determine whether the socket is at the out-of-band data mark. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.available [*available]]]
    [Determine the number of bytes available for reading. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.basic_socket [*basic_socket]]]
    [Construct a basic_socket without opening it. 

     Construct and open a basic_socket. 

     Construct a basic_socket, opening it and binding it to the given local endpoint. 

     Construct a basic_socket on an existing native socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.bind [*bind]]]
    [Bind the socket to the given local endpoint. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.cancel [*cancel]]]
    [Cancel all asynchronous operations associated with the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.close [*close]]]
    [Close the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.connect [*connect]]]
    [Connect the socket to the specified endpoint. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.get_io_service [*get_io_service]]]
    [Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.get_option [*get_option]]]
    [Get an option from the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.io_control [*io_control]]]
    [Perform an IO control command on the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.io_service [*io_service]]]
    [(Deprecated: use get_io_service().) Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.is_open [*is_open]]]
    [Determine whether the socket is open. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.local_endpoint [*local_endpoint]]]
    [Get the local endpoint of the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.lowest_layer [*lowest_layer]]]
    [Get a reference to the lowest layer. 

     Get a const reference to the lowest layer. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.native [*native]]]
    [Get the native socket representation. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.open [*open]]]
    [Open the socket using the specified protocol. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.remote_endpoint [*remote_endpoint]]]
    [Get the remote endpoint of the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.set_option [*set_option]]]
    [Set an option on the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket.shutdown [*shutdown]]]
    [Disable sends or receives on the socket. ]
  ]
  
]

[heading Protected Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_socket._basic_socket [*~basic_socket]]]
    [Protected destructor to prevent deletion through this type. ]
  ]
  
]

[heading Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_socket.max_connections [*max_connections]]]
    [The maximum length of the queue of pending incoming connections. ]
  ]

  [
    [[link boost_asio.reference.basic_socket.message_do_not_route [*message_do_not_route]]]
    [Specify that the data should not be subject to routing. ]
  ]

  [
    [[link boost_asio.reference.basic_socket.message_out_of_band [*message_out_of_band]]]
    [Process out-of-band data. ]
  ]

  [
    [[link boost_asio.reference.basic_socket.message_peek [*message_peek]]]
    [Peek at incoming data without removing it from the input queue. ]
  ]

]

[heading Protected Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_socket.implementation [*implementation]]]
    [The underlying implementation of the I/O object. ]
  ]

  [
    [[link boost_asio.reference.basic_socket.service [*service]]]
    [The service associated with the I/O object. ]
  ]

]

The basic_socket class template provides functionality that is common to both stream-oriented and datagram-oriented sockets.


[heading Thread Safety]
  
[*Distinct] [*objects:]  Safe.

[*Shared] [*objects:]  Unsafe. 




[endsect]



[section:max_connections basic_stream_socket::max_connections]


['Inherited from socket_base.]

[indexterm2 max_connections..basic_stream_socket] The maximum length of the queue of pending incoming connections. 

  static const int max_connections = implementation_defined;



[endsect]



[section:message_do_not_route basic_stream_socket::message_do_not_route]


['Inherited from socket_base.]

[indexterm2 message_do_not_route..basic_stream_socket] Specify that the data should not be subject to routing. 

  static const int message_do_not_route = implementation_defined;



[endsect]



[section:message_flags basic_stream_socket::message_flags]


['Inherited from socket_base.]

[indexterm2 message_flags..basic_stream_socket] Bitmask type for flags that can be passed to send and receive operations. 

  typedef int message_flags;




[endsect]



[section:message_out_of_band basic_stream_socket::message_out_of_band]


['Inherited from socket_base.]

[indexterm2 message_out_of_band..basic_stream_socket] Process out-of-band data. 

  static const int message_out_of_band = implementation_defined;



[endsect]



[section:message_peek basic_stream_socket::message_peek]


['Inherited from socket_base.]

[indexterm2 message_peek..basic_stream_socket] Peek at incoming data without removing it from the input queue. 

  static const int message_peek = implementation_defined;



[endsect]



[section:native basic_stream_socket::native]


['Inherited from basic_socket.]

[indexterm2 native..basic_stream_socket] Get the native socket representation. 

  native_type native();


This function may be used to obtain the underlying representation of the socket. This is intended to allow access to native socket functionality that is not otherwise provided. 


[endsect]



[section:native_type basic_stream_socket::native_type]

[indexterm2 native_type..basic_stream_socket] The native representation of a socket. 

  typedef StreamSocketService::native_type native_type;




[endsect]



[section:non_blocking_io basic_stream_socket::non_blocking_io]


['Inherited from socket_base.]

[indexterm2 non_blocking_io..basic_stream_socket] IO control command to set the blocking mode of the socket. 

  typedef implementation_defined non_blocking_io;



Implements the FIONBIO IO control command.


[heading Example]
  


   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::non_blocking_io command(true);
   socket.io_control(command);






[endsect]


[section:open basic_stream_socket::open]

[indexterm2 open..basic_stream_socket] Open the socket using the specified protocol. 

  void ``[link boost_asio.reference.basic_stream_socket.open.overload1 open]``(
      const protocol_type & protocol = protocol_type());

  boost::system::error_code ``[link boost_asio.reference.basic_stream_socket.open.overload2 open]``(
      const protocol_type & protocol,
      boost::system::error_code & ec);


[section:overload1 basic_stream_socket::open (1 of 2 overloads)]


['Inherited from basic_socket.]

Open the socket using the specified protocol. 

  void open(
      const protocol_type & protocol = protocol_type());


This function opens the socket so that it will use the specified protocol.


[heading Parameters]
    

[variablelist
  
[[protocol][An object specifying protocol parameters to be used.]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Example]
  


   boost::asio::ip::tcp::socket socket(io_service);
   socket.open(boost::asio::ip::tcp::v4());






[endsect]



[section:overload2 basic_stream_socket::open (2 of 2 overloads)]


['Inherited from basic_socket.]

Open the socket using the specified protocol. 

  boost::system::error_code open(
      const protocol_type & protocol,
      boost::system::error_code & ec);


This function opens the socket so that it will use the specified protocol.


[heading Parameters]
    

[variablelist
  
[[protocol][An object specifying which protocol is to be used.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Example]
  


   boost::asio::ip::tcp::socket socket(io_service);
   boost::system::error_code ec;
   socket.open(boost::asio::ip::tcp::v4(), ec);
   if (ec)
   {
     // An error occurred.
   }






[endsect]


[endsect]


[section:protocol_type basic_stream_socket::protocol_type]

[indexterm2 protocol_type..basic_stream_socket] The protocol type. 

  typedef Protocol protocol_type;




[endsect]


[section:read_some basic_stream_socket::read_some]

[indexterm2 read_some..basic_stream_socket] Read some data from the socket. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t ``[link boost_asio.reference.basic_stream_socket.read_some.overload1 read_some]``(
      const MutableBufferSequence & buffers);

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t ``[link boost_asio.reference.basic_stream_socket.read_some.overload2 read_some]``(
      const MutableBufferSequence & buffers,
      boost::system::error_code & ec);


[section:overload1 basic_stream_socket::read_some (1 of 2 overloads)]

Read some data from the socket. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t read_some(
      const MutableBufferSequence & buffers);


This function is used to read data from the stream socket. The function call will block until one or more bytes of data has been read successfully, or until an error occurs.


[heading Parameters]
    

[variablelist
  
[[buffers][One or more buffers into which the data will be read.]]

]

[heading Return Value]
      
The number of bytes read.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. An error code of boost::asio::error::eof indicates that the connection was closed by the peer.]]

]

[heading Remarks]
      
The read\_some operation may not read all of the requested number of bytes. Consider using the 
[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.

[heading Example]
  
To read into a single data buffer use the 
[link boost_asio.reference.buffer buffer]  function as follows: 

   socket.read_some(boost::asio::buffer(data, size));


See the 
[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. 



[endsect]



[section:overload2 basic_stream_socket::read_some (2 of 2 overloads)]

Read some data from the socket. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t read_some(
      const MutableBufferSequence & buffers,
      boost::system::error_code & ec);


This function is used to read data from the stream socket. The function call will block until one or more bytes of data has been read successfully, or until an error occurs.


[heading Parameters]
    

[variablelist
  
[[buffers][One or more buffers into which the data will be read.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Return Value]
      
The number of bytes read. Returns 0 if an error occurred.

[heading Remarks]
      
The read\_some operation may not read all of the requested number of bytes. Consider using the 
[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. 



[endsect]


[endsect]

[section:receive basic_stream_socket::receive]

[indexterm2 receive..basic_stream_socket] Receive some data on the socket. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t ``[link boost_asio.reference.basic_stream_socket.receive.overload1 receive]``(
      const MutableBufferSequence & buffers);

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t ``[link boost_asio.reference.basic_stream_socket.receive.overload2 receive]``(
      const MutableBufferSequence & buffers,
      socket_base::message_flags flags);

Receive some data on a connected socket. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t ``[link boost_asio.reference.basic_stream_socket.receive.overload3 receive]``(
      const MutableBufferSequence & buffers,
      socket_base::message_flags flags,
      boost::system::error_code & ec);


[section:overload1 basic_stream_socket::receive (1 of 3 overloads)]

Receive some data on the socket. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t receive(
      const MutableBufferSequence & buffers);


This function is used to receive data on the stream socket. The function call will block until one or more bytes of data has been received successfully, or until an error occurs.


[heading Parameters]
    

[variablelist
  
[[buffers][One or more buffers into which the data will be received.]]

]

[heading Return Value]
      
The number of bytes received.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. An error code of boost::asio::error::eof indicates that the connection was closed by the peer.]]

]

[heading Remarks]
      
The receive operation may not receive all of the requested number of bytes. Consider using the 
[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.

[heading Example]
  
To receive into a single data buffer use the 
[link boost_asio.reference.buffer buffer]  function as follows: 

   socket.receive(boost::asio::buffer(data, size));


See the 
[link boost_asio.reference.buffer buffer]  documentation for information on receiving into multiple buffers in one go, and how to use it with arrays, boost::array or std::vector. 



[endsect]



[section:overload2 basic_stream_socket::receive (2 of 3 overloads)]

Receive some data on the socket. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t receive(
      const MutableBufferSequence & buffers,
      socket_base::message_flags flags);


This function is used to receive data on the stream socket. The function call will block until one or more bytes of data has been received successfully, or until an error occurs.


[heading Parameters]
    

[variablelist
  
[[buffers][One or more buffers into which the data will be received.]]

[[flags][Flags specifying how the receive call is to be made.]]

]

[heading Return Value]
      
The number of bytes received.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. An error code of boost::asio::error::eof indicates that the connection was closed by the peer.]]

]

[heading Remarks]
      
The receive operation may not receive all of the requested number of bytes. Consider using the 
[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.

[heading Example]
  
To receive into a single data buffer use the 
[link boost_asio.reference.buffer buffer]  function as follows: 

   socket.receive(boost::asio::buffer(data, size), 0);


See the 
[link boost_asio.reference.buffer buffer]  documentation for information on receiving into multiple buffers in one go, and how to use it with arrays, boost::array or std::vector. 



[endsect]



[section:overload3 basic_stream_socket::receive (3 of 3 overloads)]

Receive some data on a connected socket. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t receive(
      const MutableBufferSequence & buffers,
      socket_base::message_flags flags,
      boost::system::error_code & ec);


This function is used to receive data on the stream socket. The function call will block until one or more bytes of data has been received successfully, or until an error occurs.


[heading Parameters]
    

[variablelist
  
[[buffers][One or more buffers into which the data will be received.]]

[[flags][Flags specifying how the receive call is to be made.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Return Value]
      
The number of bytes received. Returns 0 if an error occurred.

[heading Remarks]
      
The receive operation may not receive all of the requested number of bytes. Consider using the 
[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. 



[endsect]


[endsect]


[section:receive_buffer_size basic_stream_socket::receive_buffer_size]


['Inherited from socket_base.]

[indexterm2 receive_buffer_size..basic_stream_socket] Socket option for the receive buffer size of a socket. 

  typedef implementation_defined receive_buffer_size;



Implements the SOL\_SOCKET/SO\_RCVBUF socket option.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::receive_buffer_size option(8192);
   socket.set_option(option);




Getting the current option value: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::receive_buffer_size option;
   socket.get_option(option);
   int size = option.value();






[endsect]



[section:receive_low_watermark basic_stream_socket::receive_low_watermark]


['Inherited from socket_base.]

[indexterm2 receive_low_watermark..basic_stream_socket] Socket option for the receive low watermark. 

  typedef implementation_defined receive_low_watermark;



Implements the SOL\_SOCKET/SO\_RCVLOWAT socket option.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::receive_low_watermark option(1024);
   socket.set_option(option);




Getting the current option value: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::receive_low_watermark option;
   socket.get_option(option);
   int size = option.value();






[endsect]


[section:remote_endpoint basic_stream_socket::remote_endpoint]

[indexterm2 remote_endpoint..basic_stream_socket] Get the remote endpoint of the socket. 

  endpoint_type ``[link boost_asio.reference.basic_stream_socket.remote_endpoint.overload1 remote_endpoint]``() const;

  endpoint_type ``[link boost_asio.reference.basic_stream_socket.remote_endpoint.overload2 remote_endpoint]``(
      boost::system::error_code & ec) const;


[section:overload1 basic_stream_socket::remote_endpoint (1 of 2 overloads)]


['Inherited from basic_socket.]

Get the remote endpoint of the socket. 

  endpoint_type remote_endpoint() const;


This function is used to obtain the remote endpoint of the socket.


[heading Return Value]
      
An object that represents the remote endpoint of the socket.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Example]
  


   boost::asio::ip::tcp::socket socket(io_service);
   ...
   boost::asio::ip::tcp::endpoint endpoint = socket.remote_endpoint();






[endsect]



[section:overload2 basic_stream_socket::remote_endpoint (2 of 2 overloads)]


['Inherited from basic_socket.]

Get the remote endpoint of the socket. 

  endpoint_type remote_endpoint(
      boost::system::error_code & ec) const;


This function is used to obtain the remote endpoint of the socket.


[heading Parameters]
    

[variablelist
  
[[ec][Set to indicate what error occurred, if any.]]

]

[heading Return Value]
      
An object that represents the remote endpoint of the socket. Returns a default-constructed endpoint object if an error occurred.

[heading Example]
  


   boost::asio::ip::tcp::socket socket(io_service);
   ...
   boost::system::error_code ec;
   boost::asio::ip::tcp::endpoint endpoint = socket.remote_endpoint(ec);
   if (ec)
   {
     // An error occurred.
   }






[endsect]


[endsect]


[section:reuse_address basic_stream_socket::reuse_address]


['Inherited from socket_base.]

[indexterm2 reuse_address..basic_stream_socket] Socket option to allow the socket to be bound to an address that is already in use. 

  typedef implementation_defined reuse_address;



Implements the SOL\_SOCKET/SO\_REUSEADDR socket option.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::tcp::acceptor acceptor(io_service); 
   ...
   boost::asio::socket_base::reuse_address option(true);
   acceptor.set_option(option);




Getting the current option value: 

   boost::asio::ip::tcp::acceptor acceptor(io_service); 
   ...
   boost::asio::socket_base::reuse_address option;
   acceptor.get_option(option);
   bool is_set = option.value();






[endsect]


[section:send basic_stream_socket::send]

[indexterm2 send..basic_stream_socket] Send some data on the socket. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t ``[link boost_asio.reference.basic_stream_socket.send.overload1 send]``(
      const ConstBufferSequence & buffers);

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t ``[link boost_asio.reference.basic_stream_socket.send.overload2 send]``(
      const ConstBufferSequence & buffers,
      socket_base::message_flags flags);

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t ``[link boost_asio.reference.basic_stream_socket.send.overload3 send]``(
      const ConstBufferSequence & buffers,
      socket_base::message_flags flags,
      boost::system::error_code & ec);


[section:overload1 basic_stream_socket::send (1 of 3 overloads)]

Send some data on the socket. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t send(
      const ConstBufferSequence & buffers);


This function is used to send data on the stream socket. The function call will block until one or more bytes of the data has been sent successfully, or an until error occurs.


[heading Parameters]
    

[variablelist
  
[[buffers][One or more data buffers to be sent on the socket.]]

]

[heading Return Value]
      
The number of bytes sent.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Remarks]
      
The send operation may not transmit all of the data to the peer. Consider using the 
[link boost_asio.reference.write write]  function if you need to ensure that all data is written before the blocking operation completes.

[heading Example]
  
To send a single data buffer use the 
[link boost_asio.reference.buffer buffer]  function as follows: 

   socket.send(boost::asio::buffer(data, size));


See the 
[link boost_asio.reference.buffer buffer]  documentation for information on sending multiple buffers in one go, and how to use it with arrays, boost::array or std::vector. 



[endsect]



[section:overload2 basic_stream_socket::send (2 of 3 overloads)]

Send some data on the socket. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t send(
      const ConstBufferSequence & buffers,
      socket_base::message_flags flags);


This function is used to send data on the stream socket. The function call will block until one or more bytes of the data has been sent successfully, or an until error occurs.


[heading Parameters]
    

[variablelist
  
[[buffers][One or more data buffers to be sent on the socket.]]

[[flags][Flags specifying how the send call is to be made.]]

]

[heading Return Value]
      
The number of bytes sent.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Remarks]
      
The send operation may not transmit all of the data to the peer. Consider using the 
[link boost_asio.reference.write write]  function if you need to ensure that all data is written before the blocking operation completes.

[heading Example]
  
To send a single data buffer use the 
[link boost_asio.reference.buffer buffer]  function as follows: 

   socket.send(boost::asio::buffer(data, size), 0);


See the 
[link boost_asio.reference.buffer buffer]  documentation for information on sending multiple buffers in one go, and how to use it with arrays, boost::array or std::vector. 



[endsect]



[section:overload3 basic_stream_socket::send (3 of 3 overloads)]

Send some data on the socket. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t send(
      const ConstBufferSequence & buffers,
      socket_base::message_flags flags,
      boost::system::error_code & ec);


This function is used to send data on the stream socket. The function call will block until one or more bytes of the data has been sent successfully, or an until error occurs.


[heading Parameters]
    

[variablelist
  
[[buffers][One or more data buffers to be sent on the socket.]]

[[flags][Flags specifying how the send call is to be made.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Return Value]
      
The number of bytes sent. Returns 0 if an error occurred.

[heading Remarks]
      
The send operation may not transmit all of the data to the peer. Consider using the 
[link boost_asio.reference.write write]  function if you need to ensure that all data is written before the blocking operation completes. 



[endsect]


[endsect]


[section:send_buffer_size basic_stream_socket::send_buffer_size]


['Inherited from socket_base.]

[indexterm2 send_buffer_size..basic_stream_socket] Socket option for the send buffer size of a socket. 

  typedef implementation_defined send_buffer_size;



Implements the SOL\_SOCKET/SO\_SNDBUF socket option.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::send_buffer_size option(8192);
   socket.set_option(option);




Getting the current option value: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::send_buffer_size option;
   socket.get_option(option);
   int size = option.value();






[endsect]



[section:send_low_watermark basic_stream_socket::send_low_watermark]


['Inherited from socket_base.]

[indexterm2 send_low_watermark..basic_stream_socket] Socket option for the send low watermark. 

  typedef implementation_defined send_low_watermark;



Implements the SOL\_SOCKET/SO\_SNDLOWAT socket option.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::send_low_watermark option(1024);
   socket.set_option(option);




Getting the current option value: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::send_low_watermark option;
   socket.get_option(option);
   int size = option.value();






[endsect]



[section:service basic_stream_socket::service]


['Inherited from basic_io_object.]

[indexterm2 service..basic_stream_socket] The service associated with the I/O object. 

  service_type & service;



[endsect]



[section:service_type basic_stream_socket::service_type]


['Inherited from basic_io_object.]

[indexterm2 service_type..basic_stream_socket] The type of the service that will be used to provide I/O operations. 

  typedef StreamSocketService service_type;




[endsect]


[section:set_option basic_stream_socket::set_option]

[indexterm2 set_option..basic_stream_socket] Set an option on the socket. 

  void ``[link boost_asio.reference.basic_stream_socket.set_option.overload1 set_option]``(
      const SettableSocketOption & option);

  boost::system::error_code ``[link boost_asio.reference.basic_stream_socket.set_option.overload2 set_option]``(
      const SettableSocketOption & option,
      boost::system::error_code & ec);


[section:overload1 basic_stream_socket::set_option (1 of 2 overloads)]


['Inherited from basic_socket.]

Set an option on the socket. 

  void set_option(
      const SettableSocketOption & option);


This function is used to set an option on the socket.


[heading Parameters]
    

[variablelist
  
[[option][The new option value to be set on the socket.]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Example]
  
Setting the IPPROTO\_TCP/TCP\_NODELAY option: 

   boost::asio::ip::tcp::socket socket(io_service);
   ...
   boost::asio::ip::tcp::no_delay option(true);
   socket.set_option(option);






[endsect]



[section:overload2 basic_stream_socket::set_option (2 of 2 overloads)]


['Inherited from basic_socket.]

Set an option on the socket. 

  boost::system::error_code set_option(
      const SettableSocketOption & option,
      boost::system::error_code & ec);


This function is used to set an option on the socket.


[heading Parameters]
    

[variablelist
  
[[option][The new option value to be set on the socket.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Example]
  
Setting the IPPROTO\_TCP/TCP\_NODELAY option: 

   boost::asio::ip::tcp::socket socket(io_service);
   ...
   boost::asio::ip::tcp::no_delay option(true);
   boost::system::error_code ec;
   socket.set_option(option, ec);
   if (ec)
   {
     // An error occurred.
   }






[endsect]


[endsect]

[section:shutdown basic_stream_socket::shutdown]

[indexterm2 shutdown..basic_stream_socket] Disable sends or receives on the socket. 

  void ``[link boost_asio.reference.basic_stream_socket.shutdown.overload1 shutdown]``(
      shutdown_type what);

  boost::system::error_code ``[link boost_asio.reference.basic_stream_socket.shutdown.overload2 shutdown]``(
      shutdown_type what,
      boost::system::error_code & ec);


[section:overload1 basic_stream_socket::shutdown (1 of 2 overloads)]


['Inherited from basic_socket.]

Disable sends or receives on the socket. 

  void shutdown(
      shutdown_type what);


This function is used to disable send operations, receive operations, or both.


[heading Parameters]
    

[variablelist
  
[[what][Determines what types of operation will no longer be allowed.]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Example]
  
Shutting down the send side of the socket: 

   boost::asio::ip::tcp::socket socket(io_service);
   ...
   socket.shutdown(boost::asio::ip::tcp::socket::shutdown_send);






[endsect]



[section:overload2 basic_stream_socket::shutdown (2 of 2 overloads)]


['Inherited from basic_socket.]

Disable sends or receives on the socket. 

  boost::system::error_code shutdown(
      shutdown_type what,
      boost::system::error_code & ec);


This function is used to disable send operations, receive operations, or both.


[heading Parameters]
    

[variablelist
  
[[what][Determines what types of operation will no longer be allowed.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Example]
  
Shutting down the send side of the socket: 

   boost::asio::ip::tcp::socket socket(io_service);
   ...
   boost::system::error_code ec;
   socket.shutdown(boost::asio::ip::tcp::socket::shutdown_send, ec);
   if (ec)
   {
     // An error occurred.
   }






[endsect]


[endsect]


[section:shutdown_type basic_stream_socket::shutdown_type]


['Inherited from socket_base.]

[indexterm2 shutdown_type..basic_stream_socket] Different ways a socket may be shutdown. 

  enum shutdown_type

[heading Values]
[variablelist

  [
    [shutdown_receive]
    [Shutdown the receive side of the socket. ]
  ]

  [
    [shutdown_send]
    [Shutdown the send side of the socket. ]
  ]

  [
    [shutdown_both]
    [Shutdown both send and receive on the socket. ]
  ]

]



[endsect]


[section:write_some basic_stream_socket::write_some]

[indexterm2 write_some..basic_stream_socket] Write some data to the socket. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t ``[link boost_asio.reference.basic_stream_socket.write_some.overload1 write_some]``(
      const ConstBufferSequence & buffers);

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t ``[link boost_asio.reference.basic_stream_socket.write_some.overload2 write_some]``(
      const ConstBufferSequence & buffers,
      boost::system::error_code & ec);


[section:overload1 basic_stream_socket::write_some (1 of 2 overloads)]

Write some data to the socket. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t write_some(
      const ConstBufferSequence & buffers);


This function is used to write data to the stream socket. The function call will block until one or more bytes of the data has been written successfully, or until an error occurs.


[heading Parameters]
    

[variablelist
  
[[buffers][One or more data buffers to be written to the socket.]]

]

[heading Return Value]
      
The number of bytes written.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. An error code of boost::asio::error::eof indicates that the connection was closed by the peer.]]

]

[heading Remarks]
      
The write\_some operation may not transmit all of the data to the peer. Consider using the 
[link boost_asio.reference.write write]  function if you need to ensure that all data is written before the blocking operation completes.

[heading Example]
  
To write a single data buffer use the 
[link boost_asio.reference.buffer buffer]  function as follows: 

   socket.write_some(boost::asio::buffer(data, size));


See the 
[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. 



[endsect]



[section:overload2 basic_stream_socket::write_some (2 of 2 overloads)]

Write some data to the socket. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t write_some(
      const ConstBufferSequence & buffers,
      boost::system::error_code & ec);


This function is used to write data to the stream socket. The function call will block until one or more bytes of the data has been written successfully, or until an error occurs.


[heading Parameters]
    

[variablelist
  
[[buffers][One or more data buffers to be written to the socket.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Return Value]
      
The number of bytes written. Returns 0 if an error occurred.

[heading Remarks]
      
The write\_some operation may not transmit all of the data to the peer. Consider using the 
[link boost_asio.reference.write write]  function if you need to ensure that all data is written before the blocking operation completes. 



[endsect]


[endsect]


[endsect]

[section:basic_streambuf basic_streambuf]

Automatically resizable buffer class based on std::streambuf. 

  template<
      typename Allocator = std::allocator<char>>
  class basic_streambuf :
    noncopyable


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.basic_streambuf.const_buffers_type [*const_buffers_type]]]
    [The type used to represent the input sequence as a list of buffers. ]
  
  ]

  [

    [[link boost_asio.reference.basic_streambuf.mutable_buffers_type [*mutable_buffers_type]]]
    [The type used to represent the output sequence as a list of buffers. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_streambuf.basic_streambuf [*basic_streambuf]]]
    [Construct a basic_streambuf object. ]
  ]
  
  [
    [[link boost_asio.reference.basic_streambuf.commit [*commit]]]
    [Move characters from the output sequence to the input sequence. ]
  ]
  
  [
    [[link boost_asio.reference.basic_streambuf.consume [*consume]]]
    [Remove characters from the input sequence. ]
  ]
  
  [
    [[link boost_asio.reference.basic_streambuf.data [*data]]]
    [Get a list of buffers that represents the input sequence. ]
  ]
  
  [
    [[link boost_asio.reference.basic_streambuf.max_size [*max_size]]]
    [Get the maximum size of the basic_streambuf. ]
  ]
  
  [
    [[link boost_asio.reference.basic_streambuf.prepare [*prepare]]]
    [Get a list of buffers that represents the output sequence, with the given size. ]
  ]
  
  [
    [[link boost_asio.reference.basic_streambuf.size [*size]]]
    [Get the size of the input sequence. ]
  ]
  
]

[heading Protected Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_streambuf.overflow [*overflow]]]
    [Override std::streambuf behaviour. ]
  ]
  
  [
    [[link boost_asio.reference.basic_streambuf.reserve [*reserve]]]
    []
  ]
  
  [
    [[link boost_asio.reference.basic_streambuf.underflow [*underflow]]]
    [Override std::streambuf behaviour. ]
  ]
  
]

The `basic_streambuf` class is derived from `std::streambuf` to associate the streambuf's input and output sequences with one or more character arrays. These character arrays are internal to the `basic_streambuf` object, but direct access to the array elements is provided to permit them to be used efficiently with I/O operations. Characters written to the output sequence of a `basic_streambuf` object are appended to the input sequence of the same object.

The `basic_streambuf` class's public interface is intended to permit the following implementation strategies:


* A single contiguous character array, which is reallocated as necessary to accommodate changes in the size of the character sequence. This is the implementation approach currently used in Asio.

* A sequence of one or more character arrays, where each array is of the same size. Additional character array objects are appended to the sequence to accommodate changes in the size of the character sequence.

* A sequence of one or more character arrays of varying sizes. Additional character array objects are appended to the sequence to accommodate changes in the size of the character sequence.

The constructor for basic_streambuf accepts a `size_t` argument specifying the maximum of the sum of the sizes of the input sequence and output sequence. During the lifetime of the `basic_streambuf` object, the following invariant holds: 

   size() <= max_size()


Any member function that would, if successful, cause the invariant to be violated shall throw an exception of class `std::length_error`.

The constructor for `basic_streambuf` takes an Allocator argument. A copy of this argument is used for any memory allocation performed, by the constructor and by all member functions, during the lifetime of each `basic_streambuf` object.


[heading Examples]
  
Writing directly from an streambuf to a socket: 

   boost::asio::streambuf b;
   std::ostream os(&b);
   os << "Hello, World!\n";

   // try sending some data in input sequence
   size_t n = sock.send(b.data());

   b.consume(n); // sent data is removed from input sequence




Reading from a socket directly into a streambuf: 

   boost::asio::streambuf b;

   // reserve 512 bytes in output sequence
   boost::asio::streambuf::const_buffers_type bufs = b.prepare(512);

   size_t n = sock.receive(bufs);

   // received data is "committed" from output sequence to input sequence
   b.commit(n);

   std::istream is(&b);
   std::string s;
   is >> s;





[section:basic_streambuf basic_streambuf::basic_streambuf]

[indexterm2 basic_streambuf..basic_streambuf] Construct a basic_streambuf object. 

  basic_streambuf(
      std::size_t max_size = (std::numeric_limits< std::size_t >::max)(),
      const Allocator & allocator = Allocator());


Constructs a streambuf with the specified maximum size. The initial size of the streambuf's input sequence is 0. 


[endsect]



[section:commit basic_streambuf::commit]

[indexterm2 commit..basic_streambuf] Move characters from the output sequence to the input sequence. 

  void commit(
      std::size_t n);


Appends `n` characters from the start of the output sequence to the input sequence. The beginning of the output sequence is advanced by `n` characters.

Requires a preceding call `prepare(x)` where `x >= n`, and no intervening operations that modify the input or output sequence.


[heading Exceptions]
    

[variablelist
  
[[std::length_error][If `n` is greater than the size of the output sequence. ]]

]



[endsect]



[section:const_buffers_type basic_streambuf::const_buffers_type]

[indexterm2 const_buffers_type..basic_streambuf] The type used to represent the input sequence as a list of buffers. 

  typedef implementation_defined const_buffers_type;




[endsect]



[section:consume basic_streambuf::consume]

[indexterm2 consume..basic_streambuf] Remove characters from the input sequence. 

  void consume(
      std::size_t n);


Removes `n` characters from the beginning of the input sequence.


[heading Exceptions]
    

[variablelist
  
[[std::length_error][If `n > size()`. ]]

]



[endsect]



[section:data basic_streambuf::data]

[indexterm2 data..basic_streambuf] Get a list of buffers that represents the input sequence. 

  const_buffers_type data() const;



[heading Return Value]
      
An object of type `const_buffers_type` that satisfies ConstBufferSequence requirements, representing all character arrays in the input sequence.

[heading Remarks]
      
The returned object is invalidated by any `basic_streambuf` member function that modifies the input sequence or output sequence. 



[endsect]



[section:max_size basic_streambuf::max_size]

[indexterm2 max_size..basic_streambuf] Get the maximum size of the basic_streambuf. 

  std::size_t max_size() const;



[heading Return Value]
      
The allowed maximum of the sum of the sizes of the input sequence and output sequence. 



[endsect]



[section:mutable_buffers_type basic_streambuf::mutable_buffers_type]

[indexterm2 mutable_buffers_type..basic_streambuf] The type used to represent the output sequence as a list of buffers. 

  typedef implementation_defined mutable_buffers_type;




[endsect]



[section:overflow basic_streambuf::overflow]

[indexterm2 overflow..basic_streambuf] Override std::streambuf behaviour. 

  int_type overflow(
      int_type c);


Behaves according to the specification of `std::streambuf::overflow()`, with the specialisation that `std::length_error` is thrown if appending the character to the input sequence would require the condition `size() > max_size()` to be true. 


[endsect]



[section:prepare basic_streambuf::prepare]

[indexterm2 prepare..basic_streambuf] Get a list of buffers that represents the output sequence, with the given size. 

  mutable_buffers_type prepare(
      std::size_t n);


Ensures that the output sequence can accommodate `n` characters, reallocating character array objects as necessary.


[heading Return Value]
      
An object of type `mutable_buffers_type` that satisfies MutableBufferSequence requirements, representing character array objects at the start of the output sequence such that the sum of the buffer sizes is `n`.

[heading Exceptions]
    

[variablelist
  
[[std::length_error][If `size() + n > max_size()`.]]

]

[heading Remarks]
      
The returned object is invalidated by any `basic_streambuf` member function that modifies the input sequence or output sequence. 



[endsect]



[section:reserve basic_streambuf::reserve]

[indexterm2 reserve..basic_streambuf] 

  void reserve(
      std::size_t n);



[endsect]



[section:size basic_streambuf::size]

[indexterm2 size..basic_streambuf] Get the size of the input sequence. 

  std::size_t size() const;



[heading Return Value]
      
The size of the input sequence. The value is equal to that calculated for `s` in the following code: 

   size_t s = 0;
   const_buffers_type bufs = data();
   const_buffers_type::const_iterator i = bufs.begin();
   while (i != bufs.end())
   {
     const_buffer buf(*i++);
     s += buffer_size(buf);
   }






[endsect]



[section:underflow basic_streambuf::underflow]

[indexterm2 underflow..basic_streambuf] Override std::streambuf behaviour. 

  int_type underflow();


Behaves according to the specification of `std::streambuf::underflow()`. 


[endsect]



[endsect]

[section:buffer buffer]

[indexterm1 buffer] The boost::asio::buffer function is used to create a buffer object to represent raw memory, an array of POD elements, a vector of POD elements, or a std::string. 
      
  mutable_buffers_1 ``[link boost_asio.reference.buffer.overload1 buffer]``(
      const mutable_buffer & b);

  mutable_buffers_1 ``[link boost_asio.reference.buffer.overload2 buffer]``(
      const mutable_buffer & b,
      std::size_t max_size_in_bytes);

  const_buffers_1 ``[link boost_asio.reference.buffer.overload3 buffer]``(
      const const_buffer & b);

  const_buffers_1 ``[link boost_asio.reference.buffer.overload4 buffer]``(
      const const_buffer & b,
      std::size_t max_size_in_bytes);

  mutable_buffers_1 ``[link boost_asio.reference.buffer.overload5 buffer]``(
      void * data,
      std::size_t size_in_bytes);

  const_buffers_1 ``[link boost_asio.reference.buffer.overload6 buffer]``(
      const void * data,
      std::size_t size_in_bytes);

  template<
      typename PodType,
      std::size_t N>
  mutable_buffers_1 ``[link boost_asio.reference.buffer.overload7 buffer]``(
      PodType & data);

  template<
      typename PodType,
      std::size_t N>
  mutable_buffers_1 ``[link boost_asio.reference.buffer.overload8 buffer]``(
      PodType & data,
      std::size_t max_size_in_bytes);

  template<
      typename PodType,
      std::size_t N>
  const_buffers_1 ``[link boost_asio.reference.buffer.overload9 buffer]``(
      const PodType & data);

  template<
      typename PodType,
      std::size_t N>
  const_buffers_1 ``[link boost_asio.reference.buffer.overload10 buffer]``(
      const PodType & data,
      std::size_t max_size_in_bytes);

  template<
      typename PodType,
      std::size_t N>
  mutable_buffers_1 ``[link boost_asio.reference.buffer.overload11 buffer]``(
      boost::array< PodType, N > & data);

  template<
      typename PodType,
      std::size_t N>
  mutable_buffers_1 ``[link boost_asio.reference.buffer.overload12 buffer]``(
      boost::array< PodType, N > & data,
      std::size_t max_size_in_bytes);

  template<
      typename PodType,
      std::size_t N>
  const_buffers_1 ``[link boost_asio.reference.buffer.overload13 buffer]``(
      boost::array< const PodType, N > & data);

  template<
      typename PodType,
      std::size_t N>
  const_buffers_1 ``[link boost_asio.reference.buffer.overload14 buffer]``(
      boost::array< const PodType, N > & data,
      std::size_t max_size_in_bytes);

  template<
      typename PodType,
      std::size_t N>
  const_buffers_1 ``[link boost_asio.reference.buffer.overload15 buffer]``(
      const boost::array< PodType, N > & data);

  template<
      typename PodType,
      std::size_t N>
  const_buffers_1 ``[link boost_asio.reference.buffer.overload16 buffer]``(
      const boost::array< PodType, N > & data,
      std::size_t max_size_in_bytes);

  template<
      typename PodType,
      typename Allocator>
  mutable_buffers_1 ``[link boost_asio.reference.buffer.overload17 buffer]``(
      std::vector< PodType, Allocator > & data);

  template<
      typename PodType,
      typename Allocator>
  mutable_buffers_1 ``[link boost_asio.reference.buffer.overload18 buffer]``(
      std::vector< PodType, Allocator > & data,
      std::size_t max_size_in_bytes);

  template<
      typename PodType,
      typename Allocator>
  const_buffers_1 ``[link boost_asio.reference.buffer.overload19 buffer]``(
      const std::vector< PodType, Allocator > & data);

  template<
      typename PodType,
      typename Allocator>
  const_buffers_1 ``[link boost_asio.reference.buffer.overload20 buffer]``(
      const std::vector< PodType, Allocator > & data,
      std::size_t max_size_in_bytes);

  const_buffers_1 ``[link boost_asio.reference.buffer.overload21 buffer]``(
      const std::string & data);

  const_buffers_1 ``[link boost_asio.reference.buffer.overload22 buffer]``(
      const std::string & data,
      std::size_t max_size_in_bytes);

A buffer object represents a contiguous region of memory as a 2-tuple consisting of a pointer and size in bytes. A tuple of the form `{void*, size_t}` specifies a mutable (modifiable) region of memory. Similarly, a tuple of the form `{const void*, size_t}` specifies a const (non-modifiable) region of memory. These two forms correspond to the classes mutable_buffer and const_buffer, respectively. To mirror C++'s conversion rules, a mutable_buffer is implicitly convertible to a const_buffer, and the opposite conversion is not permitted.

The simplest use case involves reading or writing a single buffer of a specified size:



   sock.send(boost::asio::buffer(data, size)); 




In the above example, the return value of boost::asio::buffer meets the requirements of the ConstBufferSequence concept so that it may be directly passed to the socket's write function. A buffer created for modifiable memory also meets the requirements of the MutableBufferSequence concept.

An individual buffer may be created from a builtin array, std::vector or boost::array of POD elements. This helps prevent buffer overruns by automatically determining the size of the buffer:



   char d1[128];
   size_t bytes_transferred = sock.receive(boost::asio::buffer(d1));

   std::vector<char> d2(128);
   bytes_transferred = sock.receive(boost::asio::buffer(d2));

   boost::array<char, 128> d3;
   bytes_transferred = sock.receive(boost::asio::buffer(d3)); 




In all three cases above, the buffers created are exactly 128 bytes long. Note that a vector is [*never]  automatically resized when creating or using a buffer. The buffer size is determined using the vector's `size()` member function, and not its capacity.


[heading Accessing Buffer Contents]
  


The contents of a buffer may be accessed using the boost::asio::buffer\_size and boost::asio::buffer\_cast functions:



   boost::asio::mutable_buffer b1 = ...;
   std::size_t s1 = boost::asio::buffer_size(b1);
   unsigned char* p1 = boost::asio::buffer_cast<unsigned char*>(b1);

   boost::asio::const_buffer b2 = ...;
   std::size_t s2 = boost::asio::buffer_size(b2);
   const void* p2 = boost::asio::buffer_cast<const void*>(b2); 




The boost::asio::buffer\_cast function permits violations of type safety, so uses of it in application code should be carefully considered.


[heading Buffer Invalidation]
  


A buffer object does not have any ownership of the memory it refers to. It is the responsibility of the application to ensure the memory region remains valid until it is no longer required for an I/O operation. When the memory is no longer available, the buffer is said to have been invalidated.

For the boost::asio::buffer overloads that accept an argument of type std::vector, the buffer objects returned are invalidated by any vector operation that also invalidates all references, pointers and iterators referring to the elements in the sequence (C++ Std, 23.2.4)

For the boost::asio::buffer overloads that accept an argument of type std::string, the buffer objects returned are invalidated according to the rules defined for invalidation of references, pointers and iterators referring to elements of the sequence (C++ Std, 21.3).


[heading Buffer Arithmetic]
  


Buffer objects may be manipulated using simple arithmetic in a safe way which helps prevent buffer overruns. Consider an array initialised as follows:



   boost::array<char, 6> a = { 'a', 'b', 'c', 'd', 'e' }; 




A buffer object `b1` created using:



   b1 = boost::asio::buffer(a); 




represents the entire array, `{ 'a', 'b', 'c', 'd', 'e' }`. An optional second argument to the boost::asio::buffer function may be used to limit the size, in bytes, of the buffer:



   b2 = boost::asio::buffer(a, 3); 




such that `b2` represents the data `{ 'a', 'b', 'c' }`. Even if the size argument exceeds the actual size of the array, the size of the buffer object created will be limited to the array size.

An offset may be applied to an existing buffer to create a new one:



   b3 = b1 + 2; 




where `b3` will set to represent `{ 'c', 'd', 'e' }`. If the offset exceeds the size of the existing buffer, the newly created buffer will be empty.

Both an offset and size may be specified to create a buffer that corresponds to a specific range of bytes within an existing buffer:



   b4 = boost::asio::buffer(b1 + 1, 3); 




so that `b4` will refer to the bytes `{ 'b', 'c', 'd' }`.


[heading Buffers and Scatter-Gather I/O]
  


To read or write using multiple buffers (i.e. scatter-gather I/O), multiple buffer objects may be assigned into a container that supports the MutableBufferSequence (for read) or ConstBufferSequence (for write) concepts:



   char d1[128];
   std::vector<char> d2(128);
   boost::array<char, 128> d3;

   boost::array<mutable_buffer, 3> bufs1 = {
     boost::asio::buffer(d1),
     boost::asio::buffer(d2),
     boost::asio::buffer(d3) };
   bytes_transferred = sock.receive(bufs1);

   std::vector<const_buffer> bufs2;
   bufs2.push_back(boost::asio::buffer(d1));
   bufs2.push_back(boost::asio::buffer(d2));
   bufs2.push_back(boost::asio::buffer(d3));
   bytes_transferred = sock.send(bufs2); 





[section:overload1 buffer (1 of 22 overloads)]

Create a new modifiable buffer from an existing buffer. 

  mutable_buffers_1 buffer(
      const mutable_buffer & b);



[heading Return Value]
      
`mutable_buffers_1(b)`. 



[endsect]



[section:overload2 buffer (2 of 22 overloads)]

Create a new modifiable buffer from an existing buffer. 

  mutable_buffers_1 buffer(
      const mutable_buffer & b,
      std::size_t max_size_in_bytes);



[heading Return Value]
      
A mutable_buffers_1 value equivalent to: 

   mutable_buffers_1(
       buffer_cast<void*>(b),
       min(buffer_size(b), max_size_in_bytes)); 






[endsect]



[section:overload3 buffer (3 of 22 overloads)]

Create a new non-modifiable buffer from an existing buffer. 

  const_buffers_1 buffer(
      const const_buffer & b);



[heading Return Value]
      
`const_buffers_1(b)`. 



[endsect]



[section:overload4 buffer (4 of 22 overloads)]

Create a new non-modifiable buffer from an existing buffer. 

  const_buffers_1 buffer(
      const const_buffer & b,
      std::size_t max_size_in_bytes);



[heading Return Value]
      
A const_buffers_1 value equivalent to: 

   const_buffers_1(
       buffer_cast<const void*>(b),
       min(buffer_size(b), max_size_in_bytes)); 






[endsect]



[section:overload5 buffer (5 of 22 overloads)]

Create a new modifiable buffer that represents the given memory range. 

  mutable_buffers_1 buffer(
      void * data,
      std::size_t size_in_bytes);



[heading Return Value]
      
`mutable_buffers_1(data, size_in_bytes)`. 



[endsect]



[section:overload6 buffer (6 of 22 overloads)]

Create a new non-modifiable buffer that represents the given memory range. 

  const_buffers_1 buffer(
      const void * data,
      std::size_t size_in_bytes);



[heading Return Value]
      
`const_buffers_1(data, size_in_bytes)`. 



[endsect]



[section:overload7 buffer (7 of 22 overloads)]

Create a new modifiable buffer that represents the given POD array. 

  template<
      typename PodType,
      std::size_t N>
  mutable_buffers_1 buffer(
      PodType & data);



[heading Return Value]
      
A mutable_buffers_1 value equivalent to: 

   mutable_buffers_1(
       static_cast<void*>(data),
       N * sizeof(PodType)); 






[endsect]



[section:overload8 buffer (8 of 22 overloads)]

Create a new modifiable buffer that represents the given POD array. 

  template<
      typename PodType,
      std::size_t N>
  mutable_buffers_1 buffer(
      PodType & data,
      std::size_t max_size_in_bytes);



[heading Return Value]
      
A mutable_buffers_1 value equivalent to: 

   mutable_buffers_1(
       static_cast<void*>(data),
       min(N * sizeof(PodType), max_size_in_bytes)); 






[endsect]



[section:overload9 buffer (9 of 22 overloads)]

Create a new non-modifiable buffer that represents the given POD array. 

  template<
      typename PodType,
      std::size_t N>
  const_buffers_1 buffer(
      const PodType & data);



[heading Return Value]
      
A const_buffers_1 value equivalent to: 

   const_buffers_1(
       static_cast<const void*>(data),
       N * sizeof(PodType)); 






[endsect]



[section:overload10 buffer (10 of 22 overloads)]

Create a new non-modifiable buffer that represents the given POD array. 

  template<
      typename PodType,
      std::size_t N>
  const_buffers_1 buffer(
      const PodType & data,
      std::size_t max_size_in_bytes);



[heading Return Value]
      
A const_buffers_1 value equivalent to: 

   const_buffers_1(
       static_cast<const void*>(data),
       min(N * sizeof(PodType), max_size_in_bytes)); 






[endsect]



[section:overload11 buffer (11 of 22 overloads)]

Create a new modifiable buffer that represents the given POD array. 

  template<
      typename PodType,
      std::size_t N>
  mutable_buffers_1 buffer(
      boost::array< PodType, N > & data);



[heading Return Value]
      
A mutable_buffers_1 value equivalent to: 

   mutable_buffers_1(
       data.data(),
       data.size() * sizeof(PodType)); 






[endsect]



[section:overload12 buffer (12 of 22 overloads)]

Create a new modifiable buffer that represents the given POD array. 

  template<
      typename PodType,
      std::size_t N>
  mutable_buffers_1 buffer(
      boost::array< PodType, N > & data,
      std::size_t max_size_in_bytes);



[heading Return Value]
      
A mutable_buffers_1 value equivalent to: 

   mutable_buffers_1(
       data.data(),
       min(data.size() * sizeof(PodType), max_size_in_bytes)); 






[endsect]



[section:overload13 buffer (13 of 22 overloads)]

Create a new non-modifiable buffer that represents the given POD array. 

  template<
      typename PodType,
      std::size_t N>
  const_buffers_1 buffer(
      boost::array< const PodType, N > & data);



[heading Return Value]
      
A const_buffers_1 value equivalent to: 

   const_buffers_1(
       data.data(),
       data.size() * sizeof(PodType)); 






[endsect]



[section:overload14 buffer (14 of 22 overloads)]

Create a new non-modifiable buffer that represents the given POD array. 

  template<
      typename PodType,
      std::size_t N>
  const_buffers_1 buffer(
      boost::array< const PodType, N > & data,
      std::size_t max_size_in_bytes);



[heading Return Value]
      
A const_buffers_1 value equivalent to: 

   const_buffers_1(
       data.data(),
       min(data.size() * sizeof(PodType), max_size_in_bytes)); 






[endsect]



[section:overload15 buffer (15 of 22 overloads)]

Create a new non-modifiable buffer that represents the given POD array. 

  template<
      typename PodType,
      std::size_t N>
  const_buffers_1 buffer(
      const boost::array< PodType, N > & data);



[heading Return Value]
      
A const_buffers_1 value equivalent to: 

   const_buffers_1(
       data.data(),
       data.size() * sizeof(PodType)); 






[endsect]



[section:overload16 buffer (16 of 22 overloads)]

Create a new non-modifiable buffer that represents the given POD array. 

  template<
      typename PodType,
      std::size_t N>
  const_buffers_1 buffer(
      const boost::array< PodType, N > & data,
      std::size_t max_size_in_bytes);



[heading Return Value]
      
A const_buffers_1 value equivalent to: 

   const_buffers_1(
       data.data(),
       min(data.size() * sizeof(PodType), max_size_in_bytes)); 






[endsect]



[section:overload17 buffer (17 of 22 overloads)]

Create a new modifiable buffer that represents the given POD vector. 

  template<
      typename PodType,
      typename Allocator>
  mutable_buffers_1 buffer(
      std::vector< PodType, Allocator > & data);



[heading Return Value]
      
A mutable_buffers_1 value equivalent to: 

   mutable_buffers_1(
       data.size() ? &data[0] : 0,
       data.size() * sizeof(PodType)); 




[heading Remarks]
      
The buffer is invalidated by any vector operation that would also invalidate iterators. 



[endsect]



[section:overload18 buffer (18 of 22 overloads)]

Create a new modifiable buffer that represents the given POD vector. 

  template<
      typename PodType,
      typename Allocator>
  mutable_buffers_1 buffer(
      std::vector< PodType, Allocator > & data,
      std::size_t max_size_in_bytes);



[heading Return Value]
      
A mutable_buffers_1 value equivalent to: 

   mutable_buffers_1(
       data.size() ? &data[0] : 0,
       min(data.size() * sizeof(PodType), max_size_in_bytes)); 




[heading Remarks]
      
The buffer is invalidated by any vector operation that would also invalidate iterators. 



[endsect]



[section:overload19 buffer (19 of 22 overloads)]

Create a new non-modifiable buffer that represents the given POD vector. 

  template<
      typename PodType,
      typename Allocator>
  const_buffers_1 buffer(
      const std::vector< PodType, Allocator > & data);



[heading Return Value]
      
A const_buffers_1 value equivalent to: 

   const_buffers_1(
       data.size() ? &data[0] : 0,
       data.size() * sizeof(PodType)); 




[heading Remarks]
      
The buffer is invalidated by any vector operation that would also invalidate iterators. 



[endsect]



[section:overload20 buffer (20 of 22 overloads)]

Create a new non-modifiable buffer that represents the given POD vector. 

  template<
      typename PodType,
      typename Allocator>
  const_buffers_1 buffer(
      const std::vector< PodType, Allocator > & data,
      std::size_t max_size_in_bytes);



[heading Return Value]
      
A const_buffers_1 value equivalent to: 

   const_buffers_1(
       data.size() ? &data[0] : 0,
       min(data.size() * sizeof(PodType), max_size_in_bytes)); 




[heading Remarks]
      
The buffer is invalidated by any vector operation that would also invalidate iterators. 



[endsect]



[section:overload21 buffer (21 of 22 overloads)]

Create a new non-modifiable buffer that represents the given string. 

  const_buffers_1 buffer(
      const std::string & data);



[heading Return Value]
      
`const_buffers_1(data.data(), data.size())`.

[heading Remarks]
      
The buffer is invalidated by any non-const operation called on the given string object. 



[endsect]



[section:overload22 buffer (22 of 22 overloads)]

Create a new non-modifiable buffer that represents the given string. 

  const_buffers_1 buffer(
      const std::string & data,
      std::size_t max_size_in_bytes);



[heading Return Value]
      
A const_buffers_1 value equivalent to: 

   const_buffers_1(
       data.data(),
       min(data.size(), max_size_in_bytes)); 




[heading Remarks]
      
The buffer is invalidated by any non-const operation called on the given string object. 



[endsect]


[endsect]

[section:buffered_read_stream buffered_read_stream]

Adds buffering to the read-related operations of a stream. 

  template<
      typename Stream>
  class buffered_read_stream :
    noncopyable


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.buffered_read_stream.lowest_layer_type [*lowest_layer_type]]]
    [The type of the lowest layer. ]
  
  ]

  [

    [[link boost_asio.reference.buffered_read_stream.next_layer_type [*next_layer_type]]]
    [The type of the next layer. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.buffered_read_stream.async_fill [*async_fill]]]
    [Start an asynchronous fill. ]
  ]
  
  [
    [[link boost_asio.reference.buffered_read_stream.async_read_some [*async_read_some]]]
    [Start an asynchronous read. The buffer into which the data will be read must be valid for the lifetime of the asynchronous operation. ]
  ]
  
  [
    [[link boost_asio.reference.buffered_read_stream.async_write_some [*async_write_some]]]
    [Start an asynchronous write. The data being written must be valid for the lifetime of the asynchronous operation. ]
  ]
  
  [
    [[link boost_asio.reference.buffered_read_stream.buffered_read_stream [*buffered_read_stream]]]
    [Construct, passing the specified argument to initialise the next layer. ]
  ]
  
  [
    [[link boost_asio.reference.buffered_read_stream.close [*close]]]
    [Close the stream. ]
  ]
  
  [
    [[link boost_asio.reference.buffered_read_stream.fill [*fill]]]
    [Fill the buffer with some data. Returns the number of bytes placed in the buffer as a result of the operation. Throws an exception on failure. 

     Fill the buffer with some data. Returns the number of bytes placed in the buffer as a result of the operation, or 0 if an error occurred. ]
  ]
  
  [
    [[link boost_asio.reference.buffered_read_stream.get_io_service [*get_io_service]]]
    [Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.buffered_read_stream.in_avail [*in_avail]]]
    [Determine the amount of data that may be read without blocking. ]
  ]
  
  [
    [[link boost_asio.reference.buffered_read_stream.io_service [*io_service]]]
    [(Deprecated: use get_io_service().) Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.buffered_read_stream.lowest_layer [*lowest_layer]]]
    [Get a reference to the lowest layer. 

     Get a const reference to the lowest layer. ]
  ]
  
  [
    [[link boost_asio.reference.buffered_read_stream.next_layer [*next_layer]]]
    [Get a reference to the next layer. ]
  ]
  
  [
    [[link boost_asio.reference.buffered_read_stream.peek [*peek]]]
    [Peek at the incoming data on the stream. Returns the number of bytes read. Throws an exception on failure. 

     Peek at the incoming data on the stream. Returns the number of bytes read, or 0 if an error occurred. ]
  ]
  
  [
    [[link boost_asio.reference.buffered_read_stream.read_some [*read_some]]]
    [Read some data from the stream. Returns the number of bytes read. Throws an exception on failure. 

     Read some data from the stream. Returns the number of bytes read or 0 if an error occurred. ]
  ]
  
  [
    [[link boost_asio.reference.buffered_read_stream.write_some [*write_some]]]
    [Write the given data to the stream. Returns the number of bytes written. Throws an exception on failure. 

     Write the given data to the stream. Returns the number of bytes written, or 0 if an error occurred. ]
  ]
  
]

[heading Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.buffered_read_stream.default_buffer_size [*default_buffer_size]]]
    [The default buffer size. ]
  ]

]

The buffered_read_stream class template can be used to add buffering to the synchronous and asynchronous read operations of a stream.


[heading Thread Safety]
  
[*Distinct] [*objects:]  Safe.

[*Shared] [*objects:]  Unsafe.



[section:async_fill buffered_read_stream::async_fill]

[indexterm2 async_fill..buffered_read_stream] Start an asynchronous fill. 

  template<
      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
  void async_fill(
      ReadHandler handler);



[endsect]



[section:async_read_some buffered_read_stream::async_read_some]

[indexterm2 async_read_some..buffered_read_stream] Start an asynchronous read. The buffer into which the data will be read must be valid for the lifetime of the asynchronous operation. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
  void async_read_some(
      const MutableBufferSequence & buffers,
      ReadHandler handler);



[endsect]



[section:async_write_some buffered_read_stream::async_write_some]

[indexterm2 async_write_some..buffered_read_stream] Start an asynchronous write. The data being written must be valid for the lifetime of the asynchronous operation. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
  void async_write_some(
      const ConstBufferSequence & buffers,
      WriteHandler handler);



[endsect]


[section:buffered_read_stream buffered_read_stream::buffered_read_stream]

[indexterm2 buffered_read_stream..buffered_read_stream] Construct, passing the specified argument to initialise the next layer. 

  template<
      typename Arg>
  ``[link boost_asio.reference.buffered_read_stream.buffered_read_stream.overload1 buffered_read_stream]``(
      Arg & a);

  template<
      typename Arg>
  ``[link boost_asio.reference.buffered_read_stream.buffered_read_stream.overload2 buffered_read_stream]``(
      Arg & a,
      std::size_t buffer_size);


[section:overload1 buffered_read_stream::buffered_read_stream (1 of 2 overloads)]

Construct, passing the specified argument to initialise the next layer. 

  template<
      typename Arg>
  buffered_read_stream(
      Arg & a);



[endsect]



[section:overload2 buffered_read_stream::buffered_read_stream (2 of 2 overloads)]

Construct, passing the specified argument to initialise the next layer. 

  template<
      typename Arg>
  buffered_read_stream(
      Arg & a,
      std::size_t buffer_size);



[endsect]


[endsect]

[section:close buffered_read_stream::close]

[indexterm2 close..buffered_read_stream] Close the stream. 

  void ``[link boost_asio.reference.buffered_read_stream.close.overload1 close]``();

  boost::system::error_code ``[link boost_asio.reference.buffered_read_stream.close.overload2 close]``(
      boost::system::error_code & ec);


[section:overload1 buffered_read_stream::close (1 of 2 overloads)]

Close the stream. 

  void close();



[endsect]



[section:overload2 buffered_read_stream::close (2 of 2 overloads)]

Close the stream. 

  boost::system::error_code close(
      boost::system::error_code & ec);



[endsect]


[endsect]


[section:default_buffer_size buffered_read_stream::default_buffer_size]

[indexterm2 default_buffer_size..buffered_read_stream] The default buffer size. 

  static const std::size_t default_buffer_size = implementation_defined;



[endsect]


[section:fill buffered_read_stream::fill]

[indexterm2 fill..buffered_read_stream] Fill the buffer with some data. Returns the number of bytes placed in the buffer as a result of the operation. Throws an exception on failure. 

  std::size_t ``[link boost_asio.reference.buffered_read_stream.fill.overload1 fill]``();

Fill the buffer with some data. Returns the number of bytes placed in the buffer as a result of the operation, or 0 if an error occurred. 

  std::size_t ``[link boost_asio.reference.buffered_read_stream.fill.overload2 fill]``(
      boost::system::error_code & ec);


[section:overload1 buffered_read_stream::fill (1 of 2 overloads)]

Fill the buffer with some data. Returns the number of bytes placed in the buffer as a result of the operation. Throws an exception on failure. 

  std::size_t fill();



[endsect]



[section:overload2 buffered_read_stream::fill (2 of 2 overloads)]

Fill the buffer with some data. Returns the number of bytes placed in the buffer as a result of the operation, or 0 if an error occurred. 

  std::size_t fill(
      boost::system::error_code & ec);



[endsect]


[endsect]


[section:get_io_service buffered_read_stream::get_io_service]

[indexterm2 get_io_service..buffered_read_stream] Get the io_service associated with the object. 

  boost::asio::io_service & get_io_service();



[endsect]


[section:in_avail buffered_read_stream::in_avail]

[indexterm2 in_avail..buffered_read_stream] Determine the amount of data that may be read without blocking. 

  std::size_t ``[link boost_asio.reference.buffered_read_stream.in_avail.overload1 in_avail]``();

  std::size_t ``[link boost_asio.reference.buffered_read_stream.in_avail.overload2 in_avail]``(
      boost::system::error_code & ec);


[section:overload1 buffered_read_stream::in_avail (1 of 2 overloads)]

Determine the amount of data that may be read without blocking. 

  std::size_t in_avail();



[endsect]



[section:overload2 buffered_read_stream::in_avail (2 of 2 overloads)]

Determine the amount of data that may be read without blocking. 

  std::size_t in_avail(
      boost::system::error_code & ec);



[endsect]


[endsect]


[section:io_service buffered_read_stream::io_service]

[indexterm2 io_service..buffered_read_stream] (Deprecated: use get_io_service().) Get the io_service associated with the object. 

  boost::asio::io_service & io_service();



[endsect]


[section:lowest_layer buffered_read_stream::lowest_layer]

[indexterm2 lowest_layer..buffered_read_stream] Get a reference to the lowest layer. 

  lowest_layer_type & ``[link boost_asio.reference.buffered_read_stream.lowest_layer.overload1 lowest_layer]``();

Get a const reference to the lowest layer. 

  const lowest_layer_type & ``[link boost_asio.reference.buffered_read_stream.lowest_layer.overload2 lowest_layer]``() const;


[section:overload1 buffered_read_stream::lowest_layer (1 of 2 overloads)]

Get a reference to the lowest layer. 

  lowest_layer_type & lowest_layer();



[endsect]



[section:overload2 buffered_read_stream::lowest_layer (2 of 2 overloads)]

Get a const reference to the lowest layer. 

  const lowest_layer_type & lowest_layer() const;



[endsect]


[endsect]


[section:lowest_layer_type buffered_read_stream::lowest_layer_type]

[indexterm2 lowest_layer_type..buffered_read_stream] The type of the lowest layer. 

  typedef next_layer_type::lowest_layer_type lowest_layer_type;




[endsect]



[section:next_layer buffered_read_stream::next_layer]

[indexterm2 next_layer..buffered_read_stream] Get a reference to the next layer. 

  next_layer_type & next_layer();



[endsect]



[section:next_layer_type buffered_read_stream::next_layer_type]

[indexterm2 next_layer_type..buffered_read_stream] The type of the next layer. 

  typedef boost::remove_reference< Stream >::type next_layer_type;




[endsect]


[section:peek buffered_read_stream::peek]

[indexterm2 peek..buffered_read_stream] Peek at the incoming data on the stream. Returns the number of bytes read. Throws an exception on failure. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t ``[link boost_asio.reference.buffered_read_stream.peek.overload1 peek]``(
      const MutableBufferSequence & buffers);

Peek at the incoming data on the stream. Returns the number of bytes read, or 0 if an error occurred. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t ``[link boost_asio.reference.buffered_read_stream.peek.overload2 peek]``(
      const MutableBufferSequence & buffers,
      boost::system::error_code & ec);


[section:overload1 buffered_read_stream::peek (1 of 2 overloads)]

Peek at the incoming data on the stream. Returns the number of bytes read. Throws an exception on failure. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t peek(
      const MutableBufferSequence & buffers);



[endsect]



[section:overload2 buffered_read_stream::peek (2 of 2 overloads)]

Peek at the incoming data on the stream. Returns the number of bytes read, or 0 if an error occurred. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t peek(
      const MutableBufferSequence & buffers,
      boost::system::error_code & ec);



[endsect]


[endsect]

[section:read_some buffered_read_stream::read_some]

[indexterm2 read_some..buffered_read_stream] Read some data from the stream. Returns the number of bytes read. Throws an exception on failure. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t ``[link boost_asio.reference.buffered_read_stream.read_some.overload1 read_some]``(
      const MutableBufferSequence & buffers);

Read some data from the stream. Returns the number of bytes read or 0 if an error occurred. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t ``[link boost_asio.reference.buffered_read_stream.read_some.overload2 read_some]``(
      const MutableBufferSequence & buffers,
      boost::system::error_code & ec);


[section:overload1 buffered_read_stream::read_some (1 of 2 overloads)]

Read some data from the stream. Returns the number of bytes read. Throws an exception on failure. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t read_some(
      const MutableBufferSequence & buffers);



[endsect]



[section:overload2 buffered_read_stream::read_some (2 of 2 overloads)]

Read some data from the stream. Returns the number of bytes read or 0 if an error occurred. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t read_some(
      const MutableBufferSequence & buffers,
      boost::system::error_code & ec);



[endsect]


[endsect]

[section:write_some buffered_read_stream::write_some]

[indexterm2 write_some..buffered_read_stream] Write the given data to the stream. Returns the number of bytes written. Throws an exception on failure. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t ``[link boost_asio.reference.buffered_read_stream.write_some.overload1 write_some]``(
      const ConstBufferSequence & buffers);

Write the given data to the stream. Returns the number of bytes written, or 0 if an error occurred. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t ``[link boost_asio.reference.buffered_read_stream.write_some.overload2 write_some]``(
      const ConstBufferSequence & buffers,
      boost::system::error_code & ec);


[section:overload1 buffered_read_stream::write_some (1 of 2 overloads)]

Write the given data to the stream. Returns the number of bytes written. Throws an exception on failure. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t write_some(
      const ConstBufferSequence & buffers);



[endsect]



[section:overload2 buffered_read_stream::write_some (2 of 2 overloads)]

Write the given data to the stream. Returns the number of bytes written, or 0 if an error occurred. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t write_some(
      const ConstBufferSequence & buffers,
      boost::system::error_code & ec);



[endsect]


[endsect]


[endsect]

[section:buffered_stream buffered_stream]

Adds buffering to the read- and write-related operations of a stream. 

  template<
      typename Stream>
  class buffered_stream :
    noncopyable


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.buffered_stream.lowest_layer_type [*lowest_layer_type]]]
    [The type of the lowest layer. ]
  
  ]

  [

    [[link boost_asio.reference.buffered_stream.next_layer_type [*next_layer_type]]]
    [The type of the next layer. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.buffered_stream.async_fill [*async_fill]]]
    [Start an asynchronous fill. ]
  ]
  
  [
    [[link boost_asio.reference.buffered_stream.async_flush [*async_flush]]]
    [Start an asynchronous flush. ]
  ]
  
  [
    [[link boost_asio.reference.buffered_stream.async_read_some [*async_read_some]]]
    [Start an asynchronous read. The buffer into which the data will be read must be valid for the lifetime of the asynchronous operation. ]
  ]
  
  [
    [[link boost_asio.reference.buffered_stream.async_write_some [*async_write_some]]]
    [Start an asynchronous write. The data being written must be valid for the lifetime of the asynchronous operation. ]
  ]
  
  [
    [[link boost_asio.reference.buffered_stream.buffered_stream [*buffered_stream]]]
    [Construct, passing the specified argument to initialise the next layer. ]
  ]
  
  [
    [[link boost_asio.reference.buffered_stream.close [*close]]]
    [Close the stream. ]
  ]
  
  [
    [[link boost_asio.reference.buffered_stream.fill [*fill]]]
    [Fill the buffer with some data. Returns the number of bytes placed in the buffer as a result of the operation. Throws an exception on failure. 

     Fill the buffer with some data. Returns the number of bytes placed in the buffer as a result of the operation, or 0 if an error occurred. ]
  ]
  
  [
    [[link boost_asio.reference.buffered_stream.flush [*flush]]]
    [Flush all data from the buffer to the next layer. Returns the number of bytes written to the next layer on the last write operation. Throws an exception on failure. 

     Flush all data from the buffer to the next layer. Returns the number of bytes written to the next layer on the last write operation, or 0 if an error occurred. ]
  ]
  
  [
    [[link boost_asio.reference.buffered_stream.get_io_service [*get_io_service]]]
    [Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.buffered_stream.in_avail [*in_avail]]]
    [Determine the amount of data that may be read without blocking. ]
  ]
  
  [
    [[link boost_asio.reference.buffered_stream.io_service [*io_service]]]
    [(Deprecated: use get_io_service().) Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.buffered_stream.lowest_layer [*lowest_layer]]]
    [Get a reference to the lowest layer. 

     Get a const reference to the lowest layer. ]
  ]
  
  [
    [[link boost_asio.reference.buffered_stream.next_layer [*next_layer]]]
    [Get a reference to the next layer. ]
  ]
  
  [
    [[link boost_asio.reference.buffered_stream.peek [*peek]]]
    [Peek at the incoming data on the stream. Returns the number of bytes read. Throws an exception on failure. 

     Peek at the incoming data on the stream. Returns the number of bytes read, or 0 if an error occurred. ]
  ]
  
  [
    [[link boost_asio.reference.buffered_stream.read_some [*read_some]]]
    [Read some data from the stream. Returns the number of bytes read. Throws an exception on failure. 

     Read some data from the stream. Returns the number of bytes read or 0 if an error occurred. ]
  ]
  
  [
    [[link boost_asio.reference.buffered_stream.write_some [*write_some]]]
    [Write the given data to the stream. Returns the number of bytes written. Throws an exception on failure. 

     Write the given data to the stream. Returns the number of bytes written, or 0 if an error occurred. ]
  ]
  
]

The buffered_stream class template can be used to add buffering to the synchronous and asynchronous read and write operations of a stream.


[heading Thread Safety]
  
[*Distinct] [*objects:]  Safe.

[*Shared] [*objects:]  Unsafe.



[section:async_fill buffered_stream::async_fill]

[indexterm2 async_fill..buffered_stream] Start an asynchronous fill. 

  template<
      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
  void async_fill(
      ReadHandler handler);



[endsect]



[section:async_flush buffered_stream::async_flush]

[indexterm2 async_flush..buffered_stream] Start an asynchronous flush. 

  template<
      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
  void async_flush(
      WriteHandler handler);



[endsect]



[section:async_read_some buffered_stream::async_read_some]

[indexterm2 async_read_some..buffered_stream] Start an asynchronous read. The buffer into which the data will be read must be valid for the lifetime of the asynchronous operation. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
  void async_read_some(
      const MutableBufferSequence & buffers,
      ReadHandler handler);



[endsect]



[section:async_write_some buffered_stream::async_write_some]

[indexterm2 async_write_some..buffered_stream] Start an asynchronous write. The data being written must be valid for the lifetime of the asynchronous operation. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
  void async_write_some(
      const ConstBufferSequence & buffers,
      WriteHandler handler);



[endsect]


[section:buffered_stream buffered_stream::buffered_stream]

[indexterm2 buffered_stream..buffered_stream] Construct, passing the specified argument to initialise the next layer. 

  template<
      typename Arg>
  ``[link boost_asio.reference.buffered_stream.buffered_stream.overload1 buffered_stream]``(
      Arg & a);

  template<
      typename Arg>
  ``[link boost_asio.reference.buffered_stream.buffered_stream.overload2 buffered_stream]``(
      Arg & a,
      std::size_t read_buffer_size,
      std::size_t write_buffer_size);


[section:overload1 buffered_stream::buffered_stream (1 of 2 overloads)]

Construct, passing the specified argument to initialise the next layer. 

  template<
      typename Arg>
  buffered_stream(
      Arg & a);



[endsect]



[section:overload2 buffered_stream::buffered_stream (2 of 2 overloads)]

Construct, passing the specified argument to initialise the next layer. 

  template<
      typename Arg>
  buffered_stream(
      Arg & a,
      std::size_t read_buffer_size,
      std::size_t write_buffer_size);



[endsect]


[endsect]

[section:close buffered_stream::close]

[indexterm2 close..buffered_stream] Close the stream. 

  void ``[link boost_asio.reference.buffered_stream.close.overload1 close]``();

  boost::system::error_code ``[link boost_asio.reference.buffered_stream.close.overload2 close]``(
      boost::system::error_code & ec);


[section:overload1 buffered_stream::close (1 of 2 overloads)]

Close the stream. 

  void close();



[endsect]



[section:overload2 buffered_stream::close (2 of 2 overloads)]

Close the stream. 

  boost::system::error_code close(
      boost::system::error_code & ec);



[endsect]


[endsect]

[section:fill buffered_stream::fill]

[indexterm2 fill..buffered_stream] Fill the buffer with some data. Returns the number of bytes placed in the buffer as a result of the operation. Throws an exception on failure. 

  std::size_t ``[link boost_asio.reference.buffered_stream.fill.overload1 fill]``();

Fill the buffer with some data. Returns the number of bytes placed in the buffer as a result of the operation, or 0 if an error occurred. 

  std::size_t ``[link boost_asio.reference.buffered_stream.fill.overload2 fill]``(
      boost::system::error_code & ec);


[section:overload1 buffered_stream::fill (1 of 2 overloads)]

Fill the buffer with some data. Returns the number of bytes placed in the buffer as a result of the operation. Throws an exception on failure. 

  std::size_t fill();



[endsect]



[section:overload2 buffered_stream::fill (2 of 2 overloads)]

Fill the buffer with some data. Returns the number of bytes placed in the buffer as a result of the operation, or 0 if an error occurred. 

  std::size_t fill(
      boost::system::error_code & ec);



[endsect]


[endsect]

[section:flush buffered_stream::flush]

[indexterm2 flush..buffered_stream] Flush all data from the buffer to the next layer. Returns the number of bytes written to the next layer on the last write operation. Throws an exception on failure. 

  std::size_t ``[link boost_asio.reference.buffered_stream.flush.overload1 flush]``();

Flush all data from the buffer to the next layer. Returns the number of bytes written to the next layer on the last write operation, or 0 if an error occurred. 

  std::size_t ``[link boost_asio.reference.buffered_stream.flush.overload2 flush]``(
      boost::system::error_code & ec);


[section:overload1 buffered_stream::flush (1 of 2 overloads)]

Flush all data from the buffer to the next layer. Returns the number of bytes written to the next layer on the last write operation. Throws an exception on failure. 

  std::size_t flush();



[endsect]



[section:overload2 buffered_stream::flush (2 of 2 overloads)]

Flush all data from the buffer to the next layer. Returns the number of bytes written to the next layer on the last write operation, or 0 if an error occurred. 

  std::size_t flush(
      boost::system::error_code & ec);



[endsect]


[endsect]


[section:get_io_service buffered_stream::get_io_service]

[indexterm2 get_io_service..buffered_stream] Get the io_service associated with the object. 

  boost::asio::io_service & get_io_service();



[endsect]


[section:in_avail buffered_stream::in_avail]

[indexterm2 in_avail..buffered_stream] Determine the amount of data that may be read without blocking. 

  std::size_t ``[link boost_asio.reference.buffered_stream.in_avail.overload1 in_avail]``();

  std::size_t ``[link boost_asio.reference.buffered_stream.in_avail.overload2 in_avail]``(
      boost::system::error_code & ec);


[section:overload1 buffered_stream::in_avail (1 of 2 overloads)]

Determine the amount of data that may be read without blocking. 

  std::size_t in_avail();



[endsect]



[section:overload2 buffered_stream::in_avail (2 of 2 overloads)]

Determine the amount of data that may be read without blocking. 

  std::size_t in_avail(
      boost::system::error_code & ec);



[endsect]


[endsect]


[section:io_service buffered_stream::io_service]

[indexterm2 io_service..buffered_stream] (Deprecated: use get_io_service().) Get the io_service associated with the object. 

  boost::asio::io_service & io_service();



[endsect]


[section:lowest_layer buffered_stream::lowest_layer]

[indexterm2 lowest_layer..buffered_stream] Get a reference to the lowest layer. 

  lowest_layer_type & ``[link boost_asio.reference.buffered_stream.lowest_layer.overload1 lowest_layer]``();

Get a const reference to the lowest layer. 

  const lowest_layer_type & ``[link boost_asio.reference.buffered_stream.lowest_layer.overload2 lowest_layer]``() const;


[section:overload1 buffered_stream::lowest_layer (1 of 2 overloads)]

Get a reference to the lowest layer. 

  lowest_layer_type & lowest_layer();



[endsect]



[section:overload2 buffered_stream::lowest_layer (2 of 2 overloads)]

Get a const reference to the lowest layer. 

  const lowest_layer_type & lowest_layer() const;



[endsect]


[endsect]


[section:lowest_layer_type buffered_stream::lowest_layer_type]

[indexterm2 lowest_layer_type..buffered_stream] The type of the lowest layer. 

  typedef next_layer_type::lowest_layer_type lowest_layer_type;




[endsect]



[section:next_layer buffered_stream::next_layer]

[indexterm2 next_layer..buffered_stream] Get a reference to the next layer. 

  next_layer_type & next_layer();



[endsect]



[section:next_layer_type buffered_stream::next_layer_type]

[indexterm2 next_layer_type..buffered_stream] The type of the next layer. 

  typedef boost::remove_reference< Stream >::type next_layer_type;




[endsect]


[section:peek buffered_stream::peek]

[indexterm2 peek..buffered_stream] Peek at the incoming data on the stream. Returns the number of bytes read. Throws an exception on failure. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t ``[link boost_asio.reference.buffered_stream.peek.overload1 peek]``(
      const MutableBufferSequence & buffers);

Peek at the incoming data on the stream. Returns the number of bytes read, or 0 if an error occurred. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t ``[link boost_asio.reference.buffered_stream.peek.overload2 peek]``(
      const MutableBufferSequence & buffers,
      boost::system::error_code & ec);


[section:overload1 buffered_stream::peek (1 of 2 overloads)]

Peek at the incoming data on the stream. Returns the number of bytes read. Throws an exception on failure. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t peek(
      const MutableBufferSequence & buffers);



[endsect]



[section:overload2 buffered_stream::peek (2 of 2 overloads)]

Peek at the incoming data on the stream. Returns the number of bytes read, or 0 if an error occurred. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t peek(
      const MutableBufferSequence & buffers,
      boost::system::error_code & ec);



[endsect]


[endsect]

[section:read_some buffered_stream::read_some]

[indexterm2 read_some..buffered_stream] Read some data from the stream. Returns the number of bytes read. Throws an exception on failure. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t ``[link boost_asio.reference.buffered_stream.read_some.overload1 read_some]``(
      const MutableBufferSequence & buffers);

Read some data from the stream. Returns the number of bytes read or 0 if an error occurred. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t ``[link boost_asio.reference.buffered_stream.read_some.overload2 read_some]``(
      const MutableBufferSequence & buffers,
      boost::system::error_code & ec);


[section:overload1 buffered_stream::read_some (1 of 2 overloads)]

Read some data from the stream. Returns the number of bytes read. Throws an exception on failure. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t read_some(
      const MutableBufferSequence & buffers);



[endsect]



[section:overload2 buffered_stream::read_some (2 of 2 overloads)]

Read some data from the stream. Returns the number of bytes read or 0 if an error occurred. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t read_some(
      const MutableBufferSequence & buffers,
      boost::system::error_code & ec);



[endsect]


[endsect]

[section:write_some buffered_stream::write_some]

[indexterm2 write_some..buffered_stream] Write the given data to the stream. Returns the number of bytes written. Throws an exception on failure. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t ``[link boost_asio.reference.buffered_stream.write_some.overload1 write_some]``(
      const ConstBufferSequence & buffers);

Write the given data to the stream. Returns the number of bytes written, or 0 if an error occurred. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t ``[link boost_asio.reference.buffered_stream.write_some.overload2 write_some]``(
      const ConstBufferSequence & buffers,
      boost::system::error_code & ec);


[section:overload1 buffered_stream::write_some (1 of 2 overloads)]

Write the given data to the stream. Returns the number of bytes written. Throws an exception on failure. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t write_some(
      const ConstBufferSequence & buffers);



[endsect]



[section:overload2 buffered_stream::write_some (2 of 2 overloads)]

Write the given data to the stream. Returns the number of bytes written, or 0 if an error occurred. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t write_some(
      const ConstBufferSequence & buffers,
      boost::system::error_code & ec);



[endsect]


[endsect]


[endsect]

[section:buffered_write_stream buffered_write_stream]

Adds buffering to the write-related operations of a stream. 

  template<
      typename Stream>
  class buffered_write_stream :
    noncopyable


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.buffered_write_stream.lowest_layer_type [*lowest_layer_type]]]
    [The type of the lowest layer. ]
  
  ]

  [

    [[link boost_asio.reference.buffered_write_stream.next_layer_type [*next_layer_type]]]
    [The type of the next layer. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.buffered_write_stream.async_flush [*async_flush]]]
    [Start an asynchronous flush. ]
  ]
  
  [
    [[link boost_asio.reference.buffered_write_stream.async_read_some [*async_read_some]]]
    [Start an asynchronous read. The buffer into which the data will be read must be valid for the lifetime of the asynchronous operation. ]
  ]
  
  [
    [[link boost_asio.reference.buffered_write_stream.async_write_some [*async_write_some]]]
    [Start an asynchronous write. The data being written must be valid for the lifetime of the asynchronous operation. ]
  ]
  
  [
    [[link boost_asio.reference.buffered_write_stream.buffered_write_stream [*buffered_write_stream]]]
    [Construct, passing the specified argument to initialise the next layer. ]
  ]
  
  [
    [[link boost_asio.reference.buffered_write_stream.close [*close]]]
    [Close the stream. ]
  ]
  
  [
    [[link boost_asio.reference.buffered_write_stream.flush [*flush]]]
    [Flush all data from the buffer to the next layer. Returns the number of bytes written to the next layer on the last write operation. Throws an exception on failure. 

     Flush all data from the buffer to the next layer. Returns the number of bytes written to the next layer on the last write operation, or 0 if an error occurred. ]
  ]
  
  [
    [[link boost_asio.reference.buffered_write_stream.get_io_service [*get_io_service]]]
    [Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.buffered_write_stream.in_avail [*in_avail]]]
    [Determine the amount of data that may be read without blocking. ]
  ]
  
  [
    [[link boost_asio.reference.buffered_write_stream.io_service [*io_service]]]
    [(Deprecated: use get_io_service().) Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.buffered_write_stream.lowest_layer [*lowest_layer]]]
    [Get a reference to the lowest layer. 

     Get a const reference to the lowest layer. ]
  ]
  
  [
    [[link boost_asio.reference.buffered_write_stream.next_layer [*next_layer]]]
    [Get a reference to the next layer. ]
  ]
  
  [
    [[link boost_asio.reference.buffered_write_stream.peek [*peek]]]
    [Peek at the incoming data on the stream. Returns the number of bytes read. Throws an exception on failure. 

     Peek at the incoming data on the stream. Returns the number of bytes read, or 0 if an error occurred. ]
  ]
  
  [
    [[link boost_asio.reference.buffered_write_stream.read_some [*read_some]]]
    [Read some data from the stream. Returns the number of bytes read. Throws an exception on failure. 

     Read some data from the stream. Returns the number of bytes read or 0 if an error occurred. ]
  ]
  
  [
    [[link boost_asio.reference.buffered_write_stream.write_some [*write_some]]]
    [Write the given data to the stream. Returns the number of bytes written. Throws an exception on failure. 

     Write the given data to the stream. Returns the number of bytes written, or 0 if an error occurred and the error handler did not throw. ]
  ]
  
]

[heading Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.buffered_write_stream.default_buffer_size [*default_buffer_size]]]
    [The default buffer size. ]
  ]

]

The buffered_write_stream class template can be used to add buffering to the synchronous and asynchronous write operations of a stream.


[heading Thread Safety]
  
[*Distinct] [*objects:]  Safe.

[*Shared] [*objects:]  Unsafe.



[section:async_flush buffered_write_stream::async_flush]

[indexterm2 async_flush..buffered_write_stream] Start an asynchronous flush. 

  template<
      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
  void async_flush(
      WriteHandler handler);



[endsect]



[section:async_read_some buffered_write_stream::async_read_some]

[indexterm2 async_read_some..buffered_write_stream] Start an asynchronous read. The buffer into which the data will be read must be valid for the lifetime of the asynchronous operation. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
  void async_read_some(
      const MutableBufferSequence & buffers,
      ReadHandler handler);



[endsect]



[section:async_write_some buffered_write_stream::async_write_some]

[indexterm2 async_write_some..buffered_write_stream] Start an asynchronous write. The data being written must be valid for the lifetime of the asynchronous operation. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
  void async_write_some(
      const ConstBufferSequence & buffers,
      WriteHandler handler);



[endsect]


[section:buffered_write_stream buffered_write_stream::buffered_write_stream]

[indexterm2 buffered_write_stream..buffered_write_stream] Construct, passing the specified argument to initialise the next layer. 

  template<
      typename Arg>
  ``[link boost_asio.reference.buffered_write_stream.buffered_write_stream.overload1 buffered_write_stream]``(
      Arg & a);

  template<
      typename Arg>
  ``[link boost_asio.reference.buffered_write_stream.buffered_write_stream.overload2 buffered_write_stream]``(
      Arg & a,
      std::size_t buffer_size);


[section:overload1 buffered_write_stream::buffered_write_stream (1 of 2 overloads)]

Construct, passing the specified argument to initialise the next layer. 

  template<
      typename Arg>
  buffered_write_stream(
      Arg & a);



[endsect]



[section:overload2 buffered_write_stream::buffered_write_stream (2 of 2 overloads)]

Construct, passing the specified argument to initialise the next layer. 

  template<
      typename Arg>
  buffered_write_stream(
      Arg & a,
      std::size_t buffer_size);



[endsect]


[endsect]

[section:close buffered_write_stream::close]

[indexterm2 close..buffered_write_stream] Close the stream. 

  void ``[link boost_asio.reference.buffered_write_stream.close.overload1 close]``();

  boost::system::error_code ``[link boost_asio.reference.buffered_write_stream.close.overload2 close]``(
      boost::system::error_code & ec);


[section:overload1 buffered_write_stream::close (1 of 2 overloads)]

Close the stream. 

  void close();



[endsect]



[section:overload2 buffered_write_stream::close (2 of 2 overloads)]

Close the stream. 

  boost::system::error_code close(
      boost::system::error_code & ec);



[endsect]


[endsect]


[section:default_buffer_size buffered_write_stream::default_buffer_size]

[indexterm2 default_buffer_size..buffered_write_stream] The default buffer size. 

  static const std::size_t default_buffer_size = implementation_defined;



[endsect]


[section:flush buffered_write_stream::flush]

[indexterm2 flush..buffered_write_stream] Flush all data from the buffer to the next layer. Returns the number of bytes written to the next layer on the last write operation. Throws an exception on failure. 

  std::size_t ``[link boost_asio.reference.buffered_write_stream.flush.overload1 flush]``();

Flush all data from the buffer to the next layer. Returns the number of bytes written to the next layer on the last write operation, or 0 if an error occurred. 

  std::size_t ``[link boost_asio.reference.buffered_write_stream.flush.overload2 flush]``(
      boost::system::error_code & ec);


[section:overload1 buffered_write_stream::flush (1 of 2 overloads)]

Flush all data from the buffer to the next layer. Returns the number of bytes written to the next layer on the last write operation. Throws an exception on failure. 

  std::size_t flush();



[endsect]



[section:overload2 buffered_write_stream::flush (2 of 2 overloads)]

Flush all data from the buffer to the next layer. Returns the number of bytes written to the next layer on the last write operation, or 0 if an error occurred. 

  std::size_t flush(
      boost::system::error_code & ec);



[endsect]


[endsect]


[section:get_io_service buffered_write_stream::get_io_service]

[indexterm2 get_io_service..buffered_write_stream] Get the io_service associated with the object. 

  boost::asio::io_service & get_io_service();



[endsect]


[section:in_avail buffered_write_stream::in_avail]

[indexterm2 in_avail..buffered_write_stream] Determine the amount of data that may be read without blocking. 

  std::size_t ``[link boost_asio.reference.buffered_write_stream.in_avail.overload1 in_avail]``();

  std::size_t ``[link boost_asio.reference.buffered_write_stream.in_avail.overload2 in_avail]``(
      boost::system::error_code & ec);


[section:overload1 buffered_write_stream::in_avail (1 of 2 overloads)]

Determine the amount of data that may be read without blocking. 

  std::size_t in_avail();



[endsect]



[section:overload2 buffered_write_stream::in_avail (2 of 2 overloads)]

Determine the amount of data that may be read without blocking. 

  std::size_t in_avail(
      boost::system::error_code & ec);



[endsect]


[endsect]


[section:io_service buffered_write_stream::io_service]

[indexterm2 io_service..buffered_write_stream] (Deprecated: use get_io_service().) Get the io_service associated with the object. 

  boost::asio::io_service & io_service();



[endsect]


[section:lowest_layer buffered_write_stream::lowest_layer]

[indexterm2 lowest_layer..buffered_write_stream] Get a reference to the lowest layer. 

  lowest_layer_type & ``[link boost_asio.reference.buffered_write_stream.lowest_layer.overload1 lowest_layer]``();

Get a const reference to the lowest layer. 

  const lowest_layer_type & ``[link boost_asio.reference.buffered_write_stream.lowest_layer.overload2 lowest_layer]``() const;


[section:overload1 buffered_write_stream::lowest_layer (1 of 2 overloads)]

Get a reference to the lowest layer. 

  lowest_layer_type & lowest_layer();



[endsect]



[section:overload2 buffered_write_stream::lowest_layer (2 of 2 overloads)]

Get a const reference to the lowest layer. 

  const lowest_layer_type & lowest_layer() const;



[endsect]


[endsect]


[section:lowest_layer_type buffered_write_stream::lowest_layer_type]

[indexterm2 lowest_layer_type..buffered_write_stream] The type of the lowest layer. 

  typedef next_layer_type::lowest_layer_type lowest_layer_type;




[endsect]



[section:next_layer buffered_write_stream::next_layer]

[indexterm2 next_layer..buffered_write_stream] Get a reference to the next layer. 

  next_layer_type & next_layer();



[endsect]



[section:next_layer_type buffered_write_stream::next_layer_type]

[indexterm2 next_layer_type..buffered_write_stream] The type of the next layer. 

  typedef boost::remove_reference< Stream >::type next_layer_type;




[endsect]


[section:peek buffered_write_stream::peek]

[indexterm2 peek..buffered_write_stream] Peek at the incoming data on the stream. Returns the number of bytes read. Throws an exception on failure. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t ``[link boost_asio.reference.buffered_write_stream.peek.overload1 peek]``(
      const MutableBufferSequence & buffers);

Peek at the incoming data on the stream. Returns the number of bytes read, or 0 if an error occurred. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t ``[link boost_asio.reference.buffered_write_stream.peek.overload2 peek]``(
      const MutableBufferSequence & buffers,
      boost::system::error_code & ec);


[section:overload1 buffered_write_stream::peek (1 of 2 overloads)]

Peek at the incoming data on the stream. Returns the number of bytes read. Throws an exception on failure. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t peek(
      const MutableBufferSequence & buffers);



[endsect]



[section:overload2 buffered_write_stream::peek (2 of 2 overloads)]

Peek at the incoming data on the stream. Returns the number of bytes read, or 0 if an error occurred. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t peek(
      const MutableBufferSequence & buffers,
      boost::system::error_code & ec);



[endsect]


[endsect]

[section:read_some buffered_write_stream::read_some]

[indexterm2 read_some..buffered_write_stream] Read some data from the stream. Returns the number of bytes read. Throws an exception on failure. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t ``[link boost_asio.reference.buffered_write_stream.read_some.overload1 read_some]``(
      const MutableBufferSequence & buffers);

Read some data from the stream. Returns the number of bytes read or 0 if an error occurred. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t ``[link boost_asio.reference.buffered_write_stream.read_some.overload2 read_some]``(
      const MutableBufferSequence & buffers,
      boost::system::error_code & ec);


[section:overload1 buffered_write_stream::read_some (1 of 2 overloads)]

Read some data from the stream. Returns the number of bytes read. Throws an exception on failure. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t read_some(
      const MutableBufferSequence & buffers);



[endsect]



[section:overload2 buffered_write_stream::read_some (2 of 2 overloads)]

Read some data from the stream. Returns the number of bytes read or 0 if an error occurred. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t read_some(
      const MutableBufferSequence & buffers,
      boost::system::error_code & ec);



[endsect]


[endsect]

[section:write_some buffered_write_stream::write_some]

[indexterm2 write_some..buffered_write_stream] Write the given data to the stream. Returns the number of bytes written. Throws an exception on failure. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t ``[link boost_asio.reference.buffered_write_stream.write_some.overload1 write_some]``(
      const ConstBufferSequence & buffers);

Write the given data to the stream. Returns the number of bytes written, or 0 if an error occurred and the error handler did not throw. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t ``[link boost_asio.reference.buffered_write_stream.write_some.overload2 write_some]``(
      const ConstBufferSequence & buffers,
      boost::system::error_code & ec);


[section:overload1 buffered_write_stream::write_some (1 of 2 overloads)]

Write the given data to the stream. Returns the number of bytes written. Throws an exception on failure. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t write_some(
      const ConstBufferSequence & buffers);



[endsect]



[section:overload2 buffered_write_stream::write_some (2 of 2 overloads)]

Write the given data to the stream. Returns the number of bytes written, or 0 if an error occurred and the error handler did not throw. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t write_some(
      const ConstBufferSequence & buffers,
      boost::system::error_code & ec);



[endsect]


[endsect]


[endsect]


[section:buffers_begin buffers_begin]

[indexterm1 buffers_begin] Construct an iterator representing the beginning of the buffers' data. 

  template<
      typename BufferSequence>
  buffers_iterator< BufferSequence > buffers_begin(
      const BufferSequence & buffers);



[endsect]



[section:buffers_end buffers_end]

[indexterm1 buffers_end] Construct an iterator representing the end of the buffers' data. 

  template<
      typename BufferSequence>
  buffers_iterator< BufferSequence > buffers_end(
      const BufferSequence & buffers);



[endsect]


[section:buffers_iterator buffers_iterator]

A random access iterator over the bytes in a buffer sequence. 

  template<
      typename BufferSequence,
      typename ByteType = char>
  class buffers_iterator


[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.buffers_iterator.begin [*begin]]]
    [Construct an iterator representing the beginning of the buffers' data. ]
  ]
  
  [
    [[link boost_asio.reference.buffers_iterator.buffers_iterator [*buffers_iterator]]]
    [Default constructor. Creates an iterator in an undefined state. ]
  ]
  
  [
    [[link boost_asio.reference.buffers_iterator.end [*end]]]
    [Construct an iterator representing the end of the buffers' data. ]
  ]
  
]


[section:begin buffers_iterator::begin]

[indexterm2 begin..buffers_iterator] Construct an iterator representing the beginning of the buffers' data. 

  static buffers_iterator begin(
      const BufferSequence & buffers);



[endsect]



[section:buffers_iterator buffers_iterator::buffers_iterator]

[indexterm2 buffers_iterator..buffers_iterator] Default constructor. Creates an iterator in an undefined state. 

  buffers_iterator();



[endsect]



[section:end buffers_iterator::end]

[indexterm2 end..buffers_iterator] Construct an iterator representing the end of the buffers' data. 

  static buffers_iterator end(
      const BufferSequence & buffers);



[endsect]



[endsect]

[section:const_buffer const_buffer]

Holds a buffer that cannot be modified. 

  class const_buffer


[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.const_buffer.const_buffer [*const_buffer]]]
    [Construct an empty buffer. 

     Construct a buffer to represent a given memory range. 

     Construct a non-modifiable buffer from a modifiable one. ]
  ]
  
]

[heading Related Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.const_buffer.buffer_cast [*buffer_cast]]]
    [Cast a non-modifiable buffer to a specified pointer to POD type. ]
  ]
  
  [
    [[link boost_asio.reference.const_buffer.buffer_size [*buffer_size]]]
    [Get the number of bytes in a non-modifiable buffer. ]
  ]
  
  [
    [[link boost_asio.reference.const_buffer.operator_plus_ [*operator+]]]
    [Create a new non-modifiable buffer that is offset from the start of another. ]
  ]
  
]

The const_buffer class provides a safe representation of a buffer that cannot be modified. It does not own the underlying data, and so is cheap to copy or assign. 


[section:buffer_cast const_buffer::buffer_cast]

[indexterm2 buffer_cast..const_buffer] Cast a non-modifiable buffer to a specified pointer to POD type. 

  template<
      typename PointerToPodType>
  PointerToPodType buffer_cast(
      const const_buffer & b);



[endsect]



[section:buffer_size const_buffer::buffer_size]

[indexterm2 buffer_size..const_buffer] Get the number of bytes in a non-modifiable buffer. 

  std::size_t buffer_size(
      const const_buffer & b);



[endsect]


[section:const_buffer const_buffer::const_buffer]

[indexterm2 const_buffer..const_buffer] Construct an empty buffer. 

  ``[link boost_asio.reference.const_buffer.const_buffer.overload1 const_buffer]``();

Construct a buffer to represent a given memory range. 

  ``[link boost_asio.reference.const_buffer.const_buffer.overload2 const_buffer]``(
      const void * data,
      std::size_t size);

Construct a non-modifiable buffer from a modifiable one. 

  ``[link boost_asio.reference.const_buffer.const_buffer.overload3 const_buffer]``(
      const mutable_buffer & b);


[section:overload1 const_buffer::const_buffer (1 of 3 overloads)]

Construct an empty buffer. 

  const_buffer();



[endsect]



[section:overload2 const_buffer::const_buffer (2 of 3 overloads)]

Construct a buffer to represent a given memory range. 

  const_buffer(
      const void * data,
      std::size_t size);



[endsect]



[section:overload3 const_buffer::const_buffer (3 of 3 overloads)]

Construct a non-modifiable buffer from a modifiable one. 

  const_buffer(
      const mutable_buffer & b);



[endsect]


[endsect]

[section:operator_plus_ const_buffer::operator+]

[indexterm2 operator+..const_buffer] Create a new non-modifiable buffer that is offset from the start of another. 

  const_buffer ``[link boost_asio.reference.const_buffer.operator_plus_.overload1 operator+]``(
      const const_buffer & b,
      std::size_t start);

  const_buffer ``[link boost_asio.reference.const_buffer.operator_plus_.overload2 operator+]``(
      std::size_t start,
      const const_buffer & b);


[section:overload1 const_buffer::operator+ (1 of 2 overloads)]

Create a new non-modifiable buffer that is offset from the start of another. 

  const_buffer operator+(
      const const_buffer & b,
      std::size_t start);



[endsect]



[section:overload2 const_buffer::operator+ (2 of 2 overloads)]

Create a new non-modifiable buffer that is offset from the start of another. 

  const_buffer operator+(
      std::size_t start,
      const const_buffer & b);



[endsect]


[endsect]


[endsect]

[section:const_buffers_1 const_buffers_1]

Adapts a single non-modifiable buffer so that it meets the requirements of the ConstBufferSequence concept. 

  class const_buffers_1 :
    public const_buffer


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.const_buffers_1.const_iterator [*const_iterator]]]
    [A random-access iterator type that may be used to read elements. ]
  
  ]

  [

    [[link boost_asio.reference.const_buffers_1.value_type [*value_type]]]
    [The type for each element in the list of buffers. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.const_buffers_1.begin [*begin]]]
    [Get a random-access iterator to the first element. ]
  ]
  
  [
    [[link boost_asio.reference.const_buffers_1.const_buffers_1 [*const_buffers_1]]]
    [Construct to represent a given memory range. 

     Construct to represent a single non-modifiable buffer. ]
  ]
  
  [
    [[link boost_asio.reference.const_buffers_1.end [*end]]]
    [Get a random-access iterator for one past the last element. ]
  ]
  
]

[heading Related Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.const_buffers_1.buffer_cast [*buffer_cast]]]
    [Cast a non-modifiable buffer to a specified pointer to POD type. ]
  ]
  
  [
    [[link boost_asio.reference.const_buffers_1.buffer_size [*buffer_size]]]
    [Get the number of bytes in a non-modifiable buffer. ]
  ]
  
  [
    [[link boost_asio.reference.const_buffers_1.operator_plus_ [*operator+]]]
    [Create a new non-modifiable buffer that is offset from the start of another. ]
  ]
  
]


[section:begin const_buffers_1::begin]

[indexterm2 begin..const_buffers_1] Get a random-access iterator to the first element. 

  const_iterator begin() const;



[endsect]



[section:buffer_cast const_buffers_1::buffer_cast]


['Inherited from const_buffer.]

[indexterm2 buffer_cast..const_buffers_1] Cast a non-modifiable buffer to a specified pointer to POD type. 

  template<
      typename PointerToPodType>
  PointerToPodType buffer_cast(
      const const_buffer & b);



[endsect]



[section:buffer_size const_buffers_1::buffer_size]


['Inherited from const_buffer.]

[indexterm2 buffer_size..const_buffers_1] Get the number of bytes in a non-modifiable buffer. 

  std::size_t buffer_size(
      const const_buffer & b);



[endsect]


[section:const_buffers_1 const_buffers_1::const_buffers_1]

[indexterm2 const_buffers_1..const_buffers_1] Construct to represent a given memory range. 

  ``[link boost_asio.reference.const_buffers_1.const_buffers_1.overload1 const_buffers_1]``(
      const void * data,
      std::size_t size);

Construct to represent a single non-modifiable buffer. 

  ``[link boost_asio.reference.const_buffers_1.const_buffers_1.overload2 const_buffers_1]``(
      const const_buffer & b);


[section:overload1 const_buffers_1::const_buffers_1 (1 of 2 overloads)]

Construct to represent a given memory range. 

  const_buffers_1(
      const void * data,
      std::size_t size);



[endsect]



[section:overload2 const_buffers_1::const_buffers_1 (2 of 2 overloads)]

Construct to represent a single non-modifiable buffer. 

  const_buffers_1(
      const const_buffer & b);



[endsect]


[endsect]


[section:const_iterator const_buffers_1::const_iterator]

[indexterm2 const_iterator..const_buffers_1] A random-access iterator type that may be used to read elements. 

  typedef const const_buffer * const_iterator;




[endsect]



[section:end const_buffers_1::end]

[indexterm2 end..const_buffers_1] Get a random-access iterator for one past the last element. 

  const_iterator end() const;



[endsect]


[section:operator_plus_ const_buffers_1::operator+]

[indexterm2 operator+..const_buffers_1] Create a new non-modifiable buffer that is offset from the start of another. 

  const_buffer ``[link boost_asio.reference.const_buffers_1.operator_plus_.overload1 operator+]``(
      const const_buffer & b,
      std::size_t start);

  const_buffer ``[link boost_asio.reference.const_buffers_1.operator_plus_.overload2 operator+]``(
      std::size_t start,
      const const_buffer & b);


[section:overload1 const_buffers_1::operator+ (1 of 2 overloads)]


['Inherited from const_buffer.]

Create a new non-modifiable buffer that is offset from the start of another. 

  const_buffer operator+(
      const const_buffer & b,
      std::size_t start);



[endsect]



[section:overload2 const_buffers_1::operator+ (2 of 2 overloads)]


['Inherited from const_buffer.]

Create a new non-modifiable buffer that is offset from the start of another. 

  const_buffer operator+(
      std::size_t start,
      const const_buffer & b);



[endsect]


[endsect]


[section:value_type const_buffers_1::value_type]

[indexterm2 value_type..const_buffers_1] The type for each element in the list of buffers. 

  typedef const_buffer value_type;


[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.const_buffer.const_buffer [*const_buffer]]]
    [Construct an empty buffer. 

     Construct a buffer to represent a given memory range. 

     Construct a non-modifiable buffer from a modifiable one. ]
  ]
  
]

[heading Related Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.const_buffer.buffer_cast [*buffer_cast]]]
    [Cast a non-modifiable buffer to a specified pointer to POD type. ]
  ]
  
  [
    [[link boost_asio.reference.const_buffer.buffer_size [*buffer_size]]]
    [Get the number of bytes in a non-modifiable buffer. ]
  ]
  
  [
    [[link boost_asio.reference.const_buffer.operator_plus_ [*operator+]]]
    [Create a new non-modifiable buffer that is offset from the start of another. ]
  ]
  
]

The const_buffer class provides a safe representation of a buffer that cannot be modified. It does not own the underlying data, and so is cheap to copy or assign. 



[endsect]



[endsect]

[section:datagram_socket_service datagram_socket_service]

Default service implementation for a datagram socket. 

  template<
      typename ``[link boost_asio.reference.Protocol Protocol]``>
  class datagram_socket_service :
    public io_service::service


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.datagram_socket_service.endpoint_type [*endpoint_type]]]
    [The endpoint type. ]
  
  ]

  [

    [[link boost_asio.reference.datagram_socket_service.implementation_type [*implementation_type]]]
    [The type of a datagram socket. ]
  
  ]

  [

    [[link boost_asio.reference.datagram_socket_service.native_type [*native_type]]]
    [The native socket type. ]
  
  ]

  [

    [[link boost_asio.reference.datagram_socket_service.protocol_type [*protocol_type]]]
    [The protocol type. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.datagram_socket_service.assign [*assign]]]
    [Assign an existing native socket to a datagram socket. ]
  ]
  
  [
    [[link boost_asio.reference.datagram_socket_service.async_connect [*async_connect]]]
    [Start an asynchronous connect. ]
  ]
  
  [
    [[link boost_asio.reference.datagram_socket_service.async_receive [*async_receive]]]
    [Start an asynchronous receive. ]
  ]
  
  [
    [[link boost_asio.reference.datagram_socket_service.async_receive_from [*async_receive_from]]]
    [Start an asynchronous receive that will get the endpoint of the sender. ]
  ]
  
  [
    [[link boost_asio.reference.datagram_socket_service.async_send [*async_send]]]
    [Start an asynchronous send. ]
  ]
  
  [
    [[link boost_asio.reference.datagram_socket_service.async_send_to [*async_send_to]]]
    [Start an asynchronous send. ]
  ]
  
  [
    [[link boost_asio.reference.datagram_socket_service.at_mark [*at_mark]]]
    [Determine whether the socket is at the out-of-band data mark. ]
  ]
  
  [
    [[link boost_asio.reference.datagram_socket_service.available [*available]]]
    [Determine the number of bytes available for reading. ]
  ]
  
  [
    [[link boost_asio.reference.datagram_socket_service.bind [*bind]]]
    []
  ]
  
  [
    [[link boost_asio.reference.datagram_socket_service.cancel [*cancel]]]
    [Cancel all asynchronous operations associated with the socket. ]
  ]
  
  [
    [[link boost_asio.reference.datagram_socket_service.close [*close]]]
    [Close a datagram socket implementation. ]
  ]
  
  [
    [[link boost_asio.reference.datagram_socket_service.connect [*connect]]]
    [Connect the datagram socket to the specified endpoint. ]
  ]
  
  [
    [[link boost_asio.reference.datagram_socket_service.construct [*construct]]]
    [Construct a new datagram socket implementation. ]
  ]
  
  [
    [[link boost_asio.reference.datagram_socket_service.datagram_socket_service [*datagram_socket_service]]]
    [Construct a new datagram socket service for the specified io_service. ]
  ]
  
  [
    [[link boost_asio.reference.datagram_socket_service.destroy [*destroy]]]
    [Destroy a datagram socket implementation. ]
  ]
  
  [
    [[link boost_asio.reference.datagram_socket_service.get_io_service [*get_io_service]]]
    [Get the io_service object that owns the service. ]
  ]
  
  [
    [[link boost_asio.reference.datagram_socket_service.get_option [*get_option]]]
    [Get a socket option. ]
  ]
  
  [
    [[link boost_asio.reference.datagram_socket_service.io_control [*io_control]]]
    [Perform an IO control command on the socket. ]
  ]
  
  [
    [[link boost_asio.reference.datagram_socket_service.io_service [*io_service]]]
    [(Deprecated: use get_io_service().) Get the io_service object that owns the service. ]
  ]
  
  [
    [[link boost_asio.reference.datagram_socket_service.is_open [*is_open]]]
    [Determine whether the socket is open. ]
  ]
  
  [
    [[link boost_asio.reference.datagram_socket_service.local_endpoint [*local_endpoint]]]
    [Get the local endpoint. ]
  ]
  
  [
    [[link boost_asio.reference.datagram_socket_service.native [*native]]]
    [Get the native socket implementation. ]
  ]
  
  [
    [[link boost_asio.reference.datagram_socket_service.open [*open]]]
    []
  ]
  
  [
    [[link boost_asio.reference.datagram_socket_service.receive [*receive]]]
    [Receive some data from the peer. ]
  ]
  
  [
    [[link boost_asio.reference.datagram_socket_service.receive_from [*receive_from]]]
    [Receive a datagram with the endpoint of the sender. ]
  ]
  
  [
    [[link boost_asio.reference.datagram_socket_service.remote_endpoint [*remote_endpoint]]]
    [Get the remote endpoint. ]
  ]
  
  [
    [[link boost_asio.reference.datagram_socket_service.send [*send]]]
    [Send the given data to the peer. ]
  ]
  
  [
    [[link boost_asio.reference.datagram_socket_service.send_to [*send_to]]]
    [Send a datagram to the specified endpoint. ]
  ]
  
  [
    [[link boost_asio.reference.datagram_socket_service.set_option [*set_option]]]
    [Set a socket option. ]
  ]
  
  [
    [[link boost_asio.reference.datagram_socket_service.shutdown [*shutdown]]]
    [Disable sends or receives on the socket. ]
  ]
  
  [
    [[link boost_asio.reference.datagram_socket_service.shutdown_service [*shutdown_service]]]
    [Destroy all user-defined handler objects owned by the service. ]
  ]
  
]

[heading Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.datagram_socket_service.id [*id]]]
    [The unique service identifier. ]
  ]

]


[section:assign datagram_socket_service::assign]

[indexterm2 assign..datagram_socket_service] Assign an existing native socket to a datagram socket. 

  boost::system::error_code assign(
      implementation_type & impl,
      const protocol_type & protocol,
      const native_type & native_socket,
      boost::system::error_code & ec);



[endsect]



[section:async_connect datagram_socket_service::async_connect]

[indexterm2 async_connect..datagram_socket_service] Start an asynchronous connect. 

  template<
      typename ``[link boost_asio.reference.ConnectHandler ConnectHandler]``>
  void async_connect(
      implementation_type & impl,
      const endpoint_type & peer_endpoint,
      ConnectHandler handler);



[endsect]



[section:async_receive datagram_socket_service::async_receive]

[indexterm2 async_receive..datagram_socket_service] Start an asynchronous receive. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
  void async_receive(
      implementation_type & impl,
      const MutableBufferSequence & buffers,
      socket_base::message_flags flags,
      ReadHandler handler);



[endsect]



[section:async_receive_from datagram_socket_service::async_receive_from]

[indexterm2 async_receive_from..datagram_socket_service] Start an asynchronous receive that will get the endpoint of the sender. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
  void async_receive_from(
      implementation_type & impl,
      const MutableBufferSequence & buffers,
      endpoint_type & sender_endpoint,
      socket_base::message_flags flags,
      ReadHandler handler);



[endsect]



[section:async_send datagram_socket_service::async_send]

[indexterm2 async_send..datagram_socket_service] Start an asynchronous send. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
  void async_send(
      implementation_type & impl,
      const ConstBufferSequence & buffers,
      socket_base::message_flags flags,
      WriteHandler handler);



[endsect]



[section:async_send_to datagram_socket_service::async_send_to]

[indexterm2 async_send_to..datagram_socket_service] Start an asynchronous send. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
  void async_send_to(
      implementation_type & impl,
      const ConstBufferSequence & buffers,
      const endpoint_type & destination,
      socket_base::message_flags flags,
      WriteHandler handler);



[endsect]



[section:at_mark datagram_socket_service::at_mark]

[indexterm2 at_mark..datagram_socket_service] Determine whether the socket is at the out-of-band data mark. 

  bool at_mark(
      const implementation_type & impl,
      boost::system::error_code & ec) const;



[endsect]



[section:available datagram_socket_service::available]

[indexterm2 available..datagram_socket_service] Determine the number of bytes available for reading. 

  std::size_t available(
      const implementation_type & impl,
      boost::system::error_code & ec) const;



[endsect]



[section:bind datagram_socket_service::bind]

[indexterm2 bind..datagram_socket_service] 

  boost::system::error_code bind(
      implementation_type & impl,
      const endpoint_type & endpoint,
      boost::system::error_code & ec);



[endsect]



[section:cancel datagram_socket_service::cancel]

[indexterm2 cancel..datagram_socket_service] Cancel all asynchronous operations associated with the socket. 

  boost::system::error_code cancel(
      implementation_type & impl,
      boost::system::error_code & ec);



[endsect]



[section:close datagram_socket_service::close]

[indexterm2 close..datagram_socket_service] Close a datagram socket implementation. 

  boost::system::error_code close(
      implementation_type & impl,
      boost::system::error_code & ec);



[endsect]



[section:connect datagram_socket_service::connect]

[indexterm2 connect..datagram_socket_service] Connect the datagram socket to the specified endpoint. 

  boost::system::error_code connect(
      implementation_type & impl,
      const endpoint_type & peer_endpoint,
      boost::system::error_code & ec);



[endsect]



[section:construct datagram_socket_service::construct]

[indexterm2 construct..datagram_socket_service] Construct a new datagram socket implementation. 

  void construct(
      implementation_type & impl);



[endsect]



[section:datagram_socket_service datagram_socket_service::datagram_socket_service]

[indexterm2 datagram_socket_service..datagram_socket_service] Construct a new datagram socket service for the specified io_service. 

  datagram_socket_service(
      boost::asio::io_service & io_service);



[endsect]



[section:destroy datagram_socket_service::destroy]

[indexterm2 destroy..datagram_socket_service] Destroy a datagram socket implementation. 

  void destroy(
      implementation_type & impl);



[endsect]



[section:endpoint_type datagram_socket_service::endpoint_type]

[indexterm2 endpoint_type..datagram_socket_service] The endpoint type. 

  typedef Protocol::endpoint endpoint_type;




[endsect]



[section:get_io_service datagram_socket_service::get_io_service]


['Inherited from io_service.]

[indexterm2 get_io_service..datagram_socket_service] Get the io_service object that owns the service. 

  boost::asio::io_service & get_io_service();



[endsect]



[section:get_option datagram_socket_service::get_option]

[indexterm2 get_option..datagram_socket_service] Get a socket option. 

  template<
      typename ``[link boost_asio.reference.GettableSocketOption GettableSocketOption]``>
  boost::system::error_code get_option(
      const implementation_type & impl,
      GettableSocketOption & option,
      boost::system::error_code & ec) const;



[endsect]



[section:id datagram_socket_service::id]

[indexterm2 id..datagram_socket_service] The unique service identifier. 

  static boost::asio::io_service::id id;



[endsect]



[section:implementation_type datagram_socket_service::implementation_type]

[indexterm2 implementation_type..datagram_socket_service] The type of a datagram socket. 

  typedef implementation_defined implementation_type;




[endsect]



[section:io_control datagram_socket_service::io_control]

[indexterm2 io_control..datagram_socket_service] Perform an IO control command on the socket. 

  template<
      typename ``[link boost_asio.reference.IoControlCommand IoControlCommand]``>
  boost::system::error_code io_control(
      implementation_type & impl,
      IoControlCommand & command,
      boost::system::error_code & ec);



[endsect]



[section:io_service datagram_socket_service::io_service]


['Inherited from io_service.]

[indexterm2 io_service..datagram_socket_service] (Deprecated: use get_io_service().) Get the io_service object that owns the service. 

  boost::asio::io_service & io_service();



[endsect]



[section:is_open datagram_socket_service::is_open]

[indexterm2 is_open..datagram_socket_service] Determine whether the socket is open. 

  bool is_open(
      const implementation_type & impl) const;



[endsect]



[section:local_endpoint datagram_socket_service::local_endpoint]

[indexterm2 local_endpoint..datagram_socket_service] Get the local endpoint. 

  endpoint_type local_endpoint(
      const implementation_type & impl,
      boost::system::error_code & ec) const;



[endsect]



[section:native datagram_socket_service::native]

[indexterm2 native..datagram_socket_service] Get the native socket implementation. 

  native_type native(
      implementation_type & impl);



[endsect]



[section:native_type datagram_socket_service::native_type]

[indexterm2 native_type..datagram_socket_service] The native socket type. 

  typedef implementation_defined native_type;




[endsect]



[section:open datagram_socket_service::open]

[indexterm2 open..datagram_socket_service] 

  boost::system::error_code open(
      implementation_type & impl,
      const protocol_type & protocol,
      boost::system::error_code & ec);



[endsect]



[section:protocol_type datagram_socket_service::protocol_type]

[indexterm2 protocol_type..datagram_socket_service] The protocol type. 

  typedef Protocol protocol_type;




[endsect]



[section:receive datagram_socket_service::receive]

[indexterm2 receive..datagram_socket_service] Receive some data from the peer. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t receive(
      implementation_type & impl,
      const MutableBufferSequence & buffers,
      socket_base::message_flags flags,
      boost::system::error_code & ec);



[endsect]



[section:receive_from datagram_socket_service::receive_from]

[indexterm2 receive_from..datagram_socket_service] Receive a datagram with the endpoint of the sender. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t receive_from(
      implementation_type & impl,
      const MutableBufferSequence & buffers,
      endpoint_type & sender_endpoint,
      socket_base::message_flags flags,
      boost::system::error_code & ec);



[endsect]



[section:remote_endpoint datagram_socket_service::remote_endpoint]

[indexterm2 remote_endpoint..datagram_socket_service] Get the remote endpoint. 

  endpoint_type remote_endpoint(
      const implementation_type & impl,
      boost::system::error_code & ec) const;



[endsect]



[section:send datagram_socket_service::send]

[indexterm2 send..datagram_socket_service] Send the given data to the peer. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t send(
      implementation_type & impl,
      const ConstBufferSequence & buffers,
      socket_base::message_flags flags,
      boost::system::error_code & ec);



[endsect]



[section:send_to datagram_socket_service::send_to]

[indexterm2 send_to..datagram_socket_service] Send a datagram to the specified endpoint. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t send_to(
      implementation_type & impl,
      const ConstBufferSequence & buffers,
      const endpoint_type & destination,
      socket_base::message_flags flags,
      boost::system::error_code & ec);



[endsect]



[section:set_option datagram_socket_service::set_option]

[indexterm2 set_option..datagram_socket_service] Set a socket option. 

  template<
      typename ``[link boost_asio.reference.SettableSocketOption SettableSocketOption]``>
  boost::system::error_code set_option(
      implementation_type & impl,
      const SettableSocketOption & option,
      boost::system::error_code & ec);



[endsect]



[section:shutdown datagram_socket_service::shutdown]

[indexterm2 shutdown..datagram_socket_service] Disable sends or receives on the socket. 

  boost::system::error_code shutdown(
      implementation_type & impl,
      socket_base::shutdown_type what,
      boost::system::error_code & ec);



[endsect]



[section:shutdown_service datagram_socket_service::shutdown_service]

[indexterm2 shutdown_service..datagram_socket_service] Destroy all user-defined handler objects owned by the service. 

  void shutdown_service();



[endsect]



[endsect]


[section:deadline_timer deadline_timer]

[indexterm1 deadline_timer] Typedef for the typical usage of timer. 

  typedef basic_deadline_timer< boost::posix_time::ptime > deadline_timer;


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.basic_deadline_timer.duration_type [*duration_type]]]
    [The duration type. ]
  
  ]

  [

    [[link boost_asio.reference.basic_deadline_timer.implementation_type [*implementation_type]]]
    [The underlying implementation type of I/O object. ]
  
  ]

  [

    [[link boost_asio.reference.basic_deadline_timer.service_type [*service_type]]]
    [The type of the service that will be used to provide I/O operations. ]
  
  ]

  [

    [[link boost_asio.reference.basic_deadline_timer.time_type [*time_type]]]
    [The time type. ]
  
  ]

  [

    [[link boost_asio.reference.basic_deadline_timer.traits_type [*traits_type]]]
    [The time traits type. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_deadline_timer.async_wait [*async_wait]]]
    [Start an asynchronous wait on the timer. ]
  ]
  
  [
    [[link boost_asio.reference.basic_deadline_timer.basic_deadline_timer [*basic_deadline_timer]]]
    [Constructor. 

     Constructor to set a particular expiry time as an absolute time. 

     Constructor to set a particular expiry time relative to now. ]
  ]
  
  [
    [[link boost_asio.reference.basic_deadline_timer.cancel [*cancel]]]
    [Cancel any asynchronous operations that are waiting on the timer. ]
  ]
  
  [
    [[link boost_asio.reference.basic_deadline_timer.expires_at [*expires_at]]]
    [Get the timer's expiry time as an absolute time. 

     Set the timer's expiry time as an absolute time. ]
  ]
  
  [
    [[link boost_asio.reference.basic_deadline_timer.expires_from_now [*expires_from_now]]]
    [Get the timer's expiry time relative to now. 

     Set the timer's expiry time relative to now. ]
  ]
  
  [
    [[link boost_asio.reference.basic_deadline_timer.get_io_service [*get_io_service]]]
    [Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.basic_deadline_timer.io_service [*io_service]]]
    [(Deprecated: use get_io_service().) Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.basic_deadline_timer.wait [*wait]]]
    [Perform a blocking wait on the timer. ]
  ]
  
]

[heading Protected Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_deadline_timer.implementation [*implementation]]]
    [The underlying implementation of the I/O object. ]
  ]

  [
    [[link boost_asio.reference.basic_deadline_timer.service [*service]]]
    [The service associated with the I/O object. ]
  ]

]

The basic_deadline_timer class template provides the ability to perform a blocking or asynchronous wait for a timer to expire.

Most applications will use the boost::asio::deadline\_timer typedef.


[heading Thread Safety]
  
[*Distinct] [*objects:]  Safe.

[*Shared] [*objects:]  Unsafe.

[heading Examples]
  
Performing a blocking wait: 

   // Construct a timer without setting an expiry time.
   boost::asio::deadline_timer timer(io_service);

   // Set an expiry time relative to now.
   timer.expires_from_now(boost::posix_time::seconds(5));

   // Wait for the timer to expire.
   timer.wait();




Performing an asynchronous wait: 

   void handler(const boost::system::error_code& error)
   {
     if (!error)
     {
       // Timer expired.
     }
   }

   ...

   // Construct a timer with an absolute expiry time.
   boost::asio::deadline_timer timer(io_service,
       boost::posix_time::time_from_string("2005-12-07 23:59:59.000"));

   // Start an asynchronous wait.
   timer.async_wait(handler);




[heading Changing an active deadline_timer's expiry time]
  


Changing the expiry time of a timer while there are pending asynchronous waits causes those wait operations to be cancelled. To ensure that the action associated with the timer is performed only once, use something like this: used:



   void on_some_event()
   {
     if (my_timer.expires_from_now(seconds(5)) > 0)
     {
       // We managed to cancel the timer. Start new asynchronous wait.
       my_timer.async_wait(on_timeout);
     }
     else
     {
       // Too late, timer has already expired!
     }
   }

   void on_timeout(const boost::system::error_code& e)
   {
     if (e != boost::asio::error::operation_aborted)
     {
       // Timer was not cancelled, take necessary action.
     }
   }





* The boost::asio::basic_deadline_timer::expires_from_now() function cancels any pending asynchronous waits, and returns the number of asynchronous waits that were cancelled. If it returns 0 then you were too late and the wait handler has already been executed, or will soon be executed. If it returns 1 then the wait handler was successfully cancelled.

* If a wait handler is cancelled, the boost::system::error_code passed to it contains the value boost::asio::error::operation_aborted. 




[endsect]


[section:deadline_timer_service deadline_timer_service]

Default service implementation for a timer. 

  template<
      typename TimeType,
      typename ``[link boost_asio.reference.TimeTraits TimeTraits]`` = boost::asio::time_traits<TimeType>>
  class deadline_timer_service :
    public io_service::service


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.deadline_timer_service.duration_type [*duration_type]]]
    [The duration type. ]
  
  ]

  [

    [[link boost_asio.reference.deadline_timer_service.implementation_type [*implementation_type]]]
    [The implementation type of the deadline timer. ]
  
  ]

  [

    [[link boost_asio.reference.deadline_timer_service.time_type [*time_type]]]
    [The time type. ]
  
  ]

  [

    [[link boost_asio.reference.deadline_timer_service.traits_type [*traits_type]]]
    [The time traits type. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.deadline_timer_service.async_wait [*async_wait]]]
    []
  ]
  
  [
    [[link boost_asio.reference.deadline_timer_service.cancel [*cancel]]]
    [Cancel any asynchronous wait operations associated with the timer. ]
  ]
  
  [
    [[link boost_asio.reference.deadline_timer_service.construct [*construct]]]
    [Construct a new timer implementation. ]
  ]
  
  [
    [[link boost_asio.reference.deadline_timer_service.deadline_timer_service [*deadline_timer_service]]]
    [Construct a new timer service for the specified io_service. ]
  ]
  
  [
    [[link boost_asio.reference.deadline_timer_service.destroy [*destroy]]]
    [Destroy a timer implementation. ]
  ]
  
  [
    [[link boost_asio.reference.deadline_timer_service.expires_at [*expires_at]]]
    [Get the expiry time for the timer as an absolute time. 

     Set the expiry time for the timer as an absolute time. ]
  ]
  
  [
    [[link boost_asio.reference.deadline_timer_service.expires_from_now [*expires_from_now]]]
    [Get the expiry time for the timer relative to now. 

     Set the expiry time for the timer relative to now. ]
  ]
  
  [
    [[link boost_asio.reference.deadline_timer_service.get_io_service [*get_io_service]]]
    [Get the io_service object that owns the service. ]
  ]
  
  [
    [[link boost_asio.reference.deadline_timer_service.io_service [*io_service]]]
    [(Deprecated: use get_io_service().) Get the io_service object that owns the service. ]
  ]
  
  [
    [[link boost_asio.reference.deadline_timer_service.shutdown_service [*shutdown_service]]]
    [Destroy all user-defined handler objects owned by the service. ]
  ]
  
  [
    [[link boost_asio.reference.deadline_timer_service.wait [*wait]]]
    []
  ]
  
]

[heading Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.deadline_timer_service.id [*id]]]
    [The unique service identifier. ]
  ]

]


[section:async_wait deadline_timer_service::async_wait]

[indexterm2 async_wait..deadline_timer_service] 

  template<
      typename ``[link boost_asio.reference.WaitHandler WaitHandler]``>
  void async_wait(
      implementation_type & impl,
      WaitHandler handler);



[endsect]



[section:cancel deadline_timer_service::cancel]

[indexterm2 cancel..deadline_timer_service] Cancel any asynchronous wait operations associated with the timer. 

  std::size_t cancel(
      implementation_type & impl,
      boost::system::error_code & ec);



[endsect]



[section:construct deadline_timer_service::construct]

[indexterm2 construct..deadline_timer_service] Construct a new timer implementation. 

  void construct(
      implementation_type & impl);



[endsect]



[section:deadline_timer_service deadline_timer_service::deadline_timer_service]

[indexterm2 deadline_timer_service..deadline_timer_service] Construct a new timer service for the specified io_service. 

  deadline_timer_service(
      boost::asio::io_service & io_service);



[endsect]



[section:destroy deadline_timer_service::destroy]

[indexterm2 destroy..deadline_timer_service] Destroy a timer implementation. 

  void destroy(
      implementation_type & impl);



[endsect]



[section:duration_type deadline_timer_service::duration_type]

[indexterm2 duration_type..deadline_timer_service] The duration type. 

  typedef traits_type::duration_type duration_type;




[endsect]


[section:expires_at deadline_timer_service::expires_at]

[indexterm2 expires_at..deadline_timer_service] Get the expiry time for the timer as an absolute time. 

  time_type ``[link boost_asio.reference.deadline_timer_service.expires_at.overload1 expires_at]``(
      const implementation_type & impl) const;

Set the expiry time for the timer as an absolute time. 

  std::size_t ``[link boost_asio.reference.deadline_timer_service.expires_at.overload2 expires_at]``(
      implementation_type & impl,
      const time_type & expiry_time,
      boost::system::error_code & ec);


[section:overload1 deadline_timer_service::expires_at (1 of 2 overloads)]

Get the expiry time for the timer as an absolute time. 

  time_type expires_at(
      const implementation_type & impl) const;



[endsect]



[section:overload2 deadline_timer_service::expires_at (2 of 2 overloads)]

Set the expiry time for the timer as an absolute time. 

  std::size_t expires_at(
      implementation_type & impl,
      const time_type & expiry_time,
      boost::system::error_code & ec);



[endsect]


[endsect]

[section:expires_from_now deadline_timer_service::expires_from_now]

[indexterm2 expires_from_now..deadline_timer_service] Get the expiry time for the timer relative to now. 

  duration_type ``[link boost_asio.reference.deadline_timer_service.expires_from_now.overload1 expires_from_now]``(
      const implementation_type & impl) const;

Set the expiry time for the timer relative to now. 

  std::size_t ``[link boost_asio.reference.deadline_timer_service.expires_from_now.overload2 expires_from_now]``(
      implementation_type & impl,
      const duration_type & expiry_time,
      boost::system::error_code & ec);


[section:overload1 deadline_timer_service::expires_from_now (1 of 2 overloads)]

Get the expiry time for the timer relative to now. 

  duration_type expires_from_now(
      const implementation_type & impl) const;



[endsect]



[section:overload2 deadline_timer_service::expires_from_now (2 of 2 overloads)]

Set the expiry time for the timer relative to now. 

  std::size_t expires_from_now(
      implementation_type & impl,
      const duration_type & expiry_time,
      boost::system::error_code & ec);



[endsect]


[endsect]


[section:get_io_service deadline_timer_service::get_io_service]


['Inherited from io_service.]

[indexterm2 get_io_service..deadline_timer_service] Get the io_service object that owns the service. 

  boost::asio::io_service & get_io_service();



[endsect]



[section:id deadline_timer_service::id]

[indexterm2 id..deadline_timer_service] The unique service identifier. 

  static boost::asio::io_service::id id;



[endsect]



[section:implementation_type deadline_timer_service::implementation_type]

[indexterm2 implementation_type..deadline_timer_service] The implementation type of the deadline timer. 

  typedef implementation_defined implementation_type;




[endsect]



[section:io_service deadline_timer_service::io_service]


['Inherited from io_service.]

[indexterm2 io_service..deadline_timer_service] (Deprecated: use get_io_service().) Get the io_service object that owns the service. 

  boost::asio::io_service & io_service();



[endsect]



[section:shutdown_service deadline_timer_service::shutdown_service]

[indexterm2 shutdown_service..deadline_timer_service] Destroy all user-defined handler objects owned by the service. 

  void shutdown_service();



[endsect]



[section:time_type deadline_timer_service::time_type]

[indexterm2 time_type..deadline_timer_service] The time type. 

  typedef traits_type::time_type time_type;




[endsect]



[section:traits_type deadline_timer_service::traits_type]

[indexterm2 traits_type..deadline_timer_service] The time traits type. 

  typedef TimeTraits traits_type;




[endsect]



[section:wait deadline_timer_service::wait]

[indexterm2 wait..deadline_timer_service] 

  void wait(
      implementation_type & impl,
      boost::system::error_code & ec);



[endsect]



[endsect]


[section:error__addrinfo_category error::addrinfo_category]

[indexterm1 error::addrinfo_category] 

  static const boost::system::error_category & addrinfo_category = boost::asio::error::get_addrinfo_category();



[endsect]



[section:error__addrinfo_errors error::addrinfo_errors]

[indexterm1 error::addrinfo_errors] 

  enum addrinfo_errors

[heading Values]
[variablelist

  [
    [service_not_found]
    [The service is not supported for the given socket type. ]
  ]

  [
    [socket_type_not_supported]
    [The socket type is not supported. ]
  ]

]



[endsect]



[section:error__basic_errors error::basic_errors]

[indexterm1 error::basic_errors] 

  enum basic_errors

[heading Values]
[variablelist

  [
    [access_denied]
    [Permission denied. ]
  ]

  [
    [address_family_not_supported]
    [Address family not supported by protocol. ]
  ]

  [
    [address_in_use]
    [Address already in use. ]
  ]

  [
    [already_connected]
    [Transport endpoint is already connected. ]
  ]

  [
    [already_started]
    [Operation already in progress. ]
  ]

  [
    [broken_pipe]
    [Broken pipe. ]
  ]

  [
    [connection_aborted]
    [A connection has been aborted. ]
  ]

  [
    [connection_refused]
    [Connection refused. ]
  ]

  [
    [connection_reset]
    [Connection reset by peer. ]
  ]

  [
    [bad_descriptor]
    [Bad file descriptor. ]
  ]

  [
    [fault]
    [Bad address. ]
  ]

  [
    [host_unreachable]
    [No route to host. ]
  ]

  [
    [in_progress]
    [Operation now in progress. ]
  ]

  [
    [interrupted]
    [Interrupted system call. ]
  ]

  [
    [invalid_argument]
    [Invalid argument. ]
  ]

  [
    [message_size]
    [Message too long. ]
  ]

  [
    [name_too_long]
    [The name was too long. ]
  ]

  [
    [network_down]
    [Network is down. ]
  ]

  [
    [network_reset]
    [Network dropped connection on reset. ]
  ]

  [
    [network_unreachable]
    [Network is unreachable. ]
  ]

  [
    [no_descriptors]
    [Too many open files. ]
  ]

  [
    [no_buffer_space]
    [No buffer space available. ]
  ]

  [
    [no_memory]
    [Cannot allocate memory. ]
  ]

  [
    [no_permission]
    [Operation not permitted. ]
  ]

  [
    [no_protocol_option]
    [Protocol not available. ]
  ]

  [
    [not_connected]
    [Transport endpoint is not connected. ]
  ]

  [
    [not_socket]
    [Socket operation on non-socket. ]
  ]

  [
    [operation_aborted]
    [Operation cancelled. ]
  ]

  [
    [operation_not_supported]
    [Operation not supported. ]
  ]

  [
    [shut_down]
    [Cannot send after transport endpoint shutdown. ]
  ]

  [
    [timed_out]
    [Connection timed out. ]
  ]

  [
    [try_again]
    [Resource temporarily unavailable. ]
  ]

  [
    [would_block]
    [The socket is marked non-blocking and the requested operation would block. ]
  ]

]



[endsect]



[section:error__get_addrinfo_category error::get_addrinfo_category]

[indexterm1 error::get_addrinfo_category] 

  const boost::system::error_category & get_addrinfo_category();



[endsect]



[section:error__get_misc_category error::get_misc_category]

[indexterm1 error::get_misc_category] 

  const boost::system::error_category & get_misc_category();



[endsect]



[section:error__get_netdb_category error::get_netdb_category]

[indexterm1 error::get_netdb_category] 

  const boost::system::error_category & get_netdb_category();



[endsect]



[section:error__get_ssl_category error::get_ssl_category]

[indexterm1 error::get_ssl_category] 

  const boost::system::error_category & get_ssl_category();



[endsect]



[section:error__get_system_category error::get_system_category]

[indexterm1 error::get_system_category] 

  const boost::system::error_category & get_system_category();



[endsect]


[section:error__make_error_code error::make_error_code]

[indexterm1 error::make_error_code] 
    
  boost::system::error_code ``[link boost_asio.reference.error__make_error_code.overload1 make_error_code]``(
      basic_errors e);

  boost::system::error_code ``[link boost_asio.reference.error__make_error_code.overload2 make_error_code]``(
      netdb_errors e);

  boost::system::error_code ``[link boost_asio.reference.error__make_error_code.overload3 make_error_code]``(
      addrinfo_errors e);

  boost::system::error_code ``[link boost_asio.reference.error__make_error_code.overload4 make_error_code]``(
      misc_errors e);

  boost::system::error_code ``[link boost_asio.reference.error__make_error_code.overload5 make_error_code]``(
      ssl_errors e);


[section:overload1 error::make_error_code (1 of 5 overloads)]



  boost::system::error_code make_error_code(
      basic_errors e);



[endsect]



[section:overload2 error::make_error_code (2 of 5 overloads)]



  boost::system::error_code make_error_code(
      netdb_errors e);



[endsect]



[section:overload3 error::make_error_code (3 of 5 overloads)]



  boost::system::error_code make_error_code(
      addrinfo_errors e);



[endsect]



[section:overload4 error::make_error_code (4 of 5 overloads)]



  boost::system::error_code make_error_code(
      misc_errors e);



[endsect]



[section:overload5 error::make_error_code (5 of 5 overloads)]



  boost::system::error_code make_error_code(
      ssl_errors e);



[endsect]


[endsect]


[section:error__misc_category error::misc_category]

[indexterm1 error::misc_category] 

  static const boost::system::error_category & misc_category = boost::asio::error::get_misc_category();



[endsect]



[section:error__misc_errors error::misc_errors]

[indexterm1 error::misc_errors] 

  enum misc_errors

[heading Values]
[variablelist

  [
    [already_open]
    [Already open. ]
  ]

  [
    [eof]
    [End of file or stream. ]
  ]

  [
    [not_found]
    [Element not found. ]
  ]

  [
    [fd_set_failure]
    [The descriptor cannot fit into the select system call's fd_set. ]
  ]

]



[endsect]



[section:error__netdb_category error::netdb_category]

[indexterm1 error::netdb_category] 

  static const boost::system::error_category & netdb_category = boost::asio::error::get_netdb_category();



[endsect]



[section:error__netdb_errors error::netdb_errors]

[indexterm1 error::netdb_errors] 

  enum netdb_errors

[heading Values]
[variablelist

  [
    [host_not_found]
    [Host not found (authoritative). ]
  ]

  [
    [host_not_found_try_again]
    [Host not found (non-authoritative). ]
  ]

  [
    [no_data]
    [The query is valid but does not have associated address data. ]
  ]

  [
    [no_recovery]
    [A non-recoverable error occurred. ]
  ]

]



[endsect]



[section:error__ssl_category error::ssl_category]

[indexterm1 error::ssl_category] 

  static const boost::system::error_category & ssl_category = boost::asio::error::get_ssl_category();



[endsect]



[section:error__ssl_errors error::ssl_errors]

[indexterm1 error::ssl_errors] 

  enum ssl_errors



[endsect]



[section:error__system_category error::system_category]

[indexterm1 error::system_category] 

  static const boost::system::error_category & system_category = boost::asio::error::get_system_category();



[endsect]



[section:has_service has_service]

[indexterm1 has_service] 

  template<
      typename ``[link boost_asio.reference.Service Service]``>
  bool has_service(
      io_service & ios);


This function is used to determine whether the io_service contains a service object corresponding to the given service type.


[heading Parameters]
    

[variablelist
  
[[ios][The io\_service object that owns the service.]]

]

[heading Return Value]
      
A boolean indicating whether the io_service contains the service. 



[endsect]


[section:invalid_service_owner invalid_service_owner]

Exception thrown when trying to add a service object to an io_service where the service has a different owner. 

  class invalid_service_owner


[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.invalid_service_owner.invalid_service_owner [*invalid_service_owner]]]
    []
  ]
  
]


[section:invalid_service_owner invalid_service_owner::invalid_service_owner]

[indexterm2 invalid_service_owner..invalid_service_owner] 

  invalid_service_owner();



[endsect]



[endsect]

[section:io_service io_service]

Provides core I/O functionality. 

  class io_service :
    noncopyable


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.io_service__id [*id]]]
    [Class used to uniquely identify a service. ]
  
  ]

  [

    [[link boost_asio.reference.io_service__service [*service]]]
    [Base class for all io_service services. ]
  
  ]

  [

    [[link boost_asio.reference.io_service__strand [*strand]]]
    [Provides serialised handler execution. ]
  
  ]

  [

    [[link boost_asio.reference.io_service__work [*work]]]
    [Class to inform the io_service when it has work to do. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.io_service.dispatch [*dispatch]]]
    [Request the io_service to invoke the given handler. ]
  ]
  
  [
    [[link boost_asio.reference.io_service.io_service [*io_service]]]
    [Constructor. ]
  ]
  
  [
    [[link boost_asio.reference.io_service.poll [*poll]]]
    [Run the io_service's event processing loop to execute ready handlers. ]
  ]
  
  [
    [[link boost_asio.reference.io_service.poll_one [*poll_one]]]
    [Run the io_service's event processing loop to execute one ready handler. ]
  ]
  
  [
    [[link boost_asio.reference.io_service.post [*post]]]
    [Request the io_service to invoke the given handler and return immediately. ]
  ]
  
  [
    [[link boost_asio.reference.io_service.reset [*reset]]]
    [Reset the io_service in preparation for a subsequent run() invocation. ]
  ]
  
  [
    [[link boost_asio.reference.io_service.run [*run]]]
    [Run the io_service's event processing loop. ]
  ]
  
  [
    [[link boost_asio.reference.io_service.run_one [*run_one]]]
    [Run the io_service's event processing loop to execute at most one handler. ]
  ]
  
  [
    [[link boost_asio.reference.io_service.stop [*stop]]]
    [Stop the io_service's event processing loop. ]
  ]
  
  [
    [[link boost_asio.reference.io_service.wrap [*wrap]]]
    [Create a new handler that automatically dispatches the wrapped handler on the io_service. ]
  ]
  
  [
    [[link boost_asio.reference.io_service._io_service [*~io_service]]]
    [Destructor. ]
  ]
  
]

[heading Friends]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.io_service.add_service [*add_service]]]
    [Add a service object to the io_service. ]
  ]
  
  [
    [[link boost_asio.reference.io_service.has_service [*has_service]]]
    [Determine if an io_service contains a specified service type. ]
  ]
  
  [
    [[link boost_asio.reference.io_service.use_service [*use_service]]]
    [Obtain the service object corresponding to the given type. ]
  ]
  
]

The io_service class provides the core I/O functionality for users of the asynchronous I/O objects, including:


* boost::asio::ip::tcp::socket

* boost::asio::ip::tcp::acceptor

* boost::asio::ip::udp::socket

* boost::asio::deadline_timer.

The io_service class also includes facilities intended for developers of custom asynchronous services.


[heading Thread Safety]
  
[*Distinct] [*objects:]  Safe.

[*Shared] [*objects:]  Safe, with the exception that calling reset() while there are unfinished run() calls results in undefined behaviour.

[heading Effect of exceptions thrown from handlers]
  


If an exception is thrown from a handler, the exception is allowed to propagate through the throwing thread's invocation of boost::asio::io\_service::run(), boost::asio::io\_service::run\_one(), boost::asio::io\_service::poll() or boost::asio::io\_service::poll\_one(). No other threads that are calling any of these functions are affected. It is then the responsibility of the application to catch the exception.

After the exception has been caught, the boost::asio::io\_service::run(), boost::asio::io\_service::run\_one(), boost::asio::io\_service::poll() or boost::asio::io\_service::poll\_one() call may be restarted [*without]  the need for an intervening call to boost::asio::io\_service::reset(). This allows the thread to rejoin the io\_service's thread pool without impacting any other threads in the pool.

For example:



   boost::asio::io_service io_service;
   ...
   for (;;)
   {
     try
     {
       io_service.run();
       break; // run() exited normally
     }
     catch (my_exception& e)
     {
       // Deal with exception as appropriate.
     }
   }





[heading Stopping the io_service from running out of work]
  


Some applications may need to prevent an io\_service's run() call from returning when there is no more work to do. For example, the io_service may be being run in a background thread that is launched prior to the application's asynchronous operations. The run() call may be kept running by creating an object of type 
[link boost_asio.reference.io_service__work io_service::work]:



   boost::asio::io_service io_service;
   boost::asio::io_service::work work(io_service);
   ... 




To effect a shutdown, the application will then need to call the io\_service's stop() member function. This will cause the io_servicerun() call to return as soon as possible, abandoning unfinished operations and without permitting ready handlers to be dispatched.

Alternatively, if the application requires that all operations and handlers be allowed to finish normally, the work object may be explicitly destroyed.



   boost::asio::io_service io_service;
   auto_ptr<boost::asio::io_service::work> work(
       new boost::asio::io_service::work(io_service));
   ...
   work.reset(); // Allow run() to exit. 





[section:add_service io_service::add_service]

[indexterm2 add_service..io_service] Add a service object to the io_service. 

  template<
      typename ``[link boost_asio.reference.Service Service]``>
  friend void add_service(
      io_service & ios,
      Service * svc);


This function is used to add a service to the io_service.


[heading Parameters]
    

[variablelist
  
[[ios][The io\_service object that owns the service.]]

[[svc][The service object. On success, ownership of the service object is transferred to the io\_service. When the io\_service object is destroyed, it will destroy the service object by performing: 
``
   delete static_cast<io_service::service*>(svc) 
``
]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::asio::service_already_exists][Thrown if a service of the given type is already present in the io\_service.]]

[[boost::asio::invalid_service_owner][Thrown if the service's owning io\_service is not the io\_service object specified by the ios parameter. ]]

]



[endsect]



[section:dispatch io_service::dispatch]

[indexterm2 dispatch..io_service] Request the io_service to invoke the given handler. 

  template<
      typename ``[link boost_asio.reference.CompletionHandler CompletionHandler]``>
  void dispatch(
      CompletionHandler handler);


This function is used to ask the io_service to execute the given handler.

The io_service guarantees that the handler will only be called in a thread in which the run(), run\_one(), poll() or poll\_one() member functions is currently being invoked. The handler may be executed inside this function if the guarantee can be met.


[heading Parameters]
    

[variablelist
  
[[handler][The handler to be called. The io\_service will make a copy of the handler object as required. The function signature of the handler must be:
``
   void handler(); 
``
]]

]



[endsect]



[section:has_service io_service::has_service]

[indexterm2 has_service..io_service] Determine if an io_service contains a specified service type. 

  template<
      typename ``[link boost_asio.reference.Service Service]``>
  friend bool has_service(
      io_service & ios);


This function is used to determine whether the io_service contains a service object corresponding to the given service type.


[heading Parameters]
    

[variablelist
  
[[ios][The io\_service object that owns the service.]]

]

[heading Return Value]
      
A boolean indicating whether the io_service contains the service. 



[endsect]


[section:io_service io_service::io_service]

[indexterm2 io_service..io_service] Constructor. 

  ``[link boost_asio.reference.io_service.io_service.overload1 io_service]``();

  ``[link boost_asio.reference.io_service.io_service.overload2 io_service]``(
      std::size_t concurrency_hint);


[section:overload1 io_service::io_service (1 of 2 overloads)]

Constructor. 

  io_service();



[endsect]



[section:overload2 io_service::io_service (2 of 2 overloads)]

Constructor. 

  io_service(
      std::size_t concurrency_hint);


Construct with a hint about the required level of concurrency.


[heading Parameters]
    

[variablelist
  
[[concurrency_hint][A suggestion to the implementation on how many threads it should allow to run simultaneously. ]]

]



[endsect]


[endsect]

[section:poll io_service::poll]

[indexterm2 poll..io_service] Run the io_service's event processing loop to execute ready handlers. 

  std::size_t ``[link boost_asio.reference.io_service.poll.overload1 poll]``();

  std::size_t ``[link boost_asio.reference.io_service.poll.overload2 poll]``(
      boost::system::error_code & ec);


[section:overload1 io_service::poll (1 of 2 overloads)]

Run the io_service's event processing loop to execute ready handlers. 

  std::size_t poll();


The poll() function runs handlers that are ready to run, without blocking, until the io_service has been stopped or there are no more ready handlers.


[heading Return Value]
      
The number of handlers that were executed.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. ]]

]



[endsect]



[section:overload2 io_service::poll (2 of 2 overloads)]

Run the io_service's event processing loop to execute ready handlers. 

  std::size_t poll(
      boost::system::error_code & ec);


The poll() function runs handlers that are ready to run, without blocking, until the io_service has been stopped or there are no more ready handlers.


[heading Parameters]
    

[variablelist
  
[[ec][Set to indicate what error occurred, if any.]]

]

[heading Return Value]
      
The number of handlers that were executed. 



[endsect]


[endsect]

[section:poll_one io_service::poll_one]

[indexterm2 poll_one..io_service] Run the io_service's event processing loop to execute one ready handler. 

  std::size_t ``[link boost_asio.reference.io_service.poll_one.overload1 poll_one]``();

  std::size_t ``[link boost_asio.reference.io_service.poll_one.overload2 poll_one]``(
      boost::system::error_code & ec);


[section:overload1 io_service::poll_one (1 of 2 overloads)]

Run the io_service's event processing loop to execute one ready handler. 

  std::size_t poll_one();


The poll\_one() function runs at most one handler that is ready to run, without blocking.


[heading Return Value]
      
The number of handlers that were executed.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. ]]

]



[endsect]



[section:overload2 io_service::poll_one (2 of 2 overloads)]

Run the io_service's event processing loop to execute one ready handler. 

  std::size_t poll_one(
      boost::system::error_code & ec);


The poll\_one() function runs at most one handler that is ready to run, without blocking.


[heading Parameters]
    

[variablelist
  
[[ec][Set to indicate what error occurred, if any.]]

]

[heading Return Value]
      
The number of handlers that were executed. 



[endsect]


[endsect]


[section:post io_service::post]

[indexterm2 post..io_service] Request the io_service to invoke the given handler and return immediately. 

  template<
      typename ``[link boost_asio.reference.CompletionHandler CompletionHandler]``>
  void post(
      CompletionHandler handler);


This function is used to ask the io_service to execute the given handler, but without allowing the io_service to call the handler from inside this function.

The io_service guarantees that the handler will only be called in a thread in which the run(), run\_one(), poll() or poll\_one() member functions is currently being invoked.


[heading Parameters]
    

[variablelist
  
[[handler][The handler to be called. The io\_service will make a copy of the handler object as required. The function signature of the handler must be:
``
   void handler(); 
``
]]

]



[endsect]



[section:reset io_service::reset]

[indexterm2 reset..io_service] Reset the io_service in preparation for a subsequent run() invocation. 

  void reset();


This function must be called prior to any second or later set of invocations of the run(), run\_one(), poll() or poll\_one() functions when a previous invocation of these functions returned due to the io_service being stopped or running out of work. This function allows the io_service to reset any internal state, such as a "stopped" flag.

This function must not be called while there are any unfinished calls to the run(), run\_one(), poll() or poll\_one() functions. 


[endsect]


[section:run io_service::run]

[indexterm2 run..io_service] Run the io_service's event processing loop. 

  std::size_t ``[link boost_asio.reference.io_service.run.overload1 run]``();

  std::size_t ``[link boost_asio.reference.io_service.run.overload2 run]``(
      boost::system::error_code & ec);


[section:overload1 io_service::run (1 of 2 overloads)]

Run the io_service's event processing loop. 

  std::size_t run();


The run() function blocks until all work has finished and there are no more handlers to be dispatched, or until the io_service has been stopped.

Multiple threads may call the run() function to set up a pool of threads from which the io_service may execute handlers. All threads that are waiting in the pool are equivalent and the io_service may choose any one of them to invoke a handler.

The run() function may be safely called again once it has completed only after a call to reset().


[heading Return Value]
      
The number of handlers that were executed.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Remarks]
      
The poll() function may also be used to dispatch ready handlers, but without blocking. 



[endsect]



[section:overload2 io_service::run (2 of 2 overloads)]

Run the io_service's event processing loop. 

  std::size_t run(
      boost::system::error_code & ec);


The run() function blocks until all work has finished and there are no more handlers to be dispatched, or until the io_service has been stopped.

Multiple threads may call the run() function to set up a pool of threads from which the io_service may execute handlers. All threads that are waiting in the pool are equivalent and the io_service may choose any one of them to invoke a handler.

The run() function may be safely called again once it has completed only after a call to reset().


[heading Parameters]
    

[variablelist
  
[[ec][Set to indicate what error occurred, if any.]]

]

[heading Return Value]
      
The number of handlers that were executed.

[heading Remarks]
      
The poll() function may also be used to dispatch ready handlers, but without blocking. 



[endsect]


[endsect]

[section:run_one io_service::run_one]

[indexterm2 run_one..io_service] Run the io_service's event processing loop to execute at most one handler. 

  std::size_t ``[link boost_asio.reference.io_service.run_one.overload1 run_one]``();

  std::size_t ``[link boost_asio.reference.io_service.run_one.overload2 run_one]``(
      boost::system::error_code & ec);


[section:overload1 io_service::run_one (1 of 2 overloads)]

Run the io_service's event processing loop to execute at most one handler. 

  std::size_t run_one();


The run\_one() function blocks until one handler has been dispatched, or until the io_service has been stopped.


[heading Return Value]
      
The number of handlers that were executed.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. ]]

]



[endsect]



[section:overload2 io_service::run_one (2 of 2 overloads)]

Run the io_service's event processing loop to execute at most one handler. 

  std::size_t run_one(
      boost::system::error_code & ec);


The run\_one() function blocks until one handler has been dispatched, or until the io_service has been stopped.


[heading Parameters]
    

[variablelist
  
[[ec][Set to indicate what error occurred, if any.]]

]

[heading Return Value]
      
The number of handlers that were executed. 



[endsect]


[endsect]


[section:stop io_service::stop]

[indexterm2 stop..io_service] Stop the io_service's event processing loop. 

  void stop();


This function does not block, but instead simply signals the io_service to stop. All invocations of its run() or run\_one() member functions should return as soon as possible. Subsequent calls to run(), run\_one(), poll() or poll\_one() will return immediately until reset() is called. 


[endsect]



[section:use_service io_service::use_service]

[indexterm2 use_service..io_service] Obtain the service object corresponding to the given type. 

  template<
      typename ``[link boost_asio.reference.Service Service]``>
  friend Service & use_service(
      io_service & ios);


This function is used to locate a service object that corresponds to the given service type. If there is no existing implementation of the service, then the io_service will create a new instance of the service.


[heading Parameters]
    

[variablelist
  
[[ios][The io\_service object that owns the service.]]

]

[heading Return Value]
      
The service interface implementing the specified service type. Ownership of the service interface is not transferred to the caller. 



[endsect]



[section:wrap io_service::wrap]

[indexterm2 wrap..io_service] Create a new handler that automatically dispatches the wrapped handler on the io_service. 

  template<
      typename ``[link boost_asio.reference.Handler Handler]``>
  unspecified wrap(
      Handler handler);


This function is used to create a new handler function object that, when invoked, will automatically pass the wrapped handler to the io\_service's dispatch function.


[heading Parameters]
    

[variablelist
  
[[handler][The handler to be wrapped. The io\_service will make a copy of the handler object as required. The function signature of the handler must be:
``
   void handler(A1 a1, ... An an); 
``
]]

]

[heading Return Value]
      
A function object that, when invoked, passes the wrapped handler to the io\_service's dispatch function. Given a function object with the signature: 

   R f(A1 a1, ... An an); 


If this function object is passed to the wrap function like so: 

   io_service.wrap(f); 


then the return value is a function object with the signature 

   void g(A1 a1, ... An an); 


that, when invoked, executes code equivalent to: 

   io_service.dispatch(boost::bind(f, a1, ... an)); 






[endsect]



[section:_io_service io_service::~io_service]

[indexterm2 ~io_service..io_service] Destructor. 

  ~io_service();



[endsect]



[endsect]

[section:io_service__id io_service::id]

Class used to uniquely identify a service. 

  class id :
    noncopyable


[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.io_service__id.id [*id]]]
    [Constructor. ]
  ]
  
]


[section:id io_service::id::id]

[indexterm2 id..io_service::id] Constructor. 

  id();



[endsect]



[endsect]

[section:io_service__service io_service::service]

Base class for all io_service services. 

  class service :
    noncopyable


[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.io_service__service.get_io_service [*get_io_service]]]
    [Get the io_service object that owns the service. ]
  ]
  
  [
    [[link boost_asio.reference.io_service__service.io_service [*io_service]]]
    [(Deprecated: use get_io_service().) Get the io_service object that owns the service. ]
  ]
  
]

[heading Protected Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.io_service__service.service [*service]]]
    [Constructor. ]
  ]
  
  [
    [[link boost_asio.reference.io_service__service._service [*~service]]]
    [Destructor. ]
  ]
  
]


[section:get_io_service io_service::service::get_io_service]

[indexterm2 get_io_service..io_service::service] Get the io_service object that owns the service. 

  boost::asio::io_service & get_io_service();



[endsect]



[section:io_service io_service::service::io_service]

[indexterm2 io_service..io_service::service] (Deprecated: use get_io_service().) Get the io_service object that owns the service. 

  boost::asio::io_service & io_service();



[endsect]



[section:service io_service::service::service]

[indexterm2 service..io_service::service] Constructor. 

  service(
      boost::asio::io_service & owner);



[heading Parameters]
    

[variablelist
  
[[owner][The io\_service object that owns the service. ]]

]



[endsect]



[section:_service io_service::service::~service]

[indexterm2 ~service..io_service::service] Destructor. 

  virtual ~service();



[endsect]



[endsect]

[section:io_service__strand io_service::strand]

Provides serialised handler execution. 

  class strand


[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.io_service__strand.dispatch [*dispatch]]]
    [Request the strand to invoke the given handler. ]
  ]
  
  [
    [[link boost_asio.reference.io_service__strand.get_io_service [*get_io_service]]]
    [Get the io_service associated with the strand. ]
  ]
  
  [
    [[link boost_asio.reference.io_service__strand.io_service [*io_service]]]
    [(Deprecated: use get_io_service().) Get the io_service associated with the strand. ]
  ]
  
  [
    [[link boost_asio.reference.io_service__strand.post [*post]]]
    [Request the strand to invoke the given handler and return immediately. ]
  ]
  
  [
    [[link boost_asio.reference.io_service__strand.strand [*strand]]]
    [Constructor. ]
  ]
  
  [
    [[link boost_asio.reference.io_service__strand.wrap [*wrap]]]
    [Create a new handler that automatically dispatches the wrapped handler on the strand. ]
  ]
  
  [
    [[link boost_asio.reference.io_service__strand._strand [*~strand]]]
    [Destructor. ]
  ]
  
]

The io_service::strand class provides the ability to post and dispatch handlers with the guarantee that none of those handlers will execute concurrently.


[heading Thread Safety]
  
[*Distinct] [*objects:]  Safe.

[*Shared] [*objects:]  Safe.



[section:dispatch io_service::strand::dispatch]

[indexterm2 dispatch..io_service::strand] Request the strand to invoke the given handler. 

  template<
      typename ``[link boost_asio.reference.Handler Handler]``>
  void dispatch(
      Handler handler);


This function is used to ask the strand to execute the given handler.

The strand object guarantees that handlers posted or dispatched through the strand will not be executed concurrently. The handler may be executed inside this function if the guarantee can be met. If this function is called from within a handler that was posted or dispatched through the same strand, then the new handler will be executed immediately.

The strand's guarantee is in addition to the guarantee provided by the underlying io_service. The io_service guarantees that the handler will only be called in a thread in which the io\_service's run member function is currently being invoked.


[heading Parameters]
    

[variablelist
  
[[handler][The handler to be called. The strand will make a copy of the handler object as required. The function signature of the handler must be: 
``
   void handler(); 
``
]]

]



[endsect]



[section:get_io_service io_service::strand::get_io_service]

[indexterm2 get_io_service..io_service::strand] Get the io_service associated with the strand. 

  boost::asio::io_service & get_io_service();


This function may be used to obtain the io_service object that the strand uses to dispatch handlers for asynchronous operations.


[heading Return Value]
      
A reference to the io_service object that the strand will use to dispatch handlers. Ownership is not transferred to the caller. 



[endsect]



[section:io_service io_service::strand::io_service]

[indexterm2 io_service..io_service::strand] (Deprecated: use get_io_service().) Get the io_service associated with the strand. 

  boost::asio::io_service & io_service();


This function may be used to obtain the io_service object that the strand uses to dispatch handlers for asynchronous operations.


[heading Return Value]
      
A reference to the io_service object that the strand will use to dispatch handlers. Ownership is not transferred to the caller. 



[endsect]



[section:post io_service::strand::post]

[indexterm2 post..io_service::strand] Request the strand to invoke the given handler and return immediately. 

  template<
      typename ``[link boost_asio.reference.Handler Handler]``>
  void post(
      Handler handler);


This function is used to ask the strand to execute the given handler, but without allowing the strand to call the handler from inside this function.

The strand object guarantees that handlers posted or dispatched through the strand will not be executed concurrently. The strand's guarantee is in addition to the guarantee provided by the underlying io_service. The io_service guarantees that the handler will only be called in a thread in which the io\_service's run member function is currently being invoked.


[heading Parameters]
    

[variablelist
  
[[handler][The handler to be called. The strand will make a copy of the handler object as required. The function signature of the handler must be: 
``
   void handler(); 
``
]]

]



[endsect]



[section:strand io_service::strand::strand]

[indexterm2 strand..io_service::strand] Constructor. 

  strand(
      boost::asio::io_service & io_service);


Constructs the strand.


[heading Parameters]
    

[variablelist
  
[[io_service][The io\_service object that the strand will use to dispatch handlers that are ready to be run. ]]

]



[endsect]



[section:wrap io_service::strand::wrap]

[indexterm2 wrap..io_service::strand] Create a new handler that automatically dispatches the wrapped handler on the strand. 

  template<
      typename ``[link boost_asio.reference.Handler Handler]``>
  unspecified wrap(
      Handler handler);


This function is used to create a new handler function object that, when invoked, will automatically pass the wrapped handler to the strand's dispatch function.


[heading Parameters]
    

[variablelist
  
[[handler][The handler to be wrapped. The strand will make a copy of the handler object as required. The function signature of the handler must be:
``
   void handler(A1 a1, ... An an); 
``
]]

]

[heading Return Value]
      
A function object that, when invoked, passes the wrapped handler to the strand's dispatch function. Given a function object with the signature: 

   R f(A1 a1, ... An an); 


If this function object is passed to the wrap function like so: 

   strand.wrap(f); 


then the return value is a function object with the signature 

   void g(A1 a1, ... An an); 


that, when invoked, executes code equivalent to: 

   strand.dispatch(boost::bind(f, a1, ... an)); 






[endsect]



[section:_strand io_service::strand::~strand]

[indexterm2 ~strand..io_service::strand] Destructor. 

  ~strand();


Destroys a strand.

Handlers posted through the strand that have not yet been invoked will still be dispatched in a way that meets the guarantee of non-concurrency. 


[endsect]



[endsect]

[section:io_service__work io_service::work]

Class to inform the io_service when it has work to do. 

  class work


[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.io_service__work.get_io_service [*get_io_service]]]
    [Get the io_service associated with the work. ]
  ]
  
  [
    [[link boost_asio.reference.io_service__work.io_service [*io_service]]]
    [(Deprecated: use get_io_service().) Get the io_service associated with the work. ]
  ]
  
  [
    [[link boost_asio.reference.io_service__work.work [*work]]]
    [Constructor notifies the io_service that work is starting. 

     Copy constructor notifies the io_service that work is starting. ]
  ]
  
  [
    [[link boost_asio.reference.io_service__work._work [*~work]]]
    [Destructor notifies the io_service that the work is complete. ]
  ]
  
]

The work class is used to inform the io_service when work starts and finishes. This ensures that the io\_service's run() function will not exit while work is underway, and that it does exit when there is no unfinished work remaining.

The work class is copy-constructible so that it may be used as a data member in a handler class. It is not assignable. 


[section:get_io_service io_service::work::get_io_service]

[indexterm2 get_io_service..io_service::work] Get the io_service associated with the work. 

  boost::asio::io_service & get_io_service();



[endsect]



[section:io_service io_service::work::io_service]

[indexterm2 io_service..io_service::work] (Deprecated: use get_io_service().) Get the io_service associated with the work. 

  boost::asio::io_service & io_service();



[endsect]


[section:work io_service::work::work]

[indexterm2 work..io_service::work] Constructor notifies the io_service that work is starting. 

  ``[link boost_asio.reference.io_service__work.work.overload1 work]``(
      boost::asio::io_service & io_service);

Copy constructor notifies the io_service that work is starting. 

  ``[link boost_asio.reference.io_service__work.work.overload2 work]``(
      const work & other);


[section:overload1 io_service::work::work (1 of 2 overloads)]

Constructor notifies the io_service that work is starting. 

  work(
      boost::asio::io_service & io_service);


The constructor is used to inform the io_service that some work has begun. This ensures that the io\_service's run() function will not exit while the work is underway. 


[endsect]



[section:overload2 io_service::work::work (2 of 2 overloads)]

Copy constructor notifies the io_service that work is starting. 

  work(
      const work & other);


The constructor is used to inform the io_service that some work has begun. This ensures that the io\_service's run() function will not exit while the work is underway. 


[endsect]


[endsect]


[section:_work io_service::work::~work]

[indexterm2 ~work..io_service::work] Destructor notifies the io_service that the work is complete. 

  ~work();


The destructor is used to inform the io_service that some work has finished. Once the count of unfinished work reaches zero, the io\_service's run() function is permitted to exit. 


[endsect]



[endsect]

[section:ip__address ip::address]

Implements version-independent IP addresses. 

  class address


[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.ip__address.address [*address]]]
    [Default constructor. 

     Construct an address from an IPv4 address. 

     Construct an address from an IPv6 address. 

     Copy constructor. ]
  ]
  
  [
    [[link boost_asio.reference.ip__address.from_string [*from_string]]]
    [Create an address from an IPv4 address string in dotted decimal form, or from an IPv6 address in hexadecimal notation. ]
  ]
  
  [
    [[link boost_asio.reference.ip__address.is_v4 [*is_v4]]]
    [Get whether the address is an IP version 4 address. ]
  ]
  
  [
    [[link boost_asio.reference.ip__address.is_v6 [*is_v6]]]
    [Get whether the address is an IP version 6 address. ]
  ]
  
  [
    [[link boost_asio.reference.ip__address.operator_eq_ [*operator=]]]
    [Assign from another address. 

     Assign from an IPv4 address. 

     Assign from an IPv6 address. ]
  ]
  
  [
    [[link boost_asio.reference.ip__address.to_string [*to_string]]]
    [Get the address as a string in dotted decimal format. ]
  ]
  
  [
    [[link boost_asio.reference.ip__address.to_v4 [*to_v4]]]
    [Get the address as an IP version 4 address. ]
  ]
  
  [
    [[link boost_asio.reference.ip__address.to_v6 [*to_v6]]]
    [Get the address as an IP version 6 address. ]
  ]
  
]

[heading Friends]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.ip__address.operator_not__eq_ [*operator!=]]]
    [Compare two addresses for inequality. ]
  ]
  
  [
    [[link boost_asio.reference.ip__address.operator_lt_ [*operator<]]]
    [Compare addresses for ordering. ]
  ]
  
  [
    [[link boost_asio.reference.ip__address.operator_eq__eq_ [*operator==]]]
    [Compare two addresses for equality. ]
  ]
  
]

[heading Related Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.ip__address.operator_lt__lt_ [*operator<<]]]
    [Output an address as a string. ]
  ]
  
]

The 
[link boost_asio.reference.ip__address ip::address] class provides the ability to use either IP version 4 or version 6 addresses.


[heading Thread Safety]
  
[*Distinct] [*objects:]  Safe.

[*Shared] [*objects:]  Unsafe. 


[section:address ip::address::address]

[indexterm2 address..ip::address] Default constructor. 

  ``[link boost_asio.reference.ip__address.address.overload1 address]``();

Construct an address from an IPv4 address. 

  ``[link boost_asio.reference.ip__address.address.overload2 address]``(
      const boost::asio::ip::address_v4 & ipv4_address);

Construct an address from an IPv6 address. 

  ``[link boost_asio.reference.ip__address.address.overload3 address]``(
      const boost::asio::ip::address_v6 & ipv6_address);

Copy constructor. 

  ``[link boost_asio.reference.ip__address.address.overload4 address]``(
      const address & other);


[section:overload1 ip::address::address (1 of 4 overloads)]

Default constructor. 

  address();



[endsect]



[section:overload2 ip::address::address (2 of 4 overloads)]

Construct an address from an IPv4 address. 

  address(
      const boost::asio::ip::address_v4 & ipv4_address);



[endsect]



[section:overload3 ip::address::address (3 of 4 overloads)]

Construct an address from an IPv6 address. 

  address(
      const boost::asio::ip::address_v6 & ipv6_address);



[endsect]



[section:overload4 ip::address::address (4 of 4 overloads)]

Copy constructor. 

  address(
      const address & other);



[endsect]


[endsect]

[section:from_string ip::address::from_string]

[indexterm2 from_string..ip::address] Create an address from an IPv4 address string in dotted decimal form, or from an IPv6 address in hexadecimal notation. 

  static address ``[link boost_asio.reference.ip__address.from_string.overload1 from_string]``(
      const char * str);

  static address ``[link boost_asio.reference.ip__address.from_string.overload2 from_string]``(
      const char * str,
      boost::system::error_code & ec);

  static address ``[link boost_asio.reference.ip__address.from_string.overload3 from_string]``(
      const std::string & str);

  static address ``[link boost_asio.reference.ip__address.from_string.overload4 from_string]``(
      const std::string & str,
      boost::system::error_code & ec);


[section:overload1 ip::address::from_string (1 of 4 overloads)]

Create an address from an IPv4 address string in dotted decimal form, or from an IPv6 address in hexadecimal notation. 

  static address from_string(
      const char * str);



[endsect]



[section:overload2 ip::address::from_string (2 of 4 overloads)]

Create an address from an IPv4 address string in dotted decimal form, or from an IPv6 address in hexadecimal notation. 

  static address from_string(
      const char * str,
      boost::system::error_code & ec);



[endsect]



[section:overload3 ip::address::from_string (3 of 4 overloads)]

Create an address from an IPv4 address string in dotted decimal form, or from an IPv6 address in hexadecimal notation. 

  static address from_string(
      const std::string & str);



[endsect]



[section:overload4 ip::address::from_string (4 of 4 overloads)]

Create an address from an IPv4 address string in dotted decimal form, or from an IPv6 address in hexadecimal notation. 

  static address from_string(
      const std::string & str,
      boost::system::error_code & ec);



[endsect]


[endsect]


[section:is_v4 ip::address::is_v4]

[indexterm2 is_v4..ip::address] Get whether the address is an IP version 4 address. 

  bool is_v4() const;



[endsect]



[section:is_v6 ip::address::is_v6]

[indexterm2 is_v6..ip::address] Get whether the address is an IP version 6 address. 

  bool is_v6() const;



[endsect]



[section:operator_not__eq_ ip::address::operator!=]

[indexterm2 operator!=..ip::address] Compare two addresses for inequality. 

  friend bool operator!=(
      const address & a1,
      const address & a2);



[endsect]



[section:operator_lt_ ip::address::operator<]

[indexterm2 operator<..ip::address] Compare addresses for ordering. 

  friend bool operator<(
      const address & a1,
      const address & a2);



[endsect]



[section:operator_lt__lt_ ip::address::operator<<]

[indexterm2 operator<<..ip::address] Output an address as a string. 

  template<
      typename Elem,
      typename Traits>
  std::basic_ostream< Elem, Traits > & operator<<(
      std::basic_ostream< Elem, Traits > & os,
      const address & addr);


Used to output a human-readable string for a specified address.


[heading Parameters]
    

[variablelist
  
[[os][The output stream to which the string will be written.]]

[[addr][The address to be written.]]

]

[heading Return Value]
      
The output stream. 



[endsect]


[section:operator_eq_ ip::address::operator=]

[indexterm2 operator=..ip::address] Assign from another address. 

  address & ``[link boost_asio.reference.ip__address.operator_eq_.overload1 operator=]``(
      const address & other);

Assign from an IPv4 address. 

  address & ``[link boost_asio.reference.ip__address.operator_eq_.overload2 operator=]``(
      const boost::asio::ip::address_v4 & ipv4_address);

Assign from an IPv6 address. 

  address & ``[link boost_asio.reference.ip__address.operator_eq_.overload3 operator=]``(
      const boost::asio::ip::address_v6 & ipv6_address);


[section:overload1 ip::address::operator= (1 of 3 overloads)]

Assign from another address. 

  address & operator=(
      const address & other);



[endsect]



[section:overload2 ip::address::operator= (2 of 3 overloads)]

Assign from an IPv4 address. 

  address & operator=(
      const boost::asio::ip::address_v4 & ipv4_address);



[endsect]



[section:overload3 ip::address::operator= (3 of 3 overloads)]

Assign from an IPv6 address. 

  address & operator=(
      const boost::asio::ip::address_v6 & ipv6_address);



[endsect]


[endsect]


[section:operator_eq__eq_ ip::address::operator==]

[indexterm2 operator==..ip::address] Compare two addresses for equality. 

  friend bool operator==(
      const address & a1,
      const address & a2);



[endsect]


[section:to_string ip::address::to_string]

[indexterm2 to_string..ip::address] Get the address as a string in dotted decimal format. 

  std::string ``[link boost_asio.reference.ip__address.to_string.overload1 to_string]``() const;

  std::string ``[link boost_asio.reference.ip__address.to_string.overload2 to_string]``(
      boost::system::error_code & ec) const;


[section:overload1 ip::address::to_string (1 of 2 overloads)]

Get the address as a string in dotted decimal format. 

  std::string to_string() const;



[endsect]



[section:overload2 ip::address::to_string (2 of 2 overloads)]

Get the address as a string in dotted decimal format. 

  std::string to_string(
      boost::system::error_code & ec) const;



[endsect]


[endsect]


[section:to_v4 ip::address::to_v4]

[indexterm2 to_v4..ip::address] Get the address as an IP version 4 address. 

  boost::asio::ip::address_v4 to_v4() const;



[endsect]



[section:to_v6 ip::address::to_v6]

[indexterm2 to_v6..ip::address] Get the address as an IP version 6 address. 

  boost::asio::ip::address_v6 to_v6() const;



[endsect]



[endsect]

[section:ip__address_v4 ip::address_v4]

Implements IP version 4 style addresses. 

  class address_v4


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.ip__address_v4.bytes_type [*bytes_type]]]
    [The type used to represent an address as an array of bytes. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.ip__address_v4.address_v4 [*address_v4]]]
    [Default constructor. 

     Construct an address from raw bytes. 

     Construct an address from a unsigned long in host byte order. 

     Copy constructor. ]
  ]
  
  [
    [[link boost_asio.reference.ip__address_v4.any [*any]]]
    [Obtain an address object that represents any address. ]
  ]
  
  [
    [[link boost_asio.reference.ip__address_v4.broadcast [*broadcast]]]
    [Obtain an address object that represents the broadcast address. 

     Obtain an address object that represents the broadcast address that corresponds to the specified address and netmask. ]
  ]
  
  [
    [[link boost_asio.reference.ip__address_v4.from_string [*from_string]]]
    [Create an address from an IP address string in dotted decimal form. ]
  ]
  
  [
    [[link boost_asio.reference.ip__address_v4.is_class_a [*is_class_a]]]
    [Determine whether the address is a class A address. ]
  ]
  
  [
    [[link boost_asio.reference.ip__address_v4.is_class_b [*is_class_b]]]
    [Determine whether the address is a class B address. ]
  ]
  
  [
    [[link boost_asio.reference.ip__address_v4.is_class_c [*is_class_c]]]
    [Determine whether the address is a class C address. ]
  ]
  
  [
    [[link boost_asio.reference.ip__address_v4.is_multicast [*is_multicast]]]
    [Determine whether the address is a multicast address. ]
  ]
  
  [
    [[link boost_asio.reference.ip__address_v4.loopback [*loopback]]]
    [Obtain an address object that represents the loopback address. ]
  ]
  
  [
    [[link boost_asio.reference.ip__address_v4.netmask [*netmask]]]
    [Obtain the netmask that corresponds to the address, based on its address class. ]
  ]
  
  [
    [[link boost_asio.reference.ip__address_v4.operator_eq_ [*operator=]]]
    [Assign from another address. ]
  ]
  
  [
    [[link boost_asio.reference.ip__address_v4.to_bytes [*to_bytes]]]
    [Get the address in bytes. ]
  ]
  
  [
    [[link boost_asio.reference.ip__address_v4.to_string [*to_string]]]
    [Get the address as a string in dotted decimal format. ]
  ]
  
  [
    [[link boost_asio.reference.ip__address_v4.to_ulong [*to_ulong]]]
    [Get the address as an unsigned long in host byte order. ]
  ]
  
]

[heading Friends]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.ip__address_v4.operator_not__eq_ [*operator!=]]]
    [Compare two addresses for inequality. ]
  ]
  
  [
    [[link boost_asio.reference.ip__address_v4.operator_lt_ [*operator<]]]
    [Compare addresses for ordering. ]
  ]
  
  [
    [[link boost_asio.reference.ip__address_v4.operator_lt__eq_ [*operator<=]]]
    [Compare addresses for ordering. ]
  ]
  
  [
    [[link boost_asio.reference.ip__address_v4.operator_eq__eq_ [*operator==]]]
    [Compare two addresses for equality. ]
  ]
  
  [
    [[link boost_asio.reference.ip__address_v4.operator_gt_ [*operator>]]]
    [Compare addresses for ordering. ]
  ]
  
  [
    [[link boost_asio.reference.ip__address_v4.operator_gt__eq_ [*operator>=]]]
    [Compare addresses for ordering. ]
  ]
  
]

[heading Related Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.ip__address_v4.operator_lt__lt_ [*operator<<]]]
    [Output an address as a string. ]
  ]
  
]

The 
[link boost_asio.reference.ip__address_v4 ip::address_v4] class provides the ability to use and manipulate IP version 4 addresses.


[heading Thread Safety]
  
[*Distinct] [*objects:]  Safe.

[*Shared] [*objects:]  Unsafe. 


[section:address_v4 ip::address_v4::address_v4]

[indexterm2 address_v4..ip::address_v4] Default constructor. 

  ``[link boost_asio.reference.ip__address_v4.address_v4.overload1 address_v4]``();

Construct an address from raw bytes. 

  ``[link boost_asio.reference.ip__address_v4.address_v4.overload2 address_v4]``(
      const bytes_type & bytes);

Construct an address from a unsigned long in host byte order. 

  ``[link boost_asio.reference.ip__address_v4.address_v4.overload3 address_v4]``(
      unsigned long addr);

Copy constructor. 

  ``[link boost_asio.reference.ip__address_v4.address_v4.overload4 address_v4]``(
      const address_v4 & other);


[section:overload1 ip::address_v4::address_v4 (1 of 4 overloads)]

Default constructor. 

  address_v4();



[endsect]



[section:overload2 ip::address_v4::address_v4 (2 of 4 overloads)]

Construct an address from raw bytes. 

  address_v4(
      const bytes_type & bytes);



[endsect]



[section:overload3 ip::address_v4::address_v4 (3 of 4 overloads)]

Construct an address from a unsigned long in host byte order. 

  address_v4(
      unsigned long addr);



[endsect]



[section:overload4 ip::address_v4::address_v4 (4 of 4 overloads)]

Copy constructor. 

  address_v4(
      const address_v4 & other);



[endsect]


[endsect]


[section:any ip::address_v4::any]

[indexterm2 any..ip::address_v4] Obtain an address object that represents any address. 

  static address_v4 any();



[endsect]


[section:broadcast ip::address_v4::broadcast]

[indexterm2 broadcast..ip::address_v4] Obtain an address object that represents the broadcast address. 

  static address_v4 ``[link boost_asio.reference.ip__address_v4.broadcast.overload1 broadcast]``();

Obtain an address object that represents the broadcast address that corresponds to the specified address and netmask. 

  static address_v4 ``[link boost_asio.reference.ip__address_v4.broadcast.overload2 broadcast]``(
      const address_v4 & addr,
      const address_v4 & mask);


[section:overload1 ip::address_v4::broadcast (1 of 2 overloads)]

Obtain an address object that represents the broadcast address. 

  static address_v4 broadcast();



[endsect]



[section:overload2 ip::address_v4::broadcast (2 of 2 overloads)]

Obtain an address object that represents the broadcast address that corresponds to the specified address and netmask. 

  static address_v4 broadcast(
      const address_v4 & addr,
      const address_v4 & mask);



[endsect]


[endsect]


[section:bytes_type ip::address_v4::bytes_type]

[indexterm2 bytes_type..ip::address_v4] The type used to represent an address as an array of bytes. 

  typedef boost::array< unsigned char, 4 > bytes_type;




[endsect]


[section:from_string ip::address_v4::from_string]

[indexterm2 from_string..ip::address_v4] Create an address from an IP address string in dotted decimal form. 

  static address_v4 ``[link boost_asio.reference.ip__address_v4.from_string.overload1 from_string]``(
      const char * str);

  static address_v4 ``[link boost_asio.reference.ip__address_v4.from_string.overload2 from_string]``(
      const char * str,
      boost::system::error_code & ec);

  static address_v4 ``[link boost_asio.reference.ip__address_v4.from_string.overload3 from_string]``(
      const std::string & str);

  static address_v4 ``[link boost_asio.reference.ip__address_v4.from_string.overload4 from_string]``(
      const std::string & str,
      boost::system::error_code & ec);


[section:overload1 ip::address_v4::from_string (1 of 4 overloads)]

Create an address from an IP address string in dotted decimal form. 

  static address_v4 from_string(
      const char * str);



[endsect]



[section:overload2 ip::address_v4::from_string (2 of 4 overloads)]

Create an address from an IP address string in dotted decimal form. 

  static address_v4 from_string(
      const char * str,
      boost::system::error_code & ec);



[endsect]



[section:overload3 ip::address_v4::from_string (3 of 4 overloads)]

Create an address from an IP address string in dotted decimal form. 

  static address_v4 from_string(
      const std::string & str);



[endsect]



[section:overload4 ip::address_v4::from_string (4 of 4 overloads)]

Create an address from an IP address string in dotted decimal form. 

  static address_v4 from_string(
      const std::string & str,
      boost::system::error_code & ec);



[endsect]


[endsect]


[section:is_class_a ip::address_v4::is_class_a]

[indexterm2 is_class_a..ip::address_v4] Determine whether the address is a class A address. 

  bool is_class_a() const;



[endsect]



[section:is_class_b ip::address_v4::is_class_b]

[indexterm2 is_class_b..ip::address_v4] Determine whether the address is a class B address. 

  bool is_class_b() const;



[endsect]



[section:is_class_c ip::address_v4::is_class_c]

[indexterm2 is_class_c..ip::address_v4] Determine whether the address is a class C address. 

  bool is_class_c() const;



[endsect]



[section:is_multicast ip::address_v4::is_multicast]

[indexterm2 is_multicast..ip::address_v4] Determine whether the address is a multicast address. 

  bool is_multicast() const;



[endsect]



[section:loopback ip::address_v4::loopback]

[indexterm2 loopback..ip::address_v4] Obtain an address object that represents the loopback address. 

  static address_v4 loopback();



[endsect]



[section:netmask ip::address_v4::netmask]

[indexterm2 netmask..ip::address_v4] Obtain the netmask that corresponds to the address, based on its address class. 

  static address_v4 netmask(
      const address_v4 & addr);



[endsect]



[section:operator_not__eq_ ip::address_v4::operator!=]

[indexterm2 operator!=..ip::address_v4] Compare two addresses for inequality. 

  friend bool operator!=(
      const address_v4 & a1,
      const address_v4 & a2);



[endsect]



[section:operator_lt_ ip::address_v4::operator<]

[indexterm2 operator<..ip::address_v4] Compare addresses for ordering. 

  friend bool operator<(
      const address_v4 & a1,
      const address_v4 & a2);



[endsect]



[section:operator_lt__lt_ ip::address_v4::operator<<]

[indexterm2 operator<<..ip::address_v4] Output an address as a string. 

  template<
      typename Elem,
      typename Traits>
  std::basic_ostream< Elem, Traits > & operator<<(
      std::basic_ostream< Elem, Traits > & os,
      const address_v4 & addr);


Used to output a human-readable string for a specified address.


[heading Parameters]
    

[variablelist
  
[[os][The output stream to which the string will be written.]]

[[addr][The address to be written.]]

]

[heading Return Value]
      
The output stream. 



[endsect]



[section:operator_lt__eq_ ip::address_v4::operator<=]

[indexterm2 operator<=..ip::address_v4] Compare addresses for ordering. 

  friend bool operator<=(
      const address_v4 & a1,
      const address_v4 & a2);



[endsect]



[section:operator_eq_ ip::address_v4::operator=]

[indexterm2 operator=..ip::address_v4] Assign from another address. 

  address_v4 & operator=(
      const address_v4 & other);



[endsect]



[section:operator_eq__eq_ ip::address_v4::operator==]

[indexterm2 operator==..ip::address_v4] Compare two addresses for equality. 

  friend bool operator==(
      const address_v4 & a1,
      const address_v4 & a2);



[endsect]



[section:operator_gt_ ip::address_v4::operator>]

[indexterm2 operator>..ip::address_v4] Compare addresses for ordering. 

  friend bool operator>(
      const address_v4 & a1,
      const address_v4 & a2);



[endsect]



[section:operator_gt__eq_ ip::address_v4::operator>=]

[indexterm2 operator>=..ip::address_v4] Compare addresses for ordering. 

  friend bool operator>=(
      const address_v4 & a1,
      const address_v4 & a2);



[endsect]



[section:to_bytes ip::address_v4::to_bytes]

[indexterm2 to_bytes..ip::address_v4] Get the address in bytes. 

  bytes_type to_bytes() const;



[endsect]


[section:to_string ip::address_v4::to_string]

[indexterm2 to_string..ip::address_v4] Get the address as a string in dotted decimal format. 

  std::string ``[link boost_asio.reference.ip__address_v4.to_string.overload1 to_string]``() const;

  std::string ``[link boost_asio.reference.ip__address_v4.to_string.overload2 to_string]``(
      boost::system::error_code & ec) const;


[section:overload1 ip::address_v4::to_string (1 of 2 overloads)]

Get the address as a string in dotted decimal format. 

  std::string to_string() const;



[endsect]



[section:overload2 ip::address_v4::to_string (2 of 2 overloads)]

Get the address as a string in dotted decimal format. 

  std::string to_string(
      boost::system::error_code & ec) const;



[endsect]


[endsect]


[section:to_ulong ip::address_v4::to_ulong]

[indexterm2 to_ulong..ip::address_v4] Get the address as an unsigned long in host byte order. 

  unsigned long to_ulong() const;



[endsect]



[endsect]

[section:ip__address_v6 ip::address_v6]

Implements IP version 6 style addresses. 

  class address_v6


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.ip__address_v6.bytes_type [*bytes_type]]]
    [The type used to represent an address as an array of bytes. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.ip__address_v6.address_v6 [*address_v6]]]
    [Default constructor. 

     Construct an address from raw bytes and scope ID. 

     Copy constructor. ]
  ]
  
  [
    [[link boost_asio.reference.ip__address_v6.any [*any]]]
    [Obtain an address object that represents any address. ]
  ]
  
  [
    [[link boost_asio.reference.ip__address_v6.from_string [*from_string]]]
    [Create an address from an IP address string. ]
  ]
  
  [
    [[link boost_asio.reference.ip__address_v6.is_link_local [*is_link_local]]]
    [Determine whether the address is link local. ]
  ]
  
  [
    [[link boost_asio.reference.ip__address_v6.is_loopback [*is_loopback]]]
    [Determine whether the address is a loopback address. ]
  ]
  
  [
    [[link boost_asio.reference.ip__address_v6.is_multicast [*is_multicast]]]
    [Determine whether the address is a multicast address. ]
  ]
  
  [
    [[link boost_asio.reference.ip__address_v6.is_multicast_global [*is_multicast_global]]]
    [Determine whether the address is a global multicast address. ]
  ]
  
  [
    [[link boost_asio.reference.ip__address_v6.is_multicast_link_local [*is_multicast_link_local]]]
    [Determine whether the address is a link-local multicast address. ]
  ]
  
  [
    [[link boost_asio.reference.ip__address_v6.is_multicast_node_local [*is_multicast_node_local]]]
    [Determine whether the address is a node-local multicast address. ]
  ]
  
  [
    [[link boost_asio.reference.ip__address_v6.is_multicast_org_local [*is_multicast_org_local]]]
    [Determine whether the address is a org-local multicast address. ]
  ]
  
  [
    [[link boost_asio.reference.ip__address_v6.is_multicast_site_local [*is_multicast_site_local]]]
    [Determine whether the address is a site-local multicast address. ]
  ]
  
  [
    [[link boost_asio.reference.ip__address_v6.is_site_local [*is_site_local]]]
    [Determine whether the address is site local. ]
  ]
  
  [
    [[link boost_asio.reference.ip__address_v6.is_unspecified [*is_unspecified]]]
    [Determine whether the address is unspecified. ]
  ]
  
  [
    [[link boost_asio.reference.ip__address_v6.is_v4_compatible [*is_v4_compatible]]]
    [Determine whether the address is an IPv4-compatible address. ]
  ]
  
  [
    [[link boost_asio.reference.ip__address_v6.is_v4_mapped [*is_v4_mapped]]]
    [Determine whether the address is a mapped IPv4 address. ]
  ]
  
  [
    [[link boost_asio.reference.ip__address_v6.loopback [*loopback]]]
    [Obtain an address object that represents the loopback address. ]
  ]
  
  [
    [[link boost_asio.reference.ip__address_v6.operator_eq_ [*operator=]]]
    [Assign from another address. ]
  ]
  
  [
    [[link boost_asio.reference.ip__address_v6.scope_id [*scope_id]]]
    [The scope ID of the address. ]
  ]
  
  [
    [[link boost_asio.reference.ip__address_v6.to_bytes [*to_bytes]]]
    [Get the address in bytes. ]
  ]
  
  [
    [[link boost_asio.reference.ip__address_v6.to_string [*to_string]]]
    [Get the address as a string. ]
  ]
  
  [
    [[link boost_asio.reference.ip__address_v6.to_v4 [*to_v4]]]
    [Converts an IPv4-mapped or IPv4-compatible address to an IPv4 address. ]
  ]
  
  [
    [[link boost_asio.reference.ip__address_v6.v4_compatible [*v4_compatible]]]
    [Create an IPv4-compatible IPv6 address. ]
  ]
  
  [
    [[link boost_asio.reference.ip__address_v6.v4_mapped [*v4_mapped]]]
    [Create an IPv4-mapped IPv6 address. ]
  ]
  
]

[heading Friends]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.ip__address_v6.operator_not__eq_ [*operator!=]]]
    [Compare two addresses for inequality. ]
  ]
  
  [
    [[link boost_asio.reference.ip__address_v6.operator_lt_ [*operator<]]]
    [Compare addresses for ordering. ]
  ]
  
  [
    [[link boost_asio.reference.ip__address_v6.operator_lt__eq_ [*operator<=]]]
    [Compare addresses for ordering. ]
  ]
  
  [
    [[link boost_asio.reference.ip__address_v6.operator_eq__eq_ [*operator==]]]
    [Compare two addresses for equality. ]
  ]
  
  [
    [[link boost_asio.reference.ip__address_v6.operator_gt_ [*operator>]]]
    [Compare addresses for ordering. ]
  ]
  
  [
    [[link boost_asio.reference.ip__address_v6.operator_gt__eq_ [*operator>=]]]
    [Compare addresses for ordering. ]
  ]
  
]

[heading Related Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.ip__address_v6.operator_lt__lt_ [*operator<<]]]
    [Output an address as a string. ]
  ]
  
]

The 
[link boost_asio.reference.ip__address_v6 ip::address_v6] class provides the ability to use and manipulate IP version 6 addresses.


[heading Thread Safety]
  
[*Distinct] [*objects:]  Safe.

[*Shared] [*objects:]  Unsafe. 


[section:address_v6 ip::address_v6::address_v6]

[indexterm2 address_v6..ip::address_v6] Default constructor. 

  ``[link boost_asio.reference.ip__address_v6.address_v6.overload1 address_v6]``();

Construct an address from raw bytes and scope ID. 

  ``[link boost_asio.reference.ip__address_v6.address_v6.overload2 address_v6]``(
      const bytes_type & bytes,
      unsigned long scope_id = 0);

Copy constructor. 

  ``[link boost_asio.reference.ip__address_v6.address_v6.overload3 address_v6]``(
      const address_v6 & other);


[section:overload1 ip::address_v6::address_v6 (1 of 3 overloads)]

Default constructor. 

  address_v6();



[endsect]



[section:overload2 ip::address_v6::address_v6 (2 of 3 overloads)]

Construct an address from raw bytes and scope ID. 

  address_v6(
      const bytes_type & bytes,
      unsigned long scope_id = 0);



[endsect]



[section:overload3 ip::address_v6::address_v6 (3 of 3 overloads)]

Copy constructor. 

  address_v6(
      const address_v6 & other);



[endsect]


[endsect]


[section:any ip::address_v6::any]

[indexterm2 any..ip::address_v6] Obtain an address object that represents any address. 

  static address_v6 any();



[endsect]



[section:bytes_type ip::address_v6::bytes_type]

[indexterm2 bytes_type..ip::address_v6] The type used to represent an address as an array of bytes. 

  typedef boost::array< unsigned char, 16 > bytes_type;




[endsect]


[section:from_string ip::address_v6::from_string]

[indexterm2 from_string..ip::address_v6] Create an address from an IP address string. 

  static address_v6 ``[link boost_asio.reference.ip__address_v6.from_string.overload1 from_string]``(
      const char * str);

  static address_v6 ``[link boost_asio.reference.ip__address_v6.from_string.overload2 from_string]``(
      const char * str,
      boost::system::error_code & ec);

  static address_v6 ``[link boost_asio.reference.ip__address_v6.from_string.overload3 from_string]``(
      const std::string & str);

  static address_v6 ``[link boost_asio.reference.ip__address_v6.from_string.overload4 from_string]``(
      const std::string & str,
      boost::system::error_code & ec);


[section:overload1 ip::address_v6::from_string (1 of 4 overloads)]

Create an address from an IP address string. 

  static address_v6 from_string(
      const char * str);



[endsect]



[section:overload2 ip::address_v6::from_string (2 of 4 overloads)]

Create an address from an IP address string. 

  static address_v6 from_string(
      const char * str,
      boost::system::error_code & ec);



[endsect]



[section:overload3 ip::address_v6::from_string (3 of 4 overloads)]

Create an address from an IP address string. 

  static address_v6 from_string(
      const std::string & str);



[endsect]



[section:overload4 ip::address_v6::from_string (4 of 4 overloads)]

Create an address from an IP address string. 

  static address_v6 from_string(
      const std::string & str,
      boost::system::error_code & ec);



[endsect]


[endsect]


[section:is_link_local ip::address_v6::is_link_local]

[indexterm2 is_link_local..ip::address_v6] Determine whether the address is link local. 

  bool is_link_local() const;



[endsect]



[section:is_loopback ip::address_v6::is_loopback]

[indexterm2 is_loopback..ip::address_v6] Determine whether the address is a loopback address. 

  bool is_loopback() const;



[endsect]



[section:is_multicast ip::address_v6::is_multicast]

[indexterm2 is_multicast..ip::address_v6] Determine whether the address is a multicast address. 

  bool is_multicast() const;



[endsect]



[section:is_multicast_global ip::address_v6::is_multicast_global]

[indexterm2 is_multicast_global..ip::address_v6] Determine whether the address is a global multicast address. 

  bool is_multicast_global() const;



[endsect]



[section:is_multicast_link_local ip::address_v6::is_multicast_link_local]

[indexterm2 is_multicast_link_local..ip::address_v6] Determine whether the address is a link-local multicast address. 

  bool is_multicast_link_local() const;



[endsect]



[section:is_multicast_node_local ip::address_v6::is_multicast_node_local]

[indexterm2 is_multicast_node_local..ip::address_v6] Determine whether the address is a node-local multicast address. 

  bool is_multicast_node_local() const;



[endsect]



[section:is_multicast_org_local ip::address_v6::is_multicast_org_local]

[indexterm2 is_multicast_org_local..ip::address_v6] Determine whether the address is a org-local multicast address. 

  bool is_multicast_org_local() const;



[endsect]



[section:is_multicast_site_local ip::address_v6::is_multicast_site_local]

[indexterm2 is_multicast_site_local..ip::address_v6] Determine whether the address is a site-local multicast address. 

  bool is_multicast_site_local() const;



[endsect]



[section:is_site_local ip::address_v6::is_site_local]

[indexterm2 is_site_local..ip::address_v6] Determine whether the address is site local. 

  bool is_site_local() const;



[endsect]



[section:is_unspecified ip::address_v6::is_unspecified]

[indexterm2 is_unspecified..ip::address_v6] Determine whether the address is unspecified. 

  bool is_unspecified() const;



[endsect]



[section:is_v4_compatible ip::address_v6::is_v4_compatible]

[indexterm2 is_v4_compatible..ip::address_v6] Determine whether the address is an IPv4-compatible address. 

  bool is_v4_compatible() const;



[endsect]



[section:is_v4_mapped ip::address_v6::is_v4_mapped]

[indexterm2 is_v4_mapped..ip::address_v6] Determine whether the address is a mapped IPv4 address. 

  bool is_v4_mapped() const;



[endsect]



[section:loopback ip::address_v6::loopback]

[indexterm2 loopback..ip::address_v6] Obtain an address object that represents the loopback address. 

  static address_v6 loopback();



[endsect]



[section:operator_not__eq_ ip::address_v6::operator!=]

[indexterm2 operator!=..ip::address_v6] Compare two addresses for inequality. 

  friend bool operator!=(
      const address_v6 & a1,
      const address_v6 & a2);



[endsect]



[section:operator_lt_ ip::address_v6::operator<]

[indexterm2 operator<..ip::address_v6] Compare addresses for ordering. 

  friend bool operator<(
      const address_v6 & a1,
      const address_v6 & a2);



[endsect]



[section:operator_lt__lt_ ip::address_v6::operator<<]

[indexterm2 operator<<..ip::address_v6] Output an address as a string. 

  template<
      typename Elem,
      typename Traits>
  std::basic_ostream< Elem, Traits > & operator<<(
      std::basic_ostream< Elem, Traits > & os,
      const address_v6 & addr);


Used to output a human-readable string for a specified address.


[heading Parameters]
    

[variablelist
  
[[os][The output stream to which the string will be written.]]

[[addr][The address to be written.]]

]

[heading Return Value]
      
The output stream. 



[endsect]



[section:operator_lt__eq_ ip::address_v6::operator<=]

[indexterm2 operator<=..ip::address_v6] Compare addresses for ordering. 

  friend bool operator<=(
      const address_v6 & a1,
      const address_v6 & a2);



[endsect]



[section:operator_eq_ ip::address_v6::operator=]

[indexterm2 operator=..ip::address_v6] Assign from another address. 

  address_v6 & operator=(
      const address_v6 & other);



[endsect]



[section:operator_eq__eq_ ip::address_v6::operator==]

[indexterm2 operator==..ip::address_v6] Compare two addresses for equality. 

  friend bool operator==(
      const address_v6 & a1,
      const address_v6 & a2);



[endsect]



[section:operator_gt_ ip::address_v6::operator>]

[indexterm2 operator>..ip::address_v6] Compare addresses for ordering. 

  friend bool operator>(
      const address_v6 & a1,
      const address_v6 & a2);



[endsect]



[section:operator_gt__eq_ ip::address_v6::operator>=]

[indexterm2 operator>=..ip::address_v6] Compare addresses for ordering. 

  friend bool operator>=(
      const address_v6 & a1,
      const address_v6 & a2);



[endsect]


[section:scope_id ip::address_v6::scope_id]

[indexterm2 scope_id..ip::address_v6] The scope ID of the address. 

  unsigned long ``[link boost_asio.reference.ip__address_v6.scope_id.overload1 scope_id]``() const;

  void ``[link boost_asio.reference.ip__address_v6.scope_id.overload2 scope_id]``(
      unsigned long id);


[section:overload1 ip::address_v6::scope_id (1 of 2 overloads)]

The scope ID of the address. 

  unsigned long scope_id() const;


Returns the scope ID associated with the IPv6 address. 


[endsect]



[section:overload2 ip::address_v6::scope_id (2 of 2 overloads)]

The scope ID of the address. 

  void scope_id(
      unsigned long id);


Modifies the scope ID associated with the IPv6 address. 


[endsect]


[endsect]


[section:to_bytes ip::address_v6::to_bytes]

[indexterm2 to_bytes..ip::address_v6] Get the address in bytes. 

  bytes_type to_bytes() const;



[endsect]


[section:to_string ip::address_v6::to_string]

[indexterm2 to_string..ip::address_v6] Get the address as a string. 

  std::string ``[link boost_asio.reference.ip__address_v6.to_string.overload1 to_string]``() const;

  std::string ``[link boost_asio.reference.ip__address_v6.to_string.overload2 to_string]``(
      boost::system::error_code & ec) const;


[section:overload1 ip::address_v6::to_string (1 of 2 overloads)]

Get the address as a string. 

  std::string to_string() const;



[endsect]



[section:overload2 ip::address_v6::to_string (2 of 2 overloads)]

Get the address as a string. 

  std::string to_string(
      boost::system::error_code & ec) const;



[endsect]


[endsect]


[section:to_v4 ip::address_v6::to_v4]

[indexterm2 to_v4..ip::address_v6] Converts an IPv4-mapped or IPv4-compatible address to an IPv4 address. 

  address_v4 to_v4() const;



[endsect]



[section:v4_compatible ip::address_v6::v4_compatible]

[indexterm2 v4_compatible..ip::address_v6] Create an IPv4-compatible IPv6 address. 

  static address_v6 v4_compatible(
      const address_v4 & addr);



[endsect]



[section:v4_mapped ip::address_v6::v4_mapped]

[indexterm2 v4_mapped..ip::address_v6] Create an IPv4-mapped IPv6 address. 

  static address_v6 v4_mapped(
      const address_v4 & addr);



[endsect]



[endsect]

[section:ip__basic_endpoint ip::basic_endpoint]

Describes an endpoint for a version-independent IP socket. 

  template<
      typename ``[link boost_asio.reference.InternetProtocol InternetProtocol]``>
  class basic_endpoint


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.ip__basic_endpoint.data_type [*data_type]]]
    [The type of the endpoint structure. This type is dependent on the underlying implementation of the socket layer. ]
  
  ]

  [

    [[link boost_asio.reference.ip__basic_endpoint.protocol_type [*protocol_type]]]
    [The protocol type associated with the endpoint. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.ip__basic_endpoint.address [*address]]]
    [Get the IP address associated with the endpoint. 

     Set the IP address associated with the endpoint. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_endpoint.basic_endpoint [*basic_endpoint]]]
    [Default constructor. 

     Construct an endpoint using a port number, specified in the host's byte order. The IP address will be the any address (i.e. INADDR_ANY or in6addr_any). This constructor would typically be used for accepting new connections. 

     Construct an endpoint using a port number and an IP address. This constructor may be used for accepting connections on a specific interface or for making a connection to a remote endpoint. 

     Copy constructor. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_endpoint.capacity [*capacity]]]
    [Get the capacity of the endpoint in the native type. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_endpoint.data [*data]]]
    [Get the underlying endpoint in the native type. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_endpoint.operator_eq_ [*operator=]]]
    [Assign from another endpoint. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_endpoint.port [*port]]]
    [Get the port associated with the endpoint. The port number is always in the host's byte order. 

     Set the port associated with the endpoint. The port number is always in the host's byte order. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_endpoint.protocol [*protocol]]]
    [The protocol associated with the endpoint. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_endpoint.resize [*resize]]]
    [Set the underlying size of the endpoint in the native type. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_endpoint.size [*size]]]
    [Get the underlying size of the endpoint in the native type. ]
  ]
  
]

[heading Friends]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.ip__basic_endpoint.operator_not__eq_ [*operator!=]]]
    [Compare two endpoints for inequality. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_endpoint.operator_lt_ [*operator<]]]
    [Compare endpoints for ordering. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_endpoint.operator_eq__eq_ [*operator==]]]
    [Compare two endpoints for equality. ]
  ]
  
]

[heading Related Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.ip__basic_endpoint.operator_lt__lt_ [*operator<<]]]
    [Output an endpoint as a string. ]
  ]
  
]

The 
[link boost_asio.reference.ip__basic_endpoint ip::basic_endpoint] class template describes an endpoint that may be associated with a particular socket.


[heading Thread Safety]
  
[*Distinct] [*objects:]  Safe.

[*Shared] [*objects:]  Unsafe.


[section:address ip::basic_endpoint::address]

[indexterm2 address..ip::basic_endpoint] Get the IP address associated with the endpoint. 

  boost::asio::ip::address ``[link boost_asio.reference.ip__basic_endpoint.address.overload1 address]``() const;

Set the IP address associated with the endpoint. 

  void ``[link boost_asio.reference.ip__basic_endpoint.address.overload2 address]``(
      const boost::asio::ip::address & addr);


[section:overload1 ip::basic_endpoint::address (1 of 2 overloads)]

Get the IP address associated with the endpoint. 

  boost::asio::ip::address address() const;



[endsect]



[section:overload2 ip::basic_endpoint::address (2 of 2 overloads)]

Set the IP address associated with the endpoint. 

  void address(
      const boost::asio::ip::address & addr);



[endsect]


[endsect]

[section:basic_endpoint ip::basic_endpoint::basic_endpoint]

[indexterm2 basic_endpoint..ip::basic_endpoint] Default constructor. 

  ``[link boost_asio.reference.ip__basic_endpoint.basic_endpoint.overload1 basic_endpoint]``();

Construct an endpoint using a port number, specified in the host's byte order. The IP address will be the any address (i.e. INADDR_ANY or in6addr_any). This constructor would typically be used for accepting new connections. 

  ``[link boost_asio.reference.ip__basic_endpoint.basic_endpoint.overload2 basic_endpoint]``(
      const InternetProtocol & protocol,
      unsigned short port_num);

Construct an endpoint using a port number and an IP address. This constructor may be used for accepting connections on a specific interface or for making a connection to a remote endpoint. 

  ``[link boost_asio.reference.ip__basic_endpoint.basic_endpoint.overload3 basic_endpoint]``(
      const boost::asio::ip::address & addr,
      unsigned short port_num);

Copy constructor. 

  ``[link boost_asio.reference.ip__basic_endpoint.basic_endpoint.overload4 basic_endpoint]``(
      const basic_endpoint & other);


[section:overload1 ip::basic_endpoint::basic_endpoint (1 of 4 overloads)]

Default constructor. 

  basic_endpoint();



[endsect]



[section:overload2 ip::basic_endpoint::basic_endpoint (2 of 4 overloads)]

Construct an endpoint using a port number, specified in the host's byte order. The IP address will be the any address (i.e. INADDR_ANY or in6addr_any). This constructor would typically be used for accepting new connections. 

  basic_endpoint(
      const InternetProtocol & protocol,
      unsigned short port_num);



[heading Examples]
  
To initialise an IPv4 TCP endpoint for port 1234, use: 

   boost::asio::ip::tcp::endpoint ep(boost::asio::ip::tcp::v4(), 1234);




To specify an IPv6 UDP endpoint for port 9876, use: 

   boost::asio::ip::udp::endpoint ep(boost::asio::ip::udp::v6(), 9876);





[endsect]



[section:overload3 ip::basic_endpoint::basic_endpoint (3 of 4 overloads)]

Construct an endpoint using a port number and an IP address. This constructor may be used for accepting connections on a specific interface or for making a connection to a remote endpoint. 

  basic_endpoint(
      const boost::asio::ip::address & addr,
      unsigned short port_num);



[endsect]



[section:overload4 ip::basic_endpoint::basic_endpoint (4 of 4 overloads)]

Copy constructor. 

  basic_endpoint(
      const basic_endpoint & other);



[endsect]


[endsect]


[section:capacity ip::basic_endpoint::capacity]

[indexterm2 capacity..ip::basic_endpoint] Get the capacity of the endpoint in the native type. 

  std::size_t capacity() const;



[endsect]


[section:data ip::basic_endpoint::data]

[indexterm2 data..ip::basic_endpoint] Get the underlying endpoint in the native type. 

  data_type * ``[link boost_asio.reference.ip__basic_endpoint.data.overload1 data]``();

  const data_type * ``[link boost_asio.reference.ip__basic_endpoint.data.overload2 data]``() const;


[section:overload1 ip::basic_endpoint::data (1 of 2 overloads)]

Get the underlying endpoint in the native type. 

  data_type * data();



[endsect]



[section:overload2 ip::basic_endpoint::data (2 of 2 overloads)]

Get the underlying endpoint in the native type. 

  const data_type * data() const;



[endsect]


[endsect]


[section:data_type ip::basic_endpoint::data_type]

[indexterm2 data_type..ip::basic_endpoint] The type of the endpoint structure. This type is dependent on the underlying implementation of the socket layer. 

  typedef implementation_defined data_type;




[endsect]



[section:operator_not__eq_ ip::basic_endpoint::operator!=]

[indexterm2 operator!=..ip::basic_endpoint] Compare two endpoints for inequality. 

  friend bool operator!=(
      const basic_endpoint< InternetProtocol > & e1,
      const basic_endpoint< InternetProtocol > & e2);



[endsect]



[section:operator_lt_ ip::basic_endpoint::operator<]

[indexterm2 operator<..ip::basic_endpoint] Compare endpoints for ordering. 

  friend bool operator<(
      const basic_endpoint< InternetProtocol > & e1,
      const basic_endpoint< InternetProtocol > & e2);



[endsect]



[section:operator_lt__lt_ ip::basic_endpoint::operator<<]

[indexterm2 operator<<..ip::basic_endpoint] Output an endpoint as a string. 

  std::basic_ostream< Elem, Traits > & operator<<(
      std::basic_ostream< Elem, Traits > & os,
      const basic_endpoint< InternetProtocol > & endpoint);


Used to output a human-readable string for a specified endpoint.


[heading Parameters]
    

[variablelist
  
[[os][The output stream to which the string will be written.]]

[[endpoint][The endpoint to be written.]]

]

[heading Return Value]
      
The output stream. 



[endsect]



[section:operator_eq_ ip::basic_endpoint::operator=]

[indexterm2 operator=..ip::basic_endpoint] Assign from another endpoint. 

  basic_endpoint & operator=(
      const basic_endpoint & other);



[endsect]



[section:operator_eq__eq_ ip::basic_endpoint::operator==]

[indexterm2 operator==..ip::basic_endpoint] Compare two endpoints for equality. 

  friend bool operator==(
      const basic_endpoint< InternetProtocol > & e1,
      const basic_endpoint< InternetProtocol > & e2);



[endsect]


[section:port ip::basic_endpoint::port]

[indexterm2 port..ip::basic_endpoint] Get the port associated with the endpoint. The port number is always in the host's byte order. 

  unsigned short ``[link boost_asio.reference.ip__basic_endpoint.port.overload1 port]``() const;

Set the port associated with the endpoint. The port number is always in the host's byte order. 

  void ``[link boost_asio.reference.ip__basic_endpoint.port.overload2 port]``(
      unsigned short port_num);


[section:overload1 ip::basic_endpoint::port (1 of 2 overloads)]

Get the port associated with the endpoint. The port number is always in the host's byte order. 

  unsigned short port() const;



[endsect]



[section:overload2 ip::basic_endpoint::port (2 of 2 overloads)]

Set the port associated with the endpoint. The port number is always in the host's byte order. 

  void port(
      unsigned short port_num);



[endsect]


[endsect]


[section:protocol ip::basic_endpoint::protocol]

[indexterm2 protocol..ip::basic_endpoint] The protocol associated with the endpoint. 

  protocol_type protocol() const;



[endsect]



[section:protocol_type ip::basic_endpoint::protocol_type]

[indexterm2 protocol_type..ip::basic_endpoint] The protocol type associated with the endpoint. 

  typedef InternetProtocol protocol_type;




[endsect]



[section:resize ip::basic_endpoint::resize]

[indexterm2 resize..ip::basic_endpoint] Set the underlying size of the endpoint in the native type. 

  void resize(
      std::size_t size);



[endsect]



[section:size ip::basic_endpoint::size]

[indexterm2 size..ip::basic_endpoint] Get the underlying size of the endpoint in the native type. 

  std::size_t size() const;



[endsect]



[endsect]

[section:ip__basic_resolver ip::basic_resolver]

Provides endpoint resolution functionality. 

  template<
      typename ``[link boost_asio.reference.InternetProtocol InternetProtocol]``,
      typename ``[link boost_asio.reference.ResolverService ResolverService]`` = resolver_service<InternetProtocol>>
  class basic_resolver :
    public basic_io_object< ResolverService >


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.ip__basic_resolver.endpoint_type [*endpoint_type]]]
    [The endpoint type. ]
  
  ]

  [

    [[link boost_asio.reference.ip__basic_resolver.implementation_type [*implementation_type]]]
    [The underlying implementation type of I/O object. ]
  
  ]

  [

    [[link boost_asio.reference.ip__basic_resolver.iterator [*iterator]]]
    [The iterator type. ]
  
  ]

  [

    [[link boost_asio.reference.ip__basic_resolver.protocol_type [*protocol_type]]]
    [The protocol type. ]
  
  ]

  [

    [[link boost_asio.reference.ip__basic_resolver.query [*query]]]
    [The query type. ]
  
  ]

  [

    [[link boost_asio.reference.ip__basic_resolver.service_type [*service_type]]]
    [The type of the service that will be used to provide I/O operations. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.ip__basic_resolver.async_resolve [*async_resolve]]]
    [Asynchronously perform forward resolution of a query to a list of entries. 

     Asynchronously perform reverse resolution of an endpoint to a list of entries. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_resolver.basic_resolver [*basic_resolver]]]
    [Constructor. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_resolver.cancel [*cancel]]]
    [Cancel any asynchronous operations that are waiting on the resolver. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_resolver.get_io_service [*get_io_service]]]
    [Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_resolver.io_service [*io_service]]]
    [(Deprecated: use get_io_service().) Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_resolver.resolve [*resolve]]]
    [Perform forward resolution of a query to a list of entries. 

     Perform reverse resolution of an endpoint to a list of entries. ]
  ]
  
]

[heading Protected Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.ip__basic_resolver.implementation [*implementation]]]
    [The underlying implementation of the I/O object. ]
  ]

  [
    [[link boost_asio.reference.ip__basic_resolver.service [*service]]]
    [The service associated with the I/O object. ]
  ]

]

The basic_resolver class template provides the ability to resolve a query to a list of endpoints.


[heading Thread Safety]
  
[*Distinct] [*objects:]  Safe.

[*Shared] [*objects:]  Unsafe. 


[section:async_resolve ip::basic_resolver::async_resolve]

[indexterm2 async_resolve..ip::basic_resolver] Asynchronously perform forward resolution of a query to a list of entries. 

  template<
      typename ``[link boost_asio.reference.ResolveHandler ResolveHandler]``>
  void ``[link boost_asio.reference.ip__basic_resolver.async_resolve.overload1 async_resolve]``(
      const query & q,
      ResolveHandler handler);

Asynchronously perform reverse resolution of an endpoint to a list of entries. 

  template<
      typename ``[link boost_asio.reference.ResolveHandler ResolveHandler]``>
  void ``[link boost_asio.reference.ip__basic_resolver.async_resolve.overload2 async_resolve]``(
      const endpoint_type & e,
      ResolveHandler handler);


[section:overload1 ip::basic_resolver::async_resolve (1 of 2 overloads)]

Asynchronously perform forward resolution of a query to a list of entries. 

  template<
      typename ``[link boost_asio.reference.ResolveHandler ResolveHandler]``>
  void async_resolve(
      const query & q,
      ResolveHandler handler);


This function is used to asynchronously resolve a query into a list of endpoint entries.


[heading Parameters]
    

[variablelist
  
[[q][A query object that determines what endpoints will be returned.]]

[[handler][The handler to be called when the resolve operation completes. Copies will be made of the handler as required. The function signature of the handler must be: 
``
   void handler(
     const boost::system::error_code& error, // Result of operation.
     resolver::iterator iterator             // Forward-only iterator that can
                                             // be used to traverse the list
                                             // of endpoint entries.
   ); 
``
Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using boost::asio::io\_service::post().]]

]

[heading Remarks]
      
A default constructed iterator represents the end of the list.

A successful resolve operation is guaranteed to pass at least one entry to the handler. 


[endsect]



[section:overload2 ip::basic_resolver::async_resolve (2 of 2 overloads)]

Asynchronously perform reverse resolution of an endpoint to a list of entries. 

  template<
      typename ``[link boost_asio.reference.ResolveHandler ResolveHandler]``>
  void async_resolve(
      const endpoint_type & e,
      ResolveHandler handler);


This function is used to asynchronously resolve an endpoint into a list of endpoint entries.


[heading Parameters]
    

[variablelist
  
[[e][An endpoint object that determines what endpoints will be returned.]]

[[handler][The handler to be called when the resolve operation completes. Copies will be made of the handler as required. The function signature of the handler must be: 
``
   void handler(
     const boost::system::error_code& error, // Result of operation.
     resolver::iterator iterator             // Forward-only iterator that can
                                             // be used to traverse the list
                                             // of endpoint entries.
   ); 
``
Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using boost::asio::io\_service::post().]]

]

[heading Remarks]
      
A default constructed iterator represents the end of the list.

A successful resolve operation is guaranteed to pass at least one entry to the handler. 


[endsect]


[endsect]


[section:basic_resolver ip::basic_resolver::basic_resolver]

[indexterm2 basic_resolver..ip::basic_resolver] Constructor. 

  basic_resolver(
      boost::asio::io_service & io_service);


This constructor creates a basic_resolver.


[heading Parameters]
    

[variablelist
  
[[io_service][The io\_service object that the resolver will use to dispatch handlers for any asynchronous operations performed on the timer. ]]

]



[endsect]



[section:cancel ip::basic_resolver::cancel]

[indexterm2 cancel..ip::basic_resolver] Cancel any asynchronous operations that are waiting on the resolver. 

  void cancel();


This function forces the completion of any pending asynchronous operations on the host resolver. The handler for each cancelled operation will be invoked with the boost::asio::error::operation\_aborted error code. 


[endsect]



[section:endpoint_type ip::basic_resolver::endpoint_type]

[indexterm2 endpoint_type..ip::basic_resolver] The endpoint type. 

  typedef InternetProtocol::endpoint endpoint_type;




[endsect]



[section:get_io_service ip::basic_resolver::get_io_service]


['Inherited from basic_io_object.]

[indexterm2 get_io_service..ip::basic_resolver] Get the io_service associated with the object. 

  boost::asio::io_service & get_io_service();


This function may be used to obtain the io_service object that the I/O object uses to dispatch handlers for asynchronous operations.


[heading Return Value]
      
A reference to the io_service object that the I/O object will use to dispatch handlers. Ownership is not transferred to the caller. 



[endsect]



[section:implementation ip::basic_resolver::implementation]


['Inherited from basic_io_object.]

[indexterm2 implementation..ip::basic_resolver] The underlying implementation of the I/O object. 

  implementation_type implementation;



[endsect]



[section:implementation_type ip::basic_resolver::implementation_type]


['Inherited from basic_io_object.]

[indexterm2 implementation_type..ip::basic_resolver] The underlying implementation type of I/O object. 

  typedef service_type::implementation_type implementation_type;




[endsect]



[section:io_service ip::basic_resolver::io_service]


['Inherited from basic_io_object.]

[indexterm2 io_service..ip::basic_resolver] (Deprecated: use get_io_service().) Get the io_service associated with the object. 

  boost::asio::io_service & io_service();


This function may be used to obtain the io_service object that the I/O object uses to dispatch handlers for asynchronous operations.


[heading Return Value]
      
A reference to the io_service object that the I/O object will use to dispatch handlers. Ownership is not transferred to the caller. 



[endsect]



[section:iterator ip::basic_resolver::iterator]

[indexterm2 iterator..ip::basic_resolver] The iterator type. 

  typedef InternetProtocol::resolver_iterator iterator;




[endsect]



[section:protocol_type ip::basic_resolver::protocol_type]

[indexterm2 protocol_type..ip::basic_resolver] The protocol type. 

  typedef InternetProtocol protocol_type;




[endsect]



[section:query ip::basic_resolver::query]

[indexterm2 query..ip::basic_resolver] The query type. 

  typedef InternetProtocol::resolver_query query;




[endsect]


[section:resolve ip::basic_resolver::resolve]

[indexterm2 resolve..ip::basic_resolver] Perform forward resolution of a query to a list of entries. 

  iterator ``[link boost_asio.reference.ip__basic_resolver.resolve.overload1 resolve]``(
      const query & q);

  iterator ``[link boost_asio.reference.ip__basic_resolver.resolve.overload2 resolve]``(
      const query & q,
      boost::system::error_code & ec);

Perform reverse resolution of an endpoint to a list of entries. 

  iterator ``[link boost_asio.reference.ip__basic_resolver.resolve.overload3 resolve]``(
      const endpoint_type & e);

  iterator ``[link boost_asio.reference.ip__basic_resolver.resolve.overload4 resolve]``(
      const endpoint_type & e,
      boost::system::error_code & ec);


[section:overload1 ip::basic_resolver::resolve (1 of 4 overloads)]

Perform forward resolution of a query to a list of entries. 

  iterator resolve(
      const query & q);


This function is used to resolve a query into a list of endpoint entries.


[heading Parameters]
    

[variablelist
  
[[q][A query object that determines what endpoints will be returned.]]

]

[heading Return Value]
      
A forward-only iterator that can be used to traverse the list of endpoint entries.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Remarks]
      
A default constructed iterator represents the end of the list.

A successful call to this function is guaranteed to return at least one entry. 


[endsect]



[section:overload2 ip::basic_resolver::resolve (2 of 4 overloads)]

Perform forward resolution of a query to a list of entries. 

  iterator resolve(
      const query & q,
      boost::system::error_code & ec);


This function is used to resolve a query into a list of endpoint entries.


[heading Parameters]
    

[variablelist
  
[[q][A query object that determines what endpoints will be returned.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Return Value]
      
A forward-only iterator that can be used to traverse the list of endpoint entries. Returns a default constructed iterator if an error occurs.

[heading Remarks]
      
A default constructed iterator represents the end of the list.

A successful call to this function is guaranteed to return at least one entry. 


[endsect]



[section:overload3 ip::basic_resolver::resolve (3 of 4 overloads)]

Perform reverse resolution of an endpoint to a list of entries. 

  iterator resolve(
      const endpoint_type & e);


This function is used to resolve an endpoint into a list of endpoint entries.


[heading Parameters]
    

[variablelist
  
[[e][An endpoint object that determines what endpoints will be returned.]]

]

[heading Return Value]
      
A forward-only iterator that can be used to traverse the list of endpoint entries.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Remarks]
      
A default constructed iterator represents the end of the list.

A successful call to this function is guaranteed to return at least one entry. 


[endsect]



[section:overload4 ip::basic_resolver::resolve (4 of 4 overloads)]

Perform reverse resolution of an endpoint to a list of entries. 

  iterator resolve(
      const endpoint_type & e,
      boost::system::error_code & ec);


This function is used to resolve an endpoint into a list of endpoint entries.


[heading Parameters]
    

[variablelist
  
[[e][An endpoint object that determines what endpoints will be returned.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Return Value]
      
A forward-only iterator that can be used to traverse the list of endpoint entries. Returns a default constructed iterator if an error occurs.

[heading Remarks]
      
A default constructed iterator represents the end of the list.

A successful call to this function is guaranteed to return at least one entry. 


[endsect]


[endsect]


[section:service ip::basic_resolver::service]


['Inherited from basic_io_object.]

[indexterm2 service..ip::basic_resolver] The service associated with the I/O object. 

  service_type & service;



[endsect]



[section:service_type ip::basic_resolver::service_type]


['Inherited from basic_io_object.]

[indexterm2 service_type..ip::basic_resolver] The type of the service that will be used to provide I/O operations. 

  typedef ResolverService service_type;




[endsect]



[endsect]

[section:ip__basic_resolver_entry ip::basic_resolver_entry]

An entry produced by a resolver. 

  template<
      typename ``[link boost_asio.reference.InternetProtocol InternetProtocol]``>
  class basic_resolver_entry


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.ip__basic_resolver_entry.endpoint_type [*endpoint_type]]]
    [The endpoint type associated with the endpoint entry. ]
  
  ]

  [

    [[link boost_asio.reference.ip__basic_resolver_entry.protocol_type [*protocol_type]]]
    [The protocol type associated with the endpoint entry. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.ip__basic_resolver_entry.basic_resolver_entry [*basic_resolver_entry]]]
    [Default constructor. 

     Construct with specified endpoint, host name and service name. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_resolver_entry.endpoint [*endpoint]]]
    [Get the endpoint associated with the entry. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_resolver_entry.host_name [*host_name]]]
    [Get the host name associated with the entry. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_resolver_entry.operator_endpoint_type [*operator endpoint_type]]]
    [Convert to the endpoint associated with the entry. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_resolver_entry.service_name [*service_name]]]
    [Get the service name associated with the entry. ]
  ]
  
]

The 
[link boost_asio.reference.ip__basic_resolver_entry ip::basic_resolver_entry] class template describes an entry as returned by a resolver.


[heading Thread Safety]
  
[*Distinct] [*objects:]  Safe.

[*Shared] [*objects:]  Unsafe. 


[section:basic_resolver_entry ip::basic_resolver_entry::basic_resolver_entry]

[indexterm2 basic_resolver_entry..ip::basic_resolver_entry] Default constructor. 

  ``[link boost_asio.reference.ip__basic_resolver_entry.basic_resolver_entry.overload1 basic_resolver_entry]``();

Construct with specified endpoint, host name and service name. 

  ``[link boost_asio.reference.ip__basic_resolver_entry.basic_resolver_entry.overload2 basic_resolver_entry]``(
      const endpoint_type & endpoint,
      const std::string & host_name,
      const std::string & service_name);


[section:overload1 ip::basic_resolver_entry::basic_resolver_entry (1 of 2 overloads)]

Default constructor. 

  basic_resolver_entry();



[endsect]



[section:overload2 ip::basic_resolver_entry::basic_resolver_entry (2 of 2 overloads)]

Construct with specified endpoint, host name and service name. 

  basic_resolver_entry(
      const endpoint_type & endpoint,
      const std::string & host_name,
      const std::string & service_name);



[endsect]


[endsect]


[section:endpoint ip::basic_resolver_entry::endpoint]

[indexterm2 endpoint..ip::basic_resolver_entry] Get the endpoint associated with the entry. 

  endpoint_type endpoint() const;



[endsect]



[section:endpoint_type ip::basic_resolver_entry::endpoint_type]

[indexterm2 endpoint_type..ip::basic_resolver_entry] The endpoint type associated with the endpoint entry. 

  typedef InternetProtocol::endpoint endpoint_type;




[endsect]



[section:host_name ip::basic_resolver_entry::host_name]

[indexterm2 host_name..ip::basic_resolver_entry] Get the host name associated with the entry. 

  std::string host_name() const;



[endsect]



[section:operator_endpoint_type ip::basic_resolver_entry::operator endpoint_type]

[indexterm2 operator endpoint_type..ip::basic_resolver_entry] Convert to the endpoint associated with the entry. 

  operator endpoint_type() const;



[endsect]



[section:protocol_type ip::basic_resolver_entry::protocol_type]

[indexterm2 protocol_type..ip::basic_resolver_entry] The protocol type associated with the endpoint entry. 

  typedef InternetProtocol protocol_type;




[endsect]



[section:service_name ip::basic_resolver_entry::service_name]

[indexterm2 service_name..ip::basic_resolver_entry] Get the service name associated with the entry. 

  std::string service_name() const;



[endsect]



[endsect]

[section:ip__basic_resolver_iterator ip::basic_resolver_iterator]

An iterator over the entries produced by a resolver. 

  template<
      typename ``[link boost_asio.reference.InternetProtocol InternetProtocol]``>
  class basic_resolver_iterator


[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.ip__basic_resolver_iterator.basic_resolver_iterator [*basic_resolver_iterator]]]
    [Default constructor creates an end iterator. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_resolver_iterator.create [*create]]]
    [Create an iterator from an addrinfo list returned by getaddrinfo. 

     Create an iterator from an endpoint, host name and service name. ]
  ]
  
]

The 
[link boost_asio.reference.ip__basic_resolver_iterator ip::basic_resolver_iterator] class template is used to define iterators over the results returned by a resolver.

The iterator's value\_type, obtained when the iterator is dereferenced, is: 

   const basic_resolver_entry<InternetProtocol> 





[heading Thread Safety]
  
[*Distinct] [*objects:]  Safe.

[*Shared] [*objects:]  Unsafe. 



[section:basic_resolver_iterator ip::basic_resolver_iterator::basic_resolver_iterator]

[indexterm2 basic_resolver_iterator..ip::basic_resolver_iterator] Default constructor creates an end iterator. 

  basic_resolver_iterator();



[endsect]


[section:create ip::basic_resolver_iterator::create]

[indexterm2 create..ip::basic_resolver_iterator] Create an iterator from an addrinfo list returned by getaddrinfo. 

  static basic_resolver_iterator ``[link boost_asio.reference.ip__basic_resolver_iterator.create.overload1 create]``(
      boost::asio::detail::addrinfo_type * address_info,
      const std::string & host_name,
      const std::string & service_name);

Create an iterator from an endpoint, host name and service name. 

  static basic_resolver_iterator ``[link boost_asio.reference.ip__basic_resolver_iterator.create.overload2 create]``(
      const typename InternetProtocol::endpoint & endpoint,
      const std::string & host_name,
      const std::string & service_name);


[section:overload1 ip::basic_resolver_iterator::create (1 of 2 overloads)]

Create an iterator from an addrinfo list returned by getaddrinfo. 

  static basic_resolver_iterator create(
      boost::asio::detail::addrinfo_type * address_info,
      const std::string & host_name,
      const std::string & service_name);



[endsect]



[section:overload2 ip::basic_resolver_iterator::create (2 of 2 overloads)]

Create an iterator from an endpoint, host name and service name. 

  static basic_resolver_iterator create(
      const typename InternetProtocol::endpoint & endpoint,
      const std::string & host_name,
      const std::string & service_name);



[endsect]


[endsect]


[endsect]

[section:ip__basic_resolver_query ip::basic_resolver_query]

An query to be passed to a resolver. 

  template<
      typename ``[link boost_asio.reference.InternetProtocol InternetProtocol]``>
  class basic_resolver_query :
    public ip::resolver_query_base


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.ip__basic_resolver_query.protocol_type [*protocol_type]]]
    [The protocol type associated with the endpoint query. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.ip__basic_resolver_query.basic_resolver_query [*basic_resolver_query]]]
    [Construct with specified service name for any protocol. 

     Construct with specified service name for a given protocol. 

     Construct with specified host name and service name for any protocol. 

     Construct with specified host name and service name for a given protocol. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_resolver_query.hints [*hints]]]
    [Get the hints associated with the query. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_resolver_query.host_name [*host_name]]]
    [Get the host name associated with the query. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_resolver_query.service_name [*service_name]]]
    [Get the service name associated with the query. ]
  ]
  
]

[heading Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.ip__basic_resolver_query.address_configured [*address_configured]]]
    [Only return IPv4 addresses if a non-loopback IPv4 address is configured for the system. Only return IPv6 addresses if a non-loopback IPv6 address is configured for the system. ]
  ]

  [
    [[link boost_asio.reference.ip__basic_resolver_query.all_matching [*all_matching]]]
    [If used with v4_mapped, return all matching IPv6 and IPv4 addresses. ]
  ]

  [
    [[link boost_asio.reference.ip__basic_resolver_query.canonical_name [*canonical_name]]]
    [Determine the canonical name of the host specified in the query. ]
  ]

  [
    [[link boost_asio.reference.ip__basic_resolver_query.numeric_host [*numeric_host]]]
    [Host name should be treated as a numeric string defining an IPv4 or IPv6 address and no name resolution should be attempted. ]
  ]

  [
    [[link boost_asio.reference.ip__basic_resolver_query.numeric_service [*numeric_service]]]
    [Service name should be treated as a numeric string defining a port number and no name resolution should be attempted. ]
  ]

  [
    [[link boost_asio.reference.ip__basic_resolver_query.passive [*passive]]]
    [Indicate that returned endpoint is intended for use as a locally bound socket endpoint. ]
  ]

  [
    [[link boost_asio.reference.ip__basic_resolver_query.v4_mapped [*v4_mapped]]]
    [If the query protocol family is specified as IPv6, return IPv4-mapped IPv6 addresses on finding no IPv6 addresses. ]
  ]

]

The 
[link boost_asio.reference.ip__basic_resolver_query ip::basic_resolver_query] class template describes a query that can be passed to a resolver.


[heading Thread Safety]
  
[*Distinct] [*objects:]  Safe.

[*Shared] [*objects:]  Unsafe. 



[section:address_configured ip::basic_resolver_query::address_configured]


['Inherited from ip::resolver_query_base.]

[indexterm2 address_configured..ip::basic_resolver_query] Only return IPv4 addresses if a non-loopback IPv4 address is configured for the system. Only return IPv6 addresses if a non-loopback IPv6 address is configured for the system. 

  static const int address_configured = implementation_defined;



[endsect]



[section:all_matching ip::basic_resolver_query::all_matching]


['Inherited from ip::resolver_query_base.]

[indexterm2 all_matching..ip::basic_resolver_query] If used with v4_mapped, return all matching IPv6 and IPv4 addresses. 

  static const int all_matching = implementation_defined;



[endsect]


[section:basic_resolver_query ip::basic_resolver_query::basic_resolver_query]

[indexterm2 basic_resolver_query..ip::basic_resolver_query] Construct with specified service name for any protocol. 

  ``[link boost_asio.reference.ip__basic_resolver_query.basic_resolver_query.overload1 basic_resolver_query]``(
      const std::string & service_name,
      int flags = passive|address_configured);

Construct with specified service name for a given protocol. 

  ``[link boost_asio.reference.ip__basic_resolver_query.basic_resolver_query.overload2 basic_resolver_query]``(
      const protocol_type & protocol,
      const std::string & service_name,
      int flags = passive|address_configured);

Construct with specified host name and service name for any protocol. 

  ``[link boost_asio.reference.ip__basic_resolver_query.basic_resolver_query.overload3 basic_resolver_query]``(
      const std::string & host_name,
      const std::string & service_name,
      int flags = address_configured);

Construct with specified host name and service name for a given protocol. 

  ``[link boost_asio.reference.ip__basic_resolver_query.basic_resolver_query.overload4 basic_resolver_query]``(
      const protocol_type & protocol,
      const std::string & host_name,
      const std::string & service_name,
      int flags = address_configured);


[section:overload1 ip::basic_resolver_query::basic_resolver_query (1 of 4 overloads)]

Construct with specified service name for any protocol. 

  basic_resolver_query(
      const std::string & service_name,
      int flags = passive|address_configured);



[endsect]



[section:overload2 ip::basic_resolver_query::basic_resolver_query (2 of 4 overloads)]

Construct with specified service name for a given protocol. 

  basic_resolver_query(
      const protocol_type & protocol,
      const std::string & service_name,
      int flags = passive|address_configured);



[endsect]



[section:overload3 ip::basic_resolver_query::basic_resolver_query (3 of 4 overloads)]

Construct with specified host name and service name for any protocol. 

  basic_resolver_query(
      const std::string & host_name,
      const std::string & service_name,
      int flags = address_configured);



[endsect]



[section:overload4 ip::basic_resolver_query::basic_resolver_query (4 of 4 overloads)]

Construct with specified host name and service name for a given protocol. 

  basic_resolver_query(
      const protocol_type & protocol,
      const std::string & host_name,
      const std::string & service_name,
      int flags = address_configured);



[endsect]


[endsect]


[section:canonical_name ip::basic_resolver_query::canonical_name]


['Inherited from ip::resolver_query_base.]

[indexterm2 canonical_name..ip::basic_resolver_query] Determine the canonical name of the host specified in the query. 

  static const int canonical_name = implementation_defined;



[endsect]



[section:hints ip::basic_resolver_query::hints]

[indexterm2 hints..ip::basic_resolver_query] Get the hints associated with the query. 

  const boost::asio::detail::addrinfo_type & hints() const;



[endsect]



[section:host_name ip::basic_resolver_query::host_name]

[indexterm2 host_name..ip::basic_resolver_query] Get the host name associated with the query. 

  std::string host_name() const;



[endsect]



[section:numeric_host ip::basic_resolver_query::numeric_host]


['Inherited from ip::resolver_query_base.]

[indexterm2 numeric_host..ip::basic_resolver_query] Host name should be treated as a numeric string defining an IPv4 or IPv6 address and no name resolution should be attempted. 

  static const int numeric_host = implementation_defined;



[endsect]



[section:numeric_service ip::basic_resolver_query::numeric_service]


['Inherited from ip::resolver_query_base.]

[indexterm2 numeric_service..ip::basic_resolver_query] Service name should be treated as a numeric string defining a port number and no name resolution should be attempted. 

  static const int numeric_service = implementation_defined;



[endsect]



[section:passive ip::basic_resolver_query::passive]


['Inherited from ip::resolver_query_base.]

[indexterm2 passive..ip::basic_resolver_query] Indicate that returned endpoint is intended for use as a locally bound socket endpoint. 

  static const int passive = implementation_defined;



[endsect]



[section:protocol_type ip::basic_resolver_query::protocol_type]

[indexterm2 protocol_type..ip::basic_resolver_query] The protocol type associated with the endpoint query. 

  typedef InternetProtocol protocol_type;




[endsect]



[section:service_name ip::basic_resolver_query::service_name]

[indexterm2 service_name..ip::basic_resolver_query] Get the service name associated with the query. 

  std::string service_name() const;



[endsect]



[section:v4_mapped ip::basic_resolver_query::v4_mapped]


['Inherited from ip::resolver_query_base.]

[indexterm2 v4_mapped..ip::basic_resolver_query] If the query protocol family is specified as IPv6, return IPv4-mapped IPv6 addresses on finding no IPv6 addresses. 

  static const int v4_mapped = implementation_defined;



[endsect]



[endsect]

[section:ip__host_name ip::host_name]

[indexterm1 ip::host_name] Get the current host name. 
    
  std::string ``[link boost_asio.reference.ip__host_name.overload1 host_name]``();

  std::string ``[link boost_asio.reference.ip__host_name.overload2 host_name]``(
      boost::system::error_code & ec);


[section:overload1 ip::host_name (1 of 2 overloads)]

Get the current host name. 

  std::string host_name();



[endsect]



[section:overload2 ip::host_name (2 of 2 overloads)]

Get the current host name. 

  std::string host_name(
      boost::system::error_code & ec);



[endsect]


[endsect]

[section:ip__icmp ip::icmp]

Encapsulates the flags needed for ICMP. 

  class icmp


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.ip__icmp.endpoint [*endpoint]]]
    [The type of a ICMP endpoint. ]
  
  ]

  [

    [[link boost_asio.reference.ip__icmp.resolver [*resolver]]]
    [The ICMP resolver type. ]
  
  ]

  [

    [[link boost_asio.reference.ip__icmp.resolver_iterator [*resolver_iterator]]]
    [The type of a resolver iterator. ]
  
  ]

  [

    [[link boost_asio.reference.ip__icmp.resolver_query [*resolver_query]]]
    [The type of a resolver query. ]
  
  ]

  [

    [[link boost_asio.reference.ip__icmp.socket [*socket]]]
    [The ICMP socket type. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.ip__icmp.family [*family]]]
    [Obtain an identifier for the protocol family. ]
  ]
  
  [
    [[link boost_asio.reference.ip__icmp.protocol [*protocol]]]
    [Obtain an identifier for the protocol. ]
  ]
  
  [
    [[link boost_asio.reference.ip__icmp.type [*type]]]
    [Obtain an identifier for the type of the protocol. ]
  ]
  
  [
    [[link boost_asio.reference.ip__icmp.v4 [*v4]]]
    [Construct to represent the IPv4 ICMP protocol. ]
  ]
  
  [
    [[link boost_asio.reference.ip__icmp.v6 [*v6]]]
    [Construct to represent the IPv6 ICMP protocol. ]
  ]
  
]

[heading Friends]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.ip__icmp.operator_not__eq_ [*operator!=]]]
    [Compare two protocols for inequality. ]
  ]
  
  [
    [[link boost_asio.reference.ip__icmp.operator_eq__eq_ [*operator==]]]
    [Compare two protocols for equality. ]
  ]
  
]

The 
[link boost_asio.reference.ip__icmp ip::icmp] class contains flags necessary for ICMP sockets.


[heading Thread Safety]
  
[*Distinct] [*objects:]  Safe.

[*Shared] [*objects:]  Safe.



[section:endpoint ip::icmp::endpoint]

[indexterm2 endpoint..ip::icmp] The type of a ICMP endpoint. 

  typedef basic_endpoint< icmp > endpoint;


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.ip__basic_endpoint.data_type [*data_type]]]
    [The type of the endpoint structure. This type is dependent on the underlying implementation of the socket layer. ]
  
  ]

  [

    [[link boost_asio.reference.ip__basic_endpoint.protocol_type [*protocol_type]]]
    [The protocol type associated with the endpoint. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.ip__basic_endpoint.address [*address]]]
    [Get the IP address associated with the endpoint. 

     Set the IP address associated with the endpoint. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_endpoint.basic_endpoint [*basic_endpoint]]]
    [Default constructor. 

     Construct an endpoint using a port number, specified in the host's byte order. The IP address will be the any address (i.e. INADDR_ANY or in6addr_any). This constructor would typically be used for accepting new connections. 

     Construct an endpoint using a port number and an IP address. This constructor may be used for accepting connections on a specific interface or for making a connection to a remote endpoint. 

     Copy constructor. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_endpoint.capacity [*capacity]]]
    [Get the capacity of the endpoint in the native type. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_endpoint.data [*data]]]
    [Get the underlying endpoint in the native type. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_endpoint.operator_eq_ [*operator=]]]
    [Assign from another endpoint. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_endpoint.port [*port]]]
    [Get the port associated with the endpoint. The port number is always in the host's byte order. 

     Set the port associated with the endpoint. The port number is always in the host's byte order. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_endpoint.protocol [*protocol]]]
    [The protocol associated with the endpoint. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_endpoint.resize [*resize]]]
    [Set the underlying size of the endpoint in the native type. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_endpoint.size [*size]]]
    [Get the underlying size of the endpoint in the native type. ]
  ]
  
]

[heading Friends]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.ip__basic_endpoint.operator_not__eq_ [*operator!=]]]
    [Compare two endpoints for inequality. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_endpoint.operator_lt_ [*operator<]]]
    [Compare endpoints for ordering. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_endpoint.operator_eq__eq_ [*operator==]]]
    [Compare two endpoints for equality. ]
  ]
  
]

[heading Related Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.ip__basic_endpoint.operator_lt__lt_ [*operator<<]]]
    [Output an endpoint as a string. ]
  ]
  
]

The 
[link boost_asio.reference.ip__basic_endpoint ip::basic_endpoint] class template describes an endpoint that may be associated with a particular socket.


[heading Thread Safety]
  
[*Distinct] [*objects:]  Safe.

[*Shared] [*objects:]  Unsafe.




[endsect]



[section:family ip::icmp::family]

[indexterm2 family..ip::icmp] Obtain an identifier for the protocol family. 

  int family() const;



[endsect]



[section:operator_not__eq_ ip::icmp::operator!=]

[indexterm2 operator!=..ip::icmp] Compare two protocols for inequality. 

  friend bool operator!=(
      const icmp & p1,
      const icmp & p2);



[endsect]



[section:operator_eq__eq_ ip::icmp::operator==]

[indexterm2 operator==..ip::icmp] Compare two protocols for equality. 

  friend bool operator==(
      const icmp & p1,
      const icmp & p2);



[endsect]



[section:protocol ip::icmp::protocol]

[indexterm2 protocol..ip::icmp] Obtain an identifier for the protocol. 

  int protocol() const;



[endsect]



[section:resolver ip::icmp::resolver]

[indexterm2 resolver..ip::icmp] The ICMP resolver type. 

  typedef basic_resolver< icmp > resolver;


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.ip__basic_resolver.endpoint_type [*endpoint_type]]]
    [The endpoint type. ]
  
  ]

  [

    [[link boost_asio.reference.ip__basic_resolver.implementation_type [*implementation_type]]]
    [The underlying implementation type of I/O object. ]
  
  ]

  [

    [[link boost_asio.reference.ip__basic_resolver.iterator [*iterator]]]
    [The iterator type. ]
  
  ]

  [

    [[link boost_asio.reference.ip__basic_resolver.protocol_type [*protocol_type]]]
    [The protocol type. ]
  
  ]

  [

    [[link boost_asio.reference.ip__basic_resolver.query [*query]]]
    [The query type. ]
  
  ]

  [

    [[link boost_asio.reference.ip__basic_resolver.service_type [*service_type]]]
    [The type of the service that will be used to provide I/O operations. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.ip__basic_resolver.async_resolve [*async_resolve]]]
    [Asynchronously perform forward resolution of a query to a list of entries. 

     Asynchronously perform reverse resolution of an endpoint to a list of entries. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_resolver.basic_resolver [*basic_resolver]]]
    [Constructor. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_resolver.cancel [*cancel]]]
    [Cancel any asynchronous operations that are waiting on the resolver. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_resolver.get_io_service [*get_io_service]]]
    [Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_resolver.io_service [*io_service]]]
    [(Deprecated: use get_io_service().) Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_resolver.resolve [*resolve]]]
    [Perform forward resolution of a query to a list of entries. 

     Perform reverse resolution of an endpoint to a list of entries. ]
  ]
  
]

[heading Protected Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.ip__basic_resolver.implementation [*implementation]]]
    [The underlying implementation of the I/O object. ]
  ]

  [
    [[link boost_asio.reference.ip__basic_resolver.service [*service]]]
    [The service associated with the I/O object. ]
  ]

]

The basic_resolver class template provides the ability to resolve a query to a list of endpoints.


[heading Thread Safety]
  
[*Distinct] [*objects:]  Safe.

[*Shared] [*objects:]  Unsafe. 




[endsect]



[section:resolver_iterator ip::icmp::resolver_iterator]

[indexterm2 resolver_iterator..ip::icmp] The type of a resolver iterator. 

  typedef basic_resolver_iterator< icmp > resolver_iterator;


[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.ip__basic_resolver_iterator.basic_resolver_iterator [*basic_resolver_iterator]]]
    [Default constructor creates an end iterator. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_resolver_iterator.create [*create]]]
    [Create an iterator from an addrinfo list returned by getaddrinfo. 

     Create an iterator from an endpoint, host name and service name. ]
  ]
  
]

The 
[link boost_asio.reference.ip__basic_resolver_iterator ip::basic_resolver_iterator] class template is used to define iterators over the results returned by a resolver.

The iterator's value\_type, obtained when the iterator is dereferenced, is: 

   const basic_resolver_entry<InternetProtocol> 





[heading Thread Safety]
  
[*Distinct] [*objects:]  Safe.

[*Shared] [*objects:]  Unsafe. 




[endsect]



[section:resolver_query ip::icmp::resolver_query]

[indexterm2 resolver_query..ip::icmp] The type of a resolver query. 

  typedef basic_resolver_query< icmp > resolver_query;


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.ip__basic_resolver_query.protocol_type [*protocol_type]]]
    [The protocol type associated with the endpoint query. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.ip__basic_resolver_query.basic_resolver_query [*basic_resolver_query]]]
    [Construct with specified service name for any protocol. 

     Construct with specified service name for a given protocol. 

     Construct with specified host name and service name for any protocol. 

     Construct with specified host name and service name for a given protocol. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_resolver_query.hints [*hints]]]
    [Get the hints associated with the query. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_resolver_query.host_name [*host_name]]]
    [Get the host name associated with the query. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_resolver_query.service_name [*service_name]]]
    [Get the service name associated with the query. ]
  ]
  
]

[heading Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.ip__basic_resolver_query.address_configured [*address_configured]]]
    [Only return IPv4 addresses if a non-loopback IPv4 address is configured for the system. Only return IPv6 addresses if a non-loopback IPv6 address is configured for the system. ]
  ]

  [
    [[link boost_asio.reference.ip__basic_resolver_query.all_matching [*all_matching]]]
    [If used with v4_mapped, return all matching IPv6 and IPv4 addresses. ]
  ]

  [
    [[link boost_asio.reference.ip__basic_resolver_query.canonical_name [*canonical_name]]]
    [Determine the canonical name of the host specified in the query. ]
  ]

  [
    [[link boost_asio.reference.ip__basic_resolver_query.numeric_host [*numeric_host]]]
    [Host name should be treated as a numeric string defining an IPv4 or IPv6 address and no name resolution should be attempted. ]
  ]

  [
    [[link boost_asio.reference.ip__basic_resolver_query.numeric_service [*numeric_service]]]
    [Service name should be treated as a numeric string defining a port number and no name resolution should be attempted. ]
  ]

  [
    [[link boost_asio.reference.ip__basic_resolver_query.passive [*passive]]]
    [Indicate that returned endpoint is intended for use as a locally bound socket endpoint. ]
  ]

  [
    [[link boost_asio.reference.ip__basic_resolver_query.v4_mapped [*v4_mapped]]]
    [If the query protocol family is specified as IPv6, return IPv4-mapped IPv6 addresses on finding no IPv6 addresses. ]
  ]

]

The 
[link boost_asio.reference.ip__basic_resolver_query ip::basic_resolver_query] class template describes a query that can be passed to a resolver.


[heading Thread Safety]
  
[*Distinct] [*objects:]  Safe.

[*Shared] [*objects:]  Unsafe. 




[endsect]



[section:socket ip::icmp::socket]

[indexterm2 socket..ip::icmp] The ICMP socket type. 

  typedef basic_raw_socket< icmp > socket;


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.basic_raw_socket.broadcast [*broadcast]]]
    [Socket option to permit sending of broadcast messages. ]
  
  ]

  [

    [[link boost_asio.reference.basic_raw_socket.bytes_readable [*bytes_readable]]]
    [IO control command to get the amount of data that can be read without blocking. ]
  
  ]

  [

    [[link boost_asio.reference.basic_raw_socket.debug [*debug]]]
    [Socket option to enable socket-level debugging. ]
  
  ]

  [

    [[link boost_asio.reference.basic_raw_socket.do_not_route [*do_not_route]]]
    [Socket option to prevent routing, use local interfaces only. ]
  
  ]

  [

    [[link boost_asio.reference.basic_raw_socket.enable_connection_aborted [*enable_connection_aborted]]]
    [Socket option to report aborted connections on accept. ]
  
  ]

  [

    [[link boost_asio.reference.basic_raw_socket.endpoint_type [*endpoint_type]]]
    [The endpoint type. ]
  
  ]

  [

    [[link boost_asio.reference.basic_raw_socket.implementation_type [*implementation_type]]]
    [The underlying implementation type of I/O object. ]
  
  ]

  [

    [[link boost_asio.reference.basic_raw_socket.keep_alive [*keep_alive]]]
    [Socket option to send keep-alives. ]
  
  ]

  [

    [[link boost_asio.reference.basic_raw_socket.linger [*linger]]]
    [Socket option to specify whether the socket lingers on close if unsent data is present. ]
  
  ]

  [

    [[link boost_asio.reference.basic_raw_socket.lowest_layer_type [*lowest_layer_type]]]
    [A basic_socket is always the lowest layer. ]
  
  ]

  [

    [[link boost_asio.reference.basic_raw_socket.message_flags [*message_flags]]]
    [Bitmask type for flags that can be passed to send and receive operations. ]
  
  ]

  [

    [[link boost_asio.reference.basic_raw_socket.native_type [*native_type]]]
    [The native representation of a socket. ]
  
  ]

  [

    [[link boost_asio.reference.basic_raw_socket.non_blocking_io [*non_blocking_io]]]
    [IO control command to set the blocking mode of the socket. ]
  
  ]

  [

    [[link boost_asio.reference.basic_raw_socket.protocol_type [*protocol_type]]]
    [The protocol type. ]
  
  ]

  [

    [[link boost_asio.reference.basic_raw_socket.receive_buffer_size [*receive_buffer_size]]]
    [Socket option for the receive buffer size of a socket. ]
  
  ]

  [

    [[link boost_asio.reference.basic_raw_socket.receive_low_watermark [*receive_low_watermark]]]
    [Socket option for the receive low watermark. ]
  
  ]

  [

    [[link boost_asio.reference.basic_raw_socket.reuse_address [*reuse_address]]]
    [Socket option to allow the socket to be bound to an address that is already in use. ]
  
  ]

  [

    [[link boost_asio.reference.basic_raw_socket.send_buffer_size [*send_buffer_size]]]
    [Socket option for the send buffer size of a socket. ]
  
  ]

  [

    [[link boost_asio.reference.basic_raw_socket.send_low_watermark [*send_low_watermark]]]
    [Socket option for the send low watermark. ]
  
  ]

  [

    [[link boost_asio.reference.basic_raw_socket.service_type [*service_type]]]
    [The type of the service that will be used to provide I/O operations. ]
  
  ]

  [

    [[link boost_asio.reference.basic_raw_socket.shutdown_type [*shutdown_type]]]
    [Different ways a socket may be shutdown. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_raw_socket.assign [*assign]]]
    [Assign an existing native socket to the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_raw_socket.async_connect [*async_connect]]]
    [Start an asynchronous connect. ]
  ]
  
  [
    [[link boost_asio.reference.basic_raw_socket.async_receive [*async_receive]]]
    [Start an asynchronous receive on a connected socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_raw_socket.async_receive_from [*async_receive_from]]]
    [Start an asynchronous receive. ]
  ]
  
  [
    [[link boost_asio.reference.basic_raw_socket.async_send [*async_send]]]
    [Start an asynchronous send on a connected socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_raw_socket.async_send_to [*async_send_to]]]
    [Start an asynchronous send. ]
  ]
  
  [
    [[link boost_asio.reference.basic_raw_socket.at_mark [*at_mark]]]
    [Determine whether the socket is at the out-of-band data mark. ]
  ]
  
  [
    [[link boost_asio.reference.basic_raw_socket.available [*available]]]
    [Determine the number of bytes available for reading. ]
  ]
  
  [
    [[link boost_asio.reference.basic_raw_socket.basic_raw_socket [*basic_raw_socket]]]
    [Construct a basic_raw_socket without opening it. 

     Construct and open a basic_raw_socket. 

     Construct a basic_raw_socket, opening it and binding it to the given local endpoint. 

     Construct a basic_raw_socket on an existing native socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_raw_socket.bind [*bind]]]
    [Bind the socket to the given local endpoint. ]
  ]
  
  [
    [[link boost_asio.reference.basic_raw_socket.cancel [*cancel]]]
    [Cancel all asynchronous operations associated with the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_raw_socket.close [*close]]]
    [Close the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_raw_socket.connect [*connect]]]
    [Connect the socket to the specified endpoint. ]
  ]
  
  [
    [[link boost_asio.reference.basic_raw_socket.get_io_service [*get_io_service]]]
    [Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.basic_raw_socket.get_option [*get_option]]]
    [Get an option from the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_raw_socket.io_control [*io_control]]]
    [Perform an IO control command on the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_raw_socket.io_service [*io_service]]]
    [(Deprecated: use get_io_service().) Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.basic_raw_socket.is_open [*is_open]]]
    [Determine whether the socket is open. ]
  ]
  
  [
    [[link boost_asio.reference.basic_raw_socket.local_endpoint [*local_endpoint]]]
    [Get the local endpoint of the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_raw_socket.lowest_layer [*lowest_layer]]]
    [Get a reference to the lowest layer. 

     Get a const reference to the lowest layer. ]
  ]
  
  [
    [[link boost_asio.reference.basic_raw_socket.native [*native]]]
    [Get the native socket representation. ]
  ]
  
  [
    [[link boost_asio.reference.basic_raw_socket.open [*open]]]
    [Open the socket using the specified protocol. ]
  ]
  
  [
    [[link boost_asio.reference.basic_raw_socket.receive [*receive]]]
    [Receive some data on a connected socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_raw_socket.receive_from [*receive_from]]]
    [Receive raw data with the endpoint of the sender. ]
  ]
  
  [
    [[link boost_asio.reference.basic_raw_socket.remote_endpoint [*remote_endpoint]]]
    [Get the remote endpoint of the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_raw_socket.send [*send]]]
    [Send some data on a connected socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_raw_socket.send_to [*send_to]]]
    [Send raw data to the specified endpoint. ]
  ]
  
  [
    [[link boost_asio.reference.basic_raw_socket.set_option [*set_option]]]
    [Set an option on the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_raw_socket.shutdown [*shutdown]]]
    [Disable sends or receives on the socket. ]
  ]
  
]

[heading Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_raw_socket.max_connections [*max_connections]]]
    [The maximum length of the queue of pending incoming connections. ]
  ]

  [
    [[link boost_asio.reference.basic_raw_socket.message_do_not_route [*message_do_not_route]]]
    [Specify that the data should not be subject to routing. ]
  ]

  [
    [[link boost_asio.reference.basic_raw_socket.message_out_of_band [*message_out_of_band]]]
    [Process out-of-band data. ]
  ]

  [
    [[link boost_asio.reference.basic_raw_socket.message_peek [*message_peek]]]
    [Peek at incoming data without removing it from the input queue. ]
  ]

]

[heading Protected Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_raw_socket.implementation [*implementation]]]
    [The underlying implementation of the I/O object. ]
  ]

  [
    [[link boost_asio.reference.basic_raw_socket.service [*service]]]
    [The service associated with the I/O object. ]
  ]

]

The basic_raw_socket class template provides asynchronous and blocking raw-oriented socket functionality.


[heading Thread Safety]
  
[*Distinct] [*objects:]  Safe.

[*Shared] [*objects:]  Unsafe. 




[endsect]



[section:type ip::icmp::type]

[indexterm2 type..ip::icmp] Obtain an identifier for the type of the protocol. 

  int type() const;



[endsect]



[section:v4 ip::icmp::v4]

[indexterm2 v4..ip::icmp] Construct to represent the IPv4 ICMP protocol. 

  static icmp v4();



[endsect]



[section:v6 ip::icmp::v6]

[indexterm2 v6..ip::icmp] Construct to represent the IPv6 ICMP protocol. 

  static icmp v6();



[endsect]



[endsect]


[section:ip__multicast__enable_loopback ip::multicast::enable_loopback]

[indexterm1 ip::multicast::enable_loopback] Socket option determining whether outgoing multicast packets will be received on the same socket if it is a member of the multicast group. 

  typedef implementation_defined enable_loopback;



Implements the IPPROTO\_IP/IP\_MULTICAST\_LOOP socket option.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::udp::socket socket(io_service); 
   ...
   boost::asio::ip::multicast::enable_loopback option(true);
   socket.set_option(option);




Getting the current option value: 

   boost::asio::ip::udp::socket socket(io_service); 
   ...
   boost::asio::ip::multicast::enable_loopback option;
   socket.get_option(option);
   bool is_set = option.value();






[endsect]



[section:ip__multicast__hops ip::multicast::hops]

[indexterm1 ip::multicast::hops] Socket option for time-to-live associated with outgoing multicast packets. 

  typedef implementation_defined hops;



Implements the IPPROTO\_IP/IP\_MULTICAST\_TTL socket option.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::udp::socket socket(io_service); 
   ...
   boost::asio::ip::multicast::hops option(4);
   socket.set_option(option);




Getting the current option value: 

   boost::asio::ip::udp::socket socket(io_service); 
   ...
   boost::asio::ip::multicast::hops option;
   socket.get_option(option);
   int ttl = option.value();






[endsect]



[section:ip__multicast__join_group ip::multicast::join_group]

[indexterm1 ip::multicast::join_group] Socket option to join a multicast group on a specified interface. 

  typedef implementation_defined join_group;



Implements the IPPROTO\_IP/IP\_ADD\_MEMBERSHIP socket option.


[heading Examples]
  
Setting the option to join a multicast group: 

   boost::asio::ip::udp::socket socket(io_service); 
   ...
   boost::asio::ip::address multicast_address =
     boost::asio::ip::address::from_string("225.0.0.1");
   boost::asio::ip::multicast::join_group option(multicast_address);
   socket.set_option(option);






[endsect]



[section:ip__multicast__leave_group ip::multicast::leave_group]

[indexterm1 ip::multicast::leave_group] Socket option to leave a multicast group on a specified interface. 

  typedef implementation_defined leave_group;



Implements the IPPROTO\_IP/IP\_DROP\_MEMBERSHIP socket option.


[heading Examples]
  
Setting the option to leave a multicast group: 

   boost::asio::ip::udp::socket socket(io_service); 
   ...
   boost::asio::ip::address multicast_address =
     boost::asio::ip::address::from_string("225.0.0.1");
   boost::asio::ip::multicast::leave_group option(multicast_address);
   socket.set_option(option);






[endsect]



[section:ip__multicast__outbound_interface ip::multicast::outbound_interface]

[indexterm1 ip::multicast::outbound_interface] Socket option for local interface to use for outgoing multicast packets. 

  typedef implementation_defined outbound_interface;



Implements the IPPROTO\_IP/IP\_MULTICAST\_IF socket option.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::udp::socket socket(io_service); 
   ...
   boost::asio::ip::address_v4 local_interface =
     boost::asio::ip::address_v4::from_string("1.2.3.4");
   boost::asio::ip::multicast::outbound_interface option(local_interface);
   socket.set_option(option);






[endsect]


[section:ip__resolver_query_base ip::resolver_query_base]

The resolver_query_base class is used as a base for the basic_resolver_query class templates to provide a common place to define the flag constants. 

  class resolver_query_base


[heading Protected Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.ip__resolver_query_base._resolver_query_base [*~resolver_query_base]]]
    [Protected destructor to prevent deletion through this type. ]
  ]
  
]

[heading Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.ip__resolver_query_base.address_configured [*address_configured]]]
    [Only return IPv4 addresses if a non-loopback IPv4 address is configured for the system. Only return IPv6 addresses if a non-loopback IPv6 address is configured for the system. ]
  ]

  [
    [[link boost_asio.reference.ip__resolver_query_base.all_matching [*all_matching]]]
    [If used with v4_mapped, return all matching IPv6 and IPv4 addresses. ]
  ]

  [
    [[link boost_asio.reference.ip__resolver_query_base.canonical_name [*canonical_name]]]
    [Determine the canonical name of the host specified in the query. ]
  ]

  [
    [[link boost_asio.reference.ip__resolver_query_base.numeric_host [*numeric_host]]]
    [Host name should be treated as a numeric string defining an IPv4 or IPv6 address and no name resolution should be attempted. ]
  ]

  [
    [[link boost_asio.reference.ip__resolver_query_base.numeric_service [*numeric_service]]]
    [Service name should be treated as a numeric string defining a port number and no name resolution should be attempted. ]
  ]

  [
    [[link boost_asio.reference.ip__resolver_query_base.passive [*passive]]]
    [Indicate that returned endpoint is intended for use as a locally bound socket endpoint. ]
  ]

  [
    [[link boost_asio.reference.ip__resolver_query_base.v4_mapped [*v4_mapped]]]
    [If the query protocol family is specified as IPv6, return IPv4-mapped IPv6 addresses on finding no IPv6 addresses. ]
  ]

]


[section:address_configured ip::resolver_query_base::address_configured]

[indexterm2 address_configured..ip::resolver_query_base] Only return IPv4 addresses if a non-loopback IPv4 address is configured for the system. Only return IPv6 addresses if a non-loopback IPv6 address is configured for the system. 

  static const int address_configured = implementation_defined;



[endsect]



[section:all_matching ip::resolver_query_base::all_matching]

[indexterm2 all_matching..ip::resolver_query_base] If used with v4_mapped, return all matching IPv6 and IPv4 addresses. 

  static const int all_matching = implementation_defined;



[endsect]



[section:canonical_name ip::resolver_query_base::canonical_name]

[indexterm2 canonical_name..ip::resolver_query_base] Determine the canonical name of the host specified in the query. 

  static const int canonical_name = implementation_defined;



[endsect]



[section:numeric_host ip::resolver_query_base::numeric_host]

[indexterm2 numeric_host..ip::resolver_query_base] Host name should be treated as a numeric string defining an IPv4 or IPv6 address and no name resolution should be attempted. 

  static const int numeric_host = implementation_defined;



[endsect]



[section:numeric_service ip::resolver_query_base::numeric_service]

[indexterm2 numeric_service..ip::resolver_query_base] Service name should be treated as a numeric string defining a port number and no name resolution should be attempted. 

  static const int numeric_service = implementation_defined;



[endsect]



[section:passive ip::resolver_query_base::passive]

[indexterm2 passive..ip::resolver_query_base] Indicate that returned endpoint is intended for use as a locally bound socket endpoint. 

  static const int passive = implementation_defined;



[endsect]



[section:v4_mapped ip::resolver_query_base::v4_mapped]

[indexterm2 v4_mapped..ip::resolver_query_base] If the query protocol family is specified as IPv6, return IPv4-mapped IPv6 addresses on finding no IPv6 addresses. 

  static const int v4_mapped = implementation_defined;



[endsect]



[section:_resolver_query_base ip::resolver_query_base::~resolver_query_base]

[indexterm2 ~resolver_query_base..ip::resolver_query_base] Protected destructor to prevent deletion through this type. 

  ~resolver_query_base();



[endsect]



[endsect]

[section:ip__resolver_service ip::resolver_service]

Default service implementation for a resolver. 

  template<
      typename ``[link boost_asio.reference.InternetProtocol InternetProtocol]``>
  class resolver_service :
    public io_service::service


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.ip__resolver_service.endpoint_type [*endpoint_type]]]
    [The endpoint type. ]
  
  ]

  [

    [[link boost_asio.reference.ip__resolver_service.implementation_type [*implementation_type]]]
    [The type of a resolver implementation. ]
  
  ]

  [

    [[link boost_asio.reference.ip__resolver_service.iterator_type [*iterator_type]]]
    [The iterator type. ]
  
  ]

  [

    [[link boost_asio.reference.ip__resolver_service.protocol_type [*protocol_type]]]
    [The protocol type. ]
  
  ]

  [

    [[link boost_asio.reference.ip__resolver_service.query_type [*query_type]]]
    [The query type. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.ip__resolver_service.async_resolve [*async_resolve]]]
    [Asynchronously resolve a query to a list of entries. 

     Asynchronously resolve an endpoint to a list of entries. ]
  ]
  
  [
    [[link boost_asio.reference.ip__resolver_service.cancel [*cancel]]]
    [Cancel pending asynchronous operations. ]
  ]
  
  [
    [[link boost_asio.reference.ip__resolver_service.construct [*construct]]]
    [Construct a new resolver implementation. ]
  ]
  
  [
    [[link boost_asio.reference.ip__resolver_service.destroy [*destroy]]]
    [Destroy a resolver implementation. ]
  ]
  
  [
    [[link boost_asio.reference.ip__resolver_service.get_io_service [*get_io_service]]]
    [Get the io_service object that owns the service. ]
  ]
  
  [
    [[link boost_asio.reference.ip__resolver_service.io_service [*io_service]]]
    [(Deprecated: use get_io_service().) Get the io_service object that owns the service. ]
  ]
  
  [
    [[link boost_asio.reference.ip__resolver_service.resolve [*resolve]]]
    [Resolve a query to a list of entries. 

     Resolve an endpoint to a list of entries. ]
  ]
  
  [
    [[link boost_asio.reference.ip__resolver_service.resolver_service [*resolver_service]]]
    [Construct a new resolver service for the specified io_service. ]
  ]
  
  [
    [[link boost_asio.reference.ip__resolver_service.shutdown_service [*shutdown_service]]]
    [Destroy all user-defined handler objects owned by the service. ]
  ]
  
]

[heading Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.ip__resolver_service.id [*id]]]
    [The unique service identifier. ]
  ]

]

[section:async_resolve ip::resolver_service::async_resolve]

[indexterm2 async_resolve..ip::resolver_service] Asynchronously resolve a query to a list of entries. 

  template<
      typename ``[link boost_asio.reference.Handler Handler]``>
  void ``[link boost_asio.reference.ip__resolver_service.async_resolve.overload1 async_resolve]``(
      implementation_type & impl,
      const query_type & query,
      Handler handler);

Asynchronously resolve an endpoint to a list of entries. 

  template<
      typename ``[link boost_asio.reference.ResolveHandler ResolveHandler]``>
  void ``[link boost_asio.reference.ip__resolver_service.async_resolve.overload2 async_resolve]``(
      implementation_type & impl,
      const endpoint_type & endpoint,
      ResolveHandler handler);


[section:overload1 ip::resolver_service::async_resolve (1 of 2 overloads)]

Asynchronously resolve a query to a list of entries. 

  template<
      typename ``[link boost_asio.reference.Handler Handler]``>
  void async_resolve(
      implementation_type & impl,
      const query_type & query,
      Handler handler);



[endsect]



[section:overload2 ip::resolver_service::async_resolve (2 of 2 overloads)]

Asynchronously resolve an endpoint to a list of entries. 

  template<
      typename ``[link boost_asio.reference.ResolveHandler ResolveHandler]``>
  void async_resolve(
      implementation_type & impl,
      const endpoint_type & endpoint,
      ResolveHandler handler);



[endsect]


[endsect]


[section:cancel ip::resolver_service::cancel]

[indexterm2 cancel..ip::resolver_service] Cancel pending asynchronous operations. 

  void cancel(
      implementation_type & impl);



[endsect]



[section:construct ip::resolver_service::construct]

[indexterm2 construct..ip::resolver_service] Construct a new resolver implementation. 

  void construct(
      implementation_type & impl);



[endsect]



[section:destroy ip::resolver_service::destroy]

[indexterm2 destroy..ip::resolver_service] Destroy a resolver implementation. 

  void destroy(
      implementation_type & impl);



[endsect]



[section:endpoint_type ip::resolver_service::endpoint_type]

[indexterm2 endpoint_type..ip::resolver_service] The endpoint type. 

  typedef InternetProtocol::endpoint endpoint_type;




[endsect]



[section:get_io_service ip::resolver_service::get_io_service]


['Inherited from io_service.]

[indexterm2 get_io_service..ip::resolver_service] Get the io_service object that owns the service. 

  boost::asio::io_service & get_io_service();



[endsect]



[section:id ip::resolver_service::id]

[indexterm2 id..ip::resolver_service] The unique service identifier. 

  static boost::asio::io_service::id id;



[endsect]



[section:implementation_type ip::resolver_service::implementation_type]

[indexterm2 implementation_type..ip::resolver_service] The type of a resolver implementation. 

  typedef implementation_defined implementation_type;




[endsect]



[section:io_service ip::resolver_service::io_service]


['Inherited from io_service.]

[indexterm2 io_service..ip::resolver_service] (Deprecated: use get_io_service().) Get the io_service object that owns the service. 

  boost::asio::io_service & io_service();



[endsect]



[section:iterator_type ip::resolver_service::iterator_type]

[indexterm2 iterator_type..ip::resolver_service] The iterator type. 

  typedef InternetProtocol::resolver_iterator iterator_type;




[endsect]



[section:protocol_type ip::resolver_service::protocol_type]

[indexterm2 protocol_type..ip::resolver_service] The protocol type. 

  typedef InternetProtocol protocol_type;




[endsect]



[section:query_type ip::resolver_service::query_type]

[indexterm2 query_type..ip::resolver_service] The query type. 

  typedef InternetProtocol::resolver_query query_type;




[endsect]


[section:resolve ip::resolver_service::resolve]

[indexterm2 resolve..ip::resolver_service] Resolve a query to a list of entries. 

  iterator_type ``[link boost_asio.reference.ip__resolver_service.resolve.overload1 resolve]``(
      implementation_type & impl,
      const query_type & query,
      boost::system::error_code & ec);

Resolve an endpoint to a list of entries. 

  iterator_type ``[link boost_asio.reference.ip__resolver_service.resolve.overload2 resolve]``(
      implementation_type & impl,
      const endpoint_type & endpoint,
      boost::system::error_code & ec);


[section:overload1 ip::resolver_service::resolve (1 of 2 overloads)]

Resolve a query to a list of entries. 

  iterator_type resolve(
      implementation_type & impl,
      const query_type & query,
      boost::system::error_code & ec);



[endsect]



[section:overload2 ip::resolver_service::resolve (2 of 2 overloads)]

Resolve an endpoint to a list of entries. 

  iterator_type resolve(
      implementation_type & impl,
      const endpoint_type & endpoint,
      boost::system::error_code & ec);



[endsect]


[endsect]


[section:resolver_service ip::resolver_service::resolver_service]

[indexterm2 resolver_service..ip::resolver_service] Construct a new resolver service for the specified io_service. 

  resolver_service(
      boost::asio::io_service & io_service);



[endsect]



[section:shutdown_service ip::resolver_service::shutdown_service]

[indexterm2 shutdown_service..ip::resolver_service] Destroy all user-defined handler objects owned by the service. 

  void shutdown_service();



[endsect]



[endsect]

[section:ip__tcp ip::tcp]

Encapsulates the flags needed for TCP. 

  class tcp


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.ip__tcp.acceptor [*acceptor]]]
    [The TCP acceptor type. ]
  
  ]

  [

    [[link boost_asio.reference.ip__tcp.endpoint [*endpoint]]]
    [The type of a TCP endpoint. ]
  
  ]

  [

    [[link boost_asio.reference.ip__tcp.iostream [*iostream]]]
    [The TCP iostream type. ]
  
  ]

  [

    [[link boost_asio.reference.ip__tcp.no_delay [*no_delay]]]
    [Socket option for disabling the Nagle algorithm. ]
  
  ]

  [

    [[link boost_asio.reference.ip__tcp.resolver [*resolver]]]
    [The TCP resolver type. ]
  
  ]

  [

    [[link boost_asio.reference.ip__tcp.resolver_iterator [*resolver_iterator]]]
    [The type of a resolver iterator. ]
  
  ]

  [

    [[link boost_asio.reference.ip__tcp.resolver_query [*resolver_query]]]
    [The type of a resolver query. ]
  
  ]

  [

    [[link boost_asio.reference.ip__tcp.socket [*socket]]]
    [The TCP socket type. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.ip__tcp.family [*family]]]
    [Obtain an identifier for the protocol family. ]
  ]
  
  [
    [[link boost_asio.reference.ip__tcp.protocol [*protocol]]]
    [Obtain an identifier for the protocol. ]
  ]
  
  [
    [[link boost_asio.reference.ip__tcp.type [*type]]]
    [Obtain an identifier for the type of the protocol. ]
  ]
  
  [
    [[link boost_asio.reference.ip__tcp.v4 [*v4]]]
    [Construct to represent the IPv4 TCP protocol. ]
  ]
  
  [
    [[link boost_asio.reference.ip__tcp.v6 [*v6]]]
    [Construct to represent the IPv6 TCP protocol. ]
  ]
  
]

[heading Friends]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.ip__tcp.operator_not__eq_ [*operator!=]]]
    [Compare two protocols for inequality. ]
  ]
  
  [
    [[link boost_asio.reference.ip__tcp.operator_eq__eq_ [*operator==]]]
    [Compare two protocols for equality. ]
  ]
  
]

The 
[link boost_asio.reference.ip__tcp ip::tcp] class contains flags necessary for TCP sockets.


[heading Thread Safety]
  
[*Distinct] [*objects:]  Safe.

[*Shared] [*objects:]  Safe.



[section:acceptor ip::tcp::acceptor]

[indexterm2 acceptor..ip::tcp] The TCP acceptor type. 

  typedef basic_socket_acceptor< tcp > acceptor;


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.basic_socket_acceptor.broadcast [*broadcast]]]
    [Socket option to permit sending of broadcast messages. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_acceptor.bytes_readable [*bytes_readable]]]
    [IO control command to get the amount of data that can be read without blocking. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_acceptor.debug [*debug]]]
    [Socket option to enable socket-level debugging. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_acceptor.do_not_route [*do_not_route]]]
    [Socket option to prevent routing, use local interfaces only. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_acceptor.enable_connection_aborted [*enable_connection_aborted]]]
    [Socket option to report aborted connections on accept. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_acceptor.endpoint_type [*endpoint_type]]]
    [The endpoint type. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_acceptor.implementation_type [*implementation_type]]]
    [The underlying implementation type of I/O object. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_acceptor.keep_alive [*keep_alive]]]
    [Socket option to send keep-alives. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_acceptor.linger [*linger]]]
    [Socket option to specify whether the socket lingers on close if unsent data is present. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_acceptor.message_flags [*message_flags]]]
    [Bitmask type for flags that can be passed to send and receive operations. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_acceptor.native_type [*native_type]]]
    [The native representation of an acceptor. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_acceptor.non_blocking_io [*non_blocking_io]]]
    [IO control command to set the blocking mode of the socket. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_acceptor.protocol_type [*protocol_type]]]
    [The protocol type. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_acceptor.receive_buffer_size [*receive_buffer_size]]]
    [Socket option for the receive buffer size of a socket. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_acceptor.receive_low_watermark [*receive_low_watermark]]]
    [Socket option for the receive low watermark. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_acceptor.reuse_address [*reuse_address]]]
    [Socket option to allow the socket to be bound to an address that is already in use. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_acceptor.send_buffer_size [*send_buffer_size]]]
    [Socket option for the send buffer size of a socket. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_acceptor.send_low_watermark [*send_low_watermark]]]
    [Socket option for the send low watermark. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_acceptor.service_type [*service_type]]]
    [The type of the service that will be used to provide I/O operations. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_acceptor.shutdown_type [*shutdown_type]]]
    [Different ways a socket may be shutdown. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_socket_acceptor.accept [*accept]]]
    [Accept a new connection. 

     Accept a new connection and obtain the endpoint of the peer. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket_acceptor.assign [*assign]]]
    [Assigns an existing native acceptor to the acceptor. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket_acceptor.async_accept [*async_accept]]]
    [Start an asynchronous accept. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket_acceptor.basic_socket_acceptor [*basic_socket_acceptor]]]
    [Construct an acceptor without opening it. 

     Construct an open acceptor. 

     Construct an acceptor opened on the given endpoint. 

     Construct a basic_socket_acceptor on an existing native acceptor. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket_acceptor.bind [*bind]]]
    [Bind the acceptor to the given local endpoint. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket_acceptor.cancel [*cancel]]]
    [Cancel all asynchronous operations associated with the acceptor. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket_acceptor.close [*close]]]
    [Close the acceptor. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket_acceptor.get_io_service [*get_io_service]]]
    [Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket_acceptor.get_option [*get_option]]]
    [Get an option from the acceptor. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket_acceptor.io_service [*io_service]]]
    [(Deprecated: use get_io_service().) Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket_acceptor.is_open [*is_open]]]
    [Determine whether the acceptor is open. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket_acceptor.listen [*listen]]]
    [Place the acceptor into the state where it will listen for new connections. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket_acceptor.local_endpoint [*local_endpoint]]]
    [Get the local endpoint of the acceptor. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket_acceptor.native [*native]]]
    [Get the native acceptor representation. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket_acceptor.open [*open]]]
    [Open the acceptor using the specified protocol. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket_acceptor.set_option [*set_option]]]
    [Set an option on the acceptor. ]
  ]
  
]

[heading Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_socket_acceptor.max_connections [*max_connections]]]
    [The maximum length of the queue of pending incoming connections. ]
  ]

  [
    [[link boost_asio.reference.basic_socket_acceptor.message_do_not_route [*message_do_not_route]]]
    [Specify that the data should not be subject to routing. ]
  ]

  [
    [[link boost_asio.reference.basic_socket_acceptor.message_out_of_band [*message_out_of_band]]]
    [Process out-of-band data. ]
  ]

  [
    [[link boost_asio.reference.basic_socket_acceptor.message_peek [*message_peek]]]
    [Peek at incoming data without removing it from the input queue. ]
  ]

]

[heading Protected Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_socket_acceptor.implementation [*implementation]]]
    [The underlying implementation of the I/O object. ]
  ]

  [
    [[link boost_asio.reference.basic_socket_acceptor.service [*service]]]
    [The service associated with the I/O object. ]
  ]

]

The basic_socket_acceptor class template is used for accepting new socket connections.


[heading Thread Safety]
  
[*Distinct] [*objects:]  Safe.

[*Shared] [*objects:]  Unsafe.

[heading Example]
  
Opening a socket acceptor with the SO\_REUSEADDR option enabled: 

   boost::asio::ip::tcp::acceptor acceptor(io_service);
   boost::asio::ip::tcp::endpoint endpoint(boost::asio::ip::tcp::v4(), port);
   acceptor.open(endpoint.protocol());
   acceptor.set_option(boost::asio::ip::tcp::acceptor::reuse_address(true));
   acceptor.bind(endpoint);
   acceptor.listen();







[endsect]



[section:endpoint ip::tcp::endpoint]

[indexterm2 endpoint..ip::tcp] The type of a TCP endpoint. 

  typedef basic_endpoint< tcp > endpoint;


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.ip__basic_endpoint.data_type [*data_type]]]
    [The type of the endpoint structure. This type is dependent on the underlying implementation of the socket layer. ]
  
  ]

  [

    [[link boost_asio.reference.ip__basic_endpoint.protocol_type [*protocol_type]]]
    [The protocol type associated with the endpoint. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.ip__basic_endpoint.address [*address]]]
    [Get the IP address associated with the endpoint. 

     Set the IP address associated with the endpoint. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_endpoint.basic_endpoint [*basic_endpoint]]]
    [Default constructor. 

     Construct an endpoint using a port number, specified in the host's byte order. The IP address will be the any address (i.e. INADDR_ANY or in6addr_any). This constructor would typically be used for accepting new connections. 

     Construct an endpoint using a port number and an IP address. This constructor may be used for accepting connections on a specific interface or for making a connection to a remote endpoint. 

     Copy constructor. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_endpoint.capacity [*capacity]]]
    [Get the capacity of the endpoint in the native type. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_endpoint.data [*data]]]
    [Get the underlying endpoint in the native type. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_endpoint.operator_eq_ [*operator=]]]
    [Assign from another endpoint. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_endpoint.port [*port]]]
    [Get the port associated with the endpoint. The port number is always in the host's byte order. 

     Set the port associated with the endpoint. The port number is always in the host's byte order. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_endpoint.protocol [*protocol]]]
    [The protocol associated with the endpoint. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_endpoint.resize [*resize]]]
    [Set the underlying size of the endpoint in the native type. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_endpoint.size [*size]]]
    [Get the underlying size of the endpoint in the native type. ]
  ]
  
]

[heading Friends]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.ip__basic_endpoint.operator_not__eq_ [*operator!=]]]
    [Compare two endpoints for inequality. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_endpoint.operator_lt_ [*operator<]]]
    [Compare endpoints for ordering. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_endpoint.operator_eq__eq_ [*operator==]]]
    [Compare two endpoints for equality. ]
  ]
  
]

[heading Related Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.ip__basic_endpoint.operator_lt__lt_ [*operator<<]]]
    [Output an endpoint as a string. ]
  ]
  
]

The 
[link boost_asio.reference.ip__basic_endpoint ip::basic_endpoint] class template describes an endpoint that may be associated with a particular socket.


[heading Thread Safety]
  
[*Distinct] [*objects:]  Safe.

[*Shared] [*objects:]  Unsafe.




[endsect]



[section:family ip::tcp::family]

[indexterm2 family..ip::tcp] Obtain an identifier for the protocol family. 

  int family() const;



[endsect]



[section:iostream ip::tcp::iostream]

[indexterm2 iostream..ip::tcp] The TCP iostream type. 

  typedef basic_socket_iostream< tcp > iostream;


[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_socket_iostream.basic_socket_iostream [*basic_socket_iostream]]]
    [Construct a basic_socket_iostream without establishing a connection. 

     Establish a connection to an endpoint corresponding to a resolver query. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket_iostream.close [*close]]]
    [Close the connection. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket_iostream.connect [*connect]]]
    [Establish a connection to an endpoint corresponding to a resolver query. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket_iostream.rdbuf [*rdbuf]]]
    [Return a pointer to the underlying streambuf. ]
  ]
  
]



[endsect]



[section:no_delay ip::tcp::no_delay]

[indexterm2 no_delay..ip::tcp] Socket option for disabling the Nagle algorithm. 

  typedef implementation_defined no_delay;



Implements the IPPROTO\_TCP/TCP\_NODELAY socket option.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::ip::tcp::no_delay option(true);
   socket.set_option(option);




Getting the current option value: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::ip::tcp::no_delay option;
   socket.get_option(option);
   bool is_set = option.value();






[endsect]



[section:operator_not__eq_ ip::tcp::operator!=]

[indexterm2 operator!=..ip::tcp] Compare two protocols for inequality. 

  friend bool operator!=(
      const tcp & p1,
      const tcp & p2);



[endsect]



[section:operator_eq__eq_ ip::tcp::operator==]

[indexterm2 operator==..ip::tcp] Compare two protocols for equality. 

  friend bool operator==(
      const tcp & p1,
      const tcp & p2);



[endsect]



[section:protocol ip::tcp::protocol]

[indexterm2 protocol..ip::tcp] Obtain an identifier for the protocol. 

  int protocol() const;



[endsect]



[section:resolver ip::tcp::resolver]

[indexterm2 resolver..ip::tcp] The TCP resolver type. 

  typedef basic_resolver< tcp > resolver;


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.ip__basic_resolver.endpoint_type [*endpoint_type]]]
    [The endpoint type. ]
  
  ]

  [

    [[link boost_asio.reference.ip__basic_resolver.implementation_type [*implementation_type]]]
    [The underlying implementation type of I/O object. ]
  
  ]

  [

    [[link boost_asio.reference.ip__basic_resolver.iterator [*iterator]]]
    [The iterator type. ]
  
  ]

  [

    [[link boost_asio.reference.ip__basic_resolver.protocol_type [*protocol_type]]]
    [The protocol type. ]
  
  ]

  [

    [[link boost_asio.reference.ip__basic_resolver.query [*query]]]
    [The query type. ]
  
  ]

  [

    [[link boost_asio.reference.ip__basic_resolver.service_type [*service_type]]]
    [The type of the service that will be used to provide I/O operations. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.ip__basic_resolver.async_resolve [*async_resolve]]]
    [Asynchronously perform forward resolution of a query to a list of entries. 

     Asynchronously perform reverse resolution of an endpoint to a list of entries. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_resolver.basic_resolver [*basic_resolver]]]
    [Constructor. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_resolver.cancel [*cancel]]]
    [Cancel any asynchronous operations that are waiting on the resolver. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_resolver.get_io_service [*get_io_service]]]
    [Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_resolver.io_service [*io_service]]]
    [(Deprecated: use get_io_service().) Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_resolver.resolve [*resolve]]]
    [Perform forward resolution of a query to a list of entries. 

     Perform reverse resolution of an endpoint to a list of entries. ]
  ]
  
]

[heading Protected Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.ip__basic_resolver.implementation [*implementation]]]
    [The underlying implementation of the I/O object. ]
  ]

  [
    [[link boost_asio.reference.ip__basic_resolver.service [*service]]]
    [The service associated with the I/O object. ]
  ]

]

The basic_resolver class template provides the ability to resolve a query to a list of endpoints.


[heading Thread Safety]
  
[*Distinct] [*objects:]  Safe.

[*Shared] [*objects:]  Unsafe. 




[endsect]



[section:resolver_iterator ip::tcp::resolver_iterator]

[indexterm2 resolver_iterator..ip::tcp] The type of a resolver iterator. 

  typedef basic_resolver_iterator< tcp > resolver_iterator;


[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.ip__basic_resolver_iterator.basic_resolver_iterator [*basic_resolver_iterator]]]
    [Default constructor creates an end iterator. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_resolver_iterator.create [*create]]]
    [Create an iterator from an addrinfo list returned by getaddrinfo. 

     Create an iterator from an endpoint, host name and service name. ]
  ]
  
]

The 
[link boost_asio.reference.ip__basic_resolver_iterator ip::basic_resolver_iterator] class template is used to define iterators over the results returned by a resolver.

The iterator's value\_type, obtained when the iterator is dereferenced, is: 

   const basic_resolver_entry<InternetProtocol> 





[heading Thread Safety]
  
[*Distinct] [*objects:]  Safe.

[*Shared] [*objects:]  Unsafe. 




[endsect]



[section:resolver_query ip::tcp::resolver_query]

[indexterm2 resolver_query..ip::tcp] The type of a resolver query. 

  typedef basic_resolver_query< tcp > resolver_query;


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.ip__basic_resolver_query.protocol_type [*protocol_type]]]
    [The protocol type associated with the endpoint query. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.ip__basic_resolver_query.basic_resolver_query [*basic_resolver_query]]]
    [Construct with specified service name for any protocol. 

     Construct with specified service name for a given protocol. 

     Construct with specified host name and service name for any protocol. 

     Construct with specified host name and service name for a given protocol. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_resolver_query.hints [*hints]]]
    [Get the hints associated with the query. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_resolver_query.host_name [*host_name]]]
    [Get the host name associated with the query. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_resolver_query.service_name [*service_name]]]
    [Get the service name associated with the query. ]
  ]
  
]

[heading Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.ip__basic_resolver_query.address_configured [*address_configured]]]
    [Only return IPv4 addresses if a non-loopback IPv4 address is configured for the system. Only return IPv6 addresses if a non-loopback IPv6 address is configured for the system. ]
  ]

  [
    [[link boost_asio.reference.ip__basic_resolver_query.all_matching [*all_matching]]]
    [If used with v4_mapped, return all matching IPv6 and IPv4 addresses. ]
  ]

  [
    [[link boost_asio.reference.ip__basic_resolver_query.canonical_name [*canonical_name]]]
    [Determine the canonical name of the host specified in the query. ]
  ]

  [
    [[link boost_asio.reference.ip__basic_resolver_query.numeric_host [*numeric_host]]]
    [Host name should be treated as a numeric string defining an IPv4 or IPv6 address and no name resolution should be attempted. ]
  ]

  [
    [[link boost_asio.reference.ip__basic_resolver_query.numeric_service [*numeric_service]]]
    [Service name should be treated as a numeric string defining a port number and no name resolution should be attempted. ]
  ]

  [
    [[link boost_asio.reference.ip__basic_resolver_query.passive [*passive]]]
    [Indicate that returned endpoint is intended for use as a locally bound socket endpoint. ]
  ]

  [
    [[link boost_asio.reference.ip__basic_resolver_query.v4_mapped [*v4_mapped]]]
    [If the query protocol family is specified as IPv6, return IPv4-mapped IPv6 addresses on finding no IPv6 addresses. ]
  ]

]

The 
[link boost_asio.reference.ip__basic_resolver_query ip::basic_resolver_query] class template describes a query that can be passed to a resolver.


[heading Thread Safety]
  
[*Distinct] [*objects:]  Safe.

[*Shared] [*objects:]  Unsafe. 




[endsect]



[section:socket ip::tcp::socket]

[indexterm2 socket..ip::tcp] The TCP socket type. 

  typedef basic_stream_socket< tcp > socket;


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.basic_stream_socket.broadcast [*broadcast]]]
    [Socket option to permit sending of broadcast messages. ]
  
  ]

  [

    [[link boost_asio.reference.basic_stream_socket.bytes_readable [*bytes_readable]]]
    [IO control command to get the amount of data that can be read without blocking. ]
  
  ]

  [

    [[link boost_asio.reference.basic_stream_socket.debug [*debug]]]
    [Socket option to enable socket-level debugging. ]
  
  ]

  [

    [[link boost_asio.reference.basic_stream_socket.do_not_route [*do_not_route]]]
    [Socket option to prevent routing, use local interfaces only. ]
  
  ]

  [

    [[link boost_asio.reference.basic_stream_socket.enable_connection_aborted [*enable_connection_aborted]]]
    [Socket option to report aborted connections on accept. ]
  
  ]

  [

    [[link boost_asio.reference.basic_stream_socket.endpoint_type [*endpoint_type]]]
    [The endpoint type. ]
  
  ]

  [

    [[link boost_asio.reference.basic_stream_socket.implementation_type [*implementation_type]]]
    [The underlying implementation type of I/O object. ]
  
  ]

  [

    [[link boost_asio.reference.basic_stream_socket.keep_alive [*keep_alive]]]
    [Socket option to send keep-alives. ]
  
  ]

  [

    [[link boost_asio.reference.basic_stream_socket.linger [*linger]]]
    [Socket option to specify whether the socket lingers on close if unsent data is present. ]
  
  ]

  [

    [[link boost_asio.reference.basic_stream_socket.lowest_layer_type [*lowest_layer_type]]]
    [A basic_socket is always the lowest layer. ]
  
  ]

  [

    [[link boost_asio.reference.basic_stream_socket.message_flags [*message_flags]]]
    [Bitmask type for flags that can be passed to send and receive operations. ]
  
  ]

  [

    [[link boost_asio.reference.basic_stream_socket.native_type [*native_type]]]
    [The native representation of a socket. ]
  
  ]

  [

    [[link boost_asio.reference.basic_stream_socket.non_blocking_io [*non_blocking_io]]]
    [IO control command to set the blocking mode of the socket. ]
  
  ]

  [

    [[link boost_asio.reference.basic_stream_socket.protocol_type [*protocol_type]]]
    [The protocol type. ]
  
  ]

  [

    [[link boost_asio.reference.basic_stream_socket.receive_buffer_size [*receive_buffer_size]]]
    [Socket option for the receive buffer size of a socket. ]
  
  ]

  [

    [[link boost_asio.reference.basic_stream_socket.receive_low_watermark [*receive_low_watermark]]]
    [Socket option for the receive low watermark. ]
  
  ]

  [

    [[link boost_asio.reference.basic_stream_socket.reuse_address [*reuse_address]]]
    [Socket option to allow the socket to be bound to an address that is already in use. ]
  
  ]

  [

    [[link boost_asio.reference.basic_stream_socket.send_buffer_size [*send_buffer_size]]]
    [Socket option for the send buffer size of a socket. ]
  
  ]

  [

    [[link boost_asio.reference.basic_stream_socket.send_low_watermark [*send_low_watermark]]]
    [Socket option for the send low watermark. ]
  
  ]

  [

    [[link boost_asio.reference.basic_stream_socket.service_type [*service_type]]]
    [The type of the service that will be used to provide I/O operations. ]
  
  ]

  [

    [[link boost_asio.reference.basic_stream_socket.shutdown_type [*shutdown_type]]]
    [Different ways a socket may be shutdown. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_stream_socket.assign [*assign]]]
    [Assign an existing native socket to the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.async_connect [*async_connect]]]
    [Start an asynchronous connect. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.async_read_some [*async_read_some]]]
    [Start an asynchronous read. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.async_receive [*async_receive]]]
    [Start an asynchronous receive. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.async_send [*async_send]]]
    [Start an asynchronous send. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.async_write_some [*async_write_some]]]
    [Start an asynchronous write. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.at_mark [*at_mark]]]
    [Determine whether the socket is at the out-of-band data mark. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.available [*available]]]
    [Determine the number of bytes available for reading. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.basic_stream_socket [*basic_stream_socket]]]
    [Construct a basic_stream_socket without opening it. 

     Construct and open a basic_stream_socket. 

     Construct a basic_stream_socket, opening it and binding it to the given local endpoint. 

     Construct a basic_stream_socket on an existing native socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.bind [*bind]]]
    [Bind the socket to the given local endpoint. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.cancel [*cancel]]]
    [Cancel all asynchronous operations associated with the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.close [*close]]]
    [Close the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.connect [*connect]]]
    [Connect the socket to the specified endpoint. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.get_io_service [*get_io_service]]]
    [Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.get_option [*get_option]]]
    [Get an option from the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.io_control [*io_control]]]
    [Perform an IO control command on the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.io_service [*io_service]]]
    [(Deprecated: use get_io_service().) Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.is_open [*is_open]]]
    [Determine whether the socket is open. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.local_endpoint [*local_endpoint]]]
    [Get the local endpoint of the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.lowest_layer [*lowest_layer]]]
    [Get a reference to the lowest layer. 

     Get a const reference to the lowest layer. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.native [*native]]]
    [Get the native socket representation. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.open [*open]]]
    [Open the socket using the specified protocol. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.read_some [*read_some]]]
    [Read some data from the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.receive [*receive]]]
    [Receive some data on the socket. 

     Receive some data on a connected socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.remote_endpoint [*remote_endpoint]]]
    [Get the remote endpoint of the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.send [*send]]]
    [Send some data on the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.set_option [*set_option]]]
    [Set an option on the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.shutdown [*shutdown]]]
    [Disable sends or receives on the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.write_some [*write_some]]]
    [Write some data to the socket. ]
  ]
  
]

[heading Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_stream_socket.max_connections [*max_connections]]]
    [The maximum length of the queue of pending incoming connections. ]
  ]

  [
    [[link boost_asio.reference.basic_stream_socket.message_do_not_route [*message_do_not_route]]]
    [Specify that the data should not be subject to routing. ]
  ]

  [
    [[link boost_asio.reference.basic_stream_socket.message_out_of_band [*message_out_of_band]]]
    [Process out-of-band data. ]
  ]

  [
    [[link boost_asio.reference.basic_stream_socket.message_peek [*message_peek]]]
    [Peek at incoming data without removing it from the input queue. ]
  ]

]

[heading Protected Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_stream_socket.implementation [*implementation]]]
    [The underlying implementation of the I/O object. ]
  ]

  [
    [[link boost_asio.reference.basic_stream_socket.service [*service]]]
    [The service associated with the I/O object. ]
  ]

]

The basic_stream_socket class template provides asynchronous and blocking stream-oriented socket functionality.


[heading Thread Safety]
  
[*Distinct] [*objects:]  Safe.

[*Shared] [*objects:]  Unsafe.




[endsect]



[section:type ip::tcp::type]

[indexterm2 type..ip::tcp] Obtain an identifier for the type of the protocol. 

  int type() const;



[endsect]



[section:v4 ip::tcp::v4]

[indexterm2 v4..ip::tcp] Construct to represent the IPv4 TCP protocol. 

  static tcp v4();



[endsect]



[section:v6 ip::tcp::v6]

[indexterm2 v6..ip::tcp] Construct to represent the IPv6 TCP protocol. 

  static tcp v6();



[endsect]



[endsect]

[section:ip__udp ip::udp]

Encapsulates the flags needed for UDP. 

  class udp


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.ip__udp.endpoint [*endpoint]]]
    [The type of a UDP endpoint. ]
  
  ]

  [

    [[link boost_asio.reference.ip__udp.resolver [*resolver]]]
    [The UDP resolver type. ]
  
  ]

  [

    [[link boost_asio.reference.ip__udp.resolver_iterator [*resolver_iterator]]]
    [The type of a resolver iterator. ]
  
  ]

  [

    [[link boost_asio.reference.ip__udp.resolver_query [*resolver_query]]]
    [The type of a resolver query. ]
  
  ]

  [

    [[link boost_asio.reference.ip__udp.socket [*socket]]]
    [The UDP socket type. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.ip__udp.family [*family]]]
    [Obtain an identifier for the protocol family. ]
  ]
  
  [
    [[link boost_asio.reference.ip__udp.protocol [*protocol]]]
    [Obtain an identifier for the protocol. ]
  ]
  
  [
    [[link boost_asio.reference.ip__udp.type [*type]]]
    [Obtain an identifier for the type of the protocol. ]
  ]
  
  [
    [[link boost_asio.reference.ip__udp.v4 [*v4]]]
    [Construct to represent the IPv4 UDP protocol. ]
  ]
  
  [
    [[link boost_asio.reference.ip__udp.v6 [*v6]]]
    [Construct to represent the IPv6 UDP protocol. ]
  ]
  
]

[heading Friends]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.ip__udp.operator_not__eq_ [*operator!=]]]
    [Compare two protocols for inequality. ]
  ]
  
  [
    [[link boost_asio.reference.ip__udp.operator_eq__eq_ [*operator==]]]
    [Compare two protocols for equality. ]
  ]
  
]

The 
[link boost_asio.reference.ip__udp ip::udp] class contains flags necessary for UDP sockets.


[heading Thread Safety]
  
[*Distinct] [*objects:]  Safe.

[*Shared] [*objects:]  Safe.



[section:endpoint ip::udp::endpoint]

[indexterm2 endpoint..ip::udp] The type of a UDP endpoint. 

  typedef basic_endpoint< udp > endpoint;


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.ip__basic_endpoint.data_type [*data_type]]]
    [The type of the endpoint structure. This type is dependent on the underlying implementation of the socket layer. ]
  
  ]

  [

    [[link boost_asio.reference.ip__basic_endpoint.protocol_type [*protocol_type]]]
    [The protocol type associated with the endpoint. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.ip__basic_endpoint.address [*address]]]
    [Get the IP address associated with the endpoint. 

     Set the IP address associated with the endpoint. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_endpoint.basic_endpoint [*basic_endpoint]]]
    [Default constructor. 

     Construct an endpoint using a port number, specified in the host's byte order. The IP address will be the any address (i.e. INADDR_ANY or in6addr_any). This constructor would typically be used for accepting new connections. 

     Construct an endpoint using a port number and an IP address. This constructor may be used for accepting connections on a specific interface or for making a connection to a remote endpoint. 

     Copy constructor. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_endpoint.capacity [*capacity]]]
    [Get the capacity of the endpoint in the native type. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_endpoint.data [*data]]]
    [Get the underlying endpoint in the native type. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_endpoint.operator_eq_ [*operator=]]]
    [Assign from another endpoint. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_endpoint.port [*port]]]
    [Get the port associated with the endpoint. The port number is always in the host's byte order. 

     Set the port associated with the endpoint. The port number is always in the host's byte order. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_endpoint.protocol [*protocol]]]
    [The protocol associated with the endpoint. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_endpoint.resize [*resize]]]
    [Set the underlying size of the endpoint in the native type. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_endpoint.size [*size]]]
    [Get the underlying size of the endpoint in the native type. ]
  ]
  
]

[heading Friends]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.ip__basic_endpoint.operator_not__eq_ [*operator!=]]]
    [Compare two endpoints for inequality. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_endpoint.operator_lt_ [*operator<]]]
    [Compare endpoints for ordering. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_endpoint.operator_eq__eq_ [*operator==]]]
    [Compare two endpoints for equality. ]
  ]
  
]

[heading Related Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.ip__basic_endpoint.operator_lt__lt_ [*operator<<]]]
    [Output an endpoint as a string. ]
  ]
  
]

The 
[link boost_asio.reference.ip__basic_endpoint ip::basic_endpoint] class template describes an endpoint that may be associated with a particular socket.


[heading Thread Safety]
  
[*Distinct] [*objects:]  Safe.

[*Shared] [*objects:]  Unsafe.




[endsect]



[section:family ip::udp::family]

[indexterm2 family..ip::udp] Obtain an identifier for the protocol family. 

  int family() const;



[endsect]



[section:operator_not__eq_ ip::udp::operator!=]

[indexterm2 operator!=..ip::udp] Compare two protocols for inequality. 

  friend bool operator!=(
      const udp & p1,
      const udp & p2);



[endsect]



[section:operator_eq__eq_ ip::udp::operator==]

[indexterm2 operator==..ip::udp] Compare two protocols for equality. 

  friend bool operator==(
      const udp & p1,
      const udp & p2);



[endsect]



[section:protocol ip::udp::protocol]

[indexterm2 protocol..ip::udp] Obtain an identifier for the protocol. 

  int protocol() const;



[endsect]



[section:resolver ip::udp::resolver]

[indexterm2 resolver..ip::udp] The UDP resolver type. 

  typedef basic_resolver< udp > resolver;


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.ip__basic_resolver.endpoint_type [*endpoint_type]]]
    [The endpoint type. ]
  
  ]

  [

    [[link boost_asio.reference.ip__basic_resolver.implementation_type [*implementation_type]]]
    [The underlying implementation type of I/O object. ]
  
  ]

  [

    [[link boost_asio.reference.ip__basic_resolver.iterator [*iterator]]]
    [The iterator type. ]
  
  ]

  [

    [[link boost_asio.reference.ip__basic_resolver.protocol_type [*protocol_type]]]
    [The protocol type. ]
  
  ]

  [

    [[link boost_asio.reference.ip__basic_resolver.query [*query]]]
    [The query type. ]
  
  ]

  [

    [[link boost_asio.reference.ip__basic_resolver.service_type [*service_type]]]
    [The type of the service that will be used to provide I/O operations. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.ip__basic_resolver.async_resolve [*async_resolve]]]
    [Asynchronously perform forward resolution of a query to a list of entries. 

     Asynchronously perform reverse resolution of an endpoint to a list of entries. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_resolver.basic_resolver [*basic_resolver]]]
    [Constructor. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_resolver.cancel [*cancel]]]
    [Cancel any asynchronous operations that are waiting on the resolver. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_resolver.get_io_service [*get_io_service]]]
    [Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_resolver.io_service [*io_service]]]
    [(Deprecated: use get_io_service().) Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_resolver.resolve [*resolve]]]
    [Perform forward resolution of a query to a list of entries. 

     Perform reverse resolution of an endpoint to a list of entries. ]
  ]
  
]

[heading Protected Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.ip__basic_resolver.implementation [*implementation]]]
    [The underlying implementation of the I/O object. ]
  ]

  [
    [[link boost_asio.reference.ip__basic_resolver.service [*service]]]
    [The service associated with the I/O object. ]
  ]

]

The basic_resolver class template provides the ability to resolve a query to a list of endpoints.


[heading Thread Safety]
  
[*Distinct] [*objects:]  Safe.

[*Shared] [*objects:]  Unsafe. 




[endsect]



[section:resolver_iterator ip::udp::resolver_iterator]

[indexterm2 resolver_iterator..ip::udp] The type of a resolver iterator. 

  typedef basic_resolver_iterator< udp > resolver_iterator;


[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.ip__basic_resolver_iterator.basic_resolver_iterator [*basic_resolver_iterator]]]
    [Default constructor creates an end iterator. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_resolver_iterator.create [*create]]]
    [Create an iterator from an addrinfo list returned by getaddrinfo. 

     Create an iterator from an endpoint, host name and service name. ]
  ]
  
]

The 
[link boost_asio.reference.ip__basic_resolver_iterator ip::basic_resolver_iterator] class template is used to define iterators over the results returned by a resolver.

The iterator's value\_type, obtained when the iterator is dereferenced, is: 

   const basic_resolver_entry<InternetProtocol> 





[heading Thread Safety]
  
[*Distinct] [*objects:]  Safe.

[*Shared] [*objects:]  Unsafe. 




[endsect]



[section:resolver_query ip::udp::resolver_query]

[indexterm2 resolver_query..ip::udp] The type of a resolver query. 

  typedef basic_resolver_query< udp > resolver_query;


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.ip__basic_resolver_query.protocol_type [*protocol_type]]]
    [The protocol type associated with the endpoint query. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.ip__basic_resolver_query.basic_resolver_query [*basic_resolver_query]]]
    [Construct with specified service name for any protocol. 

     Construct with specified service name for a given protocol. 

     Construct with specified host name and service name for any protocol. 

     Construct with specified host name and service name for a given protocol. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_resolver_query.hints [*hints]]]
    [Get the hints associated with the query. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_resolver_query.host_name [*host_name]]]
    [Get the host name associated with the query. ]
  ]
  
  [
    [[link boost_asio.reference.ip__basic_resolver_query.service_name [*service_name]]]
    [Get the service name associated with the query. ]
  ]
  
]

[heading Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.ip__basic_resolver_query.address_configured [*address_configured]]]
    [Only return IPv4 addresses if a non-loopback IPv4 address is configured for the system. Only return IPv6 addresses if a non-loopback IPv6 address is configured for the system. ]
  ]

  [
    [[link boost_asio.reference.ip__basic_resolver_query.all_matching [*all_matching]]]
    [If used with v4_mapped, return all matching IPv6 and IPv4 addresses. ]
  ]

  [
    [[link boost_asio.reference.ip__basic_resolver_query.canonical_name [*canonical_name]]]
    [Determine the canonical name of the host specified in the query. ]
  ]

  [
    [[link boost_asio.reference.ip__basic_resolver_query.numeric_host [*numeric_host]]]
    [Host name should be treated as a numeric string defining an IPv4 or IPv6 address and no name resolution should be attempted. ]
  ]

  [
    [[link boost_asio.reference.ip__basic_resolver_query.numeric_service [*numeric_service]]]
    [Service name should be treated as a numeric string defining a port number and no name resolution should be attempted. ]
  ]

  [
    [[link boost_asio.reference.ip__basic_resolver_query.passive [*passive]]]
    [Indicate that returned endpoint is intended for use as a locally bound socket endpoint. ]
  ]

  [
    [[link boost_asio.reference.ip__basic_resolver_query.v4_mapped [*v4_mapped]]]
    [If the query protocol family is specified as IPv6, return IPv4-mapped IPv6 addresses on finding no IPv6 addresses. ]
  ]

]

The 
[link boost_asio.reference.ip__basic_resolver_query ip::basic_resolver_query] class template describes a query that can be passed to a resolver.


[heading Thread Safety]
  
[*Distinct] [*objects:]  Safe.

[*Shared] [*objects:]  Unsafe. 




[endsect]



[section:socket ip::udp::socket]

[indexterm2 socket..ip::udp] The UDP socket type. 

  typedef basic_datagram_socket< udp > socket;


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.basic_datagram_socket.broadcast [*broadcast]]]
    [Socket option to permit sending of broadcast messages. ]
  
  ]

  [

    [[link boost_asio.reference.basic_datagram_socket.bytes_readable [*bytes_readable]]]
    [IO control command to get the amount of data that can be read without blocking. ]
  
  ]

  [

    [[link boost_asio.reference.basic_datagram_socket.debug [*debug]]]
    [Socket option to enable socket-level debugging. ]
  
  ]

  [

    [[link boost_asio.reference.basic_datagram_socket.do_not_route [*do_not_route]]]
    [Socket option to prevent routing, use local interfaces only. ]
  
  ]

  [

    [[link boost_asio.reference.basic_datagram_socket.enable_connection_aborted [*enable_connection_aborted]]]
    [Socket option to report aborted connections on accept. ]
  
  ]

  [

    [[link boost_asio.reference.basic_datagram_socket.endpoint_type [*endpoint_type]]]
    [The endpoint type. ]
  
  ]

  [

    [[link boost_asio.reference.basic_datagram_socket.implementation_type [*implementation_type]]]
    [The underlying implementation type of I/O object. ]
  
  ]

  [

    [[link boost_asio.reference.basic_datagram_socket.keep_alive [*keep_alive]]]
    [Socket option to send keep-alives. ]
  
  ]

  [

    [[link boost_asio.reference.basic_datagram_socket.linger [*linger]]]
    [Socket option to specify whether the socket lingers on close if unsent data is present. ]
  
  ]

  [

    [[link boost_asio.reference.basic_datagram_socket.lowest_layer_type [*lowest_layer_type]]]
    [A basic_socket is always the lowest layer. ]
  
  ]

  [

    [[link boost_asio.reference.basic_datagram_socket.message_flags [*message_flags]]]
    [Bitmask type for flags that can be passed to send and receive operations. ]
  
  ]

  [

    [[link boost_asio.reference.basic_datagram_socket.native_type [*native_type]]]
    [The native representation of a socket. ]
  
  ]

  [

    [[link boost_asio.reference.basic_datagram_socket.non_blocking_io [*non_blocking_io]]]
    [IO control command to set the blocking mode of the socket. ]
  
  ]

  [

    [[link boost_asio.reference.basic_datagram_socket.protocol_type [*protocol_type]]]
    [The protocol type. ]
  
  ]

  [

    [[link boost_asio.reference.basic_datagram_socket.receive_buffer_size [*receive_buffer_size]]]
    [Socket option for the receive buffer size of a socket. ]
  
  ]

  [

    [[link boost_asio.reference.basic_datagram_socket.receive_low_watermark [*receive_low_watermark]]]
    [Socket option for the receive low watermark. ]
  
  ]

  [

    [[link boost_asio.reference.basic_datagram_socket.reuse_address [*reuse_address]]]
    [Socket option to allow the socket to be bound to an address that is already in use. ]
  
  ]

  [

    [[link boost_asio.reference.basic_datagram_socket.send_buffer_size [*send_buffer_size]]]
    [Socket option for the send buffer size of a socket. ]
  
  ]

  [

    [[link boost_asio.reference.basic_datagram_socket.send_low_watermark [*send_low_watermark]]]
    [Socket option for the send low watermark. ]
  
  ]

  [

    [[link boost_asio.reference.basic_datagram_socket.service_type [*service_type]]]
    [The type of the service that will be used to provide I/O operations. ]
  
  ]

  [

    [[link boost_asio.reference.basic_datagram_socket.shutdown_type [*shutdown_type]]]
    [Different ways a socket may be shutdown. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_datagram_socket.assign [*assign]]]
    [Assign an existing native socket to the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.async_connect [*async_connect]]]
    [Start an asynchronous connect. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.async_receive [*async_receive]]]
    [Start an asynchronous receive on a connected socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.async_receive_from [*async_receive_from]]]
    [Start an asynchronous receive. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.async_send [*async_send]]]
    [Start an asynchronous send on a connected socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.async_send_to [*async_send_to]]]
    [Start an asynchronous send. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.at_mark [*at_mark]]]
    [Determine whether the socket is at the out-of-band data mark. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.available [*available]]]
    [Determine the number of bytes available for reading. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.basic_datagram_socket [*basic_datagram_socket]]]
    [Construct a basic_datagram_socket without opening it. 

     Construct and open a basic_datagram_socket. 

     Construct a basic_datagram_socket, opening it and binding it to the given local endpoint. 

     Construct a basic_datagram_socket on an existing native socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.bind [*bind]]]
    [Bind the socket to the given local endpoint. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.cancel [*cancel]]]
    [Cancel all asynchronous operations associated with the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.close [*close]]]
    [Close the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.connect [*connect]]]
    [Connect the socket to the specified endpoint. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.get_io_service [*get_io_service]]]
    [Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.get_option [*get_option]]]
    [Get an option from the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.io_control [*io_control]]]
    [Perform an IO control command on the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.io_service [*io_service]]]
    [(Deprecated: use get_io_service().) Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.is_open [*is_open]]]
    [Determine whether the socket is open. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.local_endpoint [*local_endpoint]]]
    [Get the local endpoint of the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.lowest_layer [*lowest_layer]]]
    [Get a reference to the lowest layer. 

     Get a const reference to the lowest layer. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.native [*native]]]
    [Get the native socket representation. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.open [*open]]]
    [Open the socket using the specified protocol. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.receive [*receive]]]
    [Receive some data on a connected socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.receive_from [*receive_from]]]
    [Receive a datagram with the endpoint of the sender. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.remote_endpoint [*remote_endpoint]]]
    [Get the remote endpoint of the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.send [*send]]]
    [Send some data on a connected socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.send_to [*send_to]]]
    [Send a datagram to the specified endpoint. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.set_option [*set_option]]]
    [Set an option on the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.shutdown [*shutdown]]]
    [Disable sends or receives on the socket. ]
  ]
  
]

[heading Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_datagram_socket.max_connections [*max_connections]]]
    [The maximum length of the queue of pending incoming connections. ]
  ]

  [
    [[link boost_asio.reference.basic_datagram_socket.message_do_not_route [*message_do_not_route]]]
    [Specify that the data should not be subject to routing. ]
  ]

  [
    [[link boost_asio.reference.basic_datagram_socket.message_out_of_band [*message_out_of_band]]]
    [Process out-of-band data. ]
  ]

  [
    [[link boost_asio.reference.basic_datagram_socket.message_peek [*message_peek]]]
    [Peek at incoming data without removing it from the input queue. ]
  ]

]

[heading Protected Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_datagram_socket.implementation [*implementation]]]
    [The underlying implementation of the I/O object. ]
  ]

  [
    [[link boost_asio.reference.basic_datagram_socket.service [*service]]]
    [The service associated with the I/O object. ]
  ]

]

The basic_datagram_socket class template provides asynchronous and blocking datagram-oriented socket functionality.


[heading Thread Safety]
  
[*Distinct] [*objects:]  Safe.

[*Shared] [*objects:]  Unsafe. 




[endsect]



[section:type ip::udp::type]

[indexterm2 type..ip::udp] Obtain an identifier for the type of the protocol. 

  int type() const;



[endsect]



[section:v4 ip::udp::v4]

[indexterm2 v4..ip::udp] Construct to represent the IPv4 UDP protocol. 

  static udp v4();



[endsect]



[section:v6 ip::udp::v6]

[indexterm2 v6..ip::udp] Construct to represent the IPv6 UDP protocol. 

  static udp v6();



[endsect]



[endsect]


[section:ip__unicast__hops ip::unicast::hops]

[indexterm1 ip::unicast::hops] Socket option for time-to-live associated with outgoing unicast packets. 

  typedef implementation_defined hops;



Implements the IPPROTO\_IP/IP\_UNICAST\_TTL socket option.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::udp::socket socket(io_service); 
   ...
   boost::asio::ip::unicast::hops option(4);
   socket.set_option(option);




Getting the current option value: 

   boost::asio::ip::udp::socket socket(io_service); 
   ...
   boost::asio::ip::unicast::hops option;
   socket.get_option(option);
   int ttl = option.value();






[endsect]



[section:ip__v6_only ip::v6_only]

[indexterm1 ip::v6_only] Socket option for determining whether an IPv6 socket supports IPv6 communication only. 

  typedef implementation_defined v6_only;



Implements the IPPROTO\_IPV6/IP\_V6ONLY socket option.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::ip::v6_only option(true);
   socket.set_option(option);




Getting the current option value: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::ip::v6_only option;
   socket.get_option(option);
   bool v6_only = option.value();






[endsect]


[section:is_match_condition is_match_condition]

Type trait used to determine whether a type can be used as a match condition function with read_until and async_read_until. 

  template<
      typename T>
  struct is_match_condition


[heading Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.is_match_condition.value [*value]]]
    [The value member is true if the type may be used as a match condition. ]
  ]

]


[section:value is_match_condition::value]

[indexterm2 value..is_match_condition] The value member is true if the type may be used as a match condition. 

  static const bool value;



[endsect]



[endsect]

[section:is_read_buffered is_read_buffered]

The is_read_buffered class is a traits class that may be used to determine whether a stream type supports buffering of read data. 

  template<
      typename Stream>
  class is_read_buffered


[heading Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.is_read_buffered.value [*value]]]
    [The value member is true only if the Stream type supports buffering of read data. ]
  ]

]


[section:value is_read_buffered::value]

[indexterm2 value..is_read_buffered] The value member is true only if the Stream type supports buffering of read data. 

  static const bool value;



[endsect]



[endsect]

[section:is_write_buffered is_write_buffered]

The is_write_buffered class is a traits class that may be used to determine whether a stream type supports buffering of written data. 

  template<
      typename Stream>
  class is_write_buffered


[heading Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.is_write_buffered.value [*value]]]
    [The value member is true only if the Stream type supports buffering of written data. ]
  ]

]


[section:value is_write_buffered::value]

[indexterm2 value..is_write_buffered] The value member is true only if the Stream type supports buffering of written data. 

  static const bool value;



[endsect]



[endsect]

[section:local__basic_endpoint local::basic_endpoint]

Describes an endpoint for a UNIX socket. 

  template<
      typename ``[link boost_asio.reference.Protocol Protocol]``>
  class basic_endpoint


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.local__basic_endpoint.data_type [*data_type]]]
    [The type of the endpoint structure. This type is dependent on the underlying implementation of the socket layer. ]
  
  ]

  [

    [[link boost_asio.reference.local__basic_endpoint.protocol_type [*protocol_type]]]
    [The protocol type associated with the endpoint. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.local__basic_endpoint.basic_endpoint [*basic_endpoint]]]
    [Default constructor. 

     Construct an endpoint using the specified path name. 

     Copy constructor. ]
  ]
  
  [
    [[link boost_asio.reference.local__basic_endpoint.capacity [*capacity]]]
    [Get the capacity of the endpoint in the native type. ]
  ]
  
  [
    [[link boost_asio.reference.local__basic_endpoint.data [*data]]]
    [Get the underlying endpoint in the native type. ]
  ]
  
  [
    [[link boost_asio.reference.local__basic_endpoint.operator_eq_ [*operator=]]]
    [Assign from another endpoint. ]
  ]
  
  [
    [[link boost_asio.reference.local__basic_endpoint.path [*path]]]
    [Get the path associated with the endpoint. 

     Set the path associated with the endpoint. ]
  ]
  
  [
    [[link boost_asio.reference.local__basic_endpoint.protocol [*protocol]]]
    [The protocol associated with the endpoint. ]
  ]
  
  [
    [[link boost_asio.reference.local__basic_endpoint.resize [*resize]]]
    [Set the underlying size of the endpoint in the native type. ]
  ]
  
  [
    [[link boost_asio.reference.local__basic_endpoint.size [*size]]]
    [Get the underlying size of the endpoint in the native type. ]
  ]
  
]

[heading Friends]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.local__basic_endpoint.operator_not__eq_ [*operator!=]]]
    [Compare two endpoints for inequality. ]
  ]
  
  [
    [[link boost_asio.reference.local__basic_endpoint.operator_lt_ [*operator<]]]
    [Compare endpoints for ordering. ]
  ]
  
  [
    [[link boost_asio.reference.local__basic_endpoint.operator_eq__eq_ [*operator==]]]
    [Compare two endpoints for equality. ]
  ]
  
]

[heading Related Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.local__basic_endpoint.operator_lt__lt_ [*operator<<]]]
    [Output an endpoint as a string. ]
  ]
  
]

The 
[link boost_asio.reference.local__basic_endpoint local::basic_endpoint] class template describes an endpoint that may be associated with a particular UNIX socket.


[heading Thread Safety]
  
[*Distinct] [*objects:]  Safe.

[*Shared] [*objects:]  Unsafe.


[section:basic_endpoint local::basic_endpoint::basic_endpoint]

[indexterm2 basic_endpoint..local::basic_endpoint] Default constructor. 

  ``[link boost_asio.reference.local__basic_endpoint.basic_endpoint.overload1 basic_endpoint]``();

Construct an endpoint using the specified path name. 

  ``[link boost_asio.reference.local__basic_endpoint.basic_endpoint.overload2 basic_endpoint]``(
      const char * path);

  ``[link boost_asio.reference.local__basic_endpoint.basic_endpoint.overload3 basic_endpoint]``(
      const std::string & path);

Copy constructor. 

  ``[link boost_asio.reference.local__basic_endpoint.basic_endpoint.overload4 basic_endpoint]``(
      const basic_endpoint & other);


[section:overload1 local::basic_endpoint::basic_endpoint (1 of 4 overloads)]

Default constructor. 

  basic_endpoint();



[endsect]



[section:overload2 local::basic_endpoint::basic_endpoint (2 of 4 overloads)]

Construct an endpoint using the specified path name. 

  basic_endpoint(
      const char * path);



[endsect]



[section:overload3 local::basic_endpoint::basic_endpoint (3 of 4 overloads)]

Construct an endpoint using the specified path name. 

  basic_endpoint(
      const std::string & path);



[endsect]



[section:overload4 local::basic_endpoint::basic_endpoint (4 of 4 overloads)]

Copy constructor. 

  basic_endpoint(
      const basic_endpoint & other);



[endsect]


[endsect]


[section:capacity local::basic_endpoint::capacity]

[indexterm2 capacity..local::basic_endpoint] Get the capacity of the endpoint in the native type. 

  std::size_t capacity() const;



[endsect]


[section:data local::basic_endpoint::data]

[indexterm2 data..local::basic_endpoint] Get the underlying endpoint in the native type. 

  data_type * ``[link boost_asio.reference.local__basic_endpoint.data.overload1 data]``();

  const data_type * ``[link boost_asio.reference.local__basic_endpoint.data.overload2 data]``() const;


[section:overload1 local::basic_endpoint::data (1 of 2 overloads)]

Get the underlying endpoint in the native type. 

  data_type * data();



[endsect]



[section:overload2 local::basic_endpoint::data (2 of 2 overloads)]

Get the underlying endpoint in the native type. 

  const data_type * data() const;



[endsect]


[endsect]


[section:data_type local::basic_endpoint::data_type]

[indexterm2 data_type..local::basic_endpoint] The type of the endpoint structure. This type is dependent on the underlying implementation of the socket layer. 

  typedef implementation_defined data_type;




[endsect]



[section:operator_not__eq_ local::basic_endpoint::operator!=]

[indexterm2 operator!=..local::basic_endpoint] Compare two endpoints for inequality. 

  friend bool operator!=(
      const basic_endpoint< Protocol > & e1,
      const basic_endpoint< Protocol > & e2);



[endsect]



[section:operator_lt_ local::basic_endpoint::operator<]

[indexterm2 operator<..local::basic_endpoint] Compare endpoints for ordering. 

  friend bool operator<(
      const basic_endpoint< Protocol > & e1,
      const basic_endpoint< Protocol > & e2);



[endsect]



[section:operator_lt__lt_ local::basic_endpoint::operator<<]

[indexterm2 operator<<..local::basic_endpoint] Output an endpoint as a string. 

  std::basic_ostream< Elem, Traits > & operator<<(
      std::basic_ostream< Elem, Traits > & os,
      const basic_endpoint< Protocol > & endpoint);


Used to output a human-readable string for a specified endpoint.


[heading Parameters]
    

[variablelist
  
[[os][The output stream to which the string will be written.]]

[[endpoint][The endpoint to be written.]]

]

[heading Return Value]
      
The output stream. 



[endsect]



[section:operator_eq_ local::basic_endpoint::operator=]

[indexterm2 operator=..local::basic_endpoint] Assign from another endpoint. 

  basic_endpoint & operator=(
      const basic_endpoint & other);



[endsect]



[section:operator_eq__eq_ local::basic_endpoint::operator==]

[indexterm2 operator==..local::basic_endpoint] Compare two endpoints for equality. 

  friend bool operator==(
      const basic_endpoint< Protocol > & e1,
      const basic_endpoint< Protocol > & e2);



[endsect]


[section:path local::basic_endpoint::path]

[indexterm2 path..local::basic_endpoint] Get the path associated with the endpoint. 

  std::string ``[link boost_asio.reference.local__basic_endpoint.path.overload1 path]``() const;

Set the path associated with the endpoint. 

  void ``[link boost_asio.reference.local__basic_endpoint.path.overload2 path]``(
      const char * p);

  void ``[link boost_asio.reference.local__basic_endpoint.path.overload3 path]``(
      const std::string & p);


[section:overload1 local::basic_endpoint::path (1 of 3 overloads)]

Get the path associated with the endpoint. 

  std::string path() const;



[endsect]



[section:overload2 local::basic_endpoint::path (2 of 3 overloads)]

Set the path associated with the endpoint. 

  void path(
      const char * p);



[endsect]



[section:overload3 local::basic_endpoint::path (3 of 3 overloads)]

Set the path associated with the endpoint. 

  void path(
      const std::string & p);



[endsect]


[endsect]


[section:protocol local::basic_endpoint::protocol]

[indexterm2 protocol..local::basic_endpoint] The protocol associated with the endpoint. 

  protocol_type protocol() const;



[endsect]



[section:protocol_type local::basic_endpoint::protocol_type]

[indexterm2 protocol_type..local::basic_endpoint] The protocol type associated with the endpoint. 

  typedef Protocol protocol_type;




[endsect]



[section:resize local::basic_endpoint::resize]

[indexterm2 resize..local::basic_endpoint] Set the underlying size of the endpoint in the native type. 

  void resize(
      std::size_t size);



[endsect]



[section:size local::basic_endpoint::size]

[indexterm2 size..local::basic_endpoint] Get the underlying size of the endpoint in the native type. 

  std::size_t size() const;



[endsect]



[endsect]

[section:local__connect_pair local::connect_pair]

[indexterm1 local::connect_pair] Create a pair of connected sockets. 
    
  template<
      typename ``[link boost_asio.reference.Protocol Protocol]``,
      typename ``[link boost_asio.reference.SocketService SocketService1]``,
      typename ``[link boost_asio.reference.SocketService SocketService2]``>
  void ``[link boost_asio.reference.local__connect_pair.overload1 connect_pair]``(
      basic_socket< Protocol, SocketService1 > & socket1,
      basic_socket< Protocol, SocketService2 > & socket2);

  template<
      typename ``[link boost_asio.reference.Protocol Protocol]``,
      typename ``[link boost_asio.reference.SocketService SocketService1]``,
      typename ``[link boost_asio.reference.SocketService SocketService2]``>
  boost::system::error_code ``[link boost_asio.reference.local__connect_pair.overload2 connect_pair]``(
      basic_socket< Protocol, SocketService1 > & socket1,
      basic_socket< Protocol, SocketService2 > & socket2,
      boost::system::error_code & ec);


[section:overload1 local::connect_pair (1 of 2 overloads)]

Create a pair of connected sockets. 

  template<
      typename ``[link boost_asio.reference.Protocol Protocol]``,
      typename ``[link boost_asio.reference.SocketService SocketService1]``,
      typename ``[link boost_asio.reference.SocketService SocketService2]``>
  void connect_pair(
      basic_socket< Protocol, SocketService1 > & socket1,
      basic_socket< Protocol, SocketService2 > & socket2);



[endsect]



[section:overload2 local::connect_pair (2 of 2 overloads)]

Create a pair of connected sockets. 

  template<
      typename ``[link boost_asio.reference.Protocol Protocol]``,
      typename ``[link boost_asio.reference.SocketService SocketService1]``,
      typename ``[link boost_asio.reference.SocketService SocketService2]``>
  boost::system::error_code connect_pair(
      basic_socket< Protocol, SocketService1 > & socket1,
      basic_socket< Protocol, SocketService2 > & socket2,
      boost::system::error_code & ec);



[endsect]


[endsect]

[section:local__datagram_protocol local::datagram_protocol]

Encapsulates the flags needed for datagram-oriented UNIX sockets. 

  class datagram_protocol


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.local__datagram_protocol.endpoint [*endpoint]]]
    [The type of a UNIX domain endpoint. ]
  
  ]

  [

    [[link boost_asio.reference.local__datagram_protocol.socket [*socket]]]
    [The UNIX domain socket type. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.local__datagram_protocol.family [*family]]]
    [Obtain an identifier for the protocol family. ]
  ]
  
  [
    [[link boost_asio.reference.local__datagram_protocol.protocol [*protocol]]]
    [Obtain an identifier for the protocol. ]
  ]
  
  [
    [[link boost_asio.reference.local__datagram_protocol.type [*type]]]
    [Obtain an identifier for the type of the protocol. ]
  ]
  
]

The 
[link boost_asio.reference.local__datagram_protocol local::datagram_protocol] class contains flags necessary for datagram-oriented UNIX domain sockets.


[heading Thread Safety]
  
[*Distinct] [*objects:]  Safe.

[*Shared] [*objects:]  Safe.



[section:endpoint local::datagram_protocol::endpoint]

[indexterm2 endpoint..local::datagram_protocol] The type of a UNIX domain endpoint. 

  typedef basic_endpoint< datagram_protocol > endpoint;


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.local__basic_endpoint.data_type [*data_type]]]
    [The type of the endpoint structure. This type is dependent on the underlying implementation of the socket layer. ]
  
  ]

  [

    [[link boost_asio.reference.local__basic_endpoint.protocol_type [*protocol_type]]]
    [The protocol type associated with the endpoint. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.local__basic_endpoint.basic_endpoint [*basic_endpoint]]]
    [Default constructor. 

     Construct an endpoint using the specified path name. 

     Copy constructor. ]
  ]
  
  [
    [[link boost_asio.reference.local__basic_endpoint.capacity [*capacity]]]
    [Get the capacity of the endpoint in the native type. ]
  ]
  
  [
    [[link boost_asio.reference.local__basic_endpoint.data [*data]]]
    [Get the underlying endpoint in the native type. ]
  ]
  
  [
    [[link boost_asio.reference.local__basic_endpoint.operator_eq_ [*operator=]]]
    [Assign from another endpoint. ]
  ]
  
  [
    [[link boost_asio.reference.local__basic_endpoint.path [*path]]]
    [Get the path associated with the endpoint. 

     Set the path associated with the endpoint. ]
  ]
  
  [
    [[link boost_asio.reference.local__basic_endpoint.protocol [*protocol]]]
    [The protocol associated with the endpoint. ]
  ]
  
  [
    [[link boost_asio.reference.local__basic_endpoint.resize [*resize]]]
    [Set the underlying size of the endpoint in the native type. ]
  ]
  
  [
    [[link boost_asio.reference.local__basic_endpoint.size [*size]]]
    [Get the underlying size of the endpoint in the native type. ]
  ]
  
]

[heading Friends]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.local__basic_endpoint.operator_not__eq_ [*operator!=]]]
    [Compare two endpoints for inequality. ]
  ]
  
  [
    [[link boost_asio.reference.local__basic_endpoint.operator_lt_ [*operator<]]]
    [Compare endpoints for ordering. ]
  ]
  
  [
    [[link boost_asio.reference.local__basic_endpoint.operator_eq__eq_ [*operator==]]]
    [Compare two endpoints for equality. ]
  ]
  
]

[heading Related Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.local__basic_endpoint.operator_lt__lt_ [*operator<<]]]
    [Output an endpoint as a string. ]
  ]
  
]

The 
[link boost_asio.reference.local__basic_endpoint local::basic_endpoint] class template describes an endpoint that may be associated with a particular UNIX socket.


[heading Thread Safety]
  
[*Distinct] [*objects:]  Safe.

[*Shared] [*objects:]  Unsafe.




[endsect]



[section:family local::datagram_protocol::family]

[indexterm2 family..local::datagram_protocol] Obtain an identifier for the protocol family. 

  int family() const;



[endsect]



[section:protocol local::datagram_protocol::protocol]

[indexterm2 protocol..local::datagram_protocol] Obtain an identifier for the protocol. 

  int protocol() const;



[endsect]



[section:socket local::datagram_protocol::socket]

[indexterm2 socket..local::datagram_protocol] The UNIX domain socket type. 

  typedef basic_datagram_socket< datagram_protocol > socket;


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.basic_datagram_socket.broadcast [*broadcast]]]
    [Socket option to permit sending of broadcast messages. ]
  
  ]

  [

    [[link boost_asio.reference.basic_datagram_socket.bytes_readable [*bytes_readable]]]
    [IO control command to get the amount of data that can be read without blocking. ]
  
  ]

  [

    [[link boost_asio.reference.basic_datagram_socket.debug [*debug]]]
    [Socket option to enable socket-level debugging. ]
  
  ]

  [

    [[link boost_asio.reference.basic_datagram_socket.do_not_route [*do_not_route]]]
    [Socket option to prevent routing, use local interfaces only. ]
  
  ]

  [

    [[link boost_asio.reference.basic_datagram_socket.enable_connection_aborted [*enable_connection_aborted]]]
    [Socket option to report aborted connections on accept. ]
  
  ]

  [

    [[link boost_asio.reference.basic_datagram_socket.endpoint_type [*endpoint_type]]]
    [The endpoint type. ]
  
  ]

  [

    [[link boost_asio.reference.basic_datagram_socket.implementation_type [*implementation_type]]]
    [The underlying implementation type of I/O object. ]
  
  ]

  [

    [[link boost_asio.reference.basic_datagram_socket.keep_alive [*keep_alive]]]
    [Socket option to send keep-alives. ]
  
  ]

  [

    [[link boost_asio.reference.basic_datagram_socket.linger [*linger]]]
    [Socket option to specify whether the socket lingers on close if unsent data is present. ]
  
  ]

  [

    [[link boost_asio.reference.basic_datagram_socket.lowest_layer_type [*lowest_layer_type]]]
    [A basic_socket is always the lowest layer. ]
  
  ]

  [

    [[link boost_asio.reference.basic_datagram_socket.message_flags [*message_flags]]]
    [Bitmask type for flags that can be passed to send and receive operations. ]
  
  ]

  [

    [[link boost_asio.reference.basic_datagram_socket.native_type [*native_type]]]
    [The native representation of a socket. ]
  
  ]

  [

    [[link boost_asio.reference.basic_datagram_socket.non_blocking_io [*non_blocking_io]]]
    [IO control command to set the blocking mode of the socket. ]
  
  ]

  [

    [[link boost_asio.reference.basic_datagram_socket.protocol_type [*protocol_type]]]
    [The protocol type. ]
  
  ]

  [

    [[link boost_asio.reference.basic_datagram_socket.receive_buffer_size [*receive_buffer_size]]]
    [Socket option for the receive buffer size of a socket. ]
  
  ]

  [

    [[link boost_asio.reference.basic_datagram_socket.receive_low_watermark [*receive_low_watermark]]]
    [Socket option for the receive low watermark. ]
  
  ]

  [

    [[link boost_asio.reference.basic_datagram_socket.reuse_address [*reuse_address]]]
    [Socket option to allow the socket to be bound to an address that is already in use. ]
  
  ]

  [

    [[link boost_asio.reference.basic_datagram_socket.send_buffer_size [*send_buffer_size]]]
    [Socket option for the send buffer size of a socket. ]
  
  ]

  [

    [[link boost_asio.reference.basic_datagram_socket.send_low_watermark [*send_low_watermark]]]
    [Socket option for the send low watermark. ]
  
  ]

  [

    [[link boost_asio.reference.basic_datagram_socket.service_type [*service_type]]]
    [The type of the service that will be used to provide I/O operations. ]
  
  ]

  [

    [[link boost_asio.reference.basic_datagram_socket.shutdown_type [*shutdown_type]]]
    [Different ways a socket may be shutdown. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_datagram_socket.assign [*assign]]]
    [Assign an existing native socket to the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.async_connect [*async_connect]]]
    [Start an asynchronous connect. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.async_receive [*async_receive]]]
    [Start an asynchronous receive on a connected socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.async_receive_from [*async_receive_from]]]
    [Start an asynchronous receive. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.async_send [*async_send]]]
    [Start an asynchronous send on a connected socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.async_send_to [*async_send_to]]]
    [Start an asynchronous send. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.at_mark [*at_mark]]]
    [Determine whether the socket is at the out-of-band data mark. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.available [*available]]]
    [Determine the number of bytes available for reading. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.basic_datagram_socket [*basic_datagram_socket]]]
    [Construct a basic_datagram_socket without opening it. 

     Construct and open a basic_datagram_socket. 

     Construct a basic_datagram_socket, opening it and binding it to the given local endpoint. 

     Construct a basic_datagram_socket on an existing native socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.bind [*bind]]]
    [Bind the socket to the given local endpoint. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.cancel [*cancel]]]
    [Cancel all asynchronous operations associated with the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.close [*close]]]
    [Close the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.connect [*connect]]]
    [Connect the socket to the specified endpoint. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.get_io_service [*get_io_service]]]
    [Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.get_option [*get_option]]]
    [Get an option from the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.io_control [*io_control]]]
    [Perform an IO control command on the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.io_service [*io_service]]]
    [(Deprecated: use get_io_service().) Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.is_open [*is_open]]]
    [Determine whether the socket is open. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.local_endpoint [*local_endpoint]]]
    [Get the local endpoint of the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.lowest_layer [*lowest_layer]]]
    [Get a reference to the lowest layer. 

     Get a const reference to the lowest layer. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.native [*native]]]
    [Get the native socket representation. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.open [*open]]]
    [Open the socket using the specified protocol. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.receive [*receive]]]
    [Receive some data on a connected socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.receive_from [*receive_from]]]
    [Receive a datagram with the endpoint of the sender. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.remote_endpoint [*remote_endpoint]]]
    [Get the remote endpoint of the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.send [*send]]]
    [Send some data on a connected socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.send_to [*send_to]]]
    [Send a datagram to the specified endpoint. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.set_option [*set_option]]]
    [Set an option on the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_datagram_socket.shutdown [*shutdown]]]
    [Disable sends or receives on the socket. ]
  ]
  
]

[heading Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_datagram_socket.max_connections [*max_connections]]]
    [The maximum length of the queue of pending incoming connections. ]
  ]

  [
    [[link boost_asio.reference.basic_datagram_socket.message_do_not_route [*message_do_not_route]]]
    [Specify that the data should not be subject to routing. ]
  ]

  [
    [[link boost_asio.reference.basic_datagram_socket.message_out_of_band [*message_out_of_band]]]
    [Process out-of-band data. ]
  ]

  [
    [[link boost_asio.reference.basic_datagram_socket.message_peek [*message_peek]]]
    [Peek at incoming data without removing it from the input queue. ]
  ]

]

[heading Protected Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_datagram_socket.implementation [*implementation]]]
    [The underlying implementation of the I/O object. ]
  ]

  [
    [[link boost_asio.reference.basic_datagram_socket.service [*service]]]
    [The service associated with the I/O object. ]
  ]

]

The basic_datagram_socket class template provides asynchronous and blocking datagram-oriented socket functionality.


[heading Thread Safety]
  
[*Distinct] [*objects:]  Safe.

[*Shared] [*objects:]  Unsafe. 




[endsect]



[section:type local::datagram_protocol::type]

[indexterm2 type..local::datagram_protocol] Obtain an identifier for the type of the protocol. 

  int type() const;



[endsect]



[endsect]

[section:local__stream_protocol local::stream_protocol]

Encapsulates the flags needed for stream-oriented UNIX sockets. 

  class stream_protocol


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.local__stream_protocol.acceptor [*acceptor]]]
    [The UNIX domain acceptor type. ]
  
  ]

  [

    [[link boost_asio.reference.local__stream_protocol.endpoint [*endpoint]]]
    [The type of a UNIX domain endpoint. ]
  
  ]

  [

    [[link boost_asio.reference.local__stream_protocol.iostream [*iostream]]]
    [The UNIX domain iostream type. ]
  
  ]

  [

    [[link boost_asio.reference.local__stream_protocol.socket [*socket]]]
    [The UNIX domain socket type. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.local__stream_protocol.family [*family]]]
    [Obtain an identifier for the protocol family. ]
  ]
  
  [
    [[link boost_asio.reference.local__stream_protocol.protocol [*protocol]]]
    [Obtain an identifier for the protocol. ]
  ]
  
  [
    [[link boost_asio.reference.local__stream_protocol.type [*type]]]
    [Obtain an identifier for the type of the protocol. ]
  ]
  
]

The 
[link boost_asio.reference.local__stream_protocol local::stream_protocol] class contains flags necessary for stream-oriented UNIX domain sockets.


[heading Thread Safety]
  
[*Distinct] [*objects:]  Safe.

[*Shared] [*objects:]  Safe.



[section:acceptor local::stream_protocol::acceptor]

[indexterm2 acceptor..local::stream_protocol] The UNIX domain acceptor type. 

  typedef basic_socket_acceptor< stream_protocol > acceptor;


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.basic_socket_acceptor.broadcast [*broadcast]]]
    [Socket option to permit sending of broadcast messages. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_acceptor.bytes_readable [*bytes_readable]]]
    [IO control command to get the amount of data that can be read without blocking. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_acceptor.debug [*debug]]]
    [Socket option to enable socket-level debugging. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_acceptor.do_not_route [*do_not_route]]]
    [Socket option to prevent routing, use local interfaces only. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_acceptor.enable_connection_aborted [*enable_connection_aborted]]]
    [Socket option to report aborted connections on accept. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_acceptor.endpoint_type [*endpoint_type]]]
    [The endpoint type. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_acceptor.implementation_type [*implementation_type]]]
    [The underlying implementation type of I/O object. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_acceptor.keep_alive [*keep_alive]]]
    [Socket option to send keep-alives. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_acceptor.linger [*linger]]]
    [Socket option to specify whether the socket lingers on close if unsent data is present. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_acceptor.message_flags [*message_flags]]]
    [Bitmask type for flags that can be passed to send and receive operations. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_acceptor.native_type [*native_type]]]
    [The native representation of an acceptor. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_acceptor.non_blocking_io [*non_blocking_io]]]
    [IO control command to set the blocking mode of the socket. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_acceptor.protocol_type [*protocol_type]]]
    [The protocol type. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_acceptor.receive_buffer_size [*receive_buffer_size]]]
    [Socket option for the receive buffer size of a socket. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_acceptor.receive_low_watermark [*receive_low_watermark]]]
    [Socket option for the receive low watermark. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_acceptor.reuse_address [*reuse_address]]]
    [Socket option to allow the socket to be bound to an address that is already in use. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_acceptor.send_buffer_size [*send_buffer_size]]]
    [Socket option for the send buffer size of a socket. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_acceptor.send_low_watermark [*send_low_watermark]]]
    [Socket option for the send low watermark. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_acceptor.service_type [*service_type]]]
    [The type of the service that will be used to provide I/O operations. ]
  
  ]

  [

    [[link boost_asio.reference.basic_socket_acceptor.shutdown_type [*shutdown_type]]]
    [Different ways a socket may be shutdown. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_socket_acceptor.accept [*accept]]]
    [Accept a new connection. 

     Accept a new connection and obtain the endpoint of the peer. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket_acceptor.assign [*assign]]]
    [Assigns an existing native acceptor to the acceptor. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket_acceptor.async_accept [*async_accept]]]
    [Start an asynchronous accept. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket_acceptor.basic_socket_acceptor [*basic_socket_acceptor]]]
    [Construct an acceptor without opening it. 

     Construct an open acceptor. 

     Construct an acceptor opened on the given endpoint. 

     Construct a basic_socket_acceptor on an existing native acceptor. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket_acceptor.bind [*bind]]]
    [Bind the acceptor to the given local endpoint. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket_acceptor.cancel [*cancel]]]
    [Cancel all asynchronous operations associated with the acceptor. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket_acceptor.close [*close]]]
    [Close the acceptor. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket_acceptor.get_io_service [*get_io_service]]]
    [Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket_acceptor.get_option [*get_option]]]
    [Get an option from the acceptor. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket_acceptor.io_service [*io_service]]]
    [(Deprecated: use get_io_service().) Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket_acceptor.is_open [*is_open]]]
    [Determine whether the acceptor is open. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket_acceptor.listen [*listen]]]
    [Place the acceptor into the state where it will listen for new connections. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket_acceptor.local_endpoint [*local_endpoint]]]
    [Get the local endpoint of the acceptor. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket_acceptor.native [*native]]]
    [Get the native acceptor representation. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket_acceptor.open [*open]]]
    [Open the acceptor using the specified protocol. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket_acceptor.set_option [*set_option]]]
    [Set an option on the acceptor. ]
  ]
  
]

[heading Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_socket_acceptor.max_connections [*max_connections]]]
    [The maximum length of the queue of pending incoming connections. ]
  ]

  [
    [[link boost_asio.reference.basic_socket_acceptor.message_do_not_route [*message_do_not_route]]]
    [Specify that the data should not be subject to routing. ]
  ]

  [
    [[link boost_asio.reference.basic_socket_acceptor.message_out_of_band [*message_out_of_band]]]
    [Process out-of-band data. ]
  ]

  [
    [[link boost_asio.reference.basic_socket_acceptor.message_peek [*message_peek]]]
    [Peek at incoming data without removing it from the input queue. ]
  ]

]

[heading Protected Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_socket_acceptor.implementation [*implementation]]]
    [The underlying implementation of the I/O object. ]
  ]

  [
    [[link boost_asio.reference.basic_socket_acceptor.service [*service]]]
    [The service associated with the I/O object. ]
  ]

]

The basic_socket_acceptor class template is used for accepting new socket connections.


[heading Thread Safety]
  
[*Distinct] [*objects:]  Safe.

[*Shared] [*objects:]  Unsafe.

[heading Example]
  
Opening a socket acceptor with the SO\_REUSEADDR option enabled: 

   boost::asio::ip::tcp::acceptor acceptor(io_service);
   boost::asio::ip::tcp::endpoint endpoint(boost::asio::ip::tcp::v4(), port);
   acceptor.open(endpoint.protocol());
   acceptor.set_option(boost::asio::ip::tcp::acceptor::reuse_address(true));
   acceptor.bind(endpoint);
   acceptor.listen();







[endsect]



[section:endpoint local::stream_protocol::endpoint]

[indexterm2 endpoint..local::stream_protocol] The type of a UNIX domain endpoint. 

  typedef basic_endpoint< stream_protocol > endpoint;


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.local__basic_endpoint.data_type [*data_type]]]
    [The type of the endpoint structure. This type is dependent on the underlying implementation of the socket layer. ]
  
  ]

  [

    [[link boost_asio.reference.local__basic_endpoint.protocol_type [*protocol_type]]]
    [The protocol type associated with the endpoint. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.local__basic_endpoint.basic_endpoint [*basic_endpoint]]]
    [Default constructor. 

     Construct an endpoint using the specified path name. 

     Copy constructor. ]
  ]
  
  [
    [[link boost_asio.reference.local__basic_endpoint.capacity [*capacity]]]
    [Get the capacity of the endpoint in the native type. ]
  ]
  
  [
    [[link boost_asio.reference.local__basic_endpoint.data [*data]]]
    [Get the underlying endpoint in the native type. ]
  ]
  
  [
    [[link boost_asio.reference.local__basic_endpoint.operator_eq_ [*operator=]]]
    [Assign from another endpoint. ]
  ]
  
  [
    [[link boost_asio.reference.local__basic_endpoint.path [*path]]]
    [Get the path associated with the endpoint. 

     Set the path associated with the endpoint. ]
  ]
  
  [
    [[link boost_asio.reference.local__basic_endpoint.protocol [*protocol]]]
    [The protocol associated with the endpoint. ]
  ]
  
  [
    [[link boost_asio.reference.local__basic_endpoint.resize [*resize]]]
    [Set the underlying size of the endpoint in the native type. ]
  ]
  
  [
    [[link boost_asio.reference.local__basic_endpoint.size [*size]]]
    [Get the underlying size of the endpoint in the native type. ]
  ]
  
]

[heading Friends]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.local__basic_endpoint.operator_not__eq_ [*operator!=]]]
    [Compare two endpoints for inequality. ]
  ]
  
  [
    [[link boost_asio.reference.local__basic_endpoint.operator_lt_ [*operator<]]]
    [Compare endpoints for ordering. ]
  ]
  
  [
    [[link boost_asio.reference.local__basic_endpoint.operator_eq__eq_ [*operator==]]]
    [Compare two endpoints for equality. ]
  ]
  
]

[heading Related Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.local__basic_endpoint.operator_lt__lt_ [*operator<<]]]
    [Output an endpoint as a string. ]
  ]
  
]

The 
[link boost_asio.reference.local__basic_endpoint local::basic_endpoint] class template describes an endpoint that may be associated with a particular UNIX socket.


[heading Thread Safety]
  
[*Distinct] [*objects:]  Safe.

[*Shared] [*objects:]  Unsafe.




[endsect]



[section:family local::stream_protocol::family]

[indexterm2 family..local::stream_protocol] Obtain an identifier for the protocol family. 

  int family() const;



[endsect]



[section:iostream local::stream_protocol::iostream]

[indexterm2 iostream..local::stream_protocol] The UNIX domain iostream type. 

  typedef basic_socket_iostream< stream_protocol > iostream;


[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_socket_iostream.basic_socket_iostream [*basic_socket_iostream]]]
    [Construct a basic_socket_iostream without establishing a connection. 

     Establish a connection to an endpoint corresponding to a resolver query. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket_iostream.close [*close]]]
    [Close the connection. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket_iostream.connect [*connect]]]
    [Establish a connection to an endpoint corresponding to a resolver query. ]
  ]
  
  [
    [[link boost_asio.reference.basic_socket_iostream.rdbuf [*rdbuf]]]
    [Return a pointer to the underlying streambuf. ]
  ]
  
]



[endsect]



[section:protocol local::stream_protocol::protocol]

[indexterm2 protocol..local::stream_protocol] Obtain an identifier for the protocol. 

  int protocol() const;



[endsect]



[section:socket local::stream_protocol::socket]

[indexterm2 socket..local::stream_protocol] The UNIX domain socket type. 

  typedef basic_stream_socket< stream_protocol > socket;


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.basic_stream_socket.broadcast [*broadcast]]]
    [Socket option to permit sending of broadcast messages. ]
  
  ]

  [

    [[link boost_asio.reference.basic_stream_socket.bytes_readable [*bytes_readable]]]
    [IO control command to get the amount of data that can be read without blocking. ]
  
  ]

  [

    [[link boost_asio.reference.basic_stream_socket.debug [*debug]]]
    [Socket option to enable socket-level debugging. ]
  
  ]

  [

    [[link boost_asio.reference.basic_stream_socket.do_not_route [*do_not_route]]]
    [Socket option to prevent routing, use local interfaces only. ]
  
  ]

  [

    [[link boost_asio.reference.basic_stream_socket.enable_connection_aborted [*enable_connection_aborted]]]
    [Socket option to report aborted connections on accept. ]
  
  ]

  [

    [[link boost_asio.reference.basic_stream_socket.endpoint_type [*endpoint_type]]]
    [The endpoint type. ]
  
  ]

  [

    [[link boost_asio.reference.basic_stream_socket.implementation_type [*implementation_type]]]
    [The underlying implementation type of I/O object. ]
  
  ]

  [

    [[link boost_asio.reference.basic_stream_socket.keep_alive [*keep_alive]]]
    [Socket option to send keep-alives. ]
  
  ]

  [

    [[link boost_asio.reference.basic_stream_socket.linger [*linger]]]
    [Socket option to specify whether the socket lingers on close if unsent data is present. ]
  
  ]

  [

    [[link boost_asio.reference.basic_stream_socket.lowest_layer_type [*lowest_layer_type]]]
    [A basic_socket is always the lowest layer. ]
  
  ]

  [

    [[link boost_asio.reference.basic_stream_socket.message_flags [*message_flags]]]
    [Bitmask type for flags that can be passed to send and receive operations. ]
  
  ]

  [

    [[link boost_asio.reference.basic_stream_socket.native_type [*native_type]]]
    [The native representation of a socket. ]
  
  ]

  [

    [[link boost_asio.reference.basic_stream_socket.non_blocking_io [*non_blocking_io]]]
    [IO control command to set the blocking mode of the socket. ]
  
  ]

  [

    [[link boost_asio.reference.basic_stream_socket.protocol_type [*protocol_type]]]
    [The protocol type. ]
  
  ]

  [

    [[link boost_asio.reference.basic_stream_socket.receive_buffer_size [*receive_buffer_size]]]
    [Socket option for the receive buffer size of a socket. ]
  
  ]

  [

    [[link boost_asio.reference.basic_stream_socket.receive_low_watermark [*receive_low_watermark]]]
    [Socket option for the receive low watermark. ]
  
  ]

  [

    [[link boost_asio.reference.basic_stream_socket.reuse_address [*reuse_address]]]
    [Socket option to allow the socket to be bound to an address that is already in use. ]
  
  ]

  [

    [[link boost_asio.reference.basic_stream_socket.send_buffer_size [*send_buffer_size]]]
    [Socket option for the send buffer size of a socket. ]
  
  ]

  [

    [[link boost_asio.reference.basic_stream_socket.send_low_watermark [*send_low_watermark]]]
    [Socket option for the send low watermark. ]
  
  ]

  [

    [[link boost_asio.reference.basic_stream_socket.service_type [*service_type]]]
    [The type of the service that will be used to provide I/O operations. ]
  
  ]

  [

    [[link boost_asio.reference.basic_stream_socket.shutdown_type [*shutdown_type]]]
    [Different ways a socket may be shutdown. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_stream_socket.assign [*assign]]]
    [Assign an existing native socket to the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.async_connect [*async_connect]]]
    [Start an asynchronous connect. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.async_read_some [*async_read_some]]]
    [Start an asynchronous read. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.async_receive [*async_receive]]]
    [Start an asynchronous receive. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.async_send [*async_send]]]
    [Start an asynchronous send. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.async_write_some [*async_write_some]]]
    [Start an asynchronous write. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.at_mark [*at_mark]]]
    [Determine whether the socket is at the out-of-band data mark. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.available [*available]]]
    [Determine the number of bytes available for reading. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.basic_stream_socket [*basic_stream_socket]]]
    [Construct a basic_stream_socket without opening it. 

     Construct and open a basic_stream_socket. 

     Construct a basic_stream_socket, opening it and binding it to the given local endpoint. 

     Construct a basic_stream_socket on an existing native socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.bind [*bind]]]
    [Bind the socket to the given local endpoint. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.cancel [*cancel]]]
    [Cancel all asynchronous operations associated with the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.close [*close]]]
    [Close the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.connect [*connect]]]
    [Connect the socket to the specified endpoint. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.get_io_service [*get_io_service]]]
    [Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.get_option [*get_option]]]
    [Get an option from the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.io_control [*io_control]]]
    [Perform an IO control command on the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.io_service [*io_service]]]
    [(Deprecated: use get_io_service().) Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.is_open [*is_open]]]
    [Determine whether the socket is open. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.local_endpoint [*local_endpoint]]]
    [Get the local endpoint of the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.lowest_layer [*lowest_layer]]]
    [Get a reference to the lowest layer. 

     Get a const reference to the lowest layer. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.native [*native]]]
    [Get the native socket representation. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.open [*open]]]
    [Open the socket using the specified protocol. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.read_some [*read_some]]]
    [Read some data from the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.receive [*receive]]]
    [Receive some data on the socket. 

     Receive some data on a connected socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.remote_endpoint [*remote_endpoint]]]
    [Get the remote endpoint of the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.send [*send]]]
    [Send some data on the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.set_option [*set_option]]]
    [Set an option on the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.shutdown [*shutdown]]]
    [Disable sends or receives on the socket. ]
  ]
  
  [
    [[link boost_asio.reference.basic_stream_socket.write_some [*write_some]]]
    [Write some data to the socket. ]
  ]
  
]

[heading Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_stream_socket.max_connections [*max_connections]]]
    [The maximum length of the queue of pending incoming connections. ]
  ]

  [
    [[link boost_asio.reference.basic_stream_socket.message_do_not_route [*message_do_not_route]]]
    [Specify that the data should not be subject to routing. ]
  ]

  [
    [[link boost_asio.reference.basic_stream_socket.message_out_of_band [*message_out_of_band]]]
    [Process out-of-band data. ]
  ]

  [
    [[link boost_asio.reference.basic_stream_socket.message_peek [*message_peek]]]
    [Peek at incoming data without removing it from the input queue. ]
  ]

]

[heading Protected Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_stream_socket.implementation [*implementation]]]
    [The underlying implementation of the I/O object. ]
  ]

  [
    [[link boost_asio.reference.basic_stream_socket.service [*service]]]
    [The service associated with the I/O object. ]
  ]

]

The basic_stream_socket class template provides asynchronous and blocking stream-oriented socket functionality.


[heading Thread Safety]
  
[*Distinct] [*objects:]  Safe.

[*Shared] [*objects:]  Unsafe.




[endsect]



[section:type local::stream_protocol::type]

[indexterm2 type..local::stream_protocol] Obtain an identifier for the type of the protocol. 

  int type() const;



[endsect]



[endsect]

[section:mutable_buffer mutable_buffer]

Holds a buffer that can be modified. 

  class mutable_buffer


[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.mutable_buffer.mutable_buffer [*mutable_buffer]]]
    [Construct an empty buffer. 

     Construct a buffer to represent a given memory range. ]
  ]
  
]

[heading Related Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.mutable_buffer.buffer_cast [*buffer_cast]]]
    [Cast a non-modifiable buffer to a specified pointer to POD type. ]
  ]
  
  [
    [[link boost_asio.reference.mutable_buffer.buffer_size [*buffer_size]]]
    [Get the number of bytes in a non-modifiable buffer. ]
  ]
  
  [
    [[link boost_asio.reference.mutable_buffer.operator_plus_ [*operator+]]]
    [Create a new modifiable buffer that is offset from the start of another. ]
  ]
  
]

The 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. 


[section:buffer_cast mutable_buffer::buffer_cast]

[indexterm2 buffer_cast..mutable_buffer] Cast a non-modifiable buffer to a specified pointer to POD type. 

  template<
      typename PointerToPodType>
  PointerToPodType buffer_cast(
      const mutable_buffer & b);



[endsect]



[section:buffer_size mutable_buffer::buffer_size]

[indexterm2 buffer_size..mutable_buffer] Get the number of bytes in a non-modifiable buffer. 

  std::size_t buffer_size(
      const mutable_buffer & b);



[endsect]


[section:mutable_buffer mutable_buffer::mutable_buffer]

[indexterm2 mutable_buffer..mutable_buffer] Construct an empty buffer. 

  ``[link boost_asio.reference.mutable_buffer.mutable_buffer.overload1 mutable_buffer]``();

Construct a buffer to represent a given memory range. 

  ``[link boost_asio.reference.mutable_buffer.mutable_buffer.overload2 mutable_buffer]``(
      void * data,
      std::size_t size);


[section:overload1 mutable_buffer::mutable_buffer (1 of 2 overloads)]

Construct an empty buffer. 

  mutable_buffer();



[endsect]



[section:overload2 mutable_buffer::mutable_buffer (2 of 2 overloads)]

Construct a buffer to represent a given memory range. 

  mutable_buffer(
      void * data,
      std::size_t size);



[endsect]


[endsect]

[section:operator_plus_ mutable_buffer::operator+]

[indexterm2 operator+..mutable_buffer] Create a new modifiable buffer that is offset from the start of another. 

  mutable_buffer ``[link boost_asio.reference.mutable_buffer.operator_plus_.overload1 operator+]``(
      const mutable_buffer & b,
      std::size_t start);

  mutable_buffer ``[link boost_asio.reference.mutable_buffer.operator_plus_.overload2 operator+]``(
      std::size_t start,
      const mutable_buffer & b);


[section:overload1 mutable_buffer::operator+ (1 of 2 overloads)]

Create a new modifiable buffer that is offset from the start of another. 

  mutable_buffer operator+(
      const mutable_buffer & b,
      std::size_t start);



[endsect]



[section:overload2 mutable_buffer::operator+ (2 of 2 overloads)]

Create a new modifiable buffer that is offset from the start of another. 

  mutable_buffer operator+(
      std::size_t start,
      const mutable_buffer & b);



[endsect]


[endsect]


[endsect]

[section:mutable_buffers_1 mutable_buffers_1]

Adapts a single modifiable buffer so that it meets the requirements of the MutableBufferSequence concept. 

  class mutable_buffers_1 :
    public mutable_buffer


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.mutable_buffers_1.const_iterator [*const_iterator]]]
    [A random-access iterator type that may be used to read elements. ]
  
  ]

  [

    [[link boost_asio.reference.mutable_buffers_1.value_type [*value_type]]]
    [The type for each element in the list of buffers. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.mutable_buffers_1.begin [*begin]]]
    [Get a random-access iterator to the first element. ]
  ]
  
  [
    [[link boost_asio.reference.mutable_buffers_1.end [*end]]]
    [Get a random-access iterator for one past the last element. ]
  ]
  
  [
    [[link boost_asio.reference.mutable_buffers_1.mutable_buffers_1 [*mutable_buffers_1]]]
    [Construct to represent a given memory range. 

     Construct to represent a single modifiable buffer. ]
  ]
  
]

[heading Related Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.mutable_buffers_1.buffer_cast [*buffer_cast]]]
    [Cast a non-modifiable buffer to a specified pointer to POD type. ]
  ]
  
  [
    [[link boost_asio.reference.mutable_buffers_1.buffer_size [*buffer_size]]]
    [Get the number of bytes in a non-modifiable buffer. ]
  ]
  
  [
    [[link boost_asio.reference.mutable_buffers_1.operator_plus_ [*operator+]]]
    [Create a new modifiable buffer that is offset from the start of another. ]
  ]
  
]


[section:begin mutable_buffers_1::begin]

[indexterm2 begin..mutable_buffers_1] Get a random-access iterator to the first element. 

  const_iterator begin() const;



[endsect]



[section:buffer_cast mutable_buffers_1::buffer_cast]


['Inherited from mutable_buffer.]

[indexterm2 buffer_cast..mutable_buffers_1] Cast a non-modifiable buffer to a specified pointer to POD type. 

  template<
      typename PointerToPodType>
  PointerToPodType buffer_cast(
      const mutable_buffer & b);



[endsect]



[section:buffer_size mutable_buffers_1::buffer_size]


['Inherited from mutable_buffer.]

[indexterm2 buffer_size..mutable_buffers_1] Get the number of bytes in a non-modifiable buffer. 

  std::size_t buffer_size(
      const mutable_buffer & b);



[endsect]



[section:const_iterator mutable_buffers_1::const_iterator]

[indexterm2 const_iterator..mutable_buffers_1] A random-access iterator type that may be used to read elements. 

  typedef const mutable_buffer * const_iterator;




[endsect]



[section:end mutable_buffers_1::end]

[indexterm2 end..mutable_buffers_1] Get a random-access iterator for one past the last element. 

  const_iterator end() const;



[endsect]


[section:mutable_buffers_1 mutable_buffers_1::mutable_buffers_1]

[indexterm2 mutable_buffers_1..mutable_buffers_1] Construct to represent a given memory range. 

  ``[link boost_asio.reference.mutable_buffers_1.mutable_buffers_1.overload1 mutable_buffers_1]``(
      void * data,
      std::size_t size);

Construct to represent a single modifiable buffer. 

  ``[link boost_asio.reference.mutable_buffers_1.mutable_buffers_1.overload2 mutable_buffers_1]``(
      const mutable_buffer & b);


[section:overload1 mutable_buffers_1::mutable_buffers_1 (1 of 2 overloads)]

Construct to represent a given memory range. 

  mutable_buffers_1(
      void * data,
      std::size_t size);



[endsect]



[section:overload2 mutable_buffers_1::mutable_buffers_1 (2 of 2 overloads)]

Construct to represent a single modifiable buffer. 

  mutable_buffers_1(
      const mutable_buffer & b);



[endsect]


[endsect]

[section:operator_plus_ mutable_buffers_1::operator+]

[indexterm2 operator+..mutable_buffers_1] Create a new modifiable buffer that is offset from the start of another. 

  mutable_buffer ``[link boost_asio.reference.mutable_buffers_1.operator_plus_.overload1 operator+]``(
      const mutable_buffer & b,
      std::size_t start);

  mutable_buffer ``[link boost_asio.reference.mutable_buffers_1.operator_plus_.overload2 operator+]``(
      std::size_t start,
      const mutable_buffer & b);


[section:overload1 mutable_buffers_1::operator+ (1 of 2 overloads)]


['Inherited from mutable_buffer.]

Create a new modifiable buffer that is offset from the start of another. 

  mutable_buffer operator+(
      const mutable_buffer & b,
      std::size_t start);



[endsect]



[section:overload2 mutable_buffers_1::operator+ (2 of 2 overloads)]


['Inherited from mutable_buffer.]

Create a new modifiable buffer that is offset from the start of another. 

  mutable_buffer operator+(
      std::size_t start,
      const mutable_buffer & b);



[endsect]


[endsect]


[section:value_type mutable_buffers_1::value_type]

[indexterm2 value_type..mutable_buffers_1] The type for each element in the list of buffers. 

  typedef mutable_buffer value_type;


[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.mutable_buffer.mutable_buffer [*mutable_buffer]]]
    [Construct an empty buffer. 

     Construct a buffer to represent a given memory range. ]
  ]
  
]

[heading Related Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.mutable_buffer.buffer_cast [*buffer_cast]]]
    [Cast a non-modifiable buffer to a specified pointer to POD type. ]
  ]
  
  [
    [[link boost_asio.reference.mutable_buffer.buffer_size [*buffer_size]]]
    [Get the number of bytes in a non-modifiable buffer. ]
  ]
  
  [
    [[link boost_asio.reference.mutable_buffer.operator_plus_ [*operator+]]]
    [Create a new modifiable buffer that is offset from the start of another. ]
  ]
  
]

The 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. 



[endsect]



[endsect]

[section:null_buffers null_buffers]

An implementation of both the ConstBufferSequence and MutableBufferSequence concepts to represent a null buffer sequence. 

  class null_buffers


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.null_buffers.const_iterator [*const_iterator]]]
    [A random-access iterator type that may be used to read elements. ]
  
  ]

  [

    [[link boost_asio.reference.null_buffers.value_type [*value_type]]]
    [The type for each element in the list of buffers. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.null_buffers.begin [*begin]]]
    [Get a random-access iterator to the first element. ]
  ]
  
  [
    [[link boost_asio.reference.null_buffers.end [*end]]]
    [Get a random-access iterator for one past the last element. ]
  ]
  
]


[section:begin null_buffers::begin]

[indexterm2 begin..null_buffers] Get a random-access iterator to the first element. 

  const_iterator begin() const;



[endsect]



[section:const_iterator null_buffers::const_iterator]

[indexterm2 const_iterator..null_buffers] A random-access iterator type that may be used to read elements. 

  typedef const mutable_buffer * const_iterator;




[endsect]



[section:end null_buffers::end]

[indexterm2 end..null_buffers] Get a random-access iterator for one past the last element. 

  const_iterator end() const;



[endsect]



[section:value_type null_buffers::value_type]

[indexterm2 value_type..null_buffers] The type for each element in the list of buffers. 

  typedef mutable_buffer value_type;


[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.mutable_buffer.mutable_buffer [*mutable_buffer]]]
    [Construct an empty buffer. 

     Construct a buffer to represent a given memory range. ]
  ]
  
]

[heading Related Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.mutable_buffer.buffer_cast [*buffer_cast]]]
    [Cast a non-modifiable buffer to a specified pointer to POD type. ]
  ]
  
  [
    [[link boost_asio.reference.mutable_buffer.buffer_size [*buffer_size]]]
    [Get the number of bytes in a non-modifiable buffer. ]
  ]
  
  [
    [[link boost_asio.reference.mutable_buffer.operator_plus_ [*operator+]]]
    [Create a new modifiable buffer that is offset from the start of another. ]
  ]
  
]

The 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. 



[endsect]



[endsect]


[section:placeholders__bytes_transferred placeholders::bytes_transferred]

[indexterm1 placeholders::bytes_transferred] An argument placeholder, for use with boost::bind(), that corresponds to the bytes_transferred argument of a handler for asynchronous functions such as boost::asio::basic_stream_socket::async_write_some or boost::asio::async_write. 

  unspecified bytes_transferred;



[endsect]



[section:placeholders__error placeholders::error]

[indexterm1 placeholders::error] An argument placeholder, for use with boost::bind(), that corresponds to the error argument of a handler for any of the asynchronous functions. 

  unspecified error;



[endsect]



[section:placeholders__iterator placeholders::iterator]

[indexterm1 placeholders::iterator] An argument placeholder, for use with boost::bind(), that corresponds to the iterator argument of a handler for asynchronous functions such as boost::asio::basic_resolver::resolve. 

  unspecified iterator;



[endsect]


[section:posix__basic_descriptor posix::basic_descriptor]

Provides POSIX descriptor functionality. 

  template<
      typename ``[link boost_asio.reference.DescriptorService DescriptorService]``>
  class basic_descriptor :
    public basic_io_object< DescriptorService >,
    public posix::descriptor_base


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.posix__basic_descriptor.bytes_readable [*bytes_readable]]]
    [IO control command to get the amount of data that can be read without blocking. ]
  
  ]

  [

    [[link boost_asio.reference.posix__basic_descriptor.implementation_type [*implementation_type]]]
    [The underlying implementation type of I/O object. ]
  
  ]

  [

    [[link boost_asio.reference.posix__basic_descriptor.lowest_layer_type [*lowest_layer_type]]]
    [A basic_descriptor is always the lowest layer. ]
  
  ]

  [

    [[link boost_asio.reference.posix__basic_descriptor.native_type [*native_type]]]
    [The native representation of a descriptor. ]
  
  ]

  [

    [[link boost_asio.reference.posix__basic_descriptor.non_blocking_io [*non_blocking_io]]]
    [IO control command to set the blocking mode of the descriptor. ]
  
  ]

  [

    [[link boost_asio.reference.posix__basic_descriptor.service_type [*service_type]]]
    [The type of the service that will be used to provide I/O operations. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.posix__basic_descriptor.assign [*assign]]]
    [Assign an existing native descriptor to the descriptor. ]
  ]
  
  [
    [[link boost_asio.reference.posix__basic_descriptor.basic_descriptor [*basic_descriptor]]]
    [Construct a basic_descriptor without opening it. 

     Construct a basic_descriptor on an existing native descriptor. ]
  ]
  
  [
    [[link boost_asio.reference.posix__basic_descriptor.cancel [*cancel]]]
    [Cancel all asynchronous operations associated with the descriptor. ]
  ]
  
  [
    [[link boost_asio.reference.posix__basic_descriptor.close [*close]]]
    [Close the descriptor. ]
  ]
  
  [
    [[link boost_asio.reference.posix__basic_descriptor.get_io_service [*get_io_service]]]
    [Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.posix__basic_descriptor.io_control [*io_control]]]
    [Perform an IO control command on the descriptor. ]
  ]
  
  [
    [[link boost_asio.reference.posix__basic_descriptor.io_service [*io_service]]]
    [(Deprecated: use get_io_service().) Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.posix__basic_descriptor.is_open [*is_open]]]
    [Determine whether the descriptor is open. ]
  ]
  
  [
    [[link boost_asio.reference.posix__basic_descriptor.lowest_layer [*lowest_layer]]]
    [Get a reference to the lowest layer. 

     Get a const reference to the lowest layer. ]
  ]
  
  [
    [[link boost_asio.reference.posix__basic_descriptor.native [*native]]]
    [Get the native descriptor representation. ]
  ]
  
]

[heading Protected Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.posix__basic_descriptor._basic_descriptor [*~basic_descriptor]]]
    [Protected destructor to prevent deletion through this type. ]
  ]
  
]

[heading Protected Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.posix__basic_descriptor.implementation [*implementation]]]
    [The underlying implementation of the I/O object. ]
  ]

  [
    [[link boost_asio.reference.posix__basic_descriptor.service [*service]]]
    [The service associated with the I/O object. ]
  ]

]

The posix::basic_descriptor class template provides the ability to wrap a POSIX descriptor.


[heading Thread Safety]
  
[*Distinct] [*objects:]  Safe.

[*Shared] [*objects:]  Unsafe. 


[section:assign posix::basic_descriptor::assign]

[indexterm2 assign..posix::basic_descriptor] Assign an existing native descriptor to the descriptor. 

  void ``[link boost_asio.reference.posix__basic_descriptor.assign.overload1 assign]``(
      const native_type & native_descriptor);

  boost::system::error_code ``[link boost_asio.reference.posix__basic_descriptor.assign.overload2 assign]``(
      const native_type & native_descriptor,
      boost::system::error_code & ec);


[section:overload1 posix::basic_descriptor::assign (1 of 2 overloads)]

Assign an existing native descriptor to the descriptor. 

  void assign(
      const native_type & native_descriptor);



[endsect]



[section:overload2 posix::basic_descriptor::assign (2 of 2 overloads)]

Assign an existing native descriptor to the descriptor. 

  boost::system::error_code assign(
      const native_type & native_descriptor,
      boost::system::error_code & ec);



[endsect]


[endsect]

[section:basic_descriptor posix::basic_descriptor::basic_descriptor]

[indexterm2 basic_descriptor..posix::basic_descriptor] Construct a basic_descriptor without opening it. 

  ``[link boost_asio.reference.posix__basic_descriptor.basic_descriptor.overload1 basic_descriptor]``(
      boost::asio::io_service & io_service);

Construct a basic_descriptor on an existing native descriptor. 

  ``[link boost_asio.reference.posix__basic_descriptor.basic_descriptor.overload2 basic_descriptor]``(
      boost::asio::io_service & io_service,
      const native_type & native_descriptor);


[section:overload1 posix::basic_descriptor::basic_descriptor (1 of 2 overloads)]

Construct a basic_descriptor without opening it. 

  basic_descriptor(
      boost::asio::io_service & io_service);


This constructor creates a descriptor without opening it.


[heading Parameters]
    

[variablelist
  
[[io_service][The io\_service object that the descriptor will use to dispatch handlers for any asynchronous operations performed on the descriptor. ]]

]



[endsect]



[section:overload2 posix::basic_descriptor::basic_descriptor (2 of 2 overloads)]

Construct a basic_descriptor on an existing native descriptor. 

  basic_descriptor(
      boost::asio::io_service & io_service,
      const native_type & native_descriptor);


This constructor creates a descriptor object to hold an existing native descriptor.


[heading Parameters]
    

[variablelist
  
[[io_service][The io\_service object that the descriptor will use to dispatch handlers for any asynchronous operations performed on the descriptor.]]

[[native_descriptor][A native descriptor.]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. ]]

]



[endsect]


[endsect]


[section:bytes_readable posix::basic_descriptor::bytes_readable]


['Inherited from posix::descriptor_base.]

[indexterm2 bytes_readable..posix::basic_descriptor] IO control command to get the amount of data that can be read without blocking. 

  typedef implementation_defined bytes_readable;



Implements the FIONREAD IO control command.


[heading Example]
  


   boost::asio::posix::stream_descriptor descriptor(io_service); 
   ...
   boost::asio::descriptor_base::bytes_readable command(true);
   descriptor.io_control(command);
   std::size_t bytes_readable = command.get();






[endsect]


[section:cancel posix::basic_descriptor::cancel]

[indexterm2 cancel..posix::basic_descriptor] Cancel all asynchronous operations associated with the descriptor. 

  void ``[link boost_asio.reference.posix__basic_descriptor.cancel.overload1 cancel]``();

  boost::system::error_code ``[link boost_asio.reference.posix__basic_descriptor.cancel.overload2 cancel]``(
      boost::system::error_code & ec);


[section:overload1 posix::basic_descriptor::cancel (1 of 2 overloads)]

Cancel all asynchronous operations associated with the descriptor. 

  void cancel();


This 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.


[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. ]]

]



[endsect]



[section:overload2 posix::basic_descriptor::cancel (2 of 2 overloads)]

Cancel all asynchronous operations associated with the descriptor. 

  boost::system::error_code cancel(
      boost::system::error_code & ec);


This 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.


[heading Parameters]
    

[variablelist
  
[[ec][Set to indicate what error occurred, if any. ]]

]



[endsect]


[endsect]

[section:close posix::basic_descriptor::close]

[indexterm2 close..posix::basic_descriptor] Close the descriptor. 

  void ``[link boost_asio.reference.posix__basic_descriptor.close.overload1 close]``();

  boost::system::error_code ``[link boost_asio.reference.posix__basic_descriptor.close.overload2 close]``(
      boost::system::error_code & ec);


[section:overload1 posix::basic_descriptor::close (1 of 2 overloads)]

Close the descriptor. 

  void close();


This 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.


[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. ]]

]



[endsect]



[section:overload2 posix::basic_descriptor::close (2 of 2 overloads)]

Close the descriptor. 

  boost::system::error_code close(
      boost::system::error_code & ec);


This 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.


[heading Parameters]
    

[variablelist
  
[[ec][Set to indicate what error occurred, if any. ]]

]



[endsect]


[endsect]


[section:get_io_service posix::basic_descriptor::get_io_service]


['Inherited from basic_io_object.]

[indexterm2 get_io_service..posix::basic_descriptor] Get the io_service associated with the object. 

  boost::asio::io_service & get_io_service();


This function may be used to obtain the io_service object that the I/O object uses to dispatch handlers for asynchronous operations.


[heading Return Value]
      
A reference to the io_service object that the I/O object will use to dispatch handlers. Ownership is not transferred to the caller. 



[endsect]



[section:implementation posix::basic_descriptor::implementation]


['Inherited from basic_io_object.]

[indexterm2 implementation..posix::basic_descriptor] The underlying implementation of the I/O object. 

  implementation_type implementation;



[endsect]



[section:implementation_type posix::basic_descriptor::implementation_type]


['Inherited from basic_io_object.]

[indexterm2 implementation_type..posix::basic_descriptor] The underlying implementation type of I/O object. 

  typedef service_type::implementation_type implementation_type;




[endsect]


[section:io_control posix::basic_descriptor::io_control]

[indexterm2 io_control..posix::basic_descriptor] Perform an IO control command on the descriptor. 

  template<
      typename ``[link boost_asio.reference.IoControlCommand IoControlCommand]``>
  void ``[link boost_asio.reference.posix__basic_descriptor.io_control.overload1 io_control]``(
      IoControlCommand & command);

  template<
      typename ``[link boost_asio.reference.IoControlCommand IoControlCommand]``>
  boost::system::error_code ``[link boost_asio.reference.posix__basic_descriptor.io_control.overload2 io_control]``(
      IoControlCommand & command,
      boost::system::error_code & ec);


[section:overload1 posix::basic_descriptor::io_control (1 of 2 overloads)]

Perform an IO control command on the descriptor. 

  template<
      typename ``[link boost_asio.reference.IoControlCommand IoControlCommand]``>
  void io_control(
      IoControlCommand & command);


This function is used to execute an IO control command on the descriptor.


[heading Parameters]
    

[variablelist
  
[[command][The IO control command to be performed on the descriptor.]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Example]
  
Getting the number of bytes ready to read: 

   boost::asio::posix::stream_descriptor descriptor(io_service);
   ...
   boost::asio::posix::stream_descriptor::bytes_readable command;
   descriptor.io_control(command);
   std::size_t bytes_readable = command.get();






[endsect]



[section:overload2 posix::basic_descriptor::io_control (2 of 2 overloads)]

Perform an IO control command on the descriptor. 

  template<
      typename ``[link boost_asio.reference.IoControlCommand IoControlCommand]``>
  boost::system::error_code io_control(
      IoControlCommand & command,
      boost::system::error_code & ec);


This function is used to execute an IO control command on the descriptor.


[heading Parameters]
    

[variablelist
  
[[command][The IO control command to be performed on the descriptor.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Example]
  
Getting the number of bytes ready to read: 

   boost::asio::posix::stream_descriptor descriptor(io_service);
   ...
   boost::asio::posix::stream_descriptor::bytes_readable command;
   boost::system::error_code ec;
   descriptor.io_control(command, ec);
   if (ec)
   {
     // An error occurred.
   }
   std::size_t bytes_readable = command.get();






[endsect]


[endsect]


[section:io_service posix::basic_descriptor::io_service]


['Inherited from basic_io_object.]

[indexterm2 io_service..posix::basic_descriptor] (Deprecated: use get_io_service().) Get the io_service associated with the object. 

  boost::asio::io_service & io_service();


This function may be used to obtain the io_service object that the I/O object uses to dispatch handlers for asynchronous operations.


[heading Return Value]
      
A reference to the io_service object that the I/O object will use to dispatch handlers. Ownership is not transferred to the caller. 



[endsect]



[section:is_open posix::basic_descriptor::is_open]

[indexterm2 is_open..posix::basic_descriptor] Determine whether the descriptor is open. 

  bool is_open() const;



[endsect]


[section:lowest_layer posix::basic_descriptor::lowest_layer]

[indexterm2 lowest_layer..posix::basic_descriptor] Get a reference to the lowest layer. 

  lowest_layer_type & ``[link boost_asio.reference.posix__basic_descriptor.lowest_layer.overload1 lowest_layer]``();

Get a const reference to the lowest layer. 

  const lowest_layer_type & ``[link boost_asio.reference.posix__basic_descriptor.lowest_layer.overload2 lowest_layer]``() const;


[section:overload1 posix::basic_descriptor::lowest_layer (1 of 2 overloads)]

Get a reference to the lowest layer. 

  lowest_layer_type & lowest_layer();


This 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.


[heading Return Value]
      
A reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller. 



[endsect]



[section:overload2 posix::basic_descriptor::lowest_layer (2 of 2 overloads)]

Get a const reference to the lowest layer. 

  const lowest_layer_type & lowest_layer() const;


This function returns a const 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.


[heading Return Value]
      
A const reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller. 



[endsect]


[endsect]


[section:lowest_layer_type posix::basic_descriptor::lowest_layer_type]

[indexterm2 lowest_layer_type..posix::basic_descriptor] A basic_descriptor is always the lowest layer. 

  typedef basic_descriptor< DescriptorService > lowest_layer_type;


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.posix__basic_descriptor.bytes_readable [*bytes_readable]]]
    [IO control command to get the amount of data that can be read without blocking. ]
  
  ]

  [

    [[link boost_asio.reference.posix__basic_descriptor.implementation_type [*implementation_type]]]
    [The underlying implementation type of I/O object. ]
  
  ]

  [

    [[link boost_asio.reference.posix__basic_descriptor.lowest_layer_type [*lowest_layer_type]]]
    [A basic_descriptor is always the lowest layer. ]
  
  ]

  [

    [[link boost_asio.reference.posix__basic_descriptor.native_type [*native_type]]]
    [The native representation of a descriptor. ]
  
  ]

  [

    [[link boost_asio.reference.posix__basic_descriptor.non_blocking_io [*non_blocking_io]]]
    [IO control command to set the blocking mode of the descriptor. ]
  
  ]

  [

    [[link boost_asio.reference.posix__basic_descriptor.service_type [*service_type]]]
    [The type of the service that will be used to provide I/O operations. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.posix__basic_descriptor.assign [*assign]]]
    [Assign an existing native descriptor to the descriptor. ]
  ]
  
  [
    [[link boost_asio.reference.posix__basic_descriptor.basic_descriptor [*basic_descriptor]]]
    [Construct a basic_descriptor without opening it. 

     Construct a basic_descriptor on an existing native descriptor. ]
  ]
  
  [
    [[link boost_asio.reference.posix__basic_descriptor.cancel [*cancel]]]
    [Cancel all asynchronous operations associated with the descriptor. ]
  ]
  
  [
    [[link boost_asio.reference.posix__basic_descriptor.close [*close]]]
    [Close the descriptor. ]
  ]
  
  [
    [[link boost_asio.reference.posix__basic_descriptor.get_io_service [*get_io_service]]]
    [Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.posix__basic_descriptor.io_control [*io_control]]]
    [Perform an IO control command on the descriptor. ]
  ]
  
  [
    [[link boost_asio.reference.posix__basic_descriptor.io_service [*io_service]]]
    [(Deprecated: use get_io_service().) Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.posix__basic_descriptor.is_open [*is_open]]]
    [Determine whether the descriptor is open. ]
  ]
  
  [
    [[link boost_asio.reference.posix__basic_descriptor.lowest_layer [*lowest_layer]]]
    [Get a reference to the lowest layer. 

     Get a const reference to the lowest layer. ]
  ]
  
  [
    [[link boost_asio.reference.posix__basic_descriptor.native [*native]]]
    [Get the native descriptor representation. ]
  ]
  
]

[heading Protected Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.posix__basic_descriptor._basic_descriptor [*~basic_descriptor]]]
    [Protected destructor to prevent deletion through this type. ]
  ]
  
]

[heading Protected Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.posix__basic_descriptor.implementation [*implementation]]]
    [The underlying implementation of the I/O object. ]
  ]

  [
    [[link boost_asio.reference.posix__basic_descriptor.service [*service]]]
    [The service associated with the I/O object. ]
  ]

]

The posix::basic_descriptor class template provides the ability to wrap a POSIX descriptor.


[heading Thread Safety]
  
[*Distinct] [*objects:]  Safe.

[*Shared] [*objects:]  Unsafe. 




[endsect]



[section:native posix::basic_descriptor::native]

[indexterm2 native..posix::basic_descriptor] Get the native descriptor representation. 

  native_type native();


This 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. 


[endsect]



[section:native_type posix::basic_descriptor::native_type]

[indexterm2 native_type..posix::basic_descriptor] The native representation of a descriptor. 

  typedef DescriptorService::native_type native_type;




[endsect]



[section:non_blocking_io posix::basic_descriptor::non_blocking_io]


['Inherited from posix::descriptor_base.]

[indexterm2 non_blocking_io..posix::basic_descriptor] IO control command to set the blocking mode of the descriptor. 

  typedef implementation_defined non_blocking_io;



Implements the FIONBIO IO control command.


[heading Example]
  


   boost::asio::posix::stream_descriptor descriptor(io_service); 
   ...
   boost::asio::descriptor_base::non_blocking_io command(true);
   descriptor.io_control(command);






[endsect]



[section:service posix::basic_descriptor::service]


['Inherited from basic_io_object.]

[indexterm2 service..posix::basic_descriptor] The service associated with the I/O object. 

  service_type & service;



[endsect]



[section:service_type posix::basic_descriptor::service_type]


['Inherited from basic_io_object.]

[indexterm2 service_type..posix::basic_descriptor] The type of the service that will be used to provide I/O operations. 

  typedef DescriptorService service_type;




[endsect]



[section:_basic_descriptor posix::basic_descriptor::~basic_descriptor]

[indexterm2 ~basic_descriptor..posix::basic_descriptor] Protected destructor to prevent deletion through this type. 

  ~basic_descriptor();



[endsect]



[endsect]

[section:posix__basic_stream_descriptor posix::basic_stream_descriptor]

Provides stream-oriented descriptor functionality. 

  template<
      typename ``[link boost_asio.reference.StreamDescriptorService StreamDescriptorService]`` = stream_descriptor_service>
  class basic_stream_descriptor :
    public posix::basic_descriptor< StreamDescriptorService >


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.posix__basic_stream_descriptor.bytes_readable [*bytes_readable]]]
    [IO control command to get the amount of data that can be read without blocking. ]
  
  ]

  [

    [[link boost_asio.reference.posix__basic_stream_descriptor.implementation_type [*implementation_type]]]
    [The underlying implementation type of I/O object. ]
  
  ]

  [

    [[link boost_asio.reference.posix__basic_stream_descriptor.lowest_layer_type [*lowest_layer_type]]]
    [A basic_descriptor is always the lowest layer. ]
  
  ]

  [

    [[link boost_asio.reference.posix__basic_stream_descriptor.native_type [*native_type]]]
    [The native representation of a descriptor. ]
  
  ]

  [

    [[link boost_asio.reference.posix__basic_stream_descriptor.non_blocking_io [*non_blocking_io]]]
    [IO control command to set the blocking mode of the descriptor. ]
  
  ]

  [

    [[link boost_asio.reference.posix__basic_stream_descriptor.service_type [*service_type]]]
    [The type of the service that will be used to provide I/O operations. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.posix__basic_stream_descriptor.assign [*assign]]]
    [Assign an existing native descriptor to the descriptor. ]
  ]
  
  [
    [[link boost_asio.reference.posix__basic_stream_descriptor.async_read_some [*async_read_some]]]
    [Start an asynchronous read. ]
  ]
  
  [
    [[link boost_asio.reference.posix__basic_stream_descriptor.async_write_some [*async_write_some]]]
    [Start an asynchronous write. ]
  ]
  
  [
    [[link boost_asio.reference.posix__basic_stream_descriptor.basic_stream_descriptor [*basic_stream_descriptor]]]
    [Construct a basic_stream_descriptor without opening it. 

     Construct a basic_stream_descriptor on an existing native descriptor. ]
  ]
  
  [
    [[link boost_asio.reference.posix__basic_stream_descriptor.cancel [*cancel]]]
    [Cancel all asynchronous operations associated with the descriptor. ]
  ]
  
  [
    [[link boost_asio.reference.posix__basic_stream_descriptor.close [*close]]]
    [Close the descriptor. ]
  ]
  
  [
    [[link boost_asio.reference.posix__basic_stream_descriptor.get_io_service [*get_io_service]]]
    [Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.posix__basic_stream_descriptor.io_control [*io_control]]]
    [Perform an IO control command on the descriptor. ]
  ]
  
  [
    [[link boost_asio.reference.posix__basic_stream_descriptor.io_service [*io_service]]]
    [(Deprecated: use get_io_service().) Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.posix__basic_stream_descriptor.is_open [*is_open]]]
    [Determine whether the descriptor is open. ]
  ]
  
  [
    [[link boost_asio.reference.posix__basic_stream_descriptor.lowest_layer [*lowest_layer]]]
    [Get a reference to the lowest layer. 

     Get a const reference to the lowest layer. ]
  ]
  
  [
    [[link boost_asio.reference.posix__basic_stream_descriptor.native [*native]]]
    [Get the native descriptor representation. ]
  ]
  
  [
    [[link boost_asio.reference.posix__basic_stream_descriptor.read_some [*read_some]]]
    [Read some data from the descriptor. ]
  ]
  
  [
    [[link boost_asio.reference.posix__basic_stream_descriptor.write_some [*write_some]]]
    [Write some data to the descriptor. ]
  ]
  
]

[heading Protected Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.posix__basic_stream_descriptor.implementation [*implementation]]]
    [The underlying implementation of the I/O object. ]
  ]

  [
    [[link boost_asio.reference.posix__basic_stream_descriptor.service [*service]]]
    [The service associated with the I/O object. ]
  ]

]

The posix::basic_stream_descriptor class template provides asynchronous and blocking stream-oriented descriptor functionality.


[heading Thread Safety]
  
[*Distinct] [*objects:]  Safe.

[*Shared] [*objects:]  Unsafe.


[section:assign posix::basic_stream_descriptor::assign]

[indexterm2 assign..posix::basic_stream_descriptor] Assign an existing native descriptor to the descriptor. 

  void ``[link boost_asio.reference.posix__basic_stream_descriptor.assign.overload1 assign]``(
      const native_type & native_descriptor);

  boost::system::error_code ``[link boost_asio.reference.posix__basic_stream_descriptor.assign.overload2 assign]``(
      const native_type & native_descriptor,
      boost::system::error_code & ec);


[section:overload1 posix::basic_stream_descriptor::assign (1 of 2 overloads)]


['Inherited from posix::basic_descriptor.]

Assign an existing native descriptor to the descriptor. 

  void assign(
      const native_type & native_descriptor);



[endsect]



[section:overload2 posix::basic_stream_descriptor::assign (2 of 2 overloads)]


['Inherited from posix::basic_descriptor.]

Assign an existing native descriptor to the descriptor. 

  boost::system::error_code assign(
      const native_type & native_descriptor,
      boost::system::error_code & ec);



[endsect]


[endsect]


[section:async_read_some posix::basic_stream_descriptor::async_read_some]

[indexterm2 async_read_some..posix::basic_stream_descriptor] Start an asynchronous read. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
  void async_read_some(
      const MutableBufferSequence & buffers,
      ReadHandler handler);


This function is used to asynchronously read data from the stream descriptor. The function call always returns immediately.


[heading Parameters]
    

[variablelist
  
[[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.]]

[[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: 
``
   void handler(
     const boost::system::error_code& error, // Result of operation.
     std::size_t bytes_transferred           // Number of bytes read.
   ); 
``
Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using boost::asio::io\_service::post().]]

]

[heading Remarks]
      
The read operation may not read all of the requested number of bytes. Consider using the 
[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.

[heading Example]
  
To read into a single data buffer use the 
[link boost_asio.reference.buffer buffer]  function as follows: 

   descriptor.async_read_some(boost::asio::buffer(data, size), handler);


See the 
[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. 



[endsect]



[section:async_write_some posix::basic_stream_descriptor::async_write_some]

[indexterm2 async_write_some..posix::basic_stream_descriptor] Start an asynchronous write. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
  void async_write_some(
      const ConstBufferSequence & buffers,
      WriteHandler handler);


This function is used to asynchronously write data to the stream descriptor. The function call always returns immediately.


[heading Parameters]
    

[variablelist
  
[[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.]]

[[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: 
``
   void handler(
     const boost::system::error_code& error, // Result of operation.
     std::size_t bytes_transferred           // Number of bytes written.
   ); 
``
Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using boost::asio::io\_service::post().]]

]

[heading Remarks]
      
The write operation may not transmit all of the data to the peer. Consider using the 
[link boost_asio.reference.async_write async_write]  function if you need to ensure that all data is written before the asynchronous operation completes.

[heading Example]
  
To write a single data buffer use the 
[link boost_asio.reference.buffer buffer]  function as follows: 

   descriptor.async_write_some(boost::asio::buffer(data, size), handler);


See the 
[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. 



[endsect]


[section:basic_stream_descriptor posix::basic_stream_descriptor::basic_stream_descriptor]

[indexterm2 basic_stream_descriptor..posix::basic_stream_descriptor] Construct a basic_stream_descriptor without opening it. 

  ``[link boost_asio.reference.posix__basic_stream_descriptor.basic_stream_descriptor.overload1 basic_stream_descriptor]``(
      boost::asio::io_service & io_service);

Construct a basic_stream_descriptor on an existing native descriptor. 

  ``[link boost_asio.reference.posix__basic_stream_descriptor.basic_stream_descriptor.overload2 basic_stream_descriptor]``(
      boost::asio::io_service & io_service,
      const native_type & native_descriptor);


[section:overload1 posix::basic_stream_descriptor::basic_stream_descriptor (1 of 2 overloads)]

Construct a basic_stream_descriptor without opening it. 

  basic_stream_descriptor(
      boost::asio::io_service & io_service);


This 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.


[heading Parameters]
    

[variablelist
  
[[io_service][The io\_service object that the stream descriptor will use to dispatch handlers for any asynchronous operations performed on the descriptor. ]]

]



[endsect]



[section:overload2 posix::basic_stream_descriptor::basic_stream_descriptor (2 of 2 overloads)]

Construct a basic_stream_descriptor on an existing native descriptor. 

  basic_stream_descriptor(
      boost::asio::io_service & io_service,
      const native_type & native_descriptor);


This constructor creates a stream descriptor object to hold an existing native descriptor.


[heading Parameters]
    

[variablelist
  
[[io_service][The io\_service object that the stream descriptor will use to dispatch handlers for any asynchronous operations performed on the descriptor.]]

[[native_descriptor][The new underlying descriptor implementation.]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. ]]

]



[endsect]


[endsect]


[section:bytes_readable posix::basic_stream_descriptor::bytes_readable]


['Inherited from posix::descriptor_base.]

[indexterm2 bytes_readable..posix::basic_stream_descriptor] IO control command to get the amount of data that can be read without blocking. 

  typedef implementation_defined bytes_readable;



Implements the FIONREAD IO control command.


[heading Example]
  


   boost::asio::posix::stream_descriptor descriptor(io_service); 
   ...
   boost::asio::descriptor_base::bytes_readable command(true);
   descriptor.io_control(command);
   std::size_t bytes_readable = command.get();






[endsect]


[section:cancel posix::basic_stream_descriptor::cancel]

[indexterm2 cancel..posix::basic_stream_descriptor] Cancel all asynchronous operations associated with the descriptor. 

  void ``[link boost_asio.reference.posix__basic_stream_descriptor.cancel.overload1 cancel]``();

  boost::system::error_code ``[link boost_asio.reference.posix__basic_stream_descriptor.cancel.overload2 cancel]``(
      boost::system::error_code & ec);


[section:overload1 posix::basic_stream_descriptor::cancel (1 of 2 overloads)]


['Inherited from posix::basic_descriptor.]

Cancel all asynchronous operations associated with the descriptor. 

  void cancel();


This 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.


[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. ]]

]



[endsect]



[section:overload2 posix::basic_stream_descriptor::cancel (2 of 2 overloads)]


['Inherited from posix::basic_descriptor.]

Cancel all asynchronous operations associated with the descriptor. 

  boost::system::error_code cancel(
      boost::system::error_code & ec);


This 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.


[heading Parameters]
    

[variablelist
  
[[ec][Set to indicate what error occurred, if any. ]]

]



[endsect]


[endsect]

[section:close posix::basic_stream_descriptor::close]

[indexterm2 close..posix::basic_stream_descriptor] Close the descriptor. 

  void ``[link boost_asio.reference.posix__basic_stream_descriptor.close.overload1 close]``();

  boost::system::error_code ``[link boost_asio.reference.posix__basic_stream_descriptor.close.overload2 close]``(
      boost::system::error_code & ec);


[section:overload1 posix::basic_stream_descriptor::close (1 of 2 overloads)]


['Inherited from posix::basic_descriptor.]

Close the descriptor. 

  void close();


This 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.


[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. ]]

]



[endsect]



[section:overload2 posix::basic_stream_descriptor::close (2 of 2 overloads)]


['Inherited from posix::basic_descriptor.]

Close the descriptor. 

  boost::system::error_code close(
      boost::system::error_code & ec);


This 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.


[heading Parameters]
    

[variablelist
  
[[ec][Set to indicate what error occurred, if any. ]]

]



[endsect]


[endsect]


[section:get_io_service posix::basic_stream_descriptor::get_io_service]


['Inherited from basic_io_object.]

[indexterm2 get_io_service..posix::basic_stream_descriptor] Get the io_service associated with the object. 

  boost::asio::io_service & get_io_service();


This function may be used to obtain the io_service object that the I/O object uses to dispatch handlers for asynchronous operations.


[heading Return Value]
      
A reference to the io_service object that the I/O object will use to dispatch handlers. Ownership is not transferred to the caller. 



[endsect]



[section:implementation posix::basic_stream_descriptor::implementation]


['Inherited from basic_io_object.]

[indexterm2 implementation..posix::basic_stream_descriptor] The underlying implementation of the I/O object. 

  implementation_type implementation;



[endsect]



[section:implementation_type posix::basic_stream_descriptor::implementation_type]


['Inherited from basic_io_object.]

[indexterm2 implementation_type..posix::basic_stream_descriptor] The underlying implementation type of I/O object. 

  typedef service_type::implementation_type implementation_type;




[endsect]


[section:io_control posix::basic_stream_descriptor::io_control]

[indexterm2 io_control..posix::basic_stream_descriptor] Perform an IO control command on the descriptor. 

  void ``[link boost_asio.reference.posix__basic_stream_descriptor.io_control.overload1 io_control]``(
      IoControlCommand & command);

  boost::system::error_code ``[link boost_asio.reference.posix__basic_stream_descriptor.io_control.overload2 io_control]``(
      IoControlCommand & command,
      boost::system::error_code & ec);


[section:overload1 posix::basic_stream_descriptor::io_control (1 of 2 overloads)]


['Inherited from posix::basic_descriptor.]

Perform an IO control command on the descriptor. 

  void io_control(
      IoControlCommand & command);


This function is used to execute an IO control command on the descriptor.


[heading Parameters]
    

[variablelist
  
[[command][The IO control command to be performed on the descriptor.]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Example]
  
Getting the number of bytes ready to read: 

   boost::asio::posix::stream_descriptor descriptor(io_service);
   ...
   boost::asio::posix::stream_descriptor::bytes_readable command;
   descriptor.io_control(command);
   std::size_t bytes_readable = command.get();






[endsect]



[section:overload2 posix::basic_stream_descriptor::io_control (2 of 2 overloads)]


['Inherited from posix::basic_descriptor.]

Perform an IO control command on the descriptor. 

  boost::system::error_code io_control(
      IoControlCommand & command,
      boost::system::error_code & ec);


This function is used to execute an IO control command on the descriptor.


[heading Parameters]
    

[variablelist
  
[[command][The IO control command to be performed on the descriptor.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Example]
  
Getting the number of bytes ready to read: 

   boost::asio::posix::stream_descriptor descriptor(io_service);
   ...
   boost::asio::posix::stream_descriptor::bytes_readable command;
   boost::system::error_code ec;
   descriptor.io_control(command, ec);
   if (ec)
   {
     // An error occurred.
   }
   std::size_t bytes_readable = command.get();






[endsect]


[endsect]


[section:io_service posix::basic_stream_descriptor::io_service]


['Inherited from basic_io_object.]

[indexterm2 io_service..posix::basic_stream_descriptor] (Deprecated: use get_io_service().) Get the io_service associated with the object. 

  boost::asio::io_service & io_service();


This function may be used to obtain the io_service object that the I/O object uses to dispatch handlers for asynchronous operations.


[heading Return Value]
      
A reference to the io_service object that the I/O object will use to dispatch handlers. Ownership is not transferred to the caller. 



[endsect]



[section:is_open posix::basic_stream_descriptor::is_open]


['Inherited from posix::basic_descriptor.]

[indexterm2 is_open..posix::basic_stream_descriptor] Determine whether the descriptor is open. 

  bool is_open() const;



[endsect]


[section:lowest_layer posix::basic_stream_descriptor::lowest_layer]

[indexterm2 lowest_layer..posix::basic_stream_descriptor] Get a reference to the lowest layer. 

  lowest_layer_type & ``[link boost_asio.reference.posix__basic_stream_descriptor.lowest_layer.overload1 lowest_layer]``();

Get a const reference to the lowest layer. 

  const lowest_layer_type & ``[link boost_asio.reference.posix__basic_stream_descriptor.lowest_layer.overload2 lowest_layer]``() const;


[section:overload1 posix::basic_stream_descriptor::lowest_layer (1 of 2 overloads)]


['Inherited from posix::basic_descriptor.]

Get a reference to the lowest layer. 

  lowest_layer_type & lowest_layer();


This 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.


[heading Return Value]
      
A reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller. 



[endsect]



[section:overload2 posix::basic_stream_descriptor::lowest_layer (2 of 2 overloads)]


['Inherited from posix::basic_descriptor.]

Get a const reference to the lowest layer. 

  const lowest_layer_type & lowest_layer() const;


This function returns a const 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.


[heading Return Value]
      
A const reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller. 



[endsect]


[endsect]


[section:lowest_layer_type posix::basic_stream_descriptor::lowest_layer_type]


['Inherited from posix::basic_descriptor.]

[indexterm2 lowest_layer_type..posix::basic_stream_descriptor] A basic_descriptor is always the lowest layer. 

  typedef basic_descriptor< StreamDescriptorService > lowest_layer_type;


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.posix__basic_descriptor.bytes_readable [*bytes_readable]]]
    [IO control command to get the amount of data that can be read without blocking. ]
  
  ]

  [

    [[link boost_asio.reference.posix__basic_descriptor.implementation_type [*implementation_type]]]
    [The underlying implementation type of I/O object. ]
  
  ]

  [

    [[link boost_asio.reference.posix__basic_descriptor.lowest_layer_type [*lowest_layer_type]]]
    [A basic_descriptor is always the lowest layer. ]
  
  ]

  [

    [[link boost_asio.reference.posix__basic_descriptor.native_type [*native_type]]]
    [The native representation of a descriptor. ]
  
  ]

  [

    [[link boost_asio.reference.posix__basic_descriptor.non_blocking_io [*non_blocking_io]]]
    [IO control command to set the blocking mode of the descriptor. ]
  
  ]

  [

    [[link boost_asio.reference.posix__basic_descriptor.service_type [*service_type]]]
    [The type of the service that will be used to provide I/O operations. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.posix__basic_descriptor.assign [*assign]]]
    [Assign an existing native descriptor to the descriptor. ]
  ]
  
  [
    [[link boost_asio.reference.posix__basic_descriptor.basic_descriptor [*basic_descriptor]]]
    [Construct a basic_descriptor without opening it. 

     Construct a basic_descriptor on an existing native descriptor. ]
  ]
  
  [
    [[link boost_asio.reference.posix__basic_descriptor.cancel [*cancel]]]
    [Cancel all asynchronous operations associated with the descriptor. ]
  ]
  
  [
    [[link boost_asio.reference.posix__basic_descriptor.close [*close]]]
    [Close the descriptor. ]
  ]
  
  [
    [[link boost_asio.reference.posix__basic_descriptor.get_io_service [*get_io_service]]]
    [Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.posix__basic_descriptor.io_control [*io_control]]]
    [Perform an IO control command on the descriptor. ]
  ]
  
  [
    [[link boost_asio.reference.posix__basic_descriptor.io_service [*io_service]]]
    [(Deprecated: use get_io_service().) Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.posix__basic_descriptor.is_open [*is_open]]]
    [Determine whether the descriptor is open. ]
  ]
  
  [
    [[link boost_asio.reference.posix__basic_descriptor.lowest_layer [*lowest_layer]]]
    [Get a reference to the lowest layer. 

     Get a const reference to the lowest layer. ]
  ]
  
  [
    [[link boost_asio.reference.posix__basic_descriptor.native [*native]]]
    [Get the native descriptor representation. ]
  ]
  
]

[heading Protected Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.posix__basic_descriptor._basic_descriptor [*~basic_descriptor]]]
    [Protected destructor to prevent deletion through this type. ]
  ]
  
]

[heading Protected Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.posix__basic_descriptor.implementation [*implementation]]]
    [The underlying implementation of the I/O object. ]
  ]

  [
    [[link boost_asio.reference.posix__basic_descriptor.service [*service]]]
    [The service associated with the I/O object. ]
  ]

]

The posix::basic_descriptor class template provides the ability to wrap a POSIX descriptor.


[heading Thread Safety]
  
[*Distinct] [*objects:]  Safe.

[*Shared] [*objects:]  Unsafe. 




[endsect]



[section:native posix::basic_stream_descriptor::native]


['Inherited from posix::basic_descriptor.]

[indexterm2 native..posix::basic_stream_descriptor] Get the native descriptor representation. 

  native_type native();


This 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. 


[endsect]



[section:native_type posix::basic_stream_descriptor::native_type]

[indexterm2 native_type..posix::basic_stream_descriptor] The native representation of a descriptor. 

  typedef StreamDescriptorService::native_type native_type;




[endsect]



[section:non_blocking_io posix::basic_stream_descriptor::non_blocking_io]


['Inherited from posix::descriptor_base.]

[indexterm2 non_blocking_io..posix::basic_stream_descriptor] IO control command to set the blocking mode of the descriptor. 

  typedef implementation_defined non_blocking_io;



Implements the FIONBIO IO control command.


[heading Example]
  


   boost::asio::posix::stream_descriptor descriptor(io_service); 
   ...
   boost::asio::descriptor_base::non_blocking_io command(true);
   descriptor.io_control(command);






[endsect]


[section:read_some posix::basic_stream_descriptor::read_some]

[indexterm2 read_some..posix::basic_stream_descriptor] Read some data from the descriptor. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t ``[link boost_asio.reference.posix__basic_stream_descriptor.read_some.overload1 read_some]``(
      const MutableBufferSequence & buffers);

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t ``[link boost_asio.reference.posix__basic_stream_descriptor.read_some.overload2 read_some]``(
      const MutableBufferSequence & buffers,
      boost::system::error_code & ec);


[section:overload1 posix::basic_stream_descriptor::read_some (1 of 2 overloads)]

Read some data from the descriptor. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t read_some(
      const MutableBufferSequence & buffers);


This 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.


[heading Parameters]
    

[variablelist
  
[[buffers][One or more buffers into which the data will be read.]]

]

[heading Return Value]
      
The number of bytes read.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. An error code of boost::asio::error::eof indicates that the connection was closed by the peer.]]

]

[heading Remarks]
      
The read\_some operation may not read all of the requested number of bytes. Consider using the 
[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.

[heading Example]
  
To read into a single data buffer use the 
[link boost_asio.reference.buffer buffer]  function as follows: 

   descriptor.read_some(boost::asio::buffer(data, size));


See the 
[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. 



[endsect]



[section:overload2 posix::basic_stream_descriptor::read_some (2 of 2 overloads)]

Read some data from the descriptor. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t read_some(
      const MutableBufferSequence & buffers,
      boost::system::error_code & ec);


This 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.


[heading Parameters]
    

[variablelist
  
[[buffers][One or more buffers into which the data will be read.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Return Value]
      
The number of bytes read. Returns 0 if an error occurred.

[heading Remarks]
      
The read\_some operation may not read all of the requested number of bytes. Consider using the 
[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. 



[endsect]


[endsect]


[section:service posix::basic_stream_descriptor::service]


['Inherited from basic_io_object.]

[indexterm2 service..posix::basic_stream_descriptor] The service associated with the I/O object. 

  service_type & service;



[endsect]



[section:service_type posix::basic_stream_descriptor::service_type]


['Inherited from basic_io_object.]

[indexterm2 service_type..posix::basic_stream_descriptor] The type of the service that will be used to provide I/O operations. 

  typedef StreamDescriptorService service_type;




[endsect]


[section:write_some posix::basic_stream_descriptor::write_some]

[indexterm2 write_some..posix::basic_stream_descriptor] Write some data to the descriptor. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t ``[link boost_asio.reference.posix__basic_stream_descriptor.write_some.overload1 write_some]``(
      const ConstBufferSequence & buffers);

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t ``[link boost_asio.reference.posix__basic_stream_descriptor.write_some.overload2 write_some]``(
      const ConstBufferSequence & buffers,
      boost::system::error_code & ec);


[section:overload1 posix::basic_stream_descriptor::write_some (1 of 2 overloads)]

Write some data to the descriptor. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t write_some(
      const ConstBufferSequence & buffers);


This 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.


[heading Parameters]
    

[variablelist
  
[[buffers][One or more data buffers to be written to the descriptor.]]

]

[heading Return Value]
      
The number of bytes written.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. An error code of boost::asio::error::eof indicates that the connection was closed by the peer.]]

]

[heading Remarks]
      
The write\_some operation may not transmit all of the data to the peer. Consider using the 
[link boost_asio.reference.write write]  function if you need to ensure that all data is written before the blocking operation completes.

[heading Example]
  
To write a single data buffer use the 
[link boost_asio.reference.buffer buffer]  function as follows: 

   descriptor.write_some(boost::asio::buffer(data, size));


See the 
[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. 



[endsect]



[section:overload2 posix::basic_stream_descriptor::write_some (2 of 2 overloads)]

Write some data to the descriptor. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t write_some(
      const ConstBufferSequence & buffers,
      boost::system::error_code & ec);


This 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.


[heading Parameters]
    

[variablelist
  
[[buffers][One or more data buffers to be written to the descriptor.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Return Value]
      
The number of bytes written. Returns 0 if an error occurred.

[heading Remarks]
      
The write\_some operation may not transmit all of the data to the peer. Consider using the 
[link boost_asio.reference.write write]  function if you need to ensure that all data is written before the blocking operation completes. 



[endsect]


[endsect]


[endsect]

[section:posix__descriptor_base posix::descriptor_base]

The 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. 

  class descriptor_base


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.posix__descriptor_base.bytes_readable [*bytes_readable]]]
    [IO control command to get the amount of data that can be read without blocking. ]
  
  ]

  [

    [[link boost_asio.reference.posix__descriptor_base.non_blocking_io [*non_blocking_io]]]
    [IO control command to set the blocking mode of the descriptor. ]
  
  ]

]

[heading Protected Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.posix__descriptor_base._descriptor_base [*~descriptor_base]]]
    [Protected destructor to prevent deletion through this type. ]
  ]
  
]


[section:bytes_readable posix::descriptor_base::bytes_readable]

[indexterm2 bytes_readable..posix::descriptor_base] IO control command to get the amount of data that can be read without blocking. 

  typedef implementation_defined bytes_readable;



Implements the FIONREAD IO control command.


[heading Example]
  


   boost::asio::posix::stream_descriptor descriptor(io_service); 
   ...
   boost::asio::descriptor_base::bytes_readable command(true);
   descriptor.io_control(command);
   std::size_t bytes_readable = command.get();






[endsect]



[section:non_blocking_io posix::descriptor_base::non_blocking_io]

[indexterm2 non_blocking_io..posix::descriptor_base] IO control command to set the blocking mode of the descriptor. 

  typedef implementation_defined non_blocking_io;



Implements the FIONBIO IO control command.


[heading Example]
  


   boost::asio::posix::stream_descriptor descriptor(io_service); 
   ...
   boost::asio::descriptor_base::non_blocking_io command(true);
   descriptor.io_control(command);






[endsect]



[section:_descriptor_base posix::descriptor_base::~descriptor_base]

[indexterm2 ~descriptor_base..posix::descriptor_base] Protected destructor to prevent deletion through this type. 

  ~descriptor_base();



[endsect]



[endsect]


[section:posix__stream_descriptor posix::stream_descriptor]

[indexterm1 posix::stream_descriptor] Typedef for the typical usage of a stream-oriented descriptor. 

  typedef basic_stream_descriptor stream_descriptor;


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.posix__basic_stream_descriptor.bytes_readable [*bytes_readable]]]
    [IO control command to get the amount of data that can be read without blocking. ]
  
  ]

  [

    [[link boost_asio.reference.posix__basic_stream_descriptor.implementation_type [*implementation_type]]]
    [The underlying implementation type of I/O object. ]
  
  ]

  [

    [[link boost_asio.reference.posix__basic_stream_descriptor.lowest_layer_type [*lowest_layer_type]]]
    [A basic_descriptor is always the lowest layer. ]
  
  ]

  [

    [[link boost_asio.reference.posix__basic_stream_descriptor.native_type [*native_type]]]
    [The native representation of a descriptor. ]
  
  ]

  [

    [[link boost_asio.reference.posix__basic_stream_descriptor.non_blocking_io [*non_blocking_io]]]
    [IO control command to set the blocking mode of the descriptor. ]
  
  ]

  [

    [[link boost_asio.reference.posix__basic_stream_descriptor.service_type [*service_type]]]
    [The type of the service that will be used to provide I/O operations. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.posix__basic_stream_descriptor.assign [*assign]]]
    [Assign an existing native descriptor to the descriptor. ]
  ]
  
  [
    [[link boost_asio.reference.posix__basic_stream_descriptor.async_read_some [*async_read_some]]]
    [Start an asynchronous read. ]
  ]
  
  [
    [[link boost_asio.reference.posix__basic_stream_descriptor.async_write_some [*async_write_some]]]
    [Start an asynchronous write. ]
  ]
  
  [
    [[link boost_asio.reference.posix__basic_stream_descriptor.basic_stream_descriptor [*basic_stream_descriptor]]]
    [Construct a basic_stream_descriptor without opening it. 

     Construct a basic_stream_descriptor on an existing native descriptor. ]
  ]
  
  [
    [[link boost_asio.reference.posix__basic_stream_descriptor.cancel [*cancel]]]
    [Cancel all asynchronous operations associated with the descriptor. ]
  ]
  
  [
    [[link boost_asio.reference.posix__basic_stream_descriptor.close [*close]]]
    [Close the descriptor. ]
  ]
  
  [
    [[link boost_asio.reference.posix__basic_stream_descriptor.get_io_service [*get_io_service]]]
    [Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.posix__basic_stream_descriptor.io_control [*io_control]]]
    [Perform an IO control command on the descriptor. ]
  ]
  
  [
    [[link boost_asio.reference.posix__basic_stream_descriptor.io_service [*io_service]]]
    [(Deprecated: use get_io_service().) Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.posix__basic_stream_descriptor.is_open [*is_open]]]
    [Determine whether the descriptor is open. ]
  ]
  
  [
    [[link boost_asio.reference.posix__basic_stream_descriptor.lowest_layer [*lowest_layer]]]
    [Get a reference to the lowest layer. 

     Get a const reference to the lowest layer. ]
  ]
  
  [
    [[link boost_asio.reference.posix__basic_stream_descriptor.native [*native]]]
    [Get the native descriptor representation. ]
  ]
  
  [
    [[link boost_asio.reference.posix__basic_stream_descriptor.read_some [*read_some]]]
    [Read some data from the descriptor. ]
  ]
  
  [
    [[link boost_asio.reference.posix__basic_stream_descriptor.write_some [*write_some]]]
    [Write some data to the descriptor. ]
  ]
  
]

[heading Protected Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.posix__basic_stream_descriptor.implementation [*implementation]]]
    [The underlying implementation of the I/O object. ]
  ]

  [
    [[link boost_asio.reference.posix__basic_stream_descriptor.service [*service]]]
    [The service associated with the I/O object. ]
  ]

]

The posix::basic_stream_descriptor class template provides asynchronous and blocking stream-oriented descriptor functionality.


[heading Thread Safety]
  
[*Distinct] [*objects:]  Safe.

[*Shared] [*objects:]  Unsafe.




[endsect]


[section:posix__stream_descriptor_service posix::stream_descriptor_service]

Default service implementation for a stream descriptor. 

  class stream_descriptor_service :
    public io_service::service


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.posix__stream_descriptor_service.implementation_type [*implementation_type]]]
    [The type of a stream descriptor implementation. ]
  
  ]

  [

    [[link boost_asio.reference.posix__stream_descriptor_service.native_type [*native_type]]]
    [The native descriptor type. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.posix__stream_descriptor_service.assign [*assign]]]
    [Assign an existing native descriptor to a stream descriptor. ]
  ]
  
  [
    [[link boost_asio.reference.posix__stream_descriptor_service.async_read_some [*async_read_some]]]
    [Start an asynchronous read. ]
  ]
  
  [
    [[link boost_asio.reference.posix__stream_descriptor_service.async_write_some [*async_write_some]]]
    [Start an asynchronous write. ]
  ]
  
  [
    [[link boost_asio.reference.posix__stream_descriptor_service.cancel [*cancel]]]
    [Cancel all asynchronous operations associated with the descriptor. ]
  ]
  
  [
    [[link boost_asio.reference.posix__stream_descriptor_service.close [*close]]]
    [Close a stream descriptor implementation. ]
  ]
  
  [
    [[link boost_asio.reference.posix__stream_descriptor_service.construct [*construct]]]
    [Construct a new stream descriptor implementation. ]
  ]
  
  [
    [[link boost_asio.reference.posix__stream_descriptor_service.destroy [*destroy]]]
    [Destroy a stream descriptor implementation. ]
  ]
  
  [
    [[link boost_asio.reference.posix__stream_descriptor_service.get_io_service [*get_io_service]]]
    [Get the io_service object that owns the service. ]
  ]
  
  [
    [[link boost_asio.reference.posix__stream_descriptor_service.io_control [*io_control]]]
    [Perform an IO control command on the descriptor. ]
  ]
  
  [
    [[link boost_asio.reference.posix__stream_descriptor_service.io_service [*io_service]]]
    [(Deprecated: use get_io_service().) Get the io_service object that owns the service. ]
  ]
  
  [
    [[link boost_asio.reference.posix__stream_descriptor_service.is_open [*is_open]]]
    [Determine whether the descriptor is open. ]
  ]
  
  [
    [[link boost_asio.reference.posix__stream_descriptor_service.native [*native]]]
    [Get the native descriptor implementation. ]
  ]
  
  [
    [[link boost_asio.reference.posix__stream_descriptor_service.read_some [*read_some]]]
    [Read some data from the stream. ]
  ]
  
  [
    [[link boost_asio.reference.posix__stream_descriptor_service.shutdown_service [*shutdown_service]]]
    [Destroy all user-defined descriptorr objects owned by the service. ]
  ]
  
  [
    [[link boost_asio.reference.posix__stream_descriptor_service.stream_descriptor_service [*stream_descriptor_service]]]
    [Construct a new stream descriptor service for the specified io_service. ]
  ]
  
  [
    [[link boost_asio.reference.posix__stream_descriptor_service.write_some [*write_some]]]
    [Write the given data to the stream. ]
  ]
  
]

[heading Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.posix__stream_descriptor_service.id [*id]]]
    [The unique service identifier. ]
  ]

]


[section:assign posix::stream_descriptor_service::assign]

[indexterm2 assign..posix::stream_descriptor_service] Assign an existing native descriptor to a stream descriptor. 

  boost::system::error_code assign(
      implementation_type & impl,
      const native_type & native_descriptor,
      boost::system::error_code & ec);



[endsect]



[section:async_read_some posix::stream_descriptor_service::async_read_some]

[indexterm2 async_read_some..posix::stream_descriptor_service] Start an asynchronous read. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
  void async_read_some(
      implementation_type & impl,
      const MutableBufferSequence & buffers,
      ReadHandler descriptorr);



[endsect]



[section:async_write_some posix::stream_descriptor_service::async_write_some]

[indexterm2 async_write_some..posix::stream_descriptor_service] Start an asynchronous write. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
  void async_write_some(
      implementation_type & impl,
      const ConstBufferSequence & buffers,
      WriteHandler descriptorr);



[endsect]



[section:cancel posix::stream_descriptor_service::cancel]

[indexterm2 cancel..posix::stream_descriptor_service] Cancel all asynchronous operations associated with the descriptor. 

  boost::system::error_code cancel(
      implementation_type & impl,
      boost::system::error_code & ec);



[endsect]



[section:close posix::stream_descriptor_service::close]

[indexterm2 close..posix::stream_descriptor_service] Close a stream descriptor implementation. 

  boost::system::error_code close(
      implementation_type & impl,
      boost::system::error_code & ec);



[endsect]



[section:construct posix::stream_descriptor_service::construct]

[indexterm2 construct..posix::stream_descriptor_service] Construct a new stream descriptor implementation. 

  void construct(
      implementation_type & impl);



[endsect]



[section:destroy posix::stream_descriptor_service::destroy]

[indexterm2 destroy..posix::stream_descriptor_service] Destroy a stream descriptor implementation. 

  void destroy(
      implementation_type & impl);



[endsect]



[section:get_io_service posix::stream_descriptor_service::get_io_service]


['Inherited from io_service.]

[indexterm2 get_io_service..posix::stream_descriptor_service] Get the io_service object that owns the service. 

  boost::asio::io_service & get_io_service();



[endsect]



[section:id posix::stream_descriptor_service::id]

[indexterm2 id..posix::stream_descriptor_service] The unique service identifier. 

  static boost::asio::io_service::id id;



[endsect]



[section:implementation_type posix::stream_descriptor_service::implementation_type]

[indexterm2 implementation_type..posix::stream_descriptor_service] The type of a stream descriptor implementation. 

  typedef implementation_defined implementation_type;




[endsect]



[section:io_control posix::stream_descriptor_service::io_control]

[indexterm2 io_control..posix::stream_descriptor_service] Perform an IO control command on the descriptor. 

  template<
      typename ``[link boost_asio.reference.IoControlCommand IoControlCommand]``>
  boost::system::error_code io_control(
      implementation_type & impl,
      IoControlCommand & command,
      boost::system::error_code & ec);



[endsect]



[section:io_service posix::stream_descriptor_service::io_service]


['Inherited from io_service.]

[indexterm2 io_service..posix::stream_descriptor_service] (Deprecated: use get_io_service().) Get the io_service object that owns the service. 

  boost::asio::io_service & io_service();



[endsect]



[section:is_open posix::stream_descriptor_service::is_open]

[indexterm2 is_open..posix::stream_descriptor_service] Determine whether the descriptor is open. 

  bool is_open(
      const implementation_type & impl) const;



[endsect]



[section:native posix::stream_descriptor_service::native]

[indexterm2 native..posix::stream_descriptor_service] Get the native descriptor implementation. 

  native_type native(
      implementation_type & impl);



[endsect]



[section:native_type posix::stream_descriptor_service::native_type]

[indexterm2 native_type..posix::stream_descriptor_service] The native descriptor type. 

  typedef implementation_defined native_type;




[endsect]



[section:read_some posix::stream_descriptor_service::read_some]

[indexterm2 read_some..posix::stream_descriptor_service] Read some data from the stream. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t read_some(
      implementation_type & impl,
      const MutableBufferSequence & buffers,
      boost::system::error_code & ec);



[endsect]



[section:shutdown_service posix::stream_descriptor_service::shutdown_service]

[indexterm2 shutdown_service..posix::stream_descriptor_service] Destroy all user-defined descriptorr objects owned by the service. 

  void shutdown_service();



[endsect]



[section:stream_descriptor_service posix::stream_descriptor_service::stream_descriptor_service]

[indexterm2 stream_descriptor_service..posix::stream_descriptor_service] Construct a new stream descriptor service for the specified io_service. 

  stream_descriptor_service(
      boost::asio::io_service & io_service);



[endsect]



[section:write_some posix::stream_descriptor_service::write_some]

[indexterm2 write_some..posix::stream_descriptor_service] Write the given data to the stream. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t write_some(
      implementation_type & impl,
      const ConstBufferSequence & buffers,
      boost::system::error_code & ec);



[endsect]



[endsect]

[section:raw_socket_service raw_socket_service]

Default service implementation for a raw socket. 

  template<
      typename ``[link boost_asio.reference.Protocol Protocol]``>
  class raw_socket_service :
    public io_service::service


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.raw_socket_service.endpoint_type [*endpoint_type]]]
    [The endpoint type. ]
  
  ]

  [

    [[link boost_asio.reference.raw_socket_service.implementation_type [*implementation_type]]]
    [The type of a raw socket. ]
  
  ]

  [

    [[link boost_asio.reference.raw_socket_service.native_type [*native_type]]]
    [The native socket type. ]
  
  ]

  [

    [[link boost_asio.reference.raw_socket_service.protocol_type [*protocol_type]]]
    [The protocol type. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.raw_socket_service.assign [*assign]]]
    [Assign an existing native socket to a raw socket. ]
  ]
  
  [
    [[link boost_asio.reference.raw_socket_service.async_connect [*async_connect]]]
    [Start an asynchronous connect. ]
  ]
  
  [
    [[link boost_asio.reference.raw_socket_service.async_receive [*async_receive]]]
    [Start an asynchronous receive. ]
  ]
  
  [
    [[link boost_asio.reference.raw_socket_service.async_receive_from [*async_receive_from]]]
    [Start an asynchronous receive that will get the endpoint of the sender. ]
  ]
  
  [
    [[link boost_asio.reference.raw_socket_service.async_send [*async_send]]]
    [Start an asynchronous send. ]
  ]
  
  [
    [[link boost_asio.reference.raw_socket_service.async_send_to [*async_send_to]]]
    [Start an asynchronous send. ]
  ]
  
  [
    [[link boost_asio.reference.raw_socket_service.at_mark [*at_mark]]]
    [Determine whether the socket is at the out-of-band data mark. ]
  ]
  
  [
    [[link boost_asio.reference.raw_socket_service.available [*available]]]
    [Determine the number of bytes available for reading. ]
  ]
  
  [
    [[link boost_asio.reference.raw_socket_service.bind [*bind]]]
    []
  ]
  
  [
    [[link boost_asio.reference.raw_socket_service.cancel [*cancel]]]
    [Cancel all asynchronous operations associated with the socket. ]
  ]
  
  [
    [[link boost_asio.reference.raw_socket_service.close [*close]]]
    [Close a raw socket implementation. ]
  ]
  
  [
    [[link boost_asio.reference.raw_socket_service.connect [*connect]]]
    [Connect the raw socket to the specified endpoint. ]
  ]
  
  [
    [[link boost_asio.reference.raw_socket_service.construct [*construct]]]
    [Construct a new raw socket implementation. ]
  ]
  
  [
    [[link boost_asio.reference.raw_socket_service.destroy [*destroy]]]
    [Destroy a raw socket implementation. ]
  ]
  
  [
    [[link boost_asio.reference.raw_socket_service.get_io_service [*get_io_service]]]
    [Get the io_service object that owns the service. ]
  ]
  
  [
    [[link boost_asio.reference.raw_socket_service.get_option [*get_option]]]
    [Get a socket option. ]
  ]
  
  [
    [[link boost_asio.reference.raw_socket_service.io_control [*io_control]]]
    [Perform an IO control command on the socket. ]
  ]
  
  [
    [[link boost_asio.reference.raw_socket_service.io_service [*io_service]]]
    [(Deprecated: use get_io_service().) Get the io_service object that owns the service. ]
  ]
  
  [
    [[link boost_asio.reference.raw_socket_service.is_open [*is_open]]]
    [Determine whether the socket is open. ]
  ]
  
  [
    [[link boost_asio.reference.raw_socket_service.local_endpoint [*local_endpoint]]]
    [Get the local endpoint. ]
  ]
  
  [
    [[link boost_asio.reference.raw_socket_service.native [*native]]]
    [Get the native socket implementation. ]
  ]
  
  [
    [[link boost_asio.reference.raw_socket_service.open [*open]]]
    []
  ]
  
  [
    [[link boost_asio.reference.raw_socket_service.raw_socket_service [*raw_socket_service]]]
    [Construct a new raw socket service for the specified io_service. ]
  ]
  
  [
    [[link boost_asio.reference.raw_socket_service.receive [*receive]]]
    [Receive some data from the peer. ]
  ]
  
  [
    [[link boost_asio.reference.raw_socket_service.receive_from [*receive_from]]]
    [Receive raw data with the endpoint of the sender. ]
  ]
  
  [
    [[link boost_asio.reference.raw_socket_service.remote_endpoint [*remote_endpoint]]]
    [Get the remote endpoint. ]
  ]
  
  [
    [[link boost_asio.reference.raw_socket_service.send [*send]]]
    [Send the given data to the peer. ]
  ]
  
  [
    [[link boost_asio.reference.raw_socket_service.send_to [*send_to]]]
    [Send raw data to the specified endpoint. ]
  ]
  
  [
    [[link boost_asio.reference.raw_socket_service.set_option [*set_option]]]
    [Set a socket option. ]
  ]
  
  [
    [[link boost_asio.reference.raw_socket_service.shutdown [*shutdown]]]
    [Disable sends or receives on the socket. ]
  ]
  
  [
    [[link boost_asio.reference.raw_socket_service.shutdown_service [*shutdown_service]]]
    [Destroy all user-defined handler objects owned by the service. ]
  ]
  
]

[heading Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.raw_socket_service.id [*id]]]
    [The unique service identifier. ]
  ]

]


[section:assign raw_socket_service::assign]

[indexterm2 assign..raw_socket_service] Assign an existing native socket to a raw socket. 

  boost::system::error_code assign(
      implementation_type & impl,
      const protocol_type & protocol,
      const native_type & native_socket,
      boost::system::error_code & ec);



[endsect]



[section:async_connect raw_socket_service::async_connect]

[indexterm2 async_connect..raw_socket_service] Start an asynchronous connect. 

  template<
      typename ``[link boost_asio.reference.ConnectHandler ConnectHandler]``>
  void async_connect(
      implementation_type & impl,
      const endpoint_type & peer_endpoint,
      ConnectHandler handler);



[endsect]



[section:async_receive raw_socket_service::async_receive]

[indexterm2 async_receive..raw_socket_service] Start an asynchronous receive. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
  void async_receive(
      implementation_type & impl,
      const MutableBufferSequence & buffers,
      socket_base::message_flags flags,
      ReadHandler handler);



[endsect]



[section:async_receive_from raw_socket_service::async_receive_from]

[indexterm2 async_receive_from..raw_socket_service] Start an asynchronous receive that will get the endpoint of the sender. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
  void async_receive_from(
      implementation_type & impl,
      const MutableBufferSequence & buffers,
      endpoint_type & sender_endpoint,
      socket_base::message_flags flags,
      ReadHandler handler);



[endsect]



[section:async_send raw_socket_service::async_send]

[indexterm2 async_send..raw_socket_service] Start an asynchronous send. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
  void async_send(
      implementation_type & impl,
      const ConstBufferSequence & buffers,
      socket_base::message_flags flags,
      WriteHandler handler);



[endsect]



[section:async_send_to raw_socket_service::async_send_to]

[indexterm2 async_send_to..raw_socket_service] Start an asynchronous send. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
  void async_send_to(
      implementation_type & impl,
      const ConstBufferSequence & buffers,
      const endpoint_type & destination,
      socket_base::message_flags flags,
      WriteHandler handler);



[endsect]



[section:at_mark raw_socket_service::at_mark]

[indexterm2 at_mark..raw_socket_service] Determine whether the socket is at the out-of-band data mark. 

  bool at_mark(
      const implementation_type & impl,
      boost::system::error_code & ec) const;



[endsect]



[section:available raw_socket_service::available]

[indexterm2 available..raw_socket_service] Determine the number of bytes available for reading. 

  std::size_t available(
      const implementation_type & impl,
      boost::system::error_code & ec) const;



[endsect]



[section:bind raw_socket_service::bind]

[indexterm2 bind..raw_socket_service] 

  boost::system::error_code bind(
      implementation_type & impl,
      const endpoint_type & endpoint,
      boost::system::error_code & ec);



[endsect]



[section:cancel raw_socket_service::cancel]

[indexterm2 cancel..raw_socket_service] Cancel all asynchronous operations associated with the socket. 

  boost::system::error_code cancel(
      implementation_type & impl,
      boost::system::error_code & ec);



[endsect]



[section:close raw_socket_service::close]

[indexterm2 close..raw_socket_service] Close a raw socket implementation. 

  boost::system::error_code close(
      implementation_type & impl,
      boost::system::error_code & ec);



[endsect]



[section:connect raw_socket_service::connect]

[indexterm2 connect..raw_socket_service] Connect the raw socket to the specified endpoint. 

  boost::system::error_code connect(
      implementation_type & impl,
      const endpoint_type & peer_endpoint,
      boost::system::error_code & ec);



[endsect]



[section:construct raw_socket_service::construct]

[indexterm2 construct..raw_socket_service] Construct a new raw socket implementation. 

  void construct(
      implementation_type & impl);



[endsect]



[section:destroy raw_socket_service::destroy]

[indexterm2 destroy..raw_socket_service] Destroy a raw socket implementation. 

  void destroy(
      implementation_type & impl);



[endsect]



[section:endpoint_type raw_socket_service::endpoint_type]

[indexterm2 endpoint_type..raw_socket_service] The endpoint type. 

  typedef Protocol::endpoint endpoint_type;




[endsect]



[section:get_io_service raw_socket_service::get_io_service]


['Inherited from io_service.]

[indexterm2 get_io_service..raw_socket_service] Get the io_service object that owns the service. 

  boost::asio::io_service & get_io_service();



[endsect]



[section:get_option raw_socket_service::get_option]

[indexterm2 get_option..raw_socket_service] Get a socket option. 

  template<
      typename ``[link boost_asio.reference.GettableSocketOption GettableSocketOption]``>
  boost::system::error_code get_option(
      const implementation_type & impl,
      GettableSocketOption & option,
      boost::system::error_code & ec) const;



[endsect]



[section:id raw_socket_service::id]

[indexterm2 id..raw_socket_service] The unique service identifier. 

  static boost::asio::io_service::id id;



[endsect]



[section:implementation_type raw_socket_service::implementation_type]

[indexterm2 implementation_type..raw_socket_service] The type of a raw socket. 

  typedef implementation_defined implementation_type;




[endsect]



[section:io_control raw_socket_service::io_control]

[indexterm2 io_control..raw_socket_service] Perform an IO control command on the socket. 

  template<
      typename ``[link boost_asio.reference.IoControlCommand IoControlCommand]``>
  boost::system::error_code io_control(
      implementation_type & impl,
      IoControlCommand & command,
      boost::system::error_code & ec);



[endsect]



[section:io_service raw_socket_service::io_service]


['Inherited from io_service.]

[indexterm2 io_service..raw_socket_service] (Deprecated: use get_io_service().) Get the io_service object that owns the service. 

  boost::asio::io_service & io_service();



[endsect]



[section:is_open raw_socket_service::is_open]

[indexterm2 is_open..raw_socket_service] Determine whether the socket is open. 

  bool is_open(
      const implementation_type & impl) const;



[endsect]



[section:local_endpoint raw_socket_service::local_endpoint]

[indexterm2 local_endpoint..raw_socket_service] Get the local endpoint. 

  endpoint_type local_endpoint(
      const implementation_type & impl,
      boost::system::error_code & ec) const;



[endsect]



[section:native raw_socket_service::native]

[indexterm2 native..raw_socket_service] Get the native socket implementation. 

  native_type native(
      implementation_type & impl);



[endsect]



[section:native_type raw_socket_service::native_type]

[indexterm2 native_type..raw_socket_service] The native socket type. 

  typedef implementation_defined native_type;




[endsect]



[section:open raw_socket_service::open]

[indexterm2 open..raw_socket_service] 

  boost::system::error_code open(
      implementation_type & impl,
      const protocol_type & protocol,
      boost::system::error_code & ec);



[endsect]



[section:protocol_type raw_socket_service::protocol_type]

[indexterm2 protocol_type..raw_socket_service] The protocol type. 

  typedef Protocol protocol_type;




[endsect]



[section:raw_socket_service raw_socket_service::raw_socket_service]

[indexterm2 raw_socket_service..raw_socket_service] Construct a new raw socket service for the specified io_service. 

  raw_socket_service(
      boost::asio::io_service & io_service);



[endsect]



[section:receive raw_socket_service::receive]

[indexterm2 receive..raw_socket_service] Receive some data from the peer. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t receive(
      implementation_type & impl,
      const MutableBufferSequence & buffers,
      socket_base::message_flags flags,
      boost::system::error_code & ec);



[endsect]



[section:receive_from raw_socket_service::receive_from]

[indexterm2 receive_from..raw_socket_service] Receive raw data with the endpoint of the sender. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t receive_from(
      implementation_type & impl,
      const MutableBufferSequence & buffers,
      endpoint_type & sender_endpoint,
      socket_base::message_flags flags,
      boost::system::error_code & ec);



[endsect]



[section:remote_endpoint raw_socket_service::remote_endpoint]

[indexterm2 remote_endpoint..raw_socket_service] Get the remote endpoint. 

  endpoint_type remote_endpoint(
      const implementation_type & impl,
      boost::system::error_code & ec) const;



[endsect]



[section:send raw_socket_service::send]

[indexterm2 send..raw_socket_service] Send the given data to the peer. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t send(
      implementation_type & impl,
      const ConstBufferSequence & buffers,
      socket_base::message_flags flags,
      boost::system::error_code & ec);



[endsect]



[section:send_to raw_socket_service::send_to]

[indexterm2 send_to..raw_socket_service] Send raw data to the specified endpoint. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t send_to(
      implementation_type & impl,
      const ConstBufferSequence & buffers,
      const endpoint_type & destination,
      socket_base::message_flags flags,
      boost::system::error_code & ec);



[endsect]



[section:set_option raw_socket_service::set_option]

[indexterm2 set_option..raw_socket_service] Set a socket option. 

  template<
      typename ``[link boost_asio.reference.SettableSocketOption SettableSocketOption]``>
  boost::system::error_code set_option(
      implementation_type & impl,
      const SettableSocketOption & option,
      boost::system::error_code & ec);



[endsect]



[section:shutdown raw_socket_service::shutdown]

[indexterm2 shutdown..raw_socket_service] Disable sends or receives on the socket. 

  boost::system::error_code shutdown(
      implementation_type & impl,
      socket_base::shutdown_type what,
      boost::system::error_code & ec);



[endsect]



[section:shutdown_service raw_socket_service::shutdown_service]

[indexterm2 shutdown_service..raw_socket_service] Destroy all user-defined handler objects owned by the service. 

  void shutdown_service();



[endsect]



[endsect]

[section:read read]

[indexterm1 read] Attempt to read a certain amount of data from a stream before returning. 
      
  template<
      typename ``[link boost_asio.reference.SyncReadStream SyncReadStream]``,
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t ``[link boost_asio.reference.read.overload1 read]``(
      SyncReadStream & s,
      const MutableBufferSequence & buffers);

  template<
      typename ``[link boost_asio.reference.SyncReadStream SyncReadStream]``,
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
      typename CompletionCondition>
  std::size_t ``[link boost_asio.reference.read.overload2 read]``(
      SyncReadStream & s,
      const MutableBufferSequence & buffers,
      CompletionCondition completion_condition);

  template<
      typename ``[link boost_asio.reference.SyncReadStream SyncReadStream]``,
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
      typename CompletionCondition>
  std::size_t ``[link boost_asio.reference.read.overload3 read]``(
      SyncReadStream & s,
      const MutableBufferSequence & buffers,
      CompletionCondition completion_condition,
      boost::system::error_code & ec);

  template<
      typename ``[link boost_asio.reference.SyncReadStream SyncReadStream]``,
      typename Allocator>
  std::size_t ``[link boost_asio.reference.read.overload4 read]``(
      SyncReadStream & s,
      basic_streambuf< Allocator > & b);

  template<
      typename ``[link boost_asio.reference.SyncReadStream SyncReadStream]``,
      typename Allocator,
      typename CompletionCondition>
  std::size_t ``[link boost_asio.reference.read.overload5 read]``(
      SyncReadStream & s,
      basic_streambuf< Allocator > & b,
      CompletionCondition completion_condition);

  template<
      typename ``[link boost_asio.reference.SyncReadStream SyncReadStream]``,
      typename Allocator,
      typename CompletionCondition>
  std::size_t ``[link boost_asio.reference.read.overload6 read]``(
      SyncReadStream & s,
      basic_streambuf< Allocator > & b,
      CompletionCondition completion_condition,
      boost::system::error_code & ec);


[section:overload1 read (1 of 6 overloads)]

Attempt to read a certain amount of data from a stream before returning. 

  template<
      typename ``[link boost_asio.reference.SyncReadStream SyncReadStream]``,
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t read(
      SyncReadStream & s,
      const MutableBufferSequence & buffers);


This function is used to read a certain number of bytes of data from a stream. The call will block until one of the following conditions is true:


* The supplied buffers are full. That is, the bytes transferred is equal to the sum of the buffer sizes.

* An error occurred.

This operation is implemented in terms of zero or more calls to the stream's read\_some function.


[heading Parameters]
    

[variablelist
  
[[s][The stream from which the data is to be read. The type must support the SyncReadStream concept.]]

[[buffers][One or more buffers into which the data will be read. The sum of the buffer sizes indicates the maximum number of bytes to read from the stream.]]

]

[heading Return Value]
      
The number of bytes transferred.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Example]
  
To read into a single data buffer use the 
[link boost_asio.reference.buffer buffer]  function as follows: 

   boost::asio::read(s, boost::asio::buffer(data, size)); 


See the 
[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.

[heading Remarks]
      
This overload is equivalent to calling: 

   boost::asio::read(
       s, buffers,
       boost::asio::transfer_all()); 






[endsect]



[section:overload2 read (2 of 6 overloads)]

Attempt to read a certain amount of data from a stream before returning. 

  template<
      typename ``[link boost_asio.reference.SyncReadStream SyncReadStream]``,
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
      typename CompletionCondition>
  std::size_t read(
      SyncReadStream & s,
      const MutableBufferSequence & buffers,
      CompletionCondition completion_condition);


This function is used to read a certain number of bytes of data from a stream. The call will block until one of the following conditions is true:


* The supplied buffers are full. That is, the bytes transferred is equal to the sum of the buffer sizes.

* The completion_condition function object returns 0.

This operation is implemented in terms of zero or more calls to the stream's read\_some function.


[heading Parameters]
    

[variablelist
  
[[s][The stream from which the data is to be read. The type must support the SyncReadStream concept.]]

[[buffers][One or more buffers into which the data will be read. The sum of the buffer sizes indicates the maximum number of bytes to read from the stream.]]

[[completion_condition][The function object to be called to determine whether the read operation is complete. The signature of the function object must be: 
``
   std::size_t completion_condition(
     // Result of latest read_some operation.
     const boost::system::error_code& error,

     // Number of bytes transferred so far.
     std::size_t bytes_transferred
   ); 
``
A return value of 0 indicates that the read operation is complete. A non-zero return value indicates the maximum number of bytes to be read on the next call to the stream's read\_some function.]]

]

[heading Return Value]
      
The number of bytes transferred.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Example]
  
To read into a single data buffer use the 
[link boost_asio.reference.buffer buffer]  function as follows: 

   boost::asio::read(s, boost::asio::buffer(data, size),
       boost::asio::transfer_at_least(32)); 


See the 
[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. 



[endsect]



[section:overload3 read (3 of 6 overloads)]

Attempt to read a certain amount of data from a stream before returning. 

  template<
      typename ``[link boost_asio.reference.SyncReadStream SyncReadStream]``,
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
      typename CompletionCondition>
  std::size_t read(
      SyncReadStream & s,
      const MutableBufferSequence & buffers,
      CompletionCondition completion_condition,
      boost::system::error_code & ec);


This function is used to read a certain number of bytes of data from a stream. The call will block until one of the following conditions is true:


* The supplied buffers are full. That is, the bytes transferred is equal to the sum of the buffer sizes.

* The completion_condition function object returns 0.

This operation is implemented in terms of zero or more calls to the stream's read\_some function.


[heading Parameters]
    

[variablelist
  
[[s][The stream from which the data is to be read. The type must support the SyncReadStream concept.]]

[[buffers][One or more buffers into which the data will be read. The sum of the buffer sizes indicates the maximum number of bytes to read from the stream.]]

[[completion_condition][The function object to be called to determine whether the read operation is complete. The signature of the function object must be: 
``
   std::size_t completion_condition(
     // Result of latest read_some operation.
     const boost::system::error_code& error,

     // Number of bytes transferred so far.
     std::size_t bytes_transferred
   ); 
``
A return value of 0 indicates that the read operation is complete. A non-zero return value indicates the maximum number of bytes to be read on the next call to the stream's read\_some function.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Return Value]
      
The number of bytes read. If an error occurs, returns the total number of bytes successfully transferred prior to the error. 



[endsect]



[section:overload4 read (4 of 6 overloads)]

Attempt to read a certain amount of data from a stream before returning. 

  template<
      typename ``[link boost_asio.reference.SyncReadStream SyncReadStream]``,
      typename Allocator>
  std::size_t read(
      SyncReadStream & s,
      basic_streambuf< Allocator > & b);


This function is used to read a certain number of bytes of data from a stream. The call will block until one of the following conditions is true:


* An error occurred.

This operation is implemented in terms of zero or more calls to the stream's read\_some function.


[heading Parameters]
    

[variablelist
  
[[s][The stream from which the data is to be read. The type must support the SyncReadStream concept.]]

[[b][The basic\_streambuf object into which the data will be read.]]

]

[heading Return Value]
      
The number of bytes transferred.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Remarks]
      
This overload is equivalent to calling: 

   boost::asio::read(
       s, b,
       boost::asio::transfer_all()); 






[endsect]



[section:overload5 read (5 of 6 overloads)]

Attempt to read a certain amount of data from a stream before returning. 

  template<
      typename ``[link boost_asio.reference.SyncReadStream SyncReadStream]``,
      typename Allocator,
      typename CompletionCondition>
  std::size_t read(
      SyncReadStream & s,
      basic_streambuf< Allocator > & b,
      CompletionCondition completion_condition);


This function is used to read a certain number of bytes of data from a stream. The call will block until one of the following conditions is true:


* The completion_condition function object returns 0.

This operation is implemented in terms of zero or more calls to the stream's read\_some function.


[heading Parameters]
    

[variablelist
  
[[s][The stream from which the data is to be read. The type must support the SyncReadStream concept.]]

[[b][The basic\_streambuf object into which the data will be read.]]

[[completion_condition][The function object to be called to determine whether the read operation is complete. The signature of the function object must be: 
``
   std::size_t completion_condition(
     // Result of latest read_some operation.
     const boost::system::error_code& error,

     // Number of bytes transferred so far.
     std::size_t bytes_transferred
   ); 
``
A return value of 0 indicates that the read operation is complete. A non-zero return value indicates the maximum number of bytes to be read on the next call to the stream's read\_some function.]]

]

[heading Return Value]
      
The number of bytes transferred.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. ]]

]



[endsect]



[section:overload6 read (6 of 6 overloads)]

Attempt to read a certain amount of data from a stream before returning. 

  template<
      typename ``[link boost_asio.reference.SyncReadStream SyncReadStream]``,
      typename Allocator,
      typename CompletionCondition>
  std::size_t read(
      SyncReadStream & s,
      basic_streambuf< Allocator > & b,
      CompletionCondition completion_condition,
      boost::system::error_code & ec);


This function is used to read a certain number of bytes of data from a stream. The call will block until one of the following conditions is true:


* The completion_condition function object returns 0.

This operation is implemented in terms of zero or more calls to the stream's read\_some function.


[heading Parameters]
    

[variablelist
  
[[s][The stream from which the data is to be read. The type must support the SyncReadStream concept.]]

[[b][The basic\_streambuf object into which the data will be read.]]

[[completion_condition][The function object to be called to determine whether the read operation is complete. The signature of the function object must be: 
``
   std::size_t completion_condition(
     // Result of latest read_some operation.
     const boost::system::error_code& error,

     // Number of bytes transferred so far.
     std::size_t bytes_transferred
   ); 
``
A return value of 0 indicates that the read operation is complete. A non-zero return value indicates the maximum number of bytes to be read on the next call to the stream's read\_some function.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Return Value]
      
The number of bytes read. If an error occurs, returns the total number of bytes successfully transferred prior to the error. 



[endsect]


[endsect]

[section:read_at read_at]

[indexterm1 read_at] Attempt to read a certain amount of data at the specified offset before returning. 
      
  template<
      typename ``[link boost_asio.reference.SyncRandomAccessReadDevice SyncRandomAccessReadDevice]``,
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t ``[link boost_asio.reference.read_at.overload1 read_at]``(
      SyncRandomAccessReadDevice & d,
      boost::uint64_t offset,
      const MutableBufferSequence & buffers);

  template<
      typename ``[link boost_asio.reference.SyncRandomAccessReadDevice SyncRandomAccessReadDevice]``,
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
      typename CompletionCondition>
  std::size_t ``[link boost_asio.reference.read_at.overload2 read_at]``(
      SyncRandomAccessReadDevice & d,
      boost::uint64_t offset,
      const MutableBufferSequence & buffers,
      CompletionCondition completion_condition);

  template<
      typename ``[link boost_asio.reference.SyncRandomAccessReadDevice SyncRandomAccessReadDevice]``,
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
      typename CompletionCondition>
  std::size_t ``[link boost_asio.reference.read_at.overload3 read_at]``(
      SyncRandomAccessReadDevice & d,
      boost::uint64_t offset,
      const MutableBufferSequence & buffers,
      CompletionCondition completion_condition,
      boost::system::error_code & ec);

  template<
      typename ``[link boost_asio.reference.SyncRandomAccessReadDevice SyncRandomAccessReadDevice]``,
      typename Allocator>
  std::size_t ``[link boost_asio.reference.read_at.overload4 read_at]``(
      SyncRandomAccessReadDevice & d,
      boost::uint64_t offset,
      basic_streambuf< Allocator > & b);

  template<
      typename ``[link boost_asio.reference.SyncRandomAccessReadDevice SyncRandomAccessReadDevice]``,
      typename Allocator,
      typename CompletionCondition>
  std::size_t ``[link boost_asio.reference.read_at.overload5 read_at]``(
      SyncRandomAccessReadDevice & d,
      boost::uint64_t offset,
      basic_streambuf< Allocator > & b,
      CompletionCondition completion_condition);

  template<
      typename ``[link boost_asio.reference.SyncRandomAccessReadDevice SyncRandomAccessReadDevice]``,
      typename Allocator,
      typename CompletionCondition>
  std::size_t ``[link boost_asio.reference.read_at.overload6 read_at]``(
      SyncRandomAccessReadDevice & d,
      boost::uint64_t offset,
      basic_streambuf< Allocator > & b,
      CompletionCondition completion_condition,
      boost::system::error_code & ec);


[section:overload1 read_at (1 of 6 overloads)]

Attempt to read a certain amount of data at the specified offset before returning. 

  template<
      typename ``[link boost_asio.reference.SyncRandomAccessReadDevice SyncRandomAccessReadDevice]``,
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t read_at(
      SyncRandomAccessReadDevice & d,
      boost::uint64_t offset,
      const MutableBufferSequence & buffers);


This function is used to read a certain number of bytes of data from a random access device at the specified offset. The call will block until one of the following conditions is true:


* The supplied buffers are full. That is, the bytes transferred is equal to the sum of the buffer sizes.

* An error occurred.

This operation is implemented in terms of zero or more calls to the device's read\_some\_at function.


[heading Parameters]
    

[variablelist
  
[[d][The device from which the data is to be read. The type must support the SyncRandomAccessReadDevice concept.]]

[[offset][The offset at which the data will be read.]]

[[buffers][One or more buffers into which the data will be read. The sum of the buffer sizes indicates the maximum number of bytes to read from the device.]]

]

[heading Return Value]
      
The number of bytes transferred.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Example]
  
To read into a single data buffer use the 
[link boost_asio.reference.buffer buffer]  function as follows: 

   boost::asio::read_at(d, 42, boost::asio::buffer(data, size)); 


See the 
[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.

[heading Remarks]
      
This overload is equivalent to calling: 

   boost::asio::read_at(
       d, 42, buffers,
       boost::asio::transfer_all()); 






[endsect]



[section:overload2 read_at (2 of 6 overloads)]

Attempt to read a certain amount of data at the specified offset before returning. 

  template<
      typename ``[link boost_asio.reference.SyncRandomAccessReadDevice SyncRandomAccessReadDevice]``,
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
      typename CompletionCondition>
  std::size_t read_at(
      SyncRandomAccessReadDevice & d,
      boost::uint64_t offset,
      const MutableBufferSequence & buffers,
      CompletionCondition completion_condition);


This function is used to read a certain number of bytes of data from a random access device at the specified offset. The call will block until one of the following conditions is true:


* The supplied buffers are full. That is, the bytes transferred is equal to the sum of the buffer sizes.

* The completion_condition function object returns 0.

This operation is implemented in terms of zero or more calls to the device's read\_some\_at function.


[heading Parameters]
    

[variablelist
  
[[d][The device from which the data is to be read. The type must support the SyncRandomAccessReadDevice concept.]]

[[offset][The offset at which the data will be read.]]

[[buffers][One or more buffers into which the data will be read. The sum of the buffer sizes indicates the maximum number of bytes to read from the device.]]

[[completion_condition][The function object to be called to determine whether the read operation is complete. The signature of the function object must be: 
``
   std::size_t completion_condition(
     // Result of latest read_some_at operation.
     const boost::system::error_code& error,

     // Number of bytes transferred so far.
     std::size_t bytes_transferred
   ); 
``
A return value of 0 indicates that the read operation is complete. A non-zero return value indicates the maximum number of bytes to be read on the next call to the device's read\_some\_at function.]]

]

[heading Return Value]
      
The number of bytes transferred.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Example]
  
To read into a single data buffer use the 
[link boost_asio.reference.buffer buffer]  function as follows: 

   boost::asio::read_at(d, 42, boost::asio::buffer(data, size),
       boost::asio::transfer_at_least(32)); 


See the 
[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. 



[endsect]



[section:overload3 read_at (3 of 6 overloads)]

Attempt to read a certain amount of data at the specified offset before returning. 

  template<
      typename ``[link boost_asio.reference.SyncRandomAccessReadDevice SyncRandomAccessReadDevice]``,
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
      typename CompletionCondition>
  std::size_t read_at(
      SyncRandomAccessReadDevice & d,
      boost::uint64_t offset,
      const MutableBufferSequence & buffers,
      CompletionCondition completion_condition,
      boost::system::error_code & ec);


This function is used to read a certain number of bytes of data from a random access device at the specified offset. The call will block until one of the following conditions is true:


* The supplied buffers are full. That is, the bytes transferred is equal to the sum of the buffer sizes.

* The completion_condition function object returns 0.

This operation is implemented in terms of zero or more calls to the device's read\_some\_at function.


[heading Parameters]
    

[variablelist
  
[[d][The device from which the data is to be read. The type must support the SyncRandomAccessReadDevice concept.]]

[[offset][The offset at which the data will be read.]]

[[buffers][One or more buffers into which the data will be read. The sum of the buffer sizes indicates the maximum number of bytes to read from the device.]]

[[completion_condition][The function object to be called to determine whether the read operation is complete. The signature of the function object must be: 
``
   std::size_t completion_condition(
     // Result of latest read_some_at operation.
     const boost::system::error_code& error,

     // Number of bytes transferred so far.
     std::size_t bytes_transferred
   ); 
``
A return value of 0 indicates that the read operation is complete. A non-zero return value indicates the maximum number of bytes to be read on the next call to the device's read\_some\_at function.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Return Value]
      
The number of bytes read. If an error occurs, returns the total number of bytes successfully transferred prior to the error. 



[endsect]



[section:overload4 read_at (4 of 6 overloads)]

Attempt to read a certain amount of data at the specified offset before returning. 

  template<
      typename ``[link boost_asio.reference.SyncRandomAccessReadDevice SyncRandomAccessReadDevice]``,
      typename Allocator>
  std::size_t read_at(
      SyncRandomAccessReadDevice & d,
      boost::uint64_t offset,
      basic_streambuf< Allocator > & b);


This function is used to read a certain number of bytes of data from a random access device at the specified offset. The call will block until one of the following conditions is true:


* An error occurred.

This operation is implemented in terms of zero or more calls to the device's read\_some\_at function.


[heading Parameters]
    

[variablelist
  
[[d][The device from which the data is to be read. The type must support the SyncRandomAccessReadDevice concept.]]

[[offset][The offset at which the data will be read.]]

[[b][The basic\_streambuf object into which the data will be read.]]

]

[heading Return Value]
      
The number of bytes transferred.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Remarks]
      
This overload is equivalent to calling: 

   boost::asio::read_at(
       d, 42, b,
       boost::asio::transfer_all()); 






[endsect]



[section:overload5 read_at (5 of 6 overloads)]

Attempt to read a certain amount of data at the specified offset before returning. 

  template<
      typename ``[link boost_asio.reference.SyncRandomAccessReadDevice SyncRandomAccessReadDevice]``,
      typename Allocator,
      typename CompletionCondition>
  std::size_t read_at(
      SyncRandomAccessReadDevice & d,
      boost::uint64_t offset,
      basic_streambuf< Allocator > & b,
      CompletionCondition completion_condition);


This function is used to read a certain number of bytes of data from a random access device at the specified offset. The call will block until one of the following conditions is true:


* The completion_condition function object returns 0.

This operation is implemented in terms of zero or more calls to the device's read\_some\_at function.


[heading Parameters]
    

[variablelist
  
[[d][The device from which the data is to be read. The type must support the SyncRandomAccessReadDevice concept.]]

[[offset][The offset at which the data will be read.]]

[[b][The basic\_streambuf object into which the data will be read.]]

[[completion_condition][The function object to be called to determine whether the read operation is complete. The signature of the function object must be: 
``
   std::size_t completion_condition(
     // Result of latest read_some_at operation.
     const boost::system::error_code& error,

     // Number of bytes transferred so far.
     std::size_t bytes_transferred
   ); 
``
A return value of 0 indicates that the read operation is complete. A non-zero return value indicates the maximum number of bytes to be read on the next call to the device's read\_some\_at function.]]

]

[heading Return Value]
      
The number of bytes transferred.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. ]]

]



[endsect]



[section:overload6 read_at (6 of 6 overloads)]

Attempt to read a certain amount of data at the specified offset before returning. 

  template<
      typename ``[link boost_asio.reference.SyncRandomAccessReadDevice SyncRandomAccessReadDevice]``,
      typename Allocator,
      typename CompletionCondition>
  std::size_t read_at(
      SyncRandomAccessReadDevice & d,
      boost::uint64_t offset,
      basic_streambuf< Allocator > & b,
      CompletionCondition completion_condition,
      boost::system::error_code & ec);


This function is used to read a certain number of bytes of data from a random access device at the specified offset. The call will block until one of the following conditions is true:


* The completion_condition function object returns 0.

This operation is implemented in terms of zero or more calls to the device's read\_some\_at function.


[heading Parameters]
    

[variablelist
  
[[d][The device from which the data is to be read. The type must support the SyncRandomAccessReadDevice concept.]]

[[offset][The offset at which the data will be read.]]

[[b][The basic\_streambuf object into which the data will be read.]]

[[completion_condition][The function object to be called to determine whether the read operation is complete. The signature of the function object must be: 
``
   std::size_t completion_condition(
     // Result of latest read_some_at operation.
     const boost::system::error_code& error,

     // Number of bytes transferred so far.
     std::size_t bytes_transferred
   ); 
``
A return value of 0 indicates that the read operation is complete. A non-zero return value indicates the maximum number of bytes to be read on the next call to the device's read\_some\_at function.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Return Value]
      
The number of bytes read. If an error occurs, returns the total number of bytes successfully transferred prior to the error. 



[endsect]


[endsect]

[section:read_until read_until]

[indexterm1 read_until] Read data into a streambuf until it contains a delimiter, matches a regular expression, or a function object indicates a match. 
      
  template<
      typename ``[link boost_asio.reference.SyncReadStream SyncReadStream]``,
      typename Allocator>
  std::size_t ``[link boost_asio.reference.read_until.overload1 read_until]``(
      SyncReadStream & s,
      boost::asio::basic_streambuf< Allocator > & b,
      char delim);

  template<
      typename ``[link boost_asio.reference.SyncReadStream SyncReadStream]``,
      typename Allocator>
  std::size_t ``[link boost_asio.reference.read_until.overload2 read_until]``(
      SyncReadStream & s,
      boost::asio::basic_streambuf< Allocator > & b,
      char delim,
      boost::system::error_code & ec);

  template<
      typename ``[link boost_asio.reference.SyncReadStream SyncReadStream]``,
      typename Allocator>
  std::size_t ``[link boost_asio.reference.read_until.overload3 read_until]``(
      SyncReadStream & s,
      boost::asio::basic_streambuf< Allocator > & b,
      const std::string & delim);

  template<
      typename ``[link boost_asio.reference.SyncReadStream SyncReadStream]``,
      typename Allocator>
  std::size_t ``[link boost_asio.reference.read_until.overload4 read_until]``(
      SyncReadStream & s,
      boost::asio::basic_streambuf< Allocator > & b,
      const std::string & delim,
      boost::system::error_code & ec);

  template<
      typename ``[link boost_asio.reference.SyncReadStream SyncReadStream]``,
      typename Allocator>
  std::size_t ``[link boost_asio.reference.read_until.overload5 read_until]``(
      SyncReadStream & s,
      boost::asio::basic_streambuf< Allocator > & b,
      const boost::regex & expr);

  template<
      typename ``[link boost_asio.reference.SyncReadStream SyncReadStream]``,
      typename Allocator>
  std::size_t ``[link boost_asio.reference.read_until.overload6 read_until]``(
      SyncReadStream & s,
      boost::asio::basic_streambuf< Allocator > & b,
      const boost::regex & expr,
      boost::system::error_code & ec);

  template<
      typename ``[link boost_asio.reference.SyncReadStream SyncReadStream]``,
      typename Allocator,
      typename MatchCondition>
  std::size_t ``[link boost_asio.reference.read_until.overload7 read_until]``(
      SyncReadStream & s,
      boost::asio::basic_streambuf< Allocator > & b,
      MatchCondition match_condition,
      typename boost::enable_if< is_match_condition< MatchCondition > >::type *  = 0);

  template<
      typename ``[link boost_asio.reference.SyncReadStream SyncReadStream]``,
      typename Allocator,
      typename MatchCondition>
  std::size_t ``[link boost_asio.reference.read_until.overload8 read_until]``(
      SyncReadStream & s,
      boost::asio::basic_streambuf< Allocator > & b,
      MatchCondition match_condition,
      boost::system::error_code & ec,
      typename boost::enable_if< is_match_condition< MatchCondition > >::type *  = 0);


[section:overload1 read_until (1 of 8 overloads)]

Read data into a streambuf until it contains a specified delimiter. 

  template<
      typename ``[link boost_asio.reference.SyncReadStream SyncReadStream]``,
      typename Allocator>
  std::size_t read_until(
      SyncReadStream & s,
      boost::asio::basic_streambuf< Allocator > & b,
      char delim);


This function is used to read data into the specified streambuf until the streambuf's get area contains the specified delimiter. The call will block until one of the following conditions is true:


* The get area of the streambuf contains the specified delimiter.

* An error occurred.

This operation is implemented in terms of zero or more calls to the stream's read\_some function. If the streambuf's get area already contains the delimiter, the function returns immediately.


[heading Parameters]
    

[variablelist
  
[[s][The stream from which the data is to be read. The type must support the SyncReadStream concept.]]

[[b][A streambuf object into which the data will be read.]]

[[delim][The delimiter character.]]

]

[heading Return Value]
      
The number of bytes in the streambuf's get area up to and including the delimiter.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Remarks]
      
After a successful read\_until operation, the streambuf may contain additional data beyond the delimiter. An application will typically leave that data in the streambuf for a subsequent read\_until operation to examine.

[heading Example]
  
To read data into a streambuf until a newline is encountered: 

   boost::asio::streambuf b;
   boost::asio::read_until(s, b, '\n');
   std::istream is(&b);
   std::string line;
   std::getline(is, line); 






[endsect]



[section:overload2 read_until (2 of 8 overloads)]

Read data into a streambuf until it contains a specified delimiter. 

  template<
      typename ``[link boost_asio.reference.SyncReadStream SyncReadStream]``,
      typename Allocator>
  std::size_t read_until(
      SyncReadStream & s,
      boost::asio::basic_streambuf< Allocator > & b,
      char delim,
      boost::system::error_code & ec);


This function is used to read data into the specified streambuf until the streambuf's get area contains the specified delimiter. The call will block until one of the following conditions is true:


* The get area of the streambuf contains the specified delimiter.

* An error occurred.

This operation is implemented in terms of zero or more calls to the stream's read\_some function. If the streambuf's get area already contains the delimiter, the function returns immediately.


[heading Parameters]
    

[variablelist
  
[[s][The stream from which the data is to be read. The type must support the SyncReadStream concept.]]

[[b][A streambuf object into which the data will be read.]]

[[delim][The delimiter character.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Return Value]
      
The number of bytes in the streambuf's get area up to and including the delimiter. Returns 0 if an error occurred.

[heading Remarks]
      
After a successful read\_until operation, the streambuf may contain additional data beyond the delimiter. An application will typically leave that data in the streambuf for a subsequent read\_until operation to examine. 



[endsect]



[section:overload3 read_until (3 of 8 overloads)]

Read data into a streambuf until it contains a specified delimiter. 

  template<
      typename ``[link boost_asio.reference.SyncReadStream SyncReadStream]``,
      typename Allocator>
  std::size_t read_until(
      SyncReadStream & s,
      boost::asio::basic_streambuf< Allocator > & b,
      const std::string & delim);


This function is used to read data into the specified streambuf until the streambuf's get area contains the specified delimiter. The call will block until one of the following conditions is true:


* The get area of the streambuf contains the specified delimiter.

* An error occurred.

This operation is implemented in terms of zero or more calls to the stream's read\_some function. If the streambuf's get area already contains the delimiter, the function returns immediately.


[heading Parameters]
    

[variablelist
  
[[s][The stream from which the data is to be read. The type must support the SyncReadStream concept.]]

[[b][A streambuf object into which the data will be read.]]

[[delim][The delimiter string.]]

]

[heading Return Value]
      
The number of bytes in the streambuf's get area up to and including the delimiter.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Remarks]
      
After a successful read\_until operation, the streambuf may contain additional data beyond the delimiter. An application will typically leave that data in the streambuf for a subsequent read\_until operation to examine.

[heading Example]
  
To read data into a streambuf until a newline is encountered: 

   boost::asio::streambuf b;
   boost::asio::read_until(s, b, "\r\n");
   std::istream is(&b);
   std::string line;
   std::getline(is, line); 






[endsect]



[section:overload4 read_until (4 of 8 overloads)]

Read data into a streambuf until it contains a specified delimiter. 

  template<
      typename ``[link boost_asio.reference.SyncReadStream SyncReadStream]``,
      typename Allocator>
  std::size_t read_until(
      SyncReadStream & s,
      boost::asio::basic_streambuf< Allocator > & b,
      const std::string & delim,
      boost::system::error_code & ec);


This function is used to read data into the specified streambuf until the streambuf's get area contains the specified delimiter. The call will block until one of the following conditions is true:


* The get area of the streambuf contains the specified delimiter.

* An error occurred.

This operation is implemented in terms of zero or more calls to the stream's read\_some function. If the streambuf's get area already contains the delimiter, the function returns immediately.


[heading Parameters]
    

[variablelist
  
[[s][The stream from which the data is to be read. The type must support the SyncReadStream concept.]]

[[b][A streambuf object into which the data will be read.]]

[[delim][The delimiter string.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Return Value]
      
The number of bytes in the streambuf's get area up to and including the delimiter. Returns 0 if an error occurred.

[heading Remarks]
      
After a successful read\_until operation, the streambuf may contain additional data beyond the delimiter. An application will typically leave that data in the streambuf for a subsequent read\_until operation to examine. 



[endsect]



[section:overload5 read_until (5 of 8 overloads)]

Read data into a streambuf until some part of the data it contains matches a regular expression. 

  template<
      typename ``[link boost_asio.reference.SyncReadStream SyncReadStream]``,
      typename Allocator>
  std::size_t read_until(
      SyncReadStream & s,
      boost::asio::basic_streambuf< Allocator > & b,
      const boost::regex & expr);


This function is used to read data into the specified streambuf until the streambuf's get area contains some data that matches a regular expression. The call will block until one of the following conditions is true:


* A substring of the streambuf's get area matches the regular expression.

* An error occurred.

This operation is implemented in terms of zero or more calls to the stream's read\_some function. If the streambuf's get area already contains data that matches the regular expression, the function returns immediately.


[heading Parameters]
    

[variablelist
  
[[s][The stream from which the data is to be read. The type must support the SyncReadStream concept.]]

[[b][A streambuf object into which the data will be read.]]

[[expr][The regular expression.]]

]

[heading Return Value]
      
The number of bytes in the streambuf's get area up to and including the substring that matches the regular expression.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Remarks]
      
After a successful read\_until operation, the streambuf may contain additional data beyond that which matched the regular expression. An application will typically leave that data in the streambuf for a subsequent read\_until operation to examine.

[heading Example]
  
To read data into a streambuf until a CR-LF sequence is encountered: 

   boost::asio::streambuf b;
   boost::asio::read_until(s, b, boost::regex("\r\n"));
   std::istream is(&b);
   std::string line;
   std::getline(is, line); 






[endsect]



[section:overload6 read_until (6 of 8 overloads)]

Read data into a streambuf until some part of the data it contains matches a regular expression. 

  template<
      typename ``[link boost_asio.reference.SyncReadStream SyncReadStream]``,
      typename Allocator>
  std::size_t read_until(
      SyncReadStream & s,
      boost::asio::basic_streambuf< Allocator > & b,
      const boost::regex & expr,
      boost::system::error_code & ec);


This function is used to read data into the specified streambuf until the streambuf's get area contains some data that matches a regular expression. The call will block until one of the following conditions is true:


* A substring of the streambuf's get area matches the regular expression.

* An error occurred.

This operation is implemented in terms of zero or more calls to the stream's read\_some function. If the streambuf's get area already contains data that matches the regular expression, the function returns immediately.


[heading Parameters]
    

[variablelist
  
[[s][The stream from which the data is to be read. The type must support the SyncReadStream concept.]]

[[b][A streambuf object into which the data will be read.]]

[[expr][The regular expression.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Return Value]
      
The number of bytes in the streambuf's get area up to and including the substring that matches the regular expression. Returns 0 if an error occurred.

[heading Remarks]
      
After a successful read\_until operation, the streambuf may contain additional data beyond that which matched the regular expression. An application will typically leave that data in the streambuf for a subsequent read\_until operation to examine. 



[endsect]



[section:overload7 read_until (7 of 8 overloads)]

Read data into a streambuf until a function object indicates a match. 

  template<
      typename ``[link boost_asio.reference.SyncReadStream SyncReadStream]``,
      typename Allocator,
      typename MatchCondition>
  std::size_t read_until(
      SyncReadStream & s,
      boost::asio::basic_streambuf< Allocator > & b,
      MatchCondition match_condition,
      typename boost::enable_if< is_match_condition< MatchCondition > >::type *  = 0);


This function is used to read data into the specified streambuf until a user-defined match condition function object, when applied to the data contained in the streambuf, indicates a successful match. The call will block until one of the following conditions is true:


* The match condition function object returns a std::pair where the second element evaluates to true.

* An error occurred.

This operation is implemented in terms of zero or more calls to the stream's read\_some function. If the match condition function object already indicates a match, the function returns immediately.


[heading Parameters]
    

[variablelist
  
[[s][The stream from which the data is to be read. The type must support the SyncReadStream concept.]]

[[b][A streambuf object into which the data will be read.]]

[[match_condition][The function object to be called to determine whether a match exists. The signature of the function object must be: 
``
   pair<iterator, bool> match_condition(iterator begin, iterator end);
``
where `iterator` represents the type: 
``
   buffers_iterator<basic_streambuf<Allocator>::const_buffers_type>
``
The iterator parameters `begin` and `end` define the range of bytes to be scanned to determine whether there is a match. The `first` member of the return value is an iterator marking one-past-the-end of the bytes that have been consumed by the match function. This iterator is used to calculate the `begin` parameter for any subsequent invocation of the match condition. The `second` member of the return value is true if a match has been found, false otherwise.]]

]

[heading Return Value]
      
The number of bytes in the streambuf's get area that have been fully consumed by the match function.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Remarks]
      
After a successful read\_until operation, the streambuf may contain additional data beyond that which matched the function object. An application will typically leave that data in the streambuf for a subsequent

The default implementation of the `is_match_condition` type trait evaluates to true for function pointers and function objects with a `result_type` typedef. It must be specialised for other user-defined function objects.

[heading Examples]
  
To read data into a streambuf until whitespace is encountered: 

   typedef boost::asio::buffers_iterator<
       boost::asio::streambuf::const_buffers_type> iterator;

   std::pair<iterator, bool>
   match_whitespace(iterator begin, iterator end)
   {
     iterator i = begin;
     while (i != end)
       if (std::isspace(*i++))
         return std::make_pair(i, true);
     return std::make_pair(i, false);
   }
   ...
   boost::asio::streambuf b;
   boost::asio::read_until(s, b, match_whitespace);




To read data into a streambuf until a matching character is found: 

   class match_char
   {
   public:
     explicit match_char(char c) : c_(c) {}

     template <typename Iterator>
     std::pair<Iterator, bool> operator()(
         Iterator begin, Iterator end) const
     {
       Iterator i = begin;
       while (i != end)
         if (c_ == *i++)
           return std::make_pair(i, true);
       return std::make_pair(i, false);
     }

   private:
     char c_;
   };

   namespace asio {
     template <> struct is_match_condition<match_char>
       : public boost::true_type {};
   } // namespace asio
   ...
   boost::asio::streambuf b;
   boost::asio::read_until(s, b, match_char('a'));





[endsect]



[section:overload8 read_until (8 of 8 overloads)]

Read data into a streambuf until a function object indicates a match. 

  template<
      typename ``[link boost_asio.reference.SyncReadStream SyncReadStream]``,
      typename Allocator,
      typename MatchCondition>
  std::size_t read_until(
      SyncReadStream & s,
      boost::asio::basic_streambuf< Allocator > & b,
      MatchCondition match_condition,
      boost::system::error_code & ec,
      typename boost::enable_if< is_match_condition< MatchCondition > >::type *  = 0);


This function is used to read data into the specified streambuf until a user-defined match condition function object, when applied to the data contained in the streambuf, indicates a successful match. The call will block until one of the following conditions is true:


* The match condition function object returns a std::pair where the second element evaluates to true.

* An error occurred.

This operation is implemented in terms of zero or more calls to the stream's read\_some function. If the match condition function object already indicates a match, the function returns immediately.


[heading Parameters]
    

[variablelist
  
[[s][The stream from which the data is to be read. The type must support the SyncReadStream concept.]]

[[b][A streambuf object into which the data will be read.]]

[[match_condition][The function object to be called to determine whether a match exists. The signature of the function object must be: 
``
   pair<iterator, bool> match_condition(iterator begin, iterator end);
``
where `iterator` represents the type: 
``
   buffers_iterator<basic_streambuf<Allocator>::const_buffers_type>
``
The iterator parameters `begin` and `end` define the range of bytes to be scanned to determine whether there is a match. The `first` member of the return value is an iterator marking one-past-the-end of the bytes that have been consumed by the match function. This iterator is used to calculate the `begin` parameter for any subsequent invocation of the match condition. The `second` member of the return value is true if a match has been found, false otherwise.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Return Value]
      
The number of bytes in the streambuf's get area that have been fully consumed by the match function. Returns 0 if an error occurred.

[heading Remarks]
      
After a successful read\_until operation, the streambuf may contain additional data beyond that which matched the function object. An application will typically leave that data in the streambuf for a subsequent

The default implementation of the `is_match_condition` type trait evaluates to true for function pointers and function objects with a `result_type` typedef. It must be specialised for other user-defined function objects. 



[endsect]


[endsect]


[section:serial_port serial_port]

[indexterm1 serial_port] Typedef for the typical usage of a serial port. 

  typedef basic_serial_port serial_port;


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.basic_serial_port.implementation_type [*implementation_type]]]
    [The underlying implementation type of I/O object. ]
  
  ]

  [

    [[link boost_asio.reference.basic_serial_port.lowest_layer_type [*lowest_layer_type]]]
    [A basic_serial_port is always the lowest layer. ]
  
  ]

  [

    [[link boost_asio.reference.basic_serial_port.native_type [*native_type]]]
    [The native representation of a serial port. ]
  
  ]

  [

    [[link boost_asio.reference.basic_serial_port.service_type [*service_type]]]
    [The type of the service that will be used to provide I/O operations. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_serial_port.assign [*assign]]]
    [Assign an existing native serial port to the serial port. ]
  ]
  
  [
    [[link boost_asio.reference.basic_serial_port.async_read_some [*async_read_some]]]
    [Start an asynchronous read. ]
  ]
  
  [
    [[link boost_asio.reference.basic_serial_port.async_write_some [*async_write_some]]]
    [Start an asynchronous write. ]
  ]
  
  [
    [[link boost_asio.reference.basic_serial_port.basic_serial_port [*basic_serial_port]]]
    [Construct a basic_serial_port without opening it. 

     Construct and open a basic_serial_port. 

     Construct a basic_serial_port on an existing native serial port. ]
  ]
  
  [
    [[link boost_asio.reference.basic_serial_port.cancel [*cancel]]]
    [Cancel all asynchronous operations associated with the serial port. ]
  ]
  
  [
    [[link boost_asio.reference.basic_serial_port.close [*close]]]
    [Close the serial port. ]
  ]
  
  [
    [[link boost_asio.reference.basic_serial_port.get_io_service [*get_io_service]]]
    [Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.basic_serial_port.get_option [*get_option]]]
    [Get an option from the serial port. ]
  ]
  
  [
    [[link boost_asio.reference.basic_serial_port.io_service [*io_service]]]
    [(Deprecated: use get_io_service().) Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.basic_serial_port.is_open [*is_open]]]
    [Determine whether the serial port is open. ]
  ]
  
  [
    [[link boost_asio.reference.basic_serial_port.lowest_layer [*lowest_layer]]]
    [Get a reference to the lowest layer. 

     Get a const reference to the lowest layer. ]
  ]
  
  [
    [[link boost_asio.reference.basic_serial_port.native [*native]]]
    [Get the native serial port representation. ]
  ]
  
  [
    [[link boost_asio.reference.basic_serial_port.open [*open]]]
    [Open the serial port using the specified device name. ]
  ]
  
  [
    [[link boost_asio.reference.basic_serial_port.read_some [*read_some]]]
    [Read some data from the serial port. ]
  ]
  
  [
    [[link boost_asio.reference.basic_serial_port.send_break [*send_break]]]
    [Send a break sequence to the serial port. ]
  ]
  
  [
    [[link boost_asio.reference.basic_serial_port.set_option [*set_option]]]
    [Set an option on the serial port. ]
  ]
  
  [
    [[link boost_asio.reference.basic_serial_port.write_some [*write_some]]]
    [Write some data to the serial port. ]
  ]
  
]

[heading Protected Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_serial_port.implementation [*implementation]]]
    [The underlying implementation of the I/O object. ]
  ]

  [
    [[link boost_asio.reference.basic_serial_port.service [*service]]]
    [The service associated with the I/O object. ]
  ]

]

The basic_serial_port class template provides functionality that is common to all serial ports.


[heading Thread Safety]
  
[*Distinct] [*objects:]  Safe.

[*Shared] [*objects:]  Unsafe. 




[endsect]


[section:serial_port_base serial_port_base]

The serial_port_base class is used as a base for the basic_serial_port class template so that we have a common place to define the serial port options. 

  class serial_port_base


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.serial_port_base__baud_rate [*baud_rate]]]
    [Serial port option to permit changing the baud rate. ]
  
  ]

  [

    [[link boost_asio.reference.serial_port_base__character_size [*character_size]]]
    [Serial port option to permit changing the character size. ]
  
  ]

  [

    [[link boost_asio.reference.serial_port_base__flow_control [*flow_control]]]
    [Serial port option to permit changing the flow control. ]
  
  ]

  [

    [[link boost_asio.reference.serial_port_base__parity [*parity]]]
    [Serial port option to permit changing the parity. ]
  
  ]

  [

    [[link boost_asio.reference.serial_port_base__stop_bits [*stop_bits]]]
    [Serial port option to permit changing the number of stop bits. ]
  
  ]

]

[heading Protected Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.serial_port_base._serial_port_base [*~serial_port_base]]]
    [Protected destructor to prevent deletion through this type. ]
  ]
  
]


[section:_serial_port_base serial_port_base::~serial_port_base]

[indexterm2 ~serial_port_base..serial_port_base] Protected destructor to prevent deletion through this type. 

  ~serial_port_base();



[endsect]



[endsect]

[section:serial_port_base__baud_rate serial_port_base::baud_rate]

Serial port option to permit changing the baud rate. 

  class baud_rate


[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.serial_port_base__baud_rate.baud_rate [*baud_rate]]]
    []
  ]
  
  [
    [[link boost_asio.reference.serial_port_base__baud_rate.load [*load]]]
    []
  ]
  
  [
    [[link boost_asio.reference.serial_port_base__baud_rate.store [*store]]]
    []
  ]
  
  [
    [[link boost_asio.reference.serial_port_base__baud_rate.value [*value]]]
    []
  ]
  
]

Implements changing the baud rate for a given serial port. 


[section:baud_rate serial_port_base::baud_rate::baud_rate]

[indexterm2 baud_rate..serial_port_base::baud_rate] 

  baud_rate(
      unsigned int rate = 0);



[endsect]



[section:load serial_port_base::baud_rate::load]

[indexterm2 load..serial_port_base::baud_rate] 

  boost::system::error_code load(
      const BOOST_ASIO_OPTION_STORAGE & storage,
      boost::system::error_code & ec);



[endsect]



[section:store serial_port_base::baud_rate::store]

[indexterm2 store..serial_port_base::baud_rate] 

  boost::system::error_code store(
      BOOST_ASIO_OPTION_STORAGE & storage,
      boost::system::error_code & ec) const;



[endsect]



[section:value serial_port_base::baud_rate::value]

[indexterm2 value..serial_port_base::baud_rate] 

  unsigned int value() const;



[endsect]



[endsect]

[section:serial_port_base__character_size serial_port_base::character_size]

Serial port option to permit changing the character size. 

  class character_size


[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.serial_port_base__character_size.character_size [*character_size]]]
    []
  ]
  
  [
    [[link boost_asio.reference.serial_port_base__character_size.load [*load]]]
    []
  ]
  
  [
    [[link boost_asio.reference.serial_port_base__character_size.store [*store]]]
    []
  ]
  
  [
    [[link boost_asio.reference.serial_port_base__character_size.value [*value]]]
    []
  ]
  
]

Implements changing the character size for a given serial port. 


[section:character_size serial_port_base::character_size::character_size]

[indexterm2 character_size..serial_port_base::character_size] 

  character_size(
      unsigned int t = 8);



[endsect]



[section:load serial_port_base::character_size::load]

[indexterm2 load..serial_port_base::character_size] 

  boost::system::error_code load(
      const BOOST_ASIO_OPTION_STORAGE & storage,
      boost::system::error_code & ec);



[endsect]



[section:store serial_port_base::character_size::store]

[indexterm2 store..serial_port_base::character_size] 

  boost::system::error_code store(
      BOOST_ASIO_OPTION_STORAGE & storage,
      boost::system::error_code & ec) const;



[endsect]



[section:value serial_port_base::character_size::value]

[indexterm2 value..serial_port_base::character_size] 

  unsigned int value() const;



[endsect]



[endsect]

[section:serial_port_base__flow_control serial_port_base::flow_control]

Serial port option to permit changing the flow control. 

  class flow_control


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.serial_port_base__flow_control.type [*type]]]
    []
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.serial_port_base__flow_control.flow_control [*flow_control]]]
    []
  ]
  
  [
    [[link boost_asio.reference.serial_port_base__flow_control.load [*load]]]
    []
  ]
  
  [
    [[link boost_asio.reference.serial_port_base__flow_control.store [*store]]]
    []
  ]
  
  [
    [[link boost_asio.reference.serial_port_base__flow_control.value [*value]]]
    []
  ]
  
]

Implements changing the flow control for a given serial port. 


[section:flow_control serial_port_base::flow_control::flow_control]

[indexterm2 flow_control..serial_port_base::flow_control] 

  flow_control(
      type t = none);



[endsect]



[section:load serial_port_base::flow_control::load]

[indexterm2 load..serial_port_base::flow_control] 

  boost::system::error_code load(
      const BOOST_ASIO_OPTION_STORAGE & storage,
      boost::system::error_code & ec);



[endsect]



[section:store serial_port_base::flow_control::store]

[indexterm2 store..serial_port_base::flow_control] 

  boost::system::error_code store(
      BOOST_ASIO_OPTION_STORAGE & storage,
      boost::system::error_code & ec) const;



[endsect]



[section:type serial_port_base::flow_control::type]

[indexterm2 type..serial_port_base::flow_control] 

  enum type

[heading Values]
[variablelist

  [
    [none]
    []
  ]

  [
    [software]
    []
  ]

  [
    [hardware]
    []
  ]

]



[endsect]



[section:value serial_port_base::flow_control::value]

[indexterm2 value..serial_port_base::flow_control] 

  type value() const;



[endsect]



[endsect]

[section:serial_port_base__parity serial_port_base::parity]

Serial port option to permit changing the parity. 

  class parity


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.serial_port_base__parity.type [*type]]]
    []
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.serial_port_base__parity.load [*load]]]
    []
  ]
  
  [
    [[link boost_asio.reference.serial_port_base__parity.parity [*parity]]]
    []
  ]
  
  [
    [[link boost_asio.reference.serial_port_base__parity.store [*store]]]
    []
  ]
  
  [
    [[link boost_asio.reference.serial_port_base__parity.value [*value]]]
    []
  ]
  
]

Implements changing the parity for a given serial port. 


[section:load serial_port_base::parity::load]

[indexterm2 load..serial_port_base::parity] 

  boost::system::error_code load(
      const BOOST_ASIO_OPTION_STORAGE & storage,
      boost::system::error_code & ec);



[endsect]



[section:parity serial_port_base::parity::parity]

[indexterm2 parity..serial_port_base::parity] 

  parity(
      type t = none);



[endsect]



[section:store serial_port_base::parity::store]

[indexterm2 store..serial_port_base::parity] 

  boost::system::error_code store(
      BOOST_ASIO_OPTION_STORAGE & storage,
      boost::system::error_code & ec) const;



[endsect]



[section:type serial_port_base::parity::type]

[indexterm2 type..serial_port_base::parity] 

  enum type

[heading Values]
[variablelist

  [
    [none]
    []
  ]

  [
    [odd]
    []
  ]

  [
    [even]
    []
  ]

]



[endsect]



[section:value serial_port_base::parity::value]

[indexterm2 value..serial_port_base::parity] 

  type value() const;



[endsect]



[endsect]

[section:serial_port_base__stop_bits serial_port_base::stop_bits]

Serial port option to permit changing the number of stop bits. 

  class stop_bits


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.serial_port_base__stop_bits.type [*type]]]
    []
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.serial_port_base__stop_bits.load [*load]]]
    []
  ]
  
  [
    [[link boost_asio.reference.serial_port_base__stop_bits.stop_bits [*stop_bits]]]
    []
  ]
  
  [
    [[link boost_asio.reference.serial_port_base__stop_bits.store [*store]]]
    []
  ]
  
  [
    [[link boost_asio.reference.serial_port_base__stop_bits.value [*value]]]
    []
  ]
  
]

Implements changing the number of stop bits for a given serial port. 


[section:load serial_port_base::stop_bits::load]

[indexterm2 load..serial_port_base::stop_bits] 

  boost::system::error_code load(
      const BOOST_ASIO_OPTION_STORAGE & storage,
      boost::system::error_code & ec);



[endsect]



[section:stop_bits serial_port_base::stop_bits::stop_bits]

[indexterm2 stop_bits..serial_port_base::stop_bits] 

  stop_bits(
      type t = one);



[endsect]



[section:store serial_port_base::stop_bits::store]

[indexterm2 store..serial_port_base::stop_bits] 

  boost::system::error_code store(
      BOOST_ASIO_OPTION_STORAGE & storage,
      boost::system::error_code & ec) const;



[endsect]



[section:type serial_port_base::stop_bits::type]

[indexterm2 type..serial_port_base::stop_bits] 

  enum type

[heading Values]
[variablelist

  [
    [one]
    []
  ]

  [
    [onepointfive]
    []
  ]

  [
    [two]
    []
  ]

]



[endsect]



[section:value serial_port_base::stop_bits::value]

[indexterm2 value..serial_port_base::stop_bits] 

  type value() const;



[endsect]



[endsect]

[section:serial_port_service serial_port_service]

Default service implementation for a serial port. 

  class serial_port_service :
    public io_service::service


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.serial_port_service.implementation_type [*implementation_type]]]
    [The type of a serial port implementation. ]
  
  ]

  [

    [[link boost_asio.reference.serial_port_service.native_type [*native_type]]]
    [The native handle type. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.serial_port_service.assign [*assign]]]
    [Assign an existing native handle to a serial port. ]
  ]
  
  [
    [[link boost_asio.reference.serial_port_service.async_read_some [*async_read_some]]]
    [Start an asynchronous read. ]
  ]
  
  [
    [[link boost_asio.reference.serial_port_service.async_write_some [*async_write_some]]]
    [Start an asynchronous write. ]
  ]
  
  [
    [[link boost_asio.reference.serial_port_service.cancel [*cancel]]]
    [Cancel all asynchronous operations associated with the handle. ]
  ]
  
  [
    [[link boost_asio.reference.serial_port_service.close [*close]]]
    [Close a serial port implementation. ]
  ]
  
  [
    [[link boost_asio.reference.serial_port_service.construct [*construct]]]
    [Construct a new serial port implementation. ]
  ]
  
  [
    [[link boost_asio.reference.serial_port_service.destroy [*destroy]]]
    [Destroy a serial port implementation. ]
  ]
  
  [
    [[link boost_asio.reference.serial_port_service.get_io_service [*get_io_service]]]
    [Get the io_service object that owns the service. ]
  ]
  
  [
    [[link boost_asio.reference.serial_port_service.get_option [*get_option]]]
    [Get a serial port option. ]
  ]
  
  [
    [[link boost_asio.reference.serial_port_service.io_service [*io_service]]]
    [(Deprecated: use get_io_service().) Get the io_service object that owns the service. ]
  ]
  
  [
    [[link boost_asio.reference.serial_port_service.is_open [*is_open]]]
    [Determine whether the handle is open. ]
  ]
  
  [
    [[link boost_asio.reference.serial_port_service.native [*native]]]
    [Get the native handle implementation. ]
  ]
  
  [
    [[link boost_asio.reference.serial_port_service.open [*open]]]
    [Open a serial port. ]
  ]
  
  [
    [[link boost_asio.reference.serial_port_service.read_some [*read_some]]]
    [Read some data from the stream. ]
  ]
  
  [
    [[link boost_asio.reference.serial_port_service.send_break [*send_break]]]
    [Send a break sequence to the serial port. ]
  ]
  
  [
    [[link boost_asio.reference.serial_port_service.serial_port_service [*serial_port_service]]]
    [Construct a new serial port service for the specified io_service. ]
  ]
  
  [
    [[link boost_asio.reference.serial_port_service.set_option [*set_option]]]
    [Set a serial port option. ]
  ]
  
  [
    [[link boost_asio.reference.serial_port_service.shutdown_service [*shutdown_service]]]
    [Destroy all user-defined handler objects owned by the service. ]
  ]
  
  [
    [[link boost_asio.reference.serial_port_service.write_some [*write_some]]]
    [Write the given data to the stream. ]
  ]
  
]

[heading Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.serial_port_service.id [*id]]]
    [The unique service identifier. ]
  ]

]


[section:assign serial_port_service::assign]

[indexterm2 assign..serial_port_service] Assign an existing native handle to a serial port. 

  boost::system::error_code assign(
      implementation_type & impl,
      const native_type & native_handle,
      boost::system::error_code & ec);



[endsect]



[section:async_read_some serial_port_service::async_read_some]

[indexterm2 async_read_some..serial_port_service] Start an asynchronous read. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
  void async_read_some(
      implementation_type & impl,
      const MutableBufferSequence & buffers,
      ReadHandler handler);



[endsect]



[section:async_write_some serial_port_service::async_write_some]

[indexterm2 async_write_some..serial_port_service] Start an asynchronous write. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
  void async_write_some(
      implementation_type & impl,
      const ConstBufferSequence & buffers,
      WriteHandler handler);



[endsect]



[section:cancel serial_port_service::cancel]

[indexterm2 cancel..serial_port_service] Cancel all asynchronous operations associated with the handle. 

  boost::system::error_code cancel(
      implementation_type & impl,
      boost::system::error_code & ec);



[endsect]



[section:close serial_port_service::close]

[indexterm2 close..serial_port_service] Close a serial port implementation. 

  boost::system::error_code close(
      implementation_type & impl,
      boost::system::error_code & ec);



[endsect]



[section:construct serial_port_service::construct]

[indexterm2 construct..serial_port_service] Construct a new serial port implementation. 

  void construct(
      implementation_type & impl);



[endsect]



[section:destroy serial_port_service::destroy]

[indexterm2 destroy..serial_port_service] Destroy a serial port implementation. 

  void destroy(
      implementation_type & impl);



[endsect]



[section:get_io_service serial_port_service::get_io_service]


['Inherited from io_service.]

[indexterm2 get_io_service..serial_port_service] Get the io_service object that owns the service. 

  boost::asio::io_service & get_io_service();



[endsect]



[section:get_option serial_port_service::get_option]

[indexterm2 get_option..serial_port_service] Get a serial port option. 

  template<
      typename ``[link boost_asio.reference.GettableSerialPortOption GettableSerialPortOption]``>
  boost::system::error_code get_option(
      const implementation_type & impl,
      GettableSerialPortOption & option,
      boost::system::error_code & ec) const;



[endsect]



[section:id serial_port_service::id]

[indexterm2 id..serial_port_service] The unique service identifier. 

  static boost::asio::io_service::id id;



[endsect]



[section:implementation_type serial_port_service::implementation_type]

[indexterm2 implementation_type..serial_port_service] The type of a serial port implementation. 

  typedef implementation_defined implementation_type;




[endsect]



[section:io_service serial_port_service::io_service]


['Inherited from io_service.]

[indexterm2 io_service..serial_port_service] (Deprecated: use get_io_service().) Get the io_service object that owns the service. 

  boost::asio::io_service & io_service();



[endsect]



[section:is_open serial_port_service::is_open]

[indexterm2 is_open..serial_port_service] Determine whether the handle is open. 

  bool is_open(
      const implementation_type & impl) const;



[endsect]



[section:native serial_port_service::native]

[indexterm2 native..serial_port_service] Get the native handle implementation. 

  native_type native(
      implementation_type & impl);



[endsect]



[section:native_type serial_port_service::native_type]

[indexterm2 native_type..serial_port_service] The native handle type. 

  typedef implementation_defined native_type;




[endsect]



[section:open serial_port_service::open]

[indexterm2 open..serial_port_service] Open a serial port. 

  boost::system::error_code open(
      implementation_type & impl,
      const std::string & device,
      boost::system::error_code & ec);



[endsect]



[section:read_some serial_port_service::read_some]

[indexterm2 read_some..serial_port_service] Read some data from the stream. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t read_some(
      implementation_type & impl,
      const MutableBufferSequence & buffers,
      boost::system::error_code & ec);



[endsect]



[section:send_break serial_port_service::send_break]

[indexterm2 send_break..serial_port_service] Send a break sequence to the serial port. 

  boost::system::error_code send_break(
      implementation_type & impl,
      boost::system::error_code & ec);



[endsect]



[section:serial_port_service serial_port_service::serial_port_service]

[indexterm2 serial_port_service..serial_port_service] Construct a new serial port service for the specified io_service. 

  serial_port_service(
      boost::asio::io_service & io_service);



[endsect]



[section:set_option serial_port_service::set_option]

[indexterm2 set_option..serial_port_service] Set a serial port option. 

  template<
      typename ``[link boost_asio.reference.SettableSerialPortOption SettableSerialPortOption]``>
  boost::system::error_code set_option(
      implementation_type & impl,
      const SettableSerialPortOption & option,
      boost::system::error_code & ec);



[endsect]



[section:shutdown_service serial_port_service::shutdown_service]

[indexterm2 shutdown_service..serial_port_service] Destroy all user-defined handler objects owned by the service. 

  void shutdown_service();



[endsect]



[section:write_some serial_port_service::write_some]

[indexterm2 write_some..serial_port_service] Write the given data to the stream. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t write_some(
      implementation_type & impl,
      const ConstBufferSequence & buffers,
      boost::system::error_code & ec);



[endsect]



[endsect]

[section:service_already_exists service_already_exists]

Exception thrown when trying to add a duplicate service to an io_service. 

  class service_already_exists


[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.service_already_exists.service_already_exists [*service_already_exists]]]
    []
  ]
  
]


[section:service_already_exists service_already_exists::service_already_exists]

[indexterm2 service_already_exists..service_already_exists] 

  service_already_exists();



[endsect]



[endsect]

[section:socket_acceptor_service socket_acceptor_service]

Default service implementation for a socket acceptor. 

  template<
      typename ``[link boost_asio.reference.Protocol Protocol]``>
  class socket_acceptor_service :
    public io_service::service


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.socket_acceptor_service.endpoint_type [*endpoint_type]]]
    [The endpoint type. ]
  
  ]

  [

    [[link boost_asio.reference.socket_acceptor_service.implementation_type [*implementation_type]]]
    [The native type of the socket acceptor. ]
  
  ]

  [

    [[link boost_asio.reference.socket_acceptor_service.native_type [*native_type]]]
    [The native acceptor type. ]
  
  ]

  [

    [[link boost_asio.reference.socket_acceptor_service.protocol_type [*protocol_type]]]
    [The protocol type. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.socket_acceptor_service.accept [*accept]]]
    [Accept a new connection. ]
  ]
  
  [
    [[link boost_asio.reference.socket_acceptor_service.assign [*assign]]]
    [Assign an existing native acceptor to a socket acceptor. ]
  ]
  
  [
    [[link boost_asio.reference.socket_acceptor_service.async_accept [*async_accept]]]
    [Start an asynchronous accept. ]
  ]
  
  [
    [[link boost_asio.reference.socket_acceptor_service.bind [*bind]]]
    [Bind the socket acceptor to the specified local endpoint. ]
  ]
  
  [
    [[link boost_asio.reference.socket_acceptor_service.cancel [*cancel]]]
    [Cancel all asynchronous operations associated with the acceptor. ]
  ]
  
  [
    [[link boost_asio.reference.socket_acceptor_service.close [*close]]]
    [Close a socket acceptor implementation. ]
  ]
  
  [
    [[link boost_asio.reference.socket_acceptor_service.construct [*construct]]]
    [Construct a new socket acceptor implementation. ]
  ]
  
  [
    [[link boost_asio.reference.socket_acceptor_service.destroy [*destroy]]]
    [Destroy a socket acceptor implementation. ]
  ]
  
  [
    [[link boost_asio.reference.socket_acceptor_service.get_io_service [*get_io_service]]]
    [Get the io_service object that owns the service. ]
  ]
  
  [
    [[link boost_asio.reference.socket_acceptor_service.get_option [*get_option]]]
    [Get a socket option. ]
  ]
  
  [
    [[link boost_asio.reference.socket_acceptor_service.io_control [*io_control]]]
    [Perform an IO control command on the socket. ]
  ]
  
  [
    [[link boost_asio.reference.socket_acceptor_service.io_service [*io_service]]]
    [(Deprecated: use get_io_service().) Get the io_service object that owns the service. ]
  ]
  
  [
    [[link boost_asio.reference.socket_acceptor_service.is_open [*is_open]]]
    [Determine whether the acceptor is open. ]
  ]
  
  [
    [[link boost_asio.reference.socket_acceptor_service.listen [*listen]]]
    [Place the socket acceptor into the state where it will listen for new connections. ]
  ]
  
  [
    [[link boost_asio.reference.socket_acceptor_service.local_endpoint [*local_endpoint]]]
    [Get the local endpoint. ]
  ]
  
  [
    [[link boost_asio.reference.socket_acceptor_service.native [*native]]]
    [Get the native acceptor implementation. ]
  ]
  
  [
    [[link boost_asio.reference.socket_acceptor_service.open [*open]]]
    [Open a new socket acceptor implementation. ]
  ]
  
  [
    [[link boost_asio.reference.socket_acceptor_service.set_option [*set_option]]]
    [Set a socket option. ]
  ]
  
  [
    [[link boost_asio.reference.socket_acceptor_service.shutdown_service [*shutdown_service]]]
    [Destroy all user-defined handler objects owned by the service. ]
  ]
  
  [
    [[link boost_asio.reference.socket_acceptor_service.socket_acceptor_service [*socket_acceptor_service]]]
    [Construct a new socket acceptor service for the specified io_service. ]
  ]
  
]

[heading Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.socket_acceptor_service.id [*id]]]
    [The unique service identifier. ]
  ]

]


[section:accept socket_acceptor_service::accept]

[indexterm2 accept..socket_acceptor_service] Accept a new connection. 

  template<
      typename ``[link boost_asio.reference.SocketService SocketService]``>
  boost::system::error_code accept(
      implementation_type & impl,
      basic_socket< protocol_type, SocketService > & peer,
      endpoint_type * peer_endpoint,
      boost::system::error_code & ec);



[endsect]



[section:assign socket_acceptor_service::assign]

[indexterm2 assign..socket_acceptor_service] Assign an existing native acceptor to a socket acceptor. 

  boost::system::error_code assign(
      implementation_type & impl,
      const protocol_type & protocol,
      const native_type & native_acceptor,
      boost::system::error_code & ec);



[endsect]



[section:async_accept socket_acceptor_service::async_accept]

[indexterm2 async_accept..socket_acceptor_service] Start an asynchronous accept. 

  template<
      typename ``[link boost_asio.reference.SocketService SocketService]``,
      typename ``[link boost_asio.reference.AcceptHandler AcceptHandler]``>
  void async_accept(
      implementation_type & impl,
      basic_socket< protocol_type, SocketService > & peer,
      endpoint_type * peer_endpoint,
      AcceptHandler handler);



[endsect]



[section:bind socket_acceptor_service::bind]

[indexterm2 bind..socket_acceptor_service] Bind the socket acceptor to the specified local endpoint. 

  boost::system::error_code bind(
      implementation_type & impl,
      const endpoint_type & endpoint,
      boost::system::error_code & ec);



[endsect]



[section:cancel socket_acceptor_service::cancel]

[indexterm2 cancel..socket_acceptor_service] Cancel all asynchronous operations associated with the acceptor. 

  boost::system::error_code cancel(
      implementation_type & impl,
      boost::system::error_code & ec);



[endsect]



[section:close socket_acceptor_service::close]

[indexterm2 close..socket_acceptor_service] Close a socket acceptor implementation. 

  boost::system::error_code close(
      implementation_type & impl,
      boost::system::error_code & ec);



[endsect]



[section:construct socket_acceptor_service::construct]

[indexterm2 construct..socket_acceptor_service] Construct a new socket acceptor implementation. 

  void construct(
      implementation_type & impl);



[endsect]



[section:destroy socket_acceptor_service::destroy]

[indexterm2 destroy..socket_acceptor_service] Destroy a socket acceptor implementation. 

  void destroy(
      implementation_type & impl);



[endsect]



[section:endpoint_type socket_acceptor_service::endpoint_type]

[indexterm2 endpoint_type..socket_acceptor_service] The endpoint type. 

  typedef protocol_type::endpoint endpoint_type;




[endsect]



[section:get_io_service socket_acceptor_service::get_io_service]


['Inherited from io_service.]

[indexterm2 get_io_service..socket_acceptor_service] Get the io_service object that owns the service. 

  boost::asio::io_service & get_io_service();



[endsect]



[section:get_option socket_acceptor_service::get_option]

[indexterm2 get_option..socket_acceptor_service] Get a socket option. 

  template<
      typename ``[link boost_asio.reference.GettableSocketOption GettableSocketOption]``>
  boost::system::error_code get_option(
      const implementation_type & impl,
      GettableSocketOption & option,
      boost::system::error_code & ec) const;



[endsect]



[section:id socket_acceptor_service::id]

[indexterm2 id..socket_acceptor_service] The unique service identifier. 

  static boost::asio::io_service::id id;



[endsect]



[section:implementation_type socket_acceptor_service::implementation_type]

[indexterm2 implementation_type..socket_acceptor_service] The native type of the socket acceptor. 

  typedef implementation_defined implementation_type;




[endsect]



[section:io_control socket_acceptor_service::io_control]

[indexterm2 io_control..socket_acceptor_service] Perform an IO control command on the socket. 

  template<
      typename ``[link boost_asio.reference.IoControlCommand IoControlCommand]``>
  boost::system::error_code io_control(
      implementation_type & impl,
      IoControlCommand & command,
      boost::system::error_code & ec);



[endsect]



[section:io_service socket_acceptor_service::io_service]


['Inherited from io_service.]

[indexterm2 io_service..socket_acceptor_service] (Deprecated: use get_io_service().) Get the io_service object that owns the service. 

  boost::asio::io_service & io_service();



[endsect]



[section:is_open socket_acceptor_service::is_open]

[indexterm2 is_open..socket_acceptor_service] Determine whether the acceptor is open. 

  bool is_open(
      const implementation_type & impl) const;



[endsect]



[section:listen socket_acceptor_service::listen]

[indexterm2 listen..socket_acceptor_service] Place the socket acceptor into the state where it will listen for new connections. 

  boost::system::error_code listen(
      implementation_type & impl,
      int backlog,
      boost::system::error_code & ec);



[endsect]



[section:local_endpoint socket_acceptor_service::local_endpoint]

[indexterm2 local_endpoint..socket_acceptor_service] Get the local endpoint. 

  endpoint_type local_endpoint(
      const implementation_type & impl,
      boost::system::error_code & ec) const;



[endsect]



[section:native socket_acceptor_service::native]

[indexterm2 native..socket_acceptor_service] Get the native acceptor implementation. 

  native_type native(
      implementation_type & impl);



[endsect]



[section:native_type socket_acceptor_service::native_type]

[indexterm2 native_type..socket_acceptor_service] The native acceptor type. 

  typedef implementation_defined native_type;




[endsect]



[section:open socket_acceptor_service::open]

[indexterm2 open..socket_acceptor_service] Open a new socket acceptor implementation. 

  boost::system::error_code open(
      implementation_type & impl,
      const protocol_type & protocol,
      boost::system::error_code & ec);



[endsect]



[section:protocol_type socket_acceptor_service::protocol_type]

[indexterm2 protocol_type..socket_acceptor_service] The protocol type. 

  typedef Protocol protocol_type;




[endsect]



[section:set_option socket_acceptor_service::set_option]

[indexterm2 set_option..socket_acceptor_service] Set a socket option. 

  template<
      typename ``[link boost_asio.reference.SettableSocketOption SettableSocketOption]``>
  boost::system::error_code set_option(
      implementation_type & impl,
      const SettableSocketOption & option,
      boost::system::error_code & ec);



[endsect]



[section:shutdown_service socket_acceptor_service::shutdown_service]

[indexterm2 shutdown_service..socket_acceptor_service] Destroy all user-defined handler objects owned by the service. 

  void shutdown_service();



[endsect]



[section:socket_acceptor_service socket_acceptor_service::socket_acceptor_service]

[indexterm2 socket_acceptor_service..socket_acceptor_service] Construct a new socket acceptor service for the specified io_service. 

  socket_acceptor_service(
      boost::asio::io_service & io_service);



[endsect]



[endsect]

[section:socket_base socket_base]

The socket_base class is used as a base for the basic_stream_socket and basic_datagram_socket class templates so that we have a common place to define the shutdown_type and enum. 

  class socket_base


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.socket_base.broadcast [*broadcast]]]
    [Socket option to permit sending of broadcast messages. ]
  
  ]

  [

    [[link boost_asio.reference.socket_base.bytes_readable [*bytes_readable]]]
    [IO control command to get the amount of data that can be read without blocking. ]
  
  ]

  [

    [[link boost_asio.reference.socket_base.debug [*debug]]]
    [Socket option to enable socket-level debugging. ]
  
  ]

  [

    [[link boost_asio.reference.socket_base.do_not_route [*do_not_route]]]
    [Socket option to prevent routing, use local interfaces only. ]
  
  ]

  [

    [[link boost_asio.reference.socket_base.enable_connection_aborted [*enable_connection_aborted]]]
    [Socket option to report aborted connections on accept. ]
  
  ]

  [

    [[link boost_asio.reference.socket_base.keep_alive [*keep_alive]]]
    [Socket option to send keep-alives. ]
  
  ]

  [

    [[link boost_asio.reference.socket_base.linger [*linger]]]
    [Socket option to specify whether the socket lingers on close if unsent data is present. ]
  
  ]

  [

    [[link boost_asio.reference.socket_base.message_flags [*message_flags]]]
    [Bitmask type for flags that can be passed to send and receive operations. ]
  
  ]

  [

    [[link boost_asio.reference.socket_base.non_blocking_io [*non_blocking_io]]]
    [IO control command to set the blocking mode of the socket. ]
  
  ]

  [

    [[link boost_asio.reference.socket_base.receive_buffer_size [*receive_buffer_size]]]
    [Socket option for the receive buffer size of a socket. ]
  
  ]

  [

    [[link boost_asio.reference.socket_base.receive_low_watermark [*receive_low_watermark]]]
    [Socket option for the receive low watermark. ]
  
  ]

  [

    [[link boost_asio.reference.socket_base.reuse_address [*reuse_address]]]
    [Socket option to allow the socket to be bound to an address that is already in use. ]
  
  ]

  [

    [[link boost_asio.reference.socket_base.send_buffer_size [*send_buffer_size]]]
    [Socket option for the send buffer size of a socket. ]
  
  ]

  [

    [[link boost_asio.reference.socket_base.send_low_watermark [*send_low_watermark]]]
    [Socket option for the send low watermark. ]
  
  ]

  [

    [[link boost_asio.reference.socket_base.shutdown_type [*shutdown_type]]]
    [Different ways a socket may be shutdown. ]
  
  ]

]

[heading Protected Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.socket_base._socket_base [*~socket_base]]]
    [Protected destructor to prevent deletion through this type. ]
  ]
  
]

[heading Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.socket_base.max_connections [*max_connections]]]
    [The maximum length of the queue of pending incoming connections. ]
  ]

  [
    [[link boost_asio.reference.socket_base.message_do_not_route [*message_do_not_route]]]
    [Specify that the data should not be subject to routing. ]
  ]

  [
    [[link boost_asio.reference.socket_base.message_out_of_band [*message_out_of_band]]]
    [Process out-of-band data. ]
  ]

  [
    [[link boost_asio.reference.socket_base.message_peek [*message_peek]]]
    [Peek at incoming data without removing it from the input queue. ]
  ]

]


[section:broadcast socket_base::broadcast]

[indexterm2 broadcast..socket_base] Socket option to permit sending of broadcast messages. 

  typedef implementation_defined broadcast;



Implements the SOL\_SOCKET/SO\_BROADCAST socket option.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::udp::socket socket(io_service); 
   ...
   boost::asio::socket_base::broadcast option(true);
   socket.set_option(option);




Getting the current option value: 

   boost::asio::ip::udp::socket socket(io_service); 
   ...
   boost::asio::socket_base::broadcast option;
   socket.get_option(option);
   bool is_set = option.value();






[endsect]



[section:bytes_readable socket_base::bytes_readable]

[indexterm2 bytes_readable..socket_base] IO control command to get the amount of data that can be read without blocking. 

  typedef implementation_defined bytes_readable;



Implements the FIONREAD IO control command.


[heading Example]
  


   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::bytes_readable command(true);
   socket.io_control(command);
   std::size_t bytes_readable = command.get();






[endsect]



[section:debug socket_base::debug]

[indexterm2 debug..socket_base] Socket option to enable socket-level debugging. 

  typedef implementation_defined debug;



Implements the SOL\_SOCKET/SO\_DEBUG socket option.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::debug option(true);
   socket.set_option(option);




Getting the current option value: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::debug option;
   socket.get_option(option);
   bool is_set = option.value();






[endsect]



[section:do_not_route socket_base::do_not_route]

[indexterm2 do_not_route..socket_base] Socket option to prevent routing, use local interfaces only. 

  typedef implementation_defined do_not_route;



Implements the SOL\_SOCKET/SO\_DONTROUTE socket option.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::udp::socket socket(io_service); 
   ...
   boost::asio::socket_base::do_not_route option(true);
   socket.set_option(option);




Getting the current option value: 

   boost::asio::ip::udp::socket socket(io_service); 
   ...
   boost::asio::socket_base::do_not_route option;
   socket.get_option(option);
   bool is_set = option.value();






[endsect]



[section:enable_connection_aborted socket_base::enable_connection_aborted]

[indexterm2 enable_connection_aborted..socket_base] Socket option to report aborted connections on accept. 

  typedef implementation_defined enable_connection_aborted;



Implements a custom socket option that determines whether or not an accept operation is permitted to fail with boost::asio::error::connection\_aborted. By default the option is false.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::tcp::acceptor acceptor(io_service); 
   ...
   boost::asio::socket_base::enable_connection_aborted option(true);
   acceptor.set_option(option);




Getting the current option value: 

   boost::asio::ip::tcp::acceptor acceptor(io_service); 
   ...
   boost::asio::socket_base::enable_connection_aborted option;
   acceptor.get_option(option);
   bool is_set = option.value();






[endsect]



[section:keep_alive socket_base::keep_alive]

[indexterm2 keep_alive..socket_base] Socket option to send keep-alives. 

  typedef implementation_defined keep_alive;



Implements the SOL\_SOCKET/SO\_KEEPALIVE socket option.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::keep_alive option(true);
   socket.set_option(option);




Getting the current option value: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::keep_alive option;
   socket.get_option(option);
   bool is_set = option.value();






[endsect]



[section:linger socket_base::linger]

[indexterm2 linger..socket_base] Socket option to specify whether the socket lingers on close if unsent data is present. 

  typedef implementation_defined linger;



Implements the SOL\_SOCKET/SO\_LINGER socket option.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::linger option(true, 30);
   socket.set_option(option);




Getting the current option value: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::linger option;
   socket.get_option(option);
   bool is_set = option.enabled();
   unsigned short timeout = option.timeout();






[endsect]



[section:max_connections socket_base::max_connections]

[indexterm2 max_connections..socket_base] The maximum length of the queue of pending incoming connections. 

  static const int max_connections = implementation_defined;



[endsect]



[section:message_do_not_route socket_base::message_do_not_route]

[indexterm2 message_do_not_route..socket_base] Specify that the data should not be subject to routing. 

  static const int message_do_not_route = implementation_defined;



[endsect]



[section:message_flags socket_base::message_flags]

[indexterm2 message_flags..socket_base] Bitmask type for flags that can be passed to send and receive operations. 

  typedef int message_flags;




[endsect]



[section:message_out_of_band socket_base::message_out_of_band]

[indexterm2 message_out_of_band..socket_base] Process out-of-band data. 

  static const int message_out_of_band = implementation_defined;



[endsect]



[section:message_peek socket_base::message_peek]

[indexterm2 message_peek..socket_base] Peek at incoming data without removing it from the input queue. 

  static const int message_peek = implementation_defined;



[endsect]



[section:non_blocking_io socket_base::non_blocking_io]

[indexterm2 non_blocking_io..socket_base] IO control command to set the blocking mode of the socket. 

  typedef implementation_defined non_blocking_io;



Implements the FIONBIO IO control command.


[heading Example]
  


   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::non_blocking_io command(true);
   socket.io_control(command);






[endsect]



[section:receive_buffer_size socket_base::receive_buffer_size]

[indexterm2 receive_buffer_size..socket_base] Socket option for the receive buffer size of a socket. 

  typedef implementation_defined receive_buffer_size;



Implements the SOL\_SOCKET/SO\_RCVBUF socket option.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::receive_buffer_size option(8192);
   socket.set_option(option);




Getting the current option value: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::receive_buffer_size option;
   socket.get_option(option);
   int size = option.value();






[endsect]



[section:receive_low_watermark socket_base::receive_low_watermark]

[indexterm2 receive_low_watermark..socket_base] Socket option for the receive low watermark. 

  typedef implementation_defined receive_low_watermark;



Implements the SOL\_SOCKET/SO\_RCVLOWAT socket option.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::receive_low_watermark option(1024);
   socket.set_option(option);




Getting the current option value: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::receive_low_watermark option;
   socket.get_option(option);
   int size = option.value();






[endsect]



[section:reuse_address socket_base::reuse_address]

[indexterm2 reuse_address..socket_base] Socket option to allow the socket to be bound to an address that is already in use. 

  typedef implementation_defined reuse_address;



Implements the SOL\_SOCKET/SO\_REUSEADDR socket option.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::tcp::acceptor acceptor(io_service); 
   ...
   boost::asio::socket_base::reuse_address option(true);
   acceptor.set_option(option);




Getting the current option value: 

   boost::asio::ip::tcp::acceptor acceptor(io_service); 
   ...
   boost::asio::socket_base::reuse_address option;
   acceptor.get_option(option);
   bool is_set = option.value();






[endsect]



[section:send_buffer_size socket_base::send_buffer_size]

[indexterm2 send_buffer_size..socket_base] Socket option for the send buffer size of a socket. 

  typedef implementation_defined send_buffer_size;



Implements the SOL\_SOCKET/SO\_SNDBUF socket option.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::send_buffer_size option(8192);
   socket.set_option(option);




Getting the current option value: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::send_buffer_size option;
   socket.get_option(option);
   int size = option.value();






[endsect]



[section:send_low_watermark socket_base::send_low_watermark]

[indexterm2 send_low_watermark..socket_base] Socket option for the send low watermark. 

  typedef implementation_defined send_low_watermark;



Implements the SOL\_SOCKET/SO\_SNDLOWAT socket option.


[heading Examples]
  
Setting the option: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::send_low_watermark option(1024);
   socket.set_option(option);




Getting the current option value: 

   boost::asio::ip::tcp::socket socket(io_service); 
   ...
   boost::asio::socket_base::send_low_watermark option;
   socket.get_option(option);
   int size = option.value();






[endsect]



[section:shutdown_type socket_base::shutdown_type]

[indexterm2 shutdown_type..socket_base] Different ways a socket may be shutdown. 

  enum shutdown_type

[heading Values]
[variablelist

  [
    [shutdown_receive]
    [Shutdown the receive side of the socket. ]
  ]

  [
    [shutdown_send]
    [Shutdown the send side of the socket. ]
  ]

  [
    [shutdown_both]
    [Shutdown both send and receive on the socket. ]
  ]

]



[endsect]



[section:_socket_base socket_base::~socket_base]

[indexterm2 ~socket_base..socket_base] Protected destructor to prevent deletion through this type. 

  ~socket_base();



[endsect]



[endsect]

[section:ssl__basic_context ssl::basic_context]

SSL context. 

  template<
      typename ``[link boost_asio.reference.Service Service]``>
  class basic_context :
    public ssl::context_base


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.ssl__basic_context.file_format [*file_format]]]
    [File format types. ]
  
  ]

  [

    [[link boost_asio.reference.ssl__basic_context.impl_type [*impl_type]]]
    [The native implementation type of the locking dispatcher. ]
  
  ]

  [

    [[link boost_asio.reference.ssl__basic_context.method [*method]]]
    [Different methods supported by a context. ]
  
  ]

  [

    [[link boost_asio.reference.ssl__basic_context.options [*options]]]
    [Bitmask type for SSL options. ]
  
  ]

  [

    [[link boost_asio.reference.ssl__basic_context.password_purpose [*password_purpose]]]
    [Purpose of PEM password. ]
  
  ]

  [

    [[link boost_asio.reference.ssl__basic_context.service_type [*service_type]]]
    [The type of the service that will be used to provide context operations. ]
  
  ]

  [

    [[link boost_asio.reference.ssl__basic_context.verify_mode [*verify_mode]]]
    [Bitmask type for peer verification. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.ssl__basic_context.add_verify_path [*add_verify_path]]]
    [Add a directory containing certificate authority files to be used for performing verification. ]
  ]
  
  [
    [[link boost_asio.reference.ssl__basic_context.basic_context [*basic_context]]]
    [Constructor. ]
  ]
  
  [
    [[link boost_asio.reference.ssl__basic_context.impl [*impl]]]
    [Get the underlying implementation in the native type. ]
  ]
  
  [
    [[link boost_asio.reference.ssl__basic_context.load_verify_file [*load_verify_file]]]
    [Load a certification authority file for performing verification. ]
  ]
  
  [
    [[link boost_asio.reference.ssl__basic_context.set_options [*set_options]]]
    [Set options on the context. ]
  ]
  
  [
    [[link boost_asio.reference.ssl__basic_context.set_password_callback [*set_password_callback]]]
    [Set the password callback. ]
  ]
  
  [
    [[link boost_asio.reference.ssl__basic_context.set_verify_mode [*set_verify_mode]]]
    [Set the peer verification mode. ]
  ]
  
  [
    [[link boost_asio.reference.ssl__basic_context.use_certificate_chain_file [*use_certificate_chain_file]]]
    [Use a certificate chain from a file. ]
  ]
  
  [
    [[link boost_asio.reference.ssl__basic_context.use_certificate_file [*use_certificate_file]]]
    [Use a certificate from a file. ]
  ]
  
  [
    [[link boost_asio.reference.ssl__basic_context.use_private_key_file [*use_private_key_file]]]
    [Use a private key from a file. ]
  ]
  
  [
    [[link boost_asio.reference.ssl__basic_context.use_rsa_private_key_file [*use_rsa_private_key_file]]]
    [Use an RSA private key from a file. ]
  ]
  
  [
    [[link boost_asio.reference.ssl__basic_context.use_tmp_dh_file [*use_tmp_dh_file]]]
    [Use the specified file to obtain the temporary Diffie-Hellman parameters. ]
  ]
  
  [
    [[link boost_asio.reference.ssl__basic_context._basic_context [*~basic_context]]]
    [Destructor. ]
  ]
  
]

[heading Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.ssl__basic_context.default_workarounds [*default_workarounds]]]
    [Implement various bug workarounds. ]
  ]

  [
    [[link boost_asio.reference.ssl__basic_context.no_sslv2 [*no_sslv2]]]
    [Disable SSL v2. ]
  ]

  [
    [[link boost_asio.reference.ssl__basic_context.no_sslv3 [*no_sslv3]]]
    [Disable SSL v3. ]
  ]

  [
    [[link boost_asio.reference.ssl__basic_context.no_tlsv1 [*no_tlsv1]]]
    [Disable TLS v1. ]
  ]

  [
    [[link boost_asio.reference.ssl__basic_context.single_dh_use [*single_dh_use]]]
    [Always create a new key when using tmp_dh parameters. ]
  ]

  [
    [[link boost_asio.reference.ssl__basic_context.verify_client_once [*verify_client_once]]]
    [Do not request client certificate on renegotiation. Ignored unless verify_peer is set. ]
  ]

  [
    [[link boost_asio.reference.ssl__basic_context.verify_fail_if_no_peer_cert [*verify_fail_if_no_peer_cert]]]
    [Fail verification if the peer has no certificate. Ignored unless verify_peer is set. ]
  ]

  [
    [[link boost_asio.reference.ssl__basic_context.verify_none [*verify_none]]]
    [No verification. ]
  ]

  [
    [[link boost_asio.reference.ssl__basic_context.verify_peer [*verify_peer]]]
    [Verify the peer. ]
  ]

]

[section:add_verify_path ssl::basic_context::add_verify_path]

[indexterm2 add_verify_path..ssl::basic_context] Add a directory containing certificate authority files to be used for performing verification. 

  void ``[link boost_asio.reference.ssl__basic_context.add_verify_path.overload1 add_verify_path]``(
      const std::string & path);

  boost::system::error_code ``[link boost_asio.reference.ssl__basic_context.add_verify_path.overload2 add_verify_path]``(
      const std::string & path,
      boost::system::error_code & ec);


[section:overload1 ssl::basic_context::add_verify_path (1 of 2 overloads)]

Add a directory containing certificate authority files to be used for performing verification. 

  void add_verify_path(
      const std::string & path);


This function is used to specify the name of a directory containing certification authority certificates. Each file in the directory must contain a single certificate. The files must be named using the subject name's hash and an extension of ".0".


[heading Parameters]
    

[variablelist
  
[[path][The name of a directory containing the certificates.]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. ]]

]



[endsect]



[section:overload2 ssl::basic_context::add_verify_path (2 of 2 overloads)]

Add a directory containing certificate authority files to be used for performing verification. 

  boost::system::error_code add_verify_path(
      const std::string & path,
      boost::system::error_code & ec);


This function is used to specify the name of a directory containing certification authority certificates. Each file in the directory must contain a single certificate. The files must be named using the subject name's hash and an extension of ".0".


[heading Parameters]
    

[variablelist
  
[[path][The name of a directory containing the certificates.]]

[[ec][Set to indicate what error occurred, if any. ]]

]



[endsect]


[endsect]


[section:basic_context ssl::basic_context::basic_context]

[indexterm2 basic_context..ssl::basic_context] Constructor. 

  basic_context(
      boost::asio::io_service & io_service,
      method m);



[endsect]



[section:default_workarounds ssl::basic_context::default_workarounds]


['Inherited from ssl::context_base.]

[indexterm2 default_workarounds..ssl::basic_context] Implement various bug workarounds. 

  static const int default_workarounds = implementation_defined;



[endsect]



[section:file_format ssl::basic_context::file_format]


['Inherited from ssl::context_base.]

[indexterm2 file_format..ssl::basic_context] File format types. 

  enum file_format

[heading Values]
[variablelist

  [
    [asn1]
    [ASN.1 file. ]
  ]

  [
    [pem]
    [PEM file. ]
  ]

]



[endsect]



[section:impl ssl::basic_context::impl]

[indexterm2 impl..ssl::basic_context] Get the underlying implementation in the native type. 

  impl_type impl();


This function may be used to obtain the underlying implementation of the context. This is intended to allow access to context functionality that is not otherwise provided. 


[endsect]



[section:impl_type ssl::basic_context::impl_type]

[indexterm2 impl_type..ssl::basic_context] The native implementation type of the locking dispatcher. 

  typedef service_type::impl_type impl_type;




[endsect]


[section:load_verify_file ssl::basic_context::load_verify_file]

[indexterm2 load_verify_file..ssl::basic_context] Load a certification authority file for performing verification. 

  void ``[link boost_asio.reference.ssl__basic_context.load_verify_file.overload1 load_verify_file]``(
      const std::string & filename);

  boost::system::error_code ``[link boost_asio.reference.ssl__basic_context.load_verify_file.overload2 load_verify_file]``(
      const std::string & filename,
      boost::system::error_code & ec);


[section:overload1 ssl::basic_context::load_verify_file (1 of 2 overloads)]

Load a certification authority file for performing verification. 

  void load_verify_file(
      const std::string & filename);


This function is used to load one or more trusted certification authorities from a file.


[heading Parameters]
    

[variablelist
  
[[filename][The name of a file containing certification authority certificates in PEM format.]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. ]]

]



[endsect]



[section:overload2 ssl::basic_context::load_verify_file (2 of 2 overloads)]

Load a certification authority file for performing verification. 

  boost::system::error_code load_verify_file(
      const std::string & filename,
      boost::system::error_code & ec);


This function is used to load the certificates for one or more trusted certification authorities from a file.


[heading Parameters]
    

[variablelist
  
[[filename][The name of a file containing certification authority certificates in PEM format.]]

[[ec][Set to indicate what error occurred, if any. ]]

]



[endsect]


[endsect]


[section:method ssl::basic_context::method]


['Inherited from ssl::context_base.]

[indexterm2 method..ssl::basic_context] Different methods supported by a context. 

  enum method

[heading Values]
[variablelist

  [
    [sslv2]
    [Generic SSL version 2. ]
  ]

  [
    [sslv2_client]
    [SSL version 2 client. ]
  ]

  [
    [sslv2_server]
    [SSL version 2 server. ]
  ]

  [
    [sslv3]
    [Generic SSL version 3. ]
  ]

  [
    [sslv3_client]
    [SSL version 3 client. ]
  ]

  [
    [sslv3_server]
    [SSL version 3 server. ]
  ]

  [
    [tlsv1]
    [Generic TLS version 1. ]
  ]

  [
    [tlsv1_client]
    [TLS version 1 client. ]
  ]

  [
    [tlsv1_server]
    [TLS version 1 server. ]
  ]

  [
    [sslv23]
    [Generic SSL/TLS. ]
  ]

  [
    [sslv23_client]
    [SSL/TLS client. ]
  ]

  [
    [sslv23_server]
    [SSL/TLS server. ]
  ]

]



[endsect]



[section:no_sslv2 ssl::basic_context::no_sslv2]


['Inherited from ssl::context_base.]

[indexterm2 no_sslv2..ssl::basic_context] Disable SSL v2. 

  static const int no_sslv2 = implementation_defined;



[endsect]



[section:no_sslv3 ssl::basic_context::no_sslv3]


['Inherited from ssl::context_base.]

[indexterm2 no_sslv3..ssl::basic_context] Disable SSL v3. 

  static const int no_sslv3 = implementation_defined;



[endsect]



[section:no_tlsv1 ssl::basic_context::no_tlsv1]


['Inherited from ssl::context_base.]

[indexterm2 no_tlsv1..ssl::basic_context] Disable TLS v1. 

  static const int no_tlsv1 = implementation_defined;



[endsect]



[section:options ssl::basic_context::options]


['Inherited from ssl::context_base.]

[indexterm2 options..ssl::basic_context] Bitmask type for SSL options. 

  typedef int options;




[endsect]



[section:password_purpose ssl::basic_context::password_purpose]


['Inherited from ssl::context_base.]

[indexterm2 password_purpose..ssl::basic_context] Purpose of PEM password. 

  enum password_purpose

[heading Values]
[variablelist

  [
    [for_reading]
    [The password is needed for reading/decryption. ]
  ]

  [
    [for_writing]
    [The password is needed for writing/encryption. ]
  ]

]



[endsect]



[section:service_type ssl::basic_context::service_type]

[indexterm2 service_type..ssl::basic_context] The type of the service that will be used to provide context operations. 

  typedef Service service_type;




[endsect]


[section:set_options ssl::basic_context::set_options]

[indexterm2 set_options..ssl::basic_context] Set options on the context. 

  void ``[link boost_asio.reference.ssl__basic_context.set_options.overload1 set_options]``(
      options o);

  boost::system::error_code ``[link boost_asio.reference.ssl__basic_context.set_options.overload2 set_options]``(
      options o,
      boost::system::error_code & ec);


[section:overload1 ssl::basic_context::set_options (1 of 2 overloads)]

Set options on the context. 

  void set_options(
      options o);


This function may be used to configure the SSL options used by the context.


[heading Parameters]
    

[variablelist
  
[[o][A bitmask of options. The available option values are defined in the context\_base class. The options are bitwise-ored with any existing value for the options.]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. ]]

]



[endsect]



[section:overload2 ssl::basic_context::set_options (2 of 2 overloads)]

Set options on the context. 

  boost::system::error_code set_options(
      options o,
      boost::system::error_code & ec);


This function may be used to configure the SSL options used by the context.


[heading Parameters]
    

[variablelist
  
[[o][A bitmask of options. The available option values are defined in the context\_base class. The options are bitwise-ored with any existing value for the options.]]

[[ec][Set to indicate what error occurred, if any. ]]

]



[endsect]


[endsect]

[section:set_password_callback ssl::basic_context::set_password_callback]

[indexterm2 set_password_callback..ssl::basic_context] Set the password callback. 

  template<
      typename PasswordCallback>
  void ``[link boost_asio.reference.ssl__basic_context.set_password_callback.overload1 set_password_callback]``(
      PasswordCallback callback);

  template<
      typename PasswordCallback>
  boost::system::error_code ``[link boost_asio.reference.ssl__basic_context.set_password_callback.overload2 set_password_callback]``(
      PasswordCallback callback,
      boost::system::error_code & ec);


[section:overload1 ssl::basic_context::set_password_callback (1 of 2 overloads)]

Set the password callback. 

  template<
      typename PasswordCallback>
  void set_password_callback(
      PasswordCallback callback);


This function is used to specify a callback function to obtain password information about an encrypted key in PEM format.


[heading Parameters]
    

[variablelist
  
[[callback][The function object to be used for obtaining the password. The function signature of the handler must be: 
``
   std::string password_callback(
     std::size_t max_length,  // The maximum size for a password.
     password_purpose purpose // Whether password is for reading or writing.
   ); 
``
The return value of the callback is a string containing the password.]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. ]]

]



[endsect]



[section:overload2 ssl::basic_context::set_password_callback (2 of 2 overloads)]

Set the password callback. 

  template<
      typename PasswordCallback>
  boost::system::error_code set_password_callback(
      PasswordCallback callback,
      boost::system::error_code & ec);


This function is used to specify a callback function to obtain password information about an encrypted key in PEM format.


[heading Parameters]
    

[variablelist
  
[[callback][The function object to be used for obtaining the password. The function signature of the handler must be: 
``
   std::string password_callback(
     std::size_t max_length,  // The maximum size for a password.
     password_purpose purpose // Whether password is for reading or writing.
   ); 
``
The return value of the callback is a string containing the password.]]

[[ec][Set to indicate what error occurred, if any. ]]

]



[endsect]


[endsect]

[section:set_verify_mode ssl::basic_context::set_verify_mode]

[indexterm2 set_verify_mode..ssl::basic_context] Set the peer verification mode. 

  void ``[link boost_asio.reference.ssl__basic_context.set_verify_mode.overload1 set_verify_mode]``(
      verify_mode v);

  boost::system::error_code ``[link boost_asio.reference.ssl__basic_context.set_verify_mode.overload2 set_verify_mode]``(
      verify_mode v,
      boost::system::error_code & ec);


[section:overload1 ssl::basic_context::set_verify_mode (1 of 2 overloads)]

Set the peer verification mode. 

  void set_verify_mode(
      verify_mode v);


This function may be used to configure the peer verification mode used by the context.


[heading Parameters]
    

[variablelist
  
[[v][A bitmask of peer verification modes. The available verify\_mode values are defined in the context\_base class.]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. ]]

]



[endsect]



[section:overload2 ssl::basic_context::set_verify_mode (2 of 2 overloads)]

Set the peer verification mode. 

  boost::system::error_code set_verify_mode(
      verify_mode v,
      boost::system::error_code & ec);


This function may be used to configure the peer verification mode used by the context.


[heading Parameters]
    

[variablelist
  
[[v][A bitmask of peer verification modes. The available verify\_mode values are defined in the context\_base class.]]

[[ec][Set to indicate what error occurred, if any. ]]

]



[endsect]


[endsect]


[section:single_dh_use ssl::basic_context::single_dh_use]


['Inherited from ssl::context_base.]

[indexterm2 single_dh_use..ssl::basic_context] Always create a new key when using tmp_dh parameters. 

  static const int single_dh_use = implementation_defined;



[endsect]


[section:use_certificate_chain_file ssl::basic_context::use_certificate_chain_file]

[indexterm2 use_certificate_chain_file..ssl::basic_context] Use a certificate chain from a file. 

  void ``[link boost_asio.reference.ssl__basic_context.use_certificate_chain_file.overload1 use_certificate_chain_file]``(
      const std::string & filename);

  boost::system::error_code ``[link boost_asio.reference.ssl__basic_context.use_certificate_chain_file.overload2 use_certificate_chain_file]``(
      const std::string & filename,
      boost::system::error_code & ec);


[section:overload1 ssl::basic_context::use_certificate_chain_file (1 of 2 overloads)]

Use a certificate chain from a file. 

  void use_certificate_chain_file(
      const std::string & filename);


This function is used to load a certificate chain into the context from a file.


[heading Parameters]
    

[variablelist
  
[[filename][The name of the file containing the certificate. The file must use the PEM format.]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. ]]

]



[endsect]



[section:overload2 ssl::basic_context::use_certificate_chain_file (2 of 2 overloads)]

Use a certificate chain from a file. 

  boost::system::error_code use_certificate_chain_file(
      const std::string & filename,
      boost::system::error_code & ec);


This function is used to load a certificate chain into the context from a file.


[heading Parameters]
    

[variablelist
  
[[filename][The name of the file containing the certificate. The file must use the PEM format.]]

[[ec][Set to indicate what error occurred, if any. ]]

]



[endsect]


[endsect]

[section:use_certificate_file ssl::basic_context::use_certificate_file]

[indexterm2 use_certificate_file..ssl::basic_context] Use a certificate from a file. 

  void ``[link boost_asio.reference.ssl__basic_context.use_certificate_file.overload1 use_certificate_file]``(
      const std::string & filename,
      file_format format);

  boost::system::error_code ``[link boost_asio.reference.ssl__basic_context.use_certificate_file.overload2 use_certificate_file]``(
      const std::string & filename,
      file_format format,
      boost::system::error_code & ec);


[section:overload1 ssl::basic_context::use_certificate_file (1 of 2 overloads)]

Use a certificate from a file. 

  void use_certificate_file(
      const std::string & filename,
      file_format format);


This function is used to load a certificate into the context from a file.


[heading Parameters]
    

[variablelist
  
[[filename][The name of the file containing the certificate.]]

[[format][The file format (ASN.1 or PEM).]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. ]]

]



[endsect]



[section:overload2 ssl::basic_context::use_certificate_file (2 of 2 overloads)]

Use a certificate from a file. 

  boost::system::error_code use_certificate_file(
      const std::string & filename,
      file_format format,
      boost::system::error_code & ec);


This function is used to load a certificate into the context from a file.


[heading Parameters]
    

[variablelist
  
[[filename][The name of the file containing the certificate.]]

[[format][The file format (ASN.1 or PEM).]]

[[ec][Set to indicate what error occurred, if any. ]]

]



[endsect]


[endsect]

[section:use_private_key_file ssl::basic_context::use_private_key_file]

[indexterm2 use_private_key_file..ssl::basic_context] Use a private key from a file. 

  void ``[link boost_asio.reference.ssl__basic_context.use_private_key_file.overload1 use_private_key_file]``(
      const std::string & filename,
      file_format format);

  boost::system::error_code ``[link boost_asio.reference.ssl__basic_context.use_private_key_file.overload2 use_private_key_file]``(
      const std::string & filename,
      file_format format,
      boost::system::error_code & ec);


[section:overload1 ssl::basic_context::use_private_key_file (1 of 2 overloads)]

Use a private key from a file. 

  void use_private_key_file(
      const std::string & filename,
      file_format format);


This function is used to load a private key into the context from a file.


[heading Parameters]
    

[variablelist
  
[[filename][The name of the file containing the private key.]]

[[format][The file format (ASN.1 or PEM).]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. ]]

]



[endsect]



[section:overload2 ssl::basic_context::use_private_key_file (2 of 2 overloads)]

Use a private key from a file. 

  boost::system::error_code use_private_key_file(
      const std::string & filename,
      file_format format,
      boost::system::error_code & ec);


This function is used to load a private key into the context from a file.


[heading Parameters]
    

[variablelist
  
[[filename][The name of the file containing the private key.]]

[[format][The file format (ASN.1 or PEM).]]

[[ec][Set to indicate what error occurred, if any. ]]

]



[endsect]


[endsect]

[section:use_rsa_private_key_file ssl::basic_context::use_rsa_private_key_file]

[indexterm2 use_rsa_private_key_file..ssl::basic_context] Use an RSA private key from a file. 

  void ``[link boost_asio.reference.ssl__basic_context.use_rsa_private_key_file.overload1 use_rsa_private_key_file]``(
      const std::string & filename,
      file_format format);

  boost::system::error_code ``[link boost_asio.reference.ssl__basic_context.use_rsa_private_key_file.overload2 use_rsa_private_key_file]``(
      const std::string & filename,
      file_format format,
      boost::system::error_code & ec);


[section:overload1 ssl::basic_context::use_rsa_private_key_file (1 of 2 overloads)]

Use an RSA private key from a file. 

  void use_rsa_private_key_file(
      const std::string & filename,
      file_format format);


This function is used to load an RSA private key into the context from a file.


[heading Parameters]
    

[variablelist
  
[[filename][The name of the file containing the RSA private key.]]

[[format][The file format (ASN.1 or PEM).]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. ]]

]



[endsect]



[section:overload2 ssl::basic_context::use_rsa_private_key_file (2 of 2 overloads)]

Use an RSA private key from a file. 

  boost::system::error_code use_rsa_private_key_file(
      const std::string & filename,
      file_format format,
      boost::system::error_code & ec);


This function is used to load an RSA private key into the context from a file.


[heading Parameters]
    

[variablelist
  
[[filename][The name of the file containing the RSA private key.]]

[[format][The file format (ASN.1 or PEM).]]

[[ec][Set to indicate what error occurred, if any. ]]

]



[endsect]


[endsect]

[section:use_tmp_dh_file ssl::basic_context::use_tmp_dh_file]

[indexterm2 use_tmp_dh_file..ssl::basic_context] Use the specified file to obtain the temporary Diffie-Hellman parameters. 

  void ``[link boost_asio.reference.ssl__basic_context.use_tmp_dh_file.overload1 use_tmp_dh_file]``(
      const std::string & filename);

  boost::system::error_code ``[link boost_asio.reference.ssl__basic_context.use_tmp_dh_file.overload2 use_tmp_dh_file]``(
      const std::string & filename,
      boost::system::error_code & ec);


[section:overload1 ssl::basic_context::use_tmp_dh_file (1 of 2 overloads)]

Use the specified file to obtain the temporary Diffie-Hellman parameters. 

  void use_tmp_dh_file(
      const std::string & filename);


This function is used to load Diffie-Hellman parameters into the context from a file.


[heading Parameters]
    

[variablelist
  
[[filename][The name of the file containing the Diffie-Hellman parameters. The file must use the PEM format.]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. ]]

]



[endsect]



[section:overload2 ssl::basic_context::use_tmp_dh_file (2 of 2 overloads)]

Use the specified file to obtain the temporary Diffie-Hellman parameters. 

  boost::system::error_code use_tmp_dh_file(
      const std::string & filename,
      boost::system::error_code & ec);


This function is used to load Diffie-Hellman parameters into the context from a file.


[heading Parameters]
    

[variablelist
  
[[filename][The name of the file containing the Diffie-Hellman parameters. The file must use the PEM format.]]

[[ec][Set to indicate what error occurred, if any. ]]

]



[endsect]


[endsect]


[section:verify_client_once ssl::basic_context::verify_client_once]


['Inherited from ssl::context_base.]

[indexterm2 verify_client_once..ssl::basic_context] Do not request client certificate on renegotiation. Ignored unless verify_peer is set. 

  static const int verify_client_once = implementation_defined;



[endsect]



[section:verify_fail_if_no_peer_cert ssl::basic_context::verify_fail_if_no_peer_cert]


['Inherited from ssl::context_base.]

[indexterm2 verify_fail_if_no_peer_cert..ssl::basic_context] Fail verification if the peer has no certificate. Ignored unless verify_peer is set. 

  static const int verify_fail_if_no_peer_cert = implementation_defined;



[endsect]



[section:verify_mode ssl::basic_context::verify_mode]


['Inherited from ssl::context_base.]

[indexterm2 verify_mode..ssl::basic_context] Bitmask type for peer verification. 

  typedef int verify_mode;




[endsect]



[section:verify_none ssl::basic_context::verify_none]


['Inherited from ssl::context_base.]

[indexterm2 verify_none..ssl::basic_context] No verification. 

  static const int verify_none = implementation_defined;



[endsect]



[section:verify_peer ssl::basic_context::verify_peer]


['Inherited from ssl::context_base.]

[indexterm2 verify_peer..ssl::basic_context] Verify the peer. 

  static const int verify_peer = implementation_defined;



[endsect]



[section:_basic_context ssl::basic_context::~basic_context]

[indexterm2 ~basic_context..ssl::basic_context] Destructor. 

  ~basic_context();



[endsect]



[endsect]


[section:ssl__context ssl::context]

[indexterm1 ssl::context] Typedef for the typical usage of context. 

  typedef basic_context< context_service > context;


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.ssl__basic_context.file_format [*file_format]]]
    [File format types. ]
  
  ]

  [

    [[link boost_asio.reference.ssl__basic_context.impl_type [*impl_type]]]
    [The native implementation type of the locking dispatcher. ]
  
  ]

  [

    [[link boost_asio.reference.ssl__basic_context.method [*method]]]
    [Different methods supported by a context. ]
  
  ]

  [

    [[link boost_asio.reference.ssl__basic_context.options [*options]]]
    [Bitmask type for SSL options. ]
  
  ]

  [

    [[link boost_asio.reference.ssl__basic_context.password_purpose [*password_purpose]]]
    [Purpose of PEM password. ]
  
  ]

  [

    [[link boost_asio.reference.ssl__basic_context.service_type [*service_type]]]
    [The type of the service that will be used to provide context operations. ]
  
  ]

  [

    [[link boost_asio.reference.ssl__basic_context.verify_mode [*verify_mode]]]
    [Bitmask type for peer verification. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.ssl__basic_context.add_verify_path [*add_verify_path]]]
    [Add a directory containing certificate authority files to be used for performing verification. ]
  ]
  
  [
    [[link boost_asio.reference.ssl__basic_context.basic_context [*basic_context]]]
    [Constructor. ]
  ]
  
  [
    [[link boost_asio.reference.ssl__basic_context.impl [*impl]]]
    [Get the underlying implementation in the native type. ]
  ]
  
  [
    [[link boost_asio.reference.ssl__basic_context.load_verify_file [*load_verify_file]]]
    [Load a certification authority file for performing verification. ]
  ]
  
  [
    [[link boost_asio.reference.ssl__basic_context.set_options [*set_options]]]
    [Set options on the context. ]
  ]
  
  [
    [[link boost_asio.reference.ssl__basic_context.set_password_callback [*set_password_callback]]]
    [Set the password callback. ]
  ]
  
  [
    [[link boost_asio.reference.ssl__basic_context.set_verify_mode [*set_verify_mode]]]
    [Set the peer verification mode. ]
  ]
  
  [
    [[link boost_asio.reference.ssl__basic_context.use_certificate_chain_file [*use_certificate_chain_file]]]
    [Use a certificate chain from a file. ]
  ]
  
  [
    [[link boost_asio.reference.ssl__basic_context.use_certificate_file [*use_certificate_file]]]
    [Use a certificate from a file. ]
  ]
  
  [
    [[link boost_asio.reference.ssl__basic_context.use_private_key_file [*use_private_key_file]]]
    [Use a private key from a file. ]
  ]
  
  [
    [[link boost_asio.reference.ssl__basic_context.use_rsa_private_key_file [*use_rsa_private_key_file]]]
    [Use an RSA private key from a file. ]
  ]
  
  [
    [[link boost_asio.reference.ssl__basic_context.use_tmp_dh_file [*use_tmp_dh_file]]]
    [Use the specified file to obtain the temporary Diffie-Hellman parameters. ]
  ]
  
  [
    [[link boost_asio.reference.ssl__basic_context._basic_context [*~basic_context]]]
    [Destructor. ]
  ]
  
]

[heading Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.ssl__basic_context.default_workarounds [*default_workarounds]]]
    [Implement various bug workarounds. ]
  ]

  [
    [[link boost_asio.reference.ssl__basic_context.no_sslv2 [*no_sslv2]]]
    [Disable SSL v2. ]
  ]

  [
    [[link boost_asio.reference.ssl__basic_context.no_sslv3 [*no_sslv3]]]
    [Disable SSL v3. ]
  ]

  [
    [[link boost_asio.reference.ssl__basic_context.no_tlsv1 [*no_tlsv1]]]
    [Disable TLS v1. ]
  ]

  [
    [[link boost_asio.reference.ssl__basic_context.single_dh_use [*single_dh_use]]]
    [Always create a new key when using tmp_dh parameters. ]
  ]

  [
    [[link boost_asio.reference.ssl__basic_context.verify_client_once [*verify_client_once]]]
    [Do not request client certificate on renegotiation. Ignored unless verify_peer is set. ]
  ]

  [
    [[link boost_asio.reference.ssl__basic_context.verify_fail_if_no_peer_cert [*verify_fail_if_no_peer_cert]]]
    [Fail verification if the peer has no certificate. Ignored unless verify_peer is set. ]
  ]

  [
    [[link boost_asio.reference.ssl__basic_context.verify_none [*verify_none]]]
    [No verification. ]
  ]

  [
    [[link boost_asio.reference.ssl__basic_context.verify_peer [*verify_peer]]]
    [Verify the peer. ]
  ]

]



[endsect]


[section:ssl__context_base ssl::context_base]

The context_base class is used as a base for the basic_context class template so that we have a common place to define various enums. 

  class context_base


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.ssl__context_base.file_format [*file_format]]]
    [File format types. ]
  
  ]

  [

    [[link boost_asio.reference.ssl__context_base.method [*method]]]
    [Different methods supported by a context. ]
  
  ]

  [

    [[link boost_asio.reference.ssl__context_base.options [*options]]]
    [Bitmask type for SSL options. ]
  
  ]

  [

    [[link boost_asio.reference.ssl__context_base.password_purpose [*password_purpose]]]
    [Purpose of PEM password. ]
  
  ]

  [

    [[link boost_asio.reference.ssl__context_base.verify_mode [*verify_mode]]]
    [Bitmask type for peer verification. ]
  
  ]

]

[heading Protected Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.ssl__context_base._context_base [*~context_base]]]
    [Protected destructor to prevent deletion through this type. ]
  ]
  
]

[heading Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.ssl__context_base.default_workarounds [*default_workarounds]]]
    [Implement various bug workarounds. ]
  ]

  [
    [[link boost_asio.reference.ssl__context_base.no_sslv2 [*no_sslv2]]]
    [Disable SSL v2. ]
  ]

  [
    [[link boost_asio.reference.ssl__context_base.no_sslv3 [*no_sslv3]]]
    [Disable SSL v3. ]
  ]

  [
    [[link boost_asio.reference.ssl__context_base.no_tlsv1 [*no_tlsv1]]]
    [Disable TLS v1. ]
  ]

  [
    [[link boost_asio.reference.ssl__context_base.single_dh_use [*single_dh_use]]]
    [Always create a new key when using tmp_dh parameters. ]
  ]

  [
    [[link boost_asio.reference.ssl__context_base.verify_client_once [*verify_client_once]]]
    [Do not request client certificate on renegotiation. Ignored unless verify_peer is set. ]
  ]

  [
    [[link boost_asio.reference.ssl__context_base.verify_fail_if_no_peer_cert [*verify_fail_if_no_peer_cert]]]
    [Fail verification if the peer has no certificate. Ignored unless verify_peer is set. ]
  ]

  [
    [[link boost_asio.reference.ssl__context_base.verify_none [*verify_none]]]
    [No verification. ]
  ]

  [
    [[link boost_asio.reference.ssl__context_base.verify_peer [*verify_peer]]]
    [Verify the peer. ]
  ]

]


[section:default_workarounds ssl::context_base::default_workarounds]

[indexterm2 default_workarounds..ssl::context_base] Implement various bug workarounds. 

  static const int default_workarounds = implementation_defined;



[endsect]



[section:file_format ssl::context_base::file_format]

[indexterm2 file_format..ssl::context_base] File format types. 

  enum file_format

[heading Values]
[variablelist

  [
    [asn1]
    [ASN.1 file. ]
  ]

  [
    [pem]
    [PEM file. ]
  ]

]



[endsect]



[section:method ssl::context_base::method]

[indexterm2 method..ssl::context_base] Different methods supported by a context. 

  enum method

[heading Values]
[variablelist

  [
    [sslv2]
    [Generic SSL version 2. ]
  ]

  [
    [sslv2_client]
    [SSL version 2 client. ]
  ]

  [
    [sslv2_server]
    [SSL version 2 server. ]
  ]

  [
    [sslv3]
    [Generic SSL version 3. ]
  ]

  [
    [sslv3_client]
    [SSL version 3 client. ]
  ]

  [
    [sslv3_server]
    [SSL version 3 server. ]
  ]

  [
    [tlsv1]
    [Generic TLS version 1. ]
  ]

  [
    [tlsv1_client]
    [TLS version 1 client. ]
  ]

  [
    [tlsv1_server]
    [TLS version 1 server. ]
  ]

  [
    [sslv23]
    [Generic SSL/TLS. ]
  ]

  [
    [sslv23_client]
    [SSL/TLS client. ]
  ]

  [
    [sslv23_server]
    [SSL/TLS server. ]
  ]

]



[endsect]



[section:no_sslv2 ssl::context_base::no_sslv2]

[indexterm2 no_sslv2..ssl::context_base] Disable SSL v2. 

  static const int no_sslv2 = implementation_defined;



[endsect]



[section:no_sslv3 ssl::context_base::no_sslv3]

[indexterm2 no_sslv3..ssl::context_base] Disable SSL v3. 

  static const int no_sslv3 = implementation_defined;



[endsect]



[section:no_tlsv1 ssl::context_base::no_tlsv1]

[indexterm2 no_tlsv1..ssl::context_base] Disable TLS v1. 

  static const int no_tlsv1 = implementation_defined;



[endsect]



[section:options ssl::context_base::options]

[indexterm2 options..ssl::context_base] Bitmask type for SSL options. 

  typedef int options;




[endsect]



[section:password_purpose ssl::context_base::password_purpose]

[indexterm2 password_purpose..ssl::context_base] Purpose of PEM password. 

  enum password_purpose

[heading Values]
[variablelist

  [
    [for_reading]
    [The password is needed for reading/decryption. ]
  ]

  [
    [for_writing]
    [The password is needed for writing/encryption. ]
  ]

]



[endsect]



[section:single_dh_use ssl::context_base::single_dh_use]

[indexterm2 single_dh_use..ssl::context_base] Always create a new key when using tmp_dh parameters. 

  static const int single_dh_use = implementation_defined;



[endsect]



[section:verify_client_once ssl::context_base::verify_client_once]

[indexterm2 verify_client_once..ssl::context_base] Do not request client certificate on renegotiation. Ignored unless verify_peer is set. 

  static const int verify_client_once = implementation_defined;



[endsect]



[section:verify_fail_if_no_peer_cert ssl::context_base::verify_fail_if_no_peer_cert]

[indexterm2 verify_fail_if_no_peer_cert..ssl::context_base] Fail verification if the peer has no certificate. Ignored unless verify_peer is set. 

  static const int verify_fail_if_no_peer_cert = implementation_defined;



[endsect]



[section:verify_mode ssl::context_base::verify_mode]

[indexterm2 verify_mode..ssl::context_base] Bitmask type for peer verification. 

  typedef int verify_mode;




[endsect]



[section:verify_none ssl::context_base::verify_none]

[indexterm2 verify_none..ssl::context_base] No verification. 

  static const int verify_none = implementation_defined;



[endsect]



[section:verify_peer ssl::context_base::verify_peer]

[indexterm2 verify_peer..ssl::context_base] Verify the peer. 

  static const int verify_peer = implementation_defined;



[endsect]



[section:_context_base ssl::context_base::~context_base]

[indexterm2 ~context_base..ssl::context_base] Protected destructor to prevent deletion through this type. 

  ~context_base();



[endsect]



[endsect]

[section:ssl__context_service ssl::context_service]

Default service implementation for a context. 

  class context_service :
    public io_service::service


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.ssl__context_service.impl_type [*impl_type]]]
    [The type of the context. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.ssl__context_service.add_verify_path [*add_verify_path]]]
    [Add a directory containing certification authority files to be used for performing verification. ]
  ]
  
  [
    [[link boost_asio.reference.ssl__context_service.context_service [*context_service]]]
    [Constructor. ]
  ]
  
  [
    [[link boost_asio.reference.ssl__context_service.create [*create]]]
    [Create a new context implementation. ]
  ]
  
  [
    [[link boost_asio.reference.ssl__context_service.destroy [*destroy]]]
    [Destroy a context implementation. ]
  ]
  
  [
    [[link boost_asio.reference.ssl__context_service.get_io_service [*get_io_service]]]
    [Get the io_service object that owns the service. ]
  ]
  
  [
    [[link boost_asio.reference.ssl__context_service.io_service [*io_service]]]
    [(Deprecated: use get_io_service().) Get the io_service object that owns the service. ]
  ]
  
  [
    [[link boost_asio.reference.ssl__context_service.load_verify_file [*load_verify_file]]]
    [Load a certification authority file for performing verification. ]
  ]
  
  [
    [[link boost_asio.reference.ssl__context_service.null [*null]]]
    [Return a null context implementation. ]
  ]
  
  [
    [[link boost_asio.reference.ssl__context_service.set_options [*set_options]]]
    [Set options on the context. ]
  ]
  
  [
    [[link boost_asio.reference.ssl__context_service.set_password_callback [*set_password_callback]]]
    [Set the password callback. ]
  ]
  
  [
    [[link boost_asio.reference.ssl__context_service.set_verify_mode [*set_verify_mode]]]
    [Set peer verification mode. ]
  ]
  
  [
    [[link boost_asio.reference.ssl__context_service.shutdown_service [*shutdown_service]]]
    [Destroy all user-defined handler objects owned by the service. ]
  ]
  
  [
    [[link boost_asio.reference.ssl__context_service.use_certificate_chain_file [*use_certificate_chain_file]]]
    [Use a certificate chain from a file. ]
  ]
  
  [
    [[link boost_asio.reference.ssl__context_service.use_certificate_file [*use_certificate_file]]]
    [Use a certificate from a file. ]
  ]
  
  [
    [[link boost_asio.reference.ssl__context_service.use_private_key_file [*use_private_key_file]]]
    [Use a private key from a file. ]
  ]
  
  [
    [[link boost_asio.reference.ssl__context_service.use_rsa_private_key_file [*use_rsa_private_key_file]]]
    [Use an RSA private key from a file. ]
  ]
  
  [
    [[link boost_asio.reference.ssl__context_service.use_tmp_dh_file [*use_tmp_dh_file]]]
    [Use the specified file to obtain the temporary Diffie-Hellman parameters. ]
  ]
  
]

[heading Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.ssl__context_service.id [*id]]]
    [The unique service identifier. ]
  ]

]


[section:add_verify_path ssl::context_service::add_verify_path]

[indexterm2 add_verify_path..ssl::context_service] Add a directory containing certification authority files to be used for performing verification. 

  boost::system::error_code add_verify_path(
      impl_type & impl,
      const std::string & path,
      boost::system::error_code & ec);



[endsect]



[section:context_service ssl::context_service::context_service]

[indexterm2 context_service..ssl::context_service] Constructor. 

  context_service(
      boost::asio::io_service & io_service);



[endsect]



[section:create ssl::context_service::create]

[indexterm2 create..ssl::context_service] Create a new context implementation. 

  void create(
      impl_type & impl,
      context_base::method m);



[endsect]



[section:destroy ssl::context_service::destroy]

[indexterm2 destroy..ssl::context_service] Destroy a context implementation. 

  void destroy(
      impl_type & impl);



[endsect]



[section:get_io_service ssl::context_service::get_io_service]


['Inherited from io_service.]

[indexterm2 get_io_service..ssl::context_service] Get the io_service object that owns the service. 

  boost::asio::io_service & get_io_service();



[endsect]



[section:id ssl::context_service::id]

[indexterm2 id..ssl::context_service] The unique service identifier. 

  static boost::asio::io_service::id id;



[endsect]



[section:impl_type ssl::context_service::impl_type]

[indexterm2 impl_type..ssl::context_service] The type of the context. 

  typedef implementation_defined impl_type;




[endsect]



[section:io_service ssl::context_service::io_service]


['Inherited from io_service.]

[indexterm2 io_service..ssl::context_service] (Deprecated: use get_io_service().) Get the io_service object that owns the service. 

  boost::asio::io_service & io_service();



[endsect]



[section:load_verify_file ssl::context_service::load_verify_file]

[indexterm2 load_verify_file..ssl::context_service] Load a certification authority file for performing verification. 

  boost::system::error_code load_verify_file(
      impl_type & impl,
      const std::string & filename,
      boost::system::error_code & ec);



[endsect]



[section:null ssl::context_service::null]

[indexterm2 null..ssl::context_service] Return a null context implementation. 

  impl_type null() const;



[endsect]



[section:set_options ssl::context_service::set_options]

[indexterm2 set_options..ssl::context_service] Set options on the context. 

  boost::system::error_code set_options(
      impl_type & impl,
      context_base::options o,
      boost::system::error_code & ec);



[endsect]



[section:set_password_callback ssl::context_service::set_password_callback]

[indexterm2 set_password_callback..ssl::context_service] Set the password callback. 

  template<
      typename PasswordCallback>
  boost::system::error_code set_password_callback(
      impl_type & impl,
      PasswordCallback callback,
      boost::system::error_code & ec);



[endsect]



[section:set_verify_mode ssl::context_service::set_verify_mode]

[indexterm2 set_verify_mode..ssl::context_service] Set peer verification mode. 

  boost::system::error_code set_verify_mode(
      impl_type & impl,
      context_base::verify_mode v,
      boost::system::error_code & ec);



[endsect]



[section:shutdown_service ssl::context_service::shutdown_service]

[indexterm2 shutdown_service..ssl::context_service] Destroy all user-defined handler objects owned by the service. 

  void shutdown_service();



[endsect]



[section:use_certificate_chain_file ssl::context_service::use_certificate_chain_file]

[indexterm2 use_certificate_chain_file..ssl::context_service] Use a certificate chain from a file. 

  boost::system::error_code use_certificate_chain_file(
      impl_type & impl,
      const std::string & filename,
      boost::system::error_code & ec);



[endsect]



[section:use_certificate_file ssl::context_service::use_certificate_file]

[indexterm2 use_certificate_file..ssl::context_service] Use a certificate from a file. 

  boost::system::error_code use_certificate_file(
      impl_type & impl,
      const std::string & filename,
      context_base::file_format format,
      boost::system::error_code & ec);



[endsect]



[section:use_private_key_file ssl::context_service::use_private_key_file]

[indexterm2 use_private_key_file..ssl::context_service] Use a private key from a file. 

  boost::system::error_code use_private_key_file(
      impl_type & impl,
      const std::string & filename,
      context_base::file_format format,
      boost::system::error_code & ec);



[endsect]



[section:use_rsa_private_key_file ssl::context_service::use_rsa_private_key_file]

[indexterm2 use_rsa_private_key_file..ssl::context_service] Use an RSA private key from a file. 

  boost::system::error_code use_rsa_private_key_file(
      impl_type & impl,
      const std::string & filename,
      context_base::file_format format,
      boost::system::error_code & ec);



[endsect]



[section:use_tmp_dh_file ssl::context_service::use_tmp_dh_file]

[indexterm2 use_tmp_dh_file..ssl::context_service] Use the specified file to obtain the temporary Diffie-Hellman parameters. 

  boost::system::error_code use_tmp_dh_file(
      impl_type & impl,
      const std::string & filename,
      boost::system::error_code & ec);



[endsect]



[endsect]

[section:ssl__stream ssl::stream]

Provides stream-oriented functionality using SSL. 

  template<
      typename Stream,
      typename ``[link boost_asio.reference.Service Service]`` = stream_service>
  class stream :
    public ssl::stream_base


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.ssl__stream.handshake_type [*handshake_type]]]
    [Different handshake types. ]
  
  ]

  [

    [[link boost_asio.reference.ssl__stream.impl_type [*impl_type]]]
    [The native implementation type of the stream. ]
  
  ]

  [

    [[link boost_asio.reference.ssl__stream.lowest_layer_type [*lowest_layer_type]]]
    [The type of the lowest layer. ]
  
  ]

  [

    [[link boost_asio.reference.ssl__stream.next_layer_type [*next_layer_type]]]
    [The type of the next layer. ]
  
  ]

  [

    [[link boost_asio.reference.ssl__stream.service_type [*service_type]]]
    [The type of the service that will be used to provide stream operations. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.ssl__stream.async_handshake [*async_handshake]]]
    [Start an asynchronous SSL handshake. ]
  ]
  
  [
    [[link boost_asio.reference.ssl__stream.async_read_some [*async_read_some]]]
    [Start an asynchronous read. ]
  ]
  
  [
    [[link boost_asio.reference.ssl__stream.async_shutdown [*async_shutdown]]]
    [Asynchronously shut down SSL on the stream. ]
  ]
  
  [
    [[link boost_asio.reference.ssl__stream.async_write_some [*async_write_some]]]
    [Start an asynchronous write. ]
  ]
  
  [
    [[link boost_asio.reference.ssl__stream.get_io_service [*get_io_service]]]
    [Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.ssl__stream.handshake [*handshake]]]
    [Perform SSL handshaking. ]
  ]
  
  [
    [[link boost_asio.reference.ssl__stream.impl [*impl]]]
    [Get the underlying implementation in the native type. ]
  ]
  
  [
    [[link boost_asio.reference.ssl__stream.in_avail [*in_avail]]]
    [Determine the amount of data that may be read without blocking. ]
  ]
  
  [
    [[link boost_asio.reference.ssl__stream.io_service [*io_service]]]
    [(Deprecated: use get_io_service().) Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.ssl__stream.lowest_layer [*lowest_layer]]]
    [Get a reference to the lowest layer. 

     Get a const reference to the lowest layer. ]
  ]
  
  [
    [[link boost_asio.reference.ssl__stream.next_layer [*next_layer]]]
    [Get a reference to the next layer. ]
  ]
  
  [
    [[link boost_asio.reference.ssl__stream.peek [*peek]]]
    [Peek at the incoming data on the stream. ]
  ]
  
  [
    [[link boost_asio.reference.ssl__stream.read_some [*read_some]]]
    [Read some data from the stream. ]
  ]
  
  [
    [[link boost_asio.reference.ssl__stream.shutdown [*shutdown]]]
    [Shut down SSL on the stream. ]
  ]
  
  [
    [[link boost_asio.reference.ssl__stream.stream [*stream]]]
    [Construct a stream. ]
  ]
  
  [
    [[link boost_asio.reference.ssl__stream.write_some [*write_some]]]
    [Write some data to the stream. ]
  ]
  
  [
    [[link boost_asio.reference.ssl__stream._stream [*~stream]]]
    [Destructor. ]
  ]
  
]

The stream class template provides asynchronous and blocking stream-oriented functionality using SSL.


[heading Thread Safety]
  
[*Distinct] [*objects:]  Safe.

[*Shared] [*objects:]  Unsafe.

[heading Example]
  
To use the SSL stream template with an ip::tcp::socket, you would write: 

   boost::asio::io_service io_service;
   boost::asio::ssl::context context(io_service, boost::asio::ssl::context::sslv23);
   boost::asio::ssl::stream<boost::asio::ip::tcp::socket> sock(io_service, context);






[section:async_handshake ssl::stream::async_handshake]

[indexterm2 async_handshake..ssl::stream] Start an asynchronous SSL handshake. 

  template<
      typename HandshakeHandler>
  void async_handshake(
      handshake_type type,
      HandshakeHandler handler);


This function is used to asynchronously perform an SSL handshake on the stream. This function call always returns immediately.


[heading Parameters]
    

[variablelist
  
[[type][The type of handshaking to be performed, i.e. as a client or as a server.]]

[[handler][The handler to be called when the handshake operation completes. Copies will be made of the handler as required. The equivalent function signature of the handler must be: 
``
   void handler(
     const boost::system::error_code& error // Result of operation.
   ); 
``
]]

]



[endsect]



[section:async_read_some ssl::stream::async_read_some]

[indexterm2 async_read_some..ssl::stream] Start an asynchronous read. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
  void async_read_some(
      const MutableBufferSequence & buffers,
      ReadHandler handler);


This function is used to asynchronously read one or more bytes of data from the stream. The function call always returns immediately.


[heading Parameters]
    

[variablelist
  
[[buffers][The buffers into which the data will be read. Although the buffers object may be copied as necessary, ownership of the underlying buffers is retained by the caller, which must guarantee that they remain valid until the handler is called.]]

[[handler][The handler to be called when the read operation completes. Copies will be made of the handler as required. The equivalent function signature of the handler must be: 
``
   void handler(
     const boost::system::error_code& error, // Result of operation.
     std::size_t bytes_transferred           // Number of bytes read.
   ); 
``
]]

]

[heading Remarks]
      
The async\_read\_some operation may not read all of the requested number of bytes. Consider using the 
[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. 



[endsect]



[section:async_shutdown ssl::stream::async_shutdown]

[indexterm2 async_shutdown..ssl::stream] Asynchronously shut down SSL on the stream. 

  template<
      typename ShutdownHandler>
  void async_shutdown(
      ShutdownHandler handler);


This function is used to asynchronously shut down SSL on the stream. This function call always returns immediately.


[heading Parameters]
    

[variablelist
  
[[handler][The handler to be called when the handshake operation completes. Copies will be made of the handler as required. The equivalent function signature of the handler must be: 
``
   void handler(
     const boost::system::error_code& error // Result of operation.
   ); 
``
]]

]



[endsect]



[section:async_write_some ssl::stream::async_write_some]

[indexterm2 async_write_some..ssl::stream] Start an asynchronous write. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
  void async_write_some(
      const ConstBufferSequence & buffers,
      WriteHandler handler);


This function is used to asynchronously write one or more bytes of data to the stream. The function call always returns immediately.


[heading Parameters]
    

[variablelist
  
[[buffers][The data to be written to the stream. Although the buffers object may be copied as necessary, ownership of the underlying buffers is retained by the caller, which must guarantee that they remain valid until the handler is called.]]

[[handler][The handler to be called when the write operation completes. Copies will be made of the handler as required. The equivalent function signature of the handler must be: 
``
   void handler(
     const boost::system::error_code& error, // Result of operation.
     std::size_t bytes_transferred           // Number of bytes written.
   ); 
``
]]

]

[heading Remarks]
      
The async\_write\_some operation may not transmit all of the data to the peer. Consider using the 
[link boost_asio.reference.async_write async_write]  function if you need to ensure that all data is written before the blocking operation completes. 



[endsect]



[section:get_io_service ssl::stream::get_io_service]

[indexterm2 get_io_service..ssl::stream] Get the io_service associated with the object. 

  boost::asio::io_service & get_io_service();


This function may be used to obtain the io_service object that the stream uses to dispatch handlers for asynchronous operations.


[heading Return Value]
      
A reference to the io_service object that stream will use to dispatch handlers. Ownership is not transferred to the caller. 



[endsect]


[section:handshake ssl::stream::handshake]

[indexterm2 handshake..ssl::stream] Perform SSL handshaking. 

  void ``[link boost_asio.reference.ssl__stream.handshake.overload1 handshake]``(
      handshake_type type);

  boost::system::error_code ``[link boost_asio.reference.ssl__stream.handshake.overload2 handshake]``(
      handshake_type type,
      boost::system::error_code & ec);


[section:overload1 ssl::stream::handshake (1 of 2 overloads)]

Perform SSL handshaking. 

  void handshake(
      handshake_type type);


This function is used to perform SSL handshaking on the stream. The function call will block until handshaking is complete or an error occurs.


[heading Parameters]
    

[variablelist
  
[[type][The type of handshaking to be performed, i.e. as a client or as a server.]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. ]]

]



[endsect]



[section:overload2 ssl::stream::handshake (2 of 2 overloads)]

Perform SSL handshaking. 

  boost::system::error_code handshake(
      handshake_type type,
      boost::system::error_code & ec);


This function is used to perform SSL handshaking on the stream. The function call will block until handshaking is complete or an error occurs.


[heading Parameters]
    

[variablelist
  
[[type][The type of handshaking to be performed, i.e. as a client or as a server.]]

[[ec][Set to indicate what error occurred, if any. ]]

]



[endsect]


[endsect]


[section:handshake_type ssl::stream::handshake_type]

[indexterm2 handshake_type..ssl::stream] Different handshake types. 

  enum handshake_type

[heading Values]
[variablelist

  [
    [client]
    [Perform handshaking as a client. ]
  ]

  [
    [server]
    [Perform handshaking as a server. ]
  ]

]



[endsect]



[section:impl ssl::stream::impl]

[indexterm2 impl..ssl::stream] Get the underlying implementation in the native type. 

  impl_type impl();


This function may be used to obtain the underlying implementation of the context. This is intended to allow access to stream functionality that is not otherwise provided. 


[endsect]



[section:impl_type ssl::stream::impl_type]

[indexterm2 impl_type..ssl::stream] The native implementation type of the stream. 

  typedef service_type::impl_type impl_type;




[endsect]


[section:in_avail ssl::stream::in_avail]

[indexterm2 in_avail..ssl::stream] Determine the amount of data that may be read without blocking. 

  std::size_t ``[link boost_asio.reference.ssl__stream.in_avail.overload1 in_avail]``();

  std::size_t ``[link boost_asio.reference.ssl__stream.in_avail.overload2 in_avail]``(
      boost::system::error_code & ec);


[section:overload1 ssl::stream::in_avail (1 of 2 overloads)]

Determine the amount of data that may be read without blocking. 

  std::size_t in_avail();


This function is used to determine the amount of data, in bytes, that may be read from the stream without blocking.


[heading Return Value]
      
The number of bytes of data that can be read without blocking.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. ]]

]



[endsect]



[section:overload2 ssl::stream::in_avail (2 of 2 overloads)]

Determine the amount of data that may be read without blocking. 

  std::size_t in_avail(
      boost::system::error_code & ec);


This function is used to determine the amount of data, in bytes, that may be read from the stream without blocking.


[heading Parameters]
    

[variablelist
  
[[ec][Set to indicate what error occurred, if any.]]

]

[heading Return Value]
      
The number of bytes of data that can be read without blocking. 



[endsect]


[endsect]


[section:io_service ssl::stream::io_service]

[indexterm2 io_service..ssl::stream] (Deprecated: use get_io_service().) Get the io_service associated with the object. 

  boost::asio::io_service & io_service();


This function may be used to obtain the io_service object that the stream uses to dispatch handlers for asynchronous operations.


[heading Return Value]
      
A reference to the io_service object that stream will use to dispatch handlers. Ownership is not transferred to the caller. 



[endsect]


[section:lowest_layer ssl::stream::lowest_layer]

[indexterm2 lowest_layer..ssl::stream] Get a reference to the lowest layer. 

  lowest_layer_type & ``[link boost_asio.reference.ssl__stream.lowest_layer.overload1 lowest_layer]``();

Get a const reference to the lowest layer. 

  const lowest_layer_type & ``[link boost_asio.reference.ssl__stream.lowest_layer.overload2 lowest_layer]``() const;


[section:overload1 ssl::stream::lowest_layer (1 of 2 overloads)]

Get a reference to the lowest layer. 

  lowest_layer_type & lowest_layer();


This function returns a reference to the lowest layer in a stack of stream layers.


[heading Return Value]
      
A reference to the lowest layer in the stack of stream layers. Ownership is not transferred to the caller. 



[endsect]



[section:overload2 ssl::stream::lowest_layer (2 of 2 overloads)]

Get a const reference to the lowest layer. 

  const lowest_layer_type & lowest_layer() const;


This function returns a const reference to the lowest layer in a stack of stream layers.


[heading Return Value]
      
A const reference to the lowest layer in the stack of stream layers. Ownership is not transferred to the caller. 



[endsect]


[endsect]


[section:lowest_layer_type ssl::stream::lowest_layer_type]

[indexterm2 lowest_layer_type..ssl::stream] The type of the lowest layer. 

  typedef next_layer_type::lowest_layer_type lowest_layer_type;




[endsect]



[section:next_layer ssl::stream::next_layer]

[indexterm2 next_layer..ssl::stream] Get a reference to the next layer. 

  next_layer_type & next_layer();


This function returns a reference to the next layer in a stack of stream layers.


[heading Return Value]
      
A reference to the next layer in the stack of stream layers. Ownership is not transferred to the caller. 



[endsect]



[section:next_layer_type ssl::stream::next_layer_type]

[indexterm2 next_layer_type..ssl::stream] The type of the next layer. 

  typedef boost::remove_reference< Stream >::type next_layer_type;




[endsect]


[section:peek ssl::stream::peek]

[indexterm2 peek..ssl::stream] Peek at the incoming data on the stream. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t ``[link boost_asio.reference.ssl__stream.peek.overload1 peek]``(
      const MutableBufferSequence & buffers);

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t ``[link boost_asio.reference.ssl__stream.peek.overload2 peek]``(
      const MutableBufferSequence & buffers,
      boost::system::error_code & ec);


[section:overload1 ssl::stream::peek (1 of 2 overloads)]

Peek at the incoming data on the stream. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t peek(
      const MutableBufferSequence & buffers);


This function is used to peek at the incoming data on the stream, without removing it from the input queue. The function call will block until data has been read successfully or an error occurs.


[heading Parameters]
    

[variablelist
  
[[buffers][The buffers into which the data will be read.]]

]

[heading Return Value]
      
The number of bytes read.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. ]]

]



[endsect]



[section:overload2 ssl::stream::peek (2 of 2 overloads)]

Peek at the incoming data on the stream. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t peek(
      const MutableBufferSequence & buffers,
      boost::system::error_code & ec);


This function is used to peek at the incoming data on the stream, withoutxi removing it from the input queue. The function call will block until data has been read successfully or an error occurs.


[heading Parameters]
    

[variablelist
  
[[buffers][The buffers into which the data will be read.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Return Value]
      
The number of bytes read. Returns 0 if an error occurred. 



[endsect]


[endsect]

[section:read_some ssl::stream::read_some]

[indexterm2 read_some..ssl::stream] Read some data from the stream. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t ``[link boost_asio.reference.ssl__stream.read_some.overload1 read_some]``(
      const MutableBufferSequence & buffers);

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t ``[link boost_asio.reference.ssl__stream.read_some.overload2 read_some]``(
      const MutableBufferSequence & buffers,
      boost::system::error_code & ec);


[section:overload1 ssl::stream::read_some (1 of 2 overloads)]

Read some data from the stream. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t read_some(
      const MutableBufferSequence & buffers);


This function is used to read data from the stream. The function call will block until one or more bytes of data has been read successfully, or until an error occurs.


[heading Parameters]
    

[variablelist
  
[[buffers][The buffers into which the data will be read.]]

]

[heading Return Value]
      
The number of bytes read.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Remarks]
      
The read\_some operation may not read all of the requested number of bytes. Consider using the 
[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. 



[endsect]



[section:overload2 ssl::stream::read_some (2 of 2 overloads)]

Read some data from the stream. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t read_some(
      const MutableBufferSequence & buffers,
      boost::system::error_code & ec);


This function is used to read data from the stream. The function call will block until one or more bytes of data has been read successfully, or until an error occurs.


[heading Parameters]
    

[variablelist
  
[[buffers][The buffers into which the data will be read.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Return Value]
      
The number of bytes read. Returns 0 if an error occurred.

[heading Remarks]
      
The read\_some operation may not read all of the requested number of bytes. Consider using the 
[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. 



[endsect]


[endsect]


[section:service_type ssl::stream::service_type]

[indexterm2 service_type..ssl::stream] The type of the service that will be used to provide stream operations. 

  typedef Service service_type;




[endsect]


[section:shutdown ssl::stream::shutdown]

[indexterm2 shutdown..ssl::stream] Shut down SSL on the stream. 

  void ``[link boost_asio.reference.ssl__stream.shutdown.overload1 shutdown]``();

  boost::system::error_code ``[link boost_asio.reference.ssl__stream.shutdown.overload2 shutdown]``(
      boost::system::error_code & ec);


[section:overload1 ssl::stream::shutdown (1 of 2 overloads)]

Shut down SSL on the stream. 

  void shutdown();


This function is used to shut down SSL on the stream. The function call will block until SSL has been shut down or an error occurs.


[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. ]]

]



[endsect]



[section:overload2 ssl::stream::shutdown (2 of 2 overloads)]

Shut down SSL on the stream. 

  boost::system::error_code shutdown(
      boost::system::error_code & ec);


This function is used to shut down SSL on the stream. The function call will block until SSL has been shut down or an error occurs.


[heading Parameters]
    

[variablelist
  
[[ec][Set to indicate what error occurred, if any. ]]

]



[endsect]


[endsect]


[section:stream ssl::stream::stream]

[indexterm2 stream..ssl::stream] Construct a stream. 

  template<
      typename Arg,
      typename Context_Service>
  stream(
      Arg & arg,
      basic_context< Context_Service > & context);


This constructor creates a stream and initialises the underlying stream object.


[heading Parameters]
    

[variablelist
  
[[arg][The argument to be passed to initialise the underlying stream.]]

[[context][The SSL context to be used for the stream. ]]

]



[endsect]


[section:write_some ssl::stream::write_some]

[indexterm2 write_some..ssl::stream] Write some data to the stream. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t ``[link boost_asio.reference.ssl__stream.write_some.overload1 write_some]``(
      const ConstBufferSequence & buffers);

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t ``[link boost_asio.reference.ssl__stream.write_some.overload2 write_some]``(
      const ConstBufferSequence & buffers,
      boost::system::error_code & ec);


[section:overload1 ssl::stream::write_some (1 of 2 overloads)]

Write some data to the stream. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t write_some(
      const ConstBufferSequence & buffers);


This function is used to write data on the stream. The function call will block until one or more bytes of data has been written successfully, or until an error occurs.


[heading Parameters]
    

[variablelist
  
[[buffers][The data to be written.]]

]

[heading Return Value]
      
The number of bytes written.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Remarks]
      
The write\_some operation may not transmit all of the data to the peer. Consider using the 
[link boost_asio.reference.write write]  function if you need to ensure that all data is written before the blocking operation completes. 



[endsect]



[section:overload2 ssl::stream::write_some (2 of 2 overloads)]

Write some data to the stream. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t write_some(
      const ConstBufferSequence & buffers,
      boost::system::error_code & ec);


This function is used to write data on the stream. The function call will block until one or more bytes of data has been written successfully, or until an error occurs.


[heading Parameters]
    

[variablelist
  
[[buffers][The data to be written to the stream.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Return Value]
      
The number of bytes written. Returns 0 if an error occurred.

[heading Remarks]
      
The write\_some operation may not transmit all of the data to the peer. Consider using the 
[link boost_asio.reference.write write]  function if you need to ensure that all data is written before the blocking operation completes. 



[endsect]


[endsect]


[section:_stream ssl::stream::~stream]

[indexterm2 ~stream..ssl::stream] Destructor. 

  ~stream();



[endsect]



[endsect]

[section:ssl__stream_base ssl::stream_base]

The stream_base class is used as a base for the boost::asio::ssl::stream class template so that we have a common place to define various enums. 

  class stream_base


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.ssl__stream_base.handshake_type [*handshake_type]]]
    [Different handshake types. ]
  
  ]

]

[heading Protected Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.ssl__stream_base._stream_base [*~stream_base]]]
    [Protected destructor to prevent deletion through this type. ]
  ]
  
]


[section:handshake_type ssl::stream_base::handshake_type]

[indexterm2 handshake_type..ssl::stream_base] Different handshake types. 

  enum handshake_type

[heading Values]
[variablelist

  [
    [client]
    [Perform handshaking as a client. ]
  ]

  [
    [server]
    [Perform handshaking as a server. ]
  ]

]



[endsect]



[section:_stream_base ssl::stream_base::~stream_base]

[indexterm2 ~stream_base..ssl::stream_base] Protected destructor to prevent deletion through this type. 

  ~stream_base();



[endsect]



[endsect]

[section:ssl__stream_service ssl::stream_service]

Default service implementation for an SSL stream. 

  class stream_service :
    public io_service::service


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.ssl__stream_service.impl_type [*impl_type]]]
    [The type of a stream implementation. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.ssl__stream_service.async_handshake [*async_handshake]]]
    [Start an asynchronous SSL handshake. ]
  ]
  
  [
    [[link boost_asio.reference.ssl__stream_service.async_read_some [*async_read_some]]]
    [Start an asynchronous read. ]
  ]
  
  [
    [[link boost_asio.reference.ssl__stream_service.async_shutdown [*async_shutdown]]]
    [Asynchronously shut down SSL on the stream. ]
  ]
  
  [
    [[link boost_asio.reference.ssl__stream_service.async_write_some [*async_write_some]]]
    [Start an asynchronous write. ]
  ]
  
  [
    [[link boost_asio.reference.ssl__stream_service.create [*create]]]
    [Create a new stream implementation. ]
  ]
  
  [
    [[link boost_asio.reference.ssl__stream_service.destroy [*destroy]]]
    [Destroy a stream implementation. ]
  ]
  
  [
    [[link boost_asio.reference.ssl__stream_service.get_io_service [*get_io_service]]]
    [Get the io_service object that owns the service. ]
  ]
  
  [
    [[link boost_asio.reference.ssl__stream_service.handshake [*handshake]]]
    [Perform SSL handshaking. ]
  ]
  
  [
    [[link boost_asio.reference.ssl__stream_service.in_avail [*in_avail]]]
    [Determine the amount of data that may be read without blocking. ]
  ]
  
  [
    [[link boost_asio.reference.ssl__stream_service.io_service [*io_service]]]
    [(Deprecated: use get_io_service().) Get the io_service object that owns the service. ]
  ]
  
  [
    [[link boost_asio.reference.ssl__stream_service.null [*null]]]
    [Return a null stream implementation. ]
  ]
  
  [
    [[link boost_asio.reference.ssl__stream_service.peek [*peek]]]
    [Peek at the incoming data on the stream. ]
  ]
  
  [
    [[link boost_asio.reference.ssl__stream_service.read_some [*read_some]]]
    [Read some data from the stream. ]
  ]
  
  [
    [[link boost_asio.reference.ssl__stream_service.shutdown [*shutdown]]]
    [Shut down SSL on the stream. ]
  ]
  
  [
    [[link boost_asio.reference.ssl__stream_service.shutdown_service [*shutdown_service]]]
    [Destroy all user-defined handler objects owned by the service. ]
  ]
  
  [
    [[link boost_asio.reference.ssl__stream_service.stream_service [*stream_service]]]
    [Construct a new stream service for the specified io_service. ]
  ]
  
  [
    [[link boost_asio.reference.ssl__stream_service.write_some [*write_some]]]
    [Write some data to the stream. ]
  ]
  
]

[heading Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.ssl__stream_service.id [*id]]]
    [The unique service identifier. ]
  ]

]


[section:async_handshake ssl::stream_service::async_handshake]

[indexterm2 async_handshake..ssl::stream_service] Start an asynchronous SSL handshake. 

  template<
      typename Stream,
      typename HandshakeHandler>
  void async_handshake(
      impl_type & impl,
      Stream & next_layer,
      stream_base::handshake_type type,
      HandshakeHandler handler);



[endsect]



[section:async_read_some ssl::stream_service::async_read_some]

[indexterm2 async_read_some..ssl::stream_service] Start an asynchronous read. 

  template<
      typename Stream,
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
  void async_read_some(
      impl_type & impl,
      Stream & next_layer,
      const MutableBufferSequence & buffers,
      ReadHandler handler);



[endsect]



[section:async_shutdown ssl::stream_service::async_shutdown]

[indexterm2 async_shutdown..ssl::stream_service] Asynchronously shut down SSL on the stream. 

  template<
      typename Stream,
      typename ShutdownHandler>
  void async_shutdown(
      impl_type & impl,
      Stream & next_layer,
      ShutdownHandler handler);



[endsect]



[section:async_write_some ssl::stream_service::async_write_some]

[indexterm2 async_write_some..ssl::stream_service] Start an asynchronous write. 

  template<
      typename Stream,
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
  void async_write_some(
      impl_type & impl,
      Stream & next_layer,
      const ConstBufferSequence & buffers,
      WriteHandler handler);



[endsect]



[section:create ssl::stream_service::create]

[indexterm2 create..ssl::stream_service] Create a new stream implementation. 

  template<
      typename Stream,
      typename Context_Service>
  void create(
      impl_type & impl,
      Stream & next_layer,
      basic_context< Context_Service > & context);



[endsect]



[section:destroy ssl::stream_service::destroy]

[indexterm2 destroy..ssl::stream_service] Destroy a stream implementation. 

  template<
      typename Stream>
  void destroy(
      impl_type & impl,
      Stream & next_layer);



[endsect]



[section:get_io_service ssl::stream_service::get_io_service]


['Inherited from io_service.]

[indexterm2 get_io_service..ssl::stream_service] Get the io_service object that owns the service. 

  boost::asio::io_service & get_io_service();



[endsect]



[section:handshake ssl::stream_service::handshake]

[indexterm2 handshake..ssl::stream_service] Perform SSL handshaking. 

  template<
      typename Stream>
  boost::system::error_code handshake(
      impl_type & impl,
      Stream & next_layer,
      stream_base::handshake_type type,
      boost::system::error_code & ec);



[endsect]



[section:id ssl::stream_service::id]

[indexterm2 id..ssl::stream_service] The unique service identifier. 

  static boost::asio::io_service::id id;



[endsect]



[section:impl_type ssl::stream_service::impl_type]

[indexterm2 impl_type..ssl::stream_service] The type of a stream implementation. 

  typedef implementation_defined impl_type;




[endsect]



[section:in_avail ssl::stream_service::in_avail]

[indexterm2 in_avail..ssl::stream_service] Determine the amount of data that may be read without blocking. 

  template<
      typename Stream>
  std::size_t in_avail(
      impl_type & impl,
      Stream & next_layer,
      boost::system::error_code & ec);



[endsect]



[section:io_service ssl::stream_service::io_service]


['Inherited from io_service.]

[indexterm2 io_service..ssl::stream_service] (Deprecated: use get_io_service().) Get the io_service object that owns the service. 

  boost::asio::io_service & io_service();



[endsect]



[section:null ssl::stream_service::null]

[indexterm2 null..ssl::stream_service] Return a null stream implementation. 

  impl_type null() const;



[endsect]



[section:peek ssl::stream_service::peek]

[indexterm2 peek..ssl::stream_service] Peek at the incoming data on the stream. 

  template<
      typename Stream,
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t peek(
      impl_type & impl,
      Stream & next_layer,
      const MutableBufferSequence & buffers,
      boost::system::error_code & ec);



[endsect]



[section:read_some ssl::stream_service::read_some]

[indexterm2 read_some..ssl::stream_service] Read some data from the stream. 

  template<
      typename Stream,
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t read_some(
      impl_type & impl,
      Stream & next_layer,
      const MutableBufferSequence & buffers,
      boost::system::error_code & ec);



[endsect]



[section:shutdown ssl::stream_service::shutdown]

[indexterm2 shutdown..ssl::stream_service] Shut down SSL on the stream. 

  template<
      typename Stream>
  boost::system::error_code shutdown(
      impl_type & impl,
      Stream & next_layer,
      boost::system::error_code & ec);



[endsect]



[section:shutdown_service ssl::stream_service::shutdown_service]

[indexterm2 shutdown_service..ssl::stream_service] Destroy all user-defined handler objects owned by the service. 

  void shutdown_service();



[endsect]



[section:stream_service ssl::stream_service::stream_service]

[indexterm2 stream_service..ssl::stream_service] Construct a new stream service for the specified io_service. 

  stream_service(
      boost::asio::io_service & io_service);



[endsect]



[section:write_some ssl::stream_service::write_some]

[indexterm2 write_some..ssl::stream_service] Write some data to the stream. 

  template<
      typename Stream,
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t write_some(
      impl_type & impl,
      Stream & next_layer,
      const ConstBufferSequence & buffers,
      boost::system::error_code & ec);



[endsect]



[endsect]


[section:strand strand]

[indexterm1 strand] Typedef for backwards compatibility. 

  typedef boost::asio::io_service::strand strand;


[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.io_service__strand.dispatch [*dispatch]]]
    [Request the strand to invoke the given handler. ]
  ]
  
  [
    [[link boost_asio.reference.io_service__strand.get_io_service [*get_io_service]]]
    [Get the io_service associated with the strand. ]
  ]
  
  [
    [[link boost_asio.reference.io_service__strand.io_service [*io_service]]]
    [(Deprecated: use get_io_service().) Get the io_service associated with the strand. ]
  ]
  
  [
    [[link boost_asio.reference.io_service__strand.post [*post]]]
    [Request the strand to invoke the given handler and return immediately. ]
  ]
  
  [
    [[link boost_asio.reference.io_service__strand.strand [*strand]]]
    [Constructor. ]
  ]
  
  [
    [[link boost_asio.reference.io_service__strand.wrap [*wrap]]]
    [Create a new handler that automatically dispatches the wrapped handler on the strand. ]
  ]
  
  [
    [[link boost_asio.reference.io_service__strand._strand [*~strand]]]
    [Destructor. ]
  ]
  
]

The io_service::strand class provides the ability to post and dispatch handlers with the guarantee that none of those handlers will execute concurrently.


[heading Thread Safety]
  
[*Distinct] [*objects:]  Safe.

[*Shared] [*objects:]  Safe.




[endsect]


[section:stream_socket_service stream_socket_service]

Default service implementation for a stream socket. 

  template<
      typename ``[link boost_asio.reference.Protocol Protocol]``>
  class stream_socket_service :
    public io_service::service


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.stream_socket_service.endpoint_type [*endpoint_type]]]
    [The endpoint type. ]
  
  ]

  [

    [[link boost_asio.reference.stream_socket_service.implementation_type [*implementation_type]]]
    [The type of a stream socket implementation. ]
  
  ]

  [

    [[link boost_asio.reference.stream_socket_service.native_type [*native_type]]]
    [The native socket type. ]
  
  ]

  [

    [[link boost_asio.reference.stream_socket_service.protocol_type [*protocol_type]]]
    [The protocol type. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.stream_socket_service.assign [*assign]]]
    [Assign an existing native socket to a stream socket. ]
  ]
  
  [
    [[link boost_asio.reference.stream_socket_service.async_connect [*async_connect]]]
    [Start an asynchronous connect. ]
  ]
  
  [
    [[link boost_asio.reference.stream_socket_service.async_receive [*async_receive]]]
    [Start an asynchronous receive. ]
  ]
  
  [
    [[link boost_asio.reference.stream_socket_service.async_send [*async_send]]]
    [Start an asynchronous send. ]
  ]
  
  [
    [[link boost_asio.reference.stream_socket_service.at_mark [*at_mark]]]
    [Determine whether the socket is at the out-of-band data mark. ]
  ]
  
  [
    [[link boost_asio.reference.stream_socket_service.available [*available]]]
    [Determine the number of bytes available for reading. ]
  ]
  
  [
    [[link boost_asio.reference.stream_socket_service.bind [*bind]]]
    [Bind the stream socket to the specified local endpoint. ]
  ]
  
  [
    [[link boost_asio.reference.stream_socket_service.cancel [*cancel]]]
    [Cancel all asynchronous operations associated with the socket. ]
  ]
  
  [
    [[link boost_asio.reference.stream_socket_service.close [*close]]]
    [Close a stream socket implementation. ]
  ]
  
  [
    [[link boost_asio.reference.stream_socket_service.connect [*connect]]]
    [Connect the stream socket to the specified endpoint. ]
  ]
  
  [
    [[link boost_asio.reference.stream_socket_service.construct [*construct]]]
    [Construct a new stream socket implementation. ]
  ]
  
  [
    [[link boost_asio.reference.stream_socket_service.destroy [*destroy]]]
    [Destroy a stream socket implementation. ]
  ]
  
  [
    [[link boost_asio.reference.stream_socket_service.get_io_service [*get_io_service]]]
    [Get the io_service object that owns the service. ]
  ]
  
  [
    [[link boost_asio.reference.stream_socket_service.get_option [*get_option]]]
    [Get a socket option. ]
  ]
  
  [
    [[link boost_asio.reference.stream_socket_service.io_control [*io_control]]]
    [Perform an IO control command on the socket. ]
  ]
  
  [
    [[link boost_asio.reference.stream_socket_service.io_service [*io_service]]]
    [(Deprecated: use get_io_service().) Get the io_service object that owns the service. ]
  ]
  
  [
    [[link boost_asio.reference.stream_socket_service.is_open [*is_open]]]
    [Determine whether the socket is open. ]
  ]
  
  [
    [[link boost_asio.reference.stream_socket_service.local_endpoint [*local_endpoint]]]
    [Get the local endpoint. ]
  ]
  
  [
    [[link boost_asio.reference.stream_socket_service.native [*native]]]
    [Get the native socket implementation. ]
  ]
  
  [
    [[link boost_asio.reference.stream_socket_service.open [*open]]]
    [Open a stream socket. ]
  ]
  
  [
    [[link boost_asio.reference.stream_socket_service.receive [*receive]]]
    [Receive some data from the peer. ]
  ]
  
  [
    [[link boost_asio.reference.stream_socket_service.remote_endpoint [*remote_endpoint]]]
    [Get the remote endpoint. ]
  ]
  
  [
    [[link boost_asio.reference.stream_socket_service.send [*send]]]
    [Send the given data to the peer. ]
  ]
  
  [
    [[link boost_asio.reference.stream_socket_service.set_option [*set_option]]]
    [Set a socket option. ]
  ]
  
  [
    [[link boost_asio.reference.stream_socket_service.shutdown [*shutdown]]]
    [Disable sends or receives on the socket. ]
  ]
  
  [
    [[link boost_asio.reference.stream_socket_service.shutdown_service [*shutdown_service]]]
    [Destroy all user-defined handler objects owned by the service. ]
  ]
  
  [
    [[link boost_asio.reference.stream_socket_service.stream_socket_service [*stream_socket_service]]]
    [Construct a new stream socket service for the specified io_service. ]
  ]
  
]

[heading Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.stream_socket_service.id [*id]]]
    [The unique service identifier. ]
  ]

]


[section:assign stream_socket_service::assign]

[indexterm2 assign..stream_socket_service] Assign an existing native socket to a stream socket. 

  boost::system::error_code assign(
      implementation_type & impl,
      const protocol_type & protocol,
      const native_type & native_socket,
      boost::system::error_code & ec);



[endsect]



[section:async_connect stream_socket_service::async_connect]

[indexterm2 async_connect..stream_socket_service] Start an asynchronous connect. 

  template<
      typename ``[link boost_asio.reference.ConnectHandler ConnectHandler]``>
  void async_connect(
      implementation_type & impl,
      const endpoint_type & peer_endpoint,
      ConnectHandler handler);



[endsect]



[section:async_receive stream_socket_service::async_receive]

[indexterm2 async_receive..stream_socket_service] Start an asynchronous receive. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
  void async_receive(
      implementation_type & impl,
      const MutableBufferSequence & buffers,
      socket_base::message_flags flags,
      ReadHandler handler);



[endsect]



[section:async_send stream_socket_service::async_send]

[indexterm2 async_send..stream_socket_service] Start an asynchronous send. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
  void async_send(
      implementation_type & impl,
      const ConstBufferSequence & buffers,
      socket_base::message_flags flags,
      WriteHandler handler);



[endsect]



[section:at_mark stream_socket_service::at_mark]

[indexterm2 at_mark..stream_socket_service] Determine whether the socket is at the out-of-band data mark. 

  bool at_mark(
      const implementation_type & impl,
      boost::system::error_code & ec) const;



[endsect]



[section:available stream_socket_service::available]

[indexterm2 available..stream_socket_service] Determine the number of bytes available for reading. 

  std::size_t available(
      const implementation_type & impl,
      boost::system::error_code & ec) const;



[endsect]



[section:bind stream_socket_service::bind]

[indexterm2 bind..stream_socket_service] Bind the stream socket to the specified local endpoint. 

  boost::system::error_code bind(
      implementation_type & impl,
      const endpoint_type & endpoint,
      boost::system::error_code & ec);



[endsect]



[section:cancel stream_socket_service::cancel]

[indexterm2 cancel..stream_socket_service] Cancel all asynchronous operations associated with the socket. 

  boost::system::error_code cancel(
      implementation_type & impl,
      boost::system::error_code & ec);



[endsect]



[section:close stream_socket_service::close]

[indexterm2 close..stream_socket_service] Close a stream socket implementation. 

  boost::system::error_code close(
      implementation_type & impl,
      boost::system::error_code & ec);



[endsect]



[section:connect stream_socket_service::connect]

[indexterm2 connect..stream_socket_service] Connect the stream socket to the specified endpoint. 

  boost::system::error_code connect(
      implementation_type & impl,
      const endpoint_type & peer_endpoint,
      boost::system::error_code & ec);



[endsect]



[section:construct stream_socket_service::construct]

[indexterm2 construct..stream_socket_service] Construct a new stream socket implementation. 

  void construct(
      implementation_type & impl);



[endsect]



[section:destroy stream_socket_service::destroy]

[indexterm2 destroy..stream_socket_service] Destroy a stream socket implementation. 

  void destroy(
      implementation_type & impl);



[endsect]



[section:endpoint_type stream_socket_service::endpoint_type]

[indexterm2 endpoint_type..stream_socket_service] The endpoint type. 

  typedef Protocol::endpoint endpoint_type;




[endsect]



[section:get_io_service stream_socket_service::get_io_service]


['Inherited from io_service.]

[indexterm2 get_io_service..stream_socket_service] Get the io_service object that owns the service. 

  boost::asio::io_service & get_io_service();



[endsect]



[section:get_option stream_socket_service::get_option]

[indexterm2 get_option..stream_socket_service] Get a socket option. 

  template<
      typename ``[link boost_asio.reference.GettableSocketOption GettableSocketOption]``>
  boost::system::error_code get_option(
      const implementation_type & impl,
      GettableSocketOption & option,
      boost::system::error_code & ec) const;



[endsect]



[section:id stream_socket_service::id]

[indexterm2 id..stream_socket_service] The unique service identifier. 

  static boost::asio::io_service::id id;



[endsect]



[section:implementation_type stream_socket_service::implementation_type]

[indexterm2 implementation_type..stream_socket_service] The type of a stream socket implementation. 

  typedef implementation_defined implementation_type;




[endsect]



[section:io_control stream_socket_service::io_control]

[indexterm2 io_control..stream_socket_service] Perform an IO control command on the socket. 

  template<
      typename ``[link boost_asio.reference.IoControlCommand IoControlCommand]``>
  boost::system::error_code io_control(
      implementation_type & impl,
      IoControlCommand & command,
      boost::system::error_code & ec);



[endsect]



[section:io_service stream_socket_service::io_service]


['Inherited from io_service.]

[indexterm2 io_service..stream_socket_service] (Deprecated: use get_io_service().) Get the io_service object that owns the service. 

  boost::asio::io_service & io_service();



[endsect]



[section:is_open stream_socket_service::is_open]

[indexterm2 is_open..stream_socket_service] Determine whether the socket is open. 

  bool is_open(
      const implementation_type & impl) const;



[endsect]



[section:local_endpoint stream_socket_service::local_endpoint]

[indexterm2 local_endpoint..stream_socket_service] Get the local endpoint. 

  endpoint_type local_endpoint(
      const implementation_type & impl,
      boost::system::error_code & ec) const;



[endsect]



[section:native stream_socket_service::native]

[indexterm2 native..stream_socket_service] Get the native socket implementation. 

  native_type native(
      implementation_type & impl);



[endsect]



[section:native_type stream_socket_service::native_type]

[indexterm2 native_type..stream_socket_service] The native socket type. 

  typedef implementation_defined native_type;




[endsect]



[section:open stream_socket_service::open]

[indexterm2 open..stream_socket_service] Open a stream socket. 

  boost::system::error_code open(
      implementation_type & impl,
      const protocol_type & protocol,
      boost::system::error_code & ec);



[endsect]



[section:protocol_type stream_socket_service::protocol_type]

[indexterm2 protocol_type..stream_socket_service] The protocol type. 

  typedef Protocol protocol_type;




[endsect]



[section:receive stream_socket_service::receive]

[indexterm2 receive..stream_socket_service] Receive some data from the peer. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t receive(
      implementation_type & impl,
      const MutableBufferSequence & buffers,
      socket_base::message_flags flags,
      boost::system::error_code & ec);



[endsect]



[section:remote_endpoint stream_socket_service::remote_endpoint]

[indexterm2 remote_endpoint..stream_socket_service] Get the remote endpoint. 

  endpoint_type remote_endpoint(
      const implementation_type & impl,
      boost::system::error_code & ec) const;



[endsect]



[section:send stream_socket_service::send]

[indexterm2 send..stream_socket_service] Send the given data to the peer. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t send(
      implementation_type & impl,
      const ConstBufferSequence & buffers,
      socket_base::message_flags flags,
      boost::system::error_code & ec);



[endsect]



[section:set_option stream_socket_service::set_option]

[indexterm2 set_option..stream_socket_service] Set a socket option. 

  template<
      typename ``[link boost_asio.reference.SettableSocketOption SettableSocketOption]``>
  boost::system::error_code set_option(
      implementation_type & impl,
      const SettableSocketOption & option,
      boost::system::error_code & ec);



[endsect]



[section:shutdown stream_socket_service::shutdown]

[indexterm2 shutdown..stream_socket_service] Disable sends or receives on the socket. 

  boost::system::error_code shutdown(
      implementation_type & impl,
      socket_base::shutdown_type what,
      boost::system::error_code & ec);



[endsect]



[section:shutdown_service stream_socket_service::shutdown_service]

[indexterm2 shutdown_service..stream_socket_service] Destroy all user-defined handler objects owned by the service. 

  void shutdown_service();



[endsect]



[section:stream_socket_service stream_socket_service::stream_socket_service]

[indexterm2 stream_socket_service..stream_socket_service] Construct a new stream socket service for the specified io_service. 

  stream_socket_service(
      boost::asio::io_service & io_service);



[endsect]



[endsect]


[section:streambuf streambuf]

[indexterm1 streambuf] Typedef for the typical usage of basic_streambuf. 

  typedef basic_streambuf streambuf;


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.basic_streambuf.const_buffers_type [*const_buffers_type]]]
    [The type used to represent the input sequence as a list of buffers. ]
  
  ]

  [

    [[link boost_asio.reference.basic_streambuf.mutable_buffers_type [*mutable_buffers_type]]]
    [The type used to represent the output sequence as a list of buffers. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_streambuf.basic_streambuf [*basic_streambuf]]]
    [Construct a basic_streambuf object. ]
  ]
  
  [
    [[link boost_asio.reference.basic_streambuf.commit [*commit]]]
    [Move characters from the output sequence to the input sequence. ]
  ]
  
  [
    [[link boost_asio.reference.basic_streambuf.consume [*consume]]]
    [Remove characters from the input sequence. ]
  ]
  
  [
    [[link boost_asio.reference.basic_streambuf.data [*data]]]
    [Get a list of buffers that represents the input sequence. ]
  ]
  
  [
    [[link boost_asio.reference.basic_streambuf.max_size [*max_size]]]
    [Get the maximum size of the basic_streambuf. ]
  ]
  
  [
    [[link boost_asio.reference.basic_streambuf.prepare [*prepare]]]
    [Get a list of buffers that represents the output sequence, with the given size. ]
  ]
  
  [
    [[link boost_asio.reference.basic_streambuf.size [*size]]]
    [Get the size of the input sequence. ]
  ]
  
]

[heading Protected Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.basic_streambuf.overflow [*overflow]]]
    [Override std::streambuf behaviour. ]
  ]
  
  [
    [[link boost_asio.reference.basic_streambuf.reserve [*reserve]]]
    []
  ]
  
  [
    [[link boost_asio.reference.basic_streambuf.underflow [*underflow]]]
    [Override std::streambuf behaviour. ]
  ]
  
]

The `basic_streambuf` class is derived from `std::streambuf` to associate the streambuf's input and output sequences with one or more character arrays. These character arrays are internal to the `basic_streambuf` object, but direct access to the array elements is provided to permit them to be used efficiently with I/O operations. Characters written to the output sequence of a `basic_streambuf` object are appended to the input sequence of the same object.

The `basic_streambuf` class's public interface is intended to permit the following implementation strategies:


* A single contiguous character array, which is reallocated as necessary to accommodate changes in the size of the character sequence. This is the implementation approach currently used in Asio.

* A sequence of one or more character arrays, where each array is of the same size. Additional character array objects are appended to the sequence to accommodate changes in the size of the character sequence.

* A sequence of one or more character arrays of varying sizes. Additional character array objects are appended to the sequence to accommodate changes in the size of the character sequence.

The constructor for basic_streambuf accepts a `size_t` argument specifying the maximum of the sum of the sizes of the input sequence and output sequence. During the lifetime of the `basic_streambuf` object, the following invariant holds: 

   size() <= max_size()


Any member function that would, if successful, cause the invariant to be violated shall throw an exception of class `std::length_error`.

The constructor for `basic_streambuf` takes an Allocator argument. A copy of this argument is used for any memory allocation performed, by the constructor and by all member functions, during the lifetime of each `basic_streambuf` object.


[heading Examples]
  
Writing directly from an streambuf to a socket: 

   boost::asio::streambuf b;
   std::ostream os(&b);
   os << "Hello, World!\n";

   // try sending some data in input sequence
   size_t n = sock.send(b.data());

   b.consume(n); // sent data is removed from input sequence




Reading from a socket directly into a streambuf: 

   boost::asio::streambuf b;

   // reserve 512 bytes in output sequence
   boost::asio::streambuf::const_buffers_type bufs = b.prepare(512);

   size_t n = sock.receive(bufs);

   // received data is "committed" from output sequence to input sequence
   b.commit(n);

   std::istream is(&b);
   std::string s;
   is >> s;






[endsect]


[section:time_traits_lt__ptime__gt_ time_traits< boost::posix_time::ptime >]

Time traits specialised for posix_time. 

  template<>
  struct time_traits< boost::posix_time::ptime >


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.time_traits_lt__ptime__gt_.duration_type [*duration_type]]]
    [The duration type. ]
  
  ]

  [

    [[link boost_asio.reference.time_traits_lt__ptime__gt_.time_type [*time_type]]]
    [The time type. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.time_traits_lt__ptime__gt_.add [*add]]]
    [Add a duration to a time. ]
  ]
  
  [
    [[link boost_asio.reference.time_traits_lt__ptime__gt_.less_than [*less_than]]]
    [Test whether one time is less than another. ]
  ]
  
  [
    [[link boost_asio.reference.time_traits_lt__ptime__gt_.now [*now]]]
    [Get the current time. ]
  ]
  
  [
    [[link boost_asio.reference.time_traits_lt__ptime__gt_.subtract [*subtract]]]
    [Subtract one time from another. ]
  ]
  
  [
    [[link boost_asio.reference.time_traits_lt__ptime__gt_.to_posix_duration [*to_posix_duration]]]
    [Convert to POSIX duration type. ]
  ]
  
]


[section:add time_traits< boost::posix_time::ptime >::add]

[indexterm2 add..time_traits< boost::posix_time::ptime >] Add a duration to a time. 

  static time_type add(
      const time_type & t,
      const duration_type & d);



[endsect]



[section:duration_type time_traits< boost::posix_time::ptime >::duration_type]

[indexterm2 duration_type..time_traits< boost::posix_time::ptime >] The duration type. 

  typedef boost::posix_time::time_duration duration_type;




[endsect]



[section:less_than time_traits< boost::posix_time::ptime >::less_than]

[indexterm2 less_than..time_traits< boost::posix_time::ptime >] Test whether one time is less than another. 

  static bool less_than(
      const time_type & t1,
      const time_type & t2);



[endsect]



[section:now time_traits< boost::posix_time::ptime >::now]

[indexterm2 now..time_traits< boost::posix_time::ptime >] Get the current time. 

  static time_type now();



[endsect]



[section:subtract time_traits< boost::posix_time::ptime >::subtract]

[indexterm2 subtract..time_traits< boost::posix_time::ptime >] Subtract one time from another. 

  static duration_type subtract(
      const time_type & t1,
      const time_type & t2);



[endsect]



[section:time_type time_traits< boost::posix_time::ptime >::time_type]

[indexterm2 time_type..time_traits< boost::posix_time::ptime >] The time type. 

  typedef boost::posix_time::ptime time_type;




[endsect]



[section:to_posix_duration time_traits< boost::posix_time::ptime >::to_posix_duration]

[indexterm2 to_posix_duration..time_traits< boost::posix_time::ptime >] Convert to POSIX duration type. 

  static boost::posix_time::time_duration to_posix_duration(
      const duration_type & d);



[endsect]



[endsect]


[section:transfer_all transfer_all]

[indexterm1 transfer_all] Return a completion condition function object that indicates that a read or write operation should continue until all of the data has been transferred, or until an error occurs. 

  unspecified transfer_all();


This function is used to create an object, of unspecified type, that meets CompletionCondition requirements.


[heading Example]
  
Reading until a buffer is full: 

   boost::array<char, 128> buf;
   boost::system::error_code ec;
   std::size_t n = boost::asio::read(
       sock, boost::asio::buffer(buf),
       boost::asio::transfer_all(), ec);
   if (ec)
   {
     // An error occurred.
   }
   else
   {
     // n == 128
   }






[endsect]



[section:transfer_at_least transfer_at_least]

[indexterm1 transfer_at_least] Return a completion condition function object that indicates that a read or write operation should continue until a minimum number of bytes has been transferred, or until an error occurs. 

  unspecified transfer_at_least(
      std::size_t minimum);


This function is used to create an object, of unspecified type, that meets CompletionCondition requirements.


[heading Example]
  
Reading until a buffer is full or contains at least 64 bytes: 

   boost::array<char, 128> buf;
   boost::system::error_code ec;
   std::size_t n = boost::asio::read(
       sock, boost::asio::buffer(buf),
       boost::asio::transfer_at_least(64), ec);
   if (ec)
   {
     // An error occurred.
   }
   else
   {
     // n >= 64 && n <= 128
   }






[endsect]



[section:use_service use_service]

[indexterm1 use_service] 

  template<
      typename ``[link boost_asio.reference.Service Service]``>
  Service & use_service(
      io_service & ios);


This function is used to locate a service object that corresponds to the given service type. If there is no existing implementation of the service, then the io_service will create a new instance of the service.


[heading Parameters]
    

[variablelist
  
[[ios][The io\_service object that owns the service.]]

]

[heading Return Value]
      
The service interface implementing the specified service type. Ownership of the service interface is not transferred to the caller. 



[endsect]


[section:windows__basic_handle windows::basic_handle]

Provides Windows handle functionality. 

  template<
      typename ``[link boost_asio.reference.HandleService HandleService]``>
  class basic_handle :
    public basic_io_object< HandleService >


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.windows__basic_handle.implementation_type [*implementation_type]]]
    [The underlying implementation type of I/O object. ]
  
  ]

  [

    [[link boost_asio.reference.windows__basic_handle.lowest_layer_type [*lowest_layer_type]]]
    [A basic_handle is always the lowest layer. ]
  
  ]

  [

    [[link boost_asio.reference.windows__basic_handle.native_type [*native_type]]]
    [The native representation of a handle. ]
  
  ]

  [

    [[link boost_asio.reference.windows__basic_handle.service_type [*service_type]]]
    [The type of the service that will be used to provide I/O operations. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.windows__basic_handle.assign [*assign]]]
    [Assign an existing native handle to the handle. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_handle.basic_handle [*basic_handle]]]
    [Construct a basic_handle without opening it. 

     Construct a basic_handle on an existing native handle. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_handle.cancel [*cancel]]]
    [Cancel all asynchronous operations associated with the handle. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_handle.close [*close]]]
    [Close the handle. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_handle.get_io_service [*get_io_service]]]
    [Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_handle.io_service [*io_service]]]
    [(Deprecated: use get_io_service().) Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_handle.is_open [*is_open]]]
    [Determine whether the handle is open. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_handle.lowest_layer [*lowest_layer]]]
    [Get a reference to the lowest layer. 

     Get a const reference to the lowest layer. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_handle.native [*native]]]
    [Get the native handle representation. ]
  ]
  
]

[heading Protected Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.windows__basic_handle._basic_handle [*~basic_handle]]]
    [Protected destructor to prevent deletion through this type. ]
  ]
  
]

[heading Protected Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.windows__basic_handle.implementation [*implementation]]]
    [The underlying implementation of the I/O object. ]
  ]

  [
    [[link boost_asio.reference.windows__basic_handle.service [*service]]]
    [The service associated with the I/O object. ]
  ]

]

The windows::basic_handle class template provides the ability to wrap a Windows handle.


[heading Thread Safety]
  
[*Distinct] [*objects:]  Safe.

[*Shared] [*objects:]  Unsafe. 


[section:assign windows::basic_handle::assign]

[indexterm2 assign..windows::basic_handle] Assign an existing native handle to the handle. 

  void ``[link boost_asio.reference.windows__basic_handle.assign.overload1 assign]``(
      const native_type & native_handle);

  boost::system::error_code ``[link boost_asio.reference.windows__basic_handle.assign.overload2 assign]``(
      const native_type & native_handle,
      boost::system::error_code & ec);


[section:overload1 windows::basic_handle::assign (1 of 2 overloads)]

Assign an existing native handle to the handle. 

  void assign(
      const native_type & native_handle);



[endsect]



[section:overload2 windows::basic_handle::assign (2 of 2 overloads)]

Assign an existing native handle to the handle. 

  boost::system::error_code assign(
      const native_type & native_handle,
      boost::system::error_code & ec);



[endsect]


[endsect]

[section:basic_handle windows::basic_handle::basic_handle]

[indexterm2 basic_handle..windows::basic_handle] Construct a basic_handle without opening it. 

  ``[link boost_asio.reference.windows__basic_handle.basic_handle.overload1 basic_handle]``(
      boost::asio::io_service & io_service);

Construct a basic_handle on an existing native handle. 

  ``[link boost_asio.reference.windows__basic_handle.basic_handle.overload2 basic_handle]``(
      boost::asio::io_service & io_service,
      const native_type & native_handle);


[section:overload1 windows::basic_handle::basic_handle (1 of 2 overloads)]

Construct a basic_handle without opening it. 

  basic_handle(
      boost::asio::io_service & io_service);


This constructor creates a handle without opening it.


[heading Parameters]
    

[variablelist
  
[[io_service][The io\_service object that the handle will use to dispatch handlers for any asynchronous operations performed on the handle. ]]

]



[endsect]



[section:overload2 windows::basic_handle::basic_handle (2 of 2 overloads)]

Construct a basic_handle on an existing native handle. 

  basic_handle(
      boost::asio::io_service & io_service,
      const native_type & native_handle);


This constructor creates a handle object to hold an existing native handle.


[heading Parameters]
    

[variablelist
  
[[io_service][The io\_service object that the handle will use to dispatch handlers for any asynchronous operations performed on the handle.]]

[[native_handle][A native handle.]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. ]]

]



[endsect]


[endsect]

[section:cancel windows::basic_handle::cancel]

[indexterm2 cancel..windows::basic_handle] Cancel all asynchronous operations associated with the handle. 

  void ``[link boost_asio.reference.windows__basic_handle.cancel.overload1 cancel]``();

  boost::system::error_code ``[link boost_asio.reference.windows__basic_handle.cancel.overload2 cancel]``(
      boost::system::error_code & ec);


[section:overload1 windows::basic_handle::cancel (1 of 2 overloads)]

Cancel all asynchronous operations associated with the handle. 

  void cancel();


This 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.


[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. ]]

]



[endsect]



[section:overload2 windows::basic_handle::cancel (2 of 2 overloads)]

Cancel all asynchronous operations associated with the handle. 

  boost::system::error_code cancel(
      boost::system::error_code & ec);


This 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.


[heading Parameters]
    

[variablelist
  
[[ec][Set to indicate what error occurred, if any. ]]

]



[endsect]


[endsect]

[section:close windows::basic_handle::close]

[indexterm2 close..windows::basic_handle] Close the handle. 

  void ``[link boost_asio.reference.windows__basic_handle.close.overload1 close]``();

  boost::system::error_code ``[link boost_asio.reference.windows__basic_handle.close.overload2 close]``(
      boost::system::error_code & ec);


[section:overload1 windows::basic_handle::close (1 of 2 overloads)]

Close the handle. 

  void close();


This function is used to close the handle. Any asynchronous read or write operations will be cancelled immediately, and will complete with the boost::asio::error::operation\_aborted error.


[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. ]]

]



[endsect]



[section:overload2 windows::basic_handle::close (2 of 2 overloads)]

Close the handle. 

  boost::system::error_code close(
      boost::system::error_code & ec);


This function is used to close the handle. Any asynchronous read or write operations will be cancelled immediately, and will complete with the boost::asio::error::operation\_aborted error.


[heading Parameters]
    

[variablelist
  
[[ec][Set to indicate what error occurred, if any. ]]

]



[endsect]


[endsect]


[section:get_io_service windows::basic_handle::get_io_service]


['Inherited from basic_io_object.]

[indexterm2 get_io_service..windows::basic_handle] Get the io_service associated with the object. 

  boost::asio::io_service & get_io_service();


This function may be used to obtain the io_service object that the I/O object uses to dispatch handlers for asynchronous operations.


[heading Return Value]
      
A reference to the io_service object that the I/O object will use to dispatch handlers. Ownership is not transferred to the caller. 



[endsect]



[section:implementation windows::basic_handle::implementation]


['Inherited from basic_io_object.]

[indexterm2 implementation..windows::basic_handle] The underlying implementation of the I/O object. 

  implementation_type implementation;



[endsect]



[section:implementation_type windows::basic_handle::implementation_type]


['Inherited from basic_io_object.]

[indexterm2 implementation_type..windows::basic_handle] The underlying implementation type of I/O object. 

  typedef service_type::implementation_type implementation_type;




[endsect]



[section:io_service windows::basic_handle::io_service]


['Inherited from basic_io_object.]

[indexterm2 io_service..windows::basic_handle] (Deprecated: use get_io_service().) Get the io_service associated with the object. 

  boost::asio::io_service & io_service();


This function may be used to obtain the io_service object that the I/O object uses to dispatch handlers for asynchronous operations.


[heading Return Value]
      
A reference to the io_service object that the I/O object will use to dispatch handlers. Ownership is not transferred to the caller. 



[endsect]



[section:is_open windows::basic_handle::is_open]

[indexterm2 is_open..windows::basic_handle] Determine whether the handle is open. 

  bool is_open() const;



[endsect]


[section:lowest_layer windows::basic_handle::lowest_layer]

[indexterm2 lowest_layer..windows::basic_handle] Get a reference to the lowest layer. 

  lowest_layer_type & ``[link boost_asio.reference.windows__basic_handle.lowest_layer.overload1 lowest_layer]``();

Get a const reference to the lowest layer. 

  const lowest_layer_type & ``[link boost_asio.reference.windows__basic_handle.lowest_layer.overload2 lowest_layer]``() const;


[section:overload1 windows::basic_handle::lowest_layer (1 of 2 overloads)]

Get a reference to the lowest layer. 

  lowest_layer_type & lowest_layer();


This function returns a reference to the lowest layer in a stack of layers. Since a basic_handle cannot contain any further layers, it simply returns a reference to itself.


[heading Return Value]
      
A reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller. 



[endsect]



[section:overload2 windows::basic_handle::lowest_layer (2 of 2 overloads)]

Get a const reference to the lowest layer. 

  const lowest_layer_type & lowest_layer() const;


This function returns a const reference to the lowest layer in a stack of layers. Since a basic_handle cannot contain any further layers, it simply returns a reference to itself.


[heading Return Value]
      
A const reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller. 



[endsect]


[endsect]


[section:lowest_layer_type windows::basic_handle::lowest_layer_type]

[indexterm2 lowest_layer_type..windows::basic_handle] A basic_handle is always the lowest layer. 

  typedef basic_handle< HandleService > lowest_layer_type;


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.windows__basic_handle.implementation_type [*implementation_type]]]
    [The underlying implementation type of I/O object. ]
  
  ]

  [

    [[link boost_asio.reference.windows__basic_handle.lowest_layer_type [*lowest_layer_type]]]
    [A basic_handle is always the lowest layer. ]
  
  ]

  [

    [[link boost_asio.reference.windows__basic_handle.native_type [*native_type]]]
    [The native representation of a handle. ]
  
  ]

  [

    [[link boost_asio.reference.windows__basic_handle.service_type [*service_type]]]
    [The type of the service that will be used to provide I/O operations. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.windows__basic_handle.assign [*assign]]]
    [Assign an existing native handle to the handle. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_handle.basic_handle [*basic_handle]]]
    [Construct a basic_handle without opening it. 

     Construct a basic_handle on an existing native handle. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_handle.cancel [*cancel]]]
    [Cancel all asynchronous operations associated with the handle. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_handle.close [*close]]]
    [Close the handle. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_handle.get_io_service [*get_io_service]]]
    [Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_handle.io_service [*io_service]]]
    [(Deprecated: use get_io_service().) Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_handle.is_open [*is_open]]]
    [Determine whether the handle is open. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_handle.lowest_layer [*lowest_layer]]]
    [Get a reference to the lowest layer. 

     Get a const reference to the lowest layer. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_handle.native [*native]]]
    [Get the native handle representation. ]
  ]
  
]

[heading Protected Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.windows__basic_handle._basic_handle [*~basic_handle]]]
    [Protected destructor to prevent deletion through this type. ]
  ]
  
]

[heading Protected Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.windows__basic_handle.implementation [*implementation]]]
    [The underlying implementation of the I/O object. ]
  ]

  [
    [[link boost_asio.reference.windows__basic_handle.service [*service]]]
    [The service associated with the I/O object. ]
  ]

]

The windows::basic_handle class template provides the ability to wrap a Windows handle.


[heading Thread Safety]
  
[*Distinct] [*objects:]  Safe.

[*Shared] [*objects:]  Unsafe. 




[endsect]



[section:native windows::basic_handle::native]

[indexterm2 native..windows::basic_handle] Get the native handle representation. 

  native_type native();


This function may be used to obtain the underlying representation of the handle. This is intended to allow access to native handle functionality that is not otherwise provided. 


[endsect]



[section:native_type windows::basic_handle::native_type]

[indexterm2 native_type..windows::basic_handle] The native representation of a handle. 

  typedef HandleService::native_type native_type;




[endsect]



[section:service windows::basic_handle::service]


['Inherited from basic_io_object.]

[indexterm2 service..windows::basic_handle] The service associated with the I/O object. 

  service_type & service;



[endsect]



[section:service_type windows::basic_handle::service_type]


['Inherited from basic_io_object.]

[indexterm2 service_type..windows::basic_handle] The type of the service that will be used to provide I/O operations. 

  typedef HandleService service_type;




[endsect]



[section:_basic_handle windows::basic_handle::~basic_handle]

[indexterm2 ~basic_handle..windows::basic_handle] Protected destructor to prevent deletion through this type. 

  ~basic_handle();



[endsect]



[endsect]

[section:windows__basic_random_access_handle windows::basic_random_access_handle]

Provides random-access handle functionality. 

  template<
      typename ``[link boost_asio.reference.RandomAccessHandleService RandomAccessHandleService]`` = random_access_handle_service>
  class basic_random_access_handle :
    public windows::basic_handle< RandomAccessHandleService >


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.windows__basic_random_access_handle.implementation_type [*implementation_type]]]
    [The underlying implementation type of I/O object. ]
  
  ]

  [

    [[link boost_asio.reference.windows__basic_random_access_handle.lowest_layer_type [*lowest_layer_type]]]
    [A basic_handle is always the lowest layer. ]
  
  ]

  [

    [[link boost_asio.reference.windows__basic_random_access_handle.native_type [*native_type]]]
    [The native representation of a handle. ]
  
  ]

  [

    [[link boost_asio.reference.windows__basic_random_access_handle.service_type [*service_type]]]
    [The type of the service that will be used to provide I/O operations. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.windows__basic_random_access_handle.assign [*assign]]]
    [Assign an existing native handle to the handle. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_random_access_handle.async_read_some_at [*async_read_some_at]]]
    [Start an asynchronous read at the specified offset. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_random_access_handle.async_write_some_at [*async_write_some_at]]]
    [Start an asynchronous write at the specified offset. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_random_access_handle.basic_random_access_handle [*basic_random_access_handle]]]
    [Construct a basic_random_access_handle without opening it. 

     Construct a basic_random_access_handle on an existing native handle. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_random_access_handle.cancel [*cancel]]]
    [Cancel all asynchronous operations associated with the handle. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_random_access_handle.close [*close]]]
    [Close the handle. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_random_access_handle.get_io_service [*get_io_service]]]
    [Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_random_access_handle.io_service [*io_service]]]
    [(Deprecated: use get_io_service().) Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_random_access_handle.is_open [*is_open]]]
    [Determine whether the handle is open. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_random_access_handle.lowest_layer [*lowest_layer]]]
    [Get a reference to the lowest layer. 

     Get a const reference to the lowest layer. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_random_access_handle.native [*native]]]
    [Get the native handle representation. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_random_access_handle.read_some_at [*read_some_at]]]
    [Read some data from the handle at the specified offset. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_random_access_handle.write_some_at [*write_some_at]]]
    [Write some data to the handle at the specified offset. ]
  ]
  
]

[heading Protected Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.windows__basic_random_access_handle.implementation [*implementation]]]
    [The underlying implementation of the I/O object. ]
  ]

  [
    [[link boost_asio.reference.windows__basic_random_access_handle.service [*service]]]
    [The service associated with the I/O object. ]
  ]

]

The windows::basic_random_access_handle class template provides asynchronous and blocking random-access handle functionality.


[heading Thread Safety]
  
[*Distinct] [*objects:]  Safe.

[*Shared] [*objects:]  Unsafe. 


[section:assign windows::basic_random_access_handle::assign]

[indexterm2 assign..windows::basic_random_access_handle] Assign an existing native handle to the handle. 

  void ``[link boost_asio.reference.windows__basic_random_access_handle.assign.overload1 assign]``(
      const native_type & native_handle);

  boost::system::error_code ``[link boost_asio.reference.windows__basic_random_access_handle.assign.overload2 assign]``(
      const native_type & native_handle,
      boost::system::error_code & ec);


[section:overload1 windows::basic_random_access_handle::assign (1 of 2 overloads)]


['Inherited from windows::basic_handle.]

Assign an existing native handle to the handle. 

  void assign(
      const native_type & native_handle);



[endsect]



[section:overload2 windows::basic_random_access_handle::assign (2 of 2 overloads)]


['Inherited from windows::basic_handle.]

Assign an existing native handle to the handle. 

  boost::system::error_code assign(
      const native_type & native_handle,
      boost::system::error_code & ec);



[endsect]


[endsect]


[section:async_read_some_at windows::basic_random_access_handle::async_read_some_at]

[indexterm2 async_read_some_at..windows::basic_random_access_handle] Start an asynchronous read at the specified offset. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
  void async_read_some_at(
      boost::uint64_t offset,
      const MutableBufferSequence & buffers,
      ReadHandler handler);


This function is used to asynchronously read data from the random-access handle. The function call always returns immediately.


[heading Parameters]
    

[variablelist
  
[[offset][The offset at which the data will be read.]]

[[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.]]

[[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: 
``
   void handler(
     const boost::system::error_code& error, // Result of operation.
     std::size_t bytes_transferred           // Number of bytes read.
   ); 
``
Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using boost::asio::io\_service::post().]]

]

[heading Remarks]
      
The read operation may not read all of the requested number of bytes. Consider using the 
[link boost_asio.reference.async_read_at async_read_at]  function if you need to ensure that the requested amount of data is read before the asynchronous operation completes.

[heading Example]
  
To read into a single data buffer use the 
[link boost_asio.reference.buffer buffer]  function as follows: 

   handle.async_read_some_at(42, boost::asio::buffer(data, size), handler);


See the 
[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. 



[endsect]



[section:async_write_some_at windows::basic_random_access_handle::async_write_some_at]

[indexterm2 async_write_some_at..windows::basic_random_access_handle] Start an asynchronous write at the specified offset. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
  void async_write_some_at(
      boost::uint64_t offset,
      const ConstBufferSequence & buffers,
      WriteHandler handler);


This function is used to asynchronously write data to the random-access handle. The function call always returns immediately.


[heading Parameters]
    

[variablelist
  
[[offset][The offset at which the data will be written.]]

[[buffers][One or more data buffers to be written to the handle. 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.]]

[[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: 
``
   void handler(
     const boost::system::error_code& error, // Result of operation.
     std::size_t bytes_transferred           // Number of bytes written.
   ); 
``
Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using boost::asio::io\_service::post().]]

]

[heading Remarks]
      
The write operation may not transmit all of the data to the peer. Consider using the 
[link boost_asio.reference.async_write_at async_write_at]  function if you need to ensure that all data is written before the asynchronous operation completes.

[heading Example]
  
To write a single data buffer use the 
[link boost_asio.reference.buffer buffer]  function as follows: 

   handle.async_write_some_at(42, boost::asio::buffer(data, size), handler);


See the 
[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. 



[endsect]


[section:basic_random_access_handle windows::basic_random_access_handle::basic_random_access_handle]

[indexterm2 basic_random_access_handle..windows::basic_random_access_handle] Construct a basic_random_access_handle without opening it. 

  ``[link boost_asio.reference.windows__basic_random_access_handle.basic_random_access_handle.overload1 basic_random_access_handle]``(
      boost::asio::io_service & io_service);

Construct a basic_random_access_handle on an existing native handle. 

  ``[link boost_asio.reference.windows__basic_random_access_handle.basic_random_access_handle.overload2 basic_random_access_handle]``(
      boost::asio::io_service & io_service,
      const native_type & native_handle);


[section:overload1 windows::basic_random_access_handle::basic_random_access_handle (1 of 2 overloads)]

Construct a basic_random_access_handle without opening it. 

  basic_random_access_handle(
      boost::asio::io_service & io_service);


This constructor creates a random-access handle without opening it. The handle needs to be opened before data can be written to or or read from it.


[heading Parameters]
    

[variablelist
  
[[io_service][The io\_service object that the random-access handle will use to dispatch handlers for any asynchronous operations performed on the handle. ]]

]



[endsect]



[section:overload2 windows::basic_random_access_handle::basic_random_access_handle (2 of 2 overloads)]

Construct a basic_random_access_handle on an existing native handle. 

  basic_random_access_handle(
      boost::asio::io_service & io_service,
      const native_type & native_handle);


This constructor creates a random-access handle object to hold an existing native handle.


[heading Parameters]
    

[variablelist
  
[[io_service][The io\_service object that the random-access handle will use to dispatch handlers for any asynchronous operations performed on the handle.]]

[[native_handle][The new underlying handle implementation.]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. ]]

]



[endsect]


[endsect]

[section:cancel windows::basic_random_access_handle::cancel]

[indexterm2 cancel..windows::basic_random_access_handle] Cancel all asynchronous operations associated with the handle. 

  void ``[link boost_asio.reference.windows__basic_random_access_handle.cancel.overload1 cancel]``();

  boost::system::error_code ``[link boost_asio.reference.windows__basic_random_access_handle.cancel.overload2 cancel]``(
      boost::system::error_code & ec);


[section:overload1 windows::basic_random_access_handle::cancel (1 of 2 overloads)]


['Inherited from windows::basic_handle.]

Cancel all asynchronous operations associated with the handle. 

  void cancel();


This 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.


[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. ]]

]



[endsect]



[section:overload2 windows::basic_random_access_handle::cancel (2 of 2 overloads)]


['Inherited from windows::basic_handle.]

Cancel all asynchronous operations associated with the handle. 

  boost::system::error_code cancel(
      boost::system::error_code & ec);


This 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.


[heading Parameters]
    

[variablelist
  
[[ec][Set to indicate what error occurred, if any. ]]

]



[endsect]


[endsect]

[section:close windows::basic_random_access_handle::close]

[indexterm2 close..windows::basic_random_access_handle] Close the handle. 

  void ``[link boost_asio.reference.windows__basic_random_access_handle.close.overload1 close]``();

  boost::system::error_code ``[link boost_asio.reference.windows__basic_random_access_handle.close.overload2 close]``(
      boost::system::error_code & ec);


[section:overload1 windows::basic_random_access_handle::close (1 of 2 overloads)]


['Inherited from windows::basic_handle.]

Close the handle. 

  void close();


This function is used to close the handle. Any asynchronous read or write operations will be cancelled immediately, and will complete with the boost::asio::error::operation\_aborted error.


[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. ]]

]



[endsect]



[section:overload2 windows::basic_random_access_handle::close (2 of 2 overloads)]


['Inherited from windows::basic_handle.]

Close the handle. 

  boost::system::error_code close(
      boost::system::error_code & ec);


This function is used to close the handle. Any asynchronous read or write operations will be cancelled immediately, and will complete with the boost::asio::error::operation\_aborted error.


[heading Parameters]
    

[variablelist
  
[[ec][Set to indicate what error occurred, if any. ]]

]



[endsect]


[endsect]


[section:get_io_service windows::basic_random_access_handle::get_io_service]


['Inherited from basic_io_object.]

[indexterm2 get_io_service..windows::basic_random_access_handle] Get the io_service associated with the object. 

  boost::asio::io_service & get_io_service();


This function may be used to obtain the io_service object that the I/O object uses to dispatch handlers for asynchronous operations.


[heading Return Value]
      
A reference to the io_service object that the I/O object will use to dispatch handlers. Ownership is not transferred to the caller. 



[endsect]



[section:implementation windows::basic_random_access_handle::implementation]


['Inherited from basic_io_object.]

[indexterm2 implementation..windows::basic_random_access_handle] The underlying implementation of the I/O object. 

  implementation_type implementation;



[endsect]



[section:implementation_type windows::basic_random_access_handle::implementation_type]


['Inherited from basic_io_object.]

[indexterm2 implementation_type..windows::basic_random_access_handle] The underlying implementation type of I/O object. 

  typedef service_type::implementation_type implementation_type;




[endsect]



[section:io_service windows::basic_random_access_handle::io_service]


['Inherited from basic_io_object.]

[indexterm2 io_service..windows::basic_random_access_handle] (Deprecated: use get_io_service().) Get the io_service associated with the object. 

  boost::asio::io_service & io_service();


This function may be used to obtain the io_service object that the I/O object uses to dispatch handlers for asynchronous operations.


[heading Return Value]
      
A reference to the io_service object that the I/O object will use to dispatch handlers. Ownership is not transferred to the caller. 



[endsect]



[section:is_open windows::basic_random_access_handle::is_open]


['Inherited from windows::basic_handle.]

[indexterm2 is_open..windows::basic_random_access_handle] Determine whether the handle is open. 

  bool is_open() const;



[endsect]


[section:lowest_layer windows::basic_random_access_handle::lowest_layer]

[indexterm2 lowest_layer..windows::basic_random_access_handle] Get a reference to the lowest layer. 

  lowest_layer_type & ``[link boost_asio.reference.windows__basic_random_access_handle.lowest_layer.overload1 lowest_layer]``();

Get a const reference to the lowest layer. 

  const lowest_layer_type & ``[link boost_asio.reference.windows__basic_random_access_handle.lowest_layer.overload2 lowest_layer]``() const;


[section:overload1 windows::basic_random_access_handle::lowest_layer (1 of 2 overloads)]


['Inherited from windows::basic_handle.]

Get a reference to the lowest layer. 

  lowest_layer_type & lowest_layer();


This function returns a reference to the lowest layer in a stack of layers. Since a basic_handle cannot contain any further layers, it simply returns a reference to itself.


[heading Return Value]
      
A reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller. 



[endsect]



[section:overload2 windows::basic_random_access_handle::lowest_layer (2 of 2 overloads)]


['Inherited from windows::basic_handle.]

Get a const reference to the lowest layer. 

  const lowest_layer_type & lowest_layer() const;


This function returns a const reference to the lowest layer in a stack of layers. Since a basic_handle cannot contain any further layers, it simply returns a reference to itself.


[heading Return Value]
      
A const reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller. 



[endsect]


[endsect]


[section:lowest_layer_type windows::basic_random_access_handle::lowest_layer_type]


['Inherited from windows::basic_handle.]

[indexterm2 lowest_layer_type..windows::basic_random_access_handle] A basic_handle is always the lowest layer. 

  typedef basic_handle< RandomAccessHandleService > lowest_layer_type;


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.windows__basic_handle.implementation_type [*implementation_type]]]
    [The underlying implementation type of I/O object. ]
  
  ]

  [

    [[link boost_asio.reference.windows__basic_handle.lowest_layer_type [*lowest_layer_type]]]
    [A basic_handle is always the lowest layer. ]
  
  ]

  [

    [[link boost_asio.reference.windows__basic_handle.native_type [*native_type]]]
    [The native representation of a handle. ]
  
  ]

  [

    [[link boost_asio.reference.windows__basic_handle.service_type [*service_type]]]
    [The type of the service that will be used to provide I/O operations. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.windows__basic_handle.assign [*assign]]]
    [Assign an existing native handle to the handle. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_handle.basic_handle [*basic_handle]]]
    [Construct a basic_handle without opening it. 

     Construct a basic_handle on an existing native handle. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_handle.cancel [*cancel]]]
    [Cancel all asynchronous operations associated with the handle. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_handle.close [*close]]]
    [Close the handle. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_handle.get_io_service [*get_io_service]]]
    [Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_handle.io_service [*io_service]]]
    [(Deprecated: use get_io_service().) Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_handle.is_open [*is_open]]]
    [Determine whether the handle is open. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_handle.lowest_layer [*lowest_layer]]]
    [Get a reference to the lowest layer. 

     Get a const reference to the lowest layer. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_handle.native [*native]]]
    [Get the native handle representation. ]
  ]
  
]

[heading Protected Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.windows__basic_handle._basic_handle [*~basic_handle]]]
    [Protected destructor to prevent deletion through this type. ]
  ]
  
]

[heading Protected Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.windows__basic_handle.implementation [*implementation]]]
    [The underlying implementation of the I/O object. ]
  ]

  [
    [[link boost_asio.reference.windows__basic_handle.service [*service]]]
    [The service associated with the I/O object. ]
  ]

]

The windows::basic_handle class template provides the ability to wrap a Windows handle.


[heading Thread Safety]
  
[*Distinct] [*objects:]  Safe.

[*Shared] [*objects:]  Unsafe. 




[endsect]



[section:native windows::basic_random_access_handle::native]


['Inherited from windows::basic_handle.]

[indexterm2 native..windows::basic_random_access_handle] Get the native handle representation. 

  native_type native();


This function may be used to obtain the underlying representation of the handle. This is intended to allow access to native handle functionality that is not otherwise provided. 


[endsect]



[section:native_type windows::basic_random_access_handle::native_type]

[indexterm2 native_type..windows::basic_random_access_handle] The native representation of a handle. 

  typedef RandomAccessHandleService::native_type native_type;




[endsect]


[section:read_some_at windows::basic_random_access_handle::read_some_at]

[indexterm2 read_some_at..windows::basic_random_access_handle] Read some data from the handle at the specified offset. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t ``[link boost_asio.reference.windows__basic_random_access_handle.read_some_at.overload1 read_some_at]``(
      boost::uint64_t offset,
      const MutableBufferSequence & buffers);

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t ``[link boost_asio.reference.windows__basic_random_access_handle.read_some_at.overload2 read_some_at]``(
      boost::uint64_t offset,
      const MutableBufferSequence & buffers,
      boost::system::error_code & ec);


[section:overload1 windows::basic_random_access_handle::read_some_at (1 of 2 overloads)]

Read some data from the handle at the specified offset. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t read_some_at(
      boost::uint64_t offset,
      const MutableBufferSequence & buffers);


This function is used to read data from the random-access handle. The function call will block until one or more bytes of data has been read successfully, or until an error occurs.


[heading Parameters]
    

[variablelist
  
[[offset][The offset at which the data will be read.]]

[[buffers][One or more buffers into which the data will be read.]]

]

[heading Return Value]
      
The number of bytes read.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. An error code of boost::asio::error::eof indicates that the connection was closed by the peer.]]

]

[heading Remarks]
      
The read\_some operation may not read all of the requested number of bytes. Consider using the 
[link boost_asio.reference.read_at read_at]  function if you need to ensure that the requested amount of data is read before the blocking operation completes.

[heading Example]
  
To read into a single data buffer use the 
[link boost_asio.reference.buffer buffer]  function as follows: 

   handle.read_some_at(42, boost::asio::buffer(data, size));


See the 
[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. 



[endsect]



[section:overload2 windows::basic_random_access_handle::read_some_at (2 of 2 overloads)]

Read some data from the handle at the specified offset. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t read_some_at(
      boost::uint64_t offset,
      const MutableBufferSequence & buffers,
      boost::system::error_code & ec);


This function is used to read data from the random-access handle. The function call will block until one or more bytes of data has been read successfully, or until an error occurs.


[heading Parameters]
    

[variablelist
  
[[offset][The offset at which the data will be read.]]

[[buffers][One or more buffers into which the data will be read.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Return Value]
      
The number of bytes read. Returns 0 if an error occurred.

[heading Remarks]
      
The read\_some operation may not read all of the requested number of bytes. Consider using the 
[link boost_asio.reference.read_at read_at]  function if you need to ensure that the requested amount of data is read before the blocking operation completes. 



[endsect]


[endsect]


[section:service windows::basic_random_access_handle::service]


['Inherited from basic_io_object.]

[indexterm2 service..windows::basic_random_access_handle] The service associated with the I/O object. 

  service_type & service;



[endsect]



[section:service_type windows::basic_random_access_handle::service_type]


['Inherited from basic_io_object.]

[indexterm2 service_type..windows::basic_random_access_handle] The type of the service that will be used to provide I/O operations. 

  typedef RandomAccessHandleService service_type;




[endsect]


[section:write_some_at windows::basic_random_access_handle::write_some_at]

[indexterm2 write_some_at..windows::basic_random_access_handle] Write some data to the handle at the specified offset. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t ``[link boost_asio.reference.windows__basic_random_access_handle.write_some_at.overload1 write_some_at]``(
      boost::uint64_t offset,
      const ConstBufferSequence & buffers);

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t ``[link boost_asio.reference.windows__basic_random_access_handle.write_some_at.overload2 write_some_at]``(
      boost::uint64_t offset,
      const ConstBufferSequence & buffers,
      boost::system::error_code & ec);


[section:overload1 windows::basic_random_access_handle::write_some_at (1 of 2 overloads)]

Write some data to the handle at the specified offset. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t write_some_at(
      boost::uint64_t offset,
      const ConstBufferSequence & buffers);


This function is used to write data to the random-access handle. The function call will block until one or more bytes of the data has been written successfully, or until an error occurs.


[heading Parameters]
    

[variablelist
  
[[offset][The offset at which the data will be written.]]

[[buffers][One or more data buffers to be written to the handle.]]

]

[heading Return Value]
      
The number of bytes written.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. An error code of boost::asio::error::eof indicates that the connection was closed by the peer.]]

]

[heading Remarks]
      
The write\_some\_at operation may not write all of the data. Consider using the 
[link boost_asio.reference.write_at write_at]  function if you need to ensure that all data is written before the blocking operation completes.

[heading Example]
  
To write a single data buffer use the 
[link boost_asio.reference.buffer buffer]  function as follows: 

   handle.write_some_at(42, boost::asio::buffer(data, size));


See the 
[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. 



[endsect]



[section:overload2 windows::basic_random_access_handle::write_some_at (2 of 2 overloads)]

Write some data to the handle at the specified offset. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t write_some_at(
      boost::uint64_t offset,
      const ConstBufferSequence & buffers,
      boost::system::error_code & ec);


This function is used to write data to the random-access handle. The function call will block until one or more bytes of the data has been written successfully, or until an error occurs.


[heading Parameters]
    

[variablelist
  
[[offset][The offset at which the data will be written.]]

[[buffers][One or more data buffers to be written to the handle.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Return Value]
      
The number of bytes written. Returns 0 if an error occurred.

[heading Remarks]
      
The write\_some operation may not transmit all of the data to the peer. Consider using the 
[link boost_asio.reference.write_at write_at]  function if you need to ensure that all data is written before the blocking operation completes. 



[endsect]


[endsect]


[endsect]

[section:windows__basic_stream_handle windows::basic_stream_handle]

Provides stream-oriented handle functionality. 

  template<
      typename ``[link boost_asio.reference.StreamHandleService StreamHandleService]`` = stream_handle_service>
  class basic_stream_handle :
    public windows::basic_handle< StreamHandleService >


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.windows__basic_stream_handle.implementation_type [*implementation_type]]]
    [The underlying implementation type of I/O object. ]
  
  ]

  [

    [[link boost_asio.reference.windows__basic_stream_handle.lowest_layer_type [*lowest_layer_type]]]
    [A basic_handle is always the lowest layer. ]
  
  ]

  [

    [[link boost_asio.reference.windows__basic_stream_handle.native_type [*native_type]]]
    [The native representation of a handle. ]
  
  ]

  [

    [[link boost_asio.reference.windows__basic_stream_handle.service_type [*service_type]]]
    [The type of the service that will be used to provide I/O operations. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.windows__basic_stream_handle.assign [*assign]]]
    [Assign an existing native handle to the handle. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_stream_handle.async_read_some [*async_read_some]]]
    [Start an asynchronous read. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_stream_handle.async_write_some [*async_write_some]]]
    [Start an asynchronous write. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_stream_handle.basic_stream_handle [*basic_stream_handle]]]
    [Construct a basic_stream_handle without opening it. 

     Construct a basic_stream_handle on an existing native handle. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_stream_handle.cancel [*cancel]]]
    [Cancel all asynchronous operations associated with the handle. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_stream_handle.close [*close]]]
    [Close the handle. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_stream_handle.get_io_service [*get_io_service]]]
    [Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_stream_handle.io_service [*io_service]]]
    [(Deprecated: use get_io_service().) Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_stream_handle.is_open [*is_open]]]
    [Determine whether the handle is open. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_stream_handle.lowest_layer [*lowest_layer]]]
    [Get a reference to the lowest layer. 

     Get a const reference to the lowest layer. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_stream_handle.native [*native]]]
    [Get the native handle representation. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_stream_handle.read_some [*read_some]]]
    [Read some data from the handle. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_stream_handle.write_some [*write_some]]]
    [Write some data to the handle. ]
  ]
  
]

[heading Protected Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.windows__basic_stream_handle.implementation [*implementation]]]
    [The underlying implementation of the I/O object. ]
  ]

  [
    [[link boost_asio.reference.windows__basic_stream_handle.service [*service]]]
    [The service associated with the I/O object. ]
  ]

]

The windows::basic_stream_handle class template provides asynchronous and blocking stream-oriented handle functionality.


[heading Thread Safety]
  
[*Distinct] [*objects:]  Safe.

[*Shared] [*objects:]  Unsafe.


[section:assign windows::basic_stream_handle::assign]

[indexterm2 assign..windows::basic_stream_handle] Assign an existing native handle to the handle. 

  void ``[link boost_asio.reference.windows__basic_stream_handle.assign.overload1 assign]``(
      const native_type & native_handle);

  boost::system::error_code ``[link boost_asio.reference.windows__basic_stream_handle.assign.overload2 assign]``(
      const native_type & native_handle,
      boost::system::error_code & ec);


[section:overload1 windows::basic_stream_handle::assign (1 of 2 overloads)]


['Inherited from windows::basic_handle.]

Assign an existing native handle to the handle. 

  void assign(
      const native_type & native_handle);



[endsect]



[section:overload2 windows::basic_stream_handle::assign (2 of 2 overloads)]


['Inherited from windows::basic_handle.]

Assign an existing native handle to the handle. 

  boost::system::error_code assign(
      const native_type & native_handle,
      boost::system::error_code & ec);



[endsect]


[endsect]


[section:async_read_some windows::basic_stream_handle::async_read_some]

[indexterm2 async_read_some..windows::basic_stream_handle] Start an asynchronous read. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
  void async_read_some(
      const MutableBufferSequence & buffers,
      ReadHandler handler);


This function is used to asynchronously read data from the stream handle. The function call always returns immediately.


[heading Parameters]
    

[variablelist
  
[[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.]]

[[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: 
``
   void handler(
     const boost::system::error_code& error, // Result of operation.
     std::size_t bytes_transferred           // Number of bytes read.
   ); 
``
Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using boost::asio::io\_service::post().]]

]

[heading Remarks]
      
The read operation may not read all of the requested number of bytes. Consider using the 
[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.

[heading Example]
  
To read into a single data buffer use the 
[link boost_asio.reference.buffer buffer]  function as follows: 

   handle.async_read_some(boost::asio::buffer(data, size), handler);


See the 
[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. 



[endsect]



[section:async_write_some windows::basic_stream_handle::async_write_some]

[indexterm2 async_write_some..windows::basic_stream_handle] Start an asynchronous write. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
  void async_write_some(
      const ConstBufferSequence & buffers,
      WriteHandler handler);


This function is used to asynchronously write data to the stream handle. The function call always returns immediately.


[heading Parameters]
    

[variablelist
  
[[buffers][One or more data buffers to be written to the handle. 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.]]

[[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: 
``
   void handler(
     const boost::system::error_code& error, // Result of operation.
     std::size_t bytes_transferred           // Number of bytes written.
   ); 
``
Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using boost::asio::io\_service::post().]]

]

[heading Remarks]
      
The write operation may not transmit all of the data to the peer. Consider using the 
[link boost_asio.reference.async_write async_write]  function if you need to ensure that all data is written before the asynchronous operation completes.

[heading Example]
  
To write a single data buffer use the 
[link boost_asio.reference.buffer buffer]  function as follows: 

   handle.async_write_some(boost::asio::buffer(data, size), handler);


See the 
[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. 



[endsect]


[section:basic_stream_handle windows::basic_stream_handle::basic_stream_handle]

[indexterm2 basic_stream_handle..windows::basic_stream_handle] Construct a basic_stream_handle without opening it. 

  ``[link boost_asio.reference.windows__basic_stream_handle.basic_stream_handle.overload1 basic_stream_handle]``(
      boost::asio::io_service & io_service);

Construct a basic_stream_handle on an existing native handle. 

  ``[link boost_asio.reference.windows__basic_stream_handle.basic_stream_handle.overload2 basic_stream_handle]``(
      boost::asio::io_service & io_service,
      const native_type & native_handle);


[section:overload1 windows::basic_stream_handle::basic_stream_handle (1 of 2 overloads)]

Construct a basic_stream_handle without opening it. 

  basic_stream_handle(
      boost::asio::io_service & io_service);


This constructor creates a stream handle without opening it. The handle needs to be opened and then connected or accepted before data can be sent or received on it.


[heading Parameters]
    

[variablelist
  
[[io_service][The io\_service object that the stream handle will use to dispatch handlers for any asynchronous operations performed on the handle. ]]

]



[endsect]



[section:overload2 windows::basic_stream_handle::basic_stream_handle (2 of 2 overloads)]

Construct a basic_stream_handle on an existing native handle. 

  basic_stream_handle(
      boost::asio::io_service & io_service,
      const native_type & native_handle);


This constructor creates a stream handle object to hold an existing native handle.


[heading Parameters]
    

[variablelist
  
[[io_service][The io\_service object that the stream handle will use to dispatch handlers for any asynchronous operations performed on the handle.]]

[[native_handle][The new underlying handle implementation.]]

]

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. ]]

]



[endsect]


[endsect]

[section:cancel windows::basic_stream_handle::cancel]

[indexterm2 cancel..windows::basic_stream_handle] Cancel all asynchronous operations associated with the handle. 

  void ``[link boost_asio.reference.windows__basic_stream_handle.cancel.overload1 cancel]``();

  boost::system::error_code ``[link boost_asio.reference.windows__basic_stream_handle.cancel.overload2 cancel]``(
      boost::system::error_code & ec);


[section:overload1 windows::basic_stream_handle::cancel (1 of 2 overloads)]


['Inherited from windows::basic_handle.]

Cancel all asynchronous operations associated with the handle. 

  void cancel();


This 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.


[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. ]]

]



[endsect]



[section:overload2 windows::basic_stream_handle::cancel (2 of 2 overloads)]


['Inherited from windows::basic_handle.]

Cancel all asynchronous operations associated with the handle. 

  boost::system::error_code cancel(
      boost::system::error_code & ec);


This 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.


[heading Parameters]
    

[variablelist
  
[[ec][Set to indicate what error occurred, if any. ]]

]



[endsect]


[endsect]

[section:close windows::basic_stream_handle::close]

[indexterm2 close..windows::basic_stream_handle] Close the handle. 

  void ``[link boost_asio.reference.windows__basic_stream_handle.close.overload1 close]``();

  boost::system::error_code ``[link boost_asio.reference.windows__basic_stream_handle.close.overload2 close]``(
      boost::system::error_code & ec);


[section:overload1 windows::basic_stream_handle::close (1 of 2 overloads)]


['Inherited from windows::basic_handle.]

Close the handle. 

  void close();


This function is used to close the handle. Any asynchronous read or write operations will be cancelled immediately, and will complete with the boost::asio::error::operation\_aborted error.


[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. ]]

]



[endsect]



[section:overload2 windows::basic_stream_handle::close (2 of 2 overloads)]


['Inherited from windows::basic_handle.]

Close the handle. 

  boost::system::error_code close(
      boost::system::error_code & ec);


This function is used to close the handle. Any asynchronous read or write operations will be cancelled immediately, and will complete with the boost::asio::error::operation\_aborted error.


[heading Parameters]
    

[variablelist
  
[[ec][Set to indicate what error occurred, if any. ]]

]



[endsect]


[endsect]


[section:get_io_service windows::basic_stream_handle::get_io_service]


['Inherited from basic_io_object.]

[indexterm2 get_io_service..windows::basic_stream_handle] Get the io_service associated with the object. 

  boost::asio::io_service & get_io_service();


This function may be used to obtain the io_service object that the I/O object uses to dispatch handlers for asynchronous operations.


[heading Return Value]
      
A reference to the io_service object that the I/O object will use to dispatch handlers. Ownership is not transferred to the caller. 



[endsect]



[section:implementation windows::basic_stream_handle::implementation]


['Inherited from basic_io_object.]

[indexterm2 implementation..windows::basic_stream_handle] The underlying implementation of the I/O object. 

  implementation_type implementation;



[endsect]



[section:implementation_type windows::basic_stream_handle::implementation_type]


['Inherited from basic_io_object.]

[indexterm2 implementation_type..windows::basic_stream_handle] The underlying implementation type of I/O object. 

  typedef service_type::implementation_type implementation_type;




[endsect]



[section:io_service windows::basic_stream_handle::io_service]


['Inherited from basic_io_object.]

[indexterm2 io_service..windows::basic_stream_handle] (Deprecated: use get_io_service().) Get the io_service associated with the object. 

  boost::asio::io_service & io_service();


This function may be used to obtain the io_service object that the I/O object uses to dispatch handlers for asynchronous operations.


[heading Return Value]
      
A reference to the io_service object that the I/O object will use to dispatch handlers. Ownership is not transferred to the caller. 



[endsect]



[section:is_open windows::basic_stream_handle::is_open]


['Inherited from windows::basic_handle.]

[indexterm2 is_open..windows::basic_stream_handle] Determine whether the handle is open. 

  bool is_open() const;



[endsect]


[section:lowest_layer windows::basic_stream_handle::lowest_layer]

[indexterm2 lowest_layer..windows::basic_stream_handle] Get a reference to the lowest layer. 

  lowest_layer_type & ``[link boost_asio.reference.windows__basic_stream_handle.lowest_layer.overload1 lowest_layer]``();

Get a const reference to the lowest layer. 

  const lowest_layer_type & ``[link boost_asio.reference.windows__basic_stream_handle.lowest_layer.overload2 lowest_layer]``() const;


[section:overload1 windows::basic_stream_handle::lowest_layer (1 of 2 overloads)]


['Inherited from windows::basic_handle.]

Get a reference to the lowest layer. 

  lowest_layer_type & lowest_layer();


This function returns a reference to the lowest layer in a stack of layers. Since a basic_handle cannot contain any further layers, it simply returns a reference to itself.


[heading Return Value]
      
A reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller. 



[endsect]



[section:overload2 windows::basic_stream_handle::lowest_layer (2 of 2 overloads)]


['Inherited from windows::basic_handle.]

Get a const reference to the lowest layer. 

  const lowest_layer_type & lowest_layer() const;


This function returns a const reference to the lowest layer in a stack of layers. Since a basic_handle cannot contain any further layers, it simply returns a reference to itself.


[heading Return Value]
      
A const reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller. 



[endsect]


[endsect]


[section:lowest_layer_type windows::basic_stream_handle::lowest_layer_type]


['Inherited from windows::basic_handle.]

[indexterm2 lowest_layer_type..windows::basic_stream_handle] A basic_handle is always the lowest layer. 

  typedef basic_handle< StreamHandleService > lowest_layer_type;


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.windows__basic_handle.implementation_type [*implementation_type]]]
    [The underlying implementation type of I/O object. ]
  
  ]

  [

    [[link boost_asio.reference.windows__basic_handle.lowest_layer_type [*lowest_layer_type]]]
    [A basic_handle is always the lowest layer. ]
  
  ]

  [

    [[link boost_asio.reference.windows__basic_handle.native_type [*native_type]]]
    [The native representation of a handle. ]
  
  ]

  [

    [[link boost_asio.reference.windows__basic_handle.service_type [*service_type]]]
    [The type of the service that will be used to provide I/O operations. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.windows__basic_handle.assign [*assign]]]
    [Assign an existing native handle to the handle. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_handle.basic_handle [*basic_handle]]]
    [Construct a basic_handle without opening it. 

     Construct a basic_handle on an existing native handle. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_handle.cancel [*cancel]]]
    [Cancel all asynchronous operations associated with the handle. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_handle.close [*close]]]
    [Close the handle. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_handle.get_io_service [*get_io_service]]]
    [Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_handle.io_service [*io_service]]]
    [(Deprecated: use get_io_service().) Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_handle.is_open [*is_open]]]
    [Determine whether the handle is open. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_handle.lowest_layer [*lowest_layer]]]
    [Get a reference to the lowest layer. 

     Get a const reference to the lowest layer. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_handle.native [*native]]]
    [Get the native handle representation. ]
  ]
  
]

[heading Protected Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.windows__basic_handle._basic_handle [*~basic_handle]]]
    [Protected destructor to prevent deletion through this type. ]
  ]
  
]

[heading Protected Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.windows__basic_handle.implementation [*implementation]]]
    [The underlying implementation of the I/O object. ]
  ]

  [
    [[link boost_asio.reference.windows__basic_handle.service [*service]]]
    [The service associated with the I/O object. ]
  ]

]

The windows::basic_handle class template provides the ability to wrap a Windows handle.


[heading Thread Safety]
  
[*Distinct] [*objects:]  Safe.

[*Shared] [*objects:]  Unsafe. 




[endsect]



[section:native windows::basic_stream_handle::native]


['Inherited from windows::basic_handle.]

[indexterm2 native..windows::basic_stream_handle] Get the native handle representation. 

  native_type native();


This function may be used to obtain the underlying representation of the handle. This is intended to allow access to native handle functionality that is not otherwise provided. 


[endsect]



[section:native_type windows::basic_stream_handle::native_type]

[indexterm2 native_type..windows::basic_stream_handle] The native representation of a handle. 

  typedef StreamHandleService::native_type native_type;




[endsect]


[section:read_some windows::basic_stream_handle::read_some]

[indexterm2 read_some..windows::basic_stream_handle] Read some data from the handle. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t ``[link boost_asio.reference.windows__basic_stream_handle.read_some.overload1 read_some]``(
      const MutableBufferSequence & buffers);

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t ``[link boost_asio.reference.windows__basic_stream_handle.read_some.overload2 read_some]``(
      const MutableBufferSequence & buffers,
      boost::system::error_code & ec);


[section:overload1 windows::basic_stream_handle::read_some (1 of 2 overloads)]

Read some data from the handle. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t read_some(
      const MutableBufferSequence & buffers);


This function is used to read data from the stream handle. The function call will block until one or more bytes of data has been read successfully, or until an error occurs.


[heading Parameters]
    

[variablelist
  
[[buffers][One or more buffers into which the data will be read.]]

]

[heading Return Value]
      
The number of bytes read.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. An error code of boost::asio::error::eof indicates that the connection was closed by the peer.]]

]

[heading Remarks]
      
The read\_some operation may not read all of the requested number of bytes. Consider using the 
[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.

[heading Example]
  
To read into a single data buffer use the 
[link boost_asio.reference.buffer buffer]  function as follows: 

   handle.read_some(boost::asio::buffer(data, size));


See the 
[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. 



[endsect]



[section:overload2 windows::basic_stream_handle::read_some (2 of 2 overloads)]

Read some data from the handle. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t read_some(
      const MutableBufferSequence & buffers,
      boost::system::error_code & ec);


This function is used to read data from the stream handle. The function call will block until one or more bytes of data has been read successfully, or until an error occurs.


[heading Parameters]
    

[variablelist
  
[[buffers][One or more buffers into which the data will be read.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Return Value]
      
The number of bytes read. Returns 0 if an error occurred.

[heading Remarks]
      
The read\_some operation may not read all of the requested number of bytes. Consider using the 
[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. 



[endsect]


[endsect]


[section:service windows::basic_stream_handle::service]


['Inherited from basic_io_object.]

[indexterm2 service..windows::basic_stream_handle] The service associated with the I/O object. 

  service_type & service;



[endsect]



[section:service_type windows::basic_stream_handle::service_type]


['Inherited from basic_io_object.]

[indexterm2 service_type..windows::basic_stream_handle] The type of the service that will be used to provide I/O operations. 

  typedef StreamHandleService service_type;




[endsect]


[section:write_some windows::basic_stream_handle::write_some]

[indexterm2 write_some..windows::basic_stream_handle] Write some data to the handle. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t ``[link boost_asio.reference.windows__basic_stream_handle.write_some.overload1 write_some]``(
      const ConstBufferSequence & buffers);

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t ``[link boost_asio.reference.windows__basic_stream_handle.write_some.overload2 write_some]``(
      const ConstBufferSequence & buffers,
      boost::system::error_code & ec);


[section:overload1 windows::basic_stream_handle::write_some (1 of 2 overloads)]

Write some data to the handle. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t write_some(
      const ConstBufferSequence & buffers);


This function is used to write data to the stream handle. The function call will block until one or more bytes of the data has been written successfully, or until an error occurs.


[heading Parameters]
    

[variablelist
  
[[buffers][One or more data buffers to be written to the handle.]]

]

[heading Return Value]
      
The number of bytes written.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. An error code of boost::asio::error::eof indicates that the connection was closed by the peer.]]

]

[heading Remarks]
      
The write\_some operation may not transmit all of the data to the peer. Consider using the 
[link boost_asio.reference.write write]  function if you need to ensure that all data is written before the blocking operation completes.

[heading Example]
  
To write a single data buffer use the 
[link boost_asio.reference.buffer buffer]  function as follows: 

   handle.write_some(boost::asio::buffer(data, size));


See the 
[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. 



[endsect]



[section:overload2 windows::basic_stream_handle::write_some (2 of 2 overloads)]

Write some data to the handle. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t write_some(
      const ConstBufferSequence & buffers,
      boost::system::error_code & ec);


This function is used to write data to the stream handle. The function call will block until one or more bytes of the data has been written successfully, or until an error occurs.


[heading Parameters]
    

[variablelist
  
[[buffers][One or more data buffers to be written to the handle.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Return Value]
      
The number of bytes written. Returns 0 if an error occurred.

[heading Remarks]
      
The write\_some operation may not transmit all of the data to the peer. Consider using the 
[link boost_asio.reference.write write]  function if you need to ensure that all data is written before the blocking operation completes. 



[endsect]


[endsect]


[endsect]

[section:windows__overlapped_ptr windows::overlapped_ptr]

Wraps a handler to create an OVERLAPPED object for use with overlapped I/O. 

  class overlapped_ptr :
    noncopyable


[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.windows__overlapped_ptr.complete [*complete]]]
    [Post completion notification for overlapped operation. Releases ownership. ]
  ]
  
  [
    [[link boost_asio.reference.windows__overlapped_ptr.get [*get]]]
    [Get the contained OVERLAPPED object. ]
  ]
  
  [
    [[link boost_asio.reference.windows__overlapped_ptr.overlapped_ptr [*overlapped_ptr]]]
    [Construct an empty overlapped_ptr. 

     Construct an overlapped_ptr to contain the specified handler. ]
  ]
  
  [
    [[link boost_asio.reference.windows__overlapped_ptr.release [*release]]]
    [Release ownership of the OVERLAPPED object. ]
  ]
  
  [
    [[link boost_asio.reference.windows__overlapped_ptr.reset [*reset]]]
    [Reset to empty. 

     Reset to contain the specified handler, freeing any current OVERLAPPED object. ]
  ]
  
  [
    [[link boost_asio.reference.windows__overlapped_ptr._overlapped_ptr [*~overlapped_ptr]]]
    [Destructor automatically frees the OVERLAPPED object unless released. ]
  ]
  
]

A special-purpose smart pointer used to wrap an application handler so that it can be passed as the LPOVERLAPPED argument to overlapped I/O functions.


[heading Thread Safety]
  
[*Distinct] [*objects:]  Safe.

[*Shared] [*objects:]  Unsafe. 



[section:complete windows::overlapped_ptr::complete]

[indexterm2 complete..windows::overlapped_ptr] Post completion notification for overlapped operation. Releases ownership. 

  void complete(
      const boost::system::error_code & ec,
      std::size_t bytes_transferred);



[endsect]


[section:get windows::overlapped_ptr::get]

[indexterm2 get..windows::overlapped_ptr] Get the contained OVERLAPPED object. 

  OVERLAPPED * ``[link boost_asio.reference.windows__overlapped_ptr.get.overload1 get]``();

  const OVERLAPPED * ``[link boost_asio.reference.windows__overlapped_ptr.get.overload2 get]``() const;


[section:overload1 windows::overlapped_ptr::get (1 of 2 overloads)]

Get the contained OVERLAPPED object. 

  OVERLAPPED * get();



[endsect]



[section:overload2 windows::overlapped_ptr::get (2 of 2 overloads)]

Get the contained OVERLAPPED object. 

  const OVERLAPPED * get() const;



[endsect]


[endsect]

[section:overlapped_ptr windows::overlapped_ptr::overlapped_ptr]

[indexterm2 overlapped_ptr..windows::overlapped_ptr] Construct an empty overlapped_ptr. 

  ``[link boost_asio.reference.windows__overlapped_ptr.overlapped_ptr.overload1 overlapped_ptr]``();

Construct an overlapped_ptr to contain the specified handler. 

  template<
      typename ``[link boost_asio.reference.Handler Handler]``>
  ``[link boost_asio.reference.windows__overlapped_ptr.overlapped_ptr.overload2 overlapped_ptr]``(
      boost::asio::io_service & io_service,
      Handler handler);


[section:overload1 windows::overlapped_ptr::overlapped_ptr (1 of 2 overloads)]

Construct an empty overlapped_ptr. 

  overlapped_ptr();



[endsect]



[section:overload2 windows::overlapped_ptr::overlapped_ptr (2 of 2 overloads)]

Construct an overlapped_ptr to contain the specified handler. 

  template<
      typename ``[link boost_asio.reference.Handler Handler]``>
  overlapped_ptr(
      boost::asio::io_service & io_service,
      Handler handler);



[endsect]


[endsect]


[section:release windows::overlapped_ptr::release]

[indexterm2 release..windows::overlapped_ptr] Release ownership of the OVERLAPPED object. 

  OVERLAPPED * release();



[endsect]


[section:reset windows::overlapped_ptr::reset]

[indexterm2 reset..windows::overlapped_ptr] Reset to empty. 

  void ``[link boost_asio.reference.windows__overlapped_ptr.reset.overload1 reset]``();

Reset to contain the specified handler, freeing any current OVERLAPPED object. 

  template<
      typename ``[link boost_asio.reference.Handler Handler]``>
  void ``[link boost_asio.reference.windows__overlapped_ptr.reset.overload2 reset]``(
      boost::asio::io_service & io_service,
      Handler handler);


[section:overload1 windows::overlapped_ptr::reset (1 of 2 overloads)]

Reset to empty. 

  void reset();



[endsect]



[section:overload2 windows::overlapped_ptr::reset (2 of 2 overloads)]

Reset to contain the specified handler, freeing any current OVERLAPPED object. 

  template<
      typename ``[link boost_asio.reference.Handler Handler]``>
  void reset(
      boost::asio::io_service & io_service,
      Handler handler);



[endsect]


[endsect]


[section:_overlapped_ptr windows::overlapped_ptr::~overlapped_ptr]

[indexterm2 ~overlapped_ptr..windows::overlapped_ptr] Destructor automatically frees the OVERLAPPED object unless released. 

  ~overlapped_ptr();



[endsect]



[endsect]


[section:windows__random_access_handle windows::random_access_handle]

[indexterm1 windows::random_access_handle] Typedef for the typical usage of a random-access handle. 

  typedef basic_random_access_handle random_access_handle;


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.windows__basic_random_access_handle.implementation_type [*implementation_type]]]
    [The underlying implementation type of I/O object. ]
  
  ]

  [

    [[link boost_asio.reference.windows__basic_random_access_handle.lowest_layer_type [*lowest_layer_type]]]
    [A basic_handle is always the lowest layer. ]
  
  ]

  [

    [[link boost_asio.reference.windows__basic_random_access_handle.native_type [*native_type]]]
    [The native representation of a handle. ]
  
  ]

  [

    [[link boost_asio.reference.windows__basic_random_access_handle.service_type [*service_type]]]
    [The type of the service that will be used to provide I/O operations. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.windows__basic_random_access_handle.assign [*assign]]]
    [Assign an existing native handle to the handle. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_random_access_handle.async_read_some_at [*async_read_some_at]]]
    [Start an asynchronous read at the specified offset. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_random_access_handle.async_write_some_at [*async_write_some_at]]]
    [Start an asynchronous write at the specified offset. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_random_access_handle.basic_random_access_handle [*basic_random_access_handle]]]
    [Construct a basic_random_access_handle without opening it. 

     Construct a basic_random_access_handle on an existing native handle. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_random_access_handle.cancel [*cancel]]]
    [Cancel all asynchronous operations associated with the handle. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_random_access_handle.close [*close]]]
    [Close the handle. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_random_access_handle.get_io_service [*get_io_service]]]
    [Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_random_access_handle.io_service [*io_service]]]
    [(Deprecated: use get_io_service().) Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_random_access_handle.is_open [*is_open]]]
    [Determine whether the handle is open. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_random_access_handle.lowest_layer [*lowest_layer]]]
    [Get a reference to the lowest layer. 

     Get a const reference to the lowest layer. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_random_access_handle.native [*native]]]
    [Get the native handle representation. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_random_access_handle.read_some_at [*read_some_at]]]
    [Read some data from the handle at the specified offset. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_random_access_handle.write_some_at [*write_some_at]]]
    [Write some data to the handle at the specified offset. ]
  ]
  
]

[heading Protected Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.windows__basic_random_access_handle.implementation [*implementation]]]
    [The underlying implementation of the I/O object. ]
  ]

  [
    [[link boost_asio.reference.windows__basic_random_access_handle.service [*service]]]
    [The service associated with the I/O object. ]
  ]

]

The windows::basic_random_access_handle class template provides asynchronous and blocking random-access handle functionality.


[heading Thread Safety]
  
[*Distinct] [*objects:]  Safe.

[*Shared] [*objects:]  Unsafe. 




[endsect]


[section:windows__random_access_handle_service windows::random_access_handle_service]

Default service implementation for a random-access handle. 

  class random_access_handle_service :
    public io_service::service


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.windows__random_access_handle_service.implementation_type [*implementation_type]]]
    [The type of a random-access handle implementation. ]
  
  ]

  [

    [[link boost_asio.reference.windows__random_access_handle_service.native_type [*native_type]]]
    [The native handle type. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.windows__random_access_handle_service.assign [*assign]]]
    [Assign an existing native handle to a random-access handle. ]
  ]
  
  [
    [[link boost_asio.reference.windows__random_access_handle_service.async_read_some_at [*async_read_some_at]]]
    [Start an asynchronous read at the specified offset. ]
  ]
  
  [
    [[link boost_asio.reference.windows__random_access_handle_service.async_write_some_at [*async_write_some_at]]]
    [Start an asynchronous write at the specified offset. ]
  ]
  
  [
    [[link boost_asio.reference.windows__random_access_handle_service.cancel [*cancel]]]
    [Cancel all asynchronous operations associated with the handle. ]
  ]
  
  [
    [[link boost_asio.reference.windows__random_access_handle_service.close [*close]]]
    [Close a random-access handle implementation. ]
  ]
  
  [
    [[link boost_asio.reference.windows__random_access_handle_service.construct [*construct]]]
    [Construct a new random-access handle implementation. ]
  ]
  
  [
    [[link boost_asio.reference.windows__random_access_handle_service.destroy [*destroy]]]
    [Destroy a random-access handle implementation. ]
  ]
  
  [
    [[link boost_asio.reference.windows__random_access_handle_service.get_io_service [*get_io_service]]]
    [Get the io_service object that owns the service. ]
  ]
  
  [
    [[link boost_asio.reference.windows__random_access_handle_service.io_service [*io_service]]]
    [(Deprecated: use get_io_service().) Get the io_service object that owns the service. ]
  ]
  
  [
    [[link boost_asio.reference.windows__random_access_handle_service.is_open [*is_open]]]
    [Determine whether the handle is open. ]
  ]
  
  [
    [[link boost_asio.reference.windows__random_access_handle_service.native [*native]]]
    [Get the native handle implementation. ]
  ]
  
  [
    [[link boost_asio.reference.windows__random_access_handle_service.random_access_handle_service [*random_access_handle_service]]]
    [Construct a new random-access handle service for the specified io_service. ]
  ]
  
  [
    [[link boost_asio.reference.windows__random_access_handle_service.read_some_at [*read_some_at]]]
    [Read some data from the specified offset. ]
  ]
  
  [
    [[link boost_asio.reference.windows__random_access_handle_service.shutdown_service [*shutdown_service]]]
    [Destroy all user-defined handler objects owned by the service. ]
  ]
  
  [
    [[link boost_asio.reference.windows__random_access_handle_service.write_some_at [*write_some_at]]]
    [Write the given data at the specified offset. ]
  ]
  
]

[heading Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.windows__random_access_handle_service.id [*id]]]
    [The unique service identifier. ]
  ]

]


[section:assign windows::random_access_handle_service::assign]

[indexterm2 assign..windows::random_access_handle_service] Assign an existing native handle to a random-access handle. 

  boost::system::error_code assign(
      implementation_type & impl,
      const native_type & native_handle,
      boost::system::error_code & ec);



[endsect]



[section:async_read_some_at windows::random_access_handle_service::async_read_some_at]

[indexterm2 async_read_some_at..windows::random_access_handle_service] Start an asynchronous read at the specified offset. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
  void async_read_some_at(
      implementation_type & impl,
      boost::uint64_t offset,
      const MutableBufferSequence & buffers,
      ReadHandler handler);



[endsect]



[section:async_write_some_at windows::random_access_handle_service::async_write_some_at]

[indexterm2 async_write_some_at..windows::random_access_handle_service] Start an asynchronous write at the specified offset. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
  void async_write_some_at(
      implementation_type & impl,
      boost::uint64_t offset,
      const ConstBufferSequence & buffers,
      WriteHandler handler);



[endsect]



[section:cancel windows::random_access_handle_service::cancel]

[indexterm2 cancel..windows::random_access_handle_service] Cancel all asynchronous operations associated with the handle. 

  boost::system::error_code cancel(
      implementation_type & impl,
      boost::system::error_code & ec);



[endsect]



[section:close windows::random_access_handle_service::close]

[indexterm2 close..windows::random_access_handle_service] Close a random-access handle implementation. 

  boost::system::error_code close(
      implementation_type & impl,
      boost::system::error_code & ec);



[endsect]



[section:construct windows::random_access_handle_service::construct]

[indexterm2 construct..windows::random_access_handle_service] Construct a new random-access handle implementation. 

  void construct(
      implementation_type & impl);



[endsect]



[section:destroy windows::random_access_handle_service::destroy]

[indexterm2 destroy..windows::random_access_handle_service] Destroy a random-access handle implementation. 

  void destroy(
      implementation_type & impl);



[endsect]



[section:get_io_service windows::random_access_handle_service::get_io_service]


['Inherited from io_service.]

[indexterm2 get_io_service..windows::random_access_handle_service] Get the io_service object that owns the service. 

  boost::asio::io_service & get_io_service();



[endsect]



[section:id windows::random_access_handle_service::id]

[indexterm2 id..windows::random_access_handle_service] The unique service identifier. 

  static boost::asio::io_service::id id;



[endsect]



[section:implementation_type windows::random_access_handle_service::implementation_type]

[indexterm2 implementation_type..windows::random_access_handle_service] The type of a random-access handle implementation. 

  typedef implementation_defined implementation_type;




[endsect]



[section:io_service windows::random_access_handle_service::io_service]


['Inherited from io_service.]

[indexterm2 io_service..windows::random_access_handle_service] (Deprecated: use get_io_service().) Get the io_service object that owns the service. 

  boost::asio::io_service & io_service();



[endsect]



[section:is_open windows::random_access_handle_service::is_open]

[indexterm2 is_open..windows::random_access_handle_service] Determine whether the handle is open. 

  bool is_open(
      const implementation_type & impl) const;



[endsect]



[section:native windows::random_access_handle_service::native]

[indexterm2 native..windows::random_access_handle_service] Get the native handle implementation. 

  native_type native(
      implementation_type & impl);



[endsect]



[section:native_type windows::random_access_handle_service::native_type]

[indexterm2 native_type..windows::random_access_handle_service] The native handle type. 

  typedef implementation_defined native_type;




[endsect]



[section:random_access_handle_service windows::random_access_handle_service::random_access_handle_service]

[indexterm2 random_access_handle_service..windows::random_access_handle_service] Construct a new random-access handle service for the specified io_service. 

  random_access_handle_service(
      boost::asio::io_service & io_service);



[endsect]



[section:read_some_at windows::random_access_handle_service::read_some_at]

[indexterm2 read_some_at..windows::random_access_handle_service] Read some data from the specified offset. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t read_some_at(
      implementation_type & impl,
      boost::uint64_t offset,
      const MutableBufferSequence & buffers,
      boost::system::error_code & ec);



[endsect]



[section:shutdown_service windows::random_access_handle_service::shutdown_service]

[indexterm2 shutdown_service..windows::random_access_handle_service] Destroy all user-defined handler objects owned by the service. 

  void shutdown_service();



[endsect]



[section:write_some_at windows::random_access_handle_service::write_some_at]

[indexterm2 write_some_at..windows::random_access_handle_service] Write the given data at the specified offset. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t write_some_at(
      implementation_type & impl,
      boost::uint64_t offset,
      const ConstBufferSequence & buffers,
      boost::system::error_code & ec);



[endsect]



[endsect]


[section:windows__stream_handle windows::stream_handle]

[indexterm1 windows::stream_handle] Typedef for the typical usage of a stream-oriented handle. 

  typedef basic_stream_handle stream_handle;


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.windows__basic_stream_handle.implementation_type [*implementation_type]]]
    [The underlying implementation type of I/O object. ]
  
  ]

  [

    [[link boost_asio.reference.windows__basic_stream_handle.lowest_layer_type [*lowest_layer_type]]]
    [A basic_handle is always the lowest layer. ]
  
  ]

  [

    [[link boost_asio.reference.windows__basic_stream_handle.native_type [*native_type]]]
    [The native representation of a handle. ]
  
  ]

  [

    [[link boost_asio.reference.windows__basic_stream_handle.service_type [*service_type]]]
    [The type of the service that will be used to provide I/O operations. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.windows__basic_stream_handle.assign [*assign]]]
    [Assign an existing native handle to the handle. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_stream_handle.async_read_some [*async_read_some]]]
    [Start an asynchronous read. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_stream_handle.async_write_some [*async_write_some]]]
    [Start an asynchronous write. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_stream_handle.basic_stream_handle [*basic_stream_handle]]]
    [Construct a basic_stream_handle without opening it. 

     Construct a basic_stream_handle on an existing native handle. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_stream_handle.cancel [*cancel]]]
    [Cancel all asynchronous operations associated with the handle. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_stream_handle.close [*close]]]
    [Close the handle. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_stream_handle.get_io_service [*get_io_service]]]
    [Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_stream_handle.io_service [*io_service]]]
    [(Deprecated: use get_io_service().) Get the io_service associated with the object. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_stream_handle.is_open [*is_open]]]
    [Determine whether the handle is open. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_stream_handle.lowest_layer [*lowest_layer]]]
    [Get a reference to the lowest layer. 

     Get a const reference to the lowest layer. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_stream_handle.native [*native]]]
    [Get the native handle representation. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_stream_handle.read_some [*read_some]]]
    [Read some data from the handle. ]
  ]
  
  [
    [[link boost_asio.reference.windows__basic_stream_handle.write_some [*write_some]]]
    [Write some data to the handle. ]
  ]
  
]

[heading Protected Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.windows__basic_stream_handle.implementation [*implementation]]]
    [The underlying implementation of the I/O object. ]
  ]

  [
    [[link boost_asio.reference.windows__basic_stream_handle.service [*service]]]
    [The service associated with the I/O object. ]
  ]

]

The windows::basic_stream_handle class template provides asynchronous and blocking stream-oriented handle functionality.


[heading Thread Safety]
  
[*Distinct] [*objects:]  Safe.

[*Shared] [*objects:]  Unsafe.




[endsect]


[section:windows__stream_handle_service windows::stream_handle_service]

Default service implementation for a stream handle. 

  class stream_handle_service :
    public io_service::service


[heading Types]
[table
  [[Name][Description]]

  [

    [[link boost_asio.reference.windows__stream_handle_service.implementation_type [*implementation_type]]]
    [The type of a stream handle implementation. ]
  
  ]

  [

    [[link boost_asio.reference.windows__stream_handle_service.native_type [*native_type]]]
    [The native handle type. ]
  
  ]

]

[heading Member Functions]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.windows__stream_handle_service.assign [*assign]]]
    [Assign an existing native handle to a stream handle. ]
  ]
  
  [
    [[link boost_asio.reference.windows__stream_handle_service.async_read_some [*async_read_some]]]
    [Start an asynchronous read. ]
  ]
  
  [
    [[link boost_asio.reference.windows__stream_handle_service.async_write_some [*async_write_some]]]
    [Start an asynchronous write. ]
  ]
  
  [
    [[link boost_asio.reference.windows__stream_handle_service.cancel [*cancel]]]
    [Cancel all asynchronous operations associated with the handle. ]
  ]
  
  [
    [[link boost_asio.reference.windows__stream_handle_service.close [*close]]]
    [Close a stream handle implementation. ]
  ]
  
  [
    [[link boost_asio.reference.windows__stream_handle_service.construct [*construct]]]
    [Construct a new stream handle implementation. ]
  ]
  
  [
    [[link boost_asio.reference.windows__stream_handle_service.destroy [*destroy]]]
    [Destroy a stream handle implementation. ]
  ]
  
  [
    [[link boost_asio.reference.windows__stream_handle_service.get_io_service [*get_io_service]]]
    [Get the io_service object that owns the service. ]
  ]
  
  [
    [[link boost_asio.reference.windows__stream_handle_service.io_service [*io_service]]]
    [(Deprecated: use get_io_service().) Get the io_service object that owns the service. ]
  ]
  
  [
    [[link boost_asio.reference.windows__stream_handle_service.is_open [*is_open]]]
    [Determine whether the handle is open. ]
  ]
  
  [
    [[link boost_asio.reference.windows__stream_handle_service.native [*native]]]
    [Get the native handle implementation. ]
  ]
  
  [
    [[link boost_asio.reference.windows__stream_handle_service.read_some [*read_some]]]
    [Read some data from the stream. ]
  ]
  
  [
    [[link boost_asio.reference.windows__stream_handle_service.shutdown_service [*shutdown_service]]]
    [Destroy all user-defined handler objects owned by the service. ]
  ]
  
  [
    [[link boost_asio.reference.windows__stream_handle_service.stream_handle_service [*stream_handle_service]]]
    [Construct a new stream handle service for the specified io_service. ]
  ]
  
  [
    [[link boost_asio.reference.windows__stream_handle_service.write_some [*write_some]]]
    [Write the given data to the stream. ]
  ]
  
]

[heading Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.windows__stream_handle_service.id [*id]]]
    [The unique service identifier. ]
  ]

]


[section:assign windows::stream_handle_service::assign]

[indexterm2 assign..windows::stream_handle_service] Assign an existing native handle to a stream handle. 

  boost::system::error_code assign(
      implementation_type & impl,
      const native_type & native_handle,
      boost::system::error_code & ec);



[endsect]



[section:async_read_some windows::stream_handle_service::async_read_some]

[indexterm2 async_read_some..windows::stream_handle_service] Start an asynchronous read. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
  void async_read_some(
      implementation_type & impl,
      const MutableBufferSequence & buffers,
      ReadHandler handler);



[endsect]



[section:async_write_some windows::stream_handle_service::async_write_some]

[indexterm2 async_write_some..windows::stream_handle_service] Start an asynchronous write. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
  void async_write_some(
      implementation_type & impl,
      const ConstBufferSequence & buffers,
      WriteHandler handler);



[endsect]



[section:cancel windows::stream_handle_service::cancel]

[indexterm2 cancel..windows::stream_handle_service] Cancel all asynchronous operations associated with the handle. 

  boost::system::error_code cancel(
      implementation_type & impl,
      boost::system::error_code & ec);



[endsect]



[section:close windows::stream_handle_service::close]

[indexterm2 close..windows::stream_handle_service] Close a stream handle implementation. 

  boost::system::error_code close(
      implementation_type & impl,
      boost::system::error_code & ec);



[endsect]



[section:construct windows::stream_handle_service::construct]

[indexterm2 construct..windows::stream_handle_service] Construct a new stream handle implementation. 

  void construct(
      implementation_type & impl);



[endsect]



[section:destroy windows::stream_handle_service::destroy]

[indexterm2 destroy..windows::stream_handle_service] Destroy a stream handle implementation. 

  void destroy(
      implementation_type & impl);



[endsect]



[section:get_io_service windows::stream_handle_service::get_io_service]


['Inherited from io_service.]

[indexterm2 get_io_service..windows::stream_handle_service] Get the io_service object that owns the service. 

  boost::asio::io_service & get_io_service();



[endsect]



[section:id windows::stream_handle_service::id]

[indexterm2 id..windows::stream_handle_service] The unique service identifier. 

  static boost::asio::io_service::id id;



[endsect]



[section:implementation_type windows::stream_handle_service::implementation_type]

[indexterm2 implementation_type..windows::stream_handle_service] The type of a stream handle implementation. 

  typedef implementation_defined implementation_type;




[endsect]



[section:io_service windows::stream_handle_service::io_service]


['Inherited from io_service.]

[indexterm2 io_service..windows::stream_handle_service] (Deprecated: use get_io_service().) Get the io_service object that owns the service. 

  boost::asio::io_service & io_service();



[endsect]



[section:is_open windows::stream_handle_service::is_open]

[indexterm2 is_open..windows::stream_handle_service] Determine whether the handle is open. 

  bool is_open(
      const implementation_type & impl) const;



[endsect]



[section:native windows::stream_handle_service::native]

[indexterm2 native..windows::stream_handle_service] Get the native handle implementation. 

  native_type native(
      implementation_type & impl);



[endsect]



[section:native_type windows::stream_handle_service::native_type]

[indexterm2 native_type..windows::stream_handle_service] The native handle type. 

  typedef implementation_defined native_type;




[endsect]



[section:read_some windows::stream_handle_service::read_some]

[indexterm2 read_some..windows::stream_handle_service] Read some data from the stream. 

  template<
      typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``>
  std::size_t read_some(
      implementation_type & impl,
      const MutableBufferSequence & buffers,
      boost::system::error_code & ec);



[endsect]



[section:shutdown_service windows::stream_handle_service::shutdown_service]

[indexterm2 shutdown_service..windows::stream_handle_service] Destroy all user-defined handler objects owned by the service. 

  void shutdown_service();



[endsect]



[section:stream_handle_service windows::stream_handle_service::stream_handle_service]

[indexterm2 stream_handle_service..windows::stream_handle_service] Construct a new stream handle service for the specified io_service. 

  stream_handle_service(
      boost::asio::io_service & io_service);



[endsect]



[section:write_some windows::stream_handle_service::write_some]

[indexterm2 write_some..windows::stream_handle_service] Write the given data to the stream. 

  template<
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t write_some(
      implementation_type & impl,
      const ConstBufferSequence & buffers,
      boost::system::error_code & ec);



[endsect]



[endsect]

[section:write write]

[indexterm1 write] Write a certain amount of data to a stream before returning. 
      
  template<
      typename ``[link boost_asio.reference.SyncWriteStream SyncWriteStream]``,
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t ``[link boost_asio.reference.write.overload1 write]``(
      SyncWriteStream & s,
      const ConstBufferSequence & buffers);

  template<
      typename ``[link boost_asio.reference.SyncWriteStream SyncWriteStream]``,
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
      typename CompletionCondition>
  std::size_t ``[link boost_asio.reference.write.overload2 write]``(
      SyncWriteStream & s,
      const ConstBufferSequence & buffers,
      CompletionCondition completion_condition);

  template<
      typename ``[link boost_asio.reference.SyncWriteStream SyncWriteStream]``,
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
      typename CompletionCondition>
  std::size_t ``[link boost_asio.reference.write.overload3 write]``(
      SyncWriteStream & s,
      const ConstBufferSequence & buffers,
      CompletionCondition completion_condition,
      boost::system::error_code & ec);

  template<
      typename ``[link boost_asio.reference.SyncWriteStream SyncWriteStream]``,
      typename Allocator>
  std::size_t ``[link boost_asio.reference.write.overload4 write]``(
      SyncWriteStream & s,
      basic_streambuf< Allocator > & b);

  template<
      typename ``[link boost_asio.reference.SyncWriteStream SyncWriteStream]``,
      typename Allocator,
      typename CompletionCondition>
  std::size_t ``[link boost_asio.reference.write.overload5 write]``(
      SyncWriteStream & s,
      basic_streambuf< Allocator > & b,
      CompletionCondition completion_condition);

  template<
      typename ``[link boost_asio.reference.SyncWriteStream SyncWriteStream]``,
      typename Allocator,
      typename CompletionCondition>
  std::size_t ``[link boost_asio.reference.write.overload6 write]``(
      SyncWriteStream & s,
      basic_streambuf< Allocator > & b,
      CompletionCondition completion_condition,
      boost::system::error_code & ec);


[section:overload1 write (1 of 6 overloads)]

Write all of the supplied data to a stream before returning. 

  template<
      typename ``[link boost_asio.reference.SyncWriteStream SyncWriteStream]``,
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t write(
      SyncWriteStream & s,
      const ConstBufferSequence & buffers);


This function is used to write a certain number of bytes of data to a stream. The call will block until one of the following conditions is true:


* All of the data in the supplied buffers has been written. That is, the bytes transferred is equal to the sum of the buffer sizes.

* An error occurred.

This operation is implemented in terms of zero or more calls to the stream's write\_some function.


[heading Parameters]
    

[variablelist
  
[[s][The stream to which the data is to be written. The type must support the SyncWriteStream concept.]]

[[buffers][One or more buffers containing the data to be written. The sum of the buffer sizes indicates the maximum number of bytes to write to the stream.]]

]

[heading Return Value]
      
The number of bytes transferred.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Example]
  
To write a single data buffer use the 
[link boost_asio.reference.buffer buffer]  function as follows: 

   boost::asio::write(s, boost::asio::buffer(data, size)); 


See the 
[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.

[heading Remarks]
      
This overload is equivalent to calling: 

   boost::asio::write(
       s, buffers,
       boost::asio::transfer_all()); 






[endsect]



[section:overload2 write (2 of 6 overloads)]

Write a certain amount of data to a stream before returning. 

  template<
      typename ``[link boost_asio.reference.SyncWriteStream SyncWriteStream]``,
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
      typename CompletionCondition>
  std::size_t write(
      SyncWriteStream & s,
      const ConstBufferSequence & buffers,
      CompletionCondition completion_condition);


This function is used to write a certain number of bytes of data to a stream. The call will block until one of the following conditions is true:


* All of the data in the supplied buffers has been written. That is, the bytes transferred is equal to the sum of the buffer sizes.

* The completion_condition function object returns 0.

This operation is implemented in terms of zero or more calls to the stream's write\_some function.


[heading Parameters]
    

[variablelist
  
[[s][The stream to which the data is to be written. The type must support the SyncWriteStream concept.]]

[[buffers][One or more buffers containing the data to be written. The sum of the buffer sizes indicates the maximum number of bytes to write to the stream.]]

[[completion_condition][The function object to be called to determine whether the write operation is complete. The signature of the function object must be: 
``
   std::size_t completion_condition(
     // Result of latest write_some operation.
     const boost::system::error_code& error,

     // Number of bytes transferred so far.
     std::size_t bytes_transferred
   ); 
``
A return value of 0 indicates that the write operation is complete. A non-zero return value indicates the maximum number of bytes to be written on the next call to the stream's write\_some function.]]

]

[heading Return Value]
      
The number of bytes transferred.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Example]
  
To write a single data buffer use the 
[link boost_asio.reference.buffer buffer]  function as follows: 

   boost::asio::write(s, boost::asio::buffer(data, size),
       boost::asio::transfer_at_least(32)); 


See the 
[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. 



[endsect]



[section:overload3 write (3 of 6 overloads)]

Write a certain amount of data to a stream before returning. 

  template<
      typename ``[link boost_asio.reference.SyncWriteStream SyncWriteStream]``,
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
      typename CompletionCondition>
  std::size_t write(
      SyncWriteStream & s,
      const ConstBufferSequence & buffers,
      CompletionCondition completion_condition,
      boost::system::error_code & ec);


This function is used to write a certain number of bytes of data to a stream. The call will block until one of the following conditions is true:


* All of the data in the supplied buffers has been written. That is, the bytes transferred is equal to the sum of the buffer sizes.

* The completion_condition function object returns 0.

This operation is implemented in terms of zero or more calls to the stream's write\_some function.


[heading Parameters]
    

[variablelist
  
[[s][The stream to which the data is to be written. The type must support the SyncWriteStream concept.]]

[[buffers][One or more buffers containing the data to be written. The sum of the buffer sizes indicates the maximum number of bytes to write to the stream.]]

[[completion_condition][The function object to be called to determine whether the write operation is complete. The signature of the function object must be: 
``
   std::size_t completion_condition(
     // Result of latest write_some operation.
     const boost::system::error_code& error,

     // Number of bytes transferred so far.
     std::size_t bytes_transferred
   ); 
``
A return value of 0 indicates that the write operation is complete. A non-zero return value indicates the maximum number of bytes to be written on the next call to the stream's write\_some function.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Return Value]
      
The number of bytes written. If an error occurs, returns the total number of bytes successfully transferred prior to the error. 



[endsect]



[section:overload4 write (4 of 6 overloads)]

Write all of the supplied data to a stream before returning. 

  template<
      typename ``[link boost_asio.reference.SyncWriteStream SyncWriteStream]``,
      typename Allocator>
  std::size_t write(
      SyncWriteStream & s,
      basic_streambuf< Allocator > & b);


This function is used to write a certain number of bytes of data to a stream. The call will block until one of the following conditions is true:


* All of the data in the supplied basic_streambuf has been written.

* An error occurred.

This operation is implemented in terms of zero or more calls to the stream's write\_some function.


[heading Parameters]
    

[variablelist
  
[[s][The stream to which the data is to be written. The type must support the SyncWriteStream concept.]]

[[b][The basic\_streambuf object from which data will be written.]]

]

[heading Return Value]
      
The number of bytes transferred.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Remarks]
      
This overload is equivalent to calling: 

   boost::asio::write(
       s, b,
       boost::asio::transfer_all()); 






[endsect]



[section:overload5 write (5 of 6 overloads)]

Write a certain amount of data to a stream before returning. 

  template<
      typename ``[link boost_asio.reference.SyncWriteStream SyncWriteStream]``,
      typename Allocator,
      typename CompletionCondition>
  std::size_t write(
      SyncWriteStream & s,
      basic_streambuf< Allocator > & b,
      CompletionCondition completion_condition);


This function is used to write a certain number of bytes of data to a stream. The call will block until one of the following conditions is true:


* All of the data in the supplied basic_streambuf has been written.

* The completion_condition function object returns 0.

This operation is implemented in terms of zero or more calls to the stream's write\_some function.


[heading Parameters]
    

[variablelist
  
[[s][The stream to which the data is to be written. The type must support the SyncWriteStream concept.]]

[[b][The basic\_streambuf object from which data will be written.]]

[[completion_condition][The function object to be called to determine whether the write operation is complete. The signature of the function object must be: 
``
   std::size_t completion_condition(
     // Result of latest write_some operation.
     const boost::system::error_code& error,

     // Number of bytes transferred so far.
     std::size_t bytes_transferred
   ); 
``
A return value of 0 indicates that the write operation is complete. A non-zero return value indicates the maximum number of bytes to be written on the next call to the stream's write\_some function.]]

]

[heading Return Value]
      
The number of bytes transferred.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. ]]

]



[endsect]



[section:overload6 write (6 of 6 overloads)]

Write a certain amount of data to a stream before returning. 

  template<
      typename ``[link boost_asio.reference.SyncWriteStream SyncWriteStream]``,
      typename Allocator,
      typename CompletionCondition>
  std::size_t write(
      SyncWriteStream & s,
      basic_streambuf< Allocator > & b,
      CompletionCondition completion_condition,
      boost::system::error_code & ec);


This function is used to write a certain number of bytes of data to a stream. The call will block until one of the following conditions is true:


* All of the data in the supplied basic_streambuf has been written.

* The completion_condition function object returns 0.

This operation is implemented in terms of zero or more calls to the stream's write\_some function.


[heading Parameters]
    

[variablelist
  
[[s][The stream to which the data is to be written. The type must support the SyncWriteStream concept.]]

[[b][The basic\_streambuf object from which data will be written.]]

[[completion_condition][The function object to be called to determine whether the write operation is complete. The signature of the function object must be: 
``
   std::size_t completion_condition(
     // Result of latest write_some operation.
     const boost::system::error_code& error,

     // Number of bytes transferred so far.
     std::size_t bytes_transferred
   ); 
``
A return value of 0 indicates that the write operation is complete. A non-zero return value indicates the maximum number of bytes to be written on the next call to the stream's write\_some function.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Return Value]
      
The number of bytes written. If an error occurs, returns the total number of bytes successfully transferred prior to the error. 



[endsect]


[endsect]

[section:write_at write_at]

[indexterm1 write_at] Write a certain amount of data at a specified offset before returning. 
      
  template<
      typename ``[link boost_asio.reference.SyncRandomAccessWriteDevice SyncRandomAccessWriteDevice]``,
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t ``[link boost_asio.reference.write_at.overload1 write_at]``(
      SyncRandomAccessWriteDevice & d,
      boost::uint64_t offset,
      const ConstBufferSequence & buffers);

  template<
      typename ``[link boost_asio.reference.SyncRandomAccessWriteDevice SyncRandomAccessWriteDevice]``,
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
      typename CompletionCondition>
  std::size_t ``[link boost_asio.reference.write_at.overload2 write_at]``(
      SyncRandomAccessWriteDevice & d,
      boost::uint64_t offset,
      const ConstBufferSequence & buffers,
      CompletionCondition completion_condition);

  template<
      typename ``[link boost_asio.reference.SyncRandomAccessWriteDevice SyncRandomAccessWriteDevice]``,
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
      typename CompletionCondition>
  std::size_t ``[link boost_asio.reference.write_at.overload3 write_at]``(
      SyncRandomAccessWriteDevice & d,
      boost::uint64_t offset,
      const ConstBufferSequence & buffers,
      CompletionCondition completion_condition,
      boost::system::error_code & ec);

  template<
      typename ``[link boost_asio.reference.SyncRandomAccessWriteDevice SyncRandomAccessWriteDevice]``,
      typename Allocator>
  std::size_t ``[link boost_asio.reference.write_at.overload4 write_at]``(
      SyncRandomAccessWriteDevice & d,
      boost::uint64_t offset,
      basic_streambuf< Allocator > & b);

  template<
      typename ``[link boost_asio.reference.SyncRandomAccessWriteDevice SyncRandomAccessWriteDevice]``,
      typename Allocator,
      typename CompletionCondition>
  std::size_t ``[link boost_asio.reference.write_at.overload5 write_at]``(
      SyncRandomAccessWriteDevice & d,
      boost::uint64_t offset,
      basic_streambuf< Allocator > & b,
      CompletionCondition completion_condition);

  template<
      typename ``[link boost_asio.reference.SyncRandomAccessWriteDevice SyncRandomAccessWriteDevice]``,
      typename Allocator,
      typename CompletionCondition>
  std::size_t ``[link boost_asio.reference.write_at.overload6 write_at]``(
      SyncRandomAccessWriteDevice & d,
      boost::uint64_t offset,
      basic_streambuf< Allocator > & b,
      CompletionCondition completion_condition,
      boost::system::error_code & ec);


[section:overload1 write_at (1 of 6 overloads)]

Write all of the supplied data at the specified offset before returning. 

  template<
      typename ``[link boost_asio.reference.SyncRandomAccessWriteDevice SyncRandomAccessWriteDevice]``,
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``>
  std::size_t write_at(
      SyncRandomAccessWriteDevice & d,
      boost::uint64_t offset,
      const ConstBufferSequence & buffers);


This function is used to write a certain number of bytes of data to a random access device at a specified offset. The call will block until one of the following conditions is true:


* All of the data in the supplied buffers has been written. That is, the bytes transferred is equal to the sum of the buffer sizes.

* An error occurred.

This operation is implemented in terms of zero or more calls to the device's write\_some\_at function.


[heading Parameters]
    

[variablelist
  
[[d][The device to which the data is to be written. The type must support the SyncRandomAccessWriteDevice concept.]]

[[offset][The offset at which the data will be written.]]

[[buffers][One or more buffers containing the data to be written. The sum of the buffer sizes indicates the maximum number of bytes to write to the device.]]

]

[heading Return Value]
      
The number of bytes transferred.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Example]
  
To write a single data buffer use the 
[link boost_asio.reference.buffer buffer]  function as follows: 

   boost::asio::write_at(d, 42, boost::asio::buffer(data, size)); 


See the 
[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.

[heading Remarks]
      
This overload is equivalent to calling: 

   boost::asio::write_at(
       d, offset, buffers,
       boost::asio::transfer_all()); 






[endsect]



[section:overload2 write_at (2 of 6 overloads)]

Write a certain amount of data at a specified offset before returning. 

  template<
      typename ``[link boost_asio.reference.SyncRandomAccessWriteDevice SyncRandomAccessWriteDevice]``,
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
      typename CompletionCondition>
  std::size_t write_at(
      SyncRandomAccessWriteDevice & d,
      boost::uint64_t offset,
      const ConstBufferSequence & buffers,
      CompletionCondition completion_condition);


This function is used to write a certain number of bytes of data to a random access device at a specified offset. The call will block until one of the following conditions is true:


* All of the data in the supplied buffers has been written. That is, the bytes transferred is equal to the sum of the buffer sizes.

* The completion_condition function object returns 0.

This operation is implemented in terms of zero or more calls to the device's write\_some\_at function.


[heading Parameters]
    

[variablelist
  
[[d][The device to which the data is to be written. The type must support the SyncRandomAccessWriteDevice concept.]]

[[offset][The offset at which the data will be written.]]

[[buffers][One or more buffers containing the data to be written. The sum of the buffer sizes indicates the maximum number of bytes to write to the device.]]

[[completion_condition][The function object to be called to determine whether the write operation is complete. The signature of the function object must be: 
``
   std::size_t completion_condition(
     // Result of latest write_some_at operation.
     const boost::system::error_code& error,

     // Number of bytes transferred so far.
     std::size_t bytes_transferred
   ); 
``
A return value of 0 indicates that the write operation is complete. A non-zero return value indicates the maximum number of bytes to be written on the next call to the device's write\_some\_at function.]]

]

[heading Return Value]
      
The number of bytes transferred.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Example]
  
To write a single data buffer use the 
[link boost_asio.reference.buffer buffer]  function as follows: 

   boost::asio::write_at(d, 42, boost::asio::buffer(data, size),
       boost::asio::transfer_at_least(32)); 


See the 
[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. 



[endsect]



[section:overload3 write_at (3 of 6 overloads)]

Write a certain amount of data at a specified offset before returning. 

  template<
      typename ``[link boost_asio.reference.SyncRandomAccessWriteDevice SyncRandomAccessWriteDevice]``,
      typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
      typename CompletionCondition>
  std::size_t write_at(
      SyncRandomAccessWriteDevice & d,
      boost::uint64_t offset,
      const ConstBufferSequence & buffers,
      CompletionCondition completion_condition,
      boost::system::error_code & ec);


This function is used to write a certain number of bytes of data to a random access device at a specified offset. The call will block until one of the following conditions is true:


* All of the data in the supplied buffers has been written. That is, the bytes transferred is equal to the sum of the buffer sizes.

* The completion_condition function object returns 0.

This operation is implemented in terms of zero or more calls to the device's write\_some\_at function.


[heading Parameters]
    

[variablelist
  
[[d][The device to which the data is to be written. The type must support the SyncRandomAccessWriteDevice concept.]]

[[offset][The offset at which the data will be written.]]

[[buffers][One or more buffers containing the data to be written. The sum of the buffer sizes indicates the maximum number of bytes to write to the device.]]

[[completion_condition][The function object to be called to determine whether the write operation is complete. The signature of the function object must be: 
``
   std::size_t completion_condition(
     // Result of latest write_some_at operation.
     const boost::system::error_code& error,

     // Number of bytes transferred so far.
     std::size_t bytes_transferred
   ); 
``
A return value of 0 indicates that the write operation is complete. A non-zero return value indicates the maximum number of bytes to be written on the next call to the device's write\_some\_at function.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Return Value]
      
The number of bytes written. If an error occurs, returns the total number of bytes successfully transferred prior to the error. 



[endsect]



[section:overload4 write_at (4 of 6 overloads)]

Write all of the supplied data at the specified offset before returning. 

  template<
      typename ``[link boost_asio.reference.SyncRandomAccessWriteDevice SyncRandomAccessWriteDevice]``,
      typename Allocator>
  std::size_t write_at(
      SyncRandomAccessWriteDevice & d,
      boost::uint64_t offset,
      basic_streambuf< Allocator > & b);


This function is used to write a certain number of bytes of data to a random access device at a specified offset. The call will block until one of the following conditions is true:


* All of the data in the supplied basic_streambuf has been written.

* An error occurred.

This operation is implemented in terms of zero or more calls to the device's write\_some\_at function.


[heading Parameters]
    

[variablelist
  
[[d][The device to which the data is to be written. The type must support the SyncRandomAccessWriteDevice concept.]]

[[offset][The offset at which the data will be written.]]

[[b][The basic\_streambuf object from which data will be written.]]

]

[heading Return Value]
      
The number of bytes transferred.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure.]]

]

[heading Remarks]
      
This overload is equivalent to calling: 

   boost::asio::write_at(
       d, 42, b,
       boost::asio::transfer_all()); 






[endsect]



[section:overload5 write_at (5 of 6 overloads)]

Write a certain amount of data at a specified offset before returning. 

  template<
      typename ``[link boost_asio.reference.SyncRandomAccessWriteDevice SyncRandomAccessWriteDevice]``,
      typename Allocator,
      typename CompletionCondition>
  std::size_t write_at(
      SyncRandomAccessWriteDevice & d,
      boost::uint64_t offset,
      basic_streambuf< Allocator > & b,
      CompletionCondition completion_condition);


This function is used to write a certain number of bytes of data to a random access device at a specified offset. The call will block until one of the following conditions is true:


* All of the data in the supplied basic_streambuf has been written.

* The completion_condition function object returns 0.

This operation is implemented in terms of zero or more calls to the device's write\_some\_at function.


[heading Parameters]
    

[variablelist
  
[[d][The device to which the data is to be written. The type must support the SyncRandomAccessWriteDevice concept.]]

[[offset][The offset at which the data will be written.]]

[[b][The basic\_streambuf object from which data will be written.]]

[[completion_condition][The function object to be called to determine whether the write operation is complete. The signature of the function object must be: 
``
   std::size_t completion_condition(
     // Result of latest write_some_at operation.
     const boost::system::error_code& error,

     // Number of bytes transferred so far.
     std::size_t bytes_transferred
   ); 
``
A return value of 0 indicates that the write operation is complete. A non-zero return value indicates the maximum number of bytes to be written on the next call to the device's write\_some\_at function.]]

]

[heading Return Value]
      
The number of bytes transferred.

[heading Exceptions]
    

[variablelist
  
[[boost::system::system_error][Thrown on failure. ]]

]



[endsect]



[section:overload6 write_at (6 of 6 overloads)]

Write a certain amount of data at a specified offset before returning. 

  template<
      typename ``[link boost_asio.reference.SyncRandomAccessWriteDevice SyncRandomAccessWriteDevice]``,
      typename Allocator,
      typename CompletionCondition>
  std::size_t write_at(
      SyncRandomAccessWriteDevice & d,
      boost::uint64_t offset,
      basic_streambuf< Allocator > & b,
      CompletionCondition completion_condition,
      boost::system::error_code & ec);


This function is used to write a certain number of bytes of data to a random access device at a specified offset. The call will block until one of the following conditions is true:


* All of the data in the supplied basic_streambuf has been written.

* The completion_condition function object returns 0.

This operation is implemented in terms of zero or more calls to the device's write\_some\_at function.


[heading Parameters]
    

[variablelist
  
[[d][The device to which the data is to be written. The type must support the SyncRandomAccessWriteDevice concept.]]

[[offset][The offset at which the data will be written.]]

[[b][The basic\_streambuf object from which data will be written.]]

[[completion_condition][The function object to be called to determine whether the write operation is complete. The signature of the function object must be: 
``
   std::size_t completion_condition(
     // Result of latest write_some_at operation.
     const boost::system::error_code& error,

     // Number of bytes transferred so far.
     std::size_t bytes_transferred
   ); 
``
A return value of 0 indicates that the write operation is complete. A non-zero return value indicates the maximum number of bytes to be written on the next call to the device's write\_some\_at function.]]

[[ec][Set to indicate what error occurred, if any.]]

]

[heading Return Value]
      
The number of bytes written. If an error occurs, returns the total number of bytes successfully transferred prior to the error. 



[endsect]


[endsect]

[section:is_error_code_enum_lt__addrinfo_errors__gt_ boost::system::is_error_code_enum< boost::asio::error::addrinfo_errors >]



  template<>
  struct boost::system::is_error_code_enum< boost::asio::error::addrinfo_errors >


[heading Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.is_error_code_enum_lt__addrinfo_errors__gt_.value [*value]]]
    []
  ]

]


[section:value boost::system::is_error_code_enum< boost::asio::error::addrinfo_errors >::value]

[indexterm2 value..boost::system::is_error_code_enum< boost::asio::error::addrinfo_errors >] 

  static const bool value = true;



[endsect]



[endsect]

[section:is_error_code_enum_lt__basic_errors__gt_ boost::system::is_error_code_enum< boost::asio::error::basic_errors >]



  template<>
  struct boost::system::is_error_code_enum< boost::asio::error::basic_errors >


[heading Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.is_error_code_enum_lt__basic_errors__gt_.value [*value]]]
    []
  ]

]


[section:value boost::system::is_error_code_enum< boost::asio::error::basic_errors >::value]

[indexterm2 value..boost::system::is_error_code_enum< boost::asio::error::basic_errors >] 

  static const bool value = true;



[endsect]



[endsect]

[section:is_error_code_enum_lt__misc_errors__gt_ boost::system::is_error_code_enum< boost::asio::error::misc_errors >]



  template<>
  struct boost::system::is_error_code_enum< boost::asio::error::misc_errors >


[heading Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.is_error_code_enum_lt__misc_errors__gt_.value [*value]]]
    []
  ]

]


[section:value boost::system::is_error_code_enum< boost::asio::error::misc_errors >::value]

[indexterm2 value..boost::system::is_error_code_enum< boost::asio::error::misc_errors >] 

  static const bool value = true;



[endsect]



[endsect]

[section:is_error_code_enum_lt__netdb_errors__gt_ boost::system::is_error_code_enum< boost::asio::error::netdb_errors >]



  template<>
  struct boost::system::is_error_code_enum< boost::asio::error::netdb_errors >


[heading Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.is_error_code_enum_lt__netdb_errors__gt_.value [*value]]]
    []
  ]

]


[section:value boost::system::is_error_code_enum< boost::asio::error::netdb_errors >::value]

[indexterm2 value..boost::system::is_error_code_enum< boost::asio::error::netdb_errors >] 

  static const bool value = true;



[endsect]



[endsect]

[section:is_error_code_enum_lt__ssl_errors__gt_ boost::system::is_error_code_enum< boost::asio::error::ssl_errors >]



  template<>
  struct boost::system::is_error_code_enum< boost::asio::error::ssl_errors >


[heading Data Members]
[table
  [[Name][Description]]

  [
    [[link boost_asio.reference.is_error_code_enum_lt__ssl_errors__gt_.value [*value]]]
    []
  ]

]


[section:value boost::system::is_error_code_enum< boost::asio::error::ssl_errors >::value]

[indexterm2 value..boost::system::is_error_code_enum< boost::asio::error::ssl_errors >] 

  static const bool value = true;



[endsect]



[endsect]

[endsect]