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

Update documentation for boost

Browse Source
This commit is contained in:
Vinnie Falco
2017-07-23 22:49:57 -07:00
parent 198846d7bd
commit 982f4c3b70
44 changed files with 451 additions and 933 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
CHANGELOG.md
View File

@@ -7,6 +7,7 @@ Version 86:
* Add local-travis.sh
* Use winapi
* Update CMakeLists.txt for boost
* Update documentation for boost
--------------------------------------------------------------------------------

11
README.md
View File

@@ -5,8 +5,8 @@
Branch | Build | Coverage | Documentation
------------|---------------|----------------|---------------
[master](https://github.com/boostorg/beast/tree/master) | [![Build Status](https://travis-ci.org/boostorg/beast.svg?branch=master)](https://travis-ci.org/boostorg/beast) [![Build status](https://ci.appveyor.com/api/projects/status/g0llpbvhpjuxjnlw/branch/master?svg=true)](https://ci.appveyor.com/project/vinniefalco/beast/branch/master) | [![codecov](https://codecov.io/gh/vinniefalco/Beast/branch/master/graph/badge.svg)](https://codecov.io/gh/boostorg/beast/branch/master) | [![Documentation](https://img.shields.io/badge/documentation-master-brightgreen.svg)](http://vinniefalco.github.io/beast/)
[develop](https://github.com/boostorg/beast/tree/develop) | [![Build Status](https://travis-ci.org/boostorg/beast.svg?branch=develop)](https://travis-ci.org/boostorg/beast) [![Build status](https://ci.appveyor.com/api/projects/status/g0llpbvhpjuxjnlw/branch/develop?svg=true)](https://ci.appveyor.com/project/vinniefalco/beast/branch/develop) | [![codecov](https://codecov.io/gh/vinniefalco/Beast/branch/develop/graph/badge.svg)](https://codecov.io/gh/boostorg/beast/branch/develop) | [![Documentation](https://img.shields.io/badge/documentation-develop-brightgreen.svg)](http://vinniefalco.github.io/stage/beast/develop)
[master](https://github.com/boostorg/beast/tree/master) | [![Build Status](https://travis-ci.org/boostorg/beast.svg?branch=master)](https://travis-ci.org/boostorg/beast) [![Build status](https://ci.appveyor.com/api/projects/status/g0llpbvhpjuxjnlw/branch/master?svg=true)](https://ci.appveyor.com/project/vinniefalco/beast/branch/master) | [![codecov](https://codecov.io/gh/vinniefalco/Beast/branch/master/graph/badge.svg)](https://codecov.io/gh/boostorg/beast/branch/master) | [![Documentation](https://img.shields.io/badge/documentation-master-brightgreen.svg)](http://www.boost.org/doc/libs/master/libs/bind/doc/html/beast.html)
[develop](https://github.com/boostorg/beast/tree/develop) | [![Build Status](https://travis-ci.org/boostorg/beast.svg?branch=develop)](https://travis-ci.org/boostorg/beast) [![Build status](https://ci.appveyor.com/api/projects/status/g0llpbvhpjuxjnlw/branch/develop?svg=true)](https://ci.appveyor.com/project/vinniefalco/beast/branch/develop) | [![codecov](https://codecov.io/gh/vinniefalco/Beast/branch/develop/graph/badge.svg)](https://codecov.io/gh/boostorg/beast/branch/develop) | [![Documentation](https://img.shields.io/badge/documentation-develop-brightgreen.svg)](http://www.boost.org/doc/libs/develop/libs/bind/doc/html/beast.html)
## Contents
@@ -89,16 +89,15 @@ library to link with. If you use coroutines you'll also need to link
with the Boost.Coroutine library. Please visit the Boost documentation
for instructions on how to do this for your particular build system.
For the examples and tests, Beast provides build scripts for Boost.Build (bjam)
and CMake. It is possible to generate Microsoft Visual Studio or Apple
Xcode project files using CMake by executing these commands from
For the examples and tests, Beast provides build scripts for Boost.Build
(bjam) and CMake (Windows). It is possible to generate Microsoft Visual
Studio project files using CMake by executing these commands from
the root of the repository:
```
mkdir bin
cd bin
cmake .. # for 32-bit Windows builds
cmake -G Xcode .. # for Apple Xcode builds
cd ..
mkdir bin64

22
doc/Dockerfile
View File

@@ -1,22 +0,0 @@
FROM ubuntu:16.04
RUN apt-get update
RUN apt-get -y install build-essential g++ git libbz2-dev wget python-dev
# Install Boost
ENV BOOST_SHA 440a59f8bc4023dbe6285c9998b0f7fa288468b889746b1ef00e8b36c559dce1
RUN wget https://sourceforge.net/projects/boost/files/boost/1.62.0/boost_1_62_0.tar.gz
RUN echo "$BOOST_SHA boost_1_62_0.tar.gz" | sha256sum -c
RUN tar xzf boost_1_62_0.tar.gz
RUN cd boost_1_62_0 && ./bootstrap.sh --prefix=/usr/local
RUN cd boost_1_62_0 && ./b2 install
ENV BOOST_ROOT=/boost_1_62_0
# Install dependencies
RUN apt-get -y install doxygen
RUN apt-get -y install xsltproc
CMD cd /opt/beast/doc && \
chmod +x makeqbk.sh && \
./makeqbk.sh && \
$BOOST_ROOT/b2

84
doc/Jamfile
View File

@@ -5,77 +5,57 @@
# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#
import os ;
local broot = [ os.environ BOOST_ROOT ] ;
project beast/doc ;
import boostbook : boostbook ;
using boostbook ;
using quickbook ;
using doxygen ;
import quickbook ;
#
# HTML documentation for $(BOOST_ROOT)/doc/html
#
path-constant out : . ;
install stylesheets
:
$(broot)/doc/src/boostbook.css
:
<location>$(out)/html
;
explicit stylesheets ;
install images
:
[ glob $(broot)/doc/src/images/*.png ]
images/beast.png
images/message.png
:
<location>$(out)/html/images
;
explicit images ;
install callouts
:
[ glob $(broot)/doc/src/images/callouts/*.png ]
:
<location>$(out)/html/images/callouts
;
explicit callout ;
xml doc
xml beast_doc
:
qbk/00_main.qbk
:
<location>temp
<include>$(broot)/tools/boostbook/dtd
;
boostbook boostdoc
explicit beast_doc ;
install beast_doc_images
:
doc
images/message.png
:
<xsl:param>boost.root=$(broot)
<xsl:param>boost.image.src=images/beast.png
<xsl:param>boost.image.alt="Beast Logo"
<xsl:param>boost.image.w=1330
<xsl:param>boost.image.h=80
<xsl:param>chapter.autolabel=0
<location>html/beast/images
;
explicit beast_doc_images ;
boostbook beast
:
beast_doc
:
<xsl:param>boost.root=../../../..
<xsl:param>root.filename=beast
<xsl:param>chapter.autolabel=1
<xsl:param>chunk.section.depth=8 # Depth to which sections should be chunked
<xsl:param>chunk.first.sections=1 # Chunk the first top-level section?
<xsl:param>toc.section.depth=8 # How deep should recursive sections appear in the TOC?
<xsl:param>toc.max.depth=8 # How many levels should be created for each TOC?
<xsl:param>generate.section.toc.level=8 # Control depth of TOC generation in sections
<xsl:param>generate.toc="chapter toc,title section nop reference nop"
<include>$(broot)/tools/boostbook/dtd
<include>../../../tools/boostbook/dtd
:
<location>temp
<dependency>images
<dependency>stylesheets
<dependency>beast_doc_images
;
alias boostdoc : beast : : : ;
explicit boostdoc ;
alias boostrelease ;
explicit boostrelease ;

439
doc/boostbook.dtd
View File

@@ -1,439 +0,0 @@
<!--
BoostBook DTD - development version
For further information, see: http://www.crystalclearsoftware.com/cgi-bin/boost_wiki/wiki.pl?Boost_Documentation_Format
Copyright (c) 2002 by Peter Simons <simons@cryp.to>
Copyright (c) 2003-2004 by Douglas Gregor <doug.gregor -at- gmail.com>
Copyright (c) 2007 by Frank Mori Hess <fmhess@users.sourceforge.net>
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)
The latest stable DTD module is identified by the PUBLIC and SYSTEM identifiers:
PUBLIC "-//Boost//DTD BoostBook XML V1.1//EN"
SYSTEM "http://www.boost.org/tools/boostbook/dtd/1.1/boostbook.dtd"
$Revision$
$Date$
-->
<!--========== Define XInclude features. ==========-->
<!-- This is not really integrated into the DTD yet. Needs more
research. -->
<!--
<!ELEMENT xi:include (xi:fallback)?>
<!ATTLIST xi:include
xmlns:xi CDATA #FIXED "http://www.w3.org/2001/XInclude"
href CDATA #REQUIRED
parse (xml|text) "xml"
encoding CDATA #IMPLIED>
<!ELEMENT xi:fallback ANY>
<!ATTLIST xi:fallback
xmlns:xi CDATA #FIXED "http://www.w3.org/2001/XInclude">
-->
<!ENTITY % local.common.attrib "last-revision CDATA #IMPLIED">
<!--========== Define the BoostBook extensions ==========-->
<!ENTITY % boost.common.attrib "%local.common.attrib;
id CDATA #IMPLIED">
<!ENTITY % boost.namespace.mix
"class|class-specialization|struct|struct-specialization|
union|union-specialization|typedef|enum|
free-function-group|function|overloaded-function|
namespace">
<!ENTITY % boost.template.mix
"template-type-parameter|template-nontype-parameter|template-varargs">
<!ENTITY % boost.class.members
"static-constant|typedef|enum|
copy-assignment|constructor|destructor|method-group|
method|overloaded-method|data-member|class|class-specialization|struct|
struct-specialization|union|union-specialization">
<!ENTITY % boost.class.mix
"%boost.class.members;|free-function-group|function|overloaded-function">
<!ENTITY % boost.class.content
"template?, inherit*, purpose?, description?,
(%boost.class.mix;|access)*">
<!ENTITY % boost.class-specialization.content
"template?, specialization?, inherit?, purpose?, description?,
(%boost.class.mix;|access)*">
<!ENTITY % boost.function.semantics
"purpose?, description?, requires?, effects?, postconditions?,
returns?, throws?, complexity?, notes?, rationale?">
<!ENTITY % library.content
"libraryinfo, (title, ((section|library-reference|testsuite))+)?">
<!ELEMENT library (%library.content;)>
<!ATTLIST library
name CDATA #REQUIRED
dirname CDATA #REQUIRED
html-only CDATA #IMPLIED
url CDATA #IMPLIED
%boost.common.attrib;>
<!ELEMENT boostbook (title, (chapter|library)*)>
<!ATTLIST boostbook %boost.common.attrib;>
<!ELEMENT libraryinfo (author+, copyright*, legalnotice*, librarypurpose, librarycategory*)>
<!ATTLIST libraryinfo %boost.common.attrib;>
<!ELEMENT librarypurpose (#PCDATA|code|ulink|functionname|methodname|classname|macroname|headername|enumname|globalname)*>
<!ATTLIST librarypurpose %boost.common.attrib;>
<!ELEMENT librarycategory (#PCDATA)>
<!ATTLIST librarycategory
name CDATA #REQUIRED
%boost.common.attrib;>
<!ELEMENT libraryname (#PCDATA)>
<!ATTLIST libraryname %boost.common.attrib;>
<!ELEMENT library-reference ANY>
<!ATTLIST library-reference
%boost.common.attrib;>
<!ELEMENT librarylist EMPTY>
<!ATTLIST librarylist %boost.common.attrib;>
<!ELEMENT librarycategorylist (librarycategorydef)*>
<!ATTLIST librarycategorylist %boost.common.attrib;>
<!ELEMENT librarycategorydef (#PCDATA)>
<!ATTLIST librarycategorydef
name CDATA #REQUIRED
%boost.common.attrib;>
<!ELEMENT header ANY>
<!ATTLIST header
name CDATA #REQUIRED
%boost.common.attrib;>
<!ELEMENT namespace (%boost.namespace.mix;)*>
<!ATTLIST namespace
name CDATA #REQUIRED
%boost.common.attrib;>
<!ELEMENT class (%boost.class.content;)>
<!ATTLIST class
name CDATA #REQUIRED
%boost.common.attrib;>
<!ELEMENT struct (%boost.class.content;)>
<!ATTLIST struct
name CDATA #REQUIRED
%boost.common.attrib;>
<!ELEMENT union (%boost.class.content;)>
<!ATTLIST union
name CDATA #REQUIRED
%boost.common.attrib;>
<!ELEMENT class-specialization (%boost.class-specialization.content;)>
<!ATTLIST class-specialization
name CDATA #REQUIRED
%boost.common.attrib;>
<!ELEMENT struct-specialization (%boost.class-specialization.content;)>
<!ATTLIST struct-specialization
name CDATA #REQUIRED
%boost.common.attrib;>
<!ELEMENT union-specialization (%boost.class-specialization.content;)>
<!ATTLIST union-specialization
name CDATA #REQUIRED
%boost.common.attrib;>
<!ELEMENT access (%boost.class.members;)+>
<!ATTLIST access
name CDATA #REQUIRED
%boost.common.attrib;>
<!--========= C++ Templates =========-->
<!ELEMENT template (%boost.template.mix;)*>
<!ATTLIST template %boost.common.attrib;>
<!ELEMENT template-type-parameter (default?, purpose?)>
<!ATTLIST template-type-parameter
name CDATA #REQUIRED
pack CDATA #IMPLIED
%boost.common.attrib;>
<!ELEMENT template-nontype-parameter (type, default?, purpose?)>
<!ATTLIST template-nontype-parameter
name CDATA #REQUIRED
pack CDATA #IMPLIED
%boost.common.attrib;>
<!ELEMENT template-varargs EMPTY>
<!ATTLIST template-varargs %boost.common.attrib;>
<!ELEMENT specialization (template-arg)*>
<!ATTLIST specialization %boost.common.attrib;>
<!ELEMENT template-arg ANY>
<!ATTLIST template-arg
pack CDATA #IMPLIED
%boost.common.attrib;>
<!ELEMENT default ANY>
<!ATTLIST default %boost.common.attrib;>
<!ELEMENT inherit (type, purpose?)>
<!ATTLIST inherit
access CDATA #IMPLIED
pack CDATA #IMPLIED
%boost.common.attrib;>
<!ELEMENT purpose ANY>
<!ATTLIST purpose %boost.common.attrib;>
<!ELEMENT description ANY>
<!ATTLIST description %boost.common.attrib;>
<!ELEMENT type ANY>
<!ATTLIST type %boost.common.attrib;>
<!ELEMENT typedef (type, purpose?, description?)>
<!ATTLIST typedef
name CDATA #REQUIRED
%boost.common.attrib;>
<!ELEMENT enum (enumvalue*, purpose?, description?)>
<!ATTLIST enum
name CDATA #REQUIRED
%boost.common.attrib;>
<!ELEMENT enumvalue (default?, purpose?, description?)>
<!ATTLIST enumvalue
name CDATA #REQUIRED
%boost.common.attrib;>
<!ELEMENT static-constant (type, default, purpose?, description?)>
<!ATTLIST static-constant
name CDATA #REQUIRED
%boost.common.attrib;>
<!ELEMENT data-member (type, purpose?, description?)>
<!ATTLIST data-member
name CDATA #REQUIRED
specifiers CDATA #IMPLIED
%boost.common.attrib;>
<!ELEMENT paramtype ANY>
<!ATTLIST paramtype %boost.common.attrib;>
<!ELEMENT effects ANY>
<!ATTLIST effects %boost.common.attrib;>
<!ELEMENT postconditions ANY>
<!ATTLIST postconditions %boost.common.attrib;>
<!ELEMENT method-group (method|overloaded-method)*>
<!ATTLIST method-group
name CDATA #REQUIRED
%boost.common.attrib;>
<!ELEMENT constructor (template?, parameter*, %boost.function.semantics;)>
<!ATTLIST constructor
specifiers CDATA #IMPLIED
%boost.common.attrib;>
<!ELEMENT destructor (%boost.function.semantics;)>
<!ATTLIST destructor
specifiers CDATA #IMPLIED
%boost.common.attrib;>
<!ELEMENT method (template?, type, parameter*, %boost.function.semantics;)>
<!ATTLIST method
name CDATA #REQUIRED
cv CDATA #IMPLIED
specifiers CDATA #IMPLIED
%boost.common.attrib;>
<!ELEMENT function (template?, type, parameter*, %boost.function.semantics;)>
<!ATTLIST function
name CDATA #REQUIRED
specifiers CDATA #IMPLIED
%boost.common.attrib;>
<!ELEMENT overloaded-method (signature*, %boost.function.semantics;)>
<!ATTLIST overloaded-method
name CDATA #REQUIRED
%boost.common.attrib;>
<!ELEMENT overloaded-function (signature*, %boost.function.semantics;)>
<!ATTLIST overloaded-function
name CDATA #REQUIRED
%boost.common.attrib;>
<!ELEMENT signature (template?, type, parameter*)>
<!ATTLIST signature
cv CDATA #IMPLIED
specifiers CDATA #IMPLIED
%boost.common.attrib;>
<!ELEMENT requires ANY>
<!ATTLIST requires %boost.common.attrib;>
<!ELEMENT returns ANY>
<!ATTLIST returns %boost.common.attrib;>
<!ELEMENT throws ANY>
<!ATTLIST throws %boost.common.attrib;>
<!ELEMENT complexity ANY>
<!ATTLIST complexity %boost.common.attrib;>
<!ELEMENT notes ANY>
<!ATTLIST notes %boost.common.attrib;>
<!ELEMENT rationale ANY>
<!ATTLIST rationale %boost.common.attrib;>
<!ELEMENT functionname (#PCDATA)>
<!ATTLIST functionname
alt CDATA #IMPLIED
%boost.common.attrib;>
<!ELEMENT enumname (#PCDATA)>
<!ATTLIST enumname
alt CDATA #IMPLIED
%boost.common.attrib;>
<!ELEMENT macroname (#PCDATA)>
<!ATTLIST macroname
alt CDATA #IMPLIED
%boost.common.attrib;>
<!ELEMENT headername (#PCDATA)>
<!ATTLIST headername
alt CDATA #IMPLIED
%boost.common.attrib;>
<!ELEMENT globalname (#PCDATA)>
<!ATTLIST globalname
alt CDATA #IMPLIED
%boost.common.attrib;>
<!ELEMENT copy-assignment
(template?, type?, parameter*, %boost.function.semantics;)>
<!ATTLIST copy-assignment
cv CDATA #IMPLIED
specifiers CDATA #IMPLIED
%boost.common.attrib;>
<!ELEMENT free-function-group (function|overloaded-function)*>
<!ATTLIST free-function-group
name CDATA #REQUIRED
%boost.common.attrib;>
<!ELEMENT precondition ANY>
<!ATTLIST precondition %boost.common.attrib;>
<!ELEMENT code ANY>
<!ATTLIST code %boost.common.attrib;>
<!ELEMENT using-namespace EMPTY>
<!ATTLIST using-namespace
name CDATA #REQUIRED
%boost.common.attrib;>
<!ELEMENT using-class EMPTY>
<!ATTLIST using-class
name CDATA #REQUIRED
%boost.common.attrib;>
<!--========== Boost Testsuite Extensions ==========-->
<!ENTITY % boost.testsuite.tests
"compile-test|link-test|run-test|
compile-fail-test|link-fail-test|run-fail-test">
<!ENTITY % boost.testsuite.test.content
"source*, lib*, requirement*, purpose, if-fails?">
<!ELEMENT testsuite ((%boost.testsuite.tests;)+)>
<!ATTLIST testsuite %boost.common.attrib;>
<!ELEMENT compile-test (%boost.testsuite.test.content;)>
<!ATTLIST compile-test
filename CDATA #REQUIRED
name CDATA #IMPLIED>
<!ELEMENT link-test (%boost.testsuite.test.content;)>
<!ATTLIST link-test
filename CDATA #REQUIRED
name CDATA #IMPLIED>
<!ELEMENT run-test (%boost.testsuite.test.content;)>
<!ATTLIST run-test
filename CDATA #REQUIRED
name CDATA #IMPLIED>
<!ELEMENT compile-fail-test (%boost.testsuite.test.content;)>
<!ATTLIST compile-fail-test
filename CDATA #REQUIRED
name CDATA #IMPLIED>
<!ELEMENT link-fail-test (%boost.testsuite.test.content;)>
<!ATTLIST link-fail-test
filename CDATA #REQUIRED
name CDATA #IMPLIED>
<!ELEMENT run-fail-test (%boost.testsuite.test.content;)>
<!ATTLIST run-fail-test
filename CDATA #REQUIRED
name CDATA #IMPLIED>
<!ELEMENT source (#PCDATA|snippet)*>
<!ELEMENT snippet EMPTY>
<!ATTLIST snippet
name CDATA #REQUIRED>
<!ELEMENT lib (#PCDATA)>
<!ELEMENT requirement (#PCDATA)>
<!ATTLIST requirement
name CDATA #REQUIRED>
<!ELEMENT if-fails ANY>
<!ELEMENT parameter (paramtype, default?, description?)>
<!ATTLIST parameter
name CDATA #IMPLIED
pack CDATA #IMPLIED>
<!ELEMENT programlisting ANY>
<!ATTLIST programlisting
name CDATA #IMPLIED>
<!--========== Customize the DocBook DTD ==========-->
<!ENTITY % local.tech.char.class "|functionname|libraryname|enumname|headername|macroname|code">
<!ENTITY % local.para.class
"|using-namespace|using-class|librarylist|librarycategorylist">
<!ENTITY % local.descobj.class "|libraryinfo">
<!ENTITY % local.classname.attrib "alt CDATA #IMPLIED">
<!ENTITY % local.methodname.attrib "alt CDATA #IMPLIED">
<!ENTITY % local.refentry.class "|library-reference|testsuite">
<!ENTITY % local.title.char.mix "">
<!ENTITY % programlisting.module "IGNORE">
<!ENTITY % parameter.module "IGNORE">
<!ENTITY % function.module "IGNORE">
<!ENTITY % type.module "IGNORE">
<!--========== Import DocBook DTD ==========-->
<!ENTITY % DocBook PUBLIC "-//OASIS//DTD DocBook XML V4.2//EN"
"http://www.oasis-open.org/docbook/xml/4.2/docbookx.dtd">
%DocBook;

BIN
doc/images/beast.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 145 KiB

34
doc/qbk/00_main.qbk
View File

@@ -22,8 +22,8 @@
[template mdash[] '''&mdash; ''']
[template indexterm1[term1] '''<indexterm><primary>'''[term1]'''</primary></indexterm>''']
[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>'''>]]
[template repo_file[path] '''<ulink url="https://github.com/boostorg/Beast/blob/master/'''[path]'''">'''[path]'''</ulink>''']
[template include_file[path][^<'''<ulink url="https://github.com/boostorg/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]]]
@@ -64,19 +64,19 @@
[def __Stream__ [link beast.concepts.streams [*Stream]]]
[def __SyncStream__ [link beast.concepts.streams.SyncStream [*SyncStream]]]
[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 __flat_static_buffer__ [link beast.ref.beast__flat_static_buffer `flat_static_buffer`]]
[def __flat_static_buffer_base__ [link beast.ref.beast__flat_static_buffer_base `flat_static_buffer_base`]]
[def __basic_fields__ [link beast.ref.boost__beast__http__basic_fields `basic_fields`]]
[def __basic_multi_buffer__ [link beast.ref.boost__beast__basic_multi_buffer `basic_multi_buffer`]]
[def __basic_parser__ [link beast.ref.boost__beast__http__basic_parser `basic_parser`]]
[def __buffer_body__ [link beast.ref.boost__beast__http__buffer_body `buffer_body`]]
[def __fields__ [link beast.ref.boost__beast__http__fields `fields`]]
[def __flat_buffer__ [link beast.ref.boost__beast__flat_buffer `flat_buffer`]]
[def __header__ [link beast.ref.boost__beast__http__header `header`]]
[def __message__ [link beast.ref.boost__beast__http__message `message`]]
[def __multi_buffer__ [link beast.ref.boost__beast__multi_buffer `multi_buffer`]]
[def __parser__ [link beast.ref.boost__beast__http__parser `parser`]]
[def __serializer__ [link beast.ref.boost__beast__http__serializer `serializer`]]
[def __flat_static_buffer__ [link beast.ref.boost__beast__flat_static_buffer `flat_static_buffer`]]
[def __flat_static_buffer_base__ [link beast.ref.boost__beast__flat_static_buffer_base `flat_static_buffer_base`]]
[import ../../example/common/detect_ssl.hpp]
[import ../../example/doc/http_examples.hpp]
@@ -84,7 +84,7 @@
[import ../../example/http-client/http_client.cpp]
[import ../../example/websocket-client/websocket_client.cpp]
[import ../../include/beast/http/basic_file_body.hpp]
[import ../../include/boost/beast/http/basic_file_body.hpp]
[import ../../test/exemplars.cpp]
[import ../../test/core/doc_snippets.cpp]
@@ -104,7 +104,7 @@
[xinclude quickref.xml]
[endsect]
[block'''<reference id="hidden"><title>This Page Intentionally Left Blank 1/2</title>''']
[block'''<reference id="beast_hidden"><title>This Page Intentionally Left Blank 1/2</title>''']
[section:ref This Page Intentionally Left Blank 2/2]
[include ../reference.qbk]
[endsect]

2
doc/qbk/03_core.qbk
View File

@@ -5,7 +5,7 @@
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
]
[section Using I/O]
[section:using_io Using I/O]
This library makes I/O primitives used by the implementation publicly
available so users can take advantage of them in their own libraries.

4
doc/qbk/03_core/1_asio.qbk
View File

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

18
doc/qbk/03_core/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.beast__get_lowest_layer `get_lowest_layer`]
[link beast.ref.boost__beast__get_lowest_layer `get_lowest_layer`]
][
Returns `T::lowest_layer_type` if it exists, else returns `T`.
]]
[[
[link beast.ref.beast__has_get_io_service `has_get_io_service`]
[link beast.ref.boost__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.beast__is_async_read_stream `is_async_read_stream`]
[link beast.ref.boost__beast__is_async_read_stream `is_async_read_stream`]
][
Determine if a type meets the requirements of __AsyncReadStream__.
]]
[[
[link beast.ref.beast__is_async_stream `is_async_stream`]
[link beast.ref.boost__beast__is_async_stream `is_async_stream`]
][
Determine if a type meets the requirements of both __AsyncReadStream__
and __AsyncWriteStream__.
]]
[[
[link beast.ref.beast__is_async_write_stream `is_async_write_stream`]
[link beast.ref.boost__beast__is_async_write_stream `is_async_write_stream`]
][
Determine if a type meets the requirements of __AsyncWriteStream__.
]]
[[
[link beast.ref.beast__is_completion_handler `is_completion_handler`]
[link beast.ref.boost__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.beast__is_sync_read_stream `is_sync_read_stream`]
[link beast.ref.boost__beast__is_sync_read_stream `is_sync_read_stream`]
][
Determine if a type meets the requirements of __SyncReadStream__.
]]
[[
[link beast.ref.beast__is_sync_stream `is_sync_stream`]
[link beast.ref.boost__beast__is_sync_stream `is_sync_stream`]
][
Determine if a type meets the requirements of both __SyncReadStream__
and __SyncWriteStream__.
]]
[[
[link beast.ref.beast__is_sync_write_stream `is_sync_write_stream`]
[link beast.ref.boost__beast__is_sync_write_stream `is_sync_write_stream`]
][
Determine if a type meets the requirements of __SyncWriteStream__.
]]

46
doc/qbk/03_core/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.beast__is_dynamic_buffer `is_dynamic_buffer`]
[link beast.ref.boost__beast__is_dynamic_buffer `is_dynamic_buffer`]
][
Determine if a type meets the requirements of __DynamicBuffer__.
]]
[[
[link beast.ref.beast__is_const_buffer_sequence `is_const_buffer_sequence`]
[link beast.ref.boost__beast__is_const_buffer_sequence `is_const_buffer_sequence`]
][
Determine if a type meets the requirements of __ConstBufferSequence__.
]]
[[
[link beast.ref.beast__is_mutable_buffer_sequence `is_mutable_buffer_sequence`]
[link beast.ref.boost__beast__is_mutable_buffer_sequence `is_mutable_buffer_sequence`]
][
Determine if a type meets the requirements of __MutableBufferSequence__.
]]
@@ -41,7 +41,7 @@ of scenarios:
[table Dynamic Buffer Implementations
[[Name][Description]]
[[
[link beast.ref.beast__buffers_adapter `buffers_adapter`]
[link beast.ref.boost__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
@@ -49,7 +49,7 @@ of scenarios:
The implementation does not perform heap allocations.
]]
[[
[link beast.ref.beast__drain_buffer `drain_buffer`]
[link beast.ref.boost__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
@@ -58,8 +58,8 @@ of scenarios:
efficiently discard the data.
]]
[[
[link beast.ref.beast__flat_buffer `flat_buffer`]
[link beast.ref.beast__basic_flat_buffer `basic_flat_buffer`]
[link beast.ref.boost__beast__flat_buffer `flat_buffer`]
[link beast.ref.boost__beast__basic_flat_buffer `basic_flat_buffer`]
][
Guarantees that input and output areas are buffer sequences with
length one.
@@ -69,8 +69,8 @@ of scenarios:
[@http://en.cppreference.com/w/cpp/concept/AllocatorAwareContainer [*AllocatorAwareContainer]].
]]
[[
[link beast.ref.beast__multi_buffer `multi_buffer`]
[link beast.ref.beast__basic_multi_buffer `basic_multi_buffer`]
[link beast.ref.boost__beast__multi_buffer `multi_buffer`]
[link beast.ref.boost__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
@@ -79,8 +79,8 @@ of scenarios:
[@http://en.cppreference.com/w/cpp/concept/AllocatorAwareContainer [*AllocatorAwareContainer]].
]]
[[
[link beast.ref.beast__flat_static_buffer `flat_static_buffer`]
[link beast.ref.beast__flat_static_buffer_base `flat_static_buffer_base`]
[link beast.ref.boost__beast__flat_static_buffer `flat_static_buffer`]
[link beast.ref.boost__beast__flat_static_buffer_base `flat_static_buffer_base`]
][
Guarantees that input and output areas are buffer sequences with
length one.
@@ -90,8 +90,8 @@ of scenarios:
kept in the class; the implementation does not perform heap allocations.
]]
[[
[link beast.ref.beast__static_buffer `static_buffer`]
[link beast.ref.beast__static_buffer_base `static_buffer_base`]
[link beast.ref.boost__beast__static_buffer `static_buffer`]
[link beast.ref.boost__beast__static_buffer_base `static_buffer_base`]
][
Provides the facilities of a circular dynamic buffer. subject to an
upper limit placed on the total size of the input and output areas
@@ -114,7 +114,7 @@ transferred.
[table Buffer Algorithms and Types
[[Name][Description]]
[[
[link beast.ref.beast__buffer_cat `buffer_cat`]
[link beast.ref.boost__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
@@ -123,33 +123,33 @@ transferred.
expensive system calls.
]]
[[
[link beast.ref.beast__buffer_cat_view `buffer_cat_view`]
[link beast.ref.boost__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.beast__buffer_cat `buffer_cat`].
[link beast.ref.boost__beast__buffer_cat `buffer_cat`].
]]
[[
[link beast.ref.beast__buffer_front `buffer_front`]
[link beast.ref.boost__beast__buffer_front `buffer_front`]
][
This function returns the first buffer in a buffer sequence,
or a buffer of size zero if the buffer sequence has no elements.
]]
[[
[link beast.ref.beast__buffer_prefix `buffer_prefix`]
[link beast.ref.boost__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.beast__buffer_prefix_view `buffer_prefix_view`]
[link beast.ref.boost__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.beast__buffer_prefix.overload3 `buffer_prefix`].
[link beast.ref.boost__beast__buffer_prefix.overload3 `buffer_prefix`].
]]
[[
[link beast.ref.beast__consuming_buffers `consuming_buffers`]
[link beast.ref.boost__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
@@ -164,13 +164,13 @@ output streams.
[table Buffer Output Streams
[[Name][Description]]
[[
[link beast.ref.beast__buffers `buffers`]
[link beast.ref.boost__beast__buffers `buffers`]
][
This function wraps a __ConstBufferSequence__ so it may be
used with `operator<<` and `std::ostream`.
]]
[[
[link beast.ref.beast__ostream `ostream`]
[link beast.ref.boost__beast__ostream `ostream`]
][
This function returns a `std::ostream` which wraps a dynamic buffer.
Characters sent to the stream using `operator<<` are stored in the

6
doc/qbk/03_core/4_files.qbk
View File

@@ -15,19 +15,19 @@ underlying filesystem:
[table File Types
[[Name][Description]]
[[
[link beast.ref.beast__file_stdio `file_stdio`]
[link beast.ref.boost__beast__file_stdio `file_stdio`]
][
This implementation of __File__ uses the C++ standard library
facilities obtained by including `<cstdio>`.
]]
[[
[link beast.ref.beast__file_win32 `file_win32`]
[link beast.ref.boost__beast__file_win32 `file_win32`]
][
This implements a __File__ for the Win32 API. It provides low level
access to the native file handle when necessary.
]]
[[
[link beast.ref.beast__file_posix `file_posix`]
[link beast.ref.boost__beast__file_posix `file_posix`]
][
For POSIX systems, this class provides a suitable implementation
of __File__ which wraps the native file descriptor and provides

14
doc/qbk/03_core/5_composed.qbk
View File

@@ -37,7 +37,7 @@ composed operations:
[table Asynchronous Helpers
[[Name][Description]]
[[
[link beast.ref.beast__async_completion `async_completion`]
[link beast.ref.boost__beast__async_completion `async_completion`]
][
This class aggregates the completion handler customization point and
the asynchronous initiation function return value customization point
@@ -46,7 +46,7 @@ composed operations:
implement an initiation function using the Extensible Model.
]]
[[
[link beast.ref.beast__async_return_type `async_return_type`]
[link beast.ref.boost__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
@@ -54,7 +54,7 @@ composed operations:
Extensible Asynchronous Model.
]]
[[
[link beast.ref.beast__bind_handler `bind_handler`]
[link beast.ref.boost__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
@@ -65,7 +65,7 @@ composed operations:
]]
[[
[link beast.ref.beast__handler_alloc `handler_alloc`]
[link beast.ref.boost__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.
@@ -74,7 +74,7 @@ composed operations:
must be freed before the final completion handler is invoked.
]]
[[
[link beast.ref.beast__handler_ptr `handler_ptr`]
[link beast.ref.boost__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
@@ -86,7 +86,7 @@ composed operations:
optimizations transparently.
]]
[[
[link beast.ref.beast__handler_type `handler_type`]
[link beast.ref.boost__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
@@ -223,7 +223,7 @@ composed operations:
within this function. Invocation of the handler will be performed
in a manner equivalent to using `boost::asio::io_service::post`].
The function
[link beast.ref.beast__bind_handler `bind_handler`]
[link beast.ref.boost__beast__bind_handler `bind_handler`]
is provided for this purpose.
A complete, runnable version of this example may be found in the examples

68
doc/qbk/04_http.qbk
View File

@@ -31,12 +31,12 @@ format using __Asio__. Specifically, the library provides:
[Stream Reading]
[
The functions
[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`]
[link beast.ref.boost__beast__http__read `read`],
[link beast.ref.boost__beast__http__read_header `read_header`],
[link beast.ref.boost__beast__http__read_some `read_some`],
[link beast.ref.boost__beast__http__async_read `async_read`],
[link beast.ref.boost__beast__http__async_read_header `async_read_header`], and
[link beast.ref.boost__beast__http__async_read_some `async_read_some`]
read HTTP/1 message data from a
[link beast.concepts.streams stream].
]
@@ -44,12 +44,12 @@ format using __Asio__. Specifically, the library provides:
[Stream Writing]
[
The functions
[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`]
[link beast.ref.boost__beast__http__write `write`],
[link beast.ref.boost__beast__http__write_header `write_header`],
[link beast.ref.boost__beast__http__write_some `write_some`],
[link beast.ref.boost__beast__http__async_write `async_write`],
[link beast.ref.boost__beast__http__async_write_header `async_write_header`], and
[link beast.ref.boost__beast__http__async_write_some `async_write_some`]
write HTTP/1 message data to a
[link beast.concepts.streams stream].
]
@@ -85,10 +85,10 @@ parts of the implementation. The layers are arranged thusly:
At the highest level, these free functions send or receive
a complete HTTP message in one call. They are designed for
ease of use:
[link beast.ref.beast__http__read.overload4 `read`],
[link beast.ref.beast__http__write.overload4 `write`],
[link beast.ref.beast__http__async_read.overload2 `async_read`], and
[link beast.ref.beast__http__async_write.overload2 `async_write`].
[link beast.ref.boost__beast__http__read.overload4 `read`],
[link beast.ref.boost__beast__http__write.overload4 `write`],
[link beast.ref.boost__beast__http__async_read.overload2 `async_read`], and
[link beast.ref.boost__beast__http__async_write.overload2 `async_write`].
]
][
[[*5]]
@@ -101,10 +101,10 @@ parts of the implementation. The layers are arranged thusly:
of bytes for message components during parsing, or regulating the
size of buffers emitted during output. These functions send or
receive complete messages using a serializer or parser:
[link beast.ref.beast__http__read.overload2 `read`],
[link beast.ref.beast__http__write.overload2 `write`],
[link beast.ref.beast__http__async_read.overload1 `async_read`], and
[link beast.ref.beast__http__async_write.overload1 `async_write`].
[link beast.ref.boost__beast__http__read.overload2 `read`],
[link beast.ref.boost__beast__http__write.overload2 `write`],
[link beast.ref.boost__beast__http__async_read.overload1 `async_read`], and
[link beast.ref.boost__beast__http__async_write.overload1 `async_write`].
]
][
@@ -116,10 +116,10 @@ parts of the implementation. The layers are arranged thusly:
header. For example, to read the header and take action before
continuing to read the body. These functions use a __parser__
or __serializer__ to read or write the header:
[link beast.ref.beast__http__read_header.overload2 `read_header`],
[link beast.ref.beast__http__write_header.overload2 `write_header`],
[link beast.ref.beast__http__async_read_header `async_read_header`], and
[link beast.ref.beast__http__async_write_header `async_write_header`].
[link beast.ref.boost__beast__http__read_header.overload2 `read_header`],
[link beast.ref.boost__beast__http__write_header.overload2 `write_header`],
[link beast.ref.boost__beast__http__async_read_header `async_read_header`], and
[link beast.ref.boost__beast__http__async_write_header `async_write_header`].
]
][
[[*3]]
@@ -133,10 +133,10 @@ parts of the implementation. The layers are arranged thusly:
or allows better control when setting timeouts for example.
These functions read or write bounded amounts of data and return
the number of bytes transacted:
[link beast.ref.beast__http__read_some.overload2 `read_some`],
[link beast.ref.beast__http__write_some.overload2 `write_some`],
[link beast.ref.beast__http__async_read_some `async_read_some`], and
[link beast.ref.beast__http__async_write_some `async_write_some`].
[link beast.ref.boost__beast__http__read_some.overload2 `read_some`],
[link beast.ref.boost__beast__http__write_some.overload2 `write_some`],
[link beast.ref.boost__beast__http__async_read_some `async_read_some`], and
[link beast.ref.boost__beast__http__async_write_some `async_write_some`].
]
][
[[*2]]
@@ -149,18 +149,18 @@ parts of the implementation. The layers are arranged thusly:
to assume direct control over incoming or outgoing chunks in a chunk
encoded message payload.
For parsing this is achieved by setting hooks using the functions
[link beast.ref.beast__http__parser.on_chunk_header `on_chunk_header`] and/or
[link beast.ref.beast__http__parser.on_chunk_body `on_chunk_body`].
[link beast.ref.boost__beast__http__parser.on_chunk_header `on_chunk_header`] and/or
[link beast.ref.boost__beast__http__parser.on_chunk_body `on_chunk_body`].
For serializing callers may first emit the header, and then use
these buffer sequence adapters to control the contents of each chunk
including
[@https://tools.ietf.org/html/rfc7230#section-4.1.1 ['chunk extensions]]
and the
[@https://tools.ietf.org/html/rfc7230#section-4.1.2 ['trailer-part]]:
[link beast.ref.beast__http__chunk_body `chunk_body`],
[link beast.ref.beast__http__chunk_crlf `chunk_crlf`],
[link beast.ref.beast__http__chunk_header `chunk_header`], and
[link beast.ref.beast__http__chunk_last `chunk_last`].
[link beast.ref.boost__beast__http__chunk_body `chunk_body`],
[link beast.ref.boost__beast__http__chunk_crlf `chunk_crlf`],
[link beast.ref.boost__beast__http__chunk_header `chunk_header`], and
[link beast.ref.boost__beast__http__chunk_last `chunk_last`].
]
][
[[*1]]

40
doc/qbk/04_http/02_message.qbk
View File

@@ -27,7 +27,7 @@ messages:
```
]]
[[
[link beast.ref.beast__http__request `request`]
[link beast.ref.boost__beast__http__request `request`]
][
```
/// A typical HTTP request
@@ -36,7 +36,7 @@ messages:
```
]]
[[
[link beast.ref.beast__http__response `response`]
[link beast.ref.boost__beast__http__response `response`]
][
```
/// A typical HTTP response
@@ -75,7 +75,7 @@ class template __header__ and some aliases to model HTTP/1 and HTTP/2 headers:
```
]]
[[
[link beast.ref.beast__http__request_header `request_header`]
[link beast.ref.boost__beast__http__request_header `request_header`]
][
```
/// A typical HTTP request header
@@ -84,7 +84,7 @@ class template __header__ and some aliases to model HTTP/1 and HTTP/2 headers:
```
]]
[[
[link beast.ref.beast__http__response_header `response_header`]
[link beast.ref.boost__beast__http__response_header `response_header`]
][
```
/// A typical HTTP response header
@@ -104,12 +104,12 @@ member functions of `Fields`. This diagram shows the inheritance
relationship between header and message, along with some of the
notable differences in members in each partial specialization:
[$images/message.png [width 730px] [height 410px]]
[$beast/images/message.png [width 730px] [height 410px]]
[heading:body Body Types]
Beast defines the __Body__ concept, which determines both the type of
the [link beast.ref.beast__http__message.body `message::body`] member
the [link beast.ref.boost__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. Users may define their own body types which
@@ -118,26 +118,26 @@ meet the requirements, or use the ones that come with the library:
[table
[[Name][Description]]
[[
[link beast.ref.beast__http__buffer_body `buffer_body`]
[link beast.ref.boost__beast__http__buffer_body `buffer_body`]
][
A body whose
[link beast.ref.beast__http__buffer_body__value_type `value_type`]
[link beast.ref.boost__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.beast__http__dynamic_body `dynamic_body`]
[link beast.ref.boost__beast__http__dynamic_body `dynamic_body`]
[link beast.ref.beast__http__basic_dynamic_body `basic_dynamic_body`]
[link beast.ref.boost__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.beast__http__empty_body `empty_body`]
[link beast.ref.boost__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
@@ -145,9 +145,9 @@ meet the requirements, or use the ones that come with the library:
with this body will generate a unique error.
]]
[[
[link beast.ref.beast__http__file_body `file_body`]
[link beast.ref.boost__beast__http__file_body `file_body`]
[link beast.ref.beast__http__basic_file_body `basic_file_body`]
[link beast.ref.boost__beast__http__basic_file_body `basic_file_body`]
][
This body is represented by a file opened for either reading or
writing. Messages with this body may be serialized and parsed.
@@ -155,17 +155,17 @@ meet the requirements, or use the ones that come with the library:
for streaming and incremental sends and receives.
]]
[[
[link beast.ref.beast__http__span_body `span_body`]
[link beast.ref.boost__beast__http__span_body `span_body`]
][
A body whose `value_type` is a
[link beast.ref.beast__span `span`],
[link beast.ref.boost__beast__span `span`],
a non-owning reference to a single linear buffer of bytes.
Messages with this body type may be serialized and parsed.
]]
[[
[link beast.ref.beast__http__string_body `string_body`]
[link beast.ref.boost__beast__http__string_body `string_body`]
[link beast.ref.beast__http__basic_string_body `basic_string_body`]
[link beast.ref.boost__beast__http__basic_string_body `basic_string_body`]
][
A body whose `value_type` is `std::basic_string` or `std::string`.
Insertion complexity is amortized constant time, while capacity
@@ -173,7 +173,7 @@ meet the requirements, or use the ones that come with the library:
and parsed. This is the type of body used in the examples.
]]
[[
[link beast.ref.beast__http__vector_body `vector_body`]
[link beast.ref.boost__beast__http__vector_body `vector_body`]
][
A body whose `value_type` is `std::vector`. Insertion complexity
is amortized constant time, while capacity grows geometrically.
@@ -204,7 +204,7 @@ request with an empty message body:
In this code we create an HTTP response with a status code indicating success.
This message has a body with a non-zero length. The function
[link beast.ref.beast__http__message.prepare_payload `message::prepare_payload`]
[link beast.ref.boost__beast__http__message.prepare_payload `message::prepare_payload`]
automatically sets the Content-Length or Transfer-Encoding field
depending on the content and type of the `body` member. Use of this function
is optional; these fields may also be set explicitly.
@@ -228,6 +228,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.beast__http__header.reason.overload2 `header::reason`].
[link beast.ref.boost__beast__http__header.reason.overload2 `header::reason`].
[endsect]

14
doc/qbk/04_http/03_streams.qbk
View File

@@ -14,22 +14,22 @@ the message-oriented stream interface:
[table Message Stream Operations
[[Name][Description]]
[[
[link beast.ref.beast__http__read.overload3 [*read]]
[link beast.ref.boost__beast__http__read.overload3 [*read]]
][
Read a __message__ from a __SyncReadStream__.
]]
[[
[link beast.ref.beast__http__async_read.overload2 [*async_read]]
[link beast.ref.boost__beast__http__async_read.overload2 [*async_read]]
][
Read a __message__ from an __AsyncReadStream__.
]]
[[
[link beast.ref.beast__http__write.overload1 [*write]]
[link beast.ref.boost__beast__http__write.overload1 [*write]]
][
Write a __message__ to a __SyncWriteStream__.
]]
[[
[link beast.ref.beast__http__async_write [*async_write]]
[link beast.ref.boost__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.beast__error_code `error_code&`]. If an error
argument of type [link beast.ref.boost__beast__error_code `error_code&`]. If an error
occurs this argument will be set to contain the error code.
@@ -77,7 +77,7 @@ completion:
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.beast__http__error `buffer_overflow`]
[link beast.ref.boost__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 print the error message:
@@ -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, then 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.beast__http__error `error::end_of_stream`]
[link beast.ref.boost__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/qbk/04_http/04_serializer_streams.qbk
View File

@@ -38,7 +38,7 @@ the message to be sent:
```
]]
[[
[link beast.ref.beast__http__request_serializer `request_serializer`]
[link beast.ref.boost__beast__http__request_serializer `request_serializer`]
][
```
/// A serializer for HTTP/1 requests
@@ -50,7 +50,7 @@ the message to be sent:
```
]]
[[
[link beast.ref.beast__http__response_serializer `response_serializer`]
[link beast.ref.boost__beast__http__response_serializer `response_serializer`]
][
```
/// A serializer for HTTP/1 responses
@@ -73,32 +73,32 @@ The stream operations which work on serializers are:
[table Serializer Stream Operations
[[Name][Description]]
[[
[link beast.ref.beast__http__write.overload1 [*write]]
[link beast.ref.boost__beast__http__write.overload1 [*write]]
][
Send everything in a __serializer__ to a __SyncWriteStream__.
]]
[[
[link beast.ref.beast__http__async_write.overload1 [*async_write]]
[link beast.ref.boost__beast__http__async_write.overload1 [*async_write]]
][
Send everything in a __serializer__ asynchronously to an __AsyncWriteStream__.
]]
[[
[link beast.ref.beast__http__write_header.overload1 [*write_header]]
[link beast.ref.boost__beast__http__write_header.overload1 [*write_header]]
][
Send only the header from a __serializer__ to a __SyncWriteStream__.
]]
[[
[link beast.ref.beast__http__async_write_header [*async_write_header]]
[link beast.ref.boost__beast__http__async_write_header [*async_write_header]]
][
Send only the header from a __serializer__ asynchronously to an __AsyncWriteStream__.
]]
[[
[link beast.ref.beast__http__write_some.overload1 [*write_some]]
[link beast.ref.boost__beast__http__write_some.overload1 [*write_some]]
][
Send part of a __serializer__ to a __SyncWriteStream__.
]]
[[
[link beast.ref.beast__http__async_write_some [*async_write_some]]
[link beast.ref.boost__beast__http__async_write_some [*async_write_some]]
][
Send part of a __serializer__ asynchronously to an __AsyncWriteStream__.
]]

22
doc/qbk/04_http/05_parser_streams.qbk
View File

@@ -40,7 +40,7 @@ __message__ objects using the __basic_fields__ Fields container.
```
]]
[[
[link beast.ref.beast__http__request_parser `request_parser`]
[link beast.ref.boost__beast__http__request_parser `request_parser`]
][
```
/// An HTTP/1 parser for producing a request message.
@@ -49,7 +49,7 @@ __message__ objects using the __basic_fields__ Fields container.
```
]]
[[
[link beast.ref.beast__http__response_parser `response_parser`]
[link beast.ref.boost__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.beast__http__read.overload1 [*read]]
[link beast.ref.boost__beast__http__read.overload1 [*read]]
][
Read everything into a parser from a __SyncWriteStream__.
]]
[[
[link beast.ref.beast__http__async_read.overload1 [*async_read]]
[link beast.ref.boost__beast__http__async_read.overload1 [*async_read]]
][
Read everything into a parser asynchronously from an __AsyncWriteStream__.
]]
[[
[link beast.ref.beast__http__read_header.overload1 [*read_header]]
[link beast.ref.boost__beast__http__read_header.overload1 [*read_header]]
][
Read only the header octets into a parser from a __SyncWriteStream__.
]]
[[
[link beast.ref.beast__http__async_read_header [*async_read_header]]
[link beast.ref.boost__beast__http__async_read_header [*async_read_header]]
][
Read only the header octets into a parser asynchronously from an __AsyncWriteStream__.
]]
[[
[link beast.ref.beast__http__read_some.overload1 [*read_some]]
[link beast.ref.boost__beast__http__read_some.overload1 [*read_some]]
][
Read some octets into a parser from a __SyncReadStream__.
]]
[[
[link beast.ref.beast__http__async_read_some [*async_read_some]]
[link beast.ref.boost__beast__http__async_read_some [*async_read_some]]
][
Read some octets into a parser asynchronously from an __AsyncWriteStream__.
]]
@@ -112,10 +112,10 @@ 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.beast__http__parser.get `parser::get`].
[link beast.ref.boost__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.beast__http__parser.release `parser::release`]. In this example
[link beast.ref.boost__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:
@@ -126,7 +126,7 @@ the response:
[section Incremental Read]
This function uses
[link beast.ref.beast__http__buffer_body `buffer_body`]
[link beast.ref.boost__beast__http__buffer_body `buffer_body`]
and parser stream operations to read a message body progressively
using a small, fixed-size buffer:

10
doc/qbk/04_http/06_serializer_buffers.qbk
View File

@@ -18,15 +18,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.beast__http__serializer.next `serializer::next`].
[link beast.ref.boost__beast__http__serializer.next `serializer::next`].
Then, call
[link beast.ref.beast__http__serializer.consume `serializer::consume`]
[link beast.ref.boost__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::next` 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.beast__http__serializer.is_done `serializer::is_done`]
[link beast.ref.boost__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:
@@ -44,11 +44,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.beast__http__serializer.split `serializer::split`]
[link beast.ref.boost__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.beast__http__serializer.is_header_done `serializer::is_header_done`]
[link beast.ref.boost__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:

12
doc/qbk/04_http/07_parser_buffers.qbk
View File

@@ -14,10 +14,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.beast__http__basic_parser.put `basic_parser::put`]
[link beast.ref.boost__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.beast__http__basic_parser.put_eof `basic_parser::put_eof`]
[link beast.ref.boost__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),
@@ -28,7 +28,7 @@ The parser provides a few options which may be set before parsing begins:
[table Parser Options
[[Name][Default][Description]]
[[
[link beast.ref.beast__http__basic_parser.eager.overload2 `eager`]
[link beast.ref.boost__beast__http__basic_parser.eager.overload2 `eager`]
][
`false`
][
@@ -43,7 +43,7 @@ The parser provides a few options which may be set before parsing begins:
stream operations to improve performance with no change in functionality.
]]
[[
[link beast.ref.beast__http__basic_parser.skip.overload2 `skip`]
[link beast.ref.boost__beast__http__basic_parser.skip.overload2 `skip`]
][
`false`
][
@@ -59,7 +59,7 @@ The parser provides a few options which may be set before parsing begins:
after the header has been received.
]]
[[
[link beast.ref.beast__http__basic_parser.body_limit `body_limit`]
[link beast.ref.boost__beast__http__basic_parser.body_limit `body_limit`]
][
1MB/8MB
][
@@ -70,7 +70,7 @@ The parser provides a few options which may be set before parsing begins:
parsing requests is 1MB, and for parsing responses 8MB.
]]
[[
[link beast.ref.beast__http__basic_parser.header_limit `header_limit`]
[link beast.ref.boost__beast__http__basic_parser.header_limit `header_limit`]
][
8KB
][

24
doc/qbk/04_http/08_chunked_encoding.qbk
View File

@@ -31,7 +31,7 @@ field value.
The __serializer__ automatically applies the chunked tranfer encoding
when a message returns `true` from
[link beast.ref.beast__http__message.chunked.overload1 `message::chunked`].
[link beast.ref.boost__beast__http__message.chunked.overload1 `message::chunked`].
The boundaries between chunks emitted by the serializer are implementation
defined. Chunk extensions and trailers are omitted. Applications which
need precise control over the chunk boundaries, extensions, and trailers
@@ -45,12 +45,12 @@ extensions, and desired trailers, and use them with these helpers:
[table Chunking Helpers
[[Name][Description]]
[
[[link beast.ref.beast__http__chunk_body `chunk_body`]]
[[link beast.ref.boost__beast__http__chunk_body `chunk_body`]]
[
A buffer sequence representing a complete chunk body.
]
][
[[link beast.ref.beast__http__chunk_crlf `chunk_crlf`]]
[[link beast.ref.boost__beast__http__chunk_crlf `chunk_crlf`]]
[
A buffer sequence representing the CRLF (`"\r\n"`) delimiter.
This class is used when the caller desires to emit the
@@ -58,17 +58,17 @@ extensions, and desired trailers, and use them with these helpers:
]
][
[
[link beast.ref.beast__http__chunk_extensions `chunk_extensions`]
[link beast.ref.boost__beast__http__chunk_extensions `chunk_extensions`]
[link beast.ref.beast__http__basic_chunk_extensions `basic_chunk_extensions`]
[link beast.ref.boost__beast__http__basic_chunk_extensions `basic_chunk_extensions`]
]
[
This is a simple, allocating container which lets callers
easily build up a set of chunk extensions.
]
][
[[link beast.ref.beast__http__chunk_header `chunk_header`]]
[[link beast.ref.boost__beast__http__chunk_header `chunk_header`]]
[
A buffer sequence representing a hex-encoded chunk size,
followed by an optional set of chunk extensions, including
@@ -78,7 +78,7 @@ extensions, and desired trailers, and use them with these helpers:
operations.
]
][
[[link beast.ref.beast__http__chunk_last `chunk_last`]]
[[link beast.ref.boost__beast__http__chunk_last `chunk_last`]]
[
A buffer sequence representing a last chunk. The last chunk
indicates the end of the chunked message payload, and may
@@ -86,9 +86,9 @@ extensions, and desired trailers, and use them with these helpers:
]
][
[
[link beast.ref.beast__http__make_chunk `make_chunk`]
[link beast.ref.boost__beast__http__make_chunk `make_chunk`]
[link beast.ref.beast__http__make_chunk_last `make_chunk_last`]
[link beast.ref.boost__beast__http__make_chunk_last `make_chunk_last`]
]
[
These helper functions are used to construct a chunk
@@ -156,7 +156,7 @@ interface provided by __parser__:
[table Chunking Parse Callbacks
[[Name][Description]]
[
[[link beast.ref.beast__http__parser.on_chunk_header `on_chunk_header`]]
[[link beast.ref.boost__beast__http__parser.on_chunk_header `on_chunk_header`]]
[
Set a callback to be invoked on each chunk header.
@@ -166,7 +166,7 @@ interface provided by __parser__:
octets have been parsed.
The extensions are provided in raw, validated form, use
[link beast.ref.beast__http__basic_chunk_extensions.parse `chunk_extensions::parse`]
[link beast.ref.boost__beast__http__basic_chunk_extensions.parse `chunk_extensions::parse`]
to parse the extensions into a structured container for easier access.
The implementation type-erases the callback without requiring
a dynamic allocation. For this reason, the callback object is
@@ -182,7 +182,7 @@ interface provided by __parser__:
```
]
][
[[link beast.ref.beast__http__parser.on_chunk_body `on_chunk_body`]]
[[link beast.ref.boost__beast__http__parser.on_chunk_body `on_chunk_body`]]
[
Set a callback to be invoked on chunk body data.

2
doc/qbk/04_http/09_custom_body.qbk
View File

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

2
doc/qbk/05_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.beast__http__empty_body `empty_body`]. Then, a new parser is constructed
[link beast.ref.boost__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/qbk/06_websocket/1_streams.qbk
View File

@@ -8,7 +8,7 @@
[section Creating Streams]
The interface to the WebSocket implementation is a single template class
[link beast.ref.beast__websocket__stream `stream`]
[link beast.ref.boost__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.beast__websocket__stream.next_layer.overload1 `stream::next_layer`]:
[link beast.ref.boost__beast__websocket__stream.next_layer.overload1 `stream::next_layer`]:
[ws_snippet_5]

10
doc/qbk/06_websocket/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.beast__websocket__stream.handshake.overload1 `handshake`] and
[link beast.ref.beast__websocket__stream.async_handshake.overload1 `async_handshake`]
[link beast.ref.boost__beast__websocket__stream.handshake.overload1 `handshake`] and
[link beast.ref.boost__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.beast__websocket__stream.handshake_ex `handshake_ex`] and
[link beast.ref.beast__websocket__stream.async_handshake_ex `async_handshake_ex`]
[link beast.ref.boost__beast__websocket__stream.handshake_ex `handshake_ex`] and
[link beast.ref.boost__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.beast__websocket__response_type `response_type`]
[link beast.ref.boost__beast__websocket__response_type `response_type`]
as follows:
[ws_snippet_10]

24
doc/qbk/06_websocket/4_server.qbk
View File

@@ -8,7 +8,7 @@
[section Handshaking (Servers)]
A
[link beast.ref.beast__websocket__stream `stream`]
[link beast.ref.boost__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.beast__websocket__stream.accept_ex `accept_ex`] and
[link beast.ref.beast__websocket__stream.async_accept_ex `async_accept_ex`]
[link beast.ref.boost__beast__websocket__stream.accept_ex `accept_ex`] and
[link beast.ref.boost__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.beast__websocket__is_upgrade `is_upgrade`] may be used.
[link beast.ref.boost__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.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`]
[link beast.ref.boost__beast__websocket__stream.accept `accept`],
[link beast.ref.boost__beast__websocket__stream.accept_ex `accept_ex`],
[link beast.ref.boost__beast__websocket__stream.async_accept `async_accept`], and
[link beast.ref.boost__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.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`]
[link beast.ref.boost__beast__websocket__stream.accept `accept`],
[link beast.ref.boost__beast__websocket__stream.accept_ex `accept_ex`],
[link beast.ref.boost__beast__websocket__stream.async_accept `async_accept`], and
[link beast.ref.boost__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/qbk/06_websocket/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.beast__websocket__stream.set_option `set_option`]
Calls to [link beast.ref.boost__beast__websocket__stream.set_option `set_option`]
must be made from the same implicit or explicit strand as that used
to perform other operations.
]

