User avatar Bstran

Translation changed
This stream can be used for synchronous and asynchronous reading and writing. It allows timeouts to be set on logical operations, and can have an executor associated with the stream which is used to invoke completion handlers. This lets you set a strand on the stream once, which is then used for all asynchronous operations automatically.
This stream can be used for synchronous and asynchronous reading and writing. It allows timeouts to be set on logical operations, and can have an executor associated with the stream which is used to invoke completion handlers. This lets you set a strand on the stream once, which is then used for all asynchronous operations automatically.该流支持同步和异步读写操作。它允许为逻辑操作设置超时，也可以为流关联一个执行器，用来调用完成处理器。这样就可以对流只设置一次串行器，之后所有异步操作都会自动使用该串行器。
06/12/2026
User avatar Bstran

Translation changed
[link beast.ref.boost__beast__basic_stream `basic_stream`] [link beast.ref.boost__beast__tcp_stream `tcp_stream`]
[link beast.ref.boost__beast__basic_stream `basic_stream`] [link beast.ref.boost__beast__tcp_stream `tcp_stream`]
06/12/2026
User avatar Bstran

Translation changed
Description
Description描述
06/12/2026
User avatar Bstran

Translation changed
Name
Name名称
06/12/2026
User avatar Bstran

Translation changed
Layered Stream Algorithms and Types
Layered Stream Algorithms and Types分层流算法与类型
06/12/2026
User avatar Bstran

Translation changed
Beast comes with several layered stream wrappers, as well as facilities for authoring and working with layered streams:
Beast comes with several layered stream wrappers, as well as facilities for authoring and working with layered streams:提供多个分层流包装器，以及用于编写和操作分层流的工具：
06/12/2026
User avatar Bstran

