boostorg/beast
1
0
Fork 1
mirror of https://github.com/boostorg/beast.git synced 2025-07-29 20:37:31 +02:00
Code Issues Packages Projects Releases Wiki Activity

Update doc/ for docca

Browse Source
This commit is contained in:
Vinnie Falco
2017-06-14 12:03:19 -07:00
parent 9920d4526a
commit 164569157a
42 changed files with 371 additions and 2144 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
CHANGELOG.md
View File

@ -2,6 +2,7 @@ Version 57:
* Fix message.hpp javadocs
* Fix warning in basic_parser.cpp
* Integrate docca for documentation and tidy
--------------------------------------------------------------------------------

28
doc/0_main.qbk
View File

@ -24,6 +24,8 @@
[template indexterm2[term1 term2] '''<indexterm><primary>'''[term1]'''</primary><secondary>'''[term2]'''</secondary></indexterm>''']
[template repo_file[path] '''<ulink url="https://github.com/vinniefalco/Beast/blob/master/'''[path]'''">'''[path]'''</ulink>''']
[template include_file[path][^<'''<ulink url="https://github.com/vinniefalco/Beast/blob/master/include/'''[path]'''">'''[path]'''</ulink>'''>]]
[def __N3747__ [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3747.pdf [*N3747]]]
[def __N4588__ [@http://cplusplus.github.io/networking-ts/draft.pdf [*N4588]]]
[def __rfc6455__ [@https://tools.ietf.org/html/rfc6455 rfc6455]]
@ -60,19 +62,19 @@
[def __Stream__ [link beast.concept.streams [*Stream]]]
[def __SyncStream__ [link beast.concept.streams.SyncStream [*SyncStream]]]
[def __basic_fields__ [link beast.ref.http__basic_fields `basic_fields`]]
[def __basic_multi_buffer__ [link beast.ref.basic_multi_buffer `basic_multi_buffer`]]
[def __basic_parser__ [link beast.ref.http__basic_parser `basic_parser`]]
[def __buffer_body__ [link beast.ref.http__buffer_body `buffer_body`]]
[def __fields__ [link beast.ref.http__fields `fields`]]
[def __flat_buffer__ [link beast.ref.flat_buffer `flat_buffer`]]
[def __header__ [link beast.ref.http__header `header`]]
[def __message__ [link beast.ref.http__message `message`]]
[def __multi_buffer__ [link beast.ref.multi_buffer `multi_buffer`]]
[def __parser__ [link beast.ref.http__parser `parser`]]
[def __serializer__ [link beast.ref.http__serializer `serializer`]]
[def __static_buffer__ [link beast.ref.static_buffer `static_buffer`]]
[def __static_buffer_n__ [link beast.ref.static_buffer_n `static_buffer_n`]]
[def __basic_fields__ [link beast.ref.beast__http__basic_fields `basic_fields`]]
[def __basic_multi_buffer__ [link beast.ref.beast__basic_multi_buffer `basic_multi_buffer`]]
[def __basic_parser__ [link beast.ref.beast__http__basic_parser `basic_parser`]]
[def __buffer_body__ [link beast.ref.beast__http__buffer_body `buffer_body`]]
[def __fields__ [link beast.ref.beast__http__fields `fields`]]
[def __flat_buffer__ [link beast.ref.beast__flat_buffer `flat_buffer`]]
[def __header__ [link beast.ref.beast__http__header `header`]]
[def __message__ [link beast.ref.beast__http__message `message`]]
[def __multi_buffer__ [link beast.ref.beast__multi_buffer `multi_buffer`]]
[def __parser__ [link beast.ref.beast__http__parser `parser`]]
[def __serializer__ [link beast.ref.beast__http__serializer `serializer`]]
[def __static_buffer__ [link beast.ref.beast__static_buffer `static_buffer`]]
[def __static_buffer_n__ [link beast.ref.beast__static_buffer_n `static_buffer_n`]]
[import ../examples/file_body.hpp]
[import ../examples/http_example.cpp]

4
doc/3_1_asio.qbk
View File

@ -44,10 +44,10 @@ special meaning:
which is already connected and has handshaked with a remote host.
]]
[[
[link beast.ref.websocket__stream [*`ws`]]
[link beast.ref.beast__websocket__stream [*`ws`]]
][
A variable of type
[link beast.ref.websocket__stream `websocket::stream<boost::asio::ip::tcp::socket>`]
[link beast.ref.beast__websocket__stream `websocket::stream<boost::asio::ip::tcp::socket>`]
which is already connected with a remote host.
]]
]

18
doc/3_2_streams.qbk
View File

@ -60,51 +60,51 @@ checks helps provide more concise errors during compilation:
[table Stream Type Checks
[[Name][Description]]
[[
[link beast.ref.get_lowest_layer `get_lowest_layer`]
[link beast.ref.beast__get_lowest_layer `get_lowest_layer`]
][
Returns `T::lowest_layer_type` if it exists, else returns `T`.
]]
[[
[link beast.ref.has_get_io_service `has_get_io_service`]
[link beast.ref.beast__has_get_io_service `has_get_io_service`]
][
Determine if the `get_io_service` member function is present,
and returns an __io_service__.
]]
[[
[link beast.ref.is_async_read_stream `is_async_read_stream`]
[link beast.ref.beast__is_async_read_stream `is_async_read_stream`]
][
Determine if a type meets the requirements of __AsyncReadStream__.
]]
[[
[link beast.ref.is_async_stream `is_async_stream`]
[link beast.ref.beast__is_async_stream `is_async_stream`]
][
Determine if a type meets the requirements of both __AsyncReadStream__
and __AsyncWriteStream__.
]]
[[
[link beast.ref.is_async_write_stream `is_async_write_stream`]
[link beast.ref.beast__is_async_write_stream `is_async_write_stream`]
][
Determine if a type meets the requirements of __AsyncWriteStream__.
]]
[[
[link beast.ref.is_completion_handler `is_completion_handler`]
[link beast.ref.beast__is_completion_handler `is_completion_handler`]
][
Determine if a type meets the requirements of __CompletionHandler__,
and is callable with a specified signature.
]]
[[
[link beast.ref.is_sync_read_stream `is_sync_read_stream`]
[link beast.ref.beast__is_sync_read_stream `is_sync_read_stream`]
][
Determine if a type meets the requirements of __SyncReadStream__.
]]
[[
[link beast.ref.is_sync_stream `is_sync_stream`]
[link beast.ref.beast__is_sync_stream `is_sync_stream`]
][
Determine if a type meets the requirements of both __SyncReadStream__
and __SyncWriteStream__.
]]
[[
[link beast.ref.is_sync_write_stream `is_sync_write_stream`]
[link beast.ref.beast__is_sync_write_stream `is_sync_write_stream`]
][
Determine if a type meets the requirements of __SyncWriteStream__.
]]

40
doc/3_3_buffers.qbk
View File

@ -19,17 +19,17 @@ These metafunctions check if types match the buffer concepts:
[table Buffer Type Checks
[[Name][Description]]
[[
[link beast.ref.is_dynamic_buffer `is_dynamic_buffer`]
[link beast.ref.beast__is_dynamic_buffer `is_dynamic_buffer`]
][
Determine if a type meets the requirements of __DynamicBuffer__.
]]
[[
[link beast.ref.is_const_buffer_sequence `is_const_buffer_sequence`]
[link beast.ref.beast__is_const_buffer_sequence `is_const_buffer_sequence`]
][
Determine if a type meets the requirements of __ConstBufferSequence__.
]]
[[
[link beast.ref.is_mutable_buffer_sequence `is_mutable_buffer_sequence`]
[link beast.ref.beast__is_mutable_buffer_sequence `is_mutable_buffer_sequence`]
][
Determine if a type meets the requirements of __MutableBufferSequence__.
]]
@ -40,7 +40,7 @@ To suit various needs, several implementation of dynamic buffer are available:
[table Dynamic Buffer Implementations
[[Name][Description]]
[[
[link beast.ref.buffers_adapter `buffers_adapter`]
[link beast.ref.beast__buffers_adapter `buffers_adapter`]
][
This wrapper adapts any __MutableBufferSequence__ into a
__DynamicBuffer__ with an upper limit on the total size of the input and
@ -48,7 +48,7 @@ To suit various needs, several implementation of dynamic buffer are available:
The implementation does not perform heap allocations.
]]
[[
[link beast.ref.drain_buffer `drain_buffer`]
[link beast.ref.beast__drain_buffer `drain_buffer`]
][
A drain buffer has a small internal buffer and maximum size that
uses no dynamic allocation. It always has a size of zero, and
@ -57,8 +57,8 @@ To suit various needs, several implementation of dynamic buffer are available:
efficiently discard the data.
]]
[[
[link beast.ref.flat_buffer `flat_buffer`]
[link beast.ref.basic_flat_buffer `basic_flat_buffer`]
[link beast.ref.beast__flat_buffer `flat_buffer`]
[link beast.ref.beast__basic_flat_buffer `basic_flat_buffer`]
][
Guarantees that input and output areas are buffer sequences with
length one. Upon construction an optional upper limit to the total
@ -66,8 +66,8 @@ To suit various needs, several implementation of dynamic buffer are available:
supports the standard allocator model.
]]
[[
[link beast.ref.multi_buffer `multi_buffer`]
[link beast.ref.basic_multi_buffer `basic_multi_buffer`]
[link beast.ref.beast__multi_buffer `multi_buffer`]
[link beast.ref.beast__basic_multi_buffer `basic_multi_buffer`]
][
Uses a sequence of one or more character arrays of varying sizes.
Additional character array objects are appended to the sequence to
@ -75,8 +75,8 @@ To suit various needs, several implementation of dynamic buffer are available:
container supports the standard allocator model.
]]
[[
[link beast.ref.static_buffer `static_buffer`]
[link beast.ref.static_buffer `static_buffer_n`]
[link beast.ref.beast__static_buffer `static_buffer`]
[link beast.ref.beast__static_buffer `static_buffer_n`]
][
Provides the facilities of a dynamic buffer, subject to an upper
limit placed on the total size of the input and output areas defined
@ -97,7 +97,7 @@ transferred.
[table Buffer Algorithms
[[Name][Description]]
[[
[link beast.ref.buffer_cat `buffer_cat`]
[link beast.ref.beast__buffer_cat `buffer_cat`]
][
This functions returns a new buffer sequence which, when iterated,
traverses the sequence which would be formed if all of the input buffer
@ -106,27 +106,27 @@ transferred.
expensive system calls.
]]
[[
[link beast.ref.buffer_cat_view `buffer_cat_view`]
[link beast.ref.beast__buffer_cat_view `buffer_cat_view`]
][
This class represents the buffer sequence formed by concatenating
two or more buffer sequences. This is type of object returned by
[link beast.ref.buffer_cat `buffer_cat`].
[link beast.ref.beast__buffer_cat `buffer_cat`].
]]
[[
[link beast.ref.buffer_prefix `buffer_prefix`]
[link beast.ref.beast__buffer_prefix `buffer_prefix`]
][
This function returns a new buffer or buffer sequence which represents
a prefix of the original buffers.
]]
[[
[link beast.ref.buffer_prefix_view `buffer_prefix_view`]
[link beast.ref.beast__buffer_prefix_view `buffer_prefix_view`]
][
This class represents the buffer sequence formed from a prefix of
an existing buffer sequence. This is the type of buffer returned by
[link beast.ref.buffer_prefix `buffer_prefix`].
[link beast.ref.beast__buffer_prefix `buffer_prefix`].
]]
[[
[link beast.ref.consuming_buffers `consuming_buffers`]
[link beast.ref.beast__consuming_buffers `consuming_buffers`]
][
This class wraps the underlying memory of an existing buffer sequence
and presents a suffix of the original sequence. The length of the suffix
@ -141,13 +141,13 @@ output streams.
[table Buffer Output Streams
[[Name][Description]]
[[
[link beast.ref.buffers `buffers`]
[link beast.ref.beast__buffers `buffers`]
][
This function wraps a __ConstBufferSequence__ so it may be
used with `operator<<` and `std::ostream`.
]]
[[
[link beast.ref.ostream `ostream`]
[link beast.ref.beast__ostream `ostream`]
][
This function returns a `std::ostream` which wraps a dynamic buffer.
Characters sent to the stream using `operator<<` is stored in the

12
doc/3_4_composed.qbk
View File

@ -42,7 +42,7 @@ available:
[table Asynchronous Helpers
[[Name][Description]]
[[
[link beast.ref.async_completion `async_completion`]
[link beast.ref.beast__async_completion `async_completion`]
][
This class aggregates the completion handler customization point and
the asynchronous initiation function return value customization point
@ -51,7 +51,7 @@ available:
implement an initiation function using the Extensible Model.
]]
[[
[link beast.ref.async_return_type `async_return_type`]
[link beast.ref.beast__async_return_type `async_return_type`]
][
This template alias determines the return value of an asynchronous
initiation function given the completion token and signature. It is used
@ -59,7 +59,7 @@ available:
Extensible Asynchronous Model.
]]
[[
[link beast.ref.bind_handler `bind_handler`]
[link beast.ref.beast__bind_handler `bind_handler`]
][
This function returns a new, nullary completion handler which when
invoked with no arguments invokes the original completion handler with a
@ -70,7 +70,7 @@ available:
]]
[[
[link beast.ref.handler_alloc `handler_alloc`]
[link beast.ref.beast__handler_alloc `handler_alloc`]
][
This class meets the requirements of [*Allocator], and uses any custom
memory allocation and deallocation hooks associated with a given handler.
@ -79,7 +79,7 @@ available:
must be freed before the final completion handler is invoked.
]]
[[
[link beast.ref.handler_ptr `handler_ptr`]
[link beast.ref.beast__handler_ptr `handler_ptr`]
][
This is a smart pointer container used to manage the internal state of a
composed operation. It is useful when the state is non trivial. For example
@ -91,7 +91,7 @@ available:
optimizations transparently.
]]
[[
[link beast.ref.handler_type `handler_type`]
[link beast.ref.beast__handler_type `handler_type`]
][
This template alias converts a completion token and signature to the
correct completion handler type. It is used in the implementation of

24
doc/5_00_http.qbk
View File

@ -31,12 +31,12 @@ format using __Asio__. Specifically, the library provides:
[Stream Reading]
[
The functions
[link beast.ref.http__read `read`],
[link beast.ref.http__read_header `read_header`],
[link beast.ref.http__read_some `read_some`],
[link beast.ref.http__async_read `async_read`],
[link beast.ref.http__async_read_header `async_read_header`], and
[link beast.ref.http__async_read_some `async_read_some`]
[link beast.ref.beast__http__read `read`],
[link beast.ref.beast__http__read_header `read_header`],
[link beast.ref.beast__http__read_some `read_some`],
[link beast.ref.beast__http__async_read `async_read`],
[link beast.ref.beast__http__async_read_header `async_read_header`], and
[link beast.ref.beast__http__async_read_some `async_read_some`]
read HTTP/1 message data from a
[link beast.concept.streams stream].
]
@ -44,12 +44,12 @@ format using __Asio__. Specifically, the library provides:
[Stream Writing]
[
The functions
[link beast.ref.http__write `write`],
[link beast.ref.http__write_header `write_header`],
[link beast.ref.http__write_some `write_some`],
[link beast.ref.http__async_write `async_write`],
[link beast.ref.http__async_write_header `async_write_header`], and
[link beast.ref.http__async_write_some `async_write_some`]
[link beast.ref.beast__http__write `write`],
[link beast.ref.beast__http__write_header `write_header`],
[link beast.ref.beast__http__write_some `write_some`],
[link beast.ref.beast__http__async_write `async_write`],
[link beast.ref.beast__http__async_write_header `async_write_header`], and
[link beast.ref.beast__http__async_write_some `async_write_some`]
write HTTP/1 message data to a
[link beast.concept.streams stream].
]

26
doc/5_02_message.qbk
View File

@ -57,8 +57,8 @@ each possible value of `isRequest`:
[$images/message.png [width 730px] [height 410px]]
The template type aliases
[link beast.ref.http__request `request`] and
[link beast.ref.http__response `response`]
[link beast.ref.beast__http__request `request`] and
[link beast.ref.beast__http__response `response`]
are provided for brevity. They specify the common default of `fields`.
```
@ -74,7 +74,7 @@ using response = message<false, Body, Fields>;
[heading:body Body Types]
Beast defines the __Body__ concept, which determines both the type of
the [link beast.ref.http__message.body `message::body`] member
the [link beast.ref.beast__http__message.body `message::body`] member
(as seen in the diagram above) and may also include algorithms for
transferring buffers in and out. These algorithms are used during
parsing and serialization. These body types are available within the
@ -84,26 +84,26 @@ __Body__ requirements:
[table
[[Name][Description]]
[[
[link beast.ref.http__buffer_body `buffer_body`]
[link beast.ref.beast__http__buffer_body `buffer_body`]
][
A body whose
[link beast.ref.http__buffer_body__value_type `value_type`]
[link beast.ref.beast__http__buffer_body__value_type `value_type`]
holds a raw pointer and size to a caller-provided buffer.
This allows for serialization of body data coming from
external sources, and incremental parsing of message body
content using a fixed size buffer.
]]
[[
[link beast.ref.http__dynamic_body `dynamic_body`]
[link beast.ref.beast__http__dynamic_body `dynamic_body`]
[link beast.ref.http__basic_dynamic_body `basic_dynamic_body`]
[link beast.ref.beast__http__basic_dynamic_body `basic_dynamic_body`]
][
A body whose `value_type` is a __DynamicBuffer__. It inherits
the insertion complexity of the underlying choice of dynamic buffer.
Messages with this body type may be serialized and parsed.
]]
[[
[link beast.ref.http__empty_body `empty_body`]
[link beast.ref.beast__http__empty_body `empty_body`]
][
A special body with an empty `value_type` indicating that the
message has no body. Messages with this body may be serialized
@ -111,7 +111,7 @@ __Body__ requirements:
with this body will generate a unique error.
]]
[[
[link beast.ref.http__string_body `string_body`]
[link beast.ref.beast__http__string_body `string_body`]
][
A body whose `value_type` is `std::string`. Insertion complexity
is amortized constant time, while capacity grows geometrically.
@ -119,9 +119,9 @@ __Body__ requirements:
is the type of body used in the examples.
]]
[[
[link beast.ref.http__string_view_body `string_view_body`]
[link beast.ref.beast__http__string_view_body `string_view_body`]
][
A body whose `value_type` is [link beast.ref.string_view `string_view`].
A body whose `value_type` is [link beast.ref.beast__string_view `string_view`].
Messages with this body type may be serialized only, and the caller
is responsible for managing the lifetime of the buffer pointed to
by the string view.
@ -151,7 +151,7 @@ request.
Here we create an HTTP response indicating success. Note that this
message has a body. The function
[link beast.ref.http__message.prepare prepare]
[link beast.ref.beast__http__message.prepare prepare]
automatically sets the Content-Length or Transfer-Encoding field
depending on the content and type of the `body` member. The use
of prepare is optional; these fields may also be set explicitly.
@ -175,6 +175,6 @@ The implementation will automatically fill in the obsolete
[@https://tools.ietf.org/html/rfc7230#section-3.1.2 reason-phrase]
from the status code when serializing a message. Or it may
be set directly using
[link beast.ref.http__header.reason.overload2 `header::reason`].
[link beast.ref.beast__http__header.reason.overload2 `header::reason`].
[endsect]

14
doc/5_03_streams.qbk
View File

@ -14,22 +14,22 @@ the message-oriented stream interface:
[table Message Stream Operations
[[Name][Description]]
[[
[link beast.ref.http__read.overload3 [*read]]
[link beast.ref.beast__http__read.overload3 [*read]]
][
Read a __message__ from a __SyncReadStream__.
]]
[[
[link beast.ref.http__async_read.overload2 [*async_read]]
[link beast.ref.beast__http__async_read.overload2 [*async_read]]
][
Read a __message__ from an __AsyncReadStream__.
]]
[[
[link beast.ref.http__write.overload1 [*write]]
[link beast.ref.beast__http__write.overload1 [*write]]
][
Write a __message__ to a __SyncWriteStream__.
]]
[[
[link beast.ref.http__async_write [*async_write]]
[link beast.ref.beast__http__async_write [*async_write]]
][
Write a __message__ to an __AsyncWriteStream__.
]]
@ -37,7 +37,7 @@ the message-oriented stream interface:
All synchronous stream operations come in two varieties. One which throws
an exception upon error, and another which accepts as the last parameter an
argument of type [link beast.ref.error_code `error_code&`]. If an error
argument of type [link beast.ref.beast__error_code `error_code&`]. If an error
occurs this argument will be set to contain the error code.
@ -77,7 +77,7 @@ code indicating the result is printed:
If a read stream algorithm cannot complete its operation without exceeding
the maximum specified size of the dynamic buffer provided, the error
[link beast.ref.http__error `buffer_overflow`]
[link beast.ref.beast__http__error `buffer_overflow`]
is returned. This may be used to impose a limit on the maximum size of an
HTTP message header for protection from buffer overflow attacks. The following
code will generate an error:
@ -92,7 +92,7 @@ A set of free functions allow serialization of an entire HTTP message to
a stream. If a response has no declared content length, and no chunked
transfer encoding, the end of the message is indicated by the server closing
the connection. When sending such a response, Beast will return the
[link beast.ref.http__error `error::end_of_stream`]
[link beast.ref.beast__http__error `error::end_of_stream`]
from the write algorithm to indicate
to the caller that the connection should be closed. This example
constructs and sends a response whose body length is determined by

16
doc/5_04_serializer_streams.qbk
View File

@ -30,7 +30,7 @@ This code creates an HTTP response and the corresponding serializer:
[http_snippet_10]
The function
[link beast.ref.http__make_serializer `make_serializer`]
[link beast.ref.beast__http__make_serializer `make_serializer`]
is provided to simplify creation of variables:
[http_snippet_11]
@ -40,32 +40,32 @@ The stream operations which work on serializers are:
[table Serializer Stream Operations
[[Name][Description]]
[[
[link beast.ref.http__write.overload1 [*write]]
[link beast.ref.beast__http__write.overload1 [*write]]
][
Send everything in a __serializer__ to a __SyncWriteStream__.
]]
[[
[link beast.ref.http__async_write.overload1 [*async_write]]
[link beast.ref.beast__http__async_write.overload1 [*async_write]]
][
Send everything in a __serializer__ asynchronously to an __AsyncWriteStream__.
]]
[[
[link beast.ref.http__write_header.overload1 [*write_header]]
[link beast.ref.beast__http__write_header.overload1 [*write_header]]
][
Send only the header from a __serializer__ to a __SyncWriteStream__.
]]
[[
[link beast.ref.http__async_write_header [*async_write_header]]
[link beast.ref.beast__http__async_write_header [*async_write_header]]
][
Send only the header from a __serializer__ asynchronously to an __AsyncWriteStream__.
]]
[[
[link beast.ref.http__write_some.overload1 [*write_some]]
[link beast.ref.beast__http__write_some.overload1 [*write_some]]
][
Send part of a __serializer__ to a __SyncWriteStream__.
]]
[[
[link beast.ref.http__async_write_some [*async_write_some]]
[link beast.ref.beast__http__async_write_some [*async_write_some]]
][
Send part of a __serializer__ asynchronously to an __AsyncWriteStream__.
]]
@ -90,7 +90,7 @@ and trailers may instantiate the serializer with a "chunk decorator" type,
and pass an instance of the type upon construction. This decorator is
a function object which, when invoked with a __ConstBufferSequence__,
returns a
[link beast.ref.string_view `string_view`] containing either the extensions
[link beast.ref.beast__string_view `string_view`] containing either the extensions
or the trailer. For chunks containing body data, the passed buffer will
contain one or more corresponding body octets. The decorator may use this
information as needed. For example, to compute a digest on the data and

20
doc/5_05_parser_streams.qbk
View File

@ -40,7 +40,7 @@ __message__ objects; user-defined parsers are also possible:
```
]]
[[
[link beast.ref.http__request_parser `request_parser`]
[link beast.ref.beast__http__request_parser `request_parser`]
][
```
/// An HTTP/1 parser for producing a request message.
@ -49,7 +49,7 @@ __message__ objects; user-defined parsers are also possible:
```
]]
[[
[link beast.ref.http__response_parser `response_parser`]
[link beast.ref.beast__http__response_parser `response_parser`]
][
```
/// An HTTP/1 parser for producing a response message.
@ -69,32 +69,32 @@ The stream operations which work on parsers are:
[table Parser Stream Operations
[[Name][Description]]
[[
[link beast.ref.http__read.overload1 [*read]]
[link beast.ref.beast__http__read.overload1 [*read]]
][
Read everything into a parser from a __SyncWriteStream__.
]]
[[
[link beast.ref.http__async_read.overload1 [*async_read]]
[link beast.ref.beast__http__async_read.overload1 [*async_read]]
][
Read everything into a parser asynchronously from an __AsyncWriteStream__.
]]
[[
[link beast.ref.http__read_header.overload1 [*read_header]]
[link beast.ref.beast__http__read_header.overload1 [*read_header]]
][
Read only the header octets into a parser from a __SyncWriteStream__.
]]
[[
[link beast.ref.http__async_read_header [*async_read_header]]
[link beast.ref.beast__http__async_read_header [*async_read_header]]
][
Read only the header octets into a parser asynchronously from an __AsyncWriteStream__.
]]
[[
[link beast.ref.http__read_some.overload1 [*read_some]]
[link beast.ref.beast__http__read_some.overload1 [*read_some]]
][
Read some octets into a parser from a __SyncReadStream__.
]]
[[
[link beast.ref.http__async_read_some [*async_read_some]]
[link beast.ref.beast__http__async_read_some [*async_read_some]]
][
Read some octets into a parser asynchronously from an __AsyncWriteStream__.
]]
@ -111,10 +111,10 @@ __DynamicBuffer__ which produces input sequences of length one is also suitable.
The parser contains a message constructed internally. Arguments passed
to the parser's constructor are forwarded into the message container.
The caller can access the message inside the parser by calling
[link beast.ref.http__parser.get `parser::get`].
[link beast.ref.beast__http__parser.get `parser::get`].
If the `Fields` and `Body` types are [*MoveConstructible], the caller
can take ownership of the message by calling
[link beast.ref.http__parser.release `parser::release`]. In this example
[link beast.ref.beast__http__parser.release `parser::release`]. In this example
we read an HTTP response with a string body using a parser, then print
the response:

10
doc/5_06_serializer_buffers.qbk
View File

@ -17,15 +17,15 @@ to produce buffers until all of the buffers have been generated. Then the
serializer is destroyed.
To obtain the serialized next buffer sequence, call
[link beast.ref.http__serializer.get `serializer::get`].
[link beast.ref.beast__http__serializer.get `serializer::get`].
Then, call
[link beast.ref.http__serializer.consume `serializer::consume`]
[link beast.ref.beast__http__serializer.consume `serializer::consume`]
to indicate the number of bytes consumed. This updates the next
set of buffers to be returned, if any.
`serializer::get` takes an error code parameter and invokes a visitor
argument with the error code and buffer of unspecified type. In C++14
this is easily expressed with a generic lambda. The function
[link beast.ref.http__serializer.is_done `serializer::is_done`]
[link beast.ref.beast__http__serializer.is_done `serializer::is_done`]
will return `true` when all the buffers have been produced. This C++14
example prints the buffers to standard output:
@ -43,11 +43,11 @@ In some cases, such as the handling of the
field, it may be desired to first serialize the header, perform some other
action, and then continue with serialization of the body. This is
accomplished by calling
[link beast.ref.http__serializer.split `serializer::split`]
[link beast.ref.beast__http__serializer.split `serializer::split`]
with a boolean indicating that when buffers are produced, the last buffer
containing serialized header octets will not contain any octets corresponding
to the body. The function
[link beast.ref.http__serializer.is_header_done `serializer::is_header_done`]
[link beast.ref.beast__http__serializer.is_header_done `serializer::is_header_done`]
informs the caller whether the header been serialized fully. In this
C++14 example we print the header first, followed by the body:

8
doc/5_07_parser_buffers.qbk
View File

@ -13,10 +13,10 @@ algorithms on objects whose interface does not conform to __Stream__.
For example, a
[@http://zeromq.org/ *ZeroMQ* socket].
The basic parser interface is interactive; the caller invokes the function
[link beast.ref.http__basic_parser.put `basic_parser::put`]
[link beast.ref.beast__http__basic_parser.put `basic_parser::put`]
repeatedly with buffers until an error occurs or the parsing is done. The
function
[link beast.ref.http__basic_parser.put_eof `basic_parser::put_eof`]
[link beast.ref.beast__http__basic_parser.put_eof `basic_parser::put_eof`]
Is used when the caller knows that there will never be more data (for example,
if the underlying connection is closed),
@ -27,7 +27,7 @@ The parser provides two options which may be set before parsing begins:
[table Parser Options
[[Name][Default][Description]]
[[
[link beast.ref.http__basic_parser.eager.overload2 `eager`]
[link beast.ref.beast__http__basic_parser.eager.overload2 `eager`]
][
`false`
][
@ -42,7 +42,7 @@ The parser provides two options which may be set before parsing begins:
stream operations to improve performance with no change in functionality.
]]
[[
[link beast.ref.http__basic_parser.skip.overload2 `skip`]
[link beast.ref.beast__http__basic_parser.skip.overload2 `skip`]
][
`false`
][

2
doc/5_09_custom_body.qbk
View File

@ -21,7 +21,7 @@ The meaning of the nested types is as follows
[`value_type`]
[
Determines the type of the
[link beast.ref.http__message.body `message::body`]
[link beast.ref.beast__http__message.body `message::body`]
member.
]
][

2
doc/6_0_http_examples.qbk
View File

@ -20,7 +20,7 @@ until after the header is available. Then, a body type may be chosen
depending on the header contents. For example, depending on the verb,
target path, or target query parameters. To accomplish this, a parser
is declared to read in the header only, using a trivial body type such as
[link beast.ref.http__empty_body `empty_body`]. Then, a new parser is constructed
[link beast.ref.beast__http__empty_body `empty_body`]. Then, a new parser is constructed
from this existing parser where the body type is conditionally determined
by information from the header or elsewhere.

4
doc/7_1_streams.qbk
View File

@ -8,7 +8,7 @@
[section:streams Creating Streams]
The interface to the WebSocket implementation is a single template class
[link beast.ref.websocket__stream `stream`]
[link beast.ref.beast__websocket__stream `stream`]
which wraps an existing network transport object or other type of
octet oriented stream. The wrapped object is called the "next layer"
and must meet the requirements of __SyncStream__ if synchronous
@ -52,7 +52,7 @@ underlying socket being wrapped:
Once the WebSocket stream wrapper is created, the wrapped object may be
accessed by calling
[link beast.ref.websocket__stream.next_layer.overload1 `stream::next_layer`]:
[link beast.ref.beast__websocket__stream.next_layer.overload1 `stream::next_layer`]:
[ws_snippet_5]

10
doc/7_3_client.qbk
View File

@ -18,8 +18,8 @@ The Upgrade request must include the
field, and the
[@https://tools.ietf.org/html/rfc7230#section-5.3 target]
of the resource to request. The stream member functions
[link beast.ref.websocket__stream.handshake.overload1 `handshake`] and
[link beast.ref.websocket__stream.async_handshake.overload1 `async_handshake`]
[link beast.ref.beast__websocket__stream.handshake.overload1 `handshake`] and
[link beast.ref.beast__websocket__stream.async_handshake.overload1 `async_handshake`]
are used to send the request with the required host and target strings.
[ws_snippet_8]
@ -49,8 +49,8 @@ looks like this:
[heading Decorators]
If the caller wishes to add or modify fields, the member functions
[link beast.ref.websocket__stream.handshake_ex `handshake_ex`] and
[link beast.ref.websocket__stream.async_handshake_ex `async_handshake_ex`]
[link beast.ref.beast__websocket__stream.handshake_ex `handshake_ex`] and
[link beast.ref.beast__websocket__stream.async_handshake_ex `async_handshake_ex`]
are provided which allow an additional function object, called a
['decorator], to be passed. The decorator is invoked to modify
the HTTP Upgrade request as needed. This example sets a subprotocol
@ -87,7 +87,7 @@ on the received HTTP response message. For example, to check that the
response to a basic authentication challenge is valid. To achieve this,
overloads of the handshake member function allow the caller to store the
received HTTP message in an output reference argument as
[link beast.ref.websocket__response_type `response_type`]
[link beast.ref.beast__websocket__response_type `response_type`]
as follows:
[ws_snippet_10]

24
doc/7_4_server.qbk
View File

@ -8,7 +8,7 @@
[section:server Handshaking (Servers)]
A
[link beast.ref.websocket__stream `stream`]
[link beast.ref.beast__websocket__stream `stream`]
automatically handles receiving and processing the HTTP response to the
handshake request. The call to handshake is successful if a HTTP response
is received with the 101 "Switching Protocols" status code. On failure,
@ -41,8 +41,8 @@ typically look like this:
[heading Decorators]
If the caller wishes to add or modify fields, the member functions
[link beast.ref.websocket__stream.accept_ex `accept_ex`] and
[link beast.ref.websocket__stream.async_accept_ex `async_accept_ex`]
[link beast.ref.beast__websocket__stream.accept_ex `accept_ex`] and
[link beast.ref.beast__websocket__stream.async_accept_ex `async_accept_ex`]
are provided which allow an additional function object, called a
['decorator], to be passed. The decorator is invoked to modify
the HTTP Upgrade request as needed. This example sets the Server
@ -77,14 +77,14 @@ The HTTP Upgrade response produced by the previous call looks like this:
When implementing an HTTP server that also supports WebSocket, the
server usually reads the HTTP request from the client. To detect when
the incoming HTTP request is a WebSocket Upgrade request, the function
[link beast.ref.websocket__is_upgrade `is_upgrade`] may be used.
[link beast.ref.beast__websocket__is_upgrade `is_upgrade`] may be used.
Once the caller determines that the HTTP request is a WebSocket Upgrade,
additional overloads of
[link beast.ref.websocket__stream.accept `accept`],
[link beast.ref.websocket__stream.accept_ex `accept_ex`],
[link beast.ref.websocket__stream.async_accept `async_accept`], and
[link beast.ref.websocket__stream.async_accept_ex `async_accept_ex`]
[link beast.ref.beast__websocket__stream.accept `accept`],
[link beast.ref.beast__websocket__stream.accept_ex `accept_ex`],
[link beast.ref.beast__websocket__stream.async_accept `async_accept`], and
[link beast.ref.beast__websocket__stream.async_accept_ex `async_accept_ex`]
are provided which receive the entire HTTP request header as an object
to perform the handshake. In this example, the request is first read
in using the HTTP algorithms, and then passed to a newly constructed
@ -100,10 +100,10 @@ the first 6 octets after accepting an incoming connection to determine
if a TLS protocol is being negotiated, and choose a suitable implementation
at run-time. In the case where the server wishes to accept the incoming
request as an HTTP WebSocket Upgrade request, additional overloads of
[link beast.ref.websocket__stream.accept `accept`],
[link beast.ref.websocket__stream.accept_ex `accept_ex`],
[link beast.ref.websocket__stream.async_accept `async_accept`], and
[link beast.ref.websocket__stream.async_accept_ex `async_accept_ex`]
[link beast.ref.beast__websocket__stream.accept `accept`],
[link beast.ref.beast__websocket__stream.accept_ex `accept_ex`],
[link beast.ref.beast__websocket__stream.async_accept `async_accept`], and
[link beast.ref.beast__websocket__stream.async_accept_ex `async_accept_ex`]
are provided which receive the additional buffered octets and consume
them as part of the handshake.

2
doc/7_5_messages.qbk
View File

@ -14,7 +14,7 @@ all of the buffers representing the message are known ahead of time:
[ws_snippet_15]
[important
Calls to [link beast.ref.websocket__stream.set_option `set_option`]
Calls to [link beast.ref.beast__websocket__stream.set_option `set_option`]
must be made from the same implicit or explicit strand as that used
to perform other operations.
]

12
doc/7_6_control.qbk
View File

@ -25,7 +25,7 @@ During read operations, Beast automatically reads and processes control
frames. Pings are replied to as soon as possible with a pong, received
ping and pongs are delivered to the ping callback. The receipt of a close
frame initiates the WebSocket close procedure, eventually resulting in the
error code [link beast.ref.websocket__error `error::closed`] being delivered
error code [link beast.ref.beast__websocket__error `error::closed`] being delivered
to the caller in a subsequent read operation, assuming no other error
takes place.
@ -42,11 +42,11 @@ while the implementation also automatically handles control frames.
Ping and pong messages are control frames which may be sent at any time
by either peer on an established WebSocket connection. They are sent
using the functions
[link beast.ref.websocket__stream.ping `ping`] and
[link beast.ref.websocket__stream.pong `pong`].
[link beast.ref.beast__websocket__stream.ping `ping`] and
[link beast.ref.beast__websocket__stream.pong `pong`].
To be notified of ping and pong control frames, callers may register a
"ping callback" using [link beast.ref.websocket__stream.set_option `set_option`].
"ping callback" using [link beast.ref.beast__websocket__stream.set_option `set_option`].
The object provided with this option should be callable with the following
signature:
@ -77,7 +77,7 @@ The WebSocket protocol defines a procedure and control message for initiating
a close of the session. Handling of close initiated by the remote end of the
connection is performed automatically. To manually initiate a close, use
the
[link beast.ref.websocket__stream.close `close`] function:
[link beast.ref.beast__websocket__stream.close `close`] function:
[ws_snippet_18]
@ -92,7 +92,7 @@ before it receives and responds to the close frame.
[important
To receive the
[link beast.ref.websocket__error `error::closed`]
[link beast.ref.beast__websocket__error `error::closed`]
error, a read operation is required.
]

2
doc/7_7_notes.qbk
View File

@ -40,7 +40,7 @@ or require threads.
[heading Thread Safety]
Like a regular __Asio__ socket, a
[link beast.ref.websocket__stream `stream`]
[link beast.ref.beast__websocket__stream `stream`]
is not thread safe. Callers are responsible for synchronizing operations on
the socket using an implicit or explicit strand, as per the Asio documentation.
The asynchronous interface supports one active read and one active write

2
doc/9_0_design.qbk
View File

@ -30,7 +30,7 @@ __MutableBufferSequence__ concepts for passing buffers to functions.
The authors have found the dynamic buffer and buffer sequence interfaces to
be optimal for interacting with Asio, and for other tasks such as incremental
parsing of data in buffers (for example, parsing websocket frames stored
in a [link beast.ref.static_buffer `static_buffer`]).
in a [link beast.ref.beast__static_buffer `static_buffer`]).
During the development of Beast the authors have studied other software
packages and in particular the comments left during the Boost Review process

4
doc/9_4_faq.qbk
View File

@ -268,8 +268,8 @@ about Beast and other HTTP libraries that have gone through formal review.
The WebSocket implementation [*does] provide support for shutting down
the TLS connection through the use of the ADL compile-time virtual functions
[link beast.ref.websocket__teardown `teardown`] and
[link beast.ref.websocket__async_teardown `async_teardown`]. These will
[link beast.ref.beast__websocket__teardown `teardown`] and
[link beast.ref.beast__websocket__async_teardown `async_teardown`]. These will
properly close the connection as per rfc6455 and overloads are available
for TLS streams. Callers may provide their own overloads of these functions
for user-defined next layer types.

8
doc/Jamfile
View File

@ -17,13 +17,13 @@ using doxygen ;
import quickbook ;
path-constant here : . ;
path-constant out : . ;
install stylesheets
:
$(broot)/doc/src/boostbook.css
:
<location>$(here)/html
<location>$(out)/html
;
explicit stylesheets ;
@ -35,7 +35,7 @@ install images
images/body.png
images/message.png
:
<location>$(here)/html/images
<location>$(out)/html/images
;
explicit images ;
@ -44,7 +44,7 @@ install callouts
:
[ glob $(broot)/doc/src/images/callouts/*.png ]
:
<location>$(here)/html/images/callouts
<location>$(out)/html/images/callouts
;
explicit callout ;

2
doc/concept/Body.qbk
View File

@ -53,7 +53,7 @@ In this table:
[
If present, returns the serialized size of `m.body` not including
any chunked transfer encoding. When this function is provided,
[link beast.ref.http__message.prepare `message::prepare`]
[link beast.ref.beast__http__message.prepare `message::prepare`]
will automatically set the content length field based on the
value. Otherwise, the chunked transfer encoding will be set.
]

2
doc/concept/BodyReader.qbk
View File

@ -32,7 +32,7 @@ In this table:
* `m` denotes a value of type `message const&` where
`std::is_same<decltype(m.body), Body::value_type>:value == true`.
* `ec` is a value of type [link beast.ref.error_code `error_code&`].
* `ec` is a value of type [link beast.ref.beast__error_code `error_code&`].
* `R<T>` is the type `boost::optional<std::pair<T, bool>>`.

2
doc/concept/BodyWriter.qbk
View File

@ -36,7 +36,7 @@ In the table below:
* `m` denotes a value of type `message&` where
`std::is_same<decltype(m.body), Body::value_type>::value == true`.
* `ec` is a value of type [link beast.ref.error_code `error_code&`].
* `ec` is a value of type [link beast.ref.beast__error_code `error_code&`].
[table Writer requirements
[[expression] [type] [semantics, pre/post-conditions]]

2
doc/concept/Fields.qbk
View File

@ -23,7 +23,7 @@ In this table:
* `c` denotes a (possibly const) value of type `X`.
* `s` is a value of type [link beast.ref.string_view `string_view`].
* `s` is a value of type [link beast.ref.beast__string_view `string_view`].
[table Fields requirements
[[expression][type][semantics, pre/post-conditions]]

2
doc/concept/FieldsReader.qbk
View File

@ -27,7 +27,7 @@ In this table:
* `c` is an integer representing the HTTP status-code.
* `m` is a value of type [link beast.ref.http__verb `verb`].
* `m` is a value of type [link beast.ref.beast__http__verb `verb`].
[table FieldsReader requirements
[[expression][type][semantics, pre/post-conditions]]

11
doc/makeqbk.sh
View File

@ -5,9 +5,12 @@
# Distributed under the Boost Software License, Version 1.0. (See accompanying
# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
mkdir -p ../bin/doc/xml
mkdir -p temp
doxygen source.dox
cd ../bin/doc/xml
cd temp
xsltproc combine.xslt index.xml > all.xml
cd ../../../doc
xsltproc reference.xsl ../bin/doc/xml/all.xml > reference.qbk
cp ../docca/include/docca/doxygen.xsl doxygen.xsl
sed -i -e '/<!-- CLASS_DETAIL_TEMPLATE -->/{r ../xsl/class_detail.xsl' -e 'd}' doxygen.xsl
sed -i -e '/<!-- INCLUDES_TEMPLATE -->/{r ../xsl/includes.xsl' -e 'd}' doxygen.xsl
sed -i -e '/<!-- INCLUDES_FOOT_TEMPLATE -->/{r ../xsl/includes_foot.xsl' -e 'd}' doxygen.xsl
xsltproc ../xsl/reference.xsl all.xml > ../reference.qbk

236
doc/quickref.xml
View File

@ -29,73 +29,73 @@
<entry valign="top">
<bridgehead renderas="sect3">Classes</bridgehead>
<simplelist type="vert" columns="1">
<member><link linkend="beast.ref.http__basic_dynamic_body">basic_dynamic_body</link></member>
<member><link linkend="beast.ref.http__basic_fields">basic_fields</link></member>
<member><link linkend="beast.ref.http__basic_parser">basic_parser</link></member>
<member><link linkend="beast.ref.http__buffer_body">buffer_body</link></member>
<member><link linkend="beast.ref.http__dynamic_body">dynamic_body</link></member>
<member><link linkend="beast.ref.http__empty_body">empty_body</link></member>
<member><link linkend="beast.ref.http__fields">fields</link></member>
<member><link linkend="beast.ref.http__header">header</link></member>
<member><link linkend="beast.ref.http__message">message</link></member>
<member><link linkend="beast.ref.http__parser">parser</link></member>
<member><link linkend="beast.ref.http__no_chunk_decorator">no_chunk_decorator</link></member>
<member><link linkend="beast.ref.http__request">request</link></member>
<member><link linkend="beast.ref.http__request_parser">request_parser</link></member>
<member><link linkend="beast.ref.http__response">response</link></member>
<member><link linkend="beast.ref.http__response_parser">response_parser</link></member>
<member><link linkend="beast.ref.http__serializer">serializer</link></member>
<member><link linkend="beast.ref.http__string_body">string_body</link></member>
<member><link linkend="beast.ref.http__string_view_body">string_view_body</link></member>
<member><link linkend="beast.ref.beast__http__basic_dynamic_body">basic_dynamic_body</link></member>
<member><link linkend="beast.ref.beast__http__basic_fields">basic_fields</link></member>
<member><link linkend="beast.ref.beast__http__basic_parser">basic_parser</link></member>
<member><link linkend="beast.ref.beast__http__buffer_body">buffer_body</link></member>
<member><link linkend="beast.ref.beast__http__dynamic_body">dynamic_body</link></member>
<member><link linkend="beast.ref.beast__http__empty_body">empty_body</link></member>
<member><link linkend="beast.ref.beast__http__fields">fields</link></member>
<member><link linkend="beast.ref.beast__http__header">header</link></member>
<member><link linkend="beast.ref.beast__http__message">message</link></member>
<member><link linkend="beast.ref.beast__http__parser">parser</link></member>
<member><link linkend="beast.ref.beast__http__no_chunk_decorator">no_chunk_decorator</link></member>
<member><link linkend="beast.ref.beast__http__request">request</link></member>
<member><link linkend="beast.ref.beast__http__request_parser">request_parser</link></member>
<member><link linkend="beast.ref.beast__http__response">response</link></member>
<member><link linkend="beast.ref.beast__http__response_parser">response_parser</link></member>
<member><link linkend="beast.ref.beast__http__serializer">serializer</link></member>
<member><link linkend="beast.ref.beast__http__string_body">string_body</link></member>
<member><link linkend="beast.ref.beast__http__string_view_body">string_view_body</link></member>
</simplelist>
<bridgehead renderas="sect3">rfc7230</bridgehead>
<simplelist type="vert" columns="1">
<member><link linkend="beast.ref.http__ext_list">ext_list</link></member>
<member><link linkend="beast.ref.http__opt_token_list">opt_token_list</link></member>
<member><link linkend="beast.ref.http__param_list">param_list</link></member>
<member><link linkend="beast.ref.http__token_list">token_list</link></member>
<member><link linkend="beast.ref.beast__http__ext_list">ext_list</link></member>
<member><link linkend="beast.ref.beast__http__opt_token_list">opt_token_list</link></member>
<member><link linkend="beast.ref.beast__http__param_list">param_list</link></member>
<member><link linkend="beast.ref.beast__http__token_list">token_list</link></member>
</simplelist>
</entry>
<entry valign="top">
<bridgehead renderas="sect3">Functions</bridgehead>
<simplelist type="vert" columns="1">
<member><link linkend="beast.ref.http__async_read">async_read</link></member>
<member><link linkend="beast.ref.http__async_read_header">async_read_header</link></member>
<member><link linkend="beast.ref.http__async_read_some">async_read_some</link></member>
<member><link linkend="beast.ref.http__async_write">async_write</link></member>
<member><link linkend="beast.ref.http__async_write_header">async_write_header</link></member>
<member><link linkend="beast.ref.http__async_write_some">async_write_some</link></member>
<member><link linkend="beast.ref.http__int_to_status">int_to_status</link></member>
<member><link linkend="beast.ref.http__make_serializer">make_serializer</link></member>
<member><link linkend="beast.ref.http__obsolete_reason">obsolete_reason</link></member>
<member><link linkend="beast.ref.http__operator_ls_">operator&lt;&lt;</link></member>
<member><link linkend="beast.ref.http__read">read</link></member>
<member><link linkend="beast.ref.http__read_header">read_header</link></member>
<member><link linkend="beast.ref.http__read_some">read_some</link></member>
<member><link linkend="beast.ref.http__string_to_field">string_to_field</link></member>
<member><link linkend="beast.ref.http__string_to_verb">string_to_verb</link></member>
<member><link linkend="beast.ref.http__swap">swap</link></member>
<member><link linkend="beast.ref.http__to_string">to_string</link></member>
<member><link linkend="beast.ref.http__to_status_class">to_status_class</link></member>
<member><link linkend="beast.ref.http__write">write</link></member>
<member><link linkend="beast.ref.http__write_header">write_header</link></member>
<member><link linkend="beast.ref.http__write_some">write_some</link></member>
<member><link linkend="beast.ref.beast__http__async_read">async_read</link></member>
<member><link linkend="beast.ref.beast__http__async_read_header">async_read_header</link></member>
<member><link linkend="beast.ref.beast__http__async_read_some">async_read_some</link></member>
<member><link linkend="beast.ref.beast__http__async_write">async_write</link></member>
<member><link linkend="beast.ref.beast__http__async_write_header">async_write_header</link></member>
<member><link linkend="beast.ref.beast__http__async_write_some">async_write_some</link></member>
<member><link linkend="beast.ref.beast__http__int_to_status">int_to_status</link></member>
<member><link linkend="beast.ref.beast__http__make_serializer">make_serializer</link></member>
<member><link linkend="beast.ref.beast__http__obsolete_reason">obsolete_reason</link></member>
<member><link linkend="beast.ref.beast__http__operator_lt__lt_">operator&lt;&lt;</link></member>
<member><link linkend="beast.ref.beast__http__read">read</link></member>
<member><link linkend="beast.ref.beast__http__read_header">read_header</link></member>
<member><link linkend="beast.ref.beast__http__read_some">read_some</link></member>
<member><link linkend="beast.ref.beast__http__string_to_field">string_to_field</link></member>
<member><link linkend="beast.ref.beast__http__string_to_verb">string_to_verb</link></member>
<member><link linkend="beast.ref.beast__http__swap">swap</link></member>
<member><link linkend="beast.ref.beast__http__to_string">to_string</link></member>
<member><link linkend="beast.ref.beast__http__to_status_class">to_status_class</link></member>
<member><link linkend="beast.ref.beast__http__write">write</link></member>
<member><link linkend="beast.ref.beast__http__write_header">write_header</link></member>
<member><link linkend="beast.ref.beast__http__write_some">write_some</link></member>
</simplelist>
</entry>
<entry valign="top">
<bridgehead renderas="sect3">Constants</bridgehead>
<simplelist type="vert" columns="1">
<member><link linkend="beast.ref.http__error">error</link></member>
<member><link linkend="beast.ref.http__field">field</link></member>
<member><link linkend="beast.ref.http__status">status</link></member>
<member><link linkend="beast.ref.http__status_class">status_class</link></member>
<member><link linkend="beast.ref.http__verb">verb</link></member>
<member><link linkend="beast.ref.beast__http__error">error</link></member>
<member><link linkend="beast.ref.beast__http__field">field</link></member>
<member><link linkend="beast.ref.beast__http__status">status</link></member>
<member><link linkend="beast.ref.beast__http__status_class">status_class</link></member>
<member><link linkend="beast.ref.beast__http__verb">verb</link></member>
</simplelist>
<bridgehead renderas="sect3">Type Traits</bridgehead>
<simplelist type="vert" columns="1">
<member><link linkend="beast.ref.http__is_body">is_body</link></member>
<member><link linkend="beast.ref.http__is_body_writer">is_body_writer</link></member>
<member><link linkend="beast.ref.http__is_body_reader">is_body_reader</link></member>
<member><link linkend="beast.ref.beast__http__is_body">is_body</link></member>
<member><link linkend="beast.ref.beast__http__is_body_writer">is_body_writer</link></member>
<member><link linkend="beast.ref.beast__http__is_body_reader">is_body_reader</link></member>
</simplelist>
<bridgehead renderas="sect3">Concepts</bridgehead>
<simplelist type="vert" columns="1">
@ -109,26 +109,26 @@
<entry valign="top">
<bridgehead renderas="sect3">Classes</bridgehead>
<simplelist type="vert" columns="1">
<member><link linkend="beast.ref.websocket__close_reason">close_reason</link></member>
<member><link linkend="beast.ref.websocket__ping_data">ping_data</link></member>
<member><link linkend="beast.ref.websocket__stream">stream</link></member>
<member><link linkend="beast.ref.websocket__reason_string">reason_string</link></member>
<member><link linkend="beast.ref.websocket__teardown_tag">teardown_tag</link></member>
<member><link linkend="beast.ref.beast__websocket__close_reason">close_reason</link></member>
<member><link linkend="beast.ref.beast__websocket__ping_data">ping_data</link></member>
<member><link linkend="beast.ref.beast__websocket__stream">stream</link></member>
<member><link linkend="beast.ref.beast__websocket__reason_string">reason_string</link></member>
<member><link linkend="beast.ref.beast__websocket__teardown_tag">teardown_tag</link></member>
</simplelist>
<bridgehead renderas="sect3">Functions</bridgehead>
<simplelist type="vert" columns="1">
<member><link linkend="beast.ref.websocket__async_teardown">async_teardown</link></member>
<member><link linkend="beast.ref.websocket__is_upgrade">is_upgrade</link></member>
<member><link linkend="beast.ref.websocket__teardown">teardown</link></member>
<member><link linkend="beast.ref.beast__websocket__async_teardown">async_teardown</link></member>
<member><link linkend="beast.ref.beast__websocket__is_upgrade">is_upgrade</link></member>
<member><link linkend="beast.ref.beast__websocket__teardown">teardown</link></member>
</simplelist>
<bridgehead renderas="sect3">Options</bridgehead>
<simplelist type="vert" columns="1">
<member><link linkend="beast.ref.websocket__permessage_deflate">permessage_deflate</link></member>
<member><link linkend="beast.ref.beast__websocket__permessage_deflate">permessage_deflate</link></member>
</simplelist>
<bridgehead renderas="sect3">Constants</bridgehead>
<simplelist type="vert" columns="1">
<member><link linkend="beast.ref.websocket__close_code">close_code</link></member>
<member><link linkend="beast.ref.websocket__error">error</link></member>
<member><link linkend="beast.ref.beast__websocket__close_code">close_code</link></member>
<member><link linkend="beast.ref.beast__websocket__error">error</link></member>
</simplelist>
</entry>
</row>
@ -155,66 +155,66 @@
<entry valign="top">
<bridgehead renderas="sect3">Classes</bridgehead>
<simplelist type="vert" columns="1">
<member><link linkend="beast.ref.async_completion">async_completion</link></member>
<member><link linkend="beast.ref.async_result">async_result</link></member>
<member><link linkend="beast.ref.async_return_type">async_return_type</link></member>
<member><link linkend="beast.ref.basic_flat_buffer">basic_flat_buffer</link></member>
<member><link linkend="beast.ref.basic_multi_buffer">basic_multi_buffer</link></member>
<member><link linkend="beast.ref.buffer_cat_view">buffer_cat_view</link></member>
<member><link linkend="beast.ref.buffer_prefix_view">buffer_prefix_view</link></member>
<member><link linkend="beast.ref.buffered_read_stream">buffered_read_stream</link></member>
<member><link linkend="beast.ref.buffers_adapter">buffers_adapter</link></member>
<member><link linkend="beast.ref.consuming_buffers">consuming_buffers</link></member>
<member><link linkend="beast.ref.drain_buffer">drain_buffer</link></member>
<member><link linkend="beast.ref.error_category">error_category</link></member>
<member><link linkend="beast.ref.error_code">error_code</link></member>
<member><link linkend="beast.ref.error_condition">error_condition</link></member>
<member><link linkend="beast.ref.flat_buffer">flat_buffer</link></member>
<member><link linkend="beast.ref.handler_alloc">handler_alloc</link></member>
<member><link linkend="beast.ref.handler_ptr">handler_ptr</link></member>
<member><link linkend="beast.ref.handler_type">handler_type</link></member>
<member><link linkend="beast.ref.multi_buffer">multi_buffer</link></member>
<member><link linkend="beast.ref.static_buffer">static_buffer</link></member>
<member><link linkend="beast.ref.static_buffer_n">static_buffer_n</link></member>
<member><link linkend="beast.ref.static_string">static_string</link></member>
<member><link linkend="beast.ref.string_param">string_param</link></member>
<member><link linkend="beast.ref.string_view">string_view</link></member>
<member><link linkend="beast.ref.system_error">system_error</link></member>
<member><link linkend="beast.ref.beast__async_completion">async_completion</link></member>
<member><link linkend="beast.ref.beast__async_result">async_result</link></member>
<member><link linkend="beast.ref.beast__async_return_type">async_return_type</link></member>
<member><link linkend="beast.ref.beast__basic_flat_buffer">basic_flat_buffer</link></member>
<member><link linkend="beast.ref.beast__basic_multi_buffer">basic_multi_buffer</link></member>
<member><link linkend="beast.ref.beast__buffer_cat_view">buffer_cat_view</link></member>
<member><link linkend="beast.ref.beast__buffer_prefix_view">buffer_prefix_view</link></member>
<member><link linkend="beast.ref.beast__buffered_read_stream">buffered_read_stream</link></member>
<member><link linkend="beast.ref.beast__buffers_adapter">buffers_adapter</link></member>
<member><link linkend="beast.ref.beast__consuming_buffers">consuming_buffers</link></member>
<member><link linkend="beast.ref.beast__drain_buffer">drain_buffer</link></member>
<member><link linkend="beast.ref.beast__error_category">error_category</link></member>
<member><link linkend="beast.ref.beast__error_code">error_code</link></member>
<member><link linkend="beast.ref.beast__error_condition">error_condition</link></member>
<member><link linkend="beast.ref.beast__flat_buffer">flat_buffer</link></member>
<member><link linkend="beast.ref.beast__handler_alloc">handler_alloc</link></member>
<member><link linkend="beast.ref.beast__handler_ptr">handler_ptr</link></member>
<member><link linkend="beast.ref.beast__handler_type">handler_type</link></member>
<member><link linkend="beast.ref.beast__multi_buffer">multi_buffer</link></member>
<member><link linkend="beast.ref.beast__static_buffer">static_buffer</link></member>
<member><link linkend="beast.ref.beast__static_buffer_n">static_buffer_n</link></member>
<member><link linkend="beast.ref.beast__static_string">static_string</link></member>
<member><link linkend="beast.ref.beast__string_param">string_param</link></member>
<member><link linkend="beast.ref.beast__string_view">string_view</link></member>
<member><link linkend="beast.ref.beast__system_error">system_error</link></member>
</simplelist>
</entry>
<entry valign="top">
<bridgehead renderas="sect3">Functions</bridgehead>
<simplelist type="vert" columns="1">
<member><link linkend="beast.ref.bind_handler">bind_handler</link></member>
<member><link linkend="beast.ref.buffer_cat">buffer_cat</link></member>
<member><link linkend="beast.ref.buffer_prefix">buffer_prefix</link></member>
<member><link linkend="beast.ref.buffers">buffers</link></member>
<member><link linkend="beast.ref.ostream">ostream</link></member>
<member><link linkend="beast.ref.read_size">read_size</link></member>
<member><link linkend="beast.ref.read_size_or_throw">read_size_or_throw</link></member>
<member><link linkend="beast.ref.system_category">system_category</link></member>
<member><link linkend="beast.ref.to_static_string">to_static_string</link></member>
<member><link linkend="beast.ref.beast__bind_handler">bind_handler</link></member>
<member><link linkend="beast.ref.beast__buffer_cat">buffer_cat</link></member>
<member><link linkend="beast.ref.beast__buffer_prefix">buffer_prefix</link></member>
<member><link linkend="beast.ref.beast__buffers">buffers</link></member>
<member><link linkend="beast.ref.beast__ostream">ostream</link></member>
<member><link linkend="beast.ref.beast__read_size">read_size</link></member>
<member><link linkend="beast.ref.beast__read_size_or_throw">read_size_or_throw</link></member>
<member><link linkend="beast.ref.beast__system_category">system_category</link></member>
<member><link linkend="beast.ref.beast__to_static_string">to_static_string</link></member>
</simplelist>
<bridgehead renderas="sect3">Constants</bridgehead>
<simplelist type="vert" columns="1">
<member><link linkend="beast.ref.errc">errc</link></member>
<member><link linkend="beast.ref.beast__errc">errc</link></member>
</simplelist>
</entry>
<entry valign="top">
<bridgehead renderas="sect3">Type Traits</bridgehead>
<simplelist type="vert" columns="1">
<member><link linkend="beast.ref.get_lowest_layer">get_lowest_layer</link></member>
<member><link linkend="beast.ref.has_get_io_service">has_get_io_service</link></member>
<member><link linkend="beast.ref.is_async_read_stream">is_async_read_stream</link></member>
<member><link linkend="beast.ref.is_async_write_stream">is_async_write_stream</link></member>
<member><link linkend="beast.ref.is_async_stream">is_async_stream</link></member>
<member><link linkend="beast.ref.is_completion_handler">is_completion_handler</link></member>
<member><link linkend="beast.ref.is_const_buffer_sequence">is_const_buffer_sequence</link></member>
<member><link linkend="beast.ref.is_dynamic_buffer">is_dynamic_buffer</link></member>
<member><link linkend="beast.ref.is_mutable_buffer_sequence">is_mutable_buffer_sequence</link></member>
<member><link linkend="beast.ref.is_sync_read_stream">is_sync_read_stream</link></member>
<member><link linkend="beast.ref.is_sync_stream">is_sync_stream</link></member>
<member><link linkend="beast.ref.is_sync_write_stream">is_sync_write_stream</link></member>
<member><link linkend="beast.ref.beast__get_lowest_layer">get_lowest_layer</link></member>
<member><link linkend="beast.ref.beast__has_get_io_service">has_get_io_service</link></member>
<member><link linkend="beast.ref.beast__is_async_read_stream">is_async_read_stream</link></member>
<member><link linkend="beast.ref.beast__is_async_write_stream">is_async_write_stream</link></member>
<member><link linkend="beast.ref.beast__is_async_stream">is_async_stream</link></member>
<member><link linkend="beast.ref.beast__is_completion_handler">is_completion_handler</link></member>
<member><link linkend="beast.ref.beast__is_const_buffer_sequence">is_const_buffer_sequence</link></member>
<member><link linkend="beast.ref.beast__is_dynamic_buffer">is_dynamic_buffer</link></member>
<member><link linkend="beast.ref.beast__is_mutable_buffer_sequence">is_mutable_buffer_sequence</link></member>
<member><link linkend="beast.ref.beast__is_sync_read_stream">is_sync_read_stream</link></member>
<member><link linkend="beast.ref.beast__is_sync_stream">is_sync_stream</link></member>
<member><link linkend="beast.ref.beast__is_sync_write_stream">is_sync_write_stream</link></member>
</simplelist>
</entry>
<entry valign="top">
@ -230,19 +230,19 @@
<entry valign="top">
<bridgehead renderas="sect3">Classes</bridgehead>
<simplelist type="vert" columns="1">
<member><link linkend="beast.ref.zlib__deflate_stream">deflate_stream</link></member>
<member><link linkend="beast.ref.zlib__inflate_stream">inflate_stream</link></member>
<member><link linkend="beast.ref.zlib__z_params">z_params</link></member>
<member><link linkend="beast.ref.beast__zlib__deflate_stream">deflate_stream</link></member>
<member><link linkend="beast.ref.beast__zlib__inflate_stream">inflate_stream</link></member>
<member><link linkend="beast.ref.beast__zlib__z_params">z_params</link></member>
</simplelist>
<bridgehead renderas="sect3">Functions</bridgehead>
<simplelist type="vert" columns="1">
<member><link linkend="beast.ref.zlib__deflate_upper_bound">deflate_upper_bound</link></member>
<member><link linkend="beast.ref.beast__zlib__deflate_upper_bound">deflate_upper_bound</link></member>
</simplelist>
<bridgehead renderas="sect3">Constants</bridgehead>
<simplelist type="vert" columns="1">
<member><link linkend="beast.ref.zlib__error">error</link></member>
<member><link linkend="beast.ref.zlib__Flush">Flush</link></member>
<member><link linkend="beast.ref.zlib__Strategy">Strategy</link></member>
<member><link linkend="beast.ref.beast__zlib__error">error</link></member>
<member><link linkend="beast.ref.beast__zlib__Flush">Flush</link></member>
<member><link linkend="beast.ref.beast__zlib__Strategy">Strategy</link></member>
</simplelist>
</entry>
</row>
@ -261,8 +261,8 @@
<row>
<entry valign="top">
<simplelist type="vert" columns="1">
<member><link linkend="beast.ref.doc_debug">doc_debug</link></member>
<member><link linkend="beast.ref.nested__nested_doc_debug">nested_doc_debug</link></member>
<member><link linkend="beast.ref.beast__doc_debug">doc_debug</link></member>
<member><link linkend="beast.ref.beast__nested__nested_doc_debug">nested_doc_debug</link></member>
</simplelist>
</entry>
</row>

1866
doc/reference.xsl
View File

File diff suppressed because it is too large Load Diff

4
doc/source.dox
View File

@ -16,7 +16,7 @@ ABBREVIATE_BRIEF =
ALWAYS_DETAILED_SEC = NO
INLINE_INHERITED_MEMB = YES
FULL_PATH_NAMES = NO
STRIP_FROM_PATH =
STRIP_FROM_PATH = ../include/
STRIP_FROM_INC_PATH =
SHORT_NAMES = NO
JAVADOC_AUTOBRIEF = YES
@ -254,7 +254,7 @@ MAN_LINKS = NO
# Configuration options related to the XML output
#---------------------------------------------------------------------------
GENERATE_XML = YES
XML_OUTPUT = ../bin/doc/xml
XML_OUTPUT = temp/
XML_PROGRAMLISTING = YES
#---------------------------------------------------------------------------

48
doc/xsl/class_detail.xsl Normal file
View File

@ -0,0 +1,48 @@
<!-- CLASS_DETAIL_TEMPLATE BEGIN -->
<xsl:when test="type = 'class AsyncStream'">
<xsl:text>class ``[link beast.concept.streams.AsyncStream [*AsyncStream]]``</xsl:text>
</xsl:when>
<xsl:when test="type = 'class AsyncReadStream'">
<xsl:text>class __AsyncReadStream__</xsl:text>
</xsl:when>
<xsl:when test="type = 'class AsyncWriteStream'">
<xsl:text>class __AsyncWriteStream__</xsl:text>
</xsl:when>
<xsl:when test="type = 'class Body'">
<xsl:text>class ``[link beast.concept.Body [*Body]]``</xsl:text>
</xsl:when>
<xsl:when test="type = 'class BufferSequence'">
<xsl:text>class ``[link beast.concept.BufferSequence [*BufferSequence]]``</xsl:text>
</xsl:when>
<xsl:when test="(type = 'class' or type = 'class...') and declname = 'BufferSequence'">
<xsl:value-of select="type"/>
<xsl:text> ``[link beast.concept.BufferSequence [*BufferSequence]]``</xsl:text>
</xsl:when>
<xsl:when test="declname = 'CompletionHandler' or type = 'class CompletionHandler'">
<xsl:text>class __CompletionHandler__</xsl:text>
</xsl:when>
<xsl:when test="declname = 'ConstBufferSequence' or type = 'class ConstBufferSequence'">
<xsl:text>class __ConstBufferSequence__</xsl:text>
</xsl:when>
<xsl:when test="declname = 'DynamicBuffer' or type = 'class DynamicBuffer'">
<xsl:text>class ``[link beast.concept.DynamicBuffer [*DynamicBuffer]]``</xsl:text>
</xsl:when>
<xsl:when test="declname = 'Handler' or type = 'class Handler'">
<xsl:text>class __Handler__</xsl:text>
</xsl:when>
<xsl:when test="declname = 'MutableBufferSequence' or type = 'class MutableBufferSequence'">
<xsl:text>class __MutableBufferSequence__</xsl:text>
</xsl:when>
<xsl:when test="declname = 'Stream' or type = 'class Stream'">
<xsl:text>class ``[link beast.concept.streams.Stream [*Stream]]``</xsl:text>
</xsl:when>
<xsl:when test="type = 'class SyncStream'">
<xsl:text>class ``[link beast.concept.streams.SyncStream [*SyncStream]]``</xsl:text>
</xsl:when>
<xsl:when test="declname = 'SyncReadStream' or type = 'class SyncReadStream'">
<xsl:text>class __SyncReadStream__</xsl:text>
</xsl:when>
<xsl:when test="declname = 'SyncWriteStream' or type = 'class SyncWriteStream'">
<xsl:text>class __SyncWriteStream__</xsl:text>
</xsl:when>
<!-- CLASS_DETAIL_TEMPLATE END -->

5
doc/xsl/includes.xsl Normal file
View File

@ -0,0 +1,5 @@
<!-- INCLUDES_TEMPLATE BEGIN -->
<xsl:text>Defined in header [include_file </xsl:text>
<xsl:value-of select="$file"/>
<xsl:text>]&#xd;&#xd;</xsl:text>
<!-- INCLUDES_TEMPLATE END -->

16
doc/xsl/includes_foot.xsl Normal file
View File

@ -0,0 +1,16 @@
<!-- INCLUDES_FOOT_TEMPLATE BEGIN -->
<xsl:choose>
<xsl:when test="contains($file, 'beast/core')">
<xsl:text>&#xd;&#xd;Convenience header [include_file beast/core.hpp]&#xd;</xsl:text>
</xsl:when>
<xsl:when test="contains($file, 'beast/http')">
<xsl:text>&#xd;&#xd;Convenience header [include_file beast/http.hpp]&#xd;</xsl:text>
</xsl:when>
<xsl:when test="contains($file, 'beast/websocket')">
<xsl:text>&#xd;&#xd;Convenience header [include_file beast/websocket.hpp]&#xd;</xsl:text>
</xsl:when>
<xsl:when test="contains($file, 'beast/zlib')">
<xsl:text>&#xd;&#xd;Convenience header [include_file beast/zlib.hpp]&#xd;</xsl:text>
</xsl:when>
</xsl:choose>
<!-- INCLUDES_FOOT_TEMPLATE END -->

13
doc/xsl/reference.xsl Normal file
View File

@ -0,0 +1,13 @@
<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
<!-- Variables (Edit for your project) -->
<xsl:variable name="doc-ref" select="'beast.ref.'"/>
<xsl:variable name="doc-ns" select="'beast'"/>
<xsl:variable name="debug" select="0"/>
<xsl:variable name="private" select="0"/>
<!-- End Variables -->
<xsl:include href="../temp/doxygen.xsl"/>
</xsl:stylesheet>

2
examples/doc_core_samples.hpp
View File

@ -218,7 +218,7 @@ template<
class AsyncReadStream,
class DynamicBuffer,
class CompletionToken>
async_return_type< /*< The [link beast.ref.async_return_type `async_return_type`] customizes the return value based on the completion token >*/
async_return_type< /*< The [link beast.ref.beast__async_return_type `async_return_type`] customizes the return value based on the completion token >*/
CompletionToken,
void(error_code, boost::tribool)> /*< This is the signature for the completion handler >*/
async_detect_ssl(

2
examples/echo_op.cpp
View File

@ -52,7 +52,7 @@
template<
class AsyncStream,
class CompletionToken>
beast::async_return_type< /*< The [link beast.ref.async_return_type `async_return_type`] customizes the return value based on the completion token >*/
beast::async_return_type< /*< The [link beast.ref.beast__async_return_type `async_return_type`] customizes the return value based on the completion token >*/
CompletionToken,
void(beast::error_code)> /*< This is the signature for the completion handler >*/
async_echo(

1
include/beast/core/flat_buffer.hpp
View File

@ -293,6 +293,7 @@ public:
void
shrink_to_fit();
/// Exchange two flat buffers
template<class Alloc>
friend
void

6
include/beast/http/fields.hpp
View File

@ -41,6 +41,9 @@ namespace http {
of the field name.
Meets the requirements of @b Fields
@tparam Allocator The allocator to use. This must meet the
requirements of @b Allocator.
*/
template<class Allocator>
class basic_fields
@ -138,6 +141,7 @@ private:
boost::intrusive::constant_time_size<true>,
boost::intrusive::compare<key_compare>>::type;
protected:
friend class fields_test; // for `header`
@ -263,7 +267,7 @@ public:
string_view
operator[](field name) const;
/** Returns the value for a case-insensitive matching header, or `""`.
/** Returns the value for a case-insensitive matching header, or `""` if it does not exist.
If more than one field with the specified name exists, the
first field defined by insertion order is returned.

2
include/beast/http/message.hpp
View File

@ -503,7 +503,7 @@ struct message : header<isRequest, Fields>
The value of the Content-Length field will be unconditionally
set to the specified number of octets.
@par n The number of octets to set for the Content-Length field.
@param n The number of octets to set for the Content-Length field.
*/
void
content_length(std::uint64_t n);