16
doc/qbk/06_websocket/6_control.qbk
View File

@@ -26,7 +26,7 @@ frames. If a control callback is registered, the callback is notified of
the incoming control frame. The implementation will respond to pings
automatically. The receipt of a close frame initiates the WebSocket
close procedure, eventually resulting in the error code
[link beast.ref.beast__websocket__error `error::closed`]
[link beast.ref.boost__beast__websocket__error `error::closed`]
being delivered to the caller in a subsequent read operation, assuming
no other error takes place.
@@ -44,13 +44,13 @@ frames.
Ping, pong, and close 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.beast__websocket__stream.ping `ping`],
[link beast.ref.beast__websocket__stream.pong `pong`].
[link beast.ref.boost__beast__websocket__stream.ping `ping`],
[link beast.ref.boost__beast__websocket__stream.pong `pong`].
and
[link beast.ref.beast__websocket__stream.close `close`].
[link beast.ref.boost__beast__websocket__stream.close `close`].
To be notified of control frames, callers may register a
['control callback] using
[link beast.ref.beast__websocket__stream.control_callback `control_callback`].
[link beast.ref.boost__beast__websocket__stream.control_callback `control_callback`].
The object provided with this option should be callable with the following
signature:
@@ -61,7 +61,7 @@ pongs, and close frames received through either synchronous read functions
or asynchronous read functions. The type of frame and payload text are
passed as parameters to the control callback. If the frame is a close
frame, the close reason may be obtained by calling
[link beast.ref.beast__websocket__stream.reason `reason`].
[link beast.ref.boost__beast__websocket__stream.reason `reason`].
Unlike regular completion handlers used in calls to asynchronous initiation
functions, the control callback only needs to be set once. The callback is
@@ -82,7 +82,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.beast__websocket__stream.close `close`] function:
[link beast.ref.boost__beast__websocket__stream.close `close`] function:
[ws_snippet_18]
@@ -97,7 +97,7 @@ before it receives and responds to the close frame.
[important
To receive the
[link beast.ref.beast__websocket__error `error::closed`]
[link beast.ref.boost__beast__websocket__error `error::closed`]
error, a read operation is required.
]

