1 // 2 // completion_condition.hpp 3 // ~~~~~~~~~~~~~~~~~~~~~~~~ 4 // 5 // Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com) 6 // 7 // Distributed under the Boost Software License, Version 1.0. (See accompanying 8 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 9 // 10 11 #ifndef ASIO_COMPLETION_CONDITION_HPP 12 #define ASIO_COMPLETION_CONDITION_HPP 13 14 15 #include "asio/detail/config.hpp" 16 #include <cstddef> 17 18 #include "asio/detail/push_options.hpp" 19 20 namespace asio { 21 22 namespace detail { 23 24 // The default maximum number of bytes to transfer in a single operation. 25 enum default_max_transfer_size_t { default_max_transfer_size = 65536 }; 26 27 // Adapt result of old-style completion conditions (which had a bool result 28 // where true indicated that the operation was complete). 29 inline std::size_t adapt_completion_condition_result(bool result) 30 { 31 return result ? 0 : default_max_transfer_size; 32 } 33 34 // Adapt result of current completion conditions (which have a size_t result 35 // where 0 means the operation is complete, and otherwise the result is the 36 // maximum number of bytes to transfer on the next underlying operation). 37 inline std::size_t adapt_completion_condition_result(std::size_t result) 38 { 39 return result; 40 } 41 42 class transfer_all_t 43 { 44 public: 45 typedef std::size_t result_type; 46 47 template <typename Error> 48 std::size_t operator()(const Error& err, std::size_t) 49 { 50 return !!err ? 0 : default_max_transfer_size; 51 } 52 }; 53 54 class transfer_at_least_t 55 { 56 public: 57 typedef std::size_t result_type; 58 59 explicit transfer_at_least_t(std::size_t minimum) 60 : minimum_(minimum) 61 { 62 } 63 64 template <typename Error> 65 std::size_t operator()(const Error& err, std::size_t bytes_transferred) 66 { 67 return (!!err || bytes_transferred >= minimum_) 68 ? 0 : default_max_transfer_size; 69 } 70 71 private: 72 std::size_t minimum_; 73 }; 74 75 class transfer_exactly_t 76 { 77 public: 78 typedef std::size_t result_type; 79 80 explicit transfer_exactly_t(std::size_t size) 81 : size_(size) 82 { 83 } 84 85 template <typename Error> 86 std::size_t operator()(const Error& err, std::size_t bytes_transferred) 87 { 88 return (!!err || bytes_transferred >= size_) ? 0 : 89 (size_ - bytes_transferred < default_max_transfer_size 90 ? size_ - bytes_transferred : std::size_t(default_max_transfer_size)); 91 } 92 93 private: 94 std::size_t size_; 95 }; 96 97 } // namespace detail 98 99 /** 100 * @defgroup completion_condition Completion Condition Function Objects 101 * 102 * Function objects used for determining when a read or write operation should 103 * complete. 104 */ 105 /*@{*/ 106 107 /// Return a completion condition function object that indicates that a read or 108 /// write operation should continue until all of the data has been transferred, 109 /// or until an error occurs. 110 /** 111 * This function is used to create an object, of unspecified type, that meets 112 * CompletionCondition requirements. 113 * 114 * @par Example 115 * Reading until a buffer is full: 116 * @code 117 * boost::array<char, 128> buf; 118 * asio::error_code ec; 119 * std::size_t n = asio::read( 120 * sock, asio::buffer(buf), 121 * asio::transfer_all(), ec); 122 * if (ec) 123 * { 124 * // An error occurred. 125 * } 126 * else 127 * { 128 * // n == 128 129 * } 130 * @endcode 131 */ 132 inline detail::transfer_all_t transfer_all() 133 { 134 return detail::transfer_all_t(); 135 } 136 137 /// Return a completion condition function object that indicates that a read or 138 /// write operation should continue until a minimum number of bytes has been 139 /// transferred, or until an error occurs. 140 /** 141 * This function is used to create an object, of unspecified type, that meets 142 * CompletionCondition requirements. 143 * 144 * @par Example 145 * Reading until a buffer is full or contains at least 64 bytes: 146 * @code 147 * boost::array<char, 128> buf; 148 * asio::error_code ec; 149 * std::size_t n = asio::read( 150 * sock, asio::buffer(buf), 151 * asio::transfer_at_least(64), ec); 152 * if (ec) 153 * { 154 * // An error occurred. 155 * } 156 * else 157 * { 158 * // n >= 64 && n <= 128 159 * } 160 * @endcode 161 */ 162 inline detail::transfer_at_least_t transfer_at_least(std::size_t minimum) 163 { 164 return detail::transfer_at_least_t(minimum); 165 } 166 167 /// Return a completion condition function object that indicates that a read or 168 /// write operation should continue until an exact number of bytes has been 169 /// transferred, or until an error occurs. 170 /** 171 * This function is used to create an object, of unspecified type, that meets 172 * CompletionCondition requirements. 173 * 174 * @par Example 175 * Reading until a buffer is full or contains exactly 64 bytes: 176 * @code 177 * boost::array<char, 128> buf; 178 * asio::error_code ec; 179 * std::size_t n = asio::read( 180 * sock, asio::buffer(buf), 181 * asio::transfer_exactly(64), ec); 182 * if (ec) 183 * { 184 * // An error occurred. 185 * } 186 * else 187 * { 188 * // n == 64 189 * } 190 * @endcode 191 */ 192 inline detail::transfer_exactly_t transfer_exactly(std::size_t size) 193 { 194 return detail::transfer_exactly_t(size); 195 } 196 197 /*@}*/ 198 199 } // namespace asio 200 201 #include "asio/detail/pop_options.hpp" 202 203 #endif // ASIO_COMPLETION_CONDITION_HPP 204