Translation changed
Higher level abstractions can be developed in this fashion by nesting stream layers to arbitrary degree. The stack of stream layers effectively forms a compile-time singly linked list. The object at the end of this list is called the ['lowest layer], and is special from the others because it typically represents the underlying socket.
Higher level abstractions can be developed in this fashion by nesting stream layers to arbitrary degree. The stack of stream layers effectively forms a compile-time singly linked list. The object at the end of this list is called the ['lowest layer], and is special from the others because it typically represents the underlying socket.通过任意层级的嵌套，可以按这种方式构建更高层次的抽象。这些嵌套的流层在编译期形成一个单链表。链表末尾的对象称为 [最底层]，它与其他层有所不同，因为最底层通常代表底层的套接字。
06/12/2026
User avatar Bstran

Translation changed
If a Secure WebSockets stream is desired, this is accomplished simply by changing the type of the next layer and adjusting the constructor arguments to match:
If a Secure WebSockets stream is desired, this is accomplished simply by changing the type of the next layer and adjusting the constructor arguments to match:如果需要安全 WebSocket 流，只需改变下一层的类型并调整构造参数即可实现：
06/12/2026
User avatar Bstran

Translation changed
Objects using this design pattern are referred to in networking as "a stack of stream layers". In Beast we use the term ['layered stream], although the property of having a next layer is not exclusive to streams. As with the SSL stream, __websocket_stream__ is a class template parameterized on a next layer object. This declares a websocket stream which uses a regular TCP/IP socket as the next layer:
Objects using this design pattern are referred to in networking as "a stack of stream layers". In Beast we use the term ['layered stream], although the property of having a next layer is not exclusive to streams. As with the SSL stream, __websocket_stream__ is a class template parameterized on a next layer object. This declares a webs采用这种设计模式的对象在网络库中被称为“流层堆栈”。在 Beast 中，我们使用术语 [分层流]，但拥有下一层这一特性并非流所独有。与 SSL 流类似，__websocket_stream__ 也是一个以下一层对象为模板参数的类模板。以下声明一个 WebSocket stream which uses a regular TCP/IP socket as the next layer:流，该流使用普通的 TCP/IP 套接字作为其下一层：
06/12/2026
User avatar Bstran

Translation changed
Networking's __ssl_stream__ is a class template meeting the requirements of both synchronous and asynchronous read and write streams, implemented in terms of a "next layer" object whose type is determined by a class template parameter. The SSL stream constructs an instance of the next layer object internally, while allowing external access through the observer `net::ssl::stream::next_layer()`. This declares an SSL stream which uses a regular TCP/IP socket as the next layer:
Networking's网络库中的 __ssl_stream__ is a class template meeting the requirements of both synchronous and asynchronous read and write streams, implemented in terms of a "next layer" object whose type is determined by a class template parameter. The SSL stream constructs an instance of the next layer object internally, while allowing external access through the observer `net::ssl::stream::next_layer()`. This declares an SSL stream which uses a regular TCP/IP socket as the next layer:是一个类模板，它同时满足同步流与异步流的读写要求，其实现基于一个“下一层”对象，该对象的类型由类模板参数决定。SSL 流在内部构造下一层对象的实例，同时通过观察器 `net::ssl::stream::next_layer()` 提供外部访问。以下声明一个 SSL 流，该流使用普通的 TCP/IP 套接字作为其下一层：
06/12/2026
User avatar Bstran

Translation changed
Layered Streams
Layered Streams分层流类型
06/12/2026
User avatar Bstran

Contributor joined
Contributor joined 06/12/2026
User avatar Bstran

Translation completed
Translation completed 06/12/2026
User avatar Bstran

Translation changed
To use our new policy we declare an instance of the stream, and then use it with stream algorithms as usual. At any time, we can determine the current read or write rates by calling into the policy.
To use our new policy we declare an instance of the stream, and then use it with stream algorithms as usual. At any time, we can determine the current read or write rates by calling into the policy.要使用新策略，我们声明一个流实例，然后像往常一样配合流算法使用。任何时候都可以通过调用策略中的方法来获取当前的读速率或写速率。
06/12/2026
User avatar Bstran

Translation changed
Then we define our rate policy object. We friend the type [link beast.ref.boost__beast__rate_policy_access `rate_policy_access`] to allow our implementation to be private, but still allow the `basic_stream` access to call the required functions. This lets us avoid having to write a cumbersome friend declaration for the `basic_stream` class template. Public members of rate policy objects become part of the stream object's interface, through a call to `rate_policy`.
Then we define our rate policy object. We friend the type接着定义速率策略对象。我们让类型 [link beast.ref.boost__beast__rate_policy_access `rate_policy_access`] to allow our implementation to be private, but still allow the `basic_stream` access to call the required functions. This lets us avoid having to write a cumbersome friend declaration for the `basic_stream` class template. Public members of rate policy objects become part of the stream object's interface, through a call to成为友元，这样可以将实现设为私有，同时仍然允许 `basic_stream` 访问所需函数。这种方式可以避免为 `basic_stream` 类模板编写繁琐的友元声明。速率策略对象的公有成员会通过调用 `rate_policy`. 成为流对象接口的一部分。
06/12/2026
User avatar Bstran

Translation changed
More sophisticated rate policies can be implemented as user-defined types which meet the requirements of __RatePolicy__. Here, we develop a rate policy that measures the instantaneous throughput of reads and writes. First we write a small utility class that applies an exponential smoothing function to a series of discrete rate samples, to calculate instantaneous throughput.
More sophisticated rate policies can be implemented as user-defined types which meet the requirements of __RatePolicy__. Here, we develop a rate policy that measures the instantaneous throughput of reads and writes. First we write a small utility class that applies an exponential smoothing function to a series of discrete rate samples, to calculate instantaneous throughput.更复杂的速率策略可以作为用户自定义类型来实现，只需满足 __RatePolicy__ 概念的要求即可。下面我们开发一个速率策略，用于测量读写操作的瞬时吞吐量。首先编写一个辅助类，该类对一系列离散的速率采样值应用指数平滑函数，以计算瞬时吞吐量。
06/12/2026
User avatar Bstran

Translation changed
The [link beast.ref.boost__beast__basic_stream `basic_stream`] class template supports an additional `RatePolicy` template parameter. Objects of this type must meet the requirements of __RatePolicy__. They are used to implement rate limiting or bandwidth management. The default policy for `basic_stream` and `tcp_stream` is [link beast.ref.boost__beast__unlimited_rate_policy `unlimited_rate_policy`], which places no limits on reading and writing. The library comes with the [link beast.ref.boost__beast__simple_rate_policy `simple_rate_policy`], allowing for independent control of read and write limits expressed in terms of bytes per second. The follow code creates an instance of the basic stream with a simple rate policy, and sets the read and write limits:
The [link beast.ref.boost__beast__basic_stream `basic_stream`] class template supports an additional `RatePolicy` template parameter. Objects of this type must meet the requirements of __RatePolicy__. They are used to implement rate limiting or bandwidth management. The default policy for 类模板支持额外的 `RatePolicy` 模板参数。该类型的对象必须满足 __RatePolicy__ 概念的要求，用于实现速率限制或带宽管理。`basic_stream` and和 `tcp_stream` is的默认策略为 [link beast.ref.boost__beast__unlimited_rate_policy `unlimited_rate_policy`], which places no limits on reading and writing. The library comes with the [link beast.ref.boost__beast__simple_rate_policy `simple_rate_policy`], allowing for independent control of read and write limits expressed in terms of bytes per second. The follow code creates an instance of the，该策略对读写操作不施加任何限制。该库提供 [link beast.ref.boost__beast__simple_rate_policy `simple_rate_policy`] 策略，支持以字节/秒为单位分别控制读写速率限制。以下代码创建一个使用简单速率策略的 basic _stream with a simple rate policy, and sets the read and write limits:实例，并设置读写限制：
06/12/2026
User avatar Bstran

Translation changed
Rate Limiting __example__
Rate Limiting __example速率限制 __示例__
06/12/2026
User avatar Bstran

Translation changed
The following code establishes an encrypted connection, writes an HTTP request, reads the HTTP response, and closes the connection gracefully. If these operations take longer than 30 seconds total, a timeout occurs. This code is intended to show how `tcp_stream` can be used to enable timeouts across unmodified stream algorithms which were not originally written to support timing out, and how a blocking algorithm may be written from asynchronous intermediate operations.
The following code establishes an encrypted connection, writes an HTTP request, reads the HTTP response, and closes the connection gracefully. If these operations take longer than 30 seconds total, a timeout occurs. This code is intended to show how `tcp_stream` can be used to enable timeouts across unmodified stream algorithms which were not originally written to support timing out, and how a blocking algorithm may be written from asynchronous intermediate operations.以下代码用于建立加密连接、发送 HTTP 请求、接收 HTTP 响应，并正常关闭连接。如果这些操作的总耗时超过 30 秒，就会触发超时。这段代码主要展示两件事：一是如何用 `tcp_stream` 为原本不支持超时的流算法添加上超时功能，二是如何通过异步中间操作来构建一个阻塞算法。
06/12/2026
User avatar Bstran

Translation changed
It is important to note that all of the examples thus far which perform reads and writes with a timeout, make use of the existing networking stream algorithms. As these algorithms are written generically to work with any object meeting the stream requirements, they transparently support timeouts when used with `tcp_stream`. This can be used to enable timeouts for stream wrappers that do not currently support timeouts.
It is important to note that all of the examples thus far which perform reads and writes with a timeout, make use of the existing networking stream algorithms. As these algorithms are written generically to work with any object meeting the stream requirements, they transparently support timeouts when used with `tcp_stream`. This can be used to enable timeouts for s值得注意的是，目前所有涉及超时读写的示例，均使用了现有的网络流算法。由于这些算法采用泛型编写，适用于任何满足流（Stream）要求的对象，因此在与‘tcp_stream’配合使用时，能够透明地支持超时机制。借助这一特性，还可以为当前尚不支持超时的流包装器（Stream wWrappers that do not currently support timeouts.）启用超时功能。
06/12/2026

Search