couchbase 3.0.0.alpha.5 → 3.0.3

data/ext/third_party/asio/asio/src/doc/requirements/EndpointSequence.qbk

@@ -1,30 +0,0 @@
-[/
- / Copyright (c) 2003-2020 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / 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)
- /]
-
-[section:EndpointSequence Endpoint sequence requirements]
-
-A type `X` meets the `EndpointSequence` requirements if it satisfies the
-requirements of `Destructible` (C++Std [destructible]) and `CopyConstructible`
-(C++Std [copyconstructible]), as well as the additional requirements listed
-below.
-
-In the table below, `x` denotes a (possibly const) value of type `X`.
-
-[table EndpointSequence requirements
-  [[expression] [return type] [assertion/note[br]pre/post-condition]]
-  [
-    [`x.begin()`[br]
-     `x.end()`]
-    [A type meeting the requirements for forward iterators
-     (C++Std \[forward.iterators\]) whose value type is convertible to
-     a type satisfying the [link asio.reference.Endpoint `Endpoint`]
-     requirements.]
-    [[half_open_range `x.begin()`,`x.end()`] is a valid range.]
-  ]
-]
-
-[endsect]

data/ext/third_party/asio/asio/src/doc/requirements/ExecutionContext.qbk

@@ -1,36 +0,0 @@
-[/
- / Copyright (c) 2003-2020 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / 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)
- /]
-
-[section:ExecutionContext Execution context requirements]
-
-A type `X` meets the `ExecutionContext` requirements if it is publicly and
-unambiguously derived from `execution_context`, and satisfies the additional
-requirements listed below.
-
-In the table below, `x` denotes a value of type `X`.
-
-[table ExecutionContext requirements
-  [[expression] [return type] [assertion/note[br]pre/post-condition]]
-  [
-    [`X::executor_type`]
-    [type meeting [link asio.reference.Executor1 `Executor`] requirements]
-    []
-  ]
-  [
-    [`x.~X()`]
-    []
-    [Destroys all unexecuted function objects that were submitted via an
-     executor object that is associated with the execution context.]
-  ]
-  [
-    [`x.get_executor()`]
-    [`X::executor_type`]
-    [Returns an executor object that is associated with the execution context.]
-  ]
-]
-
-[endsect]

data/ext/third_party/asio/asio/src/doc/requirements/Executor.qbk

