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

28 string ID 259
	Source string description type: list
	English # `total`
	Chinese (Simplified Han script) ↹ ↵ NBS … 「 」 『 』 ﹙-﹚ ‐ – — # `total` 9/100 · 9 Needs editing (Needs rewriting)
29 string ID 266
	Source string description type: paragraph
	English 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`].
	Chinese (Simplified Han script) ↹ ↵ 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/5210 · 521 Needs editing (Needs rewriting)
30 string ID 274
	Source string description type: paragraph
	English 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:
	Chinese (Simplified Han script) ↹ ↵ 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/5250 · 525 Needs editing (Needs rewriting)
31 string ID 288
	Source string description type: heading
	English Concurrency
	Chinese (Simplified Han script) ↹ ↵ NBS … 「 」 『 』 ﹙-﹚ ‐ – — Concurrency 11/110 · 11 Needs editing (Needs rewriting)
32 string ID 290
	Source string description type: paragraph
	English 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]].
	Chinese (Simplified Han script) ↹ ↵ 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/9200 · 920 Needs editing (Needs rewriting)
33 string ID 307
	Source string description type: heading
	English Universal Model
	Chinese (Simplified Han script) ↹ ↵ NBS … 「 」 『 』 ﹙-﹚ ‐ – — Universal Model 15/150 · 15 Needs editing (Needs rewriting)
34 string ID 309
	Source string description type: paragraph
	English 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:
	Chinese (Simplified Han script) ↹ ↵ 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/6030 · 603 Needs editing (Needs rewriting)
35 string ID 321
	Source string description type: paragraph
	English 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`]:
	Chinese (Simplified Han script) ↹ ↵ 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/4670 · 467 Needs editing (Needs rewriting)
36 string ID 333
	Source string description type: paragraph
	English 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`]:
	Chinese (Simplified Han script) ↹ ↵ 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/5210 · 521 Needs editing (Needs rewriting)
37 string ID 343
	Source string description type: paragraph
	English Note that a `spawn` function itself has a completion signature, but we're ignoring it's result in the example by using `asio::detached`.
	Chinese (Simplified Han script) ↹ ↵ 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/1360 · 136 Needs editing (Needs rewriting)
38 string ID 348
	Source string description type: paragraph
	English 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:
	Chinese (Simplified Han script) ↹ ↵ 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/8700 · 870 Needs editing (Needs rewriting)
39 string ID 363
	Source string description type: paragraph
	English 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.
	Chinese (Simplified Han script) ↹ ↵ 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/3750 · 375 Needs editing (Needs rewriting)
40 string ID 371
	Source string description type: heading
	English Using Networking
	Chinese (Simplified Han script) ↹ ↵ NBS … 「 」 『 』 ﹙-﹚ ‐ – — Using Networking 16/160 · 16 Needs editing (Needs rewriting)
41 string ID 373
	Source string description type: paragraph
	English 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:
	Chinese (Simplified Han script) ↹ ↵ 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/2260 · 226 Needs editing (Needs rewriting)
42 string ID 380
	Source string description type: paragraph
	English Throughout this documentation identifiers with the following names have special meaning:
	Chinese (Simplified Han script) ↹ ↵ NBS … 「 」 『 』 ﹙-﹚ ‐ – — Throughout this documentation identifiers with the following names have special meaning: 88/880 · 88 Needs editing (Needs rewriting)
43 string ID 383
	Source string description type: table title
	English Global Variables
	Chinese (Simplified Han script) ↹ ↵ NBS … 「 」 『 』 ﹙-﹚ ‐ – — Global Variables 16/160 · 16 Needs editing (Needs rewriting)
44 string ID 383
	Source string description type: table cell
	English Name
	Chinese (Simplified Han script) ↹ ↵ NBS … 「 」 『 』 ﹙-﹚ ‐ – — Name 4/100 · 4 Needs editing (Needs rewriting)
45 string ID 383
	Source string description type: table cell
	English Description
	Chinese (Simplified Han script) ↹ ↵ NBS … 「 」 『 』 ﹙-﹚ ‐ – — Description 11/110 · 11 Needs editing (Needs rewriting)
46 string ID 383
	Source string description type: table cell
	English [@boost:/doc/html/boost_asio/reference/io_context.html [*`ioc`]]
	Chinese (Simplified Han script) ↹ ↵ NBS … 「 」 『 』 ﹙-﹚ ‐ – — [@boost:/doc/html/boost_asio/reference/io_context.html [*`ioc`]] 64/640 · 64 Needs editing (Needs rewriting)
47 string ID 383
	Source string description type: table cell
	English A variable of type __io_context__ which is running on one separate thread, and upon which an __executor_work_guard__ object has been constructed.
	Chinese (Simplified Han script) ↹ ↵ NBS … 「 」 『 』 ﹙-﹚ ‐ – — A variable of type __io_context__ which is running on one separate thread, and upon which an __executor_work_guard__ object has been constructed. 145/1450 · 145 Needs editing (Needs rewriting)