2
doc/qbk/06_websocket/7_notes.qbk
View File

@@ -40,7 +40,7 @@ or require threads.
[heading Thread Safety]
Like a regular __Asio__ socket, a
[link beast.ref.beast__websocket__stream `stream`]
[link beast.ref.boost__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

24
doc/qbk/07_concepts/Body.qbk
View File

@@ -13,7 +13,7 @@ the algorithms used during parsing and serialization.
[heading Associated Types]
* [link beast.ref.beast__http__is_body `is_body`]
* [link beast.ref.boost__beast__http__is_body `is_body`]
* __BodyReader__
* __BodyWriter__
@@ -72,11 +72,11 @@ In this table:
* The function shall not fail
* A call to
[link beast.ref.beast__http__message.payload_size `message::payload_size`]
[link beast.ref.boost__beast__http__message.payload_size `message::payload_size`]
will return the same value as `size`.
* A call to
[link beast.ref.beast__http__message.prepare_payload `message::prepare_payload`]
[link beast.ref.boost__beast__http__message.prepare_payload `message::prepare_payload`]
will remove "chunked" from the Transfer-Encoding field if it appears
as the last encoding, and will set the Content-Length field to the
returned value.
@@ -84,11 +84,11 @@ In this table:
Otherwise, when the function is omitted:
* A call to
[link beast.ref.beast__http__message.payload_size `message::payload_size`]
[link beast.ref.boost__beast__http__message.payload_size `message::payload_size`]
will return `boost::none`.
* A call to
[link beast.ref.beast__http__message.prepare_payload `message::prepare_payload`]
[link beast.ref.boost__beast__http__message.prepare_payload `message::prepare_payload`]
will erase the Content-Length field, and add "chunked" as the last
encoding in the Transfer-Encoding field if it is not already present.
]
@@ -100,12 +100,12 @@ In this table:
[heading Models]
* [link beast.ref.beast__http__basic_dynamic_body `basic_dynamic_body`]
* [link beast.ref.beast__http__basic_file_body `basic_file_body`]
* [link beast.ref.beast__http__basic_string_body `basic_string_body`]
* [link beast.ref.beast__http__buffer_body `buffer_body`]
* [link beast.ref.beast__http__empty_body `empty_body`]
* [link beast.ref.beast__http__span_body `span_body`]
* [link beast.ref.beast__http__vector_body `vector_body`]
* [link beast.ref.boost__beast__http__basic_dynamic_body `basic_dynamic_body`]
* [link beast.ref.boost__beast__http__basic_file_body `basic_file_body`]
* [link beast.ref.boost__beast__http__basic_string_body `basic_string_body`]
* [link beast.ref.boost__beast__http__buffer_body `buffer_body`]
* [link beast.ref.boost__beast__http__empty_body `empty_body`]
* [link beast.ref.boost__beast__http__span_body `span_body`]
* [link beast.ref.boost__beast__http__vector_body `vector_body`]
[endsect]