@@ -1,141 +0,0 @@
-[/
- / Copyright (c) 2003-2020 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / 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)
- /]
-
-[section:Executor1 Executor requirements]
-
-The library describes a standard set of requirements for ['executors]. A type
-meeting the `Executor` requirements embodies a set of rules for determining how
-submitted function objects are to be executed.
-
-A type `X` meets the `Executor` requirements if it satisfies the requirements of
-`CopyConstructible` (C++Std [copyconstructible]) and `Destructible` (C++Std
-[destructible]), as well as the additional requirements listed below.
-
-No constructor, comparison operator, copy operation, move operation, swap
-operation, or member functions `context`, `on_work_started`, and
-`on_work_finished` on these types shall exit via an exception.
-
-The executor copy constructor, comparison operators, and other member functions
-defined in these requirements shall not introduce data races as a result of
-concurrent calls to those functions from different threads.
-
-Let `ctx` be the execution context returned by the executor's `context()`
-member function. An executor becomes ['invalid] when the first call to
-`ctx.shutdown()` returns. The effect of calling `on_work_started`,
-`on_work_finished`, `dispatch`, `post`, or `defer` on an invalid executor is
-undefined. [inline_note The copy constructor, comparison operators, and
-`context()` member function continue to remain valid until `ctx` is destroyed.]
-
-In the table below, `x1` and `x2` denote (possibly const) values of type `X`,
-`mx1` denotes an xvalue of type `X`, `f` denotes a `MoveConstructible` (C++Std
-[moveconstructible]) function object callable with zero arguments, `a` denotes
-a (possibly const) value of type `A` meeting the `Allocator` requirements
-(C++Std [allocator.requirements]), and `u` denotes an identifier.
-
-[table Executor requirements
-  [[expression] [type] [assertion/note[br]pre/post-conditions]]
-  [
-    [`X u(x1);`]
-    []
-    [Shall not exit via an exception.[br]
-     [br]
-     post: `u == x1` and
-     `std::addressof(u.context()) == std::addressof(x1.context()).`]
-  ]
-  [
-    [`X u(mx1);`]
-    []
-    [Shall not exit via an exception.[br]
-     [br]
-     post: `u` equals the prior value of `mx1` and
-     `std::addressof(u.context())` equals the prior value of
-     `std::addressof(mx1.context())`.]
-  ]
-  [
-    [`x1 == x2`]
-    [`bool`]
-    [ Returns `true` only if `x1` and `x2` can be interchanged with identical
-     effects in any of the expressions defined in these type requirements.
-     [inline_note Returning `false` does not necessarily imply that the effects
-     are not identical.][br]
-     [br]
-     `operator==` shall be reflexive, symmetric, and transitive, and shall not
-     exit via an exception.]
-  ]
-  [
-    [`x1 != x2`]
-    [`bool`]
-    [Same as `!(x1 == x2)`.]
-  ]
-  [
-    [`x1.context()`]
-    [`execution_context&`, or `E&` where `E` is a type that satifisfies the
-     [link asio.reference.ExecutionContext `ExecutionContext`] requirements.]
-    [Shall not exit via an exception.[br]
-     [br]
-     The comparison operators and member functions defined in these
-     requirements shall not alter the reference returned by this function.]
-  ]
-  [
-    [`x1.on_work_started()`]
-    []
-    [Shall not exit via an exception.]
-  ]
-  [
-    [`x1.on_work_finished()`]
-    []
-    [Shall not exit via an exception.[br]
-     [br]
-     Precondition: A preceding call `x2.on_work_started()` where `x1 == x2`.]
-  ]
-  [
-    [`x1.dispatch(std::move(f),a)`]
-    []
-    [Effects: Creates an object `f1` initialized with
-     [^['DECAY_COPY]]`(forward<Func>(f))` (C++Std \[thread.decaycopy\]) in the
-     current thread of execution . Calls `f1()` at most once. The executor may
-     block forward progress of the caller until `f1()` finishes execution.[br]
-     [br]
-     Executor implementations should use the supplied allocator to allocate any
-     memory required to store the function object. Prior to invoking the
-     function object, the executor shall deallocate any memory allocated.
-     [inline_note Executors defined in this Technical Specification always use
-     the supplied allocator unless otherwise specified.][br]
-     [br]
-     Synchronization: The invocation of `dispatch` synchronizes with (C++Std
-     \[intro.multithread\]) the invocation of `f1`.]
-  ]
-  [
-    [`x1.post(std::move(f),a)`[br]
-     `x1.defer(std::move(f),a)`]
-    []
-    [Effects: Creates an object `f1` initialized with
-     [^['DECAY_COPY]]`(forward<Func>(f))` in the current thread of execution.
-     Calls `f1()` at most once. The executor shall not block forward progress
-     of the caller pending completion of `f1()`.[br]
-     [br]
-     Executor implementations should use the supplied allocator to allocate any
-     memory required to store the function object. Prior to invoking the
-     function object, the executor shall deallocate any memory allocated.
-     [inline_note Executors defined in this Technical Specification always use
-     the supplied allocator unless otherwise specified.][br]
-     [br]
-     Synchronization: The invocation of `post` or `defer` synchronizes with
-     (C++Std \[intro.multithread\]) the invocation of `f1`.[br]
-     [br]
-     [inline_note Although the requirements placed on `defer` are identical to
-     `post`, the use of `post` conveys a preference that the caller ['does not]
-     block the first step of [^f1]'s progress, whereas `defer` conveys a
-     preference that the caller ['does] block the first step of [^f1]. One use
-     of `defer` is to convey the intention of the caller that [^f1] is a
-     continuation of the current call context. The executor may use this
-     information to optimize or otherwise adjust the way in which `f1` is
-     invoked.]]
-  ]
-]
-
-[endsect]

data/ext/third_party/asio/asio/src/doc/requirements/GettableSerialPortOption.qbk

@@ -1,33 +0,0 @@
-[/
- / Copyright (c) 2003-2020 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / 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)
- /]
-
-[section:GettableSerialPortOption Gettable serial port option requirements]
-
-In the table below, `X` denotes a serial port option class, `a` denotes a value
-of `X`, `ec` denotes a value of type `error_code`, and `s` denotes a value of
-implementation-defined type ['[^storage]] (where ['[^storage]] is the type
-`DCB` on Windows and `termios` on __POSIX__ platforms), and `u` denotes an
-identifier.
-
-[table GettableSerialPortOption requirements
-  [[expression] [type] [assertion/note[br]pre/post-conditions]]
-  [
-    [
-      `const `['[^storage]]`& u = s;`[br]
-      `a.load(u, ec);`
-    ]
-    [`error_code`]
-    [
-      Retrieves the value of the serial port option from the storage.[br]
-      [br]
-      If successful, sets `ec` such that `!ec` is true. If an error occurred,
-      sets `ec` such that `!!ec` is true. Returns `ec`.
-    ]
-  ]
-]
-
-[endsect]

data/ext/third_party/asio/asio/src/doc/requirements/GettableSocketOption.qbk

@@ -1,67 +0,0 @@
-[/
- / Copyright (c) 2003-2020 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / 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)
- /]
-
-[section:GettableSocketOption Gettable socket option requirements]
-
-A type `X` meets the `GettableSocketOption` requirements if it satisfies the
-requirements listed below.
-
-In the table below, `a` denotes a (possibly const) value of type `X`, `b`
-denotes a value of type `X`, `p` denotes a (possibly const) value that meets
-the [link asio.reference.Protocol `Protocol`] requirements, and `s` denotes a
-(possibly const) value of a type that is convertible to `size_t` and denotes a
-size in bytes.
-
-[table GettableSocketOption requirements for extensible implementations
-  [[expression] [type] [assertion/note[br]pre/post-conditions]]
-  [
-    [`a.level(p)`]
-    [`int`]
-    [
-      Returns a value suitable for passing as the /level/ argument to __POSIX__
-      __getsockopt__ (or equivalent).
-    ]
-  ]
-  [
-    [`a.name(p)`]
-    [`int`]
-    [
-      Returns a value suitable for passing as the /option_name/ argument to
-      __POSIX__ __getsockopt__ (or equivalent).
-    ]
-  ]
-  [
-    [`b.data(p)`]
-    [`void*`]
-    [
-      Returns a pointer suitable for passing as the /option_value/ argument to
-      __POSIX__ __getsockopt__ (or equivalent).
-    ]
-  ]
-  [
-    [`a.size(p)`]
-    [`size_t`]
-    [
-      Returns a value suitable for passing as the /option_len/ argument to
-      __POSIX__ __getsockopt__ (or equivalent), after appropriate
-      integer conversion has been performed.
-    ]
-  ]
-  [
-    [`b.resize(p,s)`]
-    []
-    [
-      post: `b.size(p) == s`.[br]
-      Passed the value contained in the /option_len/ argument to __POSIX__
-      __getsockopt__ (or equivalent) after successful completion of the
-      function. Permitted to throw an exception if the socket option object `b`
-      does not support the specified size.
-    ]
-  ]
-]
-
-[endsect]

data/ext/third_party/asio/asio/src/doc/requirements/Handler.qbk

@@ -1,64 +0,0 @@
-[/
- / Copyright (c) 2003-2020 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / 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)
- /]
-
-[section:Handler Handlers]
-
-A handler must meet the requirements of `MoveConstructible` types (C++Std
-[moveconstructible]).
-
-In the table below, `X` denotes a handler class, `h` denotes a value of `X`,
-`p` denotes a pointer to a block of allocated memory of type `void*`, `s`
-denotes the size for a block of allocated memory, and `f` denotes a function
-object taking no arguments.
-
-[table Handler requirements
-  [[expression] [return type] [assertion/note[br]pre/post-conditions]]
-  [
-    [``
-      using asio::asio_handler_allocate;
-      asio_handler_allocate(s, &h);
-    ``]
-    [`void*`]
-    [
-      Returns a pointer to a block of memory of size `s`. The pointer must
-      satisfy the same alignment requirements as a pointer returned by
-      `::operator new()`. Throws `bad_alloc` on failure.[br][br] The
-      `asio_handler_allocate()` function is located using argument-dependent
-      lookup. The function `asio::asio_handler_allocate()` serves as a
-      default if no user-supplied function is available.
-    ]
-  ]
-  [
-    [``
-      using asio::asio_handler_deallocate;
-      asio_handler_deallocate(p, s, &h);
-    ``]
-    []
-    [
-      Frees a block of memory associated with a pointer `p`, of at least size
-      `s`, that was previously allocated using `asio_handler_allocate()`.[br][br] The
-      `asio_handler_deallocate()` function is located using argument-dependent
-      lookup. The function `asio::asio_handler_deallocate()` serves as a
-      default if no user-supplied function is available.
-    ]
-  ]
-  [
-    [``
-      using asio::asio_handler_invoke;
-      asio_handler_invoke(f, &h);
-    ``]
-    []
-    [
-      Causes the function object `f` to be executed as if by calling `f()`.[br][br]
-      The `asio_handler_invoke()` function is located using argument-dependent
-      lookup. The function `asio::asio_handler_invoke()` serves as a
-      default if no user-supplied function is available.
-    ]
-  ]
-]
-
-[endsect]

data/ext/third_party/asio/asio/src/doc/requirements/HandshakeHandler.qbk

@@ -1,72 +0,0 @@
-[/
- / Copyright (c) 2003-2020 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / 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)
- /]
-
-[section:HandshakeHandler SSL handshake handler requirements]
-
-A handshake handler must meet the requirements for a [link
-asio.reference.Handler handler]. A value `h` of a handshake handler
-class should work correctly in the expression `h(ec)`, where `ec` is an lvalue
-of type `const error_code`.
-
-[heading Examples]
-
-A free function as a handshake handler:
-
-  void handshake_handler(
-      const asio::error_code& ec)
-  {
-    ...
-  }
-
-A handshake handler function object:
-
-  struct handshake_handler
-  {
-    ...
-    void operator()(
-        const asio::error_code& ec)
-    {
-      ...
-    }
-    ...
-  };
-
-A lambda as a handshake handler:
-
-  ssl_stream.async_handshake(...,
-      [](const asio::error_code& ec)
-      {
-        ...
-      });
-
-A non-static class member function adapted to a handshake handler using
-`std::bind()`:
-
-  void my_class::handshake_handler(
-      const asio::error_code& ec)
-  {
-    ...
-  }
-  ...
-  ssl_stream.async_handshake(...,
-      std::bind(&my_class::handshake_handler,
-        this, std::placeholders::_1));
-
-A non-static class member function adapted to a handshake handler using
-`boost::bind()`:
-
-  void my_class::handshake_handler(
-      const asio::error_code& ec)
-  {
-    ...
-  }
-  ...
-  ssl_stream.async_handshake(...,
-      boost::bind(&my_class::handshake_handler,
-        this, asio::placeholders::error));
-
-[endsect]