2. Boost Beast Translation (zh_Hans)
3. Doc / Qbk / 03 Core / 1 Refresher (qbk)
4. English
5. Zen

27 string ID 254
	Source string description type: list
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — # `partial` 11/10000 · 11
28 string ID 259
	Source string description type: list
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — # `total` 9/10000 · 9
29 string ID 266
	Source string description type: paragraph
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Networking prescribes facilities to determine the context in which handlers run. Every I/O object refers to an __ExecutionContext__ for obtaining the __Executor__ instance used to invoke completion handlers. An executor determines where and how completion handlers are invoked. Executors obtained from an instance of __io_context__ offer a basic guarantee: handlers will only be invoked from threads which are currently calling [@boost:/doc/html/boost_asio/reference/io_context/run/overload1.html `net::io_context::run`]. 521/10000 · 521
30 string ID 274
	Source string description type: paragraph
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — The __AsyncReadStream__ and __AsyncWriteStream__ concepts define requirements for ['asynchronous streams]: a portable I/O abstraction that exchanges data asynchronously using buffer sequences to represent bytes and `error_code` to report any failures. An ['asynchronous stream algorithm] is written as a templated initiating function template accepting a stream object meeting the named requirements for asynchronous reading, writing, or both. This example shows an algorithm which writes some text to an asynchronous stream: 525/10000 · 525
31 string ID 288
	Source string description type: heading
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Concurrency 11/10000 · 11
32 string ID 290
	Source string description type: paragraph
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — I/O objects such as sockets and streams [*are not thread-safe]. Although it is possible to have more than one operation outstanding (for example, a simultaneous asynchronous read and asynchronous write) the stream object itself may only be accessed from one thread at a time. This means that member functions such as move constructors, destructors, or initiating functions must not be called concurrently. Usually this is accomplished with synchronization primitives such as a [@https://en.cppreference.com/w/cpp/thread/mutex `mutex`], but concurrent network programs need a better way to access shared resources, since acquiring ownership of a mutex could block threads from performing uncontended work. For efficiency, networking adopts a model of using threads without explicit locking by requiring all access to I/O objects to be performed within a [@boost:/doc/html/boost_asio/overview/core/strands.html ['strand]]. 920/10000 · 920
33 string ID 307
	Source string description type: heading
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Universal Model 15/10000 · 15
34 string ID 309
	Source string description type: paragraph
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Because completion handlers cause an inversion of the flow of control, sometimes other methods of attaching a continuation are desired. Networking provides the [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3747.pdf ['Universal Model for Asynchronous Operations]], providing a customizable means for transforming the signature of the initiating function to use other types of objects and methods in place of a completion handler callback. For example to call to write a string to a socket asynchronously, using a `std::future` to receive the number of bytes transferred thus looks like this: 603/10000 · 603
35 string ID 321
	Source string description type: paragraph
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — This functionality is enabled by passing the variable [@boost:/doc/html/boost_asio/reference/use_future.html `net::use_future`] (of type [@boost:/doc/html/boost_asio/reference/use_future_t.html `net::use_future_t<>`]) in place of the completion handler. The same `async_write` function overload can work with a [@https://en.wikipedia.org/wiki/Fiber_(computer_science) ['fiber]] launched with [@boost:/doc/html/boost_asio/reference/spawn/overload1.html `asio::spawn`]: 467/10000 · 467
36 string ID 333
	Source string description type: paragraph
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — In both of these cases, an object with a specific type is used in place of the completion handler, and the return value of the initiating function is transformed from `void` to `std::future<std::size_t>` or `std::size_t`. The handler is sometimes called a __CompletionToken__ when used in this context. The return type transformation is supported by customization points in the initiating function signature. Here is the signature for [@boost:/doc/html/boost_asio/reference/async_write/overload1.html `net::async_write`]: 521/10000 · 521
37 string ID 343
	Source string description type: paragraph
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Note that a `spawn` function itself has a completion signature, but we're ignoring it's result in the example by using `asio::detached`. 136/10000 · 136
38 string ID 348
	Source string description type: paragraph
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — The type of the function's return value is determined by the [@boost:/doc/html/boost_asio/reference/async_result.html `net::async_result`] customization point, which comes with specializations for common library types such as `std::future` and may also be specialized for user-defined types. The body of the initiating function calls the [@boost:/doc/html/boost_asio/reference/async_initiate.html `net::async_initiate`] helper to capture the arguments and forward them to the specialization of `async_result`. An additional "initiation function" object is provided which `async_result` may use to immediately launch the operation, or defer the launch of the operation until some point in the future (this is called "lazy execution"). The initiation function object receives the internal completion handler which matches the signature expected by the initiating function: 870/10000 · 870
39 string ID 363
	Source string description type: paragraph
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — This transformed, internal handler is responsible for the finalizing step that delivers the result of the operation to the caller. For example, when using `net::use_future` the internal handler will deliver the result by calling [@https://en.cppreference.com/w/cpp/thread/promise/set_value `std::promise::set_value`] on the promise object returned by the initiating function. 375/10000 · 375
40 string ID 371
	Source string description type: heading
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Using Networking 16/10000 · 16
41 string ID 373
	Source string description type: paragraph
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Most library stream algorithms require a __socket__, __ssl_stream__, or other __Stream__ object that has already established communication with a remote peer. This example is provided as a reminder of how to work with sockets: 226/10000 · 226
42 string ID 380
	Source string description type: paragraph
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Throughout this documentation identifiers with the following names have special meaning: 88/10000 · 88
43 string ID 383
	Source string description type: table title
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Global Variables 16/10000 · 16
44 string ID 383
	Source string description type: table cell
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Name 4/10000 · 4
45 string ID 383
	Source string description type: table cell
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Description 11/10000 · 11
46 string ID 383
	Source string description type: table cell
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — [@boost:/doc/html/boost_asio/reference/io_context.html [*`ioc`]] 64/10000 · 64