18
doc/qbk/07_concepts/BodyReader.qbk
View File

@@ -22,7 +22,7 @@ intended to obtain buffers for these scenarios:
[heading Associated Types]
* [link beast.ref.beast__http__is_body_reader `is_body_reader`]
* [link beast.ref.boost__beast__http__is_body_reader `is_body_reader`]
* __Body__
[heading Requirements]
@@ -35,7 +35,7 @@ In this table:
* `a` denotes a value of type `R`.
* `m` denotes a possibly const 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.beast__error_code `error_code&`].
* `ec` is a value of type [link beast.ref.boost__beast__error_code `error_code&`].
* `R<T>` is the type `boost::optional<std::pair<T, bool>>`.
[table Valid expressions
@@ -103,12 +103,12 @@ In this table:
[heading Models]
* [link beast.ref.beast__http__basic_dynamic_body.reader `basic_dynamic_body::reader`]
* [link beast.ref.beast__http__basic_file_body__reader `basic_file_body::reader`]
* [link beast.ref.beast__http__basic_string_body.reader `basic_string_body::reader`]
* [link beast.ref.beast__http__buffer_body.reader `buffer_body::reader`]
* [link beast.ref.beast__http__empty_body.reader `empty_body::reader`]
* [link beast.ref.beast__http__span_body.reader `span_body::reader`]
* [link beast.ref.beast__http__vector_body.reader `vector_body::reader`]
* [link beast.ref.boost__beast__http__basic_dynamic_body.reader `basic_dynamic_body::reader`]
* [link beast.ref.boost__beast__http__basic_file_body__reader `basic_file_body::reader`]
* [link beast.ref.boost__beast__http__basic_string_body.reader `basic_string_body::reader`]
* [link beast.ref.boost__beast__http__buffer_body.reader `buffer_body::reader`]
* [link beast.ref.boost__beast__http__empty_body.reader `empty_body::reader`]
* [link beast.ref.boost__beast__http__span_body.reader `span_body::reader`]
* [link beast.ref.boost__beast__http__vector_body.reader `vector_body::reader`]
[endsect]

18
doc/qbk/07_concepts/BodyWriter.qbk
View File

@@ -22,7 +22,7 @@ representation:
[heading Associated Types]
* [link beast.ref.beast__http__is_body_writer `is_body_writer`]
* [link beast.ref.boost__beast__http__is_body_writer `is_body_writer`]
* __Body__
[heading Requirements]
@@ -37,7 +37,7 @@ In this table:
* `m` denotes a value of type `message&` where
`std::is_same<decltype(m.body), Body::value_type>::value == true`.
* `n` is a value of type `boost::optional<std::uint64_t>`.
* `ec` is a value of type [link beast.ref.beast__error_code `error_code&`].
* `ec` is a value of type [link beast.ref.boost__beast__error_code `error_code&`].
[table Valid expressions
[[Expression] [Type] [Semantics, Pre/Post-conditions]]
@@ -106,12 +106,12 @@ In this table:
[heading Models]
* [link beast.ref.beast__http__basic_dynamic_body.writer `basic_dynamic_body::writer`]
* [link beast.ref.beast__http__basic_file_body__writer `basic_file_body::writer`]
* [link beast.ref.beast__http__basic_string_body.writer `basic_string_body::writer`]
* [link beast.ref.beast__http__buffer_body.writer `buffer_body::writer`]
* [link beast.ref.beast__http__empty_body.writer `empty_body::writer`]
* [link beast.ref.beast__http__span_body.writer `span_body::writer`]
* [link beast.ref.beast__http__vector_body.writer `vector_body::writer`]
* [link beast.ref.boost__beast__http__basic_dynamic_body.writer `basic_dynamic_body::writer`]
* [link beast.ref.boost__beast__http__basic_file_body__writer `basic_file_body::writer`]
* [link beast.ref.boost__beast__http__basic_string_body.writer `basic_string_body::writer`]
* [link beast.ref.boost__beast__http__buffer_body.writer `buffer_body::writer`]
* [link beast.ref.boost__beast__http__empty_body.writer `empty_body::writer`]
* [link beast.ref.boost__beast__http__span_body.writer `span_body::writer`]
* [link beast.ref.boost__beast__http__vector_body.writer `vector_body::writer`]
[endsect]

20
doc/qbk/07_concepts/DynamicBuffer.qbk
View File

@@ -33,7 +33,7 @@ implementation strategies:
[heading Associated Types]
* [link beast.ref.beast__is_dynamic_buffer `is_dynamic_buffer`]
* [link beast.ref.boost__beast__is_dynamic_buffer `is_dynamic_buffer`]
* __ConstBufferSequence__
* __MutableBufferSequence__
@@ -122,14 +122,14 @@ implementation strategies:
[heading Models]
* [link beast.ref.beast__basic_flat_buffer `basic_flat_buffer`]
* [link beast.ref.beast__basic_multi_buffer `basic_multi_buffer`]
* [link beast.ref.beast__drain_buffer `drain_buffer`]
* [link beast.ref.beast__flat_buffer `flat_buffer`]
* [link beast.ref.beast__flat_static_buffer `flat_static_buffer`]
* [link beast.ref.beast__flat_static_buffer_base `flat_static_buffer_base`]
* [link beast.ref.beast__static_buffer `static_buffer`]
* [link beast.ref.beast__static_buffer_base `static_buffer_base`]
* [link beast.ref.beast__multi_buffer `multi_buffer`]
* [link beast.ref.boost__beast__basic_flat_buffer `basic_flat_buffer`]
* [link beast.ref.boost__beast__basic_multi_buffer `basic_multi_buffer`]
* [link beast.ref.boost__beast__drain_buffer `drain_buffer`]
* [link beast.ref.boost__beast__flat_buffer `flat_buffer`]
* [link beast.ref.boost__beast__flat_static_buffer `flat_static_buffer`]
* [link beast.ref.boost__beast__flat_static_buffer_base `flat_static_buffer_base`]
* [link beast.ref.boost__beast__static_buffer `static_buffer`]
* [link beast.ref.boost__beast__static_buffer_base `static_buffer_base`]
* [link beast.ref.boost__beast__multi_buffer `multi_buffer`]
[endsect]

8
doc/qbk/07_concepts/Fields.qbk
View File

@@ -15,7 +15,7 @@ be serialized.
[heading Associated Types]
* [link beast.ref.beast__http__is_fields `is_fields`]
* [link beast.ref.boost__beast__http__is_fields `is_fields`]
* __FieldsReader__
[heading Requirements]
@@ -28,7 +28,7 @@ In this table:
* `c` denotes a (possibly const) value of type `F`.
* `b` is a value of type `bool`
* `n` is a value of type `boost::optional<std::uint64_t>`.
* `s` is a value of type [link beast.ref.beast__string_view `string_view`].
* `s` is a value of type [link beast.ref.boost__beast__string_view `string_view`].
* `v` is a value of type `unsigned int` representing the HTTP-version.
[table Valid expressions
@@ -211,7 +211,7 @@ In this table:
[heading Models]
* [link beast.ref.beast__http__basic_fields `basic_fields`]
* [link beast.ref.beast__http__fields `fields`]
* [link beast.ref.boost__beast__http__basic_fields `basic_fields`]
* [link beast.ref.boost__beast__http__fields `fields`]
[endsect]

4
doc/qbk/07_concepts/FieldsReader.qbk
View File

@@ -27,7 +27,7 @@ In this table:
* `f` is a value of type `F`.
* `v` is an `unsigned` value representing the HTTP version.
* `c` is an `unsigned` representing the HTTP status-code.
* `m` is a value of type [link beast.ref.beast__http__verb `verb`].
* `m` is a value of type [link beast.ref.boost__beast__http__verb `verb`].
[table Valid expressions
[[expression][type][semantics, pre/post-conditions]]
@@ -73,6 +73,6 @@ In this table:
[heading Models]
* [link beast.ref.beast__http__basic_fields.reader `basic_fields::reader`]
* [link beast.ref.boost__beast__http__basic_fields.reader `basic_fields::reader`]
[endsect]

14
doc/qbk/07_concepts/File.qbk
View File

@@ -13,8 +13,8 @@ types which meet these requirements.
[heading Associated Types]
* [link beast.ref.beast__file_mode `file_mode`]
* [link beast.ref.beast__is_file `is_file`]
* [link beast.ref.boost__beast__file_mode `file_mode`]
* [link beast.ref.boost__beast__is_file `is_file`]
[heading Requirements]
@@ -24,12 +24,12 @@ In this table:
* `f` is an instance of `F`
* `p` is a value of type `char const*` which points to a null
terminated utf-8 encoded string.
* `m` is an instance of [link beast.ref.beast__file_mode `file_mode`]
* `m` is an instance of [link beast.ref.boost__beast__file_mode `file_mode`]
* `n` is a number of bytes, convertible to `std::size_t`
* `o` is a byte offset in the file, convertible to `std::uint64_t`
* `b` is any non-const pointer to memory
* `c` is any possibly-const pointer to memory
* `ec` is a reference of type [link beast.ref.beast__error_code `error_code`]
* `ec` is a reference of type [link beast.ref.boost__beast__error_code `error_code`]
[table Valid expressions
[[Expression] [Type] [Semantics, Pre/Post-conditions]]
@@ -170,8 +170,8 @@ In this table:
[heading Models]
* [link beast.ref.beast__file_posix `file_posix`]
* [link beast.ref.beast__file_stdio `file_stdio`]
* [link beast.ref.beast__file_win32 `file_win32`]
* [link beast.ref.boost__beast__file_posix `file_posix`]
* [link beast.ref.boost__beast__file_stdio `file_stdio`]
* [link beast.ref.boost__beast__file_win32 `file_win32`]
[endsect]

2
doc/qbk/08_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.beast__flat_static_buffer `flat_static_buffer`]).
in a [link beast.ref.boost__beast__flat_static_buffer `flat_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/qbk/08_design/4_faq.qbk
View File

@@ -271,8 +271,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.beast__websocket__teardown `teardown`] and
[link beast.ref.beast__websocket__async_teardown `async_teardown`]. These will
[link beast.ref.boost__beast__websocket__teardown `teardown`] and
[link beast.ref.boost__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.

3
doc/qbk/index.xml
View File

@@ -1,6 +1,5 @@
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN" "../boostbook.dtd">
<!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN" "../../../../tools/boostbook/dtd/boostbook.dtd">
<!--
Copyright (c) 2013-2017 Vinnie Falco (vinnie dot falco at gmail dot com)

298
doc/qbk/quickref.xml
View File

@@ -1,5 +1,5 @@
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN" "../boostbook.dtd">
<!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN" "../../../../tools/boostbook/dtd/boostbook.dtd">
<!--
Copyright (c) 2013-2017 Vinnie Falco (vinnie dot falco at gmail dot com)
@@ -29,88 +29,88 @@
<entry valign="top">
<bridgehead renderas="sect3">Classes</bridgehead>
<simplelist type="vert" columns="1">
<member><link linkend="beast.ref.beast__http__basic_chunk_extensions">basic_chunk_extensions</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_file_body">basic_file_body</link></member>
<member><link linkend="beast.ref.beast__http__basic_parser">basic_parser</link></member>
<member><link linkend="beast.ref.beast__http__basic_string_body">basic_string_body</link></member>
<member><link linkend="beast.ref.beast__http__buffer_body">buffer_body</link></member>
<member><link linkend="beast.ref.beast__http__chunk_body">chunk_body</link></member>
<member><link linkend="beast.ref.beast__http__chunk_crlf">chunk_crlf</link></member>
<member><link linkend="beast.ref.beast__http__chunk_extensions">chunk_extensions</link></member>
<member><link linkend="beast.ref.beast__http__chunk_header">chunk_header</link></member>
<member><link linkend="beast.ref.beast__http__chunk_last">chunk_last</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__file_body">file_body</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__request">request</link></member>
<member><link linkend="beast.ref.beast__http__request_header">request_header</link></member>
<member><link linkend="beast.ref.beast__http__request_parser">request_parser</link></member>
<member><link linkend="beast.ref.beast__http__request_serializer">request_serializer</link></member>
<member><link linkend="beast.ref.beast__http__response">response</link></member>
<member><link linkend="beast.ref.beast__http__response_header">response_header</link></member>
<member><link linkend="beast.ref.beast__http__response_parser">response_parser</link></member>
<member><link linkend="beast.ref.beast__http__response_serializer">response_serializer</link></member>
<member><link linkend="beast.ref.beast__http__serializer">serializer</link></member>
<member><link linkend="beast.ref.beast__http__span_body">span_body</link></member>
<member><link linkend="beast.ref.beast__http__string_body">string_body</link></member>
<member><link linkend="beast.ref.beast__http__vector_body">vector_body</link></member>
<member><link linkend="beast.ref.boost__beast__http__basic_chunk_extensions">basic_chunk_extensions</link></member>
<member><link linkend="beast.ref.boost__beast__http__basic_dynamic_body">basic_dynamic_body</link></member>
<member><link linkend="beast.ref.boost__beast__http__basic_fields">basic_fields</link></member>
<member><link linkend="beast.ref.boost__beast__http__basic_file_body">basic_file_body</link></member>
<member><link linkend="beast.ref.boost__beast__http__basic_parser">basic_parser</link></member>
<member><link linkend="beast.ref.boost__beast__http__basic_string_body">basic_string_body</link></member>
<member><link linkend="beast.ref.boost__beast__http__buffer_body">buffer_body</link></member>
<member><link linkend="beast.ref.boost__beast__http__chunk_body">chunk_body</link></member>
<member><link linkend="beast.ref.boost__beast__http__chunk_crlf">chunk_crlf</link></member>
<member><link linkend="beast.ref.boost__beast__http__chunk_extensions">chunk_extensions</link></member>
<member><link linkend="beast.ref.boost__beast__http__chunk_header">chunk_header</link></member>
<member><link linkend="beast.ref.boost__beast__http__chunk_last">chunk_last</link></member>
<member><link linkend="beast.ref.boost__beast__http__dynamic_body">dynamic_body</link></member>
<member><link linkend="beast.ref.boost__beast__http__empty_body">empty_body</link></member>
<member><link linkend="beast.ref.boost__beast__http__fields">fields</link></member>
<member><link linkend="beast.ref.boost__beast__http__file_body">file_body</link></member>
<member><link linkend="beast.ref.boost__beast__http__header">header</link></member>
<member><link linkend="beast.ref.boost__beast__http__message">message</link></member>
<member><link linkend="beast.ref.boost__beast__http__parser">parser</link></member>
<member><link linkend="beast.ref.boost__beast__http__request">request</link></member>
<member><link linkend="beast.ref.boost__beast__http__request_header">request_header</link></member>
<member><link linkend="beast.ref.boost__beast__http__request_parser">request_parser</link></member>
<member><link linkend="beast.ref.boost__beast__http__request_serializer">request_serializer</link></member>
<member><link linkend="beast.ref.boost__beast__http__response">response</link></member>
<member><link linkend="beast.ref.boost__beast__http__response_header">response_header</link></member>
<member><link linkend="beast.ref.boost__beast__http__response_parser">response_parser</link></member>
<member><link linkend="beast.ref.boost__beast__http__response_serializer">response_serializer</link></member>
<member><link linkend="beast.ref.boost__beast__http__serializer">serializer</link></member>
<member><link linkend="beast.ref.boost__beast__http__span_body">span_body</link></member>
<member><link linkend="beast.ref.boost__beast__http__string_body">string_body</link></member>
<member><link linkend="beast.ref.boost__beast__http__vector_body">vector_body</link></member>
</simplelist>
</entry>
<entry valign="top">
<bridgehead renderas="sect3">Functions</bridgehead>
<simplelist type="vert" columns="1">
<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_chunk">make_chunk</link></member>
<member><link linkend="beast.ref.beast__http__make_chunk_last">make_chunk_last</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>
<member><link linkend="beast.ref.boost__beast__http__async_read">async_read</link></member>
<member><link linkend="beast.ref.boost__beast__http__async_read_header">async_read_header</link></member>
<member><link linkend="beast.ref.boost__beast__http__async_read_some">async_read_some</link></member>
<member><link linkend="beast.ref.boost__beast__http__async_write">async_write</link></member>
<member><link linkend="beast.ref.boost__beast__http__async_write_header">async_write_header</link></member>
<member><link linkend="beast.ref.boost__beast__http__async_write_some">async_write_some</link></member>
<member><link linkend="beast.ref.boost__beast__http__int_to_status">int_to_status</link></member>
<member><link linkend="beast.ref.boost__beast__http__make_chunk">make_chunk</link></member>
<member><link linkend="beast.ref.boost__beast__http__make_chunk_last">make_chunk_last</link></member>
<member><link linkend="beast.ref.boost__beast__http__obsolete_reason">obsolete_reason</link></member>
<member><link linkend="beast.ref.boost__beast__http__operator_lt__lt_">operator&lt;&lt;</link></member>
<member><link linkend="beast.ref.boost__beast__http__read">read</link></member>
<member><link linkend="beast.ref.boost__beast__http__read_header">read_header</link></member>
<member><link linkend="beast.ref.boost__beast__http__read_some">read_some</link></member>
<member><link linkend="beast.ref.boost__beast__http__string_to_field">string_to_field</link></member>
<member><link linkend="beast.ref.boost__beast__http__string_to_verb">string_to_verb</link></member>
<member><link linkend="beast.ref.boost__beast__http__swap">swap</link></member>
<member><link linkend="beast.ref.boost__beast__http__to_string">to_string</link></member>
<member><link linkend="beast.ref.boost__beast__http__to_status_class">to_status_class</link></member>
<member><link linkend="beast.ref.boost__beast__http__write">write</link></member>
<member><link linkend="beast.ref.boost__beast__http__write_header">write_header</link></member>
<member><link linkend="beast.ref.boost__beast__http__write_some">write_some</link></member>
</simplelist>
<bridgehead renderas="sect3">rfc7230</bridgehead>
<simplelist type="vert" columns="1">
<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>
<member><link linkend="beast.ref.boost__beast__http__ext_list">ext_list</link></member>
<member><link linkend="beast.ref.boost__beast__http__opt_token_list">opt_token_list</link></member>
<member><link linkend="beast.ref.boost__beast__http__param_list">param_list</link></member>
<member><link linkend="beast.ref.boost__beast__http__token_list">token_list</link></member>
</simplelist>
</entry>
<entry valign="top">
<bridgehead renderas="sect3">Constants</bridgehead>
<simplelist type="vert" columns="1">
<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>
<member><link linkend="beast.ref.boost__beast__http__error">error</link></member>
<member><link linkend="beast.ref.boost__beast__http__field">field</link></member>
<member><link linkend="beast.ref.boost__beast__http__status">status</link></member>
<member><link linkend="beast.ref.boost__beast__http__status_class">status_class</link></member>
<member><link linkend="beast.ref.boost__beast__http__verb">verb</link></member>
</simplelist>
<bridgehead renderas="sect3">Type Traits</bridgehead>
<simplelist type="vert" columns="1">
<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>
<member><link linkend="beast.ref.beast__http__is_fields">is_fields</link></member>
<member><link linkend="beast.ref.boost__beast__http__is_body">is_body</link></member>
<member><link linkend="beast.ref.boost__beast__http__is_body_writer">is_body_writer</link></member>
<member><link linkend="beast.ref.boost__beast__http__is_body_reader">is_body_reader</link></member>
<member><link linkend="beast.ref.boost__beast__http__is_fields">is_fields</link></member>
</simplelist>
<bridgehead renderas="sect3">Concepts</bridgehead>
<simplelist type="vert" columns="1">
@@ -124,26 +124,26 @@
<entry valign="top">
<bridgehead renderas="sect3">Classes</bridgehead>
<simplelist type="vert" columns="1">
<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.boost__beast__websocket__close_reason">close_reason</link></member>
<member><link linkend="beast.ref.boost__beast__websocket__ping_data">ping_data</link></member>
<member><link linkend="beast.ref.boost__beast__websocket__stream">stream</link></member>
<member><link linkend="beast.ref.boost__beast__websocket__reason_string">reason_string</link></member>
</simplelist>
<bridgehead renderas="sect3">Functions</bridgehead>
<simplelist type="vert" columns="1">
<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>
<member><link linkend="beast.ref.boost__beast__websocket__async_teardown">async_teardown</link></member>
<member><link linkend="beast.ref.boost__beast__websocket__is_upgrade">is_upgrade</link></member>
<member><link linkend="beast.ref.boost__beast__websocket__teardown">teardown</link></member>
</simplelist>
<bridgehead renderas="sect3">Options</bridgehead>
<simplelist type="vert" columns="1">
<member><link linkend="beast.ref.beast__websocket__permessage_deflate">permessage_deflate</link></member>
<member><link linkend="beast.ref.boost__beast__websocket__permessage_deflate">permessage_deflate</link></member>
</simplelist>
<bridgehead renderas="sect3">Constants</bridgehead>
<simplelist type="vert" columns="1">
<member><link linkend="beast.ref.beast__websocket__close_code">close_code</link></member>
<member><link linkend="beast.ref.beast__websocket__error">error</link></member>
<member><link linkend="beast.ref.beast__websocket__frame_type">frame_type</link></member>
<member><link linkend="beast.ref.boost__beast__websocket__close_code">close_code</link></member>
<member><link linkend="beast.ref.boost__beast__websocket__error">error</link></member>
<member><link linkend="beast.ref.boost__beast__websocket__frame_type">frame_type</link></member>
</simplelist>
</entry>
</row>
@@ -170,91 +170,91 @@
<entry valign="top">
<bridgehead renderas="sect3">Classes</bridgehead>
<simplelist type="vert" columns="1">
<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__file">file</link></member>
<member><link linkend="beast.ref.beast__file_mode">file_mode</link></member>
<member><link linkend="beast.ref.beast__file_posix">file_posix</link></member>
<member><link linkend="beast.ref.beast__file_stdio">file_stdio</link></member>
<member><link linkend="beast.ref.beast__file_win32">file_win32</link></member>
<member><link linkend="beast.ref.boost__beast__async_completion">async_completion</link></member>
<member><link linkend="beast.ref.boost__beast__async_result">async_result</link></member>
<member><link linkend="beast.ref.boost__beast__async_return_type">async_return_type</link></member>
<member><link linkend="beast.ref.boost__beast__basic_flat_buffer">basic_flat_buffer</link></member>
<member><link linkend="beast.ref.boost__beast__basic_multi_buffer">basic_multi_buffer</link></member>
<member><link linkend="beast.ref.boost__beast__buffer_cat_view">buffer_cat_view</link></member>
<member><link linkend="beast.ref.boost__beast__buffer_prefix_view">buffer_prefix_view</link></member>
<member><link linkend="beast.ref.boost__beast__buffered_read_stream">buffered_read_stream</link></member>
<member><link linkend="beast.ref.boost__beast__buffers_adapter">buffers_adapter</link></member>
<member><link linkend="beast.ref.boost__beast__consuming_buffers">consuming_buffers</link></member>
<member><link linkend="beast.ref.boost__beast__drain_buffer">drain_buffer</link></member>
<member><link linkend="beast.ref.boost__beast__file">file</link></member>
<member><link linkend="beast.ref.boost__beast__file_mode">file_mode</link></member>
<member><link linkend="beast.ref.boost__beast__file_posix">file_posix</link></member>
<member><link linkend="beast.ref.boost__beast__file_stdio">file_stdio</link></member>
<member><link linkend="beast.ref.boost__beast__file_win32">file_win32</link></member>
</simplelist>
</entry>
<entry valign="top">
<bridgehead renderas="sect3">&nbsp;</bridgehead>
<simplelist type="vert" columns="1">
<member><link linkend="beast.ref.beast__flat_buffer">flat_buffer</link></member>
<member><link linkend="beast.ref.beast__flat_static_buffer">flat_static_buffer</link></member>
<member><link linkend="beast.ref.beast__flat_static_buffer_base">flat_static_buffer_base</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__iequal">iequal</link></member>
<member><link linkend="beast.ref.beast__iless">iless</link></member>
<member><link linkend="beast.ref.beast__multi_buffer">multi_buffer</link></member>
<member><link linkend="beast.ref.beast__span">span</link></member>
<member><link linkend="beast.ref.beast__static_buffer">static_buffer</link></member>
<member><link linkend="beast.ref.beast__static_buffer_base">static_buffer_base</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.boost__beast__flat_buffer">flat_buffer</link></member>
<member><link linkend="beast.ref.boost__beast__flat_static_buffer">flat_static_buffer</link></member>
<member><link linkend="beast.ref.boost__beast__flat_static_buffer_base">flat_static_buffer_base</link></member>
<member><link linkend="beast.ref.boost__beast__handler_alloc">handler_alloc</link></member>
<member><link linkend="beast.ref.boost__beast__handler_ptr">handler_ptr</link></member>
<member><link linkend="beast.ref.boost__beast__handler_type">handler_type</link></member>
<member><link linkend="beast.ref.boost__beast__iequal">iequal</link></member>
<member><link linkend="beast.ref.boost__beast__iless">iless</link></member>
<member><link linkend="beast.ref.boost__beast__multi_buffer">multi_buffer</link></member>
<member><link linkend="beast.ref.boost__beast__span">span</link></member>
<member><link linkend="beast.ref.boost__beast__static_buffer">static_buffer</link></member>
<member><link linkend="beast.ref.boost__beast__static_buffer_base">static_buffer_base</link></member>
<member><link linkend="beast.ref.boost__beast__static_string">static_string</link></member>
<member><link linkend="beast.ref.boost__beast__string_param">string_param</link></member>
<member><link linkend="beast.ref.boost__beast__string_view">string_view</link></member>
</simplelist>
</entry>
<entry valign="top">
<bridgehead renderas="sect3">Functions</bridgehead>
<simplelist type="vert" columns="1">
<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_front">buffer_front</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__generic_category">generic_category</link></member>
<member><link linkend="beast.ref.beast__iequals">iequals</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__to_static_string">to_static_string</link></member>
<member><link linkend="beast.ref.boost__beast__bind_handler">bind_handler</link></member>
<member><link linkend="beast.ref.boost__beast__buffer_cat">buffer_cat</link></member>
<member><link linkend="beast.ref.boost__beast__buffer_front">buffer_front</link></member>
<member><link linkend="beast.ref.boost__beast__buffer_prefix">buffer_prefix</link></member>
<member><link linkend="beast.ref.boost__beast__buffers">buffers</link></member>
<member><link linkend="beast.ref.boost__beast__generic_category">generic_category</link></member>
<member><link linkend="beast.ref.boost__beast__iequals">iequals</link></member>
<member><link linkend="beast.ref.boost__beast__ostream">ostream</link></member>
<member><link linkend="beast.ref.boost__beast__read_size">read_size</link></member>
<member><link linkend="beast.ref.boost__beast__read_size_or_throw">read_size_or_throw</link></member>
<member><link linkend="beast.ref.boost__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.beast__file_mode">file_mode</link></member>
<member><link linkend="beast.ref.boost__beast__file_mode">file_mode</link></member>
</simplelist>
</entry>
<entry valign="top">
<bridgehead renderas="sect3">Type Traits</bridgehead>
<simplelist type="vert" columns="1">
<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_file">is_file</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>
<member><link linkend="beast.ref.boost__beast__get_lowest_layer">get_lowest_layer</link></member>
<member><link linkend="beast.ref.boost__beast__has_get_io_service">has_get_io_service</link></member>
<member><link linkend="beast.ref.boost__beast__is_async_read_stream">is_async_read_stream</link></member>
<member><link linkend="beast.ref.boost__beast__is_async_write_stream">is_async_write_stream</link></member>
<member><link linkend="beast.ref.boost__beast__is_async_stream">is_async_stream</link></member>
<member><link linkend="beast.ref.boost__beast__is_completion_handler">is_completion_handler</link></member>
<member><link linkend="beast.ref.boost__beast__is_const_buffer_sequence">is_const_buffer_sequence</link></member>
<member><link linkend="beast.ref.boost__beast__is_dynamic_buffer">is_dynamic_buffer</link></member>
<member><link linkend="beast.ref.boost__beast__is_file">is_file</link></member>
<member><link linkend="beast.ref.boost__beast__is_mutable_buffer_sequence">is_mutable_buffer_sequence</link></member>
<member><link linkend="beast.ref.boost__beast__is_sync_read_stream">is_sync_read_stream</link></member>
<member><link linkend="beast.ref.boost__beast__is_sync_stream">is_sync_stream</link></member>
<member><link linkend="beast.ref.boost__beast__is_sync_write_stream">is_sync_write_stream</link></member>
</simplelist>
</entry>
<entry valign="top">
<bridgehead renderas="sect3">Aliases</bridgehead>
<simplelist type="vert" columns="1">
<member><link linkend="beast.ref.beast__errc">errc</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__system_category">system_category</link></member>
<member><link linkend="beast.ref.beast__system_error">system_error</link></member>
<member><link linkend="beast.ref.boost__beast__errc">errc</link></member>
<member><link linkend="beast.ref.boost__beast__error_category">error_category</link></member>
<member><link linkend="beast.ref.boost__beast__error_code">error_code</link></member>
<member><link linkend="beast.ref.boost__beast__error_condition">error_condition</link></member>
<member><link linkend="beast.ref.boost__beast__system_category">system_category</link></member>
<member><link linkend="beast.ref.boost__beast__system_error">system_error</link></member>
</simplelist>
<bridgehead renderas="sect3">Concepts</bridgehead>
<simplelist type="vert" columns="1">
@@ -269,19 +269,19 @@
<entry valign="top">
<bridgehead renderas="sect3">Classes</bridgehead>
<simplelist type="vert" columns="1">
<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>
<member><link linkend="beast.ref.boost__beast__zlib__deflate_stream">deflate_stream</link></member>
<member><link linkend="beast.ref.boost__beast__zlib__inflate_stream">inflate_stream</link></member>
<member><link linkend="beast.ref.boost__beast__zlib__z_params">z_params</link></member>
</simplelist>
<bridgehead renderas="sect3">Functions</bridgehead>
<simplelist type="vert" columns="1">
<member><link linkend="beast.ref.beast__zlib__deflate_upper_bound">deflate_upper_bound</link></member>
<member><link linkend="beast.ref.boost__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.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>
<member><link linkend="beast.ref.boost__beast__zlib__error">error</link></member>
<member><link linkend="beast.ref.boost__beast__zlib__Flush">Flush</link></member>
<member><link linkend="beast.ref.boost__beast__zlib__Strategy">Strategy</link></member>
</simplelist>
</entry>
</row>
@@ -301,8 +301,8 @@
<row>
<entry valign="top">
<simplelist type="vert" columns="1">
<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>
<member><link linkend="beast.ref.boost__beast__doc_debug">doc_debug</link></member>
<member><link linkend="beast.ref.boost__beast__nested__nested_doc_debug">nested_doc_debug</link></member>
</simplelist>
</entry>
</row>

16
doc/source.dox
View File

@@ -103,11 +103,11 @@ WARN_LOGFILE =
# Configuration options related to the input files
#---------------------------------------------------------------------------
INPUT = \
../include/beast/ \
../include/beast/core \
../include/beast/http \
../include/beast/websocket \
../include/beast/zlib
../include/boost/beast/ \
../include/boost/beast/core \
../include/boost/beast/http \
../include/boost/beast/websocket \
../include/boost/beast/zlib
INPUT_ENCODING = UTF-8
FILE_PATTERNS =
@@ -283,9 +283,9 @@ INCLUDE_PATH = ../
INCLUDE_FILE_PATTERNS =
PREDEFINED = \
BEAST_DOXYGEN \
BEAST_USE_POSIX_FILE=1 \
BEAST_USE_WIN32_FILE=1
BOOST_BEAST_DOXYGEN \
BOOST_BEAST_USE_POSIX_FILE=1 \
BOOST_BEAST_USE_WIN32_FILE=1
EXPAND_AS_DEFINED =
SKIP_FUNCTION_MACROS = YES

2
doc/xsl/reference.xsl
View File

@@ -3,7 +3,7 @@
<!-- Variables (Edit for your project) -->
<xsl:variable name="doc-ref" select="'beast.ref.'"/>
<xsl:variable name="doc-ns" select="'beast'"/>
<xsl:variable name="doc-ns" select="'boost::beast'"/>
<xsl:variable name="debug" select="0"/>
<xsl:variable name="private" select="0"/>
<!-- End Variables -->

2
example/common/detect_ssl.hpp
View File

@@ -223,7 +223,7 @@ template<
class AsyncReadStream,
class DynamicBuffer,
class CompletionToken>
async_return_type< /*< The [link beast.ref.beast__async_return_type `async_return_type`] customizes the return value based on the completion token >*/
async_return_type< /*< The [link beast.ref.boost__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
example/echo-op/echo_op.cpp
View File

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