diff --git a/CHANGELOG.md b/CHANGELOG.md index 775647aa..c4cc013a 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -7,6 +7,7 @@ Version 86: * Add local-travis.sh * Use winapi * Update CMakeLists.txt for boost +* Update documentation for boost -------------------------------------------------------------------------------- diff --git a/README.md b/README.md index a2a0d51c..0e4d499c 100644 --- a/README.md +++ b/README.md @@ -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 diff --git a/doc/Dockerfile b/doc/Dockerfile deleted file mode 100644 index 46ba0ee3..00000000 --- a/doc/Dockerfile +++ /dev/null @@ -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 diff --git a/doc/Jamfile b/doc/Jamfile index 7e3a2c9a..b756d4ac 100644 --- a/doc/Jamfile +++ b/doc/Jamfile @@ -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 - : - $(out)/html - ; - -explicit stylesheets ; - -install images - : - [ glob $(broot)/doc/src/images/*.png ] - images/beast.png - images/message.png - : - $(out)/html/images - ; - -explicit images ; - -install callouts - : - [ glob $(broot)/doc/src/images/callouts/*.png ] - : - $(out)/html/images/callouts - ; - -explicit callout ; - -xml doc +xml beast_doc : qbk/00_main.qbk - : - temp - $(broot)/tools/boostbook/dtd ; -boostbook boostdoc +explicit beast_doc ; + +install beast_doc_images : - doc + images/message.png : - boost.root=$(broot) - boost.image.src=images/beast.png - boost.image.alt="Beast Logo" - boost.image.w=1330 - boost.image.h=80 - chapter.autolabel=0 + html/beast/images + ; + +explicit beast_doc_images ; + +boostbook beast + : + beast_doc + : + boost.root=../../../.. + root.filename=beast + chapter.autolabel=1 chunk.section.depth=8 # Depth to which sections should be chunked chunk.first.sections=1 # Chunk the first top-level section? toc.section.depth=8 # How deep should recursive sections appear in the TOC? toc.max.depth=8 # How many levels should be created for each TOC? generate.section.toc.level=8 # Control depth of TOC generation in sections generate.toc="chapter toc,title section nop reference nop" - $(broot)/tools/boostbook/dtd + ../../../tools/boostbook/dtd : - temp - images - stylesheets + beast_doc_images ; + +alias boostdoc : beast : : : ; + +explicit boostdoc ; + +alias boostrelease ; + +explicit boostrelease ; diff --git a/doc/boostbook.dtd b/doc/boostbook.dtd deleted file mode 100644 index bd4c3f87..00000000 --- a/doc/boostbook.dtd +++ /dev/null @@ -1,439 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -%DocBook; diff --git a/doc/images/beast.png b/doc/images/beast.png deleted file mode 100644 index eb7528ec..00000000 Binary files a/doc/images/beast.png and /dev/null differ diff --git a/doc/qbk/00_main.qbk b/doc/qbk/00_main.qbk index 8e200687..54220a3d 100644 --- a/doc/qbk/00_main.qbk +++ b/doc/qbk/00_main.qbk @@ -22,8 +22,8 @@ [template mdash[] '''— '''] [template indexterm1[term1] ''''''[term1]''''''] [template indexterm2[term1 term2] ''''''[term1]''''''[term2]''''''] -[template repo_file[path] ''''''[path]''''''] -[template include_file[path][^<''''''[path]''''''>]] +[template repo_file[path] ''''''[path]''''''] +[template include_file[path][^<''''''[path]''''''>]] [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'''This Page Intentionally Left Blank 1/2'''] +[block'''This Page Intentionally Left Blank 1/2'''] [section:ref This Page Intentionally Left Blank 2/2] [include ../reference.qbk] [endsect] diff --git a/doc/qbk/03_core.qbk b/doc/qbk/03_core.qbk index 94144f50..667d8263 100644 --- a/doc/qbk/03_core.qbk +++ b/doc/qbk/03_core.qbk @@ -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. diff --git a/doc/qbk/03_core/1_asio.qbk b/doc/qbk/03_core/1_asio.qbk index 9070dac7..9811f6a4 100644 --- a/doc/qbk/03_core/1_asio.qbk +++ b/doc/qbk/03_core/1_asio.qbk @@ -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`] + [link beast.ref.boost__beast__websocket__stream `websocket::stream`] which is already connected with a remote host. ]] ] diff --git a/doc/qbk/03_core/2_streams.qbk b/doc/qbk/03_core/2_streams.qbk index 1778dff5..1ed6977f 100644 --- a/doc/qbk/03_core/2_streams.qbk +++ b/doc/qbk/03_core/2_streams.qbk @@ -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__. ]] diff --git a/doc/qbk/03_core/3_buffers.qbk b/doc/qbk/03_core/3_buffers.qbk index b9311a95..3fc4088f 100644 --- a/doc/qbk/03_core/3_buffers.qbk +++ b/doc/qbk/03_core/3_buffers.qbk @@ -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 diff --git a/doc/qbk/03_core/4_files.qbk b/doc/qbk/03_core/4_files.qbk index 744547b4..67069458 100644 --- a/doc/qbk/03_core/4_files.qbk +++ b/doc/qbk/03_core/4_files.qbk @@ -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 ``. ]] [[ - [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 diff --git a/doc/qbk/03_core/5_composed.qbk b/doc/qbk/03_core/5_composed.qbk index 4d3eaa1e..1f98ff25 100644 --- a/doc/qbk/03_core/5_composed.qbk +++ b/doc/qbk/03_core/5_composed.qbk @@ -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 diff --git a/doc/qbk/04_http.qbk b/doc/qbk/04_http.qbk index c7ffa17b..b876166b 100644 --- a/doc/qbk/04_http.qbk +++ b/doc/qbk/04_http.qbk @@ -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]] diff --git a/doc/qbk/04_http/02_message.qbk b/doc/qbk/04_http/02_message.qbk index df82773f..80032a11 100644 --- a/doc/qbk/04_http/02_message.qbk +++ b/doc/qbk/04_http/02_message.qbk @@ -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] diff --git a/doc/qbk/04_http/03_streams.qbk b/doc/qbk/04_http/03_streams.qbk index 31cd8abc..bdb8f61c 100644 --- a/doc/qbk/04_http/03_streams.qbk +++ b/doc/qbk/04_http/03_streams.qbk @@ -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 diff --git a/doc/qbk/04_http/04_serializer_streams.qbk b/doc/qbk/04_http/04_serializer_streams.qbk index 663dc6cf..1ee05e48 100644 --- a/doc/qbk/04_http/04_serializer_streams.qbk +++ b/doc/qbk/04_http/04_serializer_streams.qbk @@ -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__. ]] diff --git a/doc/qbk/04_http/05_parser_streams.qbk b/doc/qbk/04_http/05_parser_streams.qbk index 840a5e6c..d53f3271 100644 --- a/doc/qbk/04_http/05_parser_streams.qbk +++ b/doc/qbk/04_http/05_parser_streams.qbk @@ -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: diff --git a/doc/qbk/04_http/06_serializer_buffers.qbk b/doc/qbk/04_http/06_serializer_buffers.qbk index 8e2446e3..b6047423 100644 --- a/doc/qbk/04_http/06_serializer_buffers.qbk +++ b/doc/qbk/04_http/06_serializer_buffers.qbk @@ -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: diff --git a/doc/qbk/04_http/07_parser_buffers.qbk b/doc/qbk/04_http/07_parser_buffers.qbk index 11be8576..02b38400 100644 --- a/doc/qbk/04_http/07_parser_buffers.qbk +++ b/doc/qbk/04_http/07_parser_buffers.qbk @@ -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 ][ diff --git a/doc/qbk/04_http/08_chunked_encoding.qbk b/doc/qbk/04_http/08_chunked_encoding.qbk index 315b3075..d578962c 100644 --- a/doc/qbk/04_http/08_chunked_encoding.qbk +++ b/doc/qbk/04_http/08_chunked_encoding.qbk @@ -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. diff --git a/doc/qbk/04_http/09_custom_body.qbk b/doc/qbk/04_http/09_custom_body.qbk index b209ac5d..c80e64fb 100644 --- a/doc/qbk/04_http/09_custom_body.qbk +++ b/doc/qbk/04_http/09_custom_body.qbk @@ -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. ] ][ diff --git a/doc/qbk/05_http_examples.qbk b/doc/qbk/05_http_examples.qbk index de7b5061..2a8e3efc 100644 --- a/doc/qbk/05_http_examples.qbk +++ b/doc/qbk/05_http_examples.qbk @@ -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. diff --git a/doc/qbk/06_websocket/1_streams.qbk b/doc/qbk/06_websocket/1_streams.qbk index 002f0932..fb813bd8 100644 --- a/doc/qbk/06_websocket/1_streams.qbk +++ b/doc/qbk/06_websocket/1_streams.qbk @@ -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] diff --git a/doc/qbk/06_websocket/3_client.qbk b/doc/qbk/06_websocket/3_client.qbk index 65a0e651..30e7f127 100644 --- a/doc/qbk/06_websocket/3_client.qbk +++ b/doc/qbk/06_websocket/3_client.qbk @@ -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] diff --git a/doc/qbk/06_websocket/4_server.qbk b/doc/qbk/06_websocket/4_server.qbk index f32b3105..772ccf2d 100644 --- a/doc/qbk/06_websocket/4_server.qbk +++ b/doc/qbk/06_websocket/4_server.qbk @@ -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. diff --git a/doc/qbk/06_websocket/5_messages.qbk b/doc/qbk/06_websocket/5_messages.qbk index 9518d37a..f43878a9 100644 --- a/doc/qbk/06_websocket/5_messages.qbk +++ b/doc/qbk/06_websocket/5_messages.qbk @@ -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. ] diff --git a/doc/qbk/06_websocket/6_control.qbk b/doc/qbk/06_websocket/6_control.qbk index fb1de84d..c49bc5fa 100644 --- a/doc/qbk/06_websocket/6_control.qbk +++ b/doc/qbk/06_websocket/6_control.qbk @@ -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. ] diff --git a/doc/qbk/06_websocket/7_notes.qbk b/doc/qbk/06_websocket/7_notes.qbk index 2444072c..7d37004a 100644 --- a/doc/qbk/06_websocket/7_notes.qbk +++ b/doc/qbk/06_websocket/7_notes.qbk @@ -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 diff --git a/doc/qbk/07_concepts/Body.qbk b/doc/qbk/07_concepts/Body.qbk index 44d669aa..16e66109 100644 --- a/doc/qbk/07_concepts/Body.qbk +++ b/doc/qbk/07_concepts/Body.qbk @@ -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] diff --git a/doc/qbk/07_concepts/BodyReader.qbk b/doc/qbk/07_concepts/BodyReader.qbk index 0788928f..b0c674a5 100644 --- a/doc/qbk/07_concepts/BodyReader.qbk +++ b/doc/qbk/07_concepts/BodyReader.qbk @@ -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: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` is the type `boost::optional>`. [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] diff --git a/doc/qbk/07_concepts/BodyWriter.qbk b/doc/qbk/07_concepts/BodyWriter.qbk index 53fd970d..f79c04b5 100644 --- a/doc/qbk/07_concepts/BodyWriter.qbk +++ b/doc/qbk/07_concepts/BodyWriter.qbk @@ -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::value == true`. * `n` is a value of type `boost::optional`. -* `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] diff --git a/doc/qbk/07_concepts/DynamicBuffer.qbk b/doc/qbk/07_concepts/DynamicBuffer.qbk index 599f512c..a2318b7a 100644 --- a/doc/qbk/07_concepts/DynamicBuffer.qbk +++ b/doc/qbk/07_concepts/DynamicBuffer.qbk @@ -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] diff --git a/doc/qbk/07_concepts/Fields.qbk b/doc/qbk/07_concepts/Fields.qbk index e200448f..e38d213e 100644 --- a/doc/qbk/07_concepts/Fields.qbk +++ b/doc/qbk/07_concepts/Fields.qbk @@ -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`. -* `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] diff --git a/doc/qbk/07_concepts/FieldsReader.qbk b/doc/qbk/07_concepts/FieldsReader.qbk index da813dde..1f7f047a 100644 --- a/doc/qbk/07_concepts/FieldsReader.qbk +++ b/doc/qbk/07_concepts/FieldsReader.qbk @@ -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] diff --git a/doc/qbk/07_concepts/File.qbk b/doc/qbk/07_concepts/File.qbk index b8e1e3ed..8bfd6cbd 100644 --- a/doc/qbk/07_concepts/File.qbk +++ b/doc/qbk/07_concepts/File.qbk @@ -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] diff --git a/doc/qbk/08_design.qbk b/doc/qbk/08_design.qbk index 9c263ad8..418402bc 100644 --- a/doc/qbk/08_design.qbk +++ b/doc/qbk/08_design.qbk @@ -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 diff --git a/doc/qbk/08_design/4_faq.qbk b/doc/qbk/08_design/4_faq.qbk index 99ba6c20..711d242a 100644 --- a/doc/qbk/08_design/4_faq.qbk +++ b/doc/qbk/08_design/4_faq.qbk @@ -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. diff --git a/doc/qbk/index.xml b/doc/qbk/index.xml index 27ab9fac..5b22c246 100644 --- a/doc/qbk/index.xml +++ b/doc/qbk/index.xml @@ -1,6 +1,5 @@ - - + - + diff --git a/example/common/detect_ssl.hpp b/example/common/detect_ssl.hpp index c0f2793d..3dd28ed5 100644 --- a/example/common/detect_ssl.hpp +++ b/example/common/detect_ssl.hpp @@ -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( diff --git a/example/echo-op/echo_op.cpp b/example/echo-op/echo_op.cpp index af372386..ba39fde9 100644 --- a/example/echo-op/echo_op.cpp +++ b/example/echo-op/echo_op.cpp @@ -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(