git.sesse.net Git - casparcg/blob - dependencies/boost/boost/asio/write_at.hpp

   1 //
   2 // write_at.hpp
   3 // ~~~~~~~~~~~~
   4 //
   5 // Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
   6 //
   7 // Distributed under the Boost Software License, Version 1.0. (See accompanying
   8 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   9 //
  10
  11 #ifndef BOOST_ASIO_WRITE_AT_HPP
  12 #define BOOST_ASIO_WRITE_AT_HPP
  13
  14 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
  15 # pragma once
  16 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
  17
  18 #include <boost/asio/detail/config.hpp>
  19 #include <cstddef>
  20 #include <boost/cstdint.hpp>
  21 #include <boost/asio/basic_streambuf_fwd.hpp>
  22 #include <boost/asio/error.hpp>
  23
  24 #include <boost/asio/detail/push_options.hpp>
  25
  26 namespace boost {
  27 namespace asio {
  28
  29 /**
  30  * @defgroup write_at boost::asio::write_at
  31  *
  32  * @brief Write a certain amount of data at a specified offset before returning.
  33  */
  34 /*@{*/
  35
  36 /// Write all of the supplied data at the specified offset before returning.
  37 /**
  38  * This function is used to write a certain number of bytes of data to a random
  39  * access device at a specified offset. The call will block until one of the
  40  * following conditions is true:
  41  *
  42  * @li All of the data in the supplied buffers has been written. That is, the
  43  * bytes transferred is equal to the sum of the buffer sizes.
  44  *
  45  * @li An error occurred.
  46  *
  47  * This operation is implemented in terms of zero or more calls to the device's
  48  * write_some_at function.
  49  *
  50  * @param d The device to which the data is to be written. The type must support
  51  * the SyncRandomAccessWriteDevice concept.
  52  *
  53  * @param offset The offset at which the data will be written.
  54  *
  55  * @param buffers One or more buffers containing the data to be written. The sum
  56  * of the buffer sizes indicates the maximum number of bytes to write to the
  57  * device.
  58  *
  59  * @returns The number of bytes transferred.
  60  *
  61  * @throws boost::system::system_error Thrown on failure.
  62  *
  63  * @par Example
  64  * To write a single data buffer use the @ref buffer function as follows:
  65  * @code boost::asio::write_at(d, 42, boost::asio::buffer(data, size)); @endcode
  66  * See the @ref buffer documentation for information on writing multiple
  67  * buffers in one go, and how to use it with arrays, boost::array or
  68  * std::vector.
  69  *
  70  * @note This overload is equivalent to calling:
  71  * @code boost::asio::write_at(
  72  *     d, offset, buffers,
  73  *     boost::asio::transfer_all()); @endcode
  74  */
  75 template <typename SyncRandomAccessWriteDevice, typename ConstBufferSequence>
  76 std::size_t write_at(SyncRandomAccessWriteDevice& d,
  77     boost::uint64_t offset, const ConstBufferSequence& buffers);
  78
  79 /// Write all of the supplied data at the specified offset before returning.
  80 /**
  81  * This function is used to write a certain number of bytes of data to a random
  82  * access device at a specified offset. The call will block until one of the
  83  * following conditions is true:
  84  *
  85  * @li All of the data in the supplied buffers has been written. That is, the
  86  * bytes transferred is equal to the sum of the buffer sizes.
  87  *
  88  * @li An error occurred.
  89  *
  90  * This operation is implemented in terms of zero or more calls to the device's
  91  * write_some_at function.
  92  *
  93  * @param d The device to which the data is to be written. The type must support
  94  * the SyncRandomAccessWriteDevice concept.
  95  *
  96  * @param offset The offset at which the data will be written.
  97  *
  98  * @param buffers One or more buffers containing the data to be written. The sum
  99  * of the buffer sizes indicates the maximum number of bytes to write to the
 100  * device.
 101  *
 102  * @param ec Set to indicate what error occurred, if any.
 103  *
 104  * @returns The number of bytes transferred.
 105  *
 106  * @par Example
 107  * To write a single data buffer use the @ref buffer function as follows:
 108  * @code boost::asio::write_at(d, 42,
 109  *     boost::asio::buffer(data, size), ec); @endcode
 110  * See the @ref buffer documentation for information on writing multiple
 111  * buffers in one go, and how to use it with arrays, boost::array or
 112  * std::vector.
 113  *
 114  * @note This overload is equivalent to calling:
 115  * @code boost::asio::write_at(
 116  *     d, offset, buffers,
 117  *     boost::asio::transfer_all(), ec); @endcode
 118  */
 119 template <typename SyncRandomAccessWriteDevice, typename ConstBufferSequence>
 120 std::size_t write_at(SyncRandomAccessWriteDevice& d,
 121     boost::uint64_t offset, const ConstBufferSequence& buffers,
 122     boost::system::error_code& ec);
 123
 124 /// Write a certain amount of data at a specified offset before returning.
 125 /**
 126  * This function is used to write a certain number of bytes of data to a random
 127  * access device at a specified offset. The call will block until one of the
 128  * following conditions is true:
 129  *
 130  * @li All of the data in the supplied buffers has been written. That is, the
 131  * bytes transferred is equal to the sum of the buffer sizes.
 132  *
 133  * @li The completion_condition function object returns 0.
 134  *
 135  * This operation is implemented in terms of zero or more calls to the device's
 136  * write_some_at function.
 137  *
 138  * @param d The device to which the data is to be written. The type must support
 139  * the SyncRandomAccessWriteDevice concept.
 140  *
 141  * @param offset The offset at which the data will be written.
 142  *
 143  * @param buffers One or more buffers containing the data to be written. The sum
 144  * of the buffer sizes indicates the maximum number of bytes to write to the
 145  * device.
 146  *
 147  * @param completion_condition The function object to be called to determine
 148  * whether the write operation is complete. The signature of the function object
 149  * must be:
 150  * @code std::size_t completion_condition(
 151  *   // Result of latest write_some_at operation.
 152  *   const boost::system::error_code& error,
 153  *
 154  *   // Number of bytes transferred so far.
 155  *   std::size_t bytes_transferred
 156  * ); @endcode
 157  * A return value of 0 indicates that the write operation is complete. A
 158  * non-zero return value indicates the maximum number of bytes to be written on
 159  * the next call to the device's write_some_at function.
 160  *
 161  * @returns The number of bytes transferred.
 162  *
 163  * @throws boost::system::system_error Thrown on failure.
 164  *
 165  * @par Example
 166  * To write a single data buffer use the @ref buffer function as follows:
 167  * @code boost::asio::write_at(d, 42, boost::asio::buffer(data, size),
 168  *     boost::asio::transfer_at_least(32)); @endcode
 169  * See the @ref buffer documentation for information on writing multiple
 170  * buffers in one go, and how to use it with arrays, boost::array or
 171  * std::vector.
 172  */
 173 template <typename SyncRandomAccessWriteDevice, typename ConstBufferSequence,
 174     typename CompletionCondition>
 175 std::size_t write_at(SyncRandomAccessWriteDevice& d,
 176     boost::uint64_t offset, const ConstBufferSequence& buffers,
 177     CompletionCondition completion_condition);
 178
 179 /// Write a certain amount of data at a specified offset before returning.
 180 /**
 181  * This function is used to write a certain number of bytes of data to a random
 182  * access device at a specified offset. The call will block until one of the
 183  * following conditions is true:
 184  *
 185  * @li All of the data in the supplied buffers has been written. That is, the
 186  * bytes transferred is equal to the sum of the buffer sizes.
 187  *
 188  * @li The completion_condition function object returns 0.
 189  *
 190  * This operation is implemented in terms of zero or more calls to the device's
 191  * write_some_at function.
 192  *
 193  * @param d The device to which the data is to be written. The type must support
 194  * the SyncRandomAccessWriteDevice concept.
 195  *
 196  * @param offset The offset at which the data will be written.
 197  *
 198  * @param buffers One or more buffers containing the data to be written. The sum
 199  * of the buffer sizes indicates the maximum number of bytes to write to the
 200  * device.
 201  *
 202  * @param completion_condition The function object to be called to determine
 203  * whether the write operation is complete. The signature of the function object
 204  * must be:
 205  * @code std::size_t completion_condition(
 206  *   // Result of latest write_some_at operation.
 207  *   const boost::system::error_code& error,
 208  *
 209  *   // Number of bytes transferred so far.
 210  *   std::size_t bytes_transferred
 211  * ); @endcode
 212  * A return value of 0 indicates that the write operation is complete. A
 213  * non-zero return value indicates the maximum number of bytes to be written on
 214  * the next call to the device's write_some_at function.
 215  *
 216  * @param ec Set to indicate what error occurred, if any.
 217  *
 218  * @returns The number of bytes written. If an error occurs, returns the total
 219  * number of bytes successfully transferred prior to the error.
 220  */
 221 template <typename SyncRandomAccessWriteDevice, typename ConstBufferSequence,
 222     typename CompletionCondition>
 223 std::size_t write_at(SyncRandomAccessWriteDevice& d,
 224     boost::uint64_t offset, const ConstBufferSequence& buffers,
 225     CompletionCondition completion_condition, boost::system::error_code& ec);
 226
 227 #if !defined(BOOST_NO_IOSTREAM)
 228
 229 /// Write all of the supplied data at the specified offset before returning.
 230 /**
 231  * This function is used to write a certain number of bytes of data to a random
 232  * access device at a specified offset. The call will block until one of the
 233  * following conditions is true:
 234  *
 235  * @li All of the data in the supplied basic_streambuf has been written.
 236  *
 237  * @li An error occurred.
 238  *
 239  * This operation is implemented in terms of zero or more calls to the device's
 240  * write_some_at function.
 241  *
 242  * @param d The device to which the data is to be written. The type must support
 243  * the SyncRandomAccessWriteDevice concept.
 244  *
 245  * @param offset The offset at which the data will be written.
 246  *
 247  * @param b The basic_streambuf object from which data will be written.
 248  *
 249  * @returns The number of bytes transferred.
 250  *
 251  * @throws boost::system::system_error Thrown on failure.
 252  *
 253  * @note This overload is equivalent to calling:
 254  * @code boost::asio::write_at(
 255  *     d, 42, b,
 256  *     boost::asio::transfer_all()); @endcode
 257  */
 258 template <typename SyncRandomAccessWriteDevice, typename Allocator>
 259 std::size_t write_at(SyncRandomAccessWriteDevice& d,
 260     boost::uint64_t offset, basic_streambuf<Allocator>& b);
 261
 262 /// Write all of the supplied data at the specified offset before returning.
 263 /**
 264  * This function is used to write a certain number of bytes of data to a random
 265  * access device at a specified offset. The call will block until one of the
 266  * following conditions is true:
 267  *
 268  * @li All of the data in the supplied basic_streambuf has been written.
 269  *
 270  * @li An error occurred.
 271  *
 272  * This operation is implemented in terms of zero or more calls to the device's
 273  * write_some_at function.
 274  *
 275  * @param d The device to which the data is to be written. The type must support
 276  * the SyncRandomAccessWriteDevice concept.
 277  *
 278  * @param offset The offset at which the data will be written.
 279  *
 280  * @param b The basic_streambuf object from which data will be written.
 281  *
 282  * @param ec Set to indicate what error occurred, if any.
 283  *
 284  * @returns The number of bytes transferred.
 285  *
 286  * @note This overload is equivalent to calling:
 287  * @code boost::asio::write_at(
 288  *     d, 42, b,
 289  *     boost::asio::transfer_all(), ec); @endcode
 290  */
 291 template <typename SyncRandomAccessWriteDevice, typename Allocator>
 292 std::size_t write_at(SyncRandomAccessWriteDevice& d,
 293     boost::uint64_t offset, basic_streambuf<Allocator>& b,
 294     boost::system::error_code& ec);
 295
 296 /// Write a certain amount of data at a specified offset before returning.
 297 /**
 298  * This function is used to write a certain number of bytes of data to a random
 299  * access device at a specified offset. The call will block until one of the
 300  * following conditions is true:
 301  *
 302  * @li All of the data in the supplied basic_streambuf has been written.
 303  *
 304  * @li The completion_condition function object returns 0.
 305  *
 306  * This operation is implemented in terms of zero or more calls to the device's
 307  * write_some_at function.
 308  *
 309  * @param d The device to which the data is to be written. The type must support
 310  * the SyncRandomAccessWriteDevice concept.
 311  *
 312  * @param offset The offset at which the data will be written.
 313  *
 314  * @param b The basic_streambuf object from which data will be written.
 315  *
 316  * @param completion_condition The function object to be called to determine
 317  * whether the write operation is complete. The signature of the function object
 318  * must be:
 319  * @code std::size_t completion_condition(
 320  *   // Result of latest write_some_at operation.
 321  *   const boost::system::error_code& error,
 322  *
 323  *   // Number of bytes transferred so far.
 324  *   std::size_t bytes_transferred
 325  * ); @endcode
 326  * A return value of 0 indicates that the write operation is complete. A
 327  * non-zero return value indicates the maximum number of bytes to be written on
 328  * the next call to the device's write_some_at function.
 329  *
 330  * @returns The number of bytes transferred.
 331  *
 332  * @throws boost::system::system_error Thrown on failure.
 333  */
 334 template <typename SyncRandomAccessWriteDevice, typename Allocator,
 335     typename CompletionCondition>
 336 std::size_t write_at(SyncRandomAccessWriteDevice& d, boost::uint64_t offset,
 337     basic_streambuf<Allocator>& b, CompletionCondition completion_condition);
 338
 339 /// Write a certain amount of data at a specified offset before returning.
 340 /**
 341  * This function is used to write a certain number of bytes of data to a random
 342  * access device at a specified offset. The call will block until one of the
 343  * following conditions is true:
 344  *
 345  * @li All of the data in the supplied basic_streambuf has been written.
 346  *
 347  * @li The completion_condition function object returns 0.
 348  *
 349  * This operation is implemented in terms of zero or more calls to the device's
 350  * write_some_at function.
 351  *
 352  * @param d The device to which the data is to be written. The type must support
 353  * the SyncRandomAccessWriteDevice concept.
 354  *
 355  * @param offset The offset at which the data will be written.
 356  *
 357  * @param b The basic_streambuf object from which data will be written.
 358  *
 359  * @param completion_condition The function object to be called to determine
 360  * whether the write operation is complete. The signature of the function object
 361  * must be:
 362  * @code std::size_t completion_condition(
 363  *   // Result of latest write_some_at operation.
 364  *   const boost::system::error_code& error,
 365  *
 366  *   // Number of bytes transferred so far.
 367  *   std::size_t bytes_transferred
 368  * ); @endcode
 369  * A return value of 0 indicates that the write operation is complete. A
 370  * non-zero return value indicates the maximum number of bytes to be written on
 371  * the next call to the device's write_some_at function.
 372  *
 373  * @param ec Set to indicate what error occurred, if any.
 374  *
 375  * @returns The number of bytes written. If an error occurs, returns the total
 376  * number of bytes successfully transferred prior to the error.
 377  */
 378 template <typename SyncRandomAccessWriteDevice, typename Allocator,
 379     typename CompletionCondition>
 380 std::size_t write_at(SyncRandomAccessWriteDevice& d, boost::uint64_t offset,
 381     basic_streambuf<Allocator>& b, CompletionCondition completion_condition,
 382     boost::system::error_code& ec);
 383
 384 #endif // !defined(BOOST_NO_IOSTREAM)
 385
 386 /*@}*/
 387 /**
 388  * @defgroup async_write_at boost::asio::async_write_at
 389  *
 390  * @brief Start an asynchronous operation to write a certain amount of data at
 391  * the specified offset.
 392  */
 393 /*@{*/
 394
 395 /// Start an asynchronous operation to write all of the supplied data at the
 396 /// specified offset.
 397 /**
 398  * This function is used to asynchronously write a certain number of bytes of
 399  * data to a random access device at a specified offset. The function call
 400  * always returns immediately. The asynchronous operation will continue until
 401  * one of the following conditions is true:
 402  *
 403  * @li All of the data in the supplied buffers has been written. That is, the
 404  * bytes transferred is equal to the sum of the buffer sizes.
 405  *
 406  * @li An error occurred.
 407  *
 408  * This operation is implemented in terms of zero or more calls to the device's
 409  * async_write_some_at function.
 410  *
 411  * @param d The device to which the data is to be written. The type must support
 412  * the AsyncRandomAccessWriteDevice concept.
 413  *
 414  * @param offset The offset at which the data will be written.
 415  *
 416  * @param buffers One or more buffers containing the data to be written.
 417  * Although the buffers object may be copied as necessary, ownership of the
 418  * underlying memory blocks is retained by the caller, which must guarantee
 419  * that they remain valid until the handler is called.
 420  *
 421  * @param handler The handler to be called when the write operation completes.
 422  * Copies will be made of the handler as required. The function signature of
 423  * the handler must be:
 424  * @code void handler(
 425  *   // Result of operation.
 426  *   const boost::system::error_code& error,
 427  *
 428  *   // Number of bytes written from the buffers. If an error
 429  *   // occurred, this will be less than the sum of the buffer sizes.
 430  *   std::size_t bytes_transferred
 431  * ); @endcode
 432  * Regardless of whether the asynchronous operation completes immediately or
 433  * not, the handler will not be invoked from within this function. Invocation of
 434  * the handler will be performed in a manner equivalent to using
 435  * boost::asio::io_service::post().
 436  *
 437  * @par Example
 438  * To write a single data buffer use the @ref buffer function as follows:
 439  * @code
 440  * boost::asio::async_write_at(d, 42, boost::asio::buffer(data, size), handler);
 441  * @endcode
 442  * See the @ref buffer documentation for information on writing multiple
 443  * buffers in one go, and how to use it with arrays, boost::array or
 444  * std::vector.
 445  */
 446 template <typename AsyncRandomAccessWriteDevice, typename ConstBufferSequence,
 447     typename WriteHandler>
 448 void async_write_at(AsyncRandomAccessWriteDevice& d, boost::uint64_t offset,
 449     const ConstBufferSequence& buffers,
 450     BOOST_ASIO_MOVE_ARG(WriteHandler) handler);
 451
 452 /// Start an asynchronous operation to write a certain amount of data at the
 453 /// specified offset.
 454 /**
 455  * This function is used to asynchronously write a certain number of bytes of
 456  * data to a random access device at a specified offset. The function call
 457  * always returns immediately. The asynchronous operation will continue until
 458  * one of the following conditions is true:
 459  *
 460  * @li All of the data in the supplied buffers has been written. That is, the
 461  * bytes transferred is equal to the sum of the buffer sizes.
 462  *
 463  * @li The completion_condition function object returns 0.
 464  *
 465  * This operation is implemented in terms of zero or more calls to the device's
 466  * async_write_some_at function.
 467  *
 468  * @param d The device to which the data is to be written. The type must support
 469  * the AsyncRandomAccessWriteDevice concept.
 470  *
 471  * @param offset The offset at which the data will be written.
 472  *
 473  * @param buffers One or more buffers containing the data to be written.
 474  * Although the buffers object may be copied as necessary, ownership of the
 475  * underlying memory blocks is retained by the caller, which must guarantee
 476  * that they remain valid until the handler is called.
 477  *
 478  * @param completion_condition The function object to be called to determine
 479  * whether the write operation is complete. The signature of the function object
 480  * must be:
 481  * @code std::size_t completion_condition(
 482  *   // Result of latest async_write_some_at operation.
 483  *   const boost::system::error_code& error,
 484  *
 485  *   // Number of bytes transferred so far.
 486  *   std::size_t bytes_transferred
 487  * ); @endcode
 488  * A return value of 0 indicates that the write operation is complete. A
 489  * non-zero return value indicates the maximum number of bytes to be written on
 490  * the next call to the device's async_write_some_at function.
 491  *
 492  * @param handler The handler to be called when the write operation completes.
 493  * Copies will be made of the handler as required. The function signature of the
 494  * handler must be:
 495  * @code void handler(
 496  *   // Result of operation.
 497  *   const boost::system::error_code& error,
 498  *
 499  *   // Number of bytes written from the buffers. If an error
 500  *   // occurred, this will be less than the sum of the buffer sizes.
 501  *   std::size_t bytes_transferred
 502  * ); @endcode
 503  * Regardless of whether the asynchronous operation completes immediately or
 504  * not, the handler will not be invoked from within this function. Invocation of
 505  * the handler will be performed in a manner equivalent to using
 506  * boost::asio::io_service::post().
 507  *
 508  * @par Example
 509  * To write a single data buffer use the @ref buffer function as follows:
 510  * @code boost::asio::async_write_at(d, 42,
 511  *     boost::asio::buffer(data, size),
 512  *     boost::asio::transfer_at_least(32),
 513  *     handler); @endcode
 514  * See the @ref buffer documentation for information on writing multiple
 515  * buffers in one go, and how to use it with arrays, boost::array or
 516  * std::vector.
 517  */
 518 template <typename AsyncRandomAccessWriteDevice, typename ConstBufferSequence,
 519     typename CompletionCondition, typename WriteHandler>
 520 void async_write_at(AsyncRandomAccessWriteDevice& d,
 521     boost::uint64_t offset, const ConstBufferSequence& buffers,
 522     CompletionCondition completion_condition,
 523     BOOST_ASIO_MOVE_ARG(WriteHandler) handler);
 524
 525 #if !defined(BOOST_NO_IOSTREAM)
 526
 527 /// Start an asynchronous operation to write all of the supplied data at the
 528 /// specified offset.
 529 /**
 530  * This function is used to asynchronously write a certain number of bytes of
 531  * data to a random access device at a specified offset. The function call
 532  * always returns immediately. The asynchronous operation will continue until
 533  * one of the following conditions is true:
 534  *
 535  * @li All of the data in the supplied basic_streambuf has been written.
 536  *
 537  * @li An error occurred.
 538  *
 539  * This operation is implemented in terms of zero or more calls to the device's
 540  * async_write_some_at function.
 541  *
 542  * @param d The device to which the data is to be written. The type must support
 543  * the AsyncRandomAccessWriteDevice concept.
 544  *
 545  * @param offset The offset at which the data will be written.
 546  *
 547  * @param b A basic_streambuf object from which data will be written. Ownership
 548  * of the streambuf is retained by the caller, which must guarantee that it
 549  * remains valid until the handler is called.
 550  *
 551  * @param handler The handler to be called when the write operation completes.
 552  * Copies will be made of the handler as required. The function signature of the
 553  * handler must be:
 554  * @code void handler(
 555  *   // Result of operation.
 556  *   const boost::system::error_code& error,
 557  *
 558  *   // Number of bytes written from the buffers. If an error
 559  *   // occurred, this will be less than the sum of the buffer sizes.
 560  *   std::size_t bytes_transferred
 561  * ); @endcode
 562  * Regardless of whether the asynchronous operation completes immediately or
 563  * not, the handler will not be invoked from within this function. Invocation of
 564  * the handler will be performed in a manner equivalent to using
 565  * boost::asio::io_service::post().
 566  */
 567 template <typename AsyncRandomAccessWriteDevice, typename Allocator,
 568     typename WriteHandler>
 569 void async_write_at(AsyncRandomAccessWriteDevice& d, boost::uint64_t offset,
 570     basic_streambuf<Allocator>& b, BOOST_ASIO_MOVE_ARG(WriteHandler) handler);
 571
 572 /// Start an asynchronous operation to write a certain amount of data at the
 573 /// specified offset.
 574 /**
 575  * This function is used to asynchronously write a certain number of bytes of
 576  * data to a random access device at a specified offset. The function call
 577  * always returns immediately. The asynchronous operation will continue until
 578  * one of the following conditions is true:
 579  *
 580  * @li All of the data in the supplied basic_streambuf has been written.
 581  *
 582  * @li The completion_condition function object returns 0.
 583  *
 584  * This operation is implemented in terms of zero or more calls to the device's
 585  * async_write_some_at function.
 586  *
 587  * @param d The device to which the data is to be written. The type must support
 588  * the AsyncRandomAccessWriteDevice concept.
 589  *
 590  * @param offset The offset at which the data will be written.
 591  *
 592  * @param b A basic_streambuf object from which data will be written. Ownership
 593  * of the streambuf is retained by the caller, which must guarantee that it
 594  * remains valid until the handler is called.
 595  *
 596  * @param completion_condition The function object to be called to determine
 597  * whether the write operation is complete. The signature of the function object
 598  * must be:
 599  * @code std::size_t completion_condition(
 600  *   // Result of latest async_write_some_at operation.
 601  *   const boost::system::error_code& error,
 602  *
 603  *   // Number of bytes transferred so far.
 604  *   std::size_t bytes_transferred
 605  * ); @endcode
 606  * A return value of 0 indicates that the write operation is complete. A
 607  * non-zero return value indicates the maximum number of bytes to be written on
 608  * the next call to the device's async_write_some_at function.
 609  *
 610  * @param handler The handler to be called when the write operation completes.
 611  * Copies will be made of the handler as required. The function signature of the
 612  * handler must be:
 613  * @code void handler(
 614  *   // Result of operation.
 615  *   const boost::system::error_code& error,
 616  *
 617  *   // Number of bytes written from the buffers. If an error
 618  *   // occurred, this will be less than the sum of the buffer sizes.
 619  *   std::size_t bytes_transferred
 620  * ); @endcode
 621  * Regardless of whether the asynchronous operation completes immediately or
 622  * not, the handler will not be invoked from within this function. Invocation of
 623  * the handler will be performed in a manner equivalent to using
 624  * boost::asio::io_service::post().
 625  */
 626 template <typename AsyncRandomAccessWriteDevice, typename Allocator,
 627     typename CompletionCondition, typename WriteHandler>
 628 void async_write_at(AsyncRandomAccessWriteDevice& d, boost::uint64_t offset,
 629     basic_streambuf<Allocator>& b, CompletionCondition completion_condition,
 630     BOOST_ASIO_MOVE_ARG(WriteHandler) handler);
 631
 632 #endif // !defined(BOOST_NO_IOSTREAM)
 633
 634 /*@}*/
 635
 636 } // namespace asio
 637 } // namespace boost
 638
 639 #include <boost/asio/detail/pop_options.hpp>
 640
 641 #include <boost/asio/impl/write_at.hpp>
 642
 643 #endif // BOOST_ASIO_WRITE_AT_HPP