Set version to 0.28.1-rc1

* Don't pollute ledger cache with history
* Avoid race condition when getting ledger sequence numbers
* Make fetch packs larger

.gitignore

@@ -31,6 +31,7 @@ Release/*.*
 tmp
 
 # Ignore database directory.
+db/
 db/*.db
 db/*.db-*
 
@@ -75,4 +76,7 @@ My Amplifier XE Results - RippleD
 /out.txt
 
 # Build Log
-rippled-build.log
+rippled-build.log
+
+# Profiling data
+gmon.out

.travis.yml

@@ -6,20 +6,10 @@ before_install:
   - sudo apt-get update -qq
   - sudo apt-get install -qq python-software-properties
   - sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test
-  - sudo add-apt-repository -y ppa:boost-latest/ppa
+  - sudo add-apt-repository -y ppa:afrank/boost
   - sudo apt-get update -qq
   - sudo apt-get install -qq g++-4.8
-  - sudo apt-get install -qq libboost1.55-all-dev 
-  # We want debug symbols for boost as we install gdb later
-  - sudo apt-get install -qq libboost1.55-dbg
-  - | # Setup the BOOST_ROOT
-      export BOOST_ROOT=$HOME/boost_root
-      mkdir -p $BOOST_ROOT/stage
-      ln -s /usr/lib/x86_64-linux-gnu $BOOST_ROOT/stage/lib
-      ln -s /usr/include/boost $BOOST_ROOT/boost
-  - | # Try to patch boost
-      sudo patch /usr/include/boost/bimap/detail/debug/static_error.hpp Builds/travis/static_error.boost.patch
-      sudo patch /usr/include/boost/config/compiler/clang.hpp Builds/travis/clang.boost.patch
+  - sudo apt-get install -qq libboost1.57-all-dev
   - sudo apt-get install -qq mlocate
   - sudo updatedb
   - sudo locate libboost | grep /lib | grep -e ".a$"
@@ -35,23 +25,38 @@ before_install:
   # What versions are we ACTUALLY running?
   - g++ -v
   - clang -v
+  # Avoid `spurious errors` caused by ~/.npm permission issues
+  # Does it already exist? Who owns? What permissions?
+  - ls -lah ~/.npm || mkdir ~/.npm
+  # Make sure we own it
+  - sudo chown -R $USER ~/.npm
 
 script:
   # Set so any failing command will abort the build
   - set -e
-  # If only we could do -j12 ;)
-  - scons 
+  # Make sure vcxproj is up to date
+  - scons vcxproj
+  - git diff --exit-code
+  # $CC will be either `clang` or `gcc` (If only we could do -j12 ;)
+  - scons $CC.debug
+  # We can be sure we're using the build/$CC.debug variant (-f so never err)
+  - rm -f build/rippled 
+  - export RIPPLED_PATH="$PWD/build/$CC.debug/rippled"
   # See what we've actually built
-  - ldd ./build/rippled
+  - ldd $RIPPLED_PATH
   # Run unittests (under gdb)
   - | # create gdb script
     echo "set env MALLOC_CHECK_=3" > script.gdb 
     echo "run" >> script.gdb
     echo "backtrace full" >> script.gdb 
     # gdb --help
-  - cat script.gdb | gdb --ex 'set print thread-events off' --return-child-result --args ./build/rippled --unittest 
-  # Run integration tests
+  - cat script.gdb | gdb --ex 'set print thread-events off' --return-child-result --args $RIPPLED_PATH --unittest
   - npm install
+  # Use build/(gcc|clang).debug/rippled
+  - |
+    echo "exports.default_server_config = {\"rippled_path\" : \"$RIPPLED_PATH\"};" > test/config.js
+
+  # Run integration tests
   - npm test
 notifications:
   email:

Builds/Docker/Dockerfile-testnet

@@ -0,0 +1,23 @@
+FROM ubuntu
+MAINTAINER Torrie Fischer <torrie@ripple.com>
+
+RUN apt-get update -qq &&\
+    apt-get install -qq software-properties-common &&\
+    apt-add-repository -y ppa:ubuntu-toolchain-r/test &&\
+    apt-add-repository -y ppa:afrank/boost &&\
+    apt-get update -qq
+
+RUN apt-get purge -qq libboost1.48-dev &&\
+    apt-get install -qq libprotobuf8 libboost1.57-all-dev
+
+RUN mkdir -p /srv/rippled/data
+
+VOLUME /srv/rippled/data/
+
+ENTRYPOINT ["/srv/rippled/bin/rippled"]
+CMD ["--conf", "/srv/rippled/data/rippled.cfg"]
+EXPOSE 51235/udp
+EXPOSE 5005/tcp
+
+ADD ./rippled.cfg /srv/rippled/data/rippled.cfg
+ADD ./rippled /srv/rippled/bin/

Builds/Test.py

@@ -0,0 +1,180 @@
+#!/usr/bin/env python
+
+#    This file is part of rippled: https://github.com/ripple/rippled
+#    Copyright (c) 2012 - 2015 Ripple Labs Inc.
+#
+#    Permission to use, copy, modify, and/or distribute this software for any
+#    purpose  with  or without fee is hereby granted, provided that the above
+#    copyright notice and this permission notice appear in all copies.
+#
+#    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+#    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
+#    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+#    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+#    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
+#    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+#    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+"""
+Invocation:
+  ./Builds/Test.py - builds and tests all configurations
+
+#
+# The build must succeed without shell aliases for this to work.
+#
+# Common problems:
+# 1) Boost not found. Solution: export BOOST_ROOT=[path to boost folder]
+# 2) OpenSSL not found. Solution: export OPENSSL_ROOT=[path to OpenSSL folder]
+# 3) scons is an alias. Solution: Create a script named "scons" somewhere in
+#    your $PATH (eg. ~/bin/scons will often work).
+#       #!/bin/sh
+#       python /C/Python27/Scripts/scons.py "${@}"
+"""
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+import argparse
+import itertools
+import os
+import platform
+import re
+import subprocess
+import sys
+
+IS_WINDOWS = platform.system().lower() == 'windows'
+
+if IS_WINDOWS:
+    BINARY_RE = re.compile(r'build\\([^\\]+)\\rippled.exe')
+
+else:
+    BINARY_RE = re.compile(r'build/([^/]+)/rippled')
+
+ALL_TARGETS = ['debug', 'release']
+
+parser = argparse.ArgumentParser(
+    description='Test.py - run ripple tests'
+)
+
+parser.add_argument(
+    '--all', '-a',
+    action='store_true',
+    help='Build all configurations.',
+)
+
+parser.add_argument(
+    '--keep_going', '-k',
+    action='store_true',
+    help='Keep going after one configuration has failed.',
+ )
+
+parser.add_argument(
+    '--silent', '-s',
+    action='store_true',
+    help='Silence all messages except errors',
+ )
+
+parser.add_argument(
+    '--verbose', '-v',
+    action='store_true',
+    help=('Report more information about which commands are executed and the '
+          'results.'),
+ )
+
+parser.add_argument(
+    '--test', '-t',
+    default='',
+    help='Add a prefix for unit tests',
+ )
+
+parser.add_argument(
+    'scons_args',
+    default=(),
+    nargs='*'
+    )
+
+ARGS = parser.parse_args()
+
+def shell(*cmd, **kwds):
+    "Execute a shell command and return the output."
+    silent = kwds.pop('silent', ARGS.silent)
+    verbose = not silent and kwds.pop('verbose', ARGS.verbose)
+    if verbose:
+        print('$', ' '.join(cmd))
+    kwds['shell'] = IS_WINDOWS
+
+    process = subprocess.Popen(
+        cmd,
+        stdin=subprocess.PIPE,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        **kwds)
+    lines = []
+    count = 0
+    for line in process.stdout:
+        lines.append(line)
+        if verbose:
+            print(line, end='')
+        elif not silent:
+            count += 1
+            if count >= 80:
+                print()
+                count = 0
+            else:
+                print('.', end='')
+
+    if not verbose and count:
+        print()
+    process.wait()
+    return process.returncode, lines
+
+if __name__ == '__main__':
+    args = list(ARGS.scons_args)
+    if ARGS.all:
+        for a in ALL_TARGETS:
+            if a not in args:
+                args.append(a)
+    print('Building:', *(args or ['(default)']))
+
+    # Build everything.
+    resultcode, lines = shell('scons', *args)
+    if resultcode:
+        print('Build FAILED:')
+        if not ARGS.verbose:
+            print(*lines, sep='')
+        exit(1)
+
+    # Now extract the executable names and corresponding targets.
+    failed = []
+    _, lines = shell('scons', '-n', '--tree=derived', *args, silent=True)
+    for line in lines:
+        match = BINARY_RE.search(line)
+        if match:
+            executable, target = match.group(0, 1)
+
+            print('Unit tests for', target)
+            testflag = '--unittest'
+            if ARGS.test:
+                testflag += ('=' + ARGS.test)
+
+            resultcode, lines = shell(executable, testflag)
+            if resultcode:
+                print('ERROR:', *lines, sep='')
+                failed.append([target, 'unittest'])
+                if not ARGS.keep_going:
+                    break
+            ARGS.verbose and print(*lines, sep='')
+
+            print('npm tests for', target)
+            resultcode, lines = shell('npm', 'test', '--rippled=' + executable)
+            if resultcode:
+                print('ERROR:\n', *lines, sep='')
+                failed.append([target, 'npm'])
+                if not ARGS.keep_going:
+                    break
+            else:
+                ARGS.verbose and print(*lines, sep='')
+
+    if failed:
+        print('FAILED:', *(':'.join(f) for f in failed))
+        exit(1)
+    else:
+        print('Success')

Builds/VisualStudio2013/ripple.sln

@@ -1,24 +1,26 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
 # Visual Studio Express 2013 for Windows Desktop
-VisualStudioVersion = 12.0.30110.0
+VisualStudioVersion = 12.0.31101.0
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "RippleD", "RippleD.vcxproj", "{26B7D9AC-1A80-8EF8-6703-D061F1BECB75}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
-		Debug|Win32 = Debug|Win32
-		Debug|x64 = Debug|x64
-		Release|Win32 = Release|Win32
-		Release|x64 = Release|x64
+		debug.classic|x64 = debug.classic|x64
+		debug|x64 = debug|x64
+		release.classic|x64 = release.classic|x64
+		release|x64 = release|x64
 	EndGlobalSection
 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{26B7D9AC-1A80-8EF8-6703-D061F1BECB75}.Debug|Win32.ActiveCfg = debug|x64
-		{26B7D9AC-1A80-8EF8-6703-D061F1BECB75}.Debug|x64.ActiveCfg = debug|x64
-		{26B7D9AC-1A80-8EF8-6703-D061F1BECB75}.Debug|x64.Build.0 = debug|x64
-		{26B7D9AC-1A80-8EF8-6703-D061F1BECB75}.Release|Win32.ActiveCfg = release|x64
-		{26B7D9AC-1A80-8EF8-6703-D061F1BECB75}.Release|x64.ActiveCfg = release|x64
-		{26B7D9AC-1A80-8EF8-6703-D061F1BECB75}.Release|x64.Build.0 = release|x64
+		{26B7D9AC-1A80-8EF8-6703-D061F1BECB75}.debug.classic|x64.ActiveCfg = debug.classic|x64
+		{26B7D9AC-1A80-8EF8-6703-D061F1BECB75}.debug.classic|x64.Build.0 = debug.classic|x64
+		{26B7D9AC-1A80-8EF8-6703-D061F1BECB75}.debug|x64.ActiveCfg = debug|x64
+		{26B7D9AC-1A80-8EF8-6703-D061F1BECB75}.debug|x64.Build.0 = debug|x64
+		{26B7D9AC-1A80-8EF8-6703-D061F1BECB75}.release.classic|x64.ActiveCfg = release.classic|x64
+		{26B7D9AC-1A80-8EF8-6703-D061F1BECB75}.release.classic|x64.Build.0 = release.classic|x64
+		{26B7D9AC-1A80-8EF8-6703-D061F1BECB75}.release|x64.ActiveCfg = release|x64
+		{26B7D9AC-1A80-8EF8-6703-D061F1BECB75}.release|x64.Build.0 = release|x64
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

Builds/rpm/rippled.spec

@@ -1,5 +1,5 @@
 Name:           rippled
-Version:        0.26.3-sp1
+Version:        0.28.1-rc1
 Release:        1%{?dist}
 Summary:        Ripple peer-to-peer network daemon
 
@@ -50,4 +50,3 @@ rm -rf %{buildroot}
 /usr/bin/rippled
 /usr/share/rippled/LICENSE
 /etc/rippled/rippled-example.cfg
-

README.md

@@ -1,3 +1,77 @@
+![Ripple](/images/ripple.png)
+
+#The World’s Fastest and Most Secure Payment System
+
+**What is Ripple?**
+
+Ripple is the open-source, distributed payment protocol that enables instant
+payments with low fees, no chargebacks, and currency flexibility (for example
+dollars, yen, euros, bitcoins, or even loyalty points). Businesses of any size
+can easily build payment solutions such as banking or remittance apps, and
+accelerate the movement of money. Ripple enables the world to move value the
+way it moves information on the Internet.
+
+![Ripple Network](images/network.png)
+
+**What is a Gateway?**
+
+Ripple works with gateways: independent businesses which hold customer
+deposits in various currencies such as U.S. dollars (USD) or Euros (EUR),
+in exchange for providing cryptographically-signed issuances that users can
+send and trade with one another in seconds on the Ripple network. Within the
+protocol, exchanges between multiple currencies can occur atomically without
+any central authority to monitor them. Later, customers can withdraw their
+Ripple balances from the gateways that created those issuances.
+
+**How do Ripple payments work?**
+
+A sender specifies the amount and currency the recipient should receive and
+Ripple automatically converts the sender’s available currencies using the
+distributed order books integrated into the Ripple protocol. Independent third
+parties acting as  market makers provide liquidity in these order books.
+
+Ripple uses a pathfinding algorithm that considers currency pairs when
+converting from the source to the destination currency. This algorithm searches
+for a series of currency swaps that gives the user the lowest cost. Since
+anyone can participate as a market maker, market forces drive fees to the
+lowest practical level.
+
+**What can you do with Ripple?**
+
+The protocol is entirely open-source and the network’s shared ledger is public
+information, so no central authority prevents anyone from participating. Anyone
+can become a market maker, create a wallet or a gateway, or monitor network
+behavior. Competition drives down spreads and fees, making the network useful
+to everyone.
+
+
+###Key Protocol Features
+1. XRP is Ripple’s native [cryptocurrency]
+(http://en.wikipedia.org/wiki/Cryptocurrency) with a fixed supply that
+decreases slowly over time, with no mining. XRP acts as a bridge currency, and
+pays for transaction fees that protect the network against spam.
+![XRP as a bridge currency](/images/vehicle_currency.png)
+
+2. Pathfinding discovers cheap and efficient payment paths through multiple
+[order books](https://www.ripplecharts.com) allowing anyone to [trade](https://www.rippletrade.com) anything. When two accounts aren’t linked by relationships of trust, the Ripple pathfinding engine considers intermediate links and order books to produce a set of possible paths the transaction can take. When the payment is processed, the liquidity along these paths is iteratively consumed in best-first order.
+![Pathfinding from Dollars to Euro](/images/pathfinding.png)
+
+3. [Consensus](https://www.youtube.com/watch?v=pj1QVb1vlC0) confirms
+transactions in an atomic fashion, without mining, ensuring efficient use of
+resources.
+
+[transact]: https://ripple.com/files/ripple-FIs.pdf
+[build]:    https://ripple.com/build/
+
+[transact.png]:   /images/transact.png
+[build.png]:      /images/build.png
+[contribute.png]: /images/contribute.png
+
+###Join The Ripple Community
+|![Transact][transact.png]|![Build][build.png]|![Contribute][contribute.png]|
+|:-----------------------:|:-----------------:|:---------------------------:|
+|[Transact on the fastest payment infrastructure][transact]|[Build Imaginative Apps][build]|Contribute to the Ripple Protocol Implementation|
+
 #rippled - Ripple P2P server
 
 ##[![Build Status](https://travis-ci.org/ripple/rippled.png?branch=develop)](https://travis-ci.org/ripple/rippled)
@@ -10,6 +84,9 @@ This is the repository for Ripple's `rippled`, reference P2P server.
 ###Setup instructions:
 * https://ripple.com/wiki/Rippled_setup_instructions
 
+###Issues
+* https://ripplelabs.atlassian.net/browse/RIPD
+
 ### Repository Contents
 
 #### ./bin
@@ -37,5 +114,9 @@ Ripple is open source and permissively licensed under the ISC license. See the
 LICENSE file for more details.
 
 ###For more information:
-* https://ripple.com
-* https://ripple.com/wiki
+* Ripple Wiki - https://ripple.com/wiki/
+* Ripple Primer - https://ripple.com/ripple_primer.pdf
+* Ripple Primer (Market Making) - https://ripple.com/ripple-mm.pdf
+* Ripple Gateway Primer - https://ripple.com/ripple-gateways.pdf  
+* Consensus - https://wiki.ripple.com/Consensus
+

SConstruct

@@ -11,14 +11,17 @@
     all             All available variants
     debug           All available debug variants
     release         All available release variants
+    profile         All available profile variants
 
     clang           All clang variants
     clang.debug     clang debug variant
     clang.release   clang release variant
+    clang.profile   clang profile variant
 
     gcc             All gcc variants
     gcc.debug       gcc debug variant
     gcc.release     gcc release variant
+    gcc.profile     gcc profile variant
 
     msvc            All msvc variants
     msvc.debug      MSVC debug variant
@@ -26,10 +29,37 @@
 
     vcxproj         Generate Visual Studio 2013 project file
 
+    count           Show line count metrics
+
+    Any individual target can also have ".nounity" appended for a classic,
+    non unity build. Example:
+
+        scons gcc.debug.nounity
+
 If the clang toolchain is detected, then the default target will use it, else
 the gcc toolchain will be used. On Windows environments, the MSVC toolchain is
 also detected.
 
+The following environment variables modify the build environment:
+    CLANG_CC
+    CLANG_CXX
+    CLANG_LINK
+      If set, a clang toolchain will be used. These must all be set together.
+
+    GNU_CC
+    GNU_CXX
+    GNU_LINK
+      If set, a gcc toolchain will be used (unless a clang toolchain is
+      detected first). These must all be set together.
+
+    CXX
+      If set, used to detect a toolchain.
+
+    BOOST_ROOT
+      Path to the boost directory. 
+    OPENSSL_ROOT
+      Path to the openssl directory.
+
 '''
 #
 '''
@@ -67,6 +97,7 @@ CHECK_LINE = 'built on: '
 BUILD_TIME = 'Mon Apr  7 20:33:19 UTC 2014'
 OPENSSL_ERROR = ('Your openSSL was built on %s; '
                  'rippled needs a version built on or after %s.')
+UNITY_BUILD_DIRECTORY = 'src/ripple/unity/'
 
 def check_openssl():
     if Beast.system.platform in CHECK_PLATFORMS:
@@ -82,6 +113,29 @@ def check_openssl():
                             (CHECK_LINE, CHECK_COMMAND))
 
 
+def set_implicit_cache():
+    '''Use implicit_cache on some targets to improve build times.
+
+    By default, scons scans each file for include dependecies. The implicit
+    cache flag lets you cache these dependencies for later builds, and will
+    only rescan files that change.
+
+    Failure cases are:
+    1) If the include search paths are changed (i.e. CPPPATH), then a file
+       may not be rebuilt.
+    2) If a same-named file has been added to a directory that is earlier in
+       the search path than the directory in which the file was found.
+    Turn on if this build is for a specific debug target (i.e. clang.debug)
+
+    If one of the failure cases applies, you can force a rescan of dependencies
+    using the command line option `--implicit-deps-changed`
+    '''
+    if len(COMMAND_LINE_TARGETS) == 1:
+        s = COMMAND_LINE_TARGETS[0].split('.')
+        if len(s) > 1 and 'debug' in s:
+            SetOption('implicit_cache', 1)
+
+
 def import_environ(env):
     '''Imports environment settings into the construction environment'''
     def set(keys):
@@ -198,7 +252,11 @@ def config_base(env):
             )
     check_openssl()
 
-    env.Append(CPPDEFINES=['OPENSSL_NO_SSL2'])
+    env.Append(CPPDEFINES=[
+        'OPENSSL_NO_SSL2'
+        ,'DEPRECATED_IN_MAC_OS_X_VERSION_10_7_AND_LATER'
+        ,{'HAVE_USLEEP' : '1'}
+        ])
 
     try:
         BOOST_ROOT = os.path.normpath(os.environ['BOOST_ROOT'])
@@ -244,7 +302,7 @@ def config_env(toolchain, variant, env):
     if variant == 'debug':
         env.Append(CPPDEFINES=['DEBUG', '_DEBUG'])
 
-    elif variant == 'release':
+    elif variant == 'release' or variant == 'profile':
         env.Append(CPPDEFINES=['NDEBUG'])
 
     if toolchain in Split('clang gcc'):
@@ -259,16 +317,35 @@ def config_env(toolchain, variant, env):
             '-Wno-sign-compare',
             '-Wno-char-subscripts',
             '-Wno-format',
+            '-g'                        # generate debug symbols
             ])
 
+        env.Append(LINKFLAGS=[
+            '-rdynamic',
+            '-g',
+            ])
+
+        if variant == 'profile':
+            env.Append(CCFLAGS=[
+                '-p',
+                '-pg',
+                ])
+            env.Append(LINKFLAGS=[
+                '-p',
+                '-pg',
+                ])
+
         if toolchain == 'clang':
             env.Append(CCFLAGS=['-Wno-redeclared-class-member'])
+            env.Append(CPPDEFINES=['BOOST_ASIO_HAS_STD_ARRAY'])
 
         env.Append(CXXFLAGS=[
             '-frtti',
             '-std=c++11',
             '-Wno-invalid-offsetof'])
 
+        env.Append(CPPDEFINES=['_FILE_OFFSET_BITS=64'])
+
         if Beast.system.osx:
             env.Append(CPPDEFINES={
                 'BEAST_COMPILE_OBJECTIVE_CPP': 1,
@@ -289,6 +366,8 @@ def config_env(toolchain, variant, env):
                     ])
 
         boost_libs = [
+            'boost_coroutine',
+            'boost_context',
             'boost_date_time',
             'boost_filesystem',
             'boost_program_options',
@@ -319,26 +398,12 @@ def config_env(toolchain, variant, env):
         else:
             env.Append(LIBS=['rt'])
 
-        env.Append(LINKFLAGS=[
-            '-rdynamic'
-            ])
-
-        if variant == 'debug':
-            env.Append(CCFLAGS=[
-                '-g'
-                ])
-        elif variant == 'release':
+        if variant == 'release':
             env.Append(CCFLAGS=[
                 '-O3',
                 '-fno-strict-aliasing'
                 ])
 
-        if toolchain != 'msvc':
-            git = Beast.Git(env)
-            if git.exists:
-                id = '%s+%s.%s' % (git.tags, git.user, git.branch)
-                env.Append(CPPDEFINES={'GIT_COMMIT_ID' : '\'"%s"\'' % id })
-
         if toolchain == 'clang':
             if Beast.system.osx:
                 env.Replace(CC='clang', CXX='clang++', LINK='clang++')
@@ -370,6 +435,9 @@ def config_env(toolchain, variant, env):
                 env.Append(CPPDEFINES={
                     '_FORTIFY_SOURCE': 2
                     })
+                env.Append(CCFLAGS=[
+                    '-O0'
+                    ])
 
     elif toolchain == 'msvc':
         env.Append (CPPPATH=[
@@ -459,17 +527,10 @@ def config_env(toolchain, variant, env):
 
 #-------------------------------------------------------------------------------
 
-def addSource(path, env, variant_dirs, CPPPATH=[]):
-    if CPPPATH:
-        env = env.Clone()
-        env.Prepend(CPPPATH=CPPPATH)
-    return env.Object(Beast.variantFile(path, variant_dirs))
-
-#-------------------------------------------------------------------------------
-
 # Configure the base construction environment
 root_dir = Dir('#').srcnode().get_abspath() # Path to this SConstruct file
 build_dir = os.path.join('build')
+
 base = Environment(
     toolpath=[os.path.join ('src', 'beast', 'site_scons', 'site_tools')],
     tools=['default', 'Protoc', 'VSProject'],
@@ -481,10 +542,14 @@ base.Append(CPPPATH=[
     'src',
     os.path.join('src', 'beast'),
     os.path.join(build_dir, 'proto'),
+    os.path.join('src','soci','src'),
     ])
 
+base.Decider('MD5-timestamp')
+set_implicit_cache()
+
 # Configure the toolchains, variants, default toolchain, and default target
-variants = ['debug', 'release']
+variants = ['debug', 'release', 'profile']
 all_toolchains = ['clang', 'gcc', 'msvc']
 if Beast.system.osx:
     toolchains = ['clang']
@@ -505,7 +570,9 @@ else:
         default_toolchain = 'clang'
     else:
         raise ValueError("Don't understand toolchains in " + str(toolchains))
-default_variant = 'debug'
+
+default_tu_style = 'unity'
+default_variant = 'release'
 default_target = None
 
 for source in [
@@ -517,111 +584,287 @@ for source in [
         PROTOCOUTDIR=os.path.join(build_dir, 'proto'),
         PROTOCPYTHONOUTDIR=None)
 
+#-------------------------------------------------------------------------------
+
+class ObjectBuilder(object):
+    def __init__(self, env, variant_dirs):
+        self.env = env
+        self.variant_dirs = variant_dirs
+        self.objects = []
+
+    def add_source_files(self, *filenames, **kwds):
+        for filename in filenames:
+            env = self.env
+            if kwds:
+                env = env.Clone()
+                env.Prepend(**kwds)
+            o = env.Object(Beast.variantFile(filename, self.variant_dirs))
+            self.objects.append(o)
+
+def list_sources(base, suffixes):
+    def _iter(base):
+        for parent, dirs, files in os.walk(base):
+            files = [f for f in files if not f[0] == '.']
+            dirs[:] = [d for d in dirs if not d[0] == '.']
+            for path in files:
+                path = os.path.join(parent, path)
+                r = os.path.splitext(path)
+                if r[1] and r[1] in suffixes:
+                    yield os.path.normpath(path)
+    return list(_iter(base))
+
+
+def append_sources(result, *filenames, **kwds):
+    result.append([filenames, kwds])
+
+
+def get_soci_sources(style):
+    result = []
+    cpp_path = [
+        'src/soci/src/core',
+        'src/sqlite', ]
+    append_sources(result,
+                   'src/ripple/unity/soci.cpp',
+                   CPPPATH=cpp_path)
+    if style == 'unity':
+        append_sources(result,
+                       'src/ripple/unity/soci_ripple.cpp',
+                       CPPPATH=cpp_path)
+    return result
+
+
+def get_classic_sources():
+    result = []
+    append_sources(
+        result,
+        *list_sources('src/ripple/app', '.cpp'),
+        CPPPATH=[
+            'src/soci/src/core',
+            'src/sqlite']
+    )
+    append_sources(result, *list_sources('src/ripple/basics', '.cpp'))
+    append_sources(result, *list_sources('src/ripple/core', '.cpp'))
+    append_sources(result, *list_sources('src/ripple/crypto', '.cpp'))
+    append_sources(result, *list_sources('src/ripple/json', '.cpp'))
+    append_sources(result, *list_sources('src/ripple/legacy', '.cpp'))
+    append_sources(result, *list_sources('src/ripple/net', '.cpp'))
+    append_sources(result, *list_sources('src/ripple/overlay', '.cpp'))
+    append_sources(result, *list_sources('src/ripple/peerfinder', '.cpp'))
+    append_sources(result, *list_sources('src/ripple/protocol', '.cpp'))
+    append_sources(result, *list_sources('src/ripple/shamap', '.cpp'))
+    append_sources(
+        result,
+        *list_sources('src/ripple/nodestore', '.cpp'),
+        CPPPATH=[
+            'src/rocksdb2/include',
+            'src/snappy/snappy',
+            'src/snappy/config',
+        ])
+
+    result += get_soci_sources('classic')
+    return result
+
+
+def get_unity_sources():
+    result = []
+    append_sources(
+        result,
+        'src/ripple/unity/app.cpp',
+        'src/ripple/unity/app1.cpp',
+        'src/ripple/unity/app2.cpp',
+        'src/ripple/unity/app3.cpp',
+        'src/ripple/unity/app4.cpp',
+        'src/ripple/unity/app5.cpp',
+        'src/ripple/unity/app6.cpp',
+        'src/ripple/unity/app7.cpp',
+        'src/ripple/unity/app8.cpp',
+        'src/ripple/unity/app9.cpp',
+        'src/ripple/unity/core.cpp',
+        'src/ripple/unity/basics.cpp',
+        'src/ripple/unity/crypto.cpp',
+        'src/ripple/unity/net.cpp',
+        'src/ripple/unity/overlay.cpp',
+        'src/ripple/unity/peerfinder.cpp',
+        'src/ripple/unity/json.cpp',
+        'src/ripple/unity/protocol.cpp',
+        'src/ripple/unity/shamap.cpp',
+        'src/ripple/unity/legacy.cpp',
+    )
+
+    result += get_soci_sources('unity')
+
+    append_sources(
+        result,
+        'src/ripple/unity/nodestore.cpp',
+        CPPPATH=[
+            'src/rocksdb2/include',
+            'src/snappy/snappy',
+            'src/snappy/config',
+        ])
+
+    return result
+
 # Declare the targets
 aliases = collections.defaultdict(list)
 msvc_configs = []
-for toolchain in all_toolchains:
-    for variant in variants:
-        # Configure this variant's construction environment
-        env = base.Clone()
-        config_env(toolchain, variant, env)
-        variant_name = '%s.%s' % (toolchain, variant)
-        variant_dir = os.path.join(build_dir, variant_name)
-        variant_dirs = {
-            os.path.join(variant_dir, 'src') :
-                'src',
-            os.path.join(variant_dir, 'proto') :
-                os.path.join (build_dir, 'proto'),
-            }
-        for dest, source in variant_dirs.iteritems():
-            env.VariantDir(dest, source, duplicate=0)
-        objects = []
-        objects.append(addSource('src/ripple/unity/app.cpp', env, variant_dirs))
-        objects.append(addSource('src/ripple/unity/app1.cpp', env, variant_dirs))
-        objects.append(addSource('src/ripple/unity/app2.cpp', env, variant_dirs))
-        objects.append(addSource('src/ripple/unity/app3.cpp', env, variant_dirs))
-        objects.append(addSource('src/ripple/unity/app4.cpp', env, variant_dirs))
-        objects.append(addSource('src/ripple/unity/app5.cpp', env, variant_dirs))
-        objects.append(addSource('src/ripple/unity/app6.cpp', env, variant_dirs))
-        objects.append(addSource('src/ripple/unity/app7.cpp', env, variant_dirs))
-        objects.append(addSource('src/ripple/unity/app8.cpp', env, variant_dirs))
-        objects.append(addSource('src/ripple/unity/app9.cpp', env, variant_dirs))
-        objects.append(addSource('src/ripple/unity/basics.cpp', env, variant_dirs))
-        objects.append(addSource('src/ripple/unity/beast.cpp', env, variant_dirs))
-        objects.append(addSource('src/ripple/unity/beastc.c', env, variant_dirs))
-        objects.append(addSource('src/ripple/unity/common.cpp', env, variant_dirs))
-        objects.append(addSource('src/ripple/unity/core.cpp', env, variant_dirs))
-        objects.append(addSource('src/ripple/unity/data.cpp', env, variant_dirs))
-        objects.append(addSource('src/ripple/unity/http.cpp', env, variant_dirs))
-        objects.append(addSource('src/ripple/unity/json.cpp', env, variant_dirs))
-        objects.append(addSource('src/ripple/unity/net.cpp', env, variant_dirs))
-        objects.append(addSource('src/ripple/unity/overlay.cpp', env, variant_dirs))
-        objects.append(addSource('src/ripple/unity/peerfinder.cpp', env, variant_dirs))
-        objects.append(addSource('src/ripple/unity/protobuf.cpp', env, variant_dirs))
-        objects.append(addSource('src/ripple/unity/ripple.proto.cpp', env, variant_dirs))
-        objects.append(addSource('src/ripple/unity/radmap.cpp', env, variant_dirs))
-        objects.append(addSource('src/ripple/unity/resource.cpp', env, variant_dirs))
-        objects.append(addSource('src/ripple/unity/rpcx.cpp', env, variant_dirs))
-        objects.append(addSource('src/ripple/unity/sitefiles.cpp', env, variant_dirs))
-        objects.append(addSource('src/ripple/unity/sslutil.cpp', env, variant_dirs))
-        objects.append(addSource('src/ripple/unity/testoverlay.cpp', env, variant_dirs))
-        objects.append(addSource('src/ripple/unity/types.cpp', env, variant_dirs))
-        objects.append(addSource('src/ripple/unity/validators.cpp', env, variant_dirs))
-        objects.append(addSource('src/ripple/unity/websocket.cpp', env, variant_dirs))
 
-        objects.append(addSource('src/ripple/unity/nodestore.cpp', env, variant_dirs, [
-            'src/leveldb/include',
-            #'src/hyperleveldb/include', # hyper
-            'src/rocksdb2/include',
-            ]))
 
-        objects.append(addSource('src/ripple/unity/leveldb.cpp', env, variant_dirs, [
-            'src/leveldb/',
-            'src/leveldb/include',
-            'src/snappy/snappy',
-            'src/snappy/config',
-            ]))
+def should_prepare_target(cl_target,
+                          style, toolchain, variant):
+    if not cl_target:
+        # default target
+        return (style == default_tu_style and
+                toolchain == default_toolchain and
+                variant == default_variant)
+    if 'vcxproj' in cl_target:
+        return toolchain == 'msvc'
+    s = cl_target.split('.')
+    if style == 'unity' and 'nounity' in s:
+        return False
+    if len(s) == 1:
+        return ('all' in cl_target or
+                variant in cl_target or
+                toolchain in cl_target)
+    if len(s) == 2 or len(s) == 3:
+        return s[0] == toolchain and s[1] == variant
 
-        objects.append(addSource('src/ripple/unity/hyperleveldb.cpp', env, variant_dirs, [
-            'src/hyperleveldb',
-            'src/snappy/snappy',
-            'src/snappy/config',
-            ]))
+    return True  # A target we don't know about, better prepare to build it
 
-        objects.append(addSource('src/ripple/unity/rocksdb.cpp', env, variant_dirs, [
-            'src/rocksdb2',
-            'src/rocksdb2/include',
-            'src/snappy/snappy',
-            'src/snappy/config',
-            ]))
 
-        objects.append(addSource('src/ripple/unity/snappy.cpp', env, variant_dirs, [
-            'src/snappy/snappy',
-            'src/snappy/config',
-            ]))
+def should_prepare_targets(style, toolchain, variant):
+    if not COMMAND_LINE_TARGETS:
+        return should_prepare_target(None, style, toolchain, variant)
+    for t in COMMAND_LINE_TARGETS:
+        if should_prepare_target(t, style, toolchain, variant):
+            return True
 
-        if toolchain == "clang" and Beast.system.osx:
-            objects.append(addSource('src/ripple/unity/beastobjc.mm', env, variant_dirs))
+for tu_style in ['classic', 'unity']:
+    if tu_style == 'classic':
+        sources = get_classic_sources()
+    else:
+        sources = get_unity_sources()
+    for toolchain in all_toolchains:
+        for variant in variants:
+            if not should_prepare_targets(tu_style, toolchain, variant):
+                continue
+            if variant == 'profile' and toolchain == 'msvc':
+                continue
+            # Configure this variant's construction environment
+            env = base.Clone()
+            config_env(toolchain, variant, env)
+            variant_name = '%s.%s' % (toolchain, variant)
+            if tu_style == 'classic':
+                variant_name += '.nounity'
+            variant_dir = os.path.join(build_dir, variant_name)
+            variant_dirs = {
+                os.path.join(variant_dir, 'src') :
+                    'src',
+                os.path.join(variant_dir, 'proto') :
+                    os.path.join (build_dir, 'proto'),
+                }
+            for dest, source in variant_dirs.iteritems():
+                env.VariantDir(dest, source, duplicate=0)
 
-        target = env.Program(
-            target = os.path.join(variant_dir, 'rippled'),
-            source = objects
+            object_builder = ObjectBuilder(env, variant_dirs)
+
+            for s, k in sources:
+                object_builder.add_source_files(*s, **k)
+
+            git_commit_tag = {}
+            if toolchain != 'msvc':
+                git = Beast.Git(env)
+                if git.exists:
+                    id = '%s+%s.%s' % (git.tags, git.user, git.branch)
+                    git_commit_tag = {'CPPDEFINES':
+                                      {'GIT_COMMIT_ID' : '\'"%s"\'' % id }}
+
+            object_builder.add_source_files(
+                'src/ripple/unity/git_id.cpp',
+                **git_commit_tag)
+
+            object_builder.add_source_files(
+                'src/beast/beast/unity/hash_unity.cpp',
+                'src/ripple/unity/beast.cpp',
+                'src/ripple/unity/lz4.c',
+                'src/ripple/unity/protobuf.cpp',
+                'src/ripple/unity/ripple.proto.cpp',
+                'src/ripple/unity/resource.cpp',
+                'src/ripple/unity/rpcx.cpp',
+                'src/ripple/unity/server.cpp',
+                'src/ripple/unity/validators.cpp',
+                'src/ripple/unity/websocket02.cpp'
             )
 
-        if toolchain == default_toolchain and variant == default_variant:
-            default_target = target
-            install_target = env.Install (build_dir, source = default_target)
-            env.Alias ('install', install_target)
-            env.Default (install_target)
-            aliases['all'].extend(install_target)
-        if toolchain == 'msvc':
-            config = env.VSProjectConfig(variant, 'x64', target, env)
-            msvc_configs.append(config)
-        if toolchain in toolchains:
-            aliases['all'].extend(target)
-            aliases[variant].extend(target)
-            aliases[toolchain].extend(target)
-            env.Alias(variant_name, target)
+            object_builder.add_source_files(
+                'src/ripple/unity/beastc.c',
+                CCFLAGS = ([] if toolchain == 'msvc' else ['-Wno-array-bounds']))
+
+            if 'gcc' in toolchain:
+                no_uninitialized_warning = {'CCFLAGS': ['-Wno-maybe-uninitialized']}
+            else:
+                no_uninitialized_warning = {}
+
+            object_builder.add_source_files(
+                'src/ripple/unity/ed25519.c',
+                CPPPATH=[
+                    'src/ed25519-donna',
+                ]
+            )
+
+            object_builder.add_source_files(
+                'src/ripple/unity/rocksdb.cpp',
+                CPPPATH=[
+                    'src/rocksdb2',
+                    'src/rocksdb2/include',
+                    'src/snappy/snappy',
+                    'src/snappy/config',
+                ],
+                **no_uninitialized_warning
+            )
+
+            object_builder.add_source_files(
+                'src/ripple/unity/snappy.cpp',
+                CCFLAGS=([] if toolchain == 'msvc' else ['-Wno-unused-function']),
+                CPPPATH=[
+                    'src/snappy/snappy',
+                    'src/snappy/config',
+                ]
+            )
+
+            object_builder.add_source_files(
+                'src/ripple/unity/websocket04.cpp',
+                CPPPATH='src/websocketpp',
+            )
+
+            if toolchain == "clang" and Beast.system.osx:
+                object_builder.add_source_files('src/ripple/unity/beastobjc.mm')
+
+            target = env.Program(
+                target=os.path.join(variant_dir, 'rippled'),
+                source=object_builder.objects
+                )
+
+            if tu_style == default_tu_style:
+                if toolchain == default_toolchain and (
+                    variant == default_variant):
+                    default_target = target
+                    install_target = env.Install (build_dir, source=default_target)
+                    env.Alias ('install', install_target)
+                    env.Default (install_target)
+                    aliases['all'].extend(install_target)
+                if toolchain == 'msvc':
+                    config = env.VSProjectConfig(variant, 'x64', target, env)
+                    msvc_configs.append(config)
+                if toolchain in toolchains:
+                    aliases['all'].extend(target)
+                    aliases[toolchain].extend(target)
+            elif toolchain == 'msvc':
+                config = env.VSProjectConfig(variant + ".classic", 'x64', target, env)
+                msvc_configs.append(config)
+
+            if toolchain in toolchains:
+                aliases[variant].extend(target)
+                env.Alias(variant_name, target)
 
 for key, value in aliases.iteritems():
     env.Alias(key, value)
@@ -632,3 +875,33 @@ vcxproj = base.VSProject(
     VSPROJECT_ROOT_DIRS = ['src/beast', 'src', '.'],
     VSPROJECT_CONFIGS = msvc_configs)
 base.Alias('vcxproj', vcxproj)
+
+#-------------------------------------------------------------------------------
+
+# Adds a phony target to the environment that always builds
+# See: http://www.scons.org/wiki/PhonyTargets
+def PhonyTargets(env = None, **kw):
+    if not env: env = DefaultEnvironment()
+    for target, action in kw.items():
+        env.AlwaysBuild(env.Alias(target, [], action))
+
+# Build the list of rippled source files that hold unit tests
+def do_count(target, source, env):
+    def list_testfiles(base, suffixes):
+        def _iter(base):
+            for parent, _, files in os.walk(base):
+                for path in files:
+                    path = os.path.join(parent, path)
+                    r = os.path.splitext(path)
+                    if r[1] in suffixes:
+                        if r[0].endswith('.test'):
+                            yield os.path.normpath(path)
+        return list(_iter(base))
+    testfiles = list_testfiles(os.path.join('src', 'ripple'), env.get('CPPSUFFIXES'))
+    lines = 0
+    for f in testfiles:
+        lines = lines + sum(1 for line in open(f))
+    print "Total unit test lines: %d" % lines
+
+PhonyTargets(env, count = do_count)
+

appveyor.yml

@@ -0,0 +1,77 @@
+# Set environment variables.
+environment:
+  PYTHON: C:/Python27-x64
+
+  # We bundle up protoc.exe and only the parts of boost and openssl we need so
+  # that it's a small download. We also use appveyor's free cache, avoiding fees
+  # downloading from S3 each time. 
+  # TODO: script to create this package.
+  RIPPLED_DEPS_URL: https://s3-ap-northeast-1.amazonaws.com/history-replay/rippled_deps.zip
+
+  # Other dependencies we just download each time.
+  PIP_URL: https://bootstrap.pypa.io/get-pip.py
+  PYWIN32_URL: https://downloads.sourceforge.net/project/pywin32/pywin32/Build%20219/pywin32-219.win-amd64-py2.7.exe
+
+  # Scons honours these environment variables, setting the include/lib paths.
+  BOOST_ROOT: C:/rippled_deps/boost
+  OPENSSL_ROOT: C:/rippled_deps/openssl
+
+# At the end of each successful build we cache this directory. It must be less
+# than 100MB total compressed.
+cache:
+  - "C:\\rippled_deps"
+
+# This means we'll download a zip of the branch we want, rather than the full
+# history.
+shallow_clone: true
+
+install:
+  # We want easy_install, python and protoc.exe on PATH.
+  - SET PATH=%PYTHON%;%PYTHON%/Scripts;C:/rippled_deps;%PATH%
+
+  # `ps` prefix means the command is executed by powershell.
+  - ps: Start-FileDownload $env:PIP_URL
+  - ps: Start-FileDownload $env:PYWIN32_URL
+
+  # Installing pip will install setuptools/easy_install.
+  - python get-pip.py
+
+  # Pip has some problems installing scons on windows so we use easy install.
+  - easy_install scons
+
+  # Scons has problems with parallel builds on windows without pywin32.
+  - easy_install pywin32-219.win-amd64-py2.7.exe
+  # (easy_install can do headless installs of .exe wizards)
+
+  # Download dependencies if appveyor didn't restore them from the cache.
+  # Use 7zip to unzip.
+  - ps: |
+        if (-not(Test-Path 'C:/rippled_deps')) {
+            Start-FileDownload "$env:RIPPLED_DEPS_URL"
+            7z x rippled_deps.zip -oC:\ -y > $null
+        }
+
+# TODO: This is giving me grief
+# artifacts:
+#   # Save rippled.exe in the cloud after each build.
+#   - path: "build\\rippled.exe"
+
+build_script:
+  # We set the environment variables needed to put compilers on the PATH.
+  - '"%VS120COMNTOOLS%../../VC/vcvarsall.bat" x86_amd64'
+  # Show which version of the compiler we are using.
+  - cl
+  - scons msvc.debug -j%NUMBER_OF_PROCESSORS%
+
+after_build:
+  # Put our executable in a place where npm test can find it.
+  - ps: cp build/msvc.debug/rippled.exe build
+  - ps: ls build
+
+test_script:
+  # Run the unit tests
+  - build\\rippled --unittest
+
+  # Run the integration tests
+  - npm install
+  - npm test

bin/ripple/ledger/Args.py

@@ -7,11 +7,13 @@ import os
 from ripple.ledger import LedgerNumber
 from ripple.util import File
 from ripple.util import Log
+from ripple.util import PrettyPrint
 from ripple.util import Range
 from ripple.util.Function import Function
 
 NAME = 'LedgerTool'
 VERSION = '0.1'
+NONE = '(none)'
 
 _parser = argparse.ArgumentParser(
     prog=NAME,
@@ -56,7 +58,14 @@ _parser.add_argument(
     )
 
 _parser.add_argument(
-    '--display', '-d',
+    '--database', '-d',
+    nargs='*',
+    default=NONE,
+    help='Specify a database.',
+    )
+
+_parser.add_argument(
+    '--display',
     help='Specify a function to display ledgers.',
     )
 
@@ -102,6 +111,12 @@ _parser.add_argument(
     help='If true, display times in UTC rather than local time.',
     )
 
+_parser.add_argument(
+    '--validations',
+    default=3,
+    help='The number of validations needed before considering a ledger valid.',
+    )
+
 _parser.add_argument(
     '--version',
     action='version',
@@ -130,6 +145,7 @@ _parser.add_argument(
 
 # Read the arguments from the command line.
 ARGS = _parser.parse_args()
+ARGS.NONE = NONE
 
 Log.VERBOSE = ARGS.verbose
 
@@ -159,10 +175,13 @@ if ARGS.window < 0:
     raise ValueError('Window cannot be negative: --window=%d' %
                      ARGS.window)
 
-_loaders = bool(ARGS.server) + bool(ARGS.rippled)
+PrettyPrint.INDENT = (ARGS.indent * ' ')
+
+_loaders = (ARGS.database != NONE) + bool(ARGS.rippled) + bool(ARGS.server)
 
 if not _loaders:
     ARGS.rippled = 'rippled'
 
 elif _loaders > 1:
-    raise ValueError('At most one of --rippled and --server must be specified')
+    raise ValueError('At most one of --database,  --rippled and --server '
+                     'may be specified')

bin/ripple/ledger/DatabaseReader.py

@@ -0,0 +1,78 @@
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+import json
+import os
+import subprocess
+
+from ripple.ledger.Args import ARGS
+from ripple.util import ConfigFile
+from ripple.util import Database
+from ripple.util import File
+from ripple.util import Log
+from ripple.util import Range
+
+LEDGER_QUERY = """
+SELECT
+     L.*, count(1) validations
+FROM
+    (select LedgerHash, LedgerSeq from Ledgers ORDER BY LedgerSeq DESC) L
+    JOIN Validations V
+    ON (V.LedgerHash = L.LedgerHash)
+    GROUP BY L.LedgerHash
+    HAVING validations >= {validation_quorum}
+    ORDER BY 2;
+"""
+
+COMPLETE_QUERY = """
+SELECT
+     L.LedgerSeq, count(*) validations
+FROM
+    (select LedgerHash, LedgerSeq from Ledgers ORDER BY LedgerSeq) L
+    JOIN Validations V
+    ON (V.LedgerHash = L.LedgerHash)
+    GROUP BY L.LedgerHash
+    HAVING validations >= :validation_quorum
+    ORDER BY 2;
+"""
+
+_DATABASE_NAME = 'ledger.db'
+
+USE_PLACEHOLDERS = False
+
+class DatabaseReader(object):
+    def __init__(self, config):
+        assert ARGS.database != ARGS.NONE
+        database = ARGS.database or config['database_path']
+        if not database.endswith(_DATABASE_NAME):
+            database = os.path.join(database, _DATABASE_NAME)
+        if USE_PLACEHOLDERS:
+            cursor = Database.fetchall(
+                database, COMPLETE_QUERY, config)
+        else:
+            cursor = Database.fetchall(
+                database, LEDGER_QUERY.format(**config), {})
+        self.complete = [c[1] for c in cursor]
+
+    def name_to_ledger_index(self, ledger_name, is_full=False):
+        if not self.complete:
+            return None
+        if ledger_name == 'closed':
+            return self.complete[-1]
+        if ledger_name == 'current':
+            return None
+        if ledger_name == 'validated':
+            return self.complete[-1]
+
+    def get_ledger(self, name, is_full=False):
+        cmd = ['ledger', str(name)]
+        if is_full:
+            cmd.append('full')
+        response = self._command(*cmd)
+        result = response.get('ledger')
+        if result:
+            return result
+        error = response['error']
+        etext = _ERROR_TEXT.get(error)
+        if etext:
+            error = '%s (%s)' % (etext, error)
+        Log.fatal(_ERROR_TEXT.get(error, error))

bin/ripple/ledger/PrettyPrint.py

@@ -1,21 +0,0 @@
-from __future__ import absolute_import, division, print_function, unicode_literals
-
-from ripple.ledger.Args import ARGS
-
-from functools import wraps
-import json
-
-def pretty_print(item):
-    return json.dumps(item,
-                      sort_keys=True,
-                      indent=ARGS.indent,
-                      separators=(',', ': '))
-
-def pretty(f):
-    """"A decorator on a function that makes its results pretty """
-    @wraps(f)
-    def wrapper(*args, **kwds):
-        result = list(f(*args, **kwds))
-        return pretty_print(result)
-
-    return wrapper

bin/ripple/ledger/RippledReader.py

@@ -22,13 +22,13 @@ _ERROR_TEXT = {
 _DEFAULT_ERROR_ = "Couldn't connect to server."
 
 class RippledReader(object):
-    def __init__(self):
+    def __init__(self, config):
         fname = File.normalize(ARGS.rippled)
         if not os.path.exists(fname):
             raise Exception('No rippled found at %s.' % fname)
         self.cmd = [fname]
         if ARGS.config:
-            self.cmd.extend(['--conf', _normalize(ARGS.config)])
+            self.cmd.extend(['--conf', File.normalize(ARGS.config)])
         self.info = self._command('server_info')['info']
         c = self.info.get('complete_ledgers')
         if c == 'empty':

bin/ripple/ledger/Server.py

@@ -3,17 +3,21 @@ from __future__ import absolute_import, division, print_function, unicode_litera
 import json
 import os
 
-from ripple.ledger import RippledReader, ServerReader
+from ripple.ledger import DatabaseReader, RippledReader
 from ripple.ledger.Args import ARGS
 from ripple.util.FileCache import FileCache
+from ripple.util import ConfigFile
+from ripple.util import File
 from ripple.util import Range
 
 class Server(object):
     def __init__(self):
-        if ARGS.rippled:
-            reader = RippledReader.RippledReader()
+        cfg_file = File.normalize(ARGS.config or 'rippled.cfg')
+        self.config = ConfigFile.read(open(cfg_file))
+        if ARGS.database != ARGS.NONE:
+            reader = DatabaseReader.DatabaseReader(self.config)
         else:
-            reader = ServerReader.ServerReader()
+            reader = RippledReader.RippledReader(self.config)
 
         self.reader = reader
         self.complete = reader.complete
@@ -23,8 +27,7 @@ class Server(object):
             'current': reader.name_to_ledger_index('current'),
             'validated': reader.name_to_ledger_index('validated'),
             'first': self.complete[0] if self.complete else None,
-            'last': self.complete[-1] if self.complete else None
-,
+            'last': self.complete[-1] if self.complete else None,
         }
         self.__dict__.update(names)
         self.ledgers = sorted(Range.join_ranges(*ARGS.ledgers, **names))

bin/ripple/ledger/ServerReader.py

@@ -1,5 +1,5 @@
 from __future__ import absolute_import, division, print_function, unicode_literals
 
 class ServerReader(object):
-    def __init__(self, server):
+    def __init__(self, config):
         raise ValueError('Direct server connections are not yet implemented.')

bin/ripple/ledger/commands/Cache.py

@@ -1,9 +1,9 @@
 from __future__ import absolute_import, division, print_function, unicode_literals
 
 from ripple.ledger.Args import ARGS
-from ripple.ledger.PrettyPrint import pretty_print
 from ripple.util import Log
 from ripple.util import Range
+from ripple.util.PrettyPrint import pretty_print
 
 SAFE = True
 

bin/ripple/ledger/commands/Info.py

@@ -1,17 +1,17 @@
 from __future__ import absolute_import, division, print_function, unicode_literals
 
 from ripple.ledger.Args import ARGS
-from ripple.ledger.PrettyPrint import pretty_print
 from ripple.util import Log
 from ripple.util import Range
+from ripple.util.PrettyPrint import pretty_print
 
 SAFE = True
 
 HELP = 'info - return server_info'
 
 def info(server):
-    Log.out('first = ', server.first)
-    Log.out('last = ', server.last)
+    Log.out('first =', server.first)
+    Log.out('last =', server.last)
     Log.out('closed =', server.closed)
     Log.out('current =', server.current)
     Log.out('validated =', server.validated)

bin/ripple/ledger/commands/Print.py

@@ -12,5 +12,4 @@ HELP = """print
 Print the ledgers to stdout.  The default command."""
 
 def run_print(server):
-    for x in ARGS.display(server, SearchLedgers.search(server)):
-        print(x)
+    ARGS.display(print, server, SearchLedgers.search(server))

bin/ripple/ledger/displays/__init__.py

@@ -5,11 +5,11 @@ from functools import wraps
 import jsonpath_rw
 
 from ripple.ledger.Args import ARGS
-from ripple.ledger.PrettyPrint import pretty_print
 from ripple.util import Dict
 from ripple.util import Log
 from ripple.util import Range
 from ripple.util.Decimal import Decimal
+from ripple.util.PrettyPrint import pretty_print, Streamer
 
 TRANSACT_FIELDS = (
     'accepted',
@@ -33,33 +33,30 @@ LEDGER_FIELDS = (
 def _dict_filter(d, keys):
     return dict((k, v) for (k, v) in d.items() if k in keys)
 
-def ledger_number(server, numbers):
-    yield Range.to_string(numbers)
+def ledger_number(print, server, numbers):
+    print(Range.to_string(numbers))
 
 def display(f):
-    """A decorator for displays that just print JSON"""
     @wraps(f)
-    def wrapper(server, numbers, *args, **kwds):
+    def wrapper(printer, server, numbers, *args):
+        streamer = Streamer(printer=printer)
         for number in numbers:
             ledger = server.get_ledger(number, ARGS.full)
             if ledger:
-                yield pretty_print(f(ledger, *args, **kwds))
+                streamer.add(number, f(ledger, *args))
+        streamer.finish()
     return wrapper
 
-def json(f):
-    """A decorator for displays that print JSON, extracted by a path"""
+def extractor(f):
     @wraps(f)
-    def wrapper(server, numbers, path, *args, **kwds):
+    def wrapper(printer, server, numbers, *paths):
         try:
-            path_expr = jsonpath_rw.parse(path)
+            find = jsonpath_rw.parse('|'.join(paths)).find
         except:
             raise ValueError("Can't understand jsonpath '%s'." % path)
-
-        for number in numbers:
-            ledger = server.get_ledger(number, ARGS.full)
-            if ledger:
-                finds = path_expr.find(ledger)
-                yield pretty_print(f(finds, *args, **kwds))
+        def fn(ledger, *args):
+            return f(find(ledger), *args)
+        display(fn)(printer, server, numbers)
     return wrapper
 
 @display
@@ -67,6 +64,7 @@ def ledger(ledger, full=False):
     if ARGS.full:
         if full:
             return ledger
+
         ledger = Dict.prune(ledger, 1, False)
 
     return _dict_filter(ledger, LEDGER_FIELDS)
@@ -79,11 +77,11 @@ def prune(ledger, level=1):
 def transact(ledger):
     return _dict_filter(ledger, TRANSACT_FIELDS)
 
-@json
+@extractor
 def extract(finds):
     return dict((str(f.full_path), str(f.value)) for f in finds)
 
-@json
+@extractor
 def sum(finds):
     d = Decimal()
     for f in finds:

bin/ripple/util/ConfigFile.py

@@ -0,0 +1,54 @@
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+import json
+
+"""Ripple has a proprietary format for their .cfg files, so we need a reader for
+them."""
+
+def read(lines):
+    sections = []
+    section = []
+    for line in lines:
+        line = line.strip()
+        if (not line) or line[0] == '#':
+            continue
+        if line.startswith('['):
+            if section:
+                sections.append(section)
+                section = []
+        section.append(line)
+    if section:
+        sections.append(section)
+
+    result = {}
+    for section in sections:
+        option = section.pop(0)
+        assert section, ('No value for option "%s".' % option)
+        assert option.startswith('[') and option.endswith(']'), (
+            'No option name in block "%s"' % p[0])
+        option = option[1:-1]
+        assert option not in result, 'Duplicate option "%s".' % option
+
+        subdict = {}
+        items = []
+        for part in section:
+            if '=' in part:
+                assert not items, 'Dictionary mixed with list.'
+                k, v = part.split('=', 1)
+                assert k not in subdict, 'Repeated dictionary entry ' + k
+                subdict[k] = v
+            else:
+                assert not subdict, 'List mixed with dictionary.'
+                if part.startswith('{'):
+                    items.append(json.loads(part))
+                else:
+                    words = part.split()
+                    if len(words) > 1:
+                        items.append(words)
+                    else:
+                        items.append(part)
+        if len(items) == 1:
+            result[option] = items[0]
+        else:
+            result[option] = items or subdict
+    return result

bin/ripple/util/Database.py

@@ -0,0 +1,12 @@
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+import sqlite3
+
+def fetchall(database, query, kwds):
+    conn = sqlite3.connect(database)
+    try:
+        cursor = conn.execute(query, kwds)
+        return cursor.fetchall()
+
+    finally:
+        conn.close()

bin/ripple/util/Function.py

@@ -20,7 +20,10 @@ REMAPPINGS = {
 }
 
 def eval_arguments(args):
-    tokens = tokenize.generate_tokens(StringIO(args or '()').readline)
+    args = args.strip()
+    if not args or (args == '()'):
+        return ()
+    tokens = list(tokenize.generate_tokens(StringIO(args).readline))
     def remap():
         for type, name, _, _, _ in tokens:
             if type == tokenize.NAME and name not in REMAPPINGS:
@@ -30,7 +33,11 @@ def eval_arguments(args):
     untok = tokenize.untokenize(remap())
     if untok[1:-1].strip():
         untok = untok[:-1] + ',)'  # Force a tuple.
-    return eval(untok, REMAPPINGS)
+    try:
+        return eval(untok, REMAPPINGS)
+    except Exception as e:
+        raise ValueError('Couldn\'t evaluate expression "%s" (became "%s"), '
+                         'error "%s"' % (args, untok, str(e)))
 
 class Function(object):
     def __init__(self, desc='', default_path=''):
@@ -52,10 +59,10 @@ class Function(object):
                 default_path += '.'
             self.function = default_path + self.function
         p, m = self.function.rsplit('.', 1)
-        try:
-            mod = importlib.import_module(p)
-        except:
-            raise ValueError('Can\'t find Python module "%s"' % p)
+        mod = importlib.import_module(p)
+        # Errors in modules are swallowed here.
+        # except:
+        #    raise ValueError('Can\'t find Python module "%s"' % p)
 
         try:
             self.function = getattr(mod, m)

bin/ripple/util/PrettyPrint.py

@@ -0,0 +1,42 @@
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+from functools import wraps
+import json
+
+SEPARATORS = ',', ': '
+INDENT = '    '
+
+def pretty_print(item):
+    return json.dumps(item,
+                      sort_keys=True,
+                      indent=len(INDENT),
+                      separators=SEPARATORS)
+
+class Streamer(object):
+    def __init__(self, printer=print):
+        # No automatic spacing or carriage returns.
+        self.printer = lambda *args: printer(*args, end='', sep='')
+        self.first_key = True
+
+    def add(self, key, value):
+        if self.first_key:
+            self.first_key = False
+            self.printer('{')
+        else:
+            self.printer(',')
+
+        self.printer('\n', INDENT, '"', str(key), '": ')
+
+        pp = pretty_print(value).splitlines()
+        if len(pp) > 1:
+            for i, line in enumerate(pp):
+                if i > 0:
+                    self.printer('\n', INDENT)
+                self.printer(line)
+        else:
+            self.printer(pp[0])
+
+    def finish(self):
+        if not self.first_key:
+            self.first_key = True
+            self.printer('\n}')

bin/ripple/util/test_ConfigFile.py

@@ -0,0 +1,163 @@
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+from ripple.util import ConfigFile
+
+from unittest import TestCase
+
+class test_ConfigFile(TestCase):
+    def test_trivial(self):
+        self.assertEquals(ConfigFile.read(''), {})
+
+    def test_full(self):
+        self.assertEquals(ConfigFile.read(FULL.splitlines()), RESULT)
+
+RESULT = {
+    'websocket_port': '6206',
+    'database_path': '/development/alpha/db',
+    'sntp_servers':
+        ['time.windows.com', 'time.apple.com', 'time.nist.gov', 'pool.ntp.org'],
+    'validation_seed': 'sh1T8T9yGuV7Jb6DPhqSzdU2s5LcV',
+    'node_size': 'medium',
+    'rpc_startup': {
+        'command': 'log_level',
+        'severity': 'debug'},
+    'ips': ['r.ripple.com', '51235'],
+    'node_db': {
+        'file_size_mult': '2',
+        'file_size_mb': '8',
+        'cache_mb': '256',
+        'path': '/development/alpha/db/rocksdb',
+        'open_files': '2000',
+        'type': 'RocksDB',
+        'filter_bits': '12'},
+    'peer_port': '53235',
+    'ledger_history': 'full',
+    'rpc_ip': '127.0.0.1',
+    'websocket_public_ip': '0.0.0.0',
+    'rpc_allow_remote': '0',
+    'validators':
+         [['n949f75evCHwgyP4fPVgaHqNHxUVN15PsJEZ3B3HnXPcPjcZAoy7', 'RL1'],
+          ['n9MD5h24qrQqiyBC8aeqqCWvpiBiYQ3jxSr91uiDvmrkyHRdYLUj', 'RL2'],
+          ['n9L81uNCaPgtUJfaHh89gmdvXKAmSt5Gdsw2g1iPWaPkAHW5Nm4C', 'RL3'],
+          ['n9KiYM9CgngLvtRCQHZwgC2gjpdaZcCcbt3VboxiNFcKuwFVujzS', 'RL4'],
+          ['n9LdgEtkmGB9E2h3K4Vp7iGUaKuq23Zr32ehxiU8FWY7xoxbWTSA', 'RL5']],
+    'debug_logfile': '/development/alpha/debug.log',
+    'websocket_public_port': '5206',
+    'peer_ip': '0.0.0.0',
+    'rpc_port': '5205',
+    'validation_quorum': '3',
+    'websocket_ip': '127.0.0.1'}
+
+FULL = """
+[ledger_history]
+full
+
+# Allow other peers to connect to this server.
+#
+[peer_ip]
+0.0.0.0
+
+[peer_port]
+53235
+
+# Allow untrusted clients to connect to this server.
+#
+[websocket_public_ip]
+0.0.0.0
+
+[websocket_public_port]
+5206
+
+# Provide trusted websocket ADMIN access to the localhost.
+#
+[websocket_ip]
+127.0.0.1
+
+[websocket_port]
+6206
+
+# Provide trusted json-rpc ADMIN access to the localhost.
+#
+[rpc_ip]
+127.0.0.1
+
+[rpc_port]
+5205
+
+[rpc_allow_remote]
+0
+
+[node_size]
+medium
+
+# This is primary persistent datastore for rippled.  This includes transaction
+# metadata, account states, and ledger headers.  Helpful information can be
+# found here: https://ripple.com/wiki/NodeBackEnd
+[node_db]
+type=RocksDB
+path=/development/alpha/db/rocksdb
+open_files=2000
+filter_bits=12
+cache_mb=256
+file_size_mb=8
+file_size_mult=2
+
+[database_path]
+/development/alpha/db
+
+# This needs to be an absolute directory reference, not a relative one.
+# Modify this value as required.
+[debug_logfile]
+/development/alpha/debug.log
+
+[sntp_servers]
+time.windows.com
+time.apple.com
+time.nist.gov
+pool.ntp.org
+
+# Where to find some other servers speaking the Ripple protocol.
+#
+[ips]
+r.ripple.com 51235
+
+# The latest validators can be obtained from
+# https://ripple.com/ripple.txt
+#
+[validators]
+n949f75evCHwgyP4fPVgaHqNHxUVN15PsJEZ3B3HnXPcPjcZAoy7	RL1
+n9MD5h24qrQqiyBC8aeqqCWvpiBiYQ3jxSr91uiDvmrkyHRdYLUj	RL2
+n9L81uNCaPgtUJfaHh89gmdvXKAmSt5Gdsw2g1iPWaPkAHW5Nm4C	RL3
+n9KiYM9CgngLvtRCQHZwgC2gjpdaZcCcbt3VboxiNFcKuwFVujzS	RL4
+n9LdgEtkmGB9E2h3K4Vp7iGUaKuq23Zr32ehxiU8FWY7xoxbWTSA	RL5
+
+# Ditto.
+[validation_quorum]
+3
+
+[validation_seed]
+sh1T8T9yGuV7Jb6DPhqSzdU2s5LcV
+
+# Turn down default logging to save disk space in the long run.
+# Valid values here are trace, debug, info, warning, error, and fatal
+[rpc_startup]
+{ "command": "log_level", "severity": "debug" }
+
+# Configure SSL for WebSockets.  Not enabled by default because not everybody
+# has an SSL cert on their server, but if you uncomment the following lines and
+# set the path to the SSL certificate and private key the WebSockets protocol
+# will be protected by SSL/TLS.
+#[websocket_secure]
+#1
+
+#[websocket_ssl_cert]
+#/etc/ssl/certs/server.crt
+
+#[websocket_ssl_key]
+#/etc/ssl/private/server.key
+
+# Defaults to 0 ("no") so that you can use self-signed SSL certificates for
+# development, or internally.
+#[ssl_verify]
+#0
+""".strip()

bin/ripple/util/test_PrettyPrint.py

@@ -0,0 +1,56 @@
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+from ripple.util import PrettyPrint
+
+from unittest import TestCase
+
+class test_PrettyPrint(TestCase):
+    def setUp(self):
+        self._results = []
+        self.printer = PrettyPrint.Streamer(printer=self.printer)
+
+    def printer(self, *args, **kwds):
+        self._results.extend(args)
+
+    def run_test(self, expected, *args):
+        for i in range(0, len(args), 2):
+            self.printer.add(args[i], args[i + 1])
+        self.printer.finish()
+        self.assertEquals(''.join(self._results), expected)
+
+    def test_simple_printer(self):
+        self.run_test(
+            '{\n    "foo": "bar"\n}',
+            'foo', 'bar')
+
+    def test_multiple_lines(self):
+        self.run_test(
+            '{\n    "foo": "bar",\n    "baz": 5\n}',
+            'foo', 'bar', 'baz', 5)
+
+    def test_multiple_lines(self):
+        self.run_test(
+            """
+{
+    "foo": {
+        "bar": 1,
+        "baz": true
+    },
+    "bang": "bing"
+}
+        """.strip(), 'foo', {'bar': 1, 'baz': True}, 'bang', 'bing')
+
+    def test_multiple_lines_with_list(self):
+        self.run_test(
+            """
+{
+    "foo": [
+        "bar",
+        1
+    ],
+    "baz": [
+        23,
+        42
+    ]
+}
+        """.strip(), 'foo', ['bar', 1], 'baz', [23, 42])

bin/stop-test.js

@@ -0,0 +1,133 @@
+/* -------------------------------- REQUIRES -------------------------------- */
+
+var child = require("child_process");
+var assert = require("assert");
+
+/* --------------------------------- CONFIG --------------------------------- */
+
+if (process.argv[2] == null) {
+  [
+   'Usage: ',
+   '',
+   '  `node bin/stop-test.js i,j [rippled_path] [rippled_conf]`',
+   '',
+   '  Launch rippled and stop it after n seconds for all n in [i, j}',
+   '  For all even values of n launch rippled with `--fg`',
+   '  For values of n where n % 3 == 0 launch rippled with `--fg`\n',
+   'Examples: ',
+   '',
+   '  $ node bin/stop-test.js 5,10',
+   ('  $ node bin/stop-test.js 1,4 ' +
+      'build/clang.debug/rippled $HOME/.confs/rippled.cfg')
+   ]
+      .forEach(function(l){console.log(l)});
+
+  process.exit();
+} else {
+  var testRange = process.argv[2].split(',').map(Number);
+  var rippledPath = process.argv[3] || 'build/rippled'
+  var rippledConf = process.argv[4] || 'rippled.cfg'
+}
+
+var options = {
+  env: process.env,
+  stdio: 'ignore' // we could dump the child io when it fails abnormally
+};
+
+// default args
+var conf_args = ['--conf='+rippledConf];
+var start_args  = conf_args.concat([/*'--net'*/])
+var stop_args = conf_args.concat(['stop']);
+
+/* --------------------------------- HELPERS -------------------------------- */
+
+function start(args) {
+    return child.spawn(rippledPath, args, options);
+}
+function stop(rippled) { child.execFile(rippledPath, stop_args, options)}
+function secs_l8r(ms, f) {setTimeout(f, ms * 1000); }
+
+function show_results_and_exit(results) {
+  console.log(JSON.stringify(results, undefined, 2));
+  process.exit();
+}
+
+var timeTakes = function (range) {
+  function sumRange(n) {return (n+1) * n /2}
+  var ret = sumRange(range[1]);
+  if (range[0] > 1) {
+    ret = ret - sumRange(range[0] - 1)
+  }
+  var stopping = (range[1] - range[0]) * 0.5;
+  return ret + stopping;
+}
+
+/* ---------------------------------- TEST ---------------------------------- */
+
+console.log("Test will take ~%s seconds", timeTakes(testRange));
+
+(function oneTest(n /* seconds */, results) {
+  if (n >= testRange[1]) {
+    // show_results_and_exit(results);
+    console.log(JSON.stringify(results, undefined, 2));
+    oneTest(testRange[0], []);
+    return;
+  }
+
+  var args = start_args;
+  if (n % 2 == 0) {args = args.concat(['--fg'])}
+  if (n % 3 == 0) {args = args.concat(['--net'])}
+
+  var result = {args: args, alive_for: n};
+  results.push(result);
+
+  console.log("\nLaunching `%s` with `%s` for %d seconds",
+                rippledPath, JSON.stringify(args), n);
+
+  rippled = start(args);
+  console.log("Rippled pid: %d", rippled.pid);
+
+  // defaults
+  var b4StopSent = false;
+  var stopSent = false;
+  var stop_took = null;
+
+  rippled.once('exit', function(){
+    if (!stopSent && !b4StopSent) {
+      console.warn('\nRippled exited itself b4 stop issued');
+      process.exit();
+    };
+
+    // The io handles close AFTER exit, may have implications for
+    // `stdio:'inherit'` option to `child.spawn`.
+    rippled.once('close', function() {
+      result.stop_took = (+new Date() - stop_took) / 1000; // seconds
+      console.log("Stopping after %d seconds took %s seconds",
+                   n, result.stop_took);
+      oneTest(n+1, results);
+    });
+  });
+
+  secs_l8r(n, function(){
+    console.log("Stopping rippled after %d seconds", n);
+
+    // possible race here ?
+    // seems highly unlikely, but I was having issues at one point
+    b4StopSent=true;
+    stop_took = (+new Date());
+    // when does `exit` actually get sent?
+    stop();
+    stopSent=true;
+
+    // Sometimes we want to attach with a debugger.
+    if (process.env.ABORT_TESTS_ON_STALL != null) {
+      // We wait 30 seconds, and if it hasn't stopped, we abort the process
+      secs_l8r(30, function() {
+        if (result.stop_took == null) {
+          console.log("rippled has stalled");
+          process.exit();
+        };
+      });
+    }
+  })
+}(testRange[0], []));

circle.yml

@@ -0,0 +1,52 @@
+machine:
+  services:
+    - docker
+dependencies:
+  pre:
+    - sudo apt-add-repository -y 'deb http://llvm.org/apt/precise/ llvm-toolchain-precise-3.4 main'
+    - sudo apt-add-repository -y ppa:ubuntu-toolchain-r/test
+    - sudo add-apt-repository -y ppa:afrank/boost
+    - wget -q -O - http://llvm.org/apt/llvm-snapshot.gpg.key | sudo apt-key add -
+    - sudo apt-get update -qq
+    - sudo apt-get purge -qq libboost1.48-dev
+    - sudo apt-get install -qq libboost1.57-all-dev
+    - sudo apt-get install -qq clang-3.4 gcc-4.8 libobjc-4.8-dev libgcc-4.8-dev libstdc++-4.8-dev libclang1-3.4 libgcc1 libgomp1 libstdc++6 scons protobuf-compiler libprotobuf-dev libssl-dev exuberant-ctags
+    - sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-4.8 99 --slave /usr/bin/g++ g++ /usr/bin/g++-4.8
+    - sudo update-alternatives --install /usr/bin/clang clang /usr/bin/clang-3.4 99 --slave /usr/bin/clang++ clang++ /usr/bin/clang++-3.4
+    - gcc --version
+    - clang --version
+test:
+  pre:
+    - scons clang.debug
+  override:
+    - | # create gdb script
+      echo "set env MALLOC_CHECK_=3" > script.gdb 
+      echo "run" >> script.gdb
+      echo "backtrace full" >> script.gdb 
+      # gdb --help
+    - cat script.gdb | gdb --ex 'set print thread-events off' --return-child-result --args build/clang.debug/rippled --unittest
+    - npm install
+    # Use build/(gcc|clang).debug/rippled
+    - |
+      echo "exports.default_server_config = {\"rippled_path\" : \"$HOME/rippled/build/clang.debug/rippled\"};" > test/config.js
+
+    # Run integration tests
+    - npm test
+  post:
+    - mkdir -p build/docker/
+    - cp doc/rippled-example.cfg build/clang.debug/rippled build/docker/
+    - cp Builds/Docker/Dockerfile-testnet build/docker/Dockerfile
+    - mv build/docker/rippled-example.cfg build/docker/rippled.cfg
+    - strip build/docker/rippled
+    - docker build -t ripple/rippled:$CIRCLE_SHA1 build/docker/
+    - docker tag ripple/rippled:$CIRCLE_SHA1 ripple/rippled:latest
+    - docker tag ripple/rippled:$CIRCLE_SHA1 ripple/rippled:$CIRCLE_BRANCH
+    - docker images
+deployment:
+  docker:
+    branch: /.*/
+    commands:
+      - docker login -e $DOCKER_EMAIL -u $DOCKER_USERNAME -p $DOCKER_PASSWORD
+      - docker push ripple/rippled:$CIRCLE_SHA1
+      - docker push ripple/rippled:$CIRCLE_BRANCH
+      - docker push ripple/rippled:latest

doc/CHANGELOG

@@ -1,19 +1,16 @@
-VFALCO NOTE - This file appears to be unmaintained.
+A list of rippled version numbers, and the Github pull requests they contain.
 
-Critical protocol changes
--------------------------
-
-Mon Apr  8 16:13:12 PDT 2013
-* The JSON field "inLedger" changing to "ledger_index"
-
-Previous
-* The JSON field "metaData" changing to "meta".
-* RPC ledger will no longer take "ledger", use "ledger_hash" or "ledger_index".
-* "ledgerClose" events:
-** "hash" DEPRECATED: use "ledger_hash"
-** "seqNum" DEPRECATED: use "ledger_index"
-** "closeTime" DEPRECATED: use "close" or "close_human"
-* stream "rt_accounts" --> "accounts_proposed"
-* stream "rt_transactions" --> "transactions_proposed"
-* subscribe "username" --> "url_username"
-* subscribe "password" --> "url_password"
+0.28.0-b12: Includes pulls 836, 887, 902, 903 and 904.
+0.28.0-b13: Includes pulls 906, 912, 913, 914 and 915.
+0.28.0-b14: Includes pulls 907, 910, 922 and 923.
+0.28.0-b15: Includes pulls 832, 870, 879, 883, 911, 916, 919, 920, 924, 925 and 928. FAILED pulls 909 and 926.
+0.28.0-b16: Includes pulls 909, 926, 929, 931, 932, 935 and 934.
+0.28.0-b17: Includes pulls 927, 939, 940, 943, 944, 945 and 949.
+0.28.0-b18: Includes pulls 930, 946, 947, 948, 951, 952, 953, 954, 955, 956, 959, 960 and 962.
+0.29.0-b19: Includes pulls 967, 969 and 971.
+0.29.0-b20: Includes pulls 935, 942, 957, 958, 963, 964, 965, 966, 968, 972, 973, 974 and 975.
+0.29.0-b21: Includes pulls 970 and 976.
+0.28.1-b4: Includes pulls 968, 998, 1005, 1008, 1010, 1011 and 1012.
+0.28.1-b6: Includes pulls 983, 984, 1013, 1023 and 1024.
+0.28.1-b8: Includes pulls 988, 1009, 1014, 1019, 1029, 1031, 1033, 1034 and 1035.
+0.28.1-b9: Includes pulls 1026, 1030, 1036, 1037, 1038, 1040, and 1041.

doc/Docker.md

@@ -0,0 +1,16 @@
+# Rippled Docker Image
+
+Rippled has a continuous deployment pipeline that turns every git commit into a
+docker image for quick testing and deployment.
+
+To run the tip of the latest release via docker:
+
+```$ docker run -P -v /srv/rippled/ ripple/rippled:latest```
+
+To run the tip of active development:
+
+```$ docker run -P -v /srv/rippled/ ripple/rippled:develop```
+
+Where ```/srv/rippled``` points to a directory containing a rippled.cfg and
+database files. By default, port 5005/tcp maps to the RPC port and 51235/udp to
+the peer port.

doc/rippled-example.cfg

@@ -6,21 +6,21 @@
 #
 # Contents
 #
-#   1. Peer Networking
+#   1. Server
 #
-#   2. Websocket Networking
+#   2. Peer Protocol
 #
-#   3. RPC Networking
+#   3. Ripple Protocol
 #
-#   4. SMS Gateway
+#   4. HTTPS Client
 #
-#   5. Ripple Protcol
+#   5. Database
 #
-#   6. HTTPS Client
+#   6. Diagnostics
 #
-#   7. Database
+#   7. Voting
 #
-#   8. Diagnostics
+#   8. Example Settings
 #
 #-------------------------------------------------------------------------------
 #
@@ -42,19 +42,234 @@
 #   or Mac style end of lines.  Blank lines and lines beginning with '#' are
 #   ignored. Undefined sections are reserved. No escapes are currently defined.
 #
+# Notation
+#
+#   In this document a simple BNF notation is used. Angle brackets denote
+#   required elements, square brackets denote optional elements, and single
+#   quotes indicate string literals. A vertical bar separating 1 or more
+#   elements is a logical "or"; Any one of the elements may be chosen.
+#   Parenthesis are notational only, and used to group elements, they are not
+#   part of the syntax unless they appear in quotes. White space may always
+#   appear between elements, it has no effect on values.
+#
+#       <key>       A required identifier
+#       '='         The equals sign character
+#       |           Logical "or"
+#       ( )         Used for grouping
+#
+#
+#   An identifier is a string of upper or lower case letters, digits, or
+#   underscores subject to the requirement that the first character of an
+#   identifier must be a letter. Identifiers are not case sensitive (but
+#   values may be).
+#
+#   Some configuration sections contain key/value pairs. A line containing
+#   a key/value pair has this syntax:
+#
+#       <identifier> '=' <value>
+#
+#   Depending on the section and key, different value types are possible:
+#
+#       <integer>   A signed integer
+#       <unsigned>  An unsigned integer
+#       <flag>      A boolean. 1 = true/yes/on, 0 = false/no/off.
+#
+#   Consult the documentation on the key in question to determine the possible
+#   value types.
+#
 #
 #
 #-------------------------------------------------------------------------------
 #
-# 1. Peer Networking
+# 1. Server
 #
-#-------------------
+#----------
+#
+#
+#
+#   rippled offers various server protocols to clients making inbound
+#   connections. The listening ports rippled uses are "universal" ports
+#   which may be configured to handshake in one or more of the available
+#   supported protocols. These universal ports simplify administration:
+#   A single open port can be used for multiple protocols.
+#
+#   NOTE    At least one server port must be defined in order
+#           to accept incoming network connections.
+#
+#
+# [server]
+#
+#   A list of port names and key/value pairs. A port name must start with a
+#   letter and contain only letters and numbers. The name is not case-sensitive.
+#   For each name in this list, rippled will look for a configuration file
+#   section with the same name and use it to create a listening port. The
+#   name is informational only; the choice of name does not affect the function
+#   of the listening port.
+#
+#   Key/value pairs specified in this section are optional, and apply to all
+#   listening ports unless the port overrides the value in its section. They
+#   may be considered default values.
+#
+#   Suggestion:
+#
+#       To avoid a conflict with port names and future configuration sections,
+#       we recommend prepending "port_" to the port name. This prefix is not
+#       required, but suggested.
+#
+#   This example defines two ports with different port numbers and settings:
+#
+#       [server]
+#       port_public
+#       port_private
+#       port = 80
+#
+#       [port_public]
+#       ip=0.0.0.0
+#       port = 443
+#       protocol=peer,https
+#
+#       [port_private]
+#       ip=127.0.0.1
+#       protocol=http
+#
+#   When rippled is used as a command line client (for example, issuing a
+#   server stop command), the first port advertising the http or https 
+#   protocol will be used to make the connection.
+#
+#
+#
+# [<name>]
+#
+#   A series of key/value pairs that define the settings for the port with
+#   the corresponding name. These keys are possible:
+#
+#   ip = <IP-address>
+#
+#       Required. Determines the IP address of the network interface to bind
+#       to. To bind to all available interfaces, uses 0.0.0.0
+#
+#   port = <number>
+#
+#       Required. Sets the port number to use for this port.
+#
+#   protocol = [ http, https, peer ]
+#
+#       Required. A comma-separated list of protocols to support:
+#
+#       http        JSON-RPC over HTTP
+#       https       JSON-RPC over HTTPS
+#       ws          Websockets
+#       wss         Secure Websockets
+#       peer        Peer Protocol
+#
+#       Restrictions:
+#   
+#       Only one port may be configured to support the peer protocol.
+#       A port cannot have websocket and non websocket protocols at the
+#       same time. It is possible have both Websockets and Secure Websockets
+#       together in one port.
+#
+#       NOTE    If no ports support the peer protocol, rippled cannot
+#               receive incoming peer connections or become a superpeer.
+#
+#   user = <text>
+#   password = <text>
+#
+#       When set, these credentials will be required on HTTP/S requests.
+#       The credentials must be provided using HTTP's Basic Authentication
+#       headers. If either or both fields are empty, then no credentials are
+#       required. IP address restrictions, if any, will be checked in addition
+#       to the credentials specified here.
+#
+#       When acting in the client role, rippled will supply these credentials
+#       using HTTP's Basic Authentication headers when making outbound HTTP/S
+#       requests.
+#
+#   admin = [ IP, IP, IP, ... ]
+#
+#       A comma-separated list of IP addresses.
+#
+#       When set, grants administrative command access to the specified IP
+#       addresses. These commands may be issued over http, https, ws, or wss
+#       if configured on the port. If unspecified, the default is to not allow
+#       administrative commands.
+#
+#       *SECURITY WARNING*
+#       0.0.0.0 may be specified to allow access from any IP address. It must
+#       be the only address specified and cannot be combined with other IPs.
+#       Use of this address can compromise server security, please consider its
+#       use carefully.
+#
+#   admin_user = <text>
+#   admin_password = <text>
+#
+#       When set, clients must provide these credentials in the submitted
+#       JSON for any administrative command requests submitted to the HTTP/S,
+#       WS, or WSS protocol interfaces. If administrative commands are
+#       disabled for a port, these credentials have no effect.
+#
+#       When acting in the client role, rippled will supply these credentials
+#       in the submitted JSON for any administrative command requests when
+#       invoking JSON-RPC commands on remote servers.
+#
+#   ssl_key = <filename>
+#   ssl_cert = <filename>
+#   ssl_chain = <filename>
+#
+#       Use the specified files when configuring SSL on the port.
+#
+#       NOTE    If no files are specified and secure protocols are selected,
+#               rippled will generate an internal self-signed certificate.
+#
+#       The files have these meanings:
+#
+#       ssl_key
+#
+#           Specifies the filename holding the SSL key in PEM format.
+#
+#       ssl_cert
+#
+#           Specifies the path to the SSL certificate file in PEM format.
+#           This is not needed if the chain includes it.
+#
+#       ssl_chain
+#
+#           If you need a certificate chain, specify the path to the
+#           certificate chain here. The chain may include the end certificate.
+#
+#
+#
+# [rpc_startup]
+#
+#   Specify a list of RPC commands to run at startup.
+#
+#   Examples:
+#     { "command" : "server_info" }
+#     { "command" : "log_level", "partition" : "ripplecalc", "severity" : "trace" }
+#
+#
+#
+# [websocket_ping_frequency]
+#
+#   <number>
+#
+#   The amount of time to wait in seconds, before sending a websocket 'ping'
+#   message. Ping messages are used to determine if the remote end of the
+#   connection is no longer available.
+#   
+#
+#
+#-------------------------------------------------------------------------------
+#
+# 2. Peer Protocol
+#
+#-----------------
 #
 #   These settings control security and access attributes of the Peer to Peer
-#   server section of the rippled process. Peer Networking implements the
+#   server section of the rippled process. Peer Protocol implements the
 #   Ripple Payment protocol. It is over peer connections that transactions
-#   and validations are passed from to machine to machine, to make up the
-#   components of closed ledgers.
+#   and validations are passed from to machine to machine, to determine the
+#   contents of validated ledgers.
 #
 #
 #
@@ -93,40 +308,6 @@
 #
 #
 #
-# [peer_ip]
-#
-#   IP address or domain to bind to allow external connections from peers.
-#   Defaults to not binding, which disallows external connections from peers.
-#
-#   Examples: 0.0.0.0 - Bind on all interfaces.
-#
-#
-#
-# [peer_port]
-#
-#   If peer_ip is supplied, corresponding port to bind to for peer connections.
-#
-#
-#
-# [peer_port_proxy]
-#
-#   An optional, additional listening port number for peers. Incoming
-#   connections on this port will be required to provide a PROXY Protocol
-#   handshake, described in this document (external link):
-#
-#       http://haproxy.1wt.eu/download/1.5/doc/proxy-protocol.txt
-# 
-#   The PROXY Protocol is a popular method used by elastic load balancing
-#   service providers such as Amazon, to identify the true IP address and
-#   port number of external incoming connections.
-#
-#   In addition to enabling this setting, it will also be required to
-#   use your provider-specific control panel or administrative web page
-#   to configure your server instance to receive PROXY Protocol handshakes,
-#   and also to restrict access to your instance to the Elastic Load Balancer.
-#
-#
-#
 # [peer_private]
 #
 #   0 or 1.
@@ -145,19 +326,6 @@
 #
 #
 #
-# [peer_ssl_cipher_list]
-#
-#   A colon delimited string with the allowed SSL cipher modes for peer. The
-#   choices for for ciphers are defined by the OpenSSL API function
-#   SSL_CTX_set_cipher_list, documented here (external link):
-#
-#   http://pic.dhe.ibm.com/infocenter/tpfhelp/current/index.jsp?topic=%2Fcom.ibm.ztpf-ztpfdf.doc_put.cur%2Fgtpc2%2Fcpp_ssl_ctx_set_cipher_list.html
-#
-#   The default setting is "ALL:!LOW:!EXP:!MD5:@STRENGTH", which allows
-#   non-authenticated peer connections (they are, however, secure).
-#
-#
-#
 # [node_seed]
 #
 #   This is used for clustering. To force a particular node seed or key, the
@@ -191,283 +359,45 @@
 #
 #
 #
-#-------------------------------------------------------------------------------
+# [overlay] EXPERIMENTAL
 #
-# 2. Websocket Networking
+#   This section is EXPERIMENTAL, and should not be
+#   present for production configuration settings.
 #
-#------------------------
+#   A set of key/value pair parameters to configure the overlay.
 #
-#   These settings control security and access attributes of the Websocket
-#   server section of the rippled process, primarily used to service
-#   client requests and backend applications.
+#   auto_connect = 0 | 1
 #
+#       When set, activates the autoconnect feature. This maintains outgoing
+#       connections using PeerFinder's "Outgoing Connection Strategy."
 #
+#   become_superpeer = 'never' | 'always' | 'auto'
 #
-# [websocket_public_ip]
+#       Controls the selection of peer roles:
 #
-#   IP address or domain to bind to allow untrusted connections from clients.
-#   In the future, this option will go away and the peer_ip will accept
-#   websocket client connections.
+#       'never'   Always handshake in the leaf role.
+#       'always'  Always handshake in the superpeer role.
+#       'auto'    Start as a leaf, promote to superpeer after
+#                 passing capability check (default).
 #
-#   Examples: 0.0.0.0 - Bind on all interfaces.
-#             127.0.0.1 - Bind on localhost interface.  Only local programs may connect.
+#       In the leaf role, a peer does not advertise its IP and port for
+#       the purpose of receiving incoming connections. The peer also does
+#       not forward transactions and validations received from other peers.
 #
-#
-#
-# [websocket_public_port]
-#
-#   Port to bind to allow untrusted connections from clients.  In the future,
-#   this option will go away and the peer_ip will accept websocket client
-#   connections.
-#
-#
-#
-# [websocket_public_secure]
-#
-#   0, 1 or 2.
-#   0: Provide ws service for websocket_public_ip/websocket_public_port.
-#   1: Provide both ws and wss service for websocket_public_ip/websocket_public_port. [default]
-#   2: Provide wss service only for websocket_public_ip/websocket_public_port.
-#
-#   Browser pages like the Ripple client will not be able to connect to a secure
-#   websocket connection if a self-signed certificate is used.  As the Ripple
-#   reference client currently shares secrets with its server, this should be
-#   enabled.
-#
-#
-#
-# [websocket_ping_frequency]
-#
-#   <number>
-#
-#   The amount of time to wait in seconds, before sending a websocket 'ping'
-#   message. Ping messages are used to determine if the remote end of the
-#   connection is no longer available.
-#   
-#
-#
-# [websocket_ip]
-#
-#   IP address or domain to bind to allow trusted ADMIN connections from backend
-#   applications.
-#
-#   Examples: 0.0.0.0 - Bind on all interfaces.
-#             127.0.0.1 - Bind on localhost interface.  Only local programs may connect.
-#
-#
-#
-# [websocket_port]
-#
-#   Port to bind to allow trusted ADMIN connections from backend applications.
-#
-#
-#
-# [websocket_secure]
-#
-#   0, 1, or 2.
-#   0: Provide ws service only for websocket_ip/websocket_port. [default]
-#   1: Provide ws and wss service for websocket_ip/websocket_port
-#   2: Provide wss service for websocket_ip/websocket_port.
-#
-#
-#
-# [websocket_ssl_cert]
-#
-#   Specify the path to the SSL certificate file in PEM format.
-#   This is not needed if the chain includes it.
-#
-#
-#
-# [websocket_ssl_chain]
-#
-#   If you need a certificate chain, specify the path to the certificate chain
-#   here.  The chain may include the end certificate.
-#
-#
-#
-# [websocket_ssl_key]
-#
-#   Specify the filename holding the SSL key in PEM format.
+#       In the superpeer role, a peer advertises its IP and port for
+#       receiving incoming connections after passing an incoming connection
+#       test. Superpeers forward transactions and protocol messages to all
+#       other peers. Superpeers do not forward validations to other superpeers.
+#       Instead, a validation received by a superpeer from a leaf is forwarded
+#       only to other leaf connections.
 #
 #
 #
 #-------------------------------------------------------------------------------
 #
-# 3. RPC Networking
+# 3. Ripple Protocol
 #
-#------------------
-#
-#   This group of settings configures security and access attributes of the
-#   RPC server section of the rippled process, used to service both local
-#   and optional remote clients.
-#
-#
-#
-# [rpc_allow_remote]
-#
-#   0 or 1.
-#
-#   0: Allow RPC connections only from 127.0.0.1. [default]
-#   1: Allow RPC connections from any IP.
-#
-#
-#
-# [rpc_admin_allow]
-#
-#   Specify a list of IP addresses allowed to have admin access. One per line.
-#   If you want to test the output of non-admin commands add this section and
-#   just put an ip address not under your control.
-#   Defaults to 127.0.0.1.
-#
-#
-#
-# [rpc_admin_user]
-#
-#   As a server, require this as the admin user to be specified.  Also, require
-#   rpc_admin_user and rpc_admin_password to be checked for RPC admin functions.
-#   The request must specify these as the admin_user and admin_password in the
-#   request object.
-#
-#   As a client, supply this to the server in the request object.
-#
-#
-#
-# [rpc_admin_password]
-#
-#   As a server, require this as the admin password to be specified.  Also,
-#   require rpc_admin_user and rpc_admin_password to be checked for RPC admin
-#   functions.  The request must specify these as the admin_user and
-#   admin_password in the request object.
-#
-#   As a client, supply this to the server in the request object.
-#
-#
-#
-# [rpc_ip]
-#
-#   IP address or domain to bind to allow insecure RPC connections.
-#   Defaults to not binding, which disallows RPC connections.
-#
-#
-#
-# [rpc_port]
-#
-#   If rpc_ip is supplied, corresponding port to bind to for peer connections.
-#
-#
-#
-# [rpc_user]
-#
-#   As a server, require this user to be specified and require rpc_password to
-#   be checked for RPC access via the rpc_ip and rpc_port. The user and password
-#   must be specified via HTTP's basic authentication method.
-#   As a client, supply this to the server via HTTP's basic authentication
-#   method.
-#
-#
-#
-# [rpc_password]
-#
-#   As a server, require this password to be specified and require rpc_user to
-#   be checked for RPC access via the rpc_ip and rpc_port. The user and password
-#   must be specified via HTTP's basic authentication method.
-#   As a client, supply this to the server via HTTP's basic authentication
-#   method.
-#
-#
-#
-# [rpc_startup]
-#
-#   Specify a list of RPC commands to run at startup.
-#
-#   Examples:
-#     { "command" : "server_info" }
-#     { "command" : "log_level", "partition" : "ripplecalc", "severity" : "trace" }
-#
-#
-#
-# [rpc_secure]
-#
-#   0 or 1.
-#
-#   0: Server certificates are not provided for RPC clients using SSL [default]
-#   1: Client RPC connections wil be provided with SSL certificates.
-#
-#   Note that if rpc_secure is enabled, it will also be necessary to configure
-#   the certificate file settings located in rpc_ssl_cert, rpc_ssl_chain, and
-#   rpc_ssl_key
-#
-#
-#
-# [rpc_ssl_cert]
-#
-#   <pathname>
-#
-#   A file system path leading to the SSL certificate file to use for secure
-#   RPC.  The file is in PEM format. The file is not needed if the chain
-#   includes it.
-#
-#
-#
-# [rpc_ssl_chain]
-#
-#   <pathname>
-#
-#   A file system path leading to the file with the certificate chain.
-#   The chain may include the end certificate.
-#
-#
-#
-# [rpc_ssl_key]
-#
-#   <pathname>
-#
-#   A file system path leading to the file with the SSL key.
-#   The file is in PEM format.
-#
-#
-#
-#-------------------------------------------------------------------------------
-#
-# 4. SMS Gateway
-#
-#---------------
-#
-#   If you have a certain SMS messaging provider you can configure these
-#   settings to allow the rippled server instance to send an SMS text to the
-#   configured gateway in response to an admin-level RPC command "sms" with
-#   one parameter, 'text' containing the message to send. This allows backend
-#   applications to use the rippled instance to securely notify administrators
-#   of custom events or information via SMS gateway.
-#
-#   When the 'sms' RPC command is issued, the configured SMS gateway will be
-#   contacted via HTTPS GET at the URL indicated by sms_url. The URI formed
-#   will be in this format:
-#
-#     [sms_url]?from=[sms_from]&to=[sms_to]&api_key=[sms_key]&api_secret=[sms_secret]&text=['text']
-#
-#   Where [...] are the corresponding values from the configuration file, and
-#   ['test'] is the value of the JSON field with name 'text'.
-#
-# [sms_url]
-#
-#   The URL to contact via HTTPS when sending SMS messages
-#
-# [sms_from]
-# [sms_to]
-# [sms_key]
-# [sms_secret]
-#
-#   These are all strings passed directly in the URI as query parameters
-#   to the provider of the SMS gateway.
-#
-#
-#
-#-------------------------------------------------------------------------------
-#
-# 5. Ripple Protocol
-#
-#------------------
+#-------------------
 #
 #   These settings affect the behavior of the server instance with respect
 #   to Ripple payment protocol level activities such as validating and
@@ -502,6 +432,8 @@
 #   need to serve clients can set this to "none".  Servers that want complete
 #   history can set this to "full".
 #
+#   This must be less than or equal to online_delete (if online_delete is used)
+#
 #   The default is: 256
 #
 #
@@ -596,27 +528,36 @@
 # [path_search_old]
 #
 #   For clients that use the legacy path finding interfaces, the search
-#   agressivness to use. The default is 7.
+#   aggressiveness to use. The default is 7.
+#
+#
+#
+# [fee_default]
+#
+#   Sets the base cost of a transaction in drops. Used when the server has
+#   no other source of fee information, such as signing transactions offline.
 #
 #
 #
 #-------------------------------------------------------------------------------
 #
-# 6. HTTPS Client
+# 4. HTTPS Client
 #
 #----------------
 #
 #   The rippled server instance uses HTTPS GET requests in a variety of
-#   circumstances, including but not limited to the SMS Messaging Gateway
-#   feature and also for contacting trusted domains to fetch information
-#   such as mapping an email address to a Ripple Payment Network address.
+#   circumstances, including but not limited to contacting trusted domains to
+#   fetch information such as mapping an email address to a Ripple Payment
+#   Network address.
 #
 # [ssl_verify]
 #
 #   0 or 1.
 #
 #   0. HTTPS client connections will not verify certificates.
-#   1. Certificates will be checked for HTTPS client connections  .
+#   1. Certificates will be checked for HTTPS client connections.
+#   
+#   If not specified, this parameter defaults to 1.
 #
 #
 #
@@ -642,7 +583,7 @@
 #
 #-------------------------------------------------------------------------------
 #
-# 7. Database
+# 5. Database
 #
 #------------
 #
@@ -675,22 +616,27 @@
 #       ...
 #
 #   Examples:
-#       type=HyperLevelDB
-#       path=db/hyperldb
-#       compression=0
+#       type=rocksdb
+#       path=db/rocksdb
 #
 #   Choices for 'type' (not case-sensitive)
 #       RocksDB             Use Facebook's RocksDB database (preferred)
-#       HyperLevelDB        Use an improved version of LevelDB
-#       SQLite              Use SQLite
-#       LevelDB             Use Google's LevelDB database (deprecated)
-#       none                Use no backend
+#       NuDB                Use Ripple Labs' NuDB (Windows preferred)
+#       SQLite              (Deprecated)
+#       none                (No backend)
 #
 #   Required keys:
 #       path                Location to store the database (all types)
 #
 #   Optional keys:
 #       compression         0 for none, 1 for Snappy compression
+#       online_delete       Minimum value of 256. Enable automatic purging
+#                           of older ledger information. Maintain at least this
+#                           number of ledger records online. Must be greater
+#                           than or equal to ledger_history.
+#       advisory_delete     0 for disabled, 1 for enabled. If set, then
+#                           require administrative RPC call "can_delete"
+#                           to enable online deletion of ledger records.
 #
 #   Notes:
 #       The 'node_db' entry configures the primary, persistent storage.
@@ -709,13 +655,14 @@
 #   There are 4 book-keeping SQLite database that the server creates and
 #   maintains. If you omit this configuration setting, it will default to
 #   creating a directory called "db" located in the same place as your
-#   rippled.cfg file.
+#   rippled.cfg file. Partial pathnames will be considered relative to
+#   the location of the rippled executable.
 #
 #
 #
 #-------------------------------------------------------------------------------
 #
-# 8. Diagnostics
+# 6. Diagnostics
 #
 #---------------
 #
@@ -736,10 +683,10 @@
 #
 # [insight]
 #
-#   Configuration parameters for the Beast.Insight stats collection module.
+#   Configuration parameters for the Beast. Insight stats collection module.
 #
 #   Insight is a module that collects information from the areas of rippled
-#   that have instrumentation. The configuration paramters control where the
+#   that have instrumentation. The configuration parameters control where the
 #   collection metrics are sent. The parameters are expressed as key = value
 #   pairs with no white space. The main parameter is the choice of server:
 #
@@ -770,41 +717,135 @@
 #     prefix=my_validator
 #   
 #-------------------------------------------------------------------------------
-
-# Allow other peers to connect to this server.
 #
-[peer_ip]
-0.0.0.0
-
-[peer_port]
-51235
-
-# Allow untrusted clients to connect to this server.
+# 7. Voting
 #
-[websocket_public_ip]
-0.0.0.0
-
-[websocket_public_port]
-5006
-
-# Provide trusted websocket ADMIN access to the localhost.
+#----------
 #
-[websocket_ip]
-127.0.0.1
-
-[websocket_port]
-6006
-
-# Provide trusted json-rpc ADMIN access to the localhost.
+#   The vote settings configure settings for the entire Ripple network.
+#   While a single instance of rippled cannot unilaterally enforce network-wide
+#   settings, these choices become part of the instance's vote during the
+#   consensus process for each voting ledger.
 #
-[rpc_ip]
-127.0.0.1
+# [voting]
+#
+#   A set of key/value pair parameters used during voting ledgers.
+#
+#   reference_fee = <drops>
+#
+#       The cost of the reference transaction fee, specified in drops.
+#       The reference transaction is the simplest form of transaction.
+#       It represents an XRP payment between two parties.
+#
+#       If this parameter is unspecified, rippled will use an internal
+#       default. Don't change this without understanding the consequences.
+#
+#       Example:
+#           reference_fee = 10           # 10 drops
+#       
+#   account_reserve = <drops>
+#
+#       The account reserve requirement is specified in drops. The portion of an
+#       account's XRP balance that is at or below the reserve may only be
+#       spent on transaction fees, and not transferred out of the account.
+#
+#       If this parameter is unspecified, rippled will use an internal
+#       default. Don't change this without understanding the consequences.
+#
+#       Example:
+#           account_reserve = 20000000   # 20 XRP
+#
+#   owner_reserve = <drops>
+#
+#       The owner reserve is the amount of XRP reserved in the account for
+#       each ledger item owned by the account. Ledger items an account may
+#       own include trust lines, open orders, and tickets.
+#
+#       If this parameter is unspecified, rippled will use an internal
+#       default. Don't change this without understanding the consequences.
+#
+#       Example:
+#           owner_reserve = 5000000      # 5 XRP
+#
+#-------------------------------------------------------------------------------
+#
+# 8. Example Settings
+#
+#--------------------
+#
+#   Administrators can use these values as a starting point for configuring
+#   their instance of rippled, but each value should be checked to make sure
+#   it meets the business requirements for the organization.
+#
+# Server
+#
+#   These example configuration settings create these ports:
+#
+#   "peer"
+#
+#       Peer protocol open to everyone. This is required to accept
+#       incoming rippled connections. This does not affect automatic
+#       or manual outgoing Peer protocol connections.
+#
+#   "rpc"
+#
+#       Administrative RPC commands over HTTPS, when originating from
+#       the same machine (via the loopback adapter at 127.0.0.1).
+#
+#   "wss_admin"
+#
+#       Admin level API commands over Secure Websockets, when originating
+#       from the same machine (via the loopback adapter at 127.0.0.1).
+#
+#   This port is commented out but can be enabled by removing
+#   the '#' from each corresponding line including the entry under [server]
+#
+#   "wss_public"
+#
+#       Guest level API commands over Secure Websockets, open to everyone.
+#   
+#   For HTTPS and Secure Websockets ports, if no certificate and key file
+#   are specified then a self-signed certificate will be generated on startup.
+#   If you have a certificate and key file, uncomment the corresponding lines
+#   and ensure the paths to the files are correct.
+#
+#   NOTE
+#
+#       To accept connections on well known ports such as 80 (HTTP) or
+#       443 (HTTPS), most operating systems will require rippled to
+#       run with administrator privileges, or else rippled will not start.
 
-[rpc_port]
-5005
+[server]
+port_rpc
+port_peer
+port_wss_admin
+#port_ws_public
+#ssl_key = /etc/ssl/private/server.key
+#ssl_cert = /etc/ssl/certs/server.crt
 
-[rpc_allow_remote]
-0
+[port_rpc]
+port = 5005
+ip = 127.0.0.1
+admin = 127.0.0.1
+protocol = https
+
+[port_peer]
+port = 51235
+ip = 0.0.0.0
+protocol = peer
+
+[port_wss_admin]
+port = 6006
+ip = 127.0.0.1
+admin = 127.0.0.1
+protocol = wss
+
+#[port_ws_public]
+#port = 5005
+#ip = 127.0.0.1
+#protocol = wss
+
+#-------------------------------------------------------------------------------
 
 [node_size]
 medium
@@ -812,6 +853,8 @@ medium
 # This is primary persistent datastore for rippled.  This includes transaction
 # metadata, account states, and ledger headers.  Helpful information can be
 # found here: https://ripple.com/wiki/NodeBackEnd
+# delete old ledgers while maintaining at least 2000. Do not require an
+# external administrative command to initiate deletion.
 [node_db]
 type=RocksDB
 path=/var/lib/rippled/db/rocksdb
@@ -820,6 +863,8 @@ filter_bits=12
 cache_mb=256
 file_size_mb=8
 file_size_mult=2
+online_delete=2000
+advisory_delete=0
 
 [database_path]
 /var/lib/rippled/db
@@ -844,11 +889,11 @@ r.ripple.com 51235
 # https://ripple.com/ripple.txt
 #
 [validators]
-n949f75evCHwgyP4fPVgaHqNHxUVN15PsJEZ3B3HnXPcPjcZAoy7	RL1
-n9MD5h24qrQqiyBC8aeqqCWvpiBiYQ3jxSr91uiDvmrkyHRdYLUj	RL2
-n9L81uNCaPgtUJfaHh89gmdvXKAmSt5Gdsw2g1iPWaPkAHW5Nm4C	RL3
-n9KiYM9CgngLvtRCQHZwgC2gjpdaZcCcbt3VboxiNFcKuwFVujzS	RL4
-n9LdgEtkmGB9E2h3K4Vp7iGUaKuq23Zr32ehxiU8FWY7xoxbWTSA	RL5
+n949f75evCHwgyP4fPVgaHqNHxUVN15PsJEZ3B3HnXPcPjcZAoy7    RL1
+n9MD5h24qrQqiyBC8aeqqCWvpiBiYQ3jxSr91uiDvmrkyHRdYLUj    RL2
+n9L81uNCaPgtUJfaHh89gmdvXKAmSt5Gdsw2g1iPWaPkAHW5Nm4C    RL3
+n9KiYM9CgngLvtRCQHZwgC2gjpdaZcCcbt3VboxiNFcKuwFVujzS    RL4
+n9LdgEtkmGB9E2h3K4Vp7iGUaKuq23Zr32ehxiU8FWY7xoxbWTSA    RL5
 
 # Ditto.
 [validation_quorum]
@@ -859,22 +904,7 @@ n9LdgEtkmGB9E2h3K4Vp7iGUaKuq23Zr32ehxiU8FWY7xoxbWTSA	RL5
 [rpc_startup]
 { "command": "log_level", "severity": "warning" }
 
-# Configure SSL for WebSockets.  Not enabled by default because not everybody
-# has an SSL cert on their server, but if you uncomment the following lines and
-# set the path to the SSL certificate and private key the WebSockets protocol
-# will be protected by SSL/TLS.
-#[websocket_secure]
-#1
-
-#[websocket_ssl_cert]
-#/etc/ssl/certs/server.crt
-
-#[websocket_ssl_key]
-#/etc/ssl/private/server.key
-
-# Defaults to 0 ("no") so that you can use self-signed SSL certificates for
-# development, or internally.
+# Defaults to 1 ("yes") so that certificates will be validated. To allow the use
+# of self-signed certificates for development or internal use, set to 0 ("no").
 #[ssl_verify]
 #0
-
-

package.json

@@ -2,33 +2,30 @@
   "name": "rippled",
   "version": "0.0.1",
   "description": "Rippled Server",
-
   "private": true,
-
   "directories": {
     "test": "test"
   },
-
   "dependencies": {
-    "ripple-lib": "0.7.37",
     "async": "~0.2.9",
+    "deep-equal": "0.0.0",
     "extend": "~1.2.0",
-    "simple-jsonrpc": "~0.0.2",
-    "deep-equal": "0.0.0"
+    "lodash": "^3.5.0",
+    "request": "^2.47.0",
+    "ripple-lib": "0.10.0",
+    "simple-jsonrpc": "~0.0.2"
   },
   "devDependencies": {
-    "coffee-script": "~1.6.3",
-    "mocha": "~1.13.0"
+    "assert-diff": "^1.0.1",
+    "coffee-script": "^1.8.0",
+    "mocha": "^2.1.0"
   },
-
   "scripts": {
     "test": "mocha test/websocket-test.js test/server-test.js test/*-test.{js,coffee}"
   },
-
   "repository": {
     "type": "git",
     "url": "git://github.com/ripple/rippled.git"
   },
-
   "readmeFilename": "README.md"
 }

src/BeastConfig.h

@@ -57,38 +57,13 @@
 //#define BEAST_FORCE_DEBUG 1
 #endif
 
-/** Config: BEAST_LOG_ASSERTIONS
-    If this flag is enabled, the the bassert and bassertfalse macros will always
-    use Logger::writeToLog() to write a message when an assertion happens.
-    Enabling it will also leave this turned on in release builds. When it's
-    disabled, however, the bassert and bassertfalse macros will not be compiled
-    in a release build.
-    @see bassert, bassertfalse, Logger
-*/
-#ifndef   BEAST_LOG_ASSERTIONS
-//#define BEAST_LOG_ASSERTIONS 1
-#endif
-
 /** Config: BEAST_CHECK_MEMORY_LEAKS
     Enables a memory-leak check for certain objects when the app terminates.
-    See the LeakChecked class for more details about enabling leak checking for
-    specific classes.
 */
 #ifndef   BEAST_CHECK_MEMORY_LEAKS
 //#define BEAST_CHECK_MEMORY_LEAKS 0
 #endif
 
-/** Config: BEAST_COMPILER_CHECKS_SOCKET_OVERRIDES
-    Setting this option makes Socket-derived classes generate compile errors
-    if they forget any of the virtual overrides As some Socket-derived classes
-    intentionally omit member functions that are not applicable, this macro
-    should only be enabled temporarily when writing your own Socket-derived
-    class, to make sure that the function signatures match as expected.
-*/
-#ifndef   BEAST_COMPILER_CHECKS_SOCKET_OVERRIDES
-//#define BEAST_COMPILER_CHECKS_SOCKET_OVERRIDES 1
-#endif
-
 //------------------------------------------------------------------------------
 //
 // Libraries
@@ -205,13 +180,6 @@
 #define RIPPLE_PROPOSE_AMENDMENTS 0
 #endif
 
-/** Config: RIPPLE_ENABLE_AUTOBRIDGING
-    This determines whether ripple implements offer autobridging via XRP.
-*/
-#ifndef RIPPLE_ENABLE_AUTOBRIDGING
-#define RIPPLE_ENABLE_AUTOBRIDGING 0
-#endif
-
 /** Config: RIPPLE_SINGLE_IO_SERVICE_THREAD
     When set, restricts the number of threads calling io_service::run to one.
     This is useful when debugging.
@@ -220,23 +188,18 @@
 #define RIPPLE_SINGLE_IO_SERVICE_THREAD 0
 #endif
 
-/** Config: RIPPLE_STRUCTURED_OVERLAY_CLIENT
-            RIPPLE_STRUCTURED_OVERLAY_SERVER
-    Enables Structured Overlay support for the client or server roles.
-    This feature is currently in development:
-        https://ripplelabs.atlassian.net/browse/RIPD-157
+/** Config: RIPPLE_HOOK_VALIDATORS
+    Activates code for handling validations and validators (work in progress).
 */
-#ifndef RIPPLE_STRUCTURED_OVERLAY_CLIENT
-#define RIPPLE_STRUCTURED_OVERLAY_CLIENT 0
-#endif
-#ifndef RIPPLE_STRUCTURED_OVERLAY_SERVER
-#define RIPPLE_STRUCTURED_OVERLAY_SERVER 1
+#ifndef RIPPLE_HOOK_VALIDATORS
+#define RIPPLE_HOOK_VALIDATORS 0
 #endif
 
-/** Config: RIPPLE_ASYNC_RPC_HANDLER
+/** Config: RIPPLE_ENABLE_TICKETS
+    Enables processing of ticket transactions
 */
-#ifndef RIPPLE_ASYNC_RPC_HANDLER
-#define RIPPLE_ASYNC_RPC_HANDLER 1
+#ifndef RIPPLE_ENABLE_TICKETS
+#define RIPPLE_ENABLE_TICKETS 0
 #endif
 
 #endif

src/beast/BeastConfig.h

@@ -55,18 +55,6 @@
 //#define BEAST_FORCE_DEBUG 1
 #endif
 
-/** Config: BEAST_LOG_ASSERTIONS
-    If this flag is enabled, the the bassert and bassertfalse macros will always
-    use Logger::writeToLog() to write a message when an assertion happens.
-    Enabling it will also leave this turned on in release builds. When it's
-    disabled, however, the bassert and bassertfalse macros will not be compiled
-    in a release build.
-    @see bassert, bassertfalse, Logger
-*/
-#ifndef   BEAST_LOG_ASSERTIONS
-//#define BEAST_LOG_ASSERTIONS 1
-#endif
-
 /** Config: BEAST_CHECK_MEMORY_LEAKS
     Enables a memory-leak check for certain objects when the app terminates.
     See the LeakChecked class for more details about enabling leak checking for
@@ -76,17 +64,6 @@
 //#define BEAST_CHECK_MEMORY_LEAKS 0
 #endif
 
-/** Config: BEAST_COMPILER_CHECKS_SOCKET_OVERRIDES
-    Setting this option makes Socket-derived classes generate compile errors
-    if they forget any of the virtual overrides As some Socket-derived classes
-    intentionally omit member functions that are not applicable, this macro
-    should only be enabled temporarily when writing your own Socket-derived
-    class, to make sure that the function signatures match as expected.
-*/
-#ifndef   BEAST_COMPILER_CHECKS_SOCKET_OVERRIDES
-//#define BEAST_COMPILER_CHECKS_SOCKET_OVERRIDES 1
-#endif
-
 //------------------------------------------------------------------------------
 //
 // Libraries

src/beast/beast/Arithmetic.h

@@ -34,101 +34,6 @@
 
 namespace beast {
 
-// Some indispensible min/max functions
-
-/** Returns the larger of two values. */
-template <typename Type>
-inline Type bmax (const Type a, const Type b)
-    { return (a < b) ? b : a; }
-
-/** Returns the larger of three values. */
-template <typename Type>
-inline Type bmax (const Type a, const Type b, const Type c)
-    { return (a < b) ? ((b < c) ? c : b) : ((a < c) ? c : a); }
-
-/** Returns the larger of four values. */
-template <typename Type>
-inline Type bmax (const Type a, const Type b, const Type c, const Type d)
-    { return bmax (a, bmax (b, c, d)); }
-
-/** Returns the smaller of two values. */
-template <typename Type>
-inline Type bmin (const Type a, const Type b)
-    { return (b < a) ? b : a; }
-
-/** Returns the smaller of three values. */
-template <typename Type>
-inline Type bmin (const Type a, const Type b, const Type c)
-    { return (b < a) ? ((c < b) ? c : b) : ((c < a) ? c : a); }
-
-/** Returns the smaller of four values. */
-template <typename Type>
-inline Type bmin (const Type a, const Type b, const Type c, const Type d)
-    { return bmin (a, bmin (b, c, d)); }
-
-/** Scans an array of values, returning the minimum value that it contains. */
-template <typename Type>
-const Type findMinimum (const Type* data, int numValues)
-{
-    if (numValues <= 0)
-        return Type();
-
-    Type result (*data++);
-
-    while (--numValues > 0) // (> 0 rather than >= 0 because we've already taken the first sample)
-    {
-        const Type& v = *data++;
-        if (v < result)  result = v;
-    }
-
-    return result;
-}
-
-/** Scans an array of values, returning the maximum value that it contains. */
-template <typename Type>
-const Type findMaximum (const Type* values, int numValues)
-{
-    if (numValues <= 0)
-        return Type();
-
-    Type result (*values++);
-
-    while (--numValues > 0) // (> 0 rather than >= 0 because we've already taken the first sample)
-    {
-        const Type& v = *values++;
-        if (result < v)  result = v;
-    }
-
-    return result;
-}
-
-/** Scans an array of values, returning the minimum and maximum values that it contains. */
-template <typename Type>
-void findMinAndMax (const Type* values, int numValues, Type& lowest, Type& highest)
-{
-    if (numValues <= 0)
-    {
-        lowest = Type();
-        highest = Type();
-    }
-    else
-    {
-        Type mn (*values++);
-        Type mx (mn);
-
-        while (--numValues > 0) // (> 0 rather than >= 0 because we've already taken the first sample)
-        {
-            const Type& v = *values++;
-
-            if (mx < v)  mx = v;
-            if (v < mn)  mn = v;
-        }
-
-        lowest = mn;
-        highest = mx;
-    }
-}
-
 //==============================================================================
 /** Constrains a value to keep it within a given range.
 
@@ -151,7 +56,8 @@ inline Type blimit (const Type lowerLimit,
                     const Type upperLimit,
                     const Type valueToConstrain) noexcept
 {
-    bassert (lowerLimit <= upperLimit); // if these are in the wrong order, results are unpredictable..
+    // if these are in the wrong order, results are unpredictable.
+    bassert (lowerLimit <= upperLimit);
 
     return (valueToConstrain < lowerLimit) ? lowerLimit
                                            : ((upperLimit < valueToConstrain) ? upperLimit
@@ -177,24 +83,6 @@ inline bool isPositiveAndBelow (const int valueToTest, const int upperLimit) noe
     return static_cast <unsigned int> (valueToTest) < static_cast <unsigned int> (upperLimit);
 }
 
-/** Returns true if a value is at least zero, and also less than or equal to a specified upper limit.
-    This is basically a quicker way to write:
-    @code valueToTest >= 0 && valueToTest <= upperLimit
-    @endcode
-*/
-template <typename Type>
-inline bool isPositiveAndNotGreaterThan (Type valueToTest, Type upperLimit) noexcept
-{
-    bassert (Type() <= upperLimit); // makes no sense to call this if the upper limit is itself below zero..
-    return Type() <= valueToTest && valueToTest <= upperLimit;
-}
-
-template <>
-inline bool isPositiveAndNotGreaterThan (const int valueToTest, const int upperLimit) noexcept
-{
-    bassert (upperLimit >= 0); // makes no sense to call this if the upper limit is itself below zero..
-    return static_cast <unsigned int> (valueToTest) <= static_cast <unsigned int> (upperLimit);
-}
 
 //==============================================================================
 
@@ -214,55 +102,6 @@ int numElementsInArray (Type (&array)[N])
     return N;
 }
 
-/** 64-bit abs function. */
-inline std::int64_t abs64 (const std::int64_t n) noexcept
-{
-    return (n >= 0) ? n : -n;
-}
-
-
-//==============================================================================
-#if BEAST_MSVC
- #pragma optimize ("t", off)
- #ifndef __INTEL_COMPILER
-  #pragma float_control (precise, on, push)
- #endif
-#endif
-
-/** Fast floating-point-to-integer conversion.
-
-    This is faster than using the normal c++ cast to convert a float to an int, and
-    it will round the value to the nearest integer, rather than rounding it down
-    like the normal cast does.
-
-    Note that this routine gets its speed at the expense of some accuracy, and when
-    rounding values whose floating point component is exactly 0.5, odd numbers and
-    even numbers will be rounded up or down differently.
-*/
-template <typename FloatType>
-inline int roundToInt (const FloatType value) noexcept
-{
-  #ifdef __INTEL_COMPILER
-   #pragma float_control (precise, on, push)
-  #endif
-
-    union { int asInt[2]; double asDouble; } n;
-    n.asDouble = ((double) value) + 6755399441055744.0;
-
-   #if BEAST_BIG_ENDIAN
-    return n.asInt [1];
-   #else
-    return n.asInt [0];
-   #endif
-}
-
-#if BEAST_MSVC
- #ifndef __INTEL_COMPILER
-  #pragma float_control (pop)
- #endif
- #pragma optimize ("", on)  // resets optimisations to the project defaults
-#endif
-
 }
 
 #endif

src/beast/beast/Atomic.h

@@ -1,428 +0,0 @@
-//------------------------------------------------------------------------------
-/*
-    This file is part of Beast: https://github.com/vinniefalco/Beast
-    Copyright 2013, Vinnie Falco <vinnie.falco@gmail.com>
-
-    Portions of this file are from JUCE.
-    Copyright (c) 2013 - Raw Material Software Ltd.
-    Please visit http://www.juce.com
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose  with  or without fee is hereby granted, provided that the above
-    copyright notice and this permission notice appear in all copies.
-
-    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
-    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
-    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-*/
-//==============================================================================
-
-#ifndef BEAST_ATOMIC_H_INCLUDED
-#define BEAST_ATOMIC_H_INCLUDED
-
-#include <beast/Config.h>
-#include <beast/StaticAssert.h>
-
-#include <beast/utility/noexcept.h>
-
-#include <cstdint>
-
-namespace beast {
-
-//==============================================================================
-/**
-    Simple class to hold a primitive value and perform atomic operations on it.
-
-    The type used must be a 32 or 64 bit primitive, like an int, pointer, etc.
-    There are methods to perform most of the basic atomic operations.
-*/
-template <typename Type>
-class Atomic
-{
-public:
-    /** Creates a new value, initialised to zero. */
-    inline Atomic() noexcept
-        : value (0)
-    {
-    }
-
-    /** Creates a new value, with a given initial value. */
-    inline Atomic (const Type initialValue) noexcept
-        : value (initialValue)
-    {
-    }
-
-    /** Copies another value (atomically). */
-    inline Atomic (const Atomic& other) noexcept
-        : value (other.get())
-    {
-    }
-
-    /** Destructor. */
-    inline ~Atomic() noexcept
-    {
-        // This class can only be used for types which are 32 or 64 bits in size.
-        static_bassert (sizeof (Type) == 4 || sizeof (Type) == 8);
-    }
-
-    /** Atomically reads and returns the current value. */
-    Type get() const noexcept;
-
-    /** Copies another value onto this one (atomically). */
-     Atomic& operator= (const Atomic& other) noexcept
-      { exchange (other.get()); return *this; }
-
-    /** Copies another value onto this one (atomically). */
-     Atomic& operator= (const Type newValue) noexcept
-      { exchange (newValue); return *this; }
-
-    /** Atomically sets the current value. */
-    void set (Type newValue) noexcept
-      { exchange (newValue); }
-
-    /** Atomically sets the current value, returning the value that was replaced. */
-    Type exchange (Type value) noexcept;
-
-    /** Atomically adds a number to this value, returning the new value. */
-    Type operator+= (Type amountToAdd) noexcept;
-
-    /** Atomically subtracts a number from this value, returning the new value. */
-    Type operator-= (Type amountToSubtract) noexcept;
-
-    /** Atomically increments this value, returning the new value. */
-    Type operator++() noexcept;
-
-    /** Atomically decrements this value, returning the new value. */
-    Type operator--() noexcept;
-
-    /** Atomically compares this value with a target value, and if it is equal, sets
-        this to be equal to a new value.
-
-        This operation is the atomic equivalent of doing this:
-        @code
-        bool compareAndSetBool (Type newValue, Type valueToCompare)
-        {
-            if (get() == valueToCompare)
-            {
-                set (newValue);
-                return true;
-            }
-
-            return false;
-        }
-        @endcode
-
-        @returns true if the comparison was true and the value was replaced; false if
-                 the comparison failed and the value was left unchanged.
-        @see compareAndSetValue
-    */
-    bool compareAndSetBool (Type newValue, Type valueToCompare) noexcept;
-
-    /** Atomically compares this value with a target value, and if it is equal, sets
-        this to be equal to a new value.
-
-        This operation is the atomic equivalent of doing this:
-        @code
-        Type compareAndSetValue (Type newValue, Type valueToCompare)
-        {
-            Type oldValue = get();
-            if (oldValue == valueToCompare)
-                set (newValue);
-
-            return oldValue;
-        }
-        @endcode
-
-        @returns the old value before it was changed.
-        @see compareAndSetBool
-    */
-    Type compareAndSetValue (Type newValue, Type valueToCompare) noexcept;
-
-    //==============================================================================
-   #if BEAST_64BIT
-    BEAST_ALIGN (8)
-   #else
-    BEAST_ALIGN (4)
-   #endif
-
-    /** The raw value that this class operates on.
-        This is exposed publically in case you need to manipulate it directly
-        for performance reasons.
-    */
-    volatile Type value;
-
-private:
-    template <typename Dest, typename Source>
-    static inline Dest castTo (Source value) noexcept { union { Dest d; Source s; } u; u.s = value; return u.d; }
-
-    static inline Type castFrom32Bit (std::int32_t value) noexcept { return castTo <Type, std::int32_t> (value); }
-    static inline Type castFrom64Bit (std::int64_t value) noexcept { return castTo <Type, std::int64_t> (value); }
-    static inline std::int32_t castTo32Bit (Type value) noexcept { return castTo <std::int32_t, Type> (value); }
-    static inline std::int64_t castTo64Bit (Type value) noexcept { return castTo <std::int64_t, Type> (value); }
-
-
-    Type operator++ (int); // better to just use pre-increment with atomics..
-    Type operator-- (int);
-
-    /** This templated negate function will negate pointers as well as integers */
-    template <typename ValueType>
-    inline ValueType negateValue (ValueType n) noexcept
-    {
-        return sizeof (ValueType) == 1 ? (ValueType) -(signed char) n
-            : (sizeof (ValueType) == 2 ? (ValueType) -(short) n
-            : (sizeof (ValueType) == 4 ? (ValueType) -(int) n
-            : ((ValueType) -(std::int64_t) n)));
-    }
-
-    /** This templated negate function will negate pointers as well as integers */
-    template <typename PointerType>
-    inline PointerType* negateValue (PointerType* n) noexcept
-    {
-        return reinterpret_cast <PointerType*> (-reinterpret_cast <std::intptr_t> (n));
-    }
-};
-
-
-//==============================================================================
-/*
-    The following code is in the header so that the atomics can be inlined where possible...
-*/
-#if BEAST_IOS || (BEAST_MAC && (BEAST_PPC || BEAST_CLANG || __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 2)))
-  #define BEAST_ATOMICS_MAC 1        // Older OSX builds using gcc4.1 or earlier
-
-  #if MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_5
-    #define BEAST_MAC_ATOMICS_VOLATILE
-  #else
-    #define BEAST_MAC_ATOMICS_VOLATILE volatile
-  #endif
-
-  #if BEAST_PPC || BEAST_IOS
-    // None of these atomics are available for PPC or for iOS 3.1 or earlier!!
-    template <typename Type> static Type OSAtomicAdd64Barrier (Type b, BEAST_MAC_ATOMICS_VOLATILE Type* a) noexcept  { bassertfalse; return *a += b; }
-    template <typename Type> static Type OSAtomicIncrement64Barrier (BEAST_MAC_ATOMICS_VOLATILE Type* a) noexcept    { bassertfalse; return ++*a; }
-    template <typename Type> static Type OSAtomicDecrement64Barrier (BEAST_MAC_ATOMICS_VOLATILE Type* a) noexcept    { bassertfalse; return --*a; }
-    template <typename Type> static bool OSAtomicCompareAndSwap64Barrier (Type old, Type newValue, BEAST_MAC_ATOMICS_VOLATILE Type* value) noexcept
-        { bassertfalse; if (old == *value) { *value = newValue; return true; } return false; }
-    #define BEAST_64BIT_ATOMICS_UNAVAILABLE 1
-  #endif
-
-#elif BEAST_CLANG && BEAST_LINUX
-  #define BEAST_ATOMICS_GCC 1
-
-//==============================================================================
-#elif BEAST_GCC
-  #define BEAST_ATOMICS_GCC 1        // GCC with intrinsics
-
-  #if BEAST_IOS || BEAST_ANDROID // (64-bit ops will compile but not link on these mobile OSes)
-    #define BEAST_64BIT_ATOMICS_UNAVAILABLE 1
-  #endif
-
-//==============================================================================
-#else
-  #define BEAST_ATOMICS_WINDOWS 1    // Windows with intrinsics
-
-  #if BEAST_USE_INTRINSICS
-    #ifndef __INTEL_COMPILER
-     #pragma intrinsic (_InterlockedExchange, _InterlockedIncrement, _InterlockedDecrement, _InterlockedCompareExchange, \
-                        _InterlockedCompareExchange64, _InterlockedExchangeAdd, _ReadWriteBarrier)
-    #endif
-    #define beast_InterlockedExchange(a, b)              _InterlockedExchange(a, b)
-    #define beast_InterlockedIncrement(a)                _InterlockedIncrement(a)
-    #define beast_InterlockedDecrement(a)                _InterlockedDecrement(a)
-    #define beast_InterlockedExchangeAdd(a, b)           _InterlockedExchangeAdd(a, b)
-    #define beast_InterlockedCompareExchange(a, b, c)    _InterlockedCompareExchange(a, b, c)
-    #define beast_InterlockedCompareExchange64(a, b, c)  _InterlockedCompareExchange64(a, b, c)
-    #define beast_MemoryBarrier _ReadWriteBarrier
-  #else
-    long beast_InterlockedExchange (volatile long* a, long b) noexcept;
-    long beast_InterlockedIncrement (volatile long* a) noexcept;
-    long beast_InterlockedDecrement (volatile long* a) noexcept;
-    long beast_InterlockedExchangeAdd (volatile long* a, long b) noexcept;
-    long beast_InterlockedCompareExchange (volatile long* a, long b, long c) noexcept;
-    __int64 beast_InterlockedCompareExchange64 (volatile __int64* a, __int64 b, __int64 c) noexcept;
-    inline void beast_MemoryBarrier() noexcept  { long x = 0; beast_InterlockedIncrement (&x); }
-  #endif
-
-  #if BEAST_64BIT
-    #ifndef __INTEL_COMPILER
-     #pragma intrinsic (_InterlockedExchangeAdd64, _InterlockedExchange64, _InterlockedIncrement64, _InterlockedDecrement64)
-    #endif
-    #define beast_InterlockedExchangeAdd64(a, b)     _InterlockedExchangeAdd64(a, b)
-    #define beast_InterlockedExchange64(a, b)        _InterlockedExchange64(a, b)
-    #define beast_InterlockedIncrement64(a)          _InterlockedIncrement64(a)
-    #define beast_InterlockedDecrement64(a)          _InterlockedDecrement64(a)
-  #else
-    // None of these atomics are available in a 32-bit Windows build!!
-    template <typename Type> static Type beast_InterlockedExchangeAdd64 (volatile Type* a, Type b) noexcept  { bassertfalse; Type old = *a; *a += b; return old; }
-    template <typename Type> static Type beast_InterlockedExchange64 (volatile Type* a, Type b) noexcept     { bassertfalse; Type old = *a; *a = b; return old; }
-    template <typename Type> static Type beast_InterlockedIncrement64 (volatile Type* a) noexcept            { bassertfalse; return ++*a; }
-    template <typename Type> static Type beast_InterlockedDecrement64 (volatile Type* a) noexcept            { bassertfalse; return --*a; }
-    #define BEAST_64BIT_ATOMICS_UNAVAILABLE 1
-  #endif
-#endif
-
-#if BEAST_MSVC
-  #pragma warning (push)
-  #pragma warning (disable: 4311)  // (truncation warning)
-#endif
-
-//==============================================================================
-template <typename Type>
-inline Type Atomic<Type>::get() const noexcept
-{
-  #if BEAST_ATOMICS_MAC
-    return sizeof (Type) == 4 ? castFrom32Bit ((std::int32_t) OSAtomicAdd32Barrier ((int32_t) 0, (BEAST_MAC_ATOMICS_VOLATILE int32_t*) &value))
-                              : castFrom64Bit ((std::int64_t) OSAtomicAdd64Barrier ((int64_t) 0, (BEAST_MAC_ATOMICS_VOLATILE int64_t*) &value));
-  #elif BEAST_ATOMICS_WINDOWS
-    return sizeof (Type) == 4 ? castFrom32Bit ((std::int32_t) beast_InterlockedExchangeAdd ((volatile long*) &value, (long) 0))
-                              : castFrom64Bit ((std::int64_t) beast_InterlockedExchangeAdd64 ((volatile __int64*) &value, (__int64) 0));
-  #elif BEAST_ATOMICS_GCC
-    return sizeof (Type) == 4 ? castFrom32Bit ((std::int32_t) __sync_add_and_fetch ((volatile std::int32_t*) &value, 0))
-                              : castFrom64Bit ((std::int64_t) __sync_add_and_fetch ((volatile std::int64_t*) &value, 0));
-  #endif
-}
-
-template <typename Type>
-inline Type Atomic<Type>::exchange (const Type newValue) noexcept
-{
-  #if BEAST_ATOMICS_MAC || BEAST_ATOMICS_GCC
-    Type currentVal = value;
-    while (! compareAndSetBool (newValue, currentVal)) { currentVal = value; }
-    return currentVal;
-  #elif BEAST_ATOMICS_WINDOWS
-    return sizeof (Type) == 4 ? castFrom32Bit ((std::int32_t) beast_InterlockedExchange ((volatile long*) &value, (long) castTo32Bit (newValue)))
-                              : castFrom64Bit ((std::int64_t) beast_InterlockedExchange64 ((volatile __int64*) &value, (__int64) castTo64Bit (newValue)));
-  #endif
-}
-
-template <typename Type>
-inline Type Atomic<Type>::operator+= (const Type amountToAdd) noexcept
-{
-  #if BEAST_ATOMICS_MAC
-#   ifdef __clang__
-#       pragma clang diagnostic push
-#       pragma clang diagnostic ignored "-Wint-to-void-pointer-cast"
-#       pragma clang diagnostic ignored "-Wint-to-pointer-cast"
-#   endif
-    return sizeof (Type) == 4 ? (Type) OSAtomicAdd32Barrier ((int32_t) castTo32Bit (amountToAdd), (BEAST_MAC_ATOMICS_VOLATILE int32_t*) &value)
-                              : (Type) OSAtomicAdd64Barrier ((int64_t) amountToAdd, (BEAST_MAC_ATOMICS_VOLATILE int64_t*) &value);
-#   ifdef __clang__
-#       pragma clang diagnostic pop
-#   endif
-  #elif BEAST_ATOMICS_WINDOWS
-    return sizeof (Type) == 4 ? (Type) (beast_InterlockedExchangeAdd ((volatile long*) &value, (long) amountToAdd) + (long) amountToAdd)
-                              : (Type) (beast_InterlockedExchangeAdd64 ((volatile __int64*) &value, (__int64) amountToAdd) + (__int64) amountToAdd);
-  #elif BEAST_ATOMICS_GCC
-    return (Type) __sync_add_and_fetch (&value, amountToAdd);
-  #endif
-}
-
-template <typename Type>
-inline Type Atomic<Type>::operator-= (const Type amountToSubtract) noexcept
-{
-    return operator+= (negateValue (amountToSubtract));
-}
-
-template <typename Type>
-inline Type Atomic<Type>::operator++() noexcept
-{
-  #if BEAST_ATOMICS_MAC
-#   ifdef __clang__
-#       pragma clang diagnostic push
-#       pragma clang diagnostic ignored "-Wint-to-void-pointer-cast"
-#       pragma clang diagnostic ignored "-Wint-to-pointer-cast"
-#   endif
-    return sizeof (Type) == 4 ? (Type) OSAtomicIncrement32Barrier ((BEAST_MAC_ATOMICS_VOLATILE int32_t*) &value)
-                              : (Type) OSAtomicIncrement64Barrier ((BEAST_MAC_ATOMICS_VOLATILE int64_t*) &value);
-#   ifdef __clang__
-#       pragma clang diagnostic pop
-#   endif
-  #elif BEAST_ATOMICS_WINDOWS
-    return sizeof (Type) == 4 ? (Type) beast_InterlockedIncrement ((volatile long*) &value)
-                              : (Type) beast_InterlockedIncrement64 ((volatile __int64*) &value);
-  #elif BEAST_ATOMICS_GCC
-    return (Type) __sync_add_and_fetch (&value, (Type) 1);
-  #endif
-}
-
-template <typename Type>
-inline Type Atomic<Type>::operator--() noexcept
-{
-  #if BEAST_ATOMICS_MAC
-#   ifdef __clang__
-#       pragma clang diagnostic push
-#       pragma clang diagnostic ignored "-Wint-to-void-pointer-cast"
-#       pragma clang diagnostic ignored "-Wint-to-pointer-cast"
-#   endif
-    return sizeof (Type) == 4 ? (Type) OSAtomicDecrement32Barrier ((BEAST_MAC_ATOMICS_VOLATILE int32_t*) &value)
-                              : (Type) OSAtomicDecrement64Barrier ((BEAST_MAC_ATOMICS_VOLATILE int64_t*) &value);
-#   ifdef __clang__
-#       pragma clang diagnostic pop
-#   endif
-  #elif BEAST_ATOMICS_WINDOWS
-    return sizeof (Type) == 4 ? (Type) beast_InterlockedDecrement ((volatile long*) &value)
-                              : (Type) beast_InterlockedDecrement64 ((volatile __int64*) &value);
-  #elif BEAST_ATOMICS_GCC
-    return (Type) __sync_add_and_fetch (&value, (Type) -1);
-  #endif
-}
-
-template <typename Type>
-inline bool Atomic<Type>::compareAndSetBool (const Type newValue, const Type valueToCompare) noexcept
-{
-  #if BEAST_ATOMICS_MAC
-    return sizeof (Type) == 4 ? OSAtomicCompareAndSwap32Barrier ((int32_t) castTo32Bit (valueToCompare), (int32_t) castTo32Bit (newValue), (BEAST_MAC_ATOMICS_VOLATILE int32_t*) &value)
-                              : OSAtomicCompareAndSwap64Barrier ((int64_t) castTo64Bit (valueToCompare), (int64_t) castTo64Bit (newValue), (BEAST_MAC_ATOMICS_VOLATILE int64_t*) &value);
-  #elif BEAST_ATOMICS_WINDOWS
-    return compareAndSetValue (newValue, valueToCompare) == valueToCompare;
-  #elif BEAST_ATOMICS_GCC
-    return sizeof (Type) == 4 ? __sync_bool_compare_and_swap ((volatile std::int32_t*) &value, castTo32Bit (valueToCompare), castTo32Bit (newValue))
-                              : __sync_bool_compare_and_swap ((volatile std::int64_t*) &value, castTo64Bit (valueToCompare), castTo64Bit (newValue));
-  #endif
-}
-
-template <typename Type>
-inline Type Atomic<Type>::compareAndSetValue (const Type newValue, const Type valueToCompare) noexcept
-{
-  #if BEAST_ATOMICS_MAC
-    for (;;) // Annoying workaround for only having a bool CAS operation..
-    {
-        if (compareAndSetBool (newValue, valueToCompare))
-            return valueToCompare;
-
-        const Type result = value;
-        if (result != valueToCompare)
-            return result;
-    }
-
-  #elif BEAST_ATOMICS_WINDOWS
-    return sizeof (Type) == 4 ? castFrom32Bit ((std::int32_t) beast_InterlockedCompareExchange ((volatile long*) &value, (long) castTo32Bit (newValue), (long) castTo32Bit (valueToCompare)))
-                              : castFrom64Bit ((std::int64_t) beast_InterlockedCompareExchange64 ((volatile __int64*) &value, (__int64) castTo64Bit (newValue), (__int64) castTo64Bit (valueToCompare)));
-  #elif BEAST_ATOMICS_GCC
-    return sizeof (Type) == 4 ? castFrom32Bit ((std::int32_t) __sync_val_compare_and_swap ((volatile std::int32_t*) &value, castTo32Bit (valueToCompare), castTo32Bit (newValue)))
-                              : castFrom64Bit ((std::int64_t) __sync_val_compare_and_swap ((volatile std::int64_t*) &value, castTo64Bit (valueToCompare), castTo64Bit (newValue)));
-  #endif
-}
-
-inline void memoryBarrier() noexcept
-{
-  #if BEAST_ATOMICS_MAC
-    OSMemoryBarrier();
-  #elif BEAST_ATOMICS_GCC
-    __sync_synchronize();
-  #elif BEAST_ATOMICS_WINDOWS
-    beast_MemoryBarrier();
-  #endif
-}
-
-#if BEAST_MSVC
-  #pragma warning (pop)
-#endif
-
-}
-
-#endif

src/beast/beast/ByteOrder.h

@@ -25,7 +25,6 @@
 #define BEAST_BYTEORDER_H_INCLUDED
 
 #include <beast/Config.h>
-#include <beast/Uncopyable.h>
 
 #include <cstdint>
 
@@ -35,7 +34,7 @@ namespace beast {
 /** Contains static methods for converting the byte order between different
     endiannesses.
 */
-class ByteOrder : public Uncopyable
+class ByteOrder
 {
 public:
     //==============================================================================
@@ -105,6 +104,8 @@ public:
 
 private:
     ByteOrder();
+    ByteOrder(ByteOrder const&) = delete;
+    ByteOrder& operator= (ByteOrder const&) = delete;
 };
 
 //==============================================================================

src/beast/beast/Config.h

@@ -26,9 +26,6 @@
 
 // VFALCO NOTE this is analogous to <boost/config.hpp>
 
-// Assert to boost that we always have std::array support
-#define BOOST_ASIO_HAS_STD_ARRAY 1
-
 #if !defined(BEAST_COMPILER_CONFIG) && !defined(BEAST_NO_COMPILER_CONFIG) && !defined(BEAST_NO_CONFIG)
 #include <beast/config/SelectCompilerConfig.h>
 #endif

src/beast/beast/Crypto.h

@@ -20,11 +20,7 @@
 #ifndef BEAST_CRYPTO_H_INCLUDED
 #define BEAST_CRYPTO_H_INCLUDED
 
-#include <beast/crypto/BinaryEncoding.h>
-#include <beast/crypto/MurmurHash.h>
 #include <beast/crypto/Sha256.h>
-#include <beast/crypto/UnsignedInteger.h>
-#include <beast/crypto/UnsignedIntegerCalc.h>
 
 #endif
 

src/beast/beast/HeapBlock.h

@@ -29,7 +29,6 @@
 #include <stdexcept>
 
 #include <beast/Memory.h>
-#include <beast/Uncopyable.h>
 
 // If the MSVC debug heap headers were included, disable
 // the macros during the juce include since they conflict.
@@ -122,7 +121,7 @@ namespace HeapBlockHelper
     @see Array, MemoryBlock
 */
 template <class ElementType, bool throwOnFailure = false>
-class HeapBlock : public Uncopyable
+class HeapBlock
 {
 public:
     //==============================================================================
@@ -136,12 +135,6 @@ public:
     {
     }
 
-    HeapBlock (HeapBlock& other)
-    {
-        data = other.data;
-        other.data = nullptr;
-    }
-
     /** Creates a HeapBlock containing a number of elements.
 
         The contents of the block are undefined, as it will have been created by a
@@ -169,6 +162,10 @@ public:
         throwOnAllocationFailure();
     }
 
+
+    HeapBlock(HeapBlock const&) = delete;
+    HeapBlock& operator= (HeapBlock const&) = delete;
+
     /** Destructor.
         This will free the data, if any has been allocated.
     */

src/beast/beast/Memory.h

@@ -27,7 +27,6 @@
 #include <cstring>
     
 #include <beast/Config.h>
-#include <beast/Uncopyable.h>
 
 namespace beast {
 
@@ -78,12 +77,16 @@ Type* createCopyIfNotNull (const Type* pointer)
  /** A handy C++ wrapper that creates and deletes an NSAutoreleasePool object using RAII.
      You should use the BEAST_AUTORELEASEPOOL macro to create a local auto-release pool on the stack.
  */
- class ScopedAutoReleasePool : public Uncopyable
+ class ScopedAutoReleasePool
  {
  public:
      ScopedAutoReleasePool();
      ~ScopedAutoReleasePool();
 
+
+    ScopedAutoReleasePool(ScopedAutoReleasePool const&) = delete;
+    ScopedAutoReleasePool& operator= (ScopedAutoReleasePool const&) = delete;
+    
  private:
      void* pool;
  };

src/beast/beast/StaticAssert.h

@@ -1,45 +0,0 @@
-//------------------------------------------------------------------------------
-/*
-    This file is part of Beast: https://github.com/vinniefalco/Beast
-    Copyright 2013, Vinnie Falco <vinnie.falco@gmail.com>
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose  with  or without fee is hereby granted, provided that the above
-    copyright notice and this permission notice appear in all copies.
-
-    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
-    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
-    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-*/
-//==============================================================================
-
-#ifndef BEAST_STATICASSERT_H_INCLUDED
-#define BEAST_STATICASSERT_H_INCLUDED
-
-#ifndef DOXYGEN
-namespace beast
-{
-    template <bool b>
-    struct BeastStaticAssert;
-
-    template <>
-    struct BeastStaticAssert <true>
-    {
-        static void dummy() {}
-    };
-}
-#endif
-
-/** A compile-time assertion macro.
-    If the expression parameter is false, the macro will cause a compile error.
-    (The actual error message that the compiler generates may be completely
-    bizarre and seem to have no relation to the place where you put the
-    static_assert though!)
-*/
-#define static_bassert(expression) beast::BeastStaticAssert<expression>::dummy();
-
-#endif

src/beast/beast/Threads.h

@@ -25,11 +25,9 @@
 #include <beast/threads/SharedLockGuard.h>
 #include <beast/threads/SharedMutexAdapter.h>
 #include <beast/threads/SharedData.h>
-#include <beast/threads/ServiceQueue.h>
 #include <beast/threads/SpinLock.h>
 #include <beast/threads/Stoppable.h>
 #include <beast/threads/Thread.h>
-#include <beast/threads/ThreadLocalValue.h>
 #include <beast/threads/WaitableEvent.h>
 #include <beast/threads/ScopedWrapperContext.h>
 

src/beast/beast/Uncopyable.h

@@ -1,77 +0,0 @@
-//------------------------------------------------------------------------------
-/*
-    This file is part of Beast: https://github.com/vinniefalco/Beast
-    Copyright 2013, Vinnie Falco <vinnie.falco@gmail.com>
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose  with  or without fee is hereby granted, provided that the above
-    copyright notice and this permission notice appear in all copies.
-
-    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
-    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
-    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-*/
-//==============================================================================
-
-#ifndef BEAST_UNCOPYABLE_H_INCLUDED
-#define BEAST_UNCOPYABLE_H_INCLUDED
-
-namespace beast
-{
-
-// Ideas from boost
-
-/** Prevent copy construction and assignment.
-
-    This is used to suppress warnings and prevent unsafe operations on
-    objects which cannot be passed by value. Ideas based on Boost.
-
-    For example, instead of
-
-    @code
-
-    class MyClass
-    {
-    public:
-        //...
-
-    private:
-        MyClass (const MyClass&);
-        MyClass& operator= (const MyClass&);
-    };
-    
-    @endcode
-
-    ..you can just write:
-
-    @code
-
-    class MyClass : public Uncopyable
-    {
-    public:
-        //...
-    };
-    
-    @endcode
-
-    @note The derivation should be public or else child classes which
-          also derive from Uncopyable may not compile.
-*/
-class Uncopyable
-{
-protected:
-    Uncopyable () { }
-    ~Uncopyable () { }
-
-private:
-    Uncopyable (Uncopyable const&);
-    Uncopyable const& operator= (Uncopyable const&);
-};
-
-}
-
-#endif

src/beast/beast/asio/Asio.unity.cpp

@@ -22,11 +22,8 @@
 #endif
 
 #include <beast/asio/impl/IPAddressConversion.cpp>
-
-#include <beast/asio/tests/wrap_handler.test.cpp>
+#include <beast/asio/impl/error.cpp>
 #include <beast/asio/tests/bind_handler.test.cpp>
-#include <beast/asio/tests/enable_wait_for_async.test.cpp>
-#include <beast/asio/tests/shared_handler.test.cpp>
-
-#include <beast/asio/abstract_socket.cpp> // TEMPORARY!
+#include <beast/asio/tests/streambuf.test.cpp>
+#include <beast/asio/tests/error_test.cpp>
 

src/beast/beast/asio/abstract_socket.cpp

@@ -1,217 +0,0 @@
-//------------------------------------------------------------------------------
-/*
-    This file is part of Beast: https://github.com/vinniefalco/Beast
-    Copyright 2013, Vinnie Falco <vinnie.falco@gmail.com>
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose  with  or without fee is hereby granted, provided that the above
-    copyright notice and this permission notice appear in all copies.
-
-    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
-    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
-    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-*/
-//==============================================================================
-
-#include <beast/asio/abstract_socket.h>
-#include <beast/asio/bind_handler.h>
-
-namespace beast {
-namespace asio {
-
-#if ! BEAST_COMPILER_CHECKS_SOCKET_OVERRIDES
-
-//------------------------------------------------------------------------------
-//
-// Socket
-//
-//------------------------------------------------------------------------------
-
-void* abstract_socket::this_layer_ptr (char const*) const
-{
-    pure_virtual_called ();
-    return nullptr;
-}
-
-//------------------------------------------------------------------------------
-//
-// native_handle
-//
-//------------------------------------------------------------------------------
-
-bool abstract_socket::native_handle (char const*, void*)
-{
-    pure_virtual_called ();
-    return false;
-}
-
-//------------------------------------------------------------------------------
-//
-// basic_io_object
-//
-//------------------------------------------------------------------------------
-
-boost::asio::io_service& abstract_socket::get_io_service ()
-{
-    pure_virtual_called ();
-    return *static_cast <boost::asio::io_service*>(nullptr);
-}
-
-//------------------------------------------------------------------------------
-//
-// basic_socket
-//
-//------------------------------------------------------------------------------
-
-void*
-abstract_socket::lowest_layer_ptr (char const*) const
-{
-    pure_virtual_called ();
-    return nullptr;
-}
-
-auto
-abstract_socket::cancel (boost::system::error_code& ec) -> error_code
-{
-    return pure_virtual_error (ec);
-}
-
-auto
-abstract_socket::shutdown (shutdown_type, boost::system::error_code& ec) -> error_code
-{
-    return pure_virtual_error (ec);
-}
-
-auto
-abstract_socket::close (boost::system::error_code& ec) -> error_code
-{
-    return pure_virtual_error (ec);
-}
-
-//------------------------------------------------------------------------------
-//
-// basic_socket_acceptor
-//
-//------------------------------------------------------------------------------
-
-auto 
-abstract_socket::accept (abstract_socket&, error_code& ec) -> error_code
-{
-    return pure_virtual_error (ec);
-}
-
-void
-abstract_socket::async_accept (abstract_socket&, error_handler handler)
-{
-    get_io_service ().post (bind_handler (
-        handler, pure_virtual_error()));
-}
-
-//------------------------------------------------------------------------------
-//
-// basic_stream_socket
-//
-//------------------------------------------------------------------------------
-
-std::size_t
-abstract_socket::read_some (mutable_buffers, error_code& ec)
-{
-    ec = pure_virtual_error ();
-    return 0;
-}
-
-std::size_t
-abstract_socket::write_some (const_buffers, error_code& ec)
-{
-    ec = pure_virtual_error ();
-    return 0;
-}
-
-void
-abstract_socket::async_read_some (mutable_buffers, transfer_handler handler)
-{
-    get_io_service ().post (bind_handler (
-        handler, pure_virtual_error(), 0));
-}
-
-void
-abstract_socket::async_write_some (const_buffers, transfer_handler handler)
-{
-    get_io_service ().post (bind_handler (
-        handler, pure_virtual_error(), 0));
-}
-
-//------------------------------------------------------------------------------
-//
-// ssl::stream
-//
-//------------------------------------------------------------------------------
-
-void*
-abstract_socket::next_layer_ptr (char const*) const
-{
-    pure_virtual_called ();
-    return nullptr;
-}
-
-bool
-abstract_socket::needs_handshake ()
-{
-    return false;
-}
-
-void
-abstract_socket::set_verify_mode (int)
-{
-    pure_virtual_called ();
-}
-
-auto
-abstract_socket::handshake (handshake_type, error_code& ec) -> error_code
-{
-    return pure_virtual_error (ec);
-}
-
-void
-abstract_socket::async_handshake (handshake_type, error_handler handler)
-{
-    get_io_service ().post (bind_handler (
-        handler, pure_virtual_error()));
-}
-
-auto
-abstract_socket::handshake (handshake_type, const_buffers, error_code& ec) ->
-    error_code
-{
-    return pure_virtual_error (ec);
-}
-
-void
-abstract_socket::async_handshake (handshake_type, const_buffers,
-    transfer_handler handler)
-{
-    get_io_service ().post (bind_handler (
-        handler, pure_virtual_error(), 0));
-}
-
-auto
-abstract_socket::shutdown (error_code& ec) -> error_code
-{
-    return pure_virtual_error (ec);
-}
-
-void
-abstract_socket::async_shutdown (error_handler handler)
-{
-    get_io_service ().post (bind_handler (
-        handler, pure_virtual_error()));
-}
-
-#endif
-
-}
-}

src/beast/beast/asio/abstract_socket.h

@@ -1,404 +0,0 @@
-//------------------------------------------------------------------------------
-/*
-    This file is part of Beast: https://github.com/vinniefalco/Beast
-    Copyright 2013, Vinnie Falco <vinnie.falco@gmail.com>
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose  with  or without fee is hereby granted, provided that the above
-    copyright notice and this permission notice appear in all copies.
-
-    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
-    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
-    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-*/
-//==============================================================================
-
-#ifndef BEAST_ASIO_ABSTRACT_SOCKET_H_INCLUDED
-#define BEAST_ASIO_ABSTRACT_SOCKET_H_INCLUDED
-
-#include <beast/asio/buffer_sequence.h>
-#include <beast/asio/shared_handler.h>
-#include <boost/asio/io_service.hpp>
-#include <boost/asio/socket_base.hpp>
-#include <boost/asio/ssl/stream_base.hpp>
-
-// Checking overrides replaces unimplemented stubs with pure virtuals
-#ifndef BEAST_COMPILER_CHECKS_SOCKET_OVERRIDES
-# define BEAST_COMPILER_CHECKS_SOCKET_OVERRIDES 1
-#endif
-
-#if BEAST_COMPILER_CHECKS_SOCKET_OVERRIDES
-# define BEAST_SOCKET_VIRTUAL = 0
-#else
-# define BEAST_SOCKET_VIRTUAL
-#endif
-
-namespace beast {
-namespace asio {
-
-/** A high level socket abstraction.
-
-    This combines the capabilities of multiple socket interfaces such
-    as listening, connecting, streaming, and handshaking. It brings
-    everything together into a single abstract interface.
-
-    When member functions are called and the underlying implementation does
-    not support the operation, a fatal error is generated.
-*/
-class abstract_socket
-    : public boost::asio::ssl::stream_base
-    , public boost::asio::socket_base
-{
-protected:
-    typedef boost::system::error_code error_code;
-
-    typedef asio::shared_handler <void (void)> post_handler;
-
-    typedef asio::shared_handler <void (error_code)> error_handler;
-
-    typedef asio::shared_handler <
-        void (error_code, std::size_t)> transfer_handler;
-
-    static
-    void
-    pure_virtual_called()
-    {
-        throw std::runtime_error ("pure virtual called");
-    }
-
-    static
-    error_code
-    pure_virtual_error ()
-    {
-        pure_virtual_called();
-        return boost::system::errc::make_error_code (
-            boost::system::errc::function_not_supported);
-    }
-
-    static
-    error_code
-    pure_virtual_error (error_code& ec)
-    {
-        return ec = pure_virtual_error();
-    }
-
-    static
-    void
-    throw_if (error_code const& ec)
-    {
-        if (ec)
-            throw boost::system::system_error (ec);
-    }
-
-public:
-    virtual ~abstract_socket ()
-    {
-    }
-
-    //--------------------------------------------------------------------------
-    //
-    // abstract_socket
-    //
-    //--------------------------------------------------------------------------
-
-    /** Retrieve the underlying object.
-
-        @note If the type doesn't match, nullptr is returned or an
-              exception is thrown if trying to acquire a reference.
-    */
-    /** @{ */
-    template <class Object>
-    Object& this_layer ()
-    {
-        Object* object (this->this_layer_ptr <Object> ());
-        if (object == nullptr)
-            throw std::bad_cast ();
-        return *object;
-    }
-
-    template <class Object>
-    Object const& this_layer () const
-    {
-        Object const* object (this->this_layer_ptr <Object> ());
-        if (object == nullptr)
-            throw std::bad_cast ();
-        return *object;
-    }
-
-    template <class Object>
-    Object* this_layer_ptr ()
-    {
-        return static_cast <Object*> (
-            this->this_layer_ptr (typeid (Object).name ()));
-    }
-
-    template <class Object>
-    Object const* this_layer_ptr () const
-    {
-        return static_cast <Object const*> (
-            this->this_layer_ptr (typeid (Object).name ()));
-    }
-    /** @} */
-
-    virtual void* this_layer_ptr (char const* type_name) const
-        BEAST_SOCKET_VIRTUAL;
-
-    //--------------------------------------------------------------------------
-    //
-    // native_handle
-    //
-    //--------------------------------------------------------------------------
-
-    /** Retrieve the native representation of the object.
-
-        Since we dont know the return type, and because almost every
-        asio implementation passes the result by value, you need to provide
-        a pointer to a default-constructed object of the matching type.
-
-        @note If the type doesn't match, an exception is thrown.
-    */
-    template <typename Handle>
-    void native_handle (Handle* dest)
-    {
-        if (! native_handle (typeid (Handle).name (), dest))
-            throw std::bad_cast ();
-    }
-
-    virtual bool native_handle (char const* type_name, void* dest)
-        BEAST_SOCKET_VIRTUAL;
-
-    //--------------------------------------------------------------------------
-    //
-    // basic_io_object
-    //
-    //--------------------------------------------------------------------------
-
-    virtual boost::asio::io_service& get_io_service ()
-        BEAST_SOCKET_VIRTUAL;
-
-    //--------------------------------------------------------------------------
-    //
-    // basic_socket
-    //
-    //--------------------------------------------------------------------------
-
-    /** Retrieve the lowest layer object.
-
-        @note If the type doesn't match, nullptr is returned or an
-              exception is thrown if trying to acquire a reference.
-    */
-    /** @{ */
-    template <class Object>
-    Object& lowest_layer ()
-    {
-        Object* object (this->lowest_layer_ptr <Object> ());
-        if (object == nullptr)
-            throw std::bad_cast ();
-        return *object;
-    }
-
-    template <class Object>
-    Object const& lowest_layer () const
-    {
-        Object const* object (this->lowest_layer_ptr <Object> ());
-        if (object == nullptr)
-            throw std::bad_cast ();
-        return *object;
-    }
-
-    template <class Object>
-    Object* lowest_layer_ptr ()
-    {
-        return static_cast <Object*> (
-            this->lowest_layer_ptr (typeid (Object).name ()));
-    }
-
-    template <class Object>
-    Object const* lowest_layer_ptr () const
-    {
-        return static_cast <Object const*> (
-            this->lowest_layer_ptr (typeid (Object).name ()));
-    }
-    /** @} */
-
-    virtual void* lowest_layer_ptr (char const* type_name) const
-        BEAST_SOCKET_VIRTUAL;
-
-    //--------------------------------------------------------------------------
-
-    void cancel ()
-    {
-        error_code ec;
-        cancel (ec);
-        throw_if (ec);
-    }
-
-    virtual error_code cancel (error_code& ec)
-        BEAST_SOCKET_VIRTUAL;
-
-    void shutdown (shutdown_type what)
-    {
-        error_code ec;
-        shutdown (what, ec);
-        throw_if (ec);
-    }
-
-    virtual error_code shutdown (shutdown_type what,
-        error_code& ec)
-            BEAST_SOCKET_VIRTUAL;
-
-    void close ()
-    {
-        error_code ec;
-        close (ec);
-        throw_if (ec);
-    }
-
-    virtual error_code close (error_code& ec)
-        BEAST_SOCKET_VIRTUAL;
-
-    //--------------------------------------------------------------------------
-    //
-    // basic_socket_acceptor
-    //
-    //--------------------------------------------------------------------------
-
-    virtual error_code accept (abstract_socket& peer, error_code& ec)
-        BEAST_SOCKET_VIRTUAL;
-
-    virtual void async_accept (abstract_socket& peer, error_handler handler)
-        BEAST_SOCKET_VIRTUAL;
-
-    //--------------------------------------------------------------------------
-    //
-    // basic_stream_socket
-    //
-    //--------------------------------------------------------------------------
-
-    virtual std::size_t read_some (mutable_buffers buffers, error_code& ec)
-        BEAST_SOCKET_VIRTUAL;
-
-    virtual std::size_t write_some (const_buffers buffers, error_code& ec)
-        BEAST_SOCKET_VIRTUAL;
-
-    virtual void async_read_some (mutable_buffers buffers,
-        transfer_handler handler)
-        BEAST_SOCKET_VIRTUAL;
-
-    virtual void async_write_some (const_buffers buffers,
-        transfer_handler handler)
-        BEAST_SOCKET_VIRTUAL;
-
-    //--------------------------------------------------------------------------
-    //
-    // ssl::stream
-    //
-    //--------------------------------------------------------------------------
-
-    /** Retrieve the next layer object.
-
-        @note If the type doesn't match, nullptr is returned or an
-              exception is thrown if trying to acquire a reference.
-    */
-    /** @{ */
-    template <class Object>
-    Object& next_layer ()
-    {
-        Object* object (this->next_layer_ptr <Object> ());
-        if (object == nullptr)
-            throw std::bad_cast ();
-        return *object;
-    }
-
-    template <class Object>
-    Object const& next_layer () const
-    {
-        Object const* object (this->next_layer_ptr <Object> ());
-        if (object == nullptr)
-            throw std::bad_cast ();
-        return *object;
-    }
-
-    template <class Object>
-    Object* next_layer_ptr ()
-    {
-        return static_cast <Object*> (
-            this->next_layer_ptr (typeid (Object).name ()));
-    }
-
-    template <class Object>
-    Object const* next_layer_ptr () const
-    {
-        return static_cast <Object const*> (
-            this->next_layer_ptr (typeid (Object).name ()));
-    }
-    /** @} */
-
-    virtual void* next_layer_ptr (char const* type_name) const
-        BEAST_SOCKET_VIRTUAL;
-
-    /** Determines if the underlying stream requires a handshake.
-
-        If needs_handshake is true, it will be necessary to call handshake or
-        async_handshake after the connection is established. Furthermore it
-        will be necessary to call the shutdown member from the
-        HandshakeInterface to close the connection. Do not close the underlying
-        socket or else the closure will not be graceful. Only one side should
-        initiate the handshaking shutdon. The other side should observe it.
-        Which side does what is up to the user.
-
-        The default version returns false.
-    */
-    virtual bool needs_handshake ()
-        BEAST_SOCKET_VIRTUAL;
-
-    virtual void set_verify_mode (int verify_mode)
-        BEAST_SOCKET_VIRTUAL;
-
-    void handshake (handshake_type type)
-    {
-        error_code ec;
-        handshake (type, ec);
-        throw_if (ec);
-    }
-
-    virtual error_code handshake (handshake_type type, error_code& ec)
-        BEAST_SOCKET_VIRTUAL;
-
-    virtual void async_handshake (handshake_type type, error_handler handler)
-        BEAST_SOCKET_VIRTUAL;
-
-    //--------------------------------------------------------------------------
-
-    virtual error_code handshake (handshake_type type,
-        const_buffers buffers, error_code& ec)
-        BEAST_SOCKET_VIRTUAL;
-
-    virtual void async_handshake (handshake_type type,
-        const_buffers buffers, transfer_handler handler)
-        BEAST_SOCKET_VIRTUAL;
-
-    //--------------------------------------------------------------------------
-
-    void shutdown ()
-    {
-        error_code ec;
-        shutdown (ec);
-        throw_if (ec);
-    }
-
-    virtual error_code shutdown (error_code& ec)
-        BEAST_SOCKET_VIRTUAL;
-
-    virtual void async_shutdown (error_handler handler)
-        BEAST_SOCKET_VIRTUAL;
-};
-
-}
-}
-
-#endif

src/beast/beast/asio/buffer_sequence.h

@@ -1,126 +0,0 @@
-//------------------------------------------------------------------------------
-/*
-    This file is part of Beast: https://github.com/vinniefalco/Beast
-    Copyright 2013, Vinnie Falco <vinnie.falco@gmail.com>
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose  with  or without fee is hereby granted, provided that the above
-    copyright notice and this permission notice appear in all copies.
-
-    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
-    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
-    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-*/
-//==============================================================================
-
-#ifndef BEAST_ASIO_BUFFER_SEQUENCE_H_INCLUDED
-#define BEAST_ASIO_BUFFER_SEQUENCE_H_INCLUDED
-
-#include <boost/asio/buffer.hpp>
-
-#include <beast/utility/noexcept.h>
-#include <algorithm>
-#include <iterator>
-#include <beast/cxx14/type_traits.h> // <type_traits>
-#include <vector>
-
-namespace beast {
-namespace asio {
-
-template <class Buffer>
-class buffer_sequence
-{
-private:
-    typedef std::vector <Buffer> sequence_type;
-
-public:
-    typedef Buffer value_type;
-    typedef typename sequence_type::const_iterator const_iterator;
-
-private:
-    sequence_type m_buffers;
-
-    template <class FwdIter>
-    void assign (FwdIter first, FwdIter last)
-    {
-        m_buffers.clear();
-        m_buffers.reserve (std::distance (first, last));
-        for (;first != last; ++first)
-            m_buffers.push_back (*first);
-    }
-
-public:
-    buffer_sequence ()
-    {
-    }
-
-    template <
-        class BufferSequence,
-        class = std::enable_if_t <std::is_constructible <
-            Buffer, typename BufferSequence::value_type>::value>
-    >
-    buffer_sequence (BufferSequence const& s)
-    {
-        assign (std::begin (s), std::end (s));
-    }
-
-    template <
-        class FwdIter,
-        class = std::enable_if_t <std::is_constructible <
-            Buffer, typename std::iterator_traits <
-            FwdIter>::value_type>::value>
-    >
-    buffer_sequence (FwdIter first, FwdIter last)
-    {
-        assign (first, last);
-    }
-
-    template <class BufferSequence>
-    std::enable_if_t <std::is_constructible <
-        Buffer, typename BufferSequence::value_type>::value,
-        buffer_sequence&
-    >
-    operator= (BufferSequence const& s)
-    {
-        return assign (s);
-    }
-
-    const_iterator
-    begin () const noexcept
-    {
-        return m_buffers.begin ();
-    }
-
-    const_iterator
-    end () const noexcept
-    {
-        return m_buffers.end ();
-    }
-
-#if 0
-    template <class ConstBufferSequence>
-    void
-    assign (ConstBufferSequence const& buffers)
-    {
-        auto const n (std::distance (
-            std::begin (buffers), std::end (buffers)));
-
-        for (int i = 0, auto iter (std::begin (buffers));
-            iter != std::end (buffers); ++iter, ++i)
-            m_buffers[i] = Buffer (boost::asio::buffer_cast <void*> (
-                *iter), boost::asio::buffer_size (*iter));
-    }
-#endif
-};
-
-typedef buffer_sequence <boost::asio::const_buffer> const_buffers;
-typedef buffer_sequence <boost::asio::mutable_buffer> mutable_buffers;
-
-}
-}
-
-#endif

src/beast/beast/asio/enable_wait_for_async.h

@@ -1,265 +0,0 @@
-//------------------------------------------------------------------------------
-/*
-    This file is part of Beast: https://github.com/vinniefalco/Beast
-    Copyright 2013, Vinnie Falco <vinnie.falco@gmail.com>
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose  with  or without fee is hereby granted, provided that the above
-    copyright notice and this permission notice appear in all copies.
-
-    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
-    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
-    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-*/
-//==============================================================================
-
-#ifndef BEAST_ASIO_ENABLE_WAIT_FOR_ASYNC_H_INCLUDED
-#define BEAST_ASIO_ENABLE_WAIT_FOR_ASYNC_H_INCLUDED
-
-#include <beast/asio/wrap_handler.h>
-
-#include <beast/utility/is_call_possible.h>
-
-#include <boost/asio/detail/handler_alloc_helpers.hpp>
-#include <boost/asio/detail/handler_cont_helpers.hpp>
-#include <boost/asio/detail/handler_invoke_helpers.hpp>
-
-#include <atomic>
-#include <condition_variable>
-#include <mutex>
-#include <beast/cxx14/type_traits.h> // <type_traits>
-
-namespace beast {
-namespace asio {
-
-namespace detail {
-
-template <class Owner, class Handler>
-class ref_counted_wrapped_handler
-{
-private:
-    static_assert (std::is_same <std::decay_t <Owner>, Owner>::value,
-        "Owner cannot be a const or reference type");
-
-    Handler m_handler;
-    std::reference_wrapper <Owner> m_owner;
-    bool m_continuation;
-
-public:
-    ref_counted_wrapped_handler (Owner& owner,
-        Handler&& handler, bool continuation)
-        : m_handler (std::move (handler))
-        , m_owner (owner)
-        , m_continuation (continuation ? true :
-            boost_asio_handler_cont_helpers::is_continuation (m_handler))
-    {
-        m_owner.get().increment();
-    }
-
-    ref_counted_wrapped_handler (Owner& owner,
-        Handler const& handler, bool continuation)
-        : m_handler (handler)
-        , m_owner (owner)
-        , m_continuation (continuation ? true :
-            boost_asio_handler_cont_helpers::is_continuation (m_handler))
-    {
-        m_owner.get().increment();
-    }
-
-    ~ref_counted_wrapped_handler ()
-    {
-        m_owner.get().decrement();
-    }
-
-    ref_counted_wrapped_handler (ref_counted_wrapped_handler const& other)
-        : m_handler (other.m_handler)
-        , m_owner (other.m_owner)
-        , m_continuation (other.m_continuation)
-    {
-        m_owner.get().increment();
-    }
-
-    ref_counted_wrapped_handler (ref_counted_wrapped_handler&& other)
-        : m_handler (std::move (other.m_handler))
-        , m_owner (other.m_owner)
-        , m_continuation (other.m_continuation)
-    {
-        m_owner.get().increment();
-    }
-
-    ref_counted_wrapped_handler& operator= (
-        ref_counted_wrapped_handler const&) = delete;
-
-    template <class... Args>
-    void
-    operator() (Args&&... args)
-    {
-        m_handler (std::forward <Args> (args)...);
-    }
-
-    template <class... Args>
-    void
-    operator() (Args&&... args) const
-    {
-        m_handler (std::forward <Args> (args)...);
-    }
-
-    template <class Function>
-    friend
-    void
-    asio_handler_invoke (Function& f,
-        ref_counted_wrapped_handler* h)
-    {
-        boost_asio_handler_invoke_helpers::
-            invoke (f, h->m_handler);
-    }
-
-    template <class Function>
-    friend
-    void
-    asio_handler_invoke (Function const& f,
-        ref_counted_wrapped_handler* h)
-    {
-        boost_asio_handler_invoke_helpers::
-            invoke (f, h->m_handler);
-    }
-
-    friend
-    void*
-    asio_handler_allocate (std::size_t size,
-        ref_counted_wrapped_handler* h)
-    {
-        return boost_asio_handler_alloc_helpers::
-            allocate (size, h->m_handler);
-    }
-
-    friend
-    void
-    asio_handler_deallocate (void* p, std::size_t size,
-        ref_counted_wrapped_handler* h)
-    {
-        boost_asio_handler_alloc_helpers::
-            deallocate (p, size, h->m_handler);
-    }
-
-    friend
-    bool
-    asio_handler_is_continuation (ref_counted_wrapped_handler* h)
-    {
-        return h->m_continuation;
-    }
-};
-
-}
-
-//------------------------------------------------------------------------------
-
-/** Facilitates blocking until no completion handlers are remaining.
-    If Derived has this member function:
-
-    @code
-        void on_wait_for_async (void)
-    @endcode
-
-    Then it will be called every time the number of pending completion
-    handlers transitions to zero from a non-zero value. The call is made
-    while holding the internal mutex.
-*/
-template <class Derived>
-class enable_wait_for_async
-{
-private:
-    BEAST_DEFINE_IS_CALL_POSSIBLE(
-        has_on_wait_for_async,on_wait_for_async);
-
-    void increment()
-    {
-        std::lock_guard <decltype(m_mutex)> lock (m_mutex);
-        ++m_count;
-    }
-
-    void notify (std::true_type)
-    {
-        static_cast <Derived*> (this)->on_wait_for_async();
-    }
-
-    void notify (std::false_type)
-    {
-    }
-
-    void decrement()
-    {
-        std::lock_guard <decltype(m_mutex)> lock (m_mutex);
-        --m_count;
-        if (m_count == 0)
-        {
-            m_cond.notify_all();
-            notify (std::integral_constant <bool,
-                has_on_wait_for_async<Derived, void(void)>::value>());
-        }
-    }
-
-    template <class Owner, class Handler>
-    friend class detail::ref_counted_wrapped_handler;
-
-    std::mutex m_mutex;
-    std::condition_variable m_cond;
-    std::size_t m_count;
-
-public:
-    /** Blocks if there are any pending completion handlers. */
-    void
-    wait_for_async()
-    {
-        std::unique_lock <decltype (m_mutex)> lock (m_mutex);
-        while (m_count != 0)
-            m_cond.wait (lock);
-    }
-
-protected:
-    enable_wait_for_async()
-        : m_count (0)
-    {
-    }
-
-    ~enable_wait_for_async()
-    {
-        assert (m_count == 0);
-    }
-
-    /** Wraps the specified handler so it can be counted. */
-    /** @{ */
-    template <class Handler>
-    detail::ref_counted_wrapped_handler <
-        enable_wait_for_async,
-        std::remove_reference_t <Handler>
-    >
-    wrap_with_counter (Handler&& handler, bool continuation = false)
-    {
-        return detail::ref_counted_wrapped_handler <enable_wait_for_async,
-            std::remove_reference_t <Handler>> (*this,
-                std::forward <Handler> (handler), continuation);
-    }
-
-    template <class Handler>
-    detail::ref_counted_wrapped_handler <
-        enable_wait_for_async,
-        std::remove_reference_t <Handler>
-    >
-    wrap_with_counter (continuation_t, Handler&& handler)
-    {
-        return detail::ref_counted_wrapped_handler <enable_wait_for_async,
-            std::remove_reference_t <Handler>> (*this,
-                std::forward <Handler> (handler), true);
-    }
-    /** @} */
-};
-
-}
-}
-
-#endif

src/beast/beast/asio/error.h

@@ -0,0 +1,45 @@
+//------------------------------------------------------------------------------
+/*
+    This file is part of Beast: https://github.com/vinniefalco/Beast
+    Copyright 2013, Vinnie Falco <vinnie.falco@gmail.com>
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose  with  or without fee is hereby granted, provided that the above
+    copyright notice and this permission notice appear in all copies.
+
+    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
+    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
+    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+//==============================================================================
+
+#ifndef BEAST_ASIO_ERROR_H_INCLUDED
+#define BEAST_ASIO_ERROR_H_INCLUDED
+
+#include <boost/asio.hpp>
+#include <boost/asio/ssl/error.hpp>
+
+namespace beast {
+namespace asio {
+
+/** Returns `true` if the error code is a SSL "short read." */
+inline
+bool
+is_short_read (boost::system::error_code const& ec)
+{
+    return (ec.category() == boost::asio::error::get_ssl_category())
+        && (ERR_GET_REASON(ec.value()) == SSL_R_SHORT_READ);
+}
+    
+/** Returns a human readable message if the error code is SSL related. */
+std::string
+asio_message(boost::system::error_code const& ec);
+
+}
+}
+
+#endif

src/beast/beast/asio/impl/error.cpp

@@ -0,0 +1,59 @@
+//------------------------------------------------------------------------------
+/*
+    This file is part of Beast: https://github.com/vinniefalco/Beast
+    Copyright 2013, Vinnie Falco <vinnie.falco@gmail.com>
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose  with  or without fee is hereby granted, provided that the above
+    copyright notice and this permission notice appear in all copies.
+
+    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
+    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
+    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+//==============================================================================
+
+#include <beast/asio/error.h>
+#include <boost/lexical_cast.hpp>
+
+namespace beast {
+namespace asio {
+
+// This buffer must be at least 120 bytes, most examples use 256.
+// https://www.openssl.org/docs/crypto/ERR_error_string.html
+static std::uint32_t const errorBufferSize (256);
+
+std::string
+asio_message (boost::system::error_code const& ec)
+{
+    std::string error;
+
+    if (ec.category () == boost::asio::error::get_ssl_category ())
+    {
+        error = " ("
+            + boost::lexical_cast<std::string> (ERR_GET_LIB (ec.value ()))
+            + ","
+            + boost::lexical_cast<std::string> (ERR_GET_FUNC (ec.value ()))
+            + ","
+            + boost::lexical_cast<std::string> (ERR_GET_REASON (ec.value ()))
+            + ") ";
+        
+        // 
+        char buf[errorBufferSize];
+        ::ERR_error_string_n (ec.value (), buf, errorBufferSize);
+        error += buf;
+    }
+    else
+    {
+        error = ec.message ();
+    }
+
+    return error;
+}
+
+}
+}

src/beast/beast/asio/memory_buffer.h

@@ -1,426 +0,0 @@
-//------------------------------------------------------------------------------
-/*
-    This file is part of Beast: https://github.com/vinniefalco/Beast
-    Copyright 2013, Vinnie Falco <vinnie.falco@gmail.com>
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose  with  or without fee is hereby granted, provided that the above
-    copyright notice and this permission notice appear in all copies.
-
-    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
-    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
-    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-*/
-//==============================================================================
-
-#ifndef BEAST_ASIO_MEMORY_BUFFER_H_INCLUDED
-#define BEAST_ASIO_MEMORY_BUFFER_H_INCLUDED
-
-#include <beast/utility/empty_base_optimization.h>
-
-#include <boost/asio/buffer.hpp>
-
-#include <beast/utility/noexcept.h>
-#include <cstddef>
-#include <memory>
-#include <type_traits>
-
-namespace beast {
-namespace asio {
-
-template <
-    class T,
-    class Alloc = std::allocator <T>
->
-class memory_buffer
-    : private empty_base_optimization <Alloc>
-{
-private:
-    static_assert (std::is_same <char, T>::value ||
-                   std::is_same <unsigned char, T>::value,
-        "memory_buffer only works with char and unsigned char");
-
-    typedef empty_base_optimization <Alloc> Base;
-
-    using AllocTraits = std::allocator_traits <Alloc>;
-
-    T* m_base;
-    std::size_t m_size;
-
-public:
-    typedef std::size_t size_type;
-    typedef std::ptrdiff_t difference_type;
-    typedef T& reference;
-    typedef T const& const_reference;
-    typedef T* pointer;
-    typedef T const* const_pointer;
-    typedef Alloc allocator_type;
-    typedef T* iterator;
-    typedef T const* const_iterator;
-    typedef std::reverse_iterator <iterator> reverse_iterator;
-    typedef std::reverse_iterator <const_iterator> const_reverse_iterator;
-
-    memory_buffer ()
-        : m_base (nullptr)
-        , m_size (0)
-    {
-    }
-
-    memory_buffer (memory_buffer&& other)
-        : Base (std::move (other))
-        , m_base (other.m_base)
-        , m_size (other.m_size)
-    {
-        other.m_base = nullptr;
-        other.m_size = 0;
-    }
-
-    explicit memory_buffer (size_type n)
-        : m_base (AllocTraits::allocate (Base::member(), n))
-        , m_size (n)
-    {
-    }
-
-    explicit memory_buffer (Alloc const& alloc)
-        : Base (alloc)
-        , m_base (nullptr)
-        , m_size (0)
-    {
-    }
-
-    memory_buffer (size_type n, Alloc const& alloc)
-        : Base (alloc)
-        , m_base (AllocTraits::allocate (Base::member(), n))
-        , m_size (n)
-    {
-    }
-
-    ~memory_buffer()
-    {
-        if (m_base != nullptr)
-            AllocTraits::deallocate (Base::member(), m_base, m_size);
-    }
-
-    memory_buffer& operator= (memory_buffer const&) = delete;
-
-    allocator_type
-    get_allocator() const
-    {
-        return Base::member;
-    }
-
-    //
-    // asio support
-    //
-
-    boost::asio::mutable_buffer
-    buffer()
-    {
-        return boost::asio::mutable_buffer (
-            data(), bytes());
-    }
-
-    boost::asio::const_buffer
-    buffer() const
-    {
-        return boost::asio::const_buffer (
-            data(), bytes());
-    }
-
-    boost::asio::mutable_buffers_1
-    buffers()
-    {
-        return boost::asio::mutable_buffers_1 (
-            data(), bytes());
-    }
-
-    boost::asio::const_buffers_1
-    buffers() const
-    {
-        return boost::asio::const_buffers_1 (
-            data(), bytes());
-    }
-
-    operator boost::asio::mutable_buffer()
-    {
-        return buffer();
-    }
-
-    operator boost::asio::const_buffer() const
-    {
-        return buffer();
-    }
-
-    operator boost::asio::mutable_buffers_1()
-    {
-        return buffers();
-    }
-
-    operator boost::asio::const_buffers_1() const
-    {
-        return buffers();
-    }
-
-    //
-    // Element access
-    //
-
-    reference
-    at (size_type pos)
-    {
-        if (! (pos < size()))
-            throw std::out_of_range ("bad array index");
-        return m_base [pos];
-    }
-
-    const_reference
-    at (size_type pos) const
-    {
-        if (! (pos < size()))
-            throw std::out_of_range ("bad array index");
-        return m_base [pos];
-    }
-
-    reference
-    operator[] (size_type pos) noexcept
-    {
-        return m_base [pos];
-    }
-
-    const_reference
-    operator[] (size_type pos) const noexcept
-    {
-        return m_base [pos];
-    }
-
-    reference
-    back() noexcept
-    {
-        return m_base [m_size - 1];
-    }
-
-    const_reference
-    back() const noexcept
-    {
-        return m_base [m_size - 1];
-    }
-
-    reference
-    front() noexcept
-    {
-        return *m_base;
-    }
-
-    const_reference
-    front() const noexcept
-    {
-        return *m_base;
-    }
-
-    pointer
-    data() noexcept
-    {
-        return m_base;
-    }
-
-    const_pointer
-    data() const noexcept
-    {
-        return m_base;
-    }
-
-    //
-    // Iterators
-    //
-
-    iterator
-    begin() noexcept
-    {
-        return m_base;
-    }
-
-    const_iterator
-    begin() const noexcept
-    {
-        return m_base;
-    }
-
-    const_iterator
-    cbegin() const noexcept
-    {
-        return m_base;
-    }
-
-    iterator
-    end() noexcept
-    {
-        return m_base + m_size;
-    }
-
-    const_iterator
-    end() const noexcept
-    {
-        return m_base + m_size;
-    }
-
-    const_iterator
-    cend() const noexcept
-    {
-        return m_base + m_size;
-    }
-
-    reverse_iterator
-    rbegin() noexcept
-    {
-        return reverse_iterator (end());
-    }
-
-    const_reverse_iterator
-    rbegin() const noexcept
-    {
-        return const_reverse_iterator (cend());
-    }
-
-    const_reverse_iterator
-    crbegin() const noexcept
-    {
-        return const_reverse_iterator (cend());
-    }
-
-    reverse_iterator
-    rend() noexcept
-    {
-        return reverse_iterator (begin());
-    }
-
-    const_reverse_iterator
-    rend() const noexcept
-    {
-        return const_reverse_iterator (cbegin());
-    }
-
-    const_reverse_iterator
-    crend() const noexcept
-    {
-        return const_reverse_iterator (cbegin());
-    }
-
-    //
-    // Capacity
-    //
-
-    bool
-    empty() const noexcept
-    {
-        return m_size == 0;
-    }
-
-    size_type
-    size() const noexcept
-    {
-        return m_size;
-    }
-
-    size_type
-    max_size() const noexcept
-    {
-        return size();
-    }
-
-    size_type
-    capacity() const noexcept
-    {
-        return size();
-    }
-
-    size_type bytes() const
-    {
-        return m_size * sizeof(T);
-    }
-
-    //
-    // Modifiers
-    //
-
-    template <class U, class A>
-    friend
-    void
-    swap (memory_buffer <U, A>& lhs,
-        memory_buffer <U, A>& rhs) noexcept;
-};
-
-//------------------------------------------------------------------------------
-
-template <class T, class Alloc>
-void
-swap (memory_buffer <T, Alloc>& lhs,
-    memory_buffer <T, Alloc>& rhs) noexcept
-{
-    std::swap (lhs.m_base, rhs.m_base);
-    std::swap (lhs.m_size, rhs.m_size);
-}
-
-template <class T, class A1, class A2>
-inline
-bool
-operator== (memory_buffer <T, A1> const& lhs,
-            memory_buffer <T, A2> const& rhs)
-{
-    return std::equal (lhs.cbegin(), lhs.cend(),
-        rhs.cbegin(), rhs.cend());
-}
-
-template <class T, class A1, class A2>
-inline
-bool
-operator!= (memory_buffer <T, A1> const& lhs,
-            memory_buffer <T, A2> const& rhs)
-{
-    return ! (lhs == rhs);
-}
-
-template <class T, class A1, class A2>
-inline
-bool
-operator< (memory_buffer <T, A1> const& lhs,
-           memory_buffer <T, A2> const& rhs)
-{
-    return std::lexicographical_compare (
-        lhs.cbegin(), lhs.cend(), rhs.cbegin(), rhs.cend());
-}
-
-template <class T, class A1, class A2>
-inline
-bool
-operator>= (memory_buffer <T, A1> const& lhs,
-            memory_buffer <T, A2> const& rhs)
-{
-    return ! (lhs < rhs);
-}
-
-template <class T, class A1, class A2>
-inline
-bool
-operator> (memory_buffer <T, A1> const& lhs,
-           memory_buffer <T, A2> const& rhs)
-{
-    return rhs < lhs;
-}
-
-template <class T, class A1, class A2>
-inline
-bool
-operator<= (memory_buffer <T, A1> const& lhs,
-            memory_buffer <T, A2> const& rhs)
-{
-    return ! (rhs < lhs);
-}
-
-}
-}
-
-#endif

src/beast/beast/asio/shared_handler.h

@@ -1,475 +0,0 @@
-//------------------------------------------------------------------------------
-/*
-    This file is part of Beast: https://github.com/vinniefalco/Beast
-    Copyright 2013, Vinnie Falco <vinnie.falco@gmail.com>
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose  with  or without fee is hereby granted, provided that the above
-    copyright notice and this permission notice appear in all copies.
-
-    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
-    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
-    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-*/
-//==============================================================================
-
-#ifndef BEAST_ASIO_SHARED_HANDLER_H_INCLUDED
-#define BEAST_ASIO_SHARED_HANDLER_H_INCLUDED
-
-#include <beast/Config.h>
-
-#include <beast/utility/is_call_possible.h>
-
-#include <boost/utility/base_from_member.hpp>
-#include <boost/asio/detail/handler_alloc_helpers.hpp>
-#include <boost/asio/detail/handler_cont_helpers.hpp>
-#include <boost/asio/detail/handler_invoke_helpers.hpp>
-
-#include <beast/utility/noexcept.h>
-#include <functional>
-#include <memory>
-#include <beast/cxx14/type_traits.h> // <type_traits>
-
-#ifndef BEAST_ASIO_NO_ALLOCATE_SHARED
-#define BEAST_ASIO_NO_ALLOCATE_SHARED 0
-#endif
-
-#ifndef BEAST_ASIO_NO_HANDLER_RESULT_OF
-#define BEAST_ASIO_NO_HANDLER_RESULT_OF 1
-#endif
-
-namespace beast {
-namespace asio {
-
-class shared_handler_wrapper_base
-{
-public:
-    virtual ~shared_handler_wrapper_base()
-    {
-    }
-
-    virtual void invoke (std::function <void (void)> f) = 0;
-    virtual void* allocate (std::size_t size) = 0;
-    virtual void deallocate (void* p, std::size_t size) = 0;
-    virtual bool is_continuation () = 0;
-};
-
-//------------------------------------------------------------------------------
-
-template <class Signature>
-class shared_handler_wrapper_func
-    : public shared_handler_wrapper_base
-{
-private:
-    std::function <Signature> m_func;
-
-public:
-    template <class Handler>
-    explicit shared_handler_wrapper_func (Handler&& handler)
-        : m_func (std::ref (std::forward <Handler> (handler)))
-    {
-    }
-
-    template <class... Args>
-#if BEAST_ASIO_NO_HANDLER_RESULT_OF
-    void
-#else
-    std::result_of_t <std::function <Signature> (Args...)>
-#endif
-    operator() (Args&&... args) const
-    {
-        return m_func (std::forward <Args> (args)...);
-    }
-};
-
-//------------------------------------------------------------------------------
-
-namespace detail {
-
-#ifdef _MSC_VER
-#pragma warning (push)
-#pragma warning (disable: 4512) // assignment operator could not be generated
-#endif
-
-template <class Signature, class Handler>
-class shared_handler_wrapper
-    : private boost::base_from_member <Handler>
-    , public shared_handler_wrapper_func <Signature>
-{
-private:
-    typedef boost::base_from_member <Handler> Base;
-
-    BEAST_DEFINE_IS_CALL_POSSIBLE(has_is_continuation, is_continuation);
-
-public:
-    shared_handler_wrapper (Handler&& handler)
-        : boost::base_from_member <Handler> (std::move (handler))
-        , shared_handler_wrapper_func <Signature> (Base::member)
-    {
-    }
-
-    shared_handler_wrapper (Handler const& handler)
-        : boost::base_from_member <Handler> (handler)
-        , shared_handler_wrapper_func <Signature> (Base::member)
-    {
-    }
-
-private:
-    void
-    invoke (std::function <void (void)> f) override
-    {
-        return boost_asio_handler_invoke_helpers::
-            invoke (f, Base::member);
-    }
-
-    void*
-    allocate (std::size_t size) override
-    {
-        return boost_asio_handler_alloc_helpers::
-            allocate (size, Base::member);
-    }
-
-    void
-    deallocate (void* p, std::size_t size) override
-    {
-        boost_asio_handler_alloc_helpers::
-            deallocate (p, size, Base::member);
-    }
-
-    bool
-    is_continuation () override
-    {
-        return is_continuation (std::integral_constant <bool,
-            has_is_continuation <Handler, bool(void)>::value>());
-    }
-
-    bool
-    is_continuation (std::true_type)
-    {
-        return Base::member.is_continuation();
-    }
-
-    bool
-    is_continuation (std::false_type)
-    {
-        return boost_asio_handler_cont_helpers::
-            is_continuation (Base::member);
-    }
-};
-
-#ifdef _MSC_VER
-#pragma warning (pop)
-#endif
-
-template <class T>
-struct is_shared_handler : public std::false_type
-{
-};
-
-//------------------------------------------------------------------------------
-
-template <class T, class Handler>
-class handler_allocator
-{
-private:
-    // We want a partial template specialization as a friend
-    // but that isn't allowed so we friend all versions. This
-    // should produce a compile error if Handler is not constructible
-    // from H.
-    //
-    template <class U, class H>
-    friend class handler_allocator;
-
-    Handler m_handler;
-
-public:
-    typedef T value_type;
-    typedef T* pointer;
-
-    template <class U>
-    struct rebind
-    {
-    public:
-        typedef handler_allocator <U, Handler> other;
-    };
-
-    handler_allocator() = delete;
-
-    handler_allocator (Handler const& handler)
-        : m_handler (handler)
-    {
-    }
-
-    template <class U>
-    handler_allocator (
-        handler_allocator <U, Handler> const& other)
-        : m_handler (other.m_handler)
-    {
-    }
-
-    handler_allocator&
-    operator= (handler_allocator const&) = delete;
-
-    pointer
-    allocate (std::ptrdiff_t n)
-    {
-        auto const size (n * sizeof (T));
-        return static_cast <pointer> (
-            boost_asio_handler_alloc_helpers::allocate (
-                size, m_handler));
-    }
-
-    void
-    deallocate (pointer p, std::ptrdiff_t n)
-    {
-        auto const size (n * sizeof (T));
-        boost_asio_handler_alloc_helpers::deallocate (
-            p, size, m_handler);
-    }
-
-    // Work-around for MSVC not using allocator_traits
-    // in the implementation of shared_ptr
-    //
-#ifdef _MSC_VER
-    void
-    destroy (T* t)
-    {
-        t->~T();
-    }
-#endif
-
-    friend
-    bool
-    operator== (handler_allocator const& lhs, handler_allocator const& rhs)
-    {
-        return true;
-    }
-
-    friend
-    bool
-    operator!= (handler_allocator const& lhs, handler_allocator const& rhs)
-    {
-        return ! (lhs == rhs);
-    }
-};
-
-}
-
-//------------------------------------------------------------------------------
-
-/** Handler shared reference that provides io_service execution guarantees. */
-template <class Signature>
-class shared_handler
-{
-private:
-    template <class T>
-    friend class shared_handler_allocator;
-
-    typedef shared_handler_wrapper_func <
-        Signature> wrapper_type;
-
-    typedef std::shared_ptr <wrapper_type> ptr_type;
-
-    ptr_type m_ptr;
-
-public:
-    shared_handler()
-    {
-    }
-
-    template <
-        class DeducedHandler,
-        class = std::enable_if_t <
-            ! detail::is_shared_handler <
-                std::decay_t <DeducedHandler>>::value &&
-            std::is_constructible <std::function <Signature>,
-                std::decay_t <DeducedHandler>>::value
-            >
-    >
-    shared_handler (DeducedHandler&& handler)
-    {
-        typedef std::remove_reference_t <DeducedHandler> Handler;
-
-    #if BEAST_ASIO_NO_ALLOCATE_SHARED
-        m_ptr = std::make_shared <detail::shared_handler_wrapper <
-            Signature, Handler>> (std::forward <DeducedHandler> (handler));
-    #else
-        m_ptr = std::allocate_shared <detail::shared_handler_wrapper <
-            Signature, Handler>> (detail::handler_allocator <char, Handler> (
-                handler), std::forward <DeducedHandler> (handler));
-    #endif
-    }
-
-    shared_handler (shared_handler&& other)
-        : m_ptr (std::move (other.m_ptr))
-    {
-    }
-
-    shared_handler (shared_handler const& other)
-        : m_ptr (other.m_ptr)
-    {
-    }
-
-    shared_handler&
-    operator= (std::nullptr_t)
-    {
-        m_ptr = nullptr;
-        return *this;
-    }
-
-    shared_handler&
-    operator= (shared_handler const& rhs)
-    {
-        m_ptr = rhs.m_ptr;
-        return *this;
-    }
-
-    shared_handler&
-    operator= (shared_handler&& rhs)
-    {
-        m_ptr = std::move (rhs.m_ptr);
-        return *this;
-    }
-
-    explicit
-    operator bool() const noexcept
-    {
-        return m_ptr.operator bool();
-    }
-
-    void
-    reset()
-    {
-        m_ptr.reset();
-    }
-
-    template <class... Args>
-#if BEAST_ASIO_NO_HANDLER_RESULT_OF
-    void
-#else
-    std::result_of_t <std::function <Signature> (Args...)>
-#endif
-    operator() (Args&&... args) const
-    {
-        return (*m_ptr)(std::forward <Args> (args)...);
-    }
-
-    template <class Function>
-    friend
-    void
-    asio_handler_invoke (Function&& f, shared_handler* h)
-    {
-        return h->m_ptr->invoke (f);
-    }
-
-    friend
-    void*
-    asio_handler_allocate (
-        std::size_t size, shared_handler* h)
-    {
-        return h->m_ptr->allocate (size);
-    }
-
-    friend
-    void
-    asio_handler_deallocate (
-        void* p, std::size_t size, shared_handler* h)
-    {
-        return h->m_ptr->deallocate (p, size);
-    }
-
-    friend
-    bool
-    asio_handler_is_continuation (
-        shared_handler* h)
-    {
-        return h->m_ptr->is_continuation ();
-    }
-};
-
-//------------------------------------------------------------------------------
-
-namespace detail {
-
-template <
-    class Signature
->
-struct is_shared_handler <
-    shared_handler <Signature>
-> : public std::true_type
-{
-};
-
-}
-
-//------------------------------------------------------------------------------
-
-template <class T>
-class shared_handler_allocator
-{
-private:
-    template <class U>
-    friend class shared_handler_allocator;
-
-    std::shared_ptr <shared_handler_wrapper_base> m_ptr;
-
-public:
-    typedef T value_type;
-    typedef T* pointer;
-
-    shared_handler_allocator() = delete;
-
-    template <class Signature>
-    shared_handler_allocator (
-        shared_handler <Signature> const& handler)
-        : m_ptr (handler.m_ptr)
-    {
-    }
-
-    template <class U>
-    shared_handler_allocator (
-        shared_handler_allocator <U> const& other)
-        : m_ptr (other.m_ptr)
-    {
-    }
-
-    pointer
-    allocate (std::ptrdiff_t n)
-    {
-        auto const size (n * sizeof (T));
-        return static_cast <pointer> (
-            m_ptr->allocate (size));
-    }
-
-    void
-    deallocate (pointer p, std::ptrdiff_t n)
-    {
-        auto const size (n * sizeof (T));
-        m_ptr->deallocate (p, size);
-    }
-
-    friend
-    bool
-    operator== (shared_handler_allocator const& lhs,
-        shared_handler_allocator const& rhs)
-    {
-        return lhs.m_ptr == rhs.m_ptr;
-    }
-
-    friend
-    bool
-    operator!= (shared_handler_allocator const& lhs,
-        shared_handler_allocator const& rhs)
-    {
-        return ! (lhs == rhs);
-    }
-};
-
-}
-}
-
-#endif

src/beast/beast/asio/socket_wrapper.h

@@ -1,826 +0,0 @@
-//------------------------------------------------------------------------------
-/*
-    This file is part of Beast: https://github.com/vinniefalco/Beast
-    Copyright 2013, Vinnie Falco <vinnie.falco@gmail.com>
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose  with  or without fee is hereby granted, provided that the above
-    copyright notice and this permission notice appear in all copies.
-
-    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
-    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
-    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-*/
-//==============================================================================
-
-#ifndef BEAST_ASIO_SOCKET_WRAPPER_H_INCLUDED
-#define BEAST_ASIO_SOCKET_WRAPPER_H_INCLUDED
-
-#include <beast/asio/abstract_socket.h>
-#include <beast/asio/bind_handler.h>
-
-#include <beast/utility/noexcept.h>
-
-namespace beast {
-namespace asio {
-
-/** Wraps a reference to any object and exports all availble interfaces.
-
-    If the object does not support an interface, calling those
-    member functions will behave as if a pure virtual was called.
-
-    Note that only a reference to the underlying is stored. Management
-    of the lifetime of the object is controlled by the caller.
-
-    Examples of the type of Object:
-
-    asio::ip::tcp::socket
-    asio::ip::tcp::socket&
-    asio::ssl::stream <asio::ip::tcp::socket>
-    asio::ssl::stream <asio::ip::tcp::socket&>
-        explain arg must be an io_context
-        explain socket_wrapper will create and take ownership of the tcp::socket
-        explain this_layer_type will be tcp::socket
-        explain next_layer () returns a asio::ip::tcp::socket&
-        explain lowest_layer () returns a asio::ip::tcp::socket&
-
-    asio::ssl::stream <asio::buffered_stream <asio::ip::tcp::socket> > >
-        This makes my head explode
-*/
-template <typename Object>
-class socket_wrapper : public abstract_socket
-{
-private:
-    Object m_object;
-
-public:
-    template <class... Args>
-    explicit socket_wrapper (Args&&... args)
-        : m_object (std::forward <Args> (args)...)
-    {
-    }
-
-    socket_wrapper (socket_wrapper const&) = delete;
-    socket_wrapper& operator= (socket_wrapper const&) = delete;
-
-    //--------------------------------------------------------------------------
-    //
-    // socket_wrapper
-    //
-    //--------------------------------------------------------------------------
-
-    /** The type of the object being wrapped. */
-    typedef typename boost::remove_reference <Object>::type this_layer_type;
-
-    /** Get a reference to this layer. */
-    this_layer_type& this_layer () noexcept
-    {
-        return m_object;
-    }
-
-    /** Get a const reference to this layer. */
-    this_layer_type const& this_layer () const noexcept
-    {
-        return m_object;
-    }
-
-    //--------------------------------------------------------------------------
-    //
-    // abstract_socket
-    //
-    //--------------------------------------------------------------------------
-
-    void* this_layer_ptr (char const* type_name) const override
-    {
-        char const* const name (typeid (this_layer_type).name ());
-        if (strcmp (name, type_name) == 0)
-            return const_cast <void*> (static_cast <void const*> (&m_object));
-        return nullptr;
-    }
-
-private:
-    BEAST_DEFINE_IS_CALL_POSSIBLE(has_get_io_service, get_io_service);
-
-    BEAST_DEFINE_IS_CALL_POSSIBLE(has_lowest_layer, lowest_layer);
-    BEAST_DEFINE_IS_CALL_POSSIBLE(has_cancel, cancel);
-    BEAST_DEFINE_IS_CALL_POSSIBLE(has_shutdown, shutdown);
-    BEAST_DEFINE_IS_CALL_POSSIBLE(has_close, close);
-
-    BEAST_DEFINE_IS_CALL_POSSIBLE(has_accept, accept);
-    BEAST_DEFINE_IS_CALL_POSSIBLE(has_async_accept, async_accept);
-
-    BEAST_DEFINE_IS_CALL_POSSIBLE(has_read_some, read_some);
-    BEAST_DEFINE_IS_CALL_POSSIBLE(has_write_some, write_some);
-    BEAST_DEFINE_IS_CALL_POSSIBLE(has_async_read_some, async_read_some);
-    BEAST_DEFINE_IS_CALL_POSSIBLE(has_async_write_some, async_write_some);
-
-    BEAST_DEFINE_IS_CALL_POSSIBLE(has_set_verify_mode, set_verify_mode);
-    BEAST_DEFINE_IS_CALL_POSSIBLE(has_handshake, handshake);
-    BEAST_DEFINE_IS_CALL_POSSIBLE(has_async_handshake, async_handshake);
-    BEAST_DEFINE_IS_CALL_POSSIBLE(has_async_shutdown, async_shutdown);
-
-    //--------------------------------------------------------------------------
-    //
-    // Implementation
-    //
-    //--------------------------------------------------------------------------
-
-    template <class Cond>
-    struct Enabled : public std::integral_constant <bool, Cond::value>
-    {
-    };
-
-    //--------------------------------------------------------------------------
-    //
-    // native_handle
-    //
-    //--------------------------------------------------------------------------
-
-#if 0
-    // This is a potential work-around for the problem with
-    // the has_type_native_handle_type template, but requires
-    // Boost 1.54 or later.
-    //
-    // This include will be needed:
-    //
-    // boost/tti/has_type.hpp
-    //
-    //
-    BOOST_TTI_HAS_TYPE(native_handle_type)
-
-#else
-    template <class T>
-    struct has_type_native_handle_type
-    {
-        typedef char yes; 
-        typedef struct {char dummy[2];} no;
-        template <class C> static yes f(typename C::native_handle_type*);
-        template <class C> static no f(...);
-    #ifdef _MSC_VER
-        static bool const value = sizeof(f<T>(0)) == 1;
-    #else
-        // This line fails to compile under Visual Studio 2012
-        static bool const value = sizeof(
-            has_type_native_handle_type<T>::f<T>(0)) == 1;
-    #endif
-    }; 
-
-#endif
-
-    template <typename T,
-        bool Exists = has_type_native_handle_type <T>::value
-    >
-    struct extract_native_handle_type
-    {
-        typedef typename T::native_handle_type type;
-    };
-
-    template <typename T>
-    struct extract_native_handle_type <T, false>
-    {
-        typedef void type;
-    };
-
-    // This will be void if native_handle_type doesn't exist in Object
-    typedef typename extract_native_handle_type <
-        this_layer_type>::type native_handle_type;
-
-    //--------------------------------------------------------------------------
-
-    bool native_handle (char const* type_name, void* dest) override
-    {
-        return native_handle (type_name, dest,
-            Enabled <has_type_native_handle_type <this_layer_type> > ());
-    }
-
-    bool native_handle (char const* type_name, void* dest,
-        std::true_type)
-    {
-        char const* const name (typeid (
-            typename this_layer_type::native_handle_type).name ());
-        if (strcmp (name, type_name) == 0)
-        {
-            native_handle_type* const p (reinterpret_cast <
-                native_handle_type*> (dest));
-            *p = m_object.native_handle ();
-            return true;
-        }
-        return false;
-    }
-
-    bool native_handle (char const*, void*,
-        std::false_type)
-    {
-        pure_virtual_called();
-        return false;
-    }
-
-    //--------------------------------------------------------------------------
-    //
-    // basic_io_object
-    //
-    //--------------------------------------------------------------------------
-
-    boost::asio::io_service& get_io_service () override
-    {
-        return get_io_service (
-            Enabled <has_get_io_service <this_layer_type,
-                boost::asio::io_service&()> > ());
-    }
-
-    boost::asio::io_service& get_io_service (
-        std::true_type)
-    {
-        return m_object.get_io_service ();
-    }
-
-    boost::asio::io_service& get_io_service (
-        std::false_type)
-    {
-        pure_virtual_called();
-        return *static_cast <boost::asio::io_service*>(nullptr);
-    }
-
-    //--------------------------------------------------------------------------
-    //
-    // basic_socket
-    //
-    //--------------------------------------------------------------------------
-
-    /*
-    To forward the lowest_layer_type type, we need to make sure it
-    exists in Object. This is a little more tricky than just figuring
-    out if Object has a particular member function.
-
-    The problem is boost::asio::basic_socket_acceptor, which doesn't
-    have lowest_layer () or lowest_layer_type ().
-    */
-
-    template <class T>
-    struct has_type_lowest_layer_type
-    {
-        typedef char yes; 
-        typedef struct {char dummy[2];} no;
-        template <class C> static yes f(typename C::lowest_layer_type*);
-        template <class C> static no f(...);
-#ifdef _MSC_VER
-        static bool const value = sizeof(f<T>(0)) == 1;
-#else
-        // This line fails to compile under Visual Studio 2012
-        static bool const value = sizeof(has_type_lowest_layer_type<T>::f<T>(0)) == 1;
-#endif
-    }; 
-
-    template <typename T, bool Exists = has_type_lowest_layer_type <T>::value >
-    struct extract_lowest_layer_type
-    {
-        typedef typename T::lowest_layer_type type;
-    };
-
-    template <typename T>
-    struct extract_lowest_layer_type <T, false>
-    {
-        typedef void type;
-    };
-
-    // This will be void if lowest_layer_type doesn't exist in Object
-    typedef typename extract_lowest_layer_type <this_layer_type>::type lowest_layer_type;
-
-    //--------------------------------------------------------------------------
-
-    void* lowest_layer_ptr (char const* type_name) const override
-    {
-        return lowest_layer_ptr (type_name,
-            Enabled <has_type_lowest_layer_type <this_layer_type> > ());
-    }
-
-    void* lowest_layer_ptr (char const* type_name,
-        std::true_type) const
-    {
-        char const* const name (typeid (typename this_layer_type::lowest_layer_type).name ());
-        if (strcmp (name, type_name) == 0)
-            return const_cast <void*> (static_cast <void const*> (&m_object.lowest_layer ()));
-        return nullptr;
-    }
-
-    void* lowest_layer_ptr (char const*,
-        std::false_type) const
-    {
-        pure_virtual_called();
-        return nullptr;
-    }
-
-    //--------------------------------------------------------------------------
-
-    error_code cancel (error_code& ec) override
-    {
-        return cancel (ec,
-            Enabled <has_cancel <this_layer_type,
-                error_code (error_code&)> > ());
-    }
-   
-    error_code cancel (error_code& ec,
-        std::true_type)
-    {
-        return m_object.cancel (ec);
-    }
-
-    error_code cancel (error_code& ec,
-        std::false_type)
-    {
-        return pure_virtual_error (ec);
-    }
-
-    //--------------------------------------------------------------------------
-
-    error_code shutdown (shutdown_type what, error_code& ec) override
-    {
-        return shutdown (what, ec,
-            Enabled <has_shutdown <this_layer_type,
-                error_code (shutdown_type, error_code&)> > ());
-    }
-
-
-    error_code shutdown (shutdown_type what, error_code& ec,
-        std::true_type)
-    {
-        return m_object.shutdown (what, ec);
-    }
-
-    error_code shutdown (shutdown_type, error_code& ec,
-        std::false_type)
-    {
-        return pure_virtual_error (ec);
-    }
-
-    //--------------------------------------------------------------------------
-
-    error_code close (error_code& ec) override
-    {
-        return close (ec,
-            Enabled <has_close <this_layer_type,
-                error_code (error_code&)> > ());
-    }
-
-    error_code close (error_code& ec,
-        std::true_type)
-    {
-        return m_object.close (ec);
-    }
-
-    error_code close (error_code& ec,
-        std::false_type)
-    {
-        return pure_virtual_error (ec);
-    }
-
-    //--------------------------------------------------------------------------
-    //
-    // basic_socket_acceptor
-    //
-    //--------------------------------------------------------------------------
-
-    // Extracts the underlying socket type from the protocol of another asio object
-    template <typename T, typename Enable = void>
-    struct native_socket
-    {
-        typedef void* socket_type;
-        inline native_socket (abstract_socket&)
-            : m_socket (nullptr)
-        {
-            abstract_socket::pure_virtual_called();
-        }
-        inline socket_type& get ()
-        {
-            abstract_socket::pure_virtual_called();
-            return m_socket;
-        }
-        inline socket_type& operator-> ()
-        {
-            return get ();
-        }
-    private:
-        socket_type m_socket;
-    };
-
-    // Enabled if T::protocol_type::socket exists as a type
-    template <typename T>
-    struct native_socket <T, typename boost::enable_if <boost::is_class <
-        typename T::protocol_type::socket> >::type>
-    {
-        typedef typename T::protocol_type::socket socket_type;
-        inline native_socket (abstract_socket& peer)
-            : m_socket_ptr (&peer.this_layer <socket_type> ())
-        {
-        }
-        inline socket_type& get () noexcept
-        {
-            return *m_socket_ptr;
-        }
-        inline socket_type& operator-> () noexcept
-        {
-            return get ();
-        }
-    private:
-        socket_type* m_socket_ptr;
-    };
-
-    //--------------------------------------------------------------------------
-
-    error_code accept (abstract_socket& peer, error_code& ec) override
-    {
-        typedef typename native_socket <this_layer_type>::socket_type socket_type;
-        return accept (peer, ec,
-            Enabled <has_accept <this_layer_type,
-                error_code (socket_type&, error_code&)> > ());
-    }
-
-    error_code accept (abstract_socket& peer, error_code& ec,
-        std::true_type)
-    {
-        return m_object.accept (
-            native_socket <this_layer_type> (peer).get (), ec);
-    }
-
-    error_code accept (abstract_socket&, error_code& ec,
-        std::false_type)
-    {
-        return pure_virtual_error (ec);
-    }
-
-    //--------------------------------------------------------------------------
-
-    void async_accept (abstract_socket& peer, error_handler handler) override
-    {
-        typedef typename native_socket <this_layer_type>::socket_type socket_type;
-        async_accept (peer, handler,
-            Enabled <has_async_accept <this_layer_type,
-                void (socket_type&, error_handler)> > ());
-    }
-
-    void async_accept (abstract_socket& peer, error_handler const& handler,
-        std::true_type)
-    {
-        m_object.async_accept (
-            native_socket <this_layer_type> (peer).get (), handler);
-    }
-
-    void async_accept (abstract_socket&, error_handler const& handler,
-        std::false_type)
-    {
-        get_io_service ().post (bind_handler (
-            handler, pure_virtual_error()));
-    }
-
-    //--------------------------------------------------------------------------
-    //
-    // basic_stream_socket
-    //
-    //--------------------------------------------------------------------------
-
-    std::size_t
-    read_some (mutable_buffers buffers, error_code& ec) override
-    {
-        return read_some (buffers, ec,
-            Enabled <has_read_some <this_layer_type,
-                std::size_t (mutable_buffers const&, error_code&)> > ());
-    }
-
-    std::size_t
-    read_some (mutable_buffers const& buffers, error_code& ec,
-        std::true_type)
-    {
-        return m_object.read_some (buffers, ec);
-    }
-
-    std::size_t read_some (mutable_buffers const&, error_code& ec,
-        std::false_type)
-    {
-        ec = pure_virtual_error ();
-        return 0;
-    }
-
-    //--------------------------------------------------------------------------
-
-    std::size_t
-    write_some (const_buffers buffers, error_code& ec) override
-    {
-        return write_some (buffers, ec,
-            Enabled <has_write_some <this_layer_type,
-                std::size_t (const_buffers const&, error_code&)> > ());
-    }
-
-    std::size_t
-    write_some (const_buffers const& buffers, error_code& ec,
-        std::true_type)
-    {
-        return m_object.write_some (buffers, ec);
-    }
-
-    std::size_t
-    write_some (const_buffers const&, error_code& ec,
-        std::false_type)
-    {
-        ec = pure_virtual_error ();
-        return 0;
-    }
-
-    //--------------------------------------------------------------------------
-
-    void async_read_some (mutable_buffers buffers,
-        transfer_handler handler) override
-    {
-        async_read_some (buffers, handler,
-            Enabled <has_async_read_some <this_layer_type,
-                void (mutable_buffers const&, transfer_handler const&)> > ());
-    }
-
-    void
-    async_read_some (mutable_buffers const& buffers,
-            transfer_handler const& handler,
-        std::true_type)
-    {
-        m_object.async_read_some (buffers, handler);
-    }
-
-    void
-    async_read_some (mutable_buffers const&,
-            transfer_handler const& handler,
-        std::false_type)
-    {
-        get_io_service ().post (bind_handler (
-            handler, pure_virtual_error(), 0));
-    }
-
-    //--------------------------------------------------------------------------
-
-    void
-    async_write_some (const_buffers buffers,
-        transfer_handler handler) override
-    {
-        async_write_some (buffers, handler,
-            Enabled <has_async_write_some <this_layer_type,
-                void (const_buffers const&, transfer_handler const&)> > ());
-    }
-
-    void
-    async_write_some (const_buffers const& buffers,
-            transfer_handler const& handler,
-        std::true_type)
-    {
-        m_object.async_write_some (buffers, handler);
-    }
-
-    void
-    async_write_some (const_buffers const&,
-            transfer_handler const& handler,
-        std::false_type)
-    {
-        get_io_service ().post (bind_handler (
-            handler, pure_virtual_error(), 0));
-    }
-
-    //--------------------------------------------------------------------------
-    //
-    // ssl::stream
-    //
-    //--------------------------------------------------------------------------
-
-    template <class T>
-    struct has_type_next_layer_type
-    {
-        typedef char yes; 
-        typedef struct {char dummy[2];} no;
-        template <class C> static yes f(typename C::next_layer_type*);
-        template <class C> static no f(...);
-    #ifdef _MSC_VER
-        static bool const value = sizeof(f<T>(0)) == 1;
-    #else
-        // This line fails to compile under Visual Studio 2012
-        static bool const value = sizeof(has_type_next_layer_type<T>::f<T>(0)) == 1;
-    #endif
-    }; 
-
-    template <typename T, bool Exists = has_type_next_layer_type <T>::value >
-    struct extract_next_layer_type
-    {
-        typedef typename T::next_layer_type type;
-    };
-
-    template <typename T>
-    struct extract_next_layer_type <T, false>
-    {
-        typedef void type;
-    };
-
-    // This will be void if next_layer_type doesn't exist in Object
-    typedef typename extract_next_layer_type <this_layer_type>::type next_layer_type;
-
-    //--------------------------------------------------------------------------
-
-    void* next_layer_ptr (char const* type_name) const override
-    {
-        return next_layer_ptr (type_name,
-            Enabled <has_type_next_layer_type <this_layer_type> > ());
-    }
-
-    void* next_layer_ptr (char const* type_name,
-        std::true_type) const
-    {
-        char const* const name (typeid (typename this_layer_type::next_layer_type).name ());
-        if (strcmp (name, type_name) == 0)
-            return const_cast <void*> (static_cast <void const*> (&m_object.next_layer ()));
-        return nullptr;
-    }
-
-    void* next_layer_ptr (char const*,
-        std::false_type) const
-    {
-        pure_virtual_called();
-        return nullptr;
-    }
-
-    //--------------------------------------------------------------------------
-
-    bool needs_handshake () override
-    {
-        return
-            has_handshake <this_layer_type,
-                error_code (handshake_type, error_code&)>::value ||
-            has_async_handshake <this_layer_type,
-                void (handshake_type, error_handler)>::value;
-    }
-
-    //--------------------------------------------------------------------------
-
-    void set_verify_mode (int verify_mode) override
-    {
-        set_verify_mode (verify_mode,
-            Enabled <has_set_verify_mode <this_layer_type,
-                void (int)> > ());
- 
-    }
-
-    void set_verify_mode (int verify_mode,
-        std::true_type)
-    {
-        m_object.set_verify_mode (verify_mode);
-    }
-
-    void set_verify_mode (int,
-        std::false_type)
-    {
-        pure_virtual_called();
-    }
-
-    //--------------------------------------------------------------------------
-
-    error_code
-    handshake (handshake_type type, error_code& ec) override
-    {
-        return handshake (type, ec,
-            Enabled <has_handshake <this_layer_type,
-                error_code (handshake_type, error_code&)> > ());
-    }
-
-    error_code
-    handshake (handshake_type type, error_code& ec,
-        std::true_type)
-    {
-        return m_object.handshake (type, ec);
-    }
-
-    error_code
-    handshake (handshake_type, error_code& ec,
-        std::false_type)
-    {
-        return pure_virtual_error (ec);
-    }
-
-    //--------------------------------------------------------------------------
-
-    void async_handshake (handshake_type type, error_handler handler) override
-    {
-        async_handshake (type, handler,
-            Enabled <has_async_handshake <this_layer_type,
-                void (handshake_type, error_handler)> > ());
-    }
-
-    void async_handshake (handshake_type type, error_handler const& handler,
-        std::true_type)
-    {
-        m_object.async_handshake (type, handler);
-    }
-
-    void async_handshake (handshake_type, error_handler const& handler,
-        std::false_type)
-    {
-        get_io_service ().post (bind_handler (
-            handler, pure_virtual_error()));
-    }
-
-    //--------------------------------------------------------------------------
-
-    error_code
-    handshake (handshake_type type, const_buffers buffers,
-        error_code& ec) override
-    {
-        return handshake (type, buffers, ec,
-            Enabled <has_handshake <this_layer_type,
-                error_code (handshake_type, const_buffers const&, error_code&)> > ());
-    }
-
-    error_code
-    handshake (handshake_type type, const_buffers const& buffers,
-            error_code& ec,
-        std::true_type)
-    {
-        return m_object.handshake (type, buffers, ec);
-    }
-
-    error_code
-    handshake (handshake_type, const_buffers const&,
-            error_code& ec,
-        std::false_type)
-    {
-        return pure_virtual_error (ec);
-    }
-
-    //--------------------------------------------------------------------------
-
-    void async_handshake (handshake_type type,
-        const_buffers buffers, transfer_handler handler) override
-    {
-        async_handshake (type, buffers, handler,
-            Enabled <has_async_handshake <this_layer_type,
-                void (handshake_type, const_buffers const&,
-                    transfer_handler)> > ());
-    }
-
-    void async_handshake (handshake_type type, const_buffers const& buffers,
-            transfer_handler const& handler,
-        std::true_type)
-    {
-        m_object.async_handshake (type, buffers, handler);
-    }
-
-    void async_handshake (handshake_type, const_buffers const&,
-            transfer_handler const& handler,
-        std::false_type)
-    {
-        get_io_service ().post (bind_handler (
-            handler, pure_virtual_error(), 0));
-    }
-
-    //--------------------------------------------------------------------------
-
-    error_code shutdown (error_code& ec) override
-    {
-        return shutdown (ec,
-            Enabled <has_shutdown <this_layer_type,
-                error_code (error_code&)> > ());
-    }
-
-    error_code shutdown (error_code& ec,
-        std::true_type)
-    {
-        return m_object.shutdown (ec);
-    }
-
-    error_code shutdown (error_code& ec,
-        std::false_type)
-    {
-        return pure_virtual_error (ec);
-    }
-
-    //--------------------------------------------------------------------------
-
-    void async_shutdown (error_handler handler) override
-    {
-        async_shutdown (handler,
-            Enabled <has_async_shutdown <this_layer_type,
-                void (error_handler)> > ());
-    }
-
-    void async_shutdown (error_handler const& handler,
-        std::true_type)
-    {
-        m_object.async_shutdown (handler);
-    }
-
-    void async_shutdown (error_handler const& handler,
-        std::false_type)
-    {
-        get_io_service ().post (bind_handler (
-            handler, pure_virtual_error()));
-    }
-};
-
-}
-}
-
-#endif

src/beast/beast/asio/ssl.h

@@ -1,41 +0,0 @@
-//------------------------------------------------------------------------------
-/*
-    This file is part of Beast: https://github.com/vinniefalco/Beast
-    Copyright 2013, Vinnie Falco <vinnie.falco@gmail.com>
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose  with  or without fee is hereby granted, provided that the above
-    copyright notice and this permission notice appear in all copies.
-
-    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
-    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
-    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-*/
-//==============================================================================
-
-#ifndef BEAST_ASIO_SSL_H_INCLUDED
-#define BEAST_ASIO_SSL_H_INCLUDED
-
-#include <boost/asio/ssl/error.hpp>
-#include <boost/system/error_code.hpp>
-
-namespace beast {
-namespace asio {
-
-/** Returns `true` if the error code is a SSL "short read." */
-inline
-bool
-is_short_read (boost::system::error_code const& ec)
-{
-    return (ec.category() == boost::asio::error::get_ssl_category())
-         && (ERR_GET_REASON(ec.value()) == SSL_R_SHORT_READ);
-}
-
-}
-}
-
-#endif

src/beast/beast/asio/ssl_bundle.h

@@ -0,0 +1,71 @@
+//------------------------------------------------------------------------------
+/*
+    This file is part of Beast: https://github.com/vinniefalco/Beast
+    Copyright 2013, Vinnie Falco <vinnie.falco@gmail.com>
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose  with  or without fee is hereby granted, provided that the above
+    copyright notice and this permission notice appear in all copies.
+
+    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
+    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
+    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+//==============================================================================
+
+#ifndef BEAST_ASIO_SSL_BUNDLE_H_INCLUDED
+#define BEAST_ASIO_SSL_BUNDLE_H_INCLUDED
+
+#include <boost/asio/ip/tcp.hpp>
+#include <boost/asio/ssl/context.hpp>
+#include <boost/asio/ssl/stream.hpp>
+#include <memory>
+#include <utility>
+
+namespace beast {
+namespace asio {
+
+/** Work-around for non-movable boost::ssl::stream.
+    This allows ssl::stream to be movable and allows the stream to
+    construct from an already-existing socket.
+*/
+struct ssl_bundle
+{
+    using socket_type = boost::asio::ip::tcp::socket;
+    using stream_type = boost::asio::ssl::stream <socket_type&>;
+    using shared_context = std::shared_ptr<boost::asio::ssl::context>;
+
+    template <class... Args>
+    ssl_bundle (shared_context const& context_, Args&&... args);
+
+    // DEPRECATED
+    template <class... Args>
+    ssl_bundle (boost::asio::ssl::context& context_, Args&&... args);
+
+    shared_context context;
+    socket_type socket;
+    stream_type stream;
+};
+
+template <class... Args>
+ssl_bundle::ssl_bundle (shared_context const& context_, Args&&... args)
+    : socket(std::forward<Args>(args)...)
+    , stream (socket, *context_)
+{
+}
+
+template <class... Args>
+ssl_bundle::ssl_bundle (boost::asio::ssl::context& context_, Args&&... args)
+    : socket(std::forward<Args>(args)...)
+    , stream (socket, context_)
+{
+}
+
+} // asio
+} // beast
+
+#endif

src/beast/beast/asio/streambuf.h

@@ -17,33 +17,663 @@
 */
 //==============================================================================
 
-#ifndef BEAST_ASIO_BASIC_STREAMBUF_H_INCLUDED
-#define BEAST_ASIO_BASIC_STREAMBUF_H_INCLUDED
+#ifndef BEAST_ASIO_STREAMBUF_H_INCLUDED
+#define BEAST_ASIO_STREAMBUF_H_INCLUDED
 
+#include <beast/utility/empty_base_optimization.h>
 #include <boost/asio/buffer.hpp>
+#include <boost/intrusive/list.hpp>
+#include <boost/iterator/transform_iterator.hpp>
+#include <algorithm>
+#include <cassert>
 #include <memory>
-#include <vector>
+#include <exception>
+#include <beast/cxx14/type_traits.h> // <type_traits>
+#include <string>
+#include <utility>
 
 namespace beast {
 namespace asio {
 
-template <class Alloc = std::allocator <char>>
-class basic_streambuf : private Alloc
+/** Implements asio::streambuf interface using multiple buffers. */
+template <class Allocator>
+class basic_streambuf
+    : private empty_base_optimization<Allocator>
 {
+public:
+    using size_type = typename std::allocator_traits<Allocator>::size_type;
+    using const_buffer = boost::asio::const_buffer;
+    using mutable_buffer = boost::asio::mutable_buffer;
+
 private:
-    typedef std::allocator_traits <Alloc> alloc_traits;
-    std::vector <boost::asio::mutable_buffer> bufs_;
+    class element;
+
+    using alloc_traits = std::allocator_traits<Allocator>;
+    using list_type = typename boost::intrusive::make_list <element,
+        boost::intrusive::constant_time_size <true>>::type;
+    using iterator = typename list_type::iterator;
+    using const_iterator = typename list_type::const_iterator;
+
+    /*  These diagrams illustrate the layout and state variables.
+
+        Input and output contained entirely in one element:
+
+        0                            out_
+        |<-------------+------------------------------------------->|
+      in_pos_       out_pos_                                     out_end_
+
+
+        Output contained in first and second elements:
+
+                     out_
+        |<------+----------+------->|   |<----------+-------------->|
+              in_pos_   out_pos_                 out_end_
+
+
+        Output contained in the second element:
+
+                                                     out_
+        |<------------+------------>|   |<----+-------------------->|
+                    in_pos_                out_pos_              out_end_
+
+
+        Output contained in second and third elements:
+
+                                     out_
+        |<-----+-------->|   |<-------+------>|   |<--------------->|
+             in_pos_               out_pos_                      out_end_
+
+
+        Input sequence is empty:
+
+                     out_
+        |<------+------------------>|   |<-----------+------------->|
+             out_pos_                             out_end_
+              in_pos_
+
+
+        Output sequence is empty:
+
+                                                     out_
+        |<------+------------------>|   |<------+------------------>|
+              in_pos_                        out_pos_
+                                             out_end_
+
+
+        The end of output can point to the end of an element.
+        But out_pos_ should never point to the end:
+
+                                                     out_
+        |<------+------------------>|   |<------+------------------>|
+              in_pos_                        out_pos_            out_end_
+
+
+        When the input sequence entirely fills the last element and
+        the output sequence is empty, out_ will point to the end of
+        the list of buffers, and out_pos_ and out_end_ will be 0:
+
+                                                     
+        |<------+------------------>|   out_     == list_.end()
+              in_pos_                   out_pos_ == 0
+                                        out_end_ == 0
+    */
+
+    list_type list_;
+    size_type block_size_;
+    size_type block_size_next_;
+    size_type in_size_ = 0; // size of the input sequence
+    iterator out_;          // element that contains out_pos_
+    size_type in_pos_ = 0;  // input offset in list_.front()
+    size_type out_pos_ = 0; // output offset in *out_
+    size_type out_end_ = 0; // output end offset in list_.back()
 
 public:
-    ~basic_streambuf()
+    class const_buffers_type;
+    class mutable_buffers_type;
+
+    basic_streambuf (basic_streambuf const& other) = delete;
+    basic_streambuf& operator= (basic_streambuf const& other) = delete;
+    basic_streambuf& operator= (basic_streambuf&& other) = delete;
+
+    ~basic_streambuf();
+
+    explicit
+    basic_streambuf(std::size_t block_size = 16*1024,
+        Allocator const& alloc = Allocator{});
+
+    basic_streambuf (basic_streambuf&& other);
+
+    /** Get the maximum size of the basic_streambuf. */
+    size_type
+    max_size() const
     {
-        for (auto const& buf : bufs_)
-            alloc_traits::deallocate (
-                boost::asio::buffer_cast<char const*>(buf));
+        return std::numeric_limits<std::size_t>::max();
+    }
+
+    /** Get the size of the input sequence. */
+    size_type
+    size() const
+    {
+        return in_size_;
+    }
+
+    /** Get a list of buffers that represents the output sequence, with the given size. */
+    mutable_buffers_type
+    prepare (size_type n);
+
+    /** Move bytes from the output sequence to the input sequence. */
+    void
+    commit (size_type n);
+
+    /** Get a list of buffers that represents the input sequence. */
+    const_buffers_type
+    data() const;
+
+    /** Remove bytes from the input sequence. */
+    void
+    consume (size_type n);
+
+private:
+    void
+    debug_check() const;
+};
+
+//------------------------------------------------------------------------------
+
+template <class Allocator>
+class basic_streambuf<Allocator>::element
+    : public boost::intrusive::list_base_hook <
+        boost::intrusive::link_mode <boost::intrusive::normal_link>>
+{
+private:
+    size_type const size_;  // size of the allocation minus sizeof(element)
+
+public:
+    element (element const&) = delete;
+    element& operator= (element const&) = delete;
+
+    explicit
+    element (size_type block_size)
+        : size_(block_size)
+        { }
+
+    size_type
+    size() const
+    {
+        return size_;
+    }
+
+    size_type
+    alloc_size() const
+    {
+        return size_ + sizeof(*this);
+    }
+
+    char*
+    data() const
+    {
+        return const_cast<char*>(
+            reinterpret_cast<char const*>(this+1));
+    }
+};
+
+//------------------------------------------------------------------------------
+
+template <class Allocator>
+class basic_streambuf<Allocator>::const_buffers_type
+{
+public:
+    using value_type = const_buffer;
+
+private:
+    struct transform
+    {
+        using argument_type = element;
+        using result_type = value_type;
+
+        basic_streambuf const* streambuf_ = nullptr;
+
+        transform() = default;
+
+        explicit
+        transform (basic_streambuf const& streambuf)
+            : streambuf_ (&streambuf)
+        {
+        }
+
+        value_type const
+        operator() (element const& e) const;
+    };
+
+    basic_streambuf const* streambuf_ = nullptr;
+
+public:
+    using const_iterator = boost::transform_iterator<
+        transform, typename list_type::const_iterator,
+            value_type, value_type>;
+
+    const_buffers_type() = default;
+    const_buffers_type (const_buffers_type const&) = default;
+    const_buffers_type& operator= (const_buffers_type const&) = default;
+
+    const_iterator
+    begin() const
+    {
+        return const_iterator (streambuf_->list_.begin(),
+            transform(*streambuf_));
+    }
+
+    const_iterator
+    end() const
+    {
+        return const_iterator (streambuf_->out_ ==
+            streambuf_->list_.end() ? streambuf_->list_.end() :
+                std::next(streambuf_->out_), transform(*streambuf_));
+    }
+
+private:
+    friend class basic_streambuf;
+
+    explicit
+    const_buffers_type (basic_streambuf const& streambuf);
+};
+
+template <class Allocator>
+basic_streambuf<Allocator>::const_buffers_type::const_buffers_type (
+    basic_streambuf const& streambuf)
+    : streambuf_ (&streambuf)
+{
+}
+
+template <class Allocator>
+auto
+basic_streambuf<Allocator>::const_buffers_type::
+    transform::operator() (element const& e) const ->
+        value_type const
+{
+    return value_type (e.data(),
+        (streambuf_->out_ == streambuf_->list_.end() ||
+            &e != &*streambuf_->out_) ? e.size() : streambuf_->out_pos_) +
+                (&e == &*streambuf_->list_.begin() ?
+                    streambuf_->in_pos_ : 0);
+}
+
+//------------------------------------------------------------------------------
+
+template <class Allocator>
+class basic_streambuf<Allocator>::mutable_buffers_type
+{
+public:
+    using value_type = mutable_buffer;
+
+private:
+    struct transform
+    {
+        using argument_type = element;
+        using result_type = value_type;
+
+        basic_streambuf const* streambuf_ = nullptr;
+
+        transform() = default;
+
+        explicit
+        transform (basic_streambuf const& streambuf)
+            : streambuf_ (&streambuf)
+        {
+        }
+
+        value_type const
+        operator() (element const& e) const;
+    };
+
+    basic_streambuf const* streambuf_;
+
+public:
+    using const_iterator = boost::transform_iterator<
+        transform, typename list_type::const_iterator,
+            value_type, value_type>;
+
+    mutable_buffers_type() = default;
+    mutable_buffers_type (mutable_buffers_type const&) = default;
+    mutable_buffers_type& operator= (mutable_buffers_type const&) = default;
+
+    const_iterator
+    begin() const
+    {
+        return const_iterator (streambuf_->out_,
+            transform(*streambuf_));
+    }
+
+    const_iterator
+    end() const
+    {
+        return const_iterator (streambuf_->list_.end(),
+            transform(*streambuf_));
+    }
+
+private:
+    friend class basic_streambuf;
+    mutable_buffers_type (basic_streambuf const& streambuf);
+};
+
+template <class Allocator>
+basic_streambuf<Allocator>::mutable_buffers_type::mutable_buffers_type (
+    basic_streambuf const& streambuf)
+    : streambuf_ (&streambuf)
+{
+}
+
+template <class Allocator>
+auto
+basic_streambuf<Allocator>::mutable_buffers_type::
+    transform::operator() (element const& e) const ->
+        value_type const
+{
+    return value_type (e.data(), &e == &*std::prev(streambuf_->list_.end()) ?
+        streambuf_->out_end_ : e.size()) + (&e == &*streambuf_->out_ ?
+            streambuf_->out_pos_ : 0);
+}
+
+//------------------------------------------------------------------------------
+
+template <class Allocator>
+basic_streambuf<Allocator>::~basic_streambuf()
+{
+    for(auto iter = list_.begin(); iter != list_.end();)
+    {
+        auto& e = *iter++;
+        size_type const n = e.alloc_size();
+        alloc_traits::destroy(this->member(), &e);
+        alloc_traits::deallocate(this->member(),
+            reinterpret_cast<char*>(&e), n);
     }
 }
 
-} // asio
-} // beast
+template <class Allocator>
+basic_streambuf<Allocator>::basic_streambuf(std::size_t block_size,
+        Allocator const& alloc)
+    : empty_base_optimization<Allocator>(alloc)
+    , block_size_ (block_size)
+    , block_size_next_ (block_size)
+    , out_ (list_.end())
+{
+    if (! (block_size > 0))
+        throw std::invalid_argument(
+            "basic_streambuf: invalid block_size");
+}
+
+template <class Allocator>
+basic_streambuf<Allocator>::basic_streambuf (basic_streambuf&& other)
+    : empty_base_optimization<Allocator>(other.member())
+    , list_ (std::move(other.list_))
+    , block_size_ (other.block_size_)
+    , block_size_next_ (other.block_size_next_)
+    , in_size_ (other.in_size_)
+    , out_ (other.out_)
+    , in_pos_ (other.in_pos_)
+    , out_pos_ (other.out_pos_)
+    , out_end_ (other.out_end_)
+{
+    other.in_size_ = 0;
+    other.out_ = other.list_.end();
+    other.in_pos_ = 0;
+    other.out_pos_ = 0;
+    other.out_end_ = 0;
+}
+
+template <class Allocator>
+auto
+basic_streambuf<Allocator>::prepare (size_type n) ->
+    mutable_buffers_type
+{
+    iterator pos = out_;
+    if (pos != list_.end())
+    {
+        auto const avail = pos->size() - out_pos_;
+        if (n > avail)
+        {
+            n -= avail;
+            while (++pos != list_.end())
+            {
+                if (n < pos->size())
+                {
+                    out_end_ = n;
+                    n = 0;
+                    ++pos;
+                    break;
+                }
+                n -= pos->size();
+            }
+        }
+        else
+        {
+            ++pos;
+            out_end_ = out_pos_ + n;
+            n = 0;
+        }
+        debug_check();
+    }
+
+    if (n > 0)
+    {
+        assert(pos == list_.end());
+        for(;;)
+        {
+            auto const avail = block_size_next_;
+            auto& e = *reinterpret_cast<element*>(alloc_traits::allocate(
+                this->member(), avail + sizeof(element)));
+            alloc_traits::construct(this->member(), &e, avail);
+            list_.push_back(e);
+            if (out_ == list_.end())
+            {
+                out_ = list_.iterator_to(e);
+                debug_check();
+            }
+            if (n <= avail)
+            {
+                out_end_ = n;
+                debug_check();
+                break;
+            }
+            n -= avail;
+        }
+    }
+    else
+    {
+        while (pos != list_.end())
+        {
+            auto& e = *pos++;
+            list_.erase(list_.iterator_to(e));
+            auto const len = e.alloc_size();
+            alloc_traits::destroy(this->member(), &e);
+            alloc_traits::deallocate(this->member(),
+                reinterpret_cast<char*>(&e), len);
+        }
+        debug_check();
+    }
+
+    return mutable_buffers_type (*this);
+}
+
+template <class Allocator>
+void
+basic_streambuf<Allocator>::commit (size_type n)
+{
+    if (list_.empty())
+        return;
+    if (out_ == list_.end())
+        return;
+    auto const last = std::prev(list_.end());
+    while (out_ != last)
+    {
+        auto const avail =
+            out_->size() - out_pos_;
+        if (n < avail)
+        {
+            out_pos_ += n;
+            in_size_ += n;
+            debug_check();
+            return;
+        }
+        ++out_;
+        n -= avail;
+        out_pos_ = 0;
+        in_size_ += avail;
+        debug_check();
+    }
+
+    n = std::min (n, out_end_ - out_pos_);
+    out_pos_ += n;
+    in_size_ += n;
+    if (out_pos_ == out_->size())
+    {
+        ++out_;
+        out_pos_ = 0;
+        out_end_ = 0;
+    }
+    debug_check();
+}
+
+template <class Allocator>
+auto
+basic_streambuf<Allocator>::data() const ->
+    const_buffers_type
+{
+    return const_buffers_type(*this);
+}
+
+template <class Allocator>
+void
+basic_streambuf<Allocator>::consume (size_type n)
+{
+    if (list_.empty())
+        return;
+
+    auto pos = list_.begin();
+    for(;;)
+    {
+        if (pos != out_)
+        {
+            auto const avail = pos->size() - in_pos_;
+            if (n < avail)
+            {
+                in_size_ -= n;
+                in_pos_ += n;
+                debug_check();
+                break;
+            }
+            n -= avail;
+            in_size_ -= avail;
+            in_pos_ = 0;
+            debug_check();
+
+            element& e = *pos++;
+            list_.erase(list_.iterator_to(e));
+            size_type const len = e.alloc_size();
+            alloc_traits::destroy(this->member(), &e);
+            alloc_traits::deallocate(this->member(),
+                reinterpret_cast<char*>(&e), len);
+        }
+        else
+        {
+            auto const avail = out_pos_ - in_pos_;
+            if (n < avail)
+            {
+                in_size_ -= n;
+                in_pos_ += n;
+            }
+            else
+            {
+                in_size_ -= avail;
+                if (out_pos_ != out_end_||
+                    out_ != list_.iterator_to(list_.back()))
+                {
+                    in_pos_ = out_pos_;
+                }
+                else
+                {
+                    // Use the whole buffer now.
+                    // Alternatively we could deallocate it.
+                    in_pos_ = 0;
+                    out_pos_ = 0;
+                    out_end_ = 0;
+                }
+            }
+            debug_check();
+            break;
+        }
+    }
+}
+
+template <class Allocator>
+void
+basic_streambuf<Allocator>::debug_check() const
+{
+#ifndef NDEBUG
+    if (list_.empty())
+    {
+        assert(in_pos_ == 0);
+        assert(in_size_ == 0);
+        assert(out_pos_ == 0);
+        assert(out_end_ == 0);
+        assert(out_ == list_.end());
+        return;
+    }
+
+    auto const& front = list_.front();
+
+    assert(in_pos_ < front.size());
+
+    if (out_ == list_.end())
+    {
+        assert(out_pos_ == 0);
+        assert(out_end_ == 0);
+    }
+    else
+    {
+        auto const& out = *out_;
+        auto const& back = list_.back();
+
+        assert(out_end_ <= back.size());
+        assert(out_pos_ <  out.size());
+        assert(&out != &front || out_pos_ >= in_pos_);
+        assert(&out != &front || out_pos_ - in_pos_ == in_size_);
+        assert(&out != &back  || out_pos_ <= out_end_);
+    }
+#endif
+}
+
+template <class Alloc, class T>
+basic_streambuf<Alloc>&
+operator<< (basic_streambuf<Alloc>& buf, T const& t)
+{
+    std::stringstream ss;
+    ss << t;
+    auto const& s = ss.str();
+    buf.commit(boost::asio::buffer_copy(
+        buf.prepare(s.size()), boost::asio::buffer(s)));
+    return buf;
+}
+
+//------------------------------------------------------------------------------
+
+using streambuf = basic_streambuf<std::allocator<char>>;
+
+/** Convert the entire basic_streambuf to a string.
+    @note It is more efficient to deal directly in the streambuf instead.
+*/
+template <class Allocator>
+std::string
+to_string (basic_streambuf<Allocator> const& buf)
+{
+    std::string s;
+    s.resize(buf.size());
+    boost::asio::buffer_copy(boost::asio::buffer(
+        &s[0], s.size()), buf.data());
+    return s;
+}
+
+}
+}
 
 #endif

src/beast/beast/asio/tests/enable_wait_for_async.test.cpp

@@ -1,105 +0,0 @@
-//------------------------------------------------------------------------------
-/*
-    This file is part of Beast: https://github.com/vinniefalco/Beast
-    Copyright 2013, Vinnie Falco <vinnie.falco@gmail.com>
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose  with  or without fee is hereby granted, provided that the above
-    copyright notice and this permission notice appear in all copies.
-
-    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
-    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
-    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-*/
-//==============================================================================
-
-#if BEAST_INCLUDE_BEASTCONFIG
-#include <BeastConfig.h>
-#endif
-
-#include <beast/unit_test/suite.h>
-
-#include <beast/asio/bind_handler.h>
-#include <beast/asio/enable_wait_for_async.h>
-
-#include <boost/asio/io_service.hpp>
-
-namespace beast {
-
-class enable_wait_for_async_test : public unit_test::suite
-{
-public:
-    typedef boost::system::error_code error_code;
-
-    void test()
-    {
-        struct handler
-        {
-            void operator()(error_code)
-            {
-            }
-        };
-
-        struct owner : asio::enable_wait_for_async <owner>
-        {
-            bool notified;
-
-            owner()
-                : notified (false)
-            {
-            }
-
-            void operator()()
-            {
-                {
-                    boost::asio::io_service ios;
-                    ios.post (asio::bind_handler (handler(),
-                        error_code()));
-                    ios.run();
-                    ios.reset();
-                    wait_for_async();
-                }
-
-                {
-                    boost::asio::io_service ios;
-                    ios.post (wrap_with_counter (asio::bind_handler (
-                        handler(), error_code())));
-                    ios.run();
-                    wait_for_async();
-                }
-
-                {
-                    boost::asio::io_service ios;
-                    handler h;
-                    ios.post (wrap_with_counter (std::bind (
-                        &handler::operator(), &h,
-                            error_code())));
-                    ios.run();
-                    wait_for_async();
-                }
-            }
-
-            void on_wait_for_async()
-            {
-                notified = true;
-            }
-        };
-
-        owner o;
-        o();
-        expect (o.notified);
-    }
-
-    void run()
-    {
-        test();
-    }
-};
-
-BEAST_DEFINE_TESTSUITE(enable_wait_for_async,asio,beast);
-
-}

src/beast/beast/asio/tests/error_test.cpp

@@ -0,0 +1,44 @@
+//------------------------------------------------------------------------------
+/*
+    This file is part of Beast: https://github.com/vinniefalco/Beast
+    Copyright 2013, Vinnie Falco <vinnie.falco@gmail.com>
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose  with  or without fee is hereby granted, provided that the above
+    copyright notice and this permission notice appear in all copies.
+
+    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
+    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
+    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+//==============================================================================
+
+#include <beast/asio/error.h>
+#include <beast/unit_test/suite.h>
+#include <string>
+
+namespace beast {
+namespace asio {
+
+class error_test : public unit_test::suite
+{
+public:
+    void run ()
+    {        
+        {
+            boost::system::error_code ec = boost::system::error_code (335544539,
+                boost::asio::error::get_ssl_category ());
+            std::string const s = beast::asio::asio_message (ec);
+            expect(s == " (20,0,219) error:140000DB:SSL routines:SSL routines:short read");
+        }
+    }
+};
+
+BEAST_DEFINE_TESTSUITE(error,asio,beast);
+
+}
+}

src/beast/beast/asio/tests/shared_handler.test.cpp

@@ -1,235 +0,0 @@
-//------------------------------------------------------------------------------
-/*
-    This file is part of Beast: https://github.com/vinniefalco/Beast
-    Copyright 2013, Vinnie Falco <vinnie.falco@gmail.com>
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose  with  or without fee is hereby granted, provided that the above
-    copyright notice and this permission notice appear in all copies.
-
-    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
-    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
-    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-*/
-//==============================================================================
-
-#if BEAST_INCLUDE_BEASTCONFIG
-#include <BeastConfig.h>
-#endif
-
-#include <beast/unit_test/suite.h>
-
-#include <beast/asio/shared_handler.h>
-
-// Disables is_constructible tests for std::function
-// Visual Studio std::function fails the is_constructible tests
-#ifndef BEAST_NO_STD_FUNCTION_CONSTRUCTIBLE
-# ifdef _MSC_VER
-#  define BEAST_NO_STD_FUNCTION_CONSTRUCTIBLE 1
-# else
-#  define BEAST_NO_STD_FUNCTION_CONSTRUCTIBLE 0
-# endif
-#endif
-
-namespace beast {
-
-class shared_handler_test : public unit_test::suite
-{
-public:
-    struct test_results
-    {
-        bool call;
-        bool invoke;
-        bool alloc;
-        bool dealloc;
-        bool cont;
-
-        test_results ()
-            : call (false)
-            , invoke (false)
-            , alloc (false)
-            , dealloc (false)
-            , cont (false)
-        {
-        }
-    };
-
-    struct test_handler
-    {
-        std::reference_wrapper <test_results> results;
-
-        explicit test_handler (test_results& results_)
-            : results (results_)
-        {
-        }
-
-        void operator() ()
-        {
-            results.get().call = true;
-        }
-
-        template <class Function>
-        friend void asio_handler_invoke (
-            Function& f, test_handler* h)
-        {
-            h->results.get().invoke = true;
-            f();
-        }
-
-        template <class Function>
-        friend void asio_handler_invoke (
-            Function const& f, test_handler* h)
-        {
-            h->results.get().invoke = true;
-            f();
-        }
-
-        friend void* asio_handler_allocate (
-            std::size_t size, test_handler* h)
-        {
-            h->results.get().alloc = true;
-            return boost::asio::asio_handler_allocate (size);
-        }
-
-        friend void asio_handler_deallocate (
-            void* p, std::size_t size, test_handler* h)
-        {
-            h->results.get().dealloc = true;
-            boost::asio::asio_handler_deallocate (p, size);
-        }
-
-        friend bool asio_handler_is_continuation (
-            test_handler* h)
-        {
-            h->results.get().cont = true;
-            return true;
-        }
-    };
-
-    struct test_invokable
-    {
-        bool call;
-
-        test_invokable ()
-            : call (false)
-        {
-        }
-
-        void operator() ()
-        {
-            call = true;
-        }
-    };
-
-    template <class Handler>
-    bool async_op (Handler&& handler)
-    {
-        void* const p (boost_asio_handler_alloc_helpers::allocate (32, handler));
-        handler();
-        boost_asio_handler_alloc_helpers::deallocate (p, 32, handler);
-        return boost_asio_handler_cont_helpers::is_continuation (handler);
-    }
-
-    void virtual_async_op (asio::shared_handler <void(void)> handler)
-    {
-        async_op (handler);
-    }
-
-    void run()
-    {
-    #if ! BEAST_NO_STD_FUNCTION_CONSTRUCTIBLE
-        static_assert (! std::is_constructible <
-            std::function <void(void)>, int&&>::value,
-                "Cannot construct std::function from int&&");
-
-        static_assert (! std::is_constructible <
-            std::function <void(void)>, int>::value,
-                "Cannot construct std::function from int");
-
-        static_assert (! std::is_constructible <
-            asio::shared_handler <void(void)>, int>::value,
-                "Cannot construct shared_handler from int");
-    #endif
-
-        static_assert (std::is_constructible <
-            asio::shared_handler <void(int)>,
-                asio::shared_handler <void(int)>>::value,
-                    "Should construct <void(int)> from <void(int)>");
-
-        static_assert (! std::is_constructible <
-            asio::shared_handler <void(int)>,
-                asio::shared_handler <void(void)>>::value,
-                    "Can't construct <void(int)> from <void(void)>");
-
-        // Hooks called when using the raw handler
-        {
-            test_results r;
-            test_handler h (r);
-
-            async_op (h);
-            expect (r.call);
-            expect (r.alloc);
-            expect (r.dealloc);
-            expect (r.cont);
-
-            test_invokable f;
-            boost_asio_handler_invoke_helpers::invoke (std::ref (f), h);
-            expect (r.invoke);
-            expect (f.call);
-        }
-
-        // Use of std::function shows the hooks not getting called
-        {
-            test_results r;
-            std::function <void(void)> fh ((test_handler) (r));
-
-            async_op (fh);
-            expect (r.call);
-            unexpected (r.alloc);
-            unexpected (r.dealloc);
-            unexpected (r.cont);
-
-            test_invokable f;
-            boost_asio_handler_invoke_helpers::invoke (std::ref (f), fh);
-            unexpected (r.invoke);
-            expect (f.call);
-        }
-
-        // Make sure shared_handler calls the hooks
-        {
-            test_results r;
-            asio::shared_handler <void(void)> sh ((test_handler)(r));
-
-            async_op (sh);
-            expect (r.call);
-            expect (r.alloc);
-            expect (r.dealloc);
-            expect (r.cont);
-
-            test_invokable f;
-            boost_asio_handler_invoke_helpers::invoke (std::ref (f), sh);
-            expect (r.invoke);
-            expect (f.call);
-        }
-
-        // Make sure shared_handler via implicit conversion calls hooks
-        {
-            test_results r;
-            test_handler h (r);
-
-            virtual_async_op ((test_handler) (r));
-            expect (r.call);
-            expect (r.alloc);
-            expect (r.dealloc);
-            expect (r.cont);
-        }
-    }
-};
-
-BEAST_DEFINE_TESTSUITE(shared_handler,asio,beast);
-
-}

src/beast/beast/asio/tests/streambuf.test.cpp

@@ -0,0 +1,158 @@
+//------------------------------------------------------------------------------
+/*
+    This file is part of Beast: https://github.com/vinniefalco/Beast
+    Copyright 2013, Vinnie Falco <vinnie.falco@gmail.com>
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose  with  or without fee is hereby granted, provided that the above
+    copyright notice and this permission notice appear in all copies.
+
+    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
+    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
+    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+//==============================================================================
+
+#include <beast/asio/streambuf.h>
+#include <beast/unit_test/suite.h>
+
+namespace beast {
+namespace asio {
+
+class streambuf_test : public unit_test::suite
+{
+public:
+    // Convert a buffer sequence to a string
+    template <class Buffers>
+    static
+    std::string
+    to_str (Buffers const& b)
+    {
+        std::string s;
+        auto const n = boost::asio::buffer_size(b);
+        s.resize(n);
+        boost::asio::buffer_copy(
+            boost::asio::buffer(&s[0], n), b);
+        return s;
+    }
+
+    // Fill a buffer sequence with predictable data
+    template <class Buffers>
+    static
+    void
+    fill (Buffers const& b)
+    {
+        char c = 0;
+        auto first = boost::asio::buffers_begin(b);
+        auto last = boost::asio::buffers_end(b);
+        while (first != last)
+            *first++ = c++;
+    }
+
+    // Check that a buffer sequence has predictable data
+    template <class Buffers>
+    void
+    check (Buffers const& b, char c = 0)
+    {
+        auto first = boost::asio::buffers_begin(b);
+        auto last = boost::asio::buffers_end(b);
+        while (first != last)
+            expect (*first++ == c++);
+    }
+
+    void
+    test_prepare()
+    {
+        testcase << "prepare";
+        beast::asio::streambuf b(11);
+        for (std::size_t n = 0; n < 97; ++n)
+        {
+            fill(b.prepare(n));
+            b.commit(n);
+            check(b.data());
+            b.consume(n);
+        }
+    }
+
+    void
+    test_commit()
+    {
+        testcase << "commit";
+        beast::asio::streambuf b(11);
+        for (std::size_t n = 0; n < 97; ++n)
+        {
+            fill(b.prepare(n));
+            char c = 0;
+            for (int i = 1;; ++i)
+            {
+                b.commit(i);
+                check(b.data(), c);
+                b.consume(i);
+                if (b.size() < 1)
+                    break;
+                c += i;
+            }
+        }
+    }
+
+    void
+    test_consume()
+    {
+        testcase << "consume";
+        beast::asio::streambuf b(11);
+        for (std::size_t n = 0; n < 97; ++n)
+        {
+            fill(b.prepare(n));
+            b.commit(n);
+            char c = 0;
+            for (int i = 1; b.size() > 0; ++i)
+            {
+                check(b.data(), c);
+                b.consume(i);
+                c += i;
+            }
+        }
+    }
+
+    void run()
+    {
+        {
+            beast::asio::streambuf b(10);
+            std::string const s = "1234567890";
+            b << s;
+            expect (to_str(b.data()) == s);
+            b.prepare(5);
+        }
+
+        {
+            beast::asio::streambuf b(10);
+            b.prepare(10);
+            b.commit(10);
+            b.consume(10);
+        }
+
+        {
+            beast::asio::streambuf b(5);
+            boost::asio::buffer_copy(b.prepare(14),
+                boost::asio::buffer(std::string("1234567890ABCD")));
+            b.commit(4);
+            expect(to_str(b.data()) == "1234");
+            b.consume(4);
+            b.commit(10);
+            expect(to_str(b.data()) == "567890ABCD");
+        }
+        
+        test_prepare();
+        test_commit();
+        test_consume();
+    }
+};
+
+BEAST_DEFINE_TESTSUITE(streambuf,asio,beast);
+
+}
+}

src/beast/beast/asio/tests/wrap_handler.test.cpp

@@ -1,280 +0,0 @@
-//------------------------------------------------------------------------------
-/*
-    This file is part of Beast: https://github.com/vinniefalco/Beast
-    Copyright 2013, Vinnie Falco <vinnie.falco@gmail.com>
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose  with  or without fee is hereby granted, provided that the above
-    copyright notice and this permission notice appear in all copies.
-
-    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
-    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
-    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-*/
-//==============================================================================
-
-#if BEAST_INCLUDE_BEASTCONFIG
-#include <BeastConfig.h>
-#endif
-
-#include <beast/unit_test/suite.h>
-
-#include <beast/asio/wrap_handler.h>
-
-#include <boost/version.hpp>
-
-#include <boost/bind.hpp>
-#include <functional>
-#include <memory>
-
-namespace beast {
-namespace asio {
-
-//------------------------------------------------------------------------------
-
-// Displays the order of destruction of parameters in the bind wrapper
-//
-class boost_bind_test : public unit_test::suite
-{
-public:
-    struct Result
-    {
-        std::string text;
-
-        void push_back (std::string const& s)
-        {
-            if (! text.empty())
-                text += ", ";
-            text += s;
-        }
-    };
-
-    struct Payload
-    {
-        std::reference_wrapper <Result> m_result;
-        std::string m_name;
-
-        explicit Payload (Result& result, std::string const& name)
-            : m_result (result)
-            , m_name (name)
-        {
-        }
-
-        ~Payload ()
-        {
-            m_result.get().push_back (m_name);
-        }
-    };
-
-    struct Arg
-    {
-        std::shared_ptr <Payload> m_payload;
-
-        Arg (Result& result, std::string const& name)
-            : m_payload (std::make_shared <Payload> (result, name))
-        {
-        }
-    };
-
-    static void foo (Arg const&, Arg const&, Arg const&)
-    {
-    }
-
-    void run()
-    {
-        {
-            Result r;
-            {
-                boost::bind (&foo,
-                    Arg (r, "one"),
-                    Arg (r, "two"),
-                    Arg (r, "three"));
-            }
-            log <<
-                std::string ("boost::bind (") + r.text + ")";
-        }
-
-        {
-            Result r;
-            {
-                std::bind (&foo,
-                    Arg (r, "one"),
-                    Arg (r, "two"),
-                    Arg (r, "three"));
-            }
-            
-            log <<
-                std::string ("std::bind (") + r.text + ")";
-        }
-
-        pass();
-    }
-};
-
-BEAST_DEFINE_TESTSUITE(boost_bind,asio,beast);
-
-//------------------------------------------------------------------------------
-
-class wrap_handler_test : public unit_test::suite
-{
-public:
-    struct test_results
-    {
-        bool call;
-        bool invoke;
-        bool alloc;
-        bool dealloc;
-        bool cont;
-
-        test_results ()
-            : call (false)
-            , invoke (false)
-            , alloc (false)
-            , dealloc (false)
-            , cont (false)
-        {
-        }
-    };
-
-    struct test_handler
-    {
-        std::reference_wrapper <test_results> results;
-
-        explicit test_handler (test_results& results_)
-            : results (results_)
-        {
-        }
-
-        void operator() ()
-        {
-            results.get().call = true;
-        }
-
-        template <class Function>
-        friend void asio_handler_invoke (
-            Function& f, test_handler* h)
-        {
-            h->results.get().invoke = true;
-            f();
-        }
-
-        template <class Function>
-        friend void asio_handler_invoke (
-            Function const& f, test_handler* h)
-        {
-            h->results.get().invoke = true;
-            f();
-        }
-
-        friend void* asio_handler_allocate (
-            std::size_t, test_handler* h)
-        {
-            h->results.get().alloc = true;
-            return nullptr;
-        }
-
-        friend void asio_handler_deallocate (
-            void*, std::size_t, test_handler* h)
-        {
-            h->results.get().dealloc = true;
-        }
-
-        friend bool asio_handler_is_continuation (
-            test_handler* h)
-        {
-            h->results.get().cont = true;
-            return true;
-        }
-    };
-
-    struct test_invokable
-    {
-        bool call;
-
-        test_invokable ()
-            : call (false)
-        {
-        }
-
-        void operator() ()
-        {
-            call = true;
-        }
-    };
-
-    template <class Handler>
-    bool async_op (Handler&& handler)
-    {
-        void* const p (boost_asio_handler_alloc_helpers::allocate (32, handler));
-        (handler)();
-        boost_asio_handler_alloc_helpers::deallocate (p, 32, handler);
-        return boost_asio_handler_cont_helpers::is_continuation (handler);
-    }
-
-    void run()
-    {
-        // Hooks called when using the raw handler
-        {
-            test_results r;
-            test_handler h (r);
-
-            async_op (h);
-            expect (r.call);
-            expect (r.alloc);
-            expect (r.dealloc);
-            expect (r.cont);
-
-            test_invokable f;
-            boost_asio_handler_invoke_helpers::invoke (std::ref (f), h);
-            expect (r.invoke);
-            expect (f.call);
-        }
-
-        // Use of boost::bind shows the hooks not getting called
-        {
-            test_results r;
-            test_handler h (r);
-            auto b (std::bind (&test_handler::operator(), &h));
-
-            async_op (b);
-            expect (r.call);
-            unexpected (r.alloc);
-            unexpected (r.dealloc);
-            unexpected (r.cont);
-
-            test_invokable f;
-            boost_asio_handler_invoke_helpers::invoke (std::ref (f), b);
-            unexpected (r.invoke);
-            expect (f.call);
-        }
-
-        // Make sure the wrapped handler calls the hooks
-        {
-            test_results r;
-            test_handler h (r);
-            auto w (wrap_handler (
-                std::bind (&test_handler::operator(), test_handler(r)), h));
-
-            async_op (w);
-            expect (r.call);
-            expect (r.alloc);
-            expect (r.dealloc);
-            expect (r.cont);
-
-            test_invokable f;
-            boost_asio_handler_invoke_helpers::invoke (std::ref (f), w);
-            expect (r.invoke);
-            expect (f.call);
-        }
-    }
-};
-
-BEAST_DEFINE_TESTSUITE(wrap_handler,asio,beast);
-
-}
-}
-

src/beast/beast/asio/waitable_executor.h

@@ -0,0 +1,315 @@
+//------------------------------------------------------------------------------
+/*
+    This file is part of Beast: https://github.com/vinniefalco/Beast
+    Copyright 2013, Vinnie Falco <vinnie.falco@gmail.com>
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose  with  or without fee is hereby granted, provided that the above
+    copyright notice and this permission notice appear in all copies.
+
+    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
+    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
+    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+//==============================================================================
+
+#ifndef BEAST_ASIO_WAITABLE_EXECUTOR_H_INCLUDED
+#define BEAST_ASIO_WAITABLE_EXECUTOR_H_INCLUDED
+
+#include <boost/asio/handler_alloc_hook.hpp>
+#include <boost/asio/handler_continuation_hook.hpp>
+#include <boost/asio/handler_invoke_hook.hpp>
+#include <condition_variable>
+#include <functional>
+#include <memory>
+#include <mutex>
+#include <beast/cxx14/type_traits.h> // <type_traits>
+#include <utility>
+#include <vector>
+
+namespace beast {
+namespace asio {
+
+namespace detail {
+
+template <class Owner, class Handler>
+class waitable_executor_wrapped_handler
+{
+private:
+    static_assert (std::is_same <std::decay_t <Owner>, Owner>::value,
+        "Owner cannot be a const or reference type");
+
+    Handler handler_;
+    std::reference_wrapper <Owner> owner_;
+    bool cont_;
+
+public:
+    waitable_executor_wrapped_handler (Owner& owner,
+        Handler&& handler, bool continuation = false)
+        : handler_ (std::move(handler))
+        , owner_ (owner)
+    {
+        using boost::asio::asio_handler_is_continuation;
+        cont_ = continuation ? true :
+            asio_handler_is_continuation(
+                std::addressof(handler_));
+        owner_.get().increment();
+    }
+
+    waitable_executor_wrapped_handler (Owner& owner,
+        Handler const& handler, bool continuation = false)
+        : handler_ (handler)
+        , owner_ (owner)
+    {
+        using boost::asio::asio_handler_is_continuation;
+        cont_ = continuation ? true :
+            asio_handler_is_continuation(
+                std::addressof(handler_));
+        owner_.get().increment();
+    }
+
+    ~waitable_executor_wrapped_handler()
+    {
+        owner_.get().decrement();
+    }
+
+    waitable_executor_wrapped_handler (
+            waitable_executor_wrapped_handler const& other)
+        : handler_ (other.handler_)
+        , owner_ (other.owner_)
+        , cont_ (other.cont_)
+    {
+        owner_.get().increment();
+    }
+
+    waitable_executor_wrapped_handler (
+            waitable_executor_wrapped_handler&& other)
+        : handler_ (std::move(other.handler_))
+        , owner_ (other.owner_)
+        , cont_ (other.cont_)
+    {
+        owner_.get().increment();
+    }
+
+    waitable_executor_wrapped_handler& operator=(
+        waitable_executor_wrapped_handler const&) = delete;
+
+    template <class... Args>
+    void
+    operator()(Args&&... args)
+    {
+        handler_(std::forward<Args>(args)...);
+    }
+
+    template <class... Args>
+    void
+    operator()(Args&&... args) const
+    {
+        handler_(std::forward<Args>(args)...);
+    }
+
+    template <class Function>
+    friend
+    void
+    asio_handler_invoke (Function& f,
+        waitable_executor_wrapped_handler* h)
+    {
+        using boost::asio::asio_handler_invoke;
+        asio_handler_invoke(f,
+            std::addressof(h->handler_));
+    }
+
+    template <class Function>
+    friend
+    void
+    asio_handler_invoke (Function const& f,
+        waitable_executor_wrapped_handler* h)
+    {
+        using boost::asio::asio_handler_invoke;
+        asio_handler_invoke(f,
+            std::addressof(h->handler_));
+    }
+
+    friend
+    void*
+    asio_handler_allocate (std::size_t size,
+        waitable_executor_wrapped_handler* h)
+    {
+        using boost::asio::asio_handler_allocate;
+        return asio_handler_allocate(
+            size, std::addressof(h->handler_));
+    }
+
+    friend
+    void
+    asio_handler_deallocate (void* p, std::size_t size,
+        waitable_executor_wrapped_handler* h)
+    {
+        using boost::asio::asio_handler_deallocate;
+        asio_handler_deallocate(
+            p, size, std::addressof(h->handler_));
+    }
+
+    friend
+    bool
+    asio_handler_is_continuation (
+        waitable_executor_wrapped_handler* h)
+    {
+        return h->cont_;
+    }
+};
+
+} // detail
+
+//------------------------------------------------------------------------------
+
+/** Executor which provides blocking until all handlers are called. */
+class waitable_executor
+{
+private:
+    template <class, class>
+    friend class detail::waitable_executor_wrapped_handler;
+
+    std::mutex mutex_;
+    std::condition_variable cond_;
+    std::size_t count_ = 0;
+    std::vector<std::function<void(void)>> notify_;
+
+public:
+    /** Block until all handlers are called. */
+    template <class = void>
+    void
+    wait();
+
+    /** Blocks until all handlers are called or time elapses.
+        @return `true` if all handlers are done or `false` if the time elapses.
+    */
+    template <class Rep, class Period>
+    bool
+    wait_for (std::chrono::duration<
+        Rep, Period> const& elapsed_time);
+
+    /** Blocks until all handlers are called or a time is reached.
+        @return `true` if all handlers are done or `false` on timeout.
+    */
+    template <class Clock, class Duration>
+    bool
+    wait_until (std::chrono::time_point<
+        Clock, Duration> const& timeout_time);
+
+    /** Call a function asynchronously after all handlers are called.
+        The function may be called on the callers thread.
+    */
+    template <class = void>
+    void
+    async_wait(std::function<void(void)> f);
+
+    /** Create a new handler that dispatches the wrapped handler on the Context. */
+    template <class Handler>
+    detail::waitable_executor_wrapped_handler<waitable_executor,
+        std::remove_reference_t<Handler>>
+    wrap (Handler&& handler);
+
+private:
+    template <class = void>
+    void
+    increment();
+
+    template <class = void>
+    void
+    decrement();
+};
+
+template <class>
+void
+waitable_executor::wait()
+{
+    std::unique_lock<std::mutex> lock(mutex_);
+    cond_.wait(lock,
+        [this]() { return count_ == 0; });
+}
+
+template <class Rep, class Period>
+bool
+waitable_executor::wait_for (std::chrono::duration<
+    Rep, Period> const& elapsed_time)
+{
+    std::unique_lock<std::mutex> lock(mutex_);
+    return cond_.wait_for(lock, elapsed_time,
+        [this]() { return count_ == 0; }) ==
+            std::cv_status::no_timeout;
+}
+
+template <class Clock, class Duration>
+bool
+waitable_executor::wait_until (std::chrono::time_point<
+    Clock, Duration> const& timeout_time)
+{
+    std::unique_lock<std::mutex> lock(mutex_);
+    return cond_.wait_until(lock, timeout_time,
+        [this]() { return count_ == 0; }) ==
+            std::cv_status::no_timeout;
+    return true;
+}
+
+template <class>
+void
+waitable_executor::async_wait(std::function<void(void)> f)
+{
+    bool busy;
+    {
+        std::lock_guard<std::mutex> _(mutex_);
+        busy = count_ > 0;
+        if (busy)
+            notify_.emplace_back(std::move(f));
+    }
+    if (! busy)
+        f();
+}
+
+template <class Handler>
+detail::waitable_executor_wrapped_handler<waitable_executor,
+    std::remove_reference_t<Handler>>
+waitable_executor::wrap (Handler&& handler)
+{
+    return detail::waitable_executor_wrapped_handler<
+        waitable_executor, std::remove_reference_t<Handler>>(
+            *this, std::forward<Handler>(handler));
+}
+
+template <class>
+void
+waitable_executor::increment()
+{
+    std::lock_guard<std::mutex> _(mutex_);
+    ++count_;
+}
+
+template <class>
+void
+waitable_executor::decrement()
+{
+    bool notify;
+    std::vector<std::function<void(void)>> list;
+    {
+        std::lock_guard<std::mutex> _(mutex_);
+        notify = --count_ == 0;
+        if (notify)
+            std::swap(list, notify_);
+    }
+    if (notify)
+    {
+        cond_.notify_all();
+        for(auto& _ : list)
+            _();
+    }
+}
+
+} // asio
+} // beast
+
+#endif

src/beast/beast/asio/wrap_handler.h

@@ -1,176 +0,0 @@
-//------------------------------------------------------------------------------
-/*
-    This file is part of Beast: https://github.com/vinniefalco/Beast
-    Copyright 2013, Vinnie Falco <vinnie.falco@gmail.com>
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose  with  or without fee is hereby granted, provided that the above
-    copyright notice and this permission notice appear in all copies.
-
-    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
-    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
-    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-*/
-//==============================================================================
-
-#ifndef BEAST_ASIO_WRAP_HANDLER_H_INCLUDED
-#define BEAST_ASIO_WRAP_HANDLER_H_INCLUDED
-
-#include <boost/asio/detail/handler_alloc_helpers.hpp>
-#include <boost/asio/detail/handler_cont_helpers.hpp>
-#include <boost/asio/detail/handler_invoke_helpers.hpp>
-
-#include <beast/cxx14/type_traits.h> // <type_traits>
-#include <utility>
-
-namespace beast {
-namespace asio {
-
-#ifdef _MSC_VER
-#pragma warning (push)
-#pragma warning (disable: 4512) // assignment operator could not be generated
-#endif
-
-namespace detail {
-
-/** A handler which wraps another handler using a specfic context.
-    The handler is invoked with the same io_service execution guarantees
-    as the provided context.
-    @note A copy of Context is made.
-*/
-template <class Handler, class Context>
-class wrapped_handler
-{
-private:
-    Handler m_handler;
-    Context m_context;
-    bool m_continuation;
-
-    // If this goes off, consider carefully what the intent is.
-    static_assert (! std::is_reference <Handler>::value,
-        "Handler should not be a reference type");
-
-public:
-    wrapped_handler (bool continuation, Handler&& handler, Context context)
-        : m_handler (std::move (handler))
-        , m_context (context)
-        , m_continuation (continuation ? true :
-            boost_asio_handler_cont_helpers::is_continuation (context))
-    {
-    }
-
-    wrapped_handler (bool continuation, Handler const& handler, Context context)
-        : m_handler (handler)
-        , m_context (context)
-        , m_continuation (continuation ? true :
-            boost_asio_handler_cont_helpers::is_continuation (context))
-    {
-    }
-
-    template <class... Args>
-    void
-    operator() (Args&&... args)
-    {
-        m_handler (std::forward <Args> (args)...);
-    }
-
-    template <class... Args>
-    void
-    operator() (Args&&... args) const
-    {
-        m_handler (std::forward <Args> (args)...);
-    }
-
-    template <class Function>
-    friend
-    void
-    asio_handler_invoke (Function& f, wrapped_handler* h)
-    {
-        boost_asio_handler_invoke_helpers::
-            invoke (f, h->m_context);
-    }
-
-    template <class Function>
-    friend
-    void
-    asio_handler_invoke (Function const& f, wrapped_handler* h)
-    {
-        boost_asio_handler_invoke_helpers::
-            invoke (f, h->m_context);
-    }
-
-    friend
-    void*
-    asio_handler_allocate (std::size_t size, wrapped_handler* h)
-    {
-        return boost_asio_handler_alloc_helpers::
-            allocate (size, h->m_context);
-    }
-
-    friend
-    void
-    asio_handler_deallocate (void* p, std::size_t size, wrapped_handler* h)
-    {
-        boost_asio_handler_alloc_helpers::
-            deallocate (p, size, h->m_context);
-    }
-
-    friend
-    bool
-    asio_handler_is_continuation (wrapped_handler* h)
-    {
-        return h->m_continuation;
-    }
-};
-
-}
-
-//------------------------------------------------------------------------------
-
-// Tag for dispatching wrap_handler with is_continuation == true
-enum continuation_t
-{
-    continuation
-};
-
-/** Returns a wrapped handler so it executes within another context.
-    The handler is invoked with the same io_service execution guarantees
-    as the provided context. The handler will be copied if necessary.
-    @note A copy of Context is made.
-*/
-/** @{ */
-template <class DeducedHandler, class Context>
-detail::wrapped_handler <
-    std::remove_reference_t <DeducedHandler>,
-    Context
->
-wrap_handler (DeducedHandler&& handler, Context const& context,
-    bool continuation = false)
-{
-    typedef std::remove_reference_t <DeducedHandler> Handler;
-    return detail::wrapped_handler <Handler, Context> (continuation,
-        std::forward <DeducedHandler> (handler), context);
-}
-
-template <class DeducedHandler, class Context>
-detail::wrapped_handler <
-    std::remove_reference_t <DeducedHandler>,
-    Context
->
-wrap_handler (continuation_t, DeducedHandler&& handler,
-    Context const& context)
-{
-    typedef std::remove_reference_t <DeducedHandler> Handler;
-    return detail::wrapped_handler <Handler, Context> (true,
-        std::forward <DeducedHandler> (handler), context);
-}
-/** @} */
-
-}
-}
-
-#endif

src/beast/beast/boost/get_pointer.h

@@ -1,46 +0,0 @@
-//------------------------------------------------------------------------------
-/*
-    This file is part of Beast: https://github.com/vinniefalco/Beast
-    Copyright 2013, Vinnie Falco <vinnie.falco@gmail.com>
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose  with  or without fee is hereby granted, provided that the above
-    copyright notice and this permission notice appear in all copies.
-
-    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
-    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
-    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-*/
-//==============================================================================
-
-#ifndef BEAST_BOOST_GET_POINTER_H_INCLUDED
-#define BEAST_BOOST_GET_POINTER_H_INCLUDED
-
-#include <boost/get_pointer.hpp>
-
-// Boost 1.55 incorrectly defines BOOST_NO_CXX11_SMART_PTR
-// when building with clang 3.4 and earlier. This workaround
-// gives beast its own overloads.
-
-#ifdef BOOST_NO_CXX11_SMART_PTR
-#include <memory>
-namespace beast {
-template <class T>
-T* get_pointer (std::unique_ptr<T> const& p)
-{
-    return p.get();
-}
-
-template <class T>
-T* get_pointer (std::shared_ptr<T> const& p)
-{
-    return p.get();
-}
-}
-#endif
-
-#endif

src/beast/beast/chrono/abstract_clock.h

@@ -27,12 +27,12 @@ namespace beast {
 
 /** Abstract interface to a clock.
 
-    The abstract clock interface allows a dependency injection to take
-    place so that the choice of implementation can be made at run-time
-    instead of compile time. The trade-off is that the Duration used to
-    represent the clock must be chosen at compile time and cannot be
-    changed. This includes both the choice of representation (integers
-    for example) and the period in ticks corresponding to one second.
+    This makes now() a member function instead of a static member, so
+    an instance of the class can be dependency injected, facilitating
+    unit tests where time may be controlled.
+
+    An abstract_clock inherits all the nested types of the Clock
+    template parameter.
 
     Example:
 
@@ -40,56 +40,37 @@ namespace beast {
 
     struct Implementation
     {
-        abstract_clock <std::chrono::seconds>& m_clock;
-
-        // Dependency injection
-        //
-        explicit Implementation (
-            abstract_clock <std::chrono::seconds>& clock)
-            : m_clock (clock)
+        using clock_type = abstract_clock <std::chrono::steady_clock>;
+        clock_type& clock_;
+        explicit Implementation (clock_type& clock)
+            : clock_(clock)
         {
         }
     };
 
     @endcode
 
-    @tparam The length of time, in seconds, corresponding to one tick.
+    @tparam Clock A type meeting these requirements:
+        http://en.cppreference.com/w/cpp/concept/Clock
 */
-template <class Duration>
+template <class Clock>
 class abstract_clock
 {
 public:
-    typedef typename Duration::rep rep;
-    typedef typename Duration::period period;
-    typedef Duration duration;
-    typedef std::chrono::time_point <
-        abstract_clock, duration> time_point;
+    using rep = typename Clock::rep;
+    using period = typename Clock::period;
+    using duration = typename Clock::duration;
+    using time_point = typename Clock::time_point;
 
-    virtual ~abstract_clock () { }
+    static bool const is_steady = Clock::is_steady;
 
-    /** Returns `true` if this is a steady clock. */
-    virtual bool is_steady () const = 0;
+    virtual ~abstract_clock() = default;
 
     /** Returns the current time. */
-    virtual time_point now () const = 0;
-
-#if 0
-    /** Convert the specified time point to a string. */
-    /** @{ */
-    //virtual std::string to_string (time_point const& tp) const = 0;
-
-    template <class Duration2>
-    std::string to_string (
-        std::chrono::time_point <abstract_clock, Duration2> const& tp) const
-    {
-        return to_string (
-            std::chrono::time_point_cast <Duration> (tp));
-    }
-    /** @} */
-#endif
+    virtual time_point now() const = 0;
 
     /** Returning elapsed ticks since the epoch. */
-    rep elapsed () const
+    rep elapsed()
     {
         return now().time_since_epoch().count();
     }
@@ -99,68 +80,34 @@ public:
 
 namespace detail {
 
-template <class TrivialClock, class Duration>
-struct basic_abstract_clock_wrapper : public abstract_clock <Duration>
-{
-    using typename abstract_clock <Duration>::duration;
-    using typename abstract_clock <Duration>::time_point;
-
-    bool is_steady () const
-    {
-        return TrivialClock::is_steady;
-    }
-
-    time_point now () const
-    {
-        return time_point (duration (
-            std::chrono::duration_cast <duration> (
-                TrivialClock::now().time_since_epoch ()).count ()));
-    }
-};
-
-template <class TrivialClock, class Duration>
+template <class Facade, class Clock>
 struct abstract_clock_wrapper
-    : public basic_abstract_clock_wrapper <TrivialClock, Duration>
+    : public abstract_clock<Facade>
 {
-    // generic conversion displays the duration
-    /*
-    std::string to_string (typename basic_abstract_clock_wrapper <
-        TrivialClock, Duration>::time_point const& tp) const
-    {
-        std::stringstream ss;
-        ss << tp.time_since_epoch();
-        return ss.str ();
-    }
-    */
-};
+    using typename abstract_clock<Facade>::duration;
+    using typename abstract_clock<Facade>::time_point;
 
-/*
-template <class Duration>
-struct abstract_clock_wrapper <std::chrono::system_clock, Duration>
-    : public basic_abstract_clock_wrapper <std::chrono::system_clock, Duration>
-{
-    typedef std::chrono::system_clock clock_type;
-    std::string to_string (time_point const& tp)
+    time_point
+    now() const override
     {
-        std::stringstream ss;
-        ss << clock_type::time_point (tp.time_since_epoch ());
-        return ss.str ();
+        return Clock::now();
     }
 };
-*/
 
 }
 
 //------------------------------------------------------------------------------
 
-/** Retrieve a discrete clock for a type implementing the Clock concept.
-    The interface is created as an object with static storage duration.
+/** Returns a global instance of an abstract clock.
+    @tparam Facade A type meeting these requirements:
+        http://en.cppreference.com/w/cpp/concept/Clock
+    @tparam Clock The actual concrete clock to use.
 */
-template <class TrivialClock, class Duration>
-abstract_clock <Duration>& get_abstract_clock ()
+template<class Facade, class Clock = Facade>
+abstract_clock<Facade>&
+get_abstract_clock()
 {
-    static detail::abstract_clock_wrapper <
-        TrivialClock, Duration> clock;
+    static detail::abstract_clock_wrapper<Facade, Clock> clock;
     return clock;
 }
 

src/beast/beast/chrono/abstract_clock_io.h

@@ -1,37 +0,0 @@
-//------------------------------------------------------------------------------
-/*
-    This file is part of Beast: https://github.com/vinniefalco/Beast
-    Copyright 2013, Vinnie Falco <vinnie.falco@gmail.com>
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose  with  or without fee is hereby granted, provided that the above
-    copyright notice and this permission notice appear in all copies.
-
-    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
-    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
-    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-*/
-//==============================================================================
-
-#ifndef BEAST_CHRONO_ABSTRACT_CLOCK_IO_H_INCLUDED
-#define BEAST_CHRONO_ABSTRACT_CLOCK_IO_H_INCLUDED
-
-#include <beast/chrono/chrono_io.h>
-
-namespace beast {
-
-template <class CharT, class Traits, class Duration, class Resolution>
-std::basic_ostream <CharT, Traits>&
-operator<< (std::basic_ostream <CharT, Traits>& os,
-    std::chrono::time_point <abstract_clock <Resolution>, Duration> const& tp)
-{
-    return os << tp.time_since_epoch() << " since epoch";
-}
-
-}
-
-#endif

src/beast/beast/chrono/basic_seconds_clock.h

@@ -45,25 +45,25 @@ public:
 class seconds_clock_thread
 {
 public:
-    typedef std::mutex mutex;
-    typedef std::condition_variable cond_var;
-    typedef std::lock_guard <mutex> lock_guard;
-    typedef std::unique_lock <mutex> unique_lock;
-    typedef std::chrono::steady_clock clock_type;
-    typedef std::chrono::seconds seconds;
-    typedef std::thread thread;
-    typedef std::vector <seconds_clock_worker*> workers;
+    using mutex = std::mutex;
+    using cond_var = std::condition_variable;
+    using lock_guard = std::lock_guard <mutex>;
+    using unique_lock = std::unique_lock <mutex>;
+    using clock_type = std::chrono::steady_clock;
+    using seconds = std::chrono::seconds;
+    using thread = std::thread;
+    using workers = std::vector <seconds_clock_worker*>;
 
-    bool m_stop;
-    mutex m_mutex;
-    cond_var m_cond;
-    workers m_workers;
-    thread m_thread;
+    bool stop_;
+    mutex mutex_;
+    cond_var cond_;
+    workers workers_;
+    thread thread_;
 
     seconds_clock_thread ()
-        : m_stop (false)
+        : stop_ (false)
     {
-        m_thread = thread (std::bind(
+        thread_ = thread (std::bind(
             &seconds_clock_thread::run, this));
     }
 
@@ -74,37 +74,37 @@ public:
 
     void add (seconds_clock_worker& w)
     {
-        lock_guard lock (m_mutex);
-        m_workers.push_back (&w);
+        lock_guard lock (mutex_);
+        workers_.push_back (&w);
     }
 
     void remove (seconds_clock_worker& w)
     {
-        lock_guard lock (m_mutex);
-        m_workers.erase (std::find (
-            m_workers.begin (), m_workers.end(), &w));
+        lock_guard lock (mutex_);
+        workers_.erase (std::find (
+            workers_.begin (), workers_.end(), &w));
     }
 
     void stop()
     {
-        if (m_thread.joinable())
+        if (thread_.joinable())
         {
             {
-                lock_guard lock (m_mutex);
-                m_stop = true;
+                lock_guard lock (mutex_);
+                stop_ = true;
             }
-            m_cond.notify_all();
-            m_thread.join();
+            cond_.notify_all();
+            thread_.join();
         }
     }
 
     void run()
     {
-        unique_lock lock (m_mutex);;
+        unique_lock lock (mutex_);;
 
         for (;;)
         {
-            for (auto iter : m_workers)
+            for (auto iter : workers_)
                 iter->sample();
 
             clock_type::time_point const when (
@@ -112,7 +112,7 @@ public:
                     clock_type::now().time_since_epoch()) +
                         seconds (1));
 
-            if (m_cond.wait_until (lock, when, [this]{ return m_stop; }))
+            if (cond_.wait_until (lock, when, [this]{ return stop_; }))
                 return;
         }
     }
@@ -143,24 +143,26 @@ basic_seconds_clock_main_hook()
 }
 
 /** A clock whose minimum resolution is one second.
+
     The purpose of this class is to optimize the performance of the now()
     member function call. It uses a dedicated thread that wakes up at least
     once per second to sample the requested trivial clock.
-    @tparam TrivialClock The clock to sample.
+
+    @tparam Clock A type meeting these requirements:
+        http://en.cppreference.com/w/cpp/concept/Clock
 */
-template <class TrivialClock>
+template <class Clock>
 class basic_seconds_clock
 {
 public:
-    typedef std::chrono::seconds resolution;
-    typedef typename resolution::rep rep;
-    typedef typename resolution::period period;
-    typedef std::chrono::duration <rep, period> duration;
-    typedef std::chrono::time_point <basic_seconds_clock> time_point;
+    using rep = typename Clock::rep;
+    using period = typename Clock::period;
+    using duration = typename Clock::duration;
+    using time_point = typename Clock::time_point;
 
-    static bool const is_steady = TrivialClock::is_steady;
+    static bool const is_steady = Clock::is_steady;
 
-    static time_point now ()
+    static time_point now()
     {
         // Make sure the thread is constructed before the
         // worker otherwise we will crash during destruction
@@ -176,45 +178,36 @@ public:
 
         struct worker : detail::seconds_clock_worker
         {
-            typedef std::mutex mutex;
-            typedef std::lock_guard <mutex> lock_guard;
-
             time_point m_now;
-            mutex m_mutex;
+            std::mutex mutex_;
 
-            static time_point get_now ()
+            worker()
+                : m_now(Clock::now())
             {
-                return time_point (floor <resolution> (
-                    TrivialClock::now().time_since_epoch()));
+                detail::seconds_clock_thread::instance().add(*this);
             }
 
-            worker ()
-                : m_now (get_now ())
+            ~worker()
             {
-                detail::seconds_clock_thread::instance().add (*this);
-            }
-
-            ~worker ()
-            {
-                detail::seconds_clock_thread::instance().remove (*this);
+                detail::seconds_clock_thread::instance().remove(*this);
             }
 
             time_point now()
             {
-                lock_guard lock (m_mutex);
+                std::lock_guard<std::mutex> lock (mutex_);
                 return m_now;
             }
 
-            void sample ()
+            void sample()
             {
-                lock_guard lock (m_mutex);
-                m_now = get_now ();
+                std::lock_guard<std::mutex> lock (mutex_);
+                m_now = Clock::now();
             }
         };
 
         static worker w;
 
-        return w.now ();
+        return w.now();
     }
 };
 

src/beast/beast/chrono/chrono_io.h

@@ -32,8 +32,6 @@
 #include <beast/utility/noexcept.h>
 #include <ctime>
 #include <locale>
-
-#define BEAST_CHRONO_NO_TIMEPOINT_IO 1
     
 /*
 
@@ -798,292 +796,8 @@ time_fmt(timezone f)
     return __time_man(f);
 }
 
-#if ! BEAST_CHRONO_NO_TIMEPOINT_IO
+} // chrono
 
-template <class _CharT, class _Traits, class _Duration>
-basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>& __is,
-           time_point<steady_clock, _Duration>& __tp)
-{
-    _Duration __d;
-    __is >> __d;
-    if (__is.good())
-    {
-        const _CharT __u[] = {' ', 's', 'i', 'n', 'c', 'e', ' ', 'b', 'o', 'o', 't'};
-        const basic_string<_CharT> __units(__u, __u + sizeof(__u)/sizeof(__u[0]));
-        ios_base::iostate __err = ios_base::goodbit;
-        typedef istreambuf_iterator<_CharT, _Traits> _I;
-        _I __i(__is);
-        _I __e;
-        ptrdiff_t __k = __scan_keyword(__i, __e,
-                      &__units, &__units + 1,
-                      use_facet<ctype<_CharT> >(__is.getloc()),
-                      __err) - &__units;
-        if (__k == 1)
-        {
-            // failed to read epoch string
-            __is.setstate(__err);
-            return __is;
-        }
-        __tp = time_point<steady_clock, _Duration>(__d);
-    }
-    else
-        __is.setstate(__is.failbit);
-    return __is;
-}
-
-template <class _CharT, class _Traits, class _Duration>
-basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os,
-           const time_point<system_clock, _Duration>& __tp)
-{
-    typename basic_ostream<_CharT, _Traits>::sentry ok(__os);
-    if (ok)
-    {
-        bool failed = false;
-        try
-        {
-            const _CharT* pb = nullptr;
-            const _CharT* pe = pb;
-            timezone tz = utc;
-            typedef timepunct<_CharT> F;
-            locale loc = __os.getloc();
-            if (has_facet<F>(loc))
-            {
-                const F& f = use_facet<F>(loc);
-                pb = f.fmt().data();
-                pe = pb + f.fmt().size();
-                tz = f.get_timezone();
-            }
-            time_t __t = system_clock::to_time_t(__tp);
-            tm __tm;
-            if (tz == local)
-            {
-                if (localtime_r(&__t, &__tm) == 0)
-                    failed = true;
-            }
-            else
-            {
-                if (gmtime_r(&__t, &__tm) == 0)
-                    failed = true;
-            }
-            if (!failed)
-            {
-                const time_put<_CharT>& tp = use_facet<time_put<_CharT> >(loc);
-                if (pb == pe)
-                {
-                    _CharT pattern[] = {'%', 'F', 'T', '%', 'H', ':', '%', 'M', ':'};
-                    pb = pattern;
-                    pe = pb + sizeof(pattern) / sizeof(_CharT);
-                    failed = tp.put(__os, __os, __os.fill(), &__tm, pb, pe).failed();
-                    if (!failed)
-                    {
-                        duration<double> __d = __tp - system_clock::from_time_t(__t) +
-                                  seconds(__tm.tm_sec);
-                        if (__d.count() < 10)
-                            __os << _CharT('0');
-                        ios::fmtflags __flgs = __os.flags();
-                        __os.setf(ios::fixed, ios::floatfield);
-                        __os << __d.count();
-                        __os.flags(__flgs);
-                        if (tz == local)
-                        {
-                            _CharT sub_pattern[] = {' ', '%', 'z'};
-                            pb = sub_pattern;
-                            pe = pb + + sizeof(sub_pattern) / sizeof(_CharT);
-                            failed = tp.put(__os, __os, __os.fill(), &__tm, pb, pe).failed();
-                        }
-                        else
-                        {
-                            _CharT sub_pattern[] = {' ', '+', '0', '0', '0', '0', 0};
-                            __os << sub_pattern;
-                        }
-                    }
-                }
-                else
-                    failed = tp.put(__os, __os, __os.fill(), &__tm, pb, pe).failed();
-            }
-        }
-        catch (...)
-        {
-            failed = true;
-        }
-        if (failed)
-            __os.setstate(ios_base::failbit | ios_base::badbit);
-    }
-    return __os;
-}
-
-template <class _CharT, class _InputIterator>
-minutes
-__extract_z(_InputIterator& __b, _InputIterator __e,
-            ios_base::iostate& __err, const ctype<_CharT>& __ct)
-{
-    int __minn = 0;
-    if (__b != __e)
-    {
-        char __cn = __ct.narrow(*__b, 0);
-        if (__cn != '+' && __cn != '-')
-        {
-            __err |= ios_base::failbit;
-            return minutes(0);
-        }
-        int __sn = __cn == '-' ? -1 : 1;
-        int __hr = 0;
-        for (int i = 0; i < 2; ++i)
-        {
-            if (++__b == __e)
-            {
-                __err |= ios_base::eofbit | ios_base::failbit;
-                return minutes(0);
-            }
-            __cn = __ct.narrow(*__b, 0);
-            if (!('0' <= __cn && __cn <= '9'))
-            {
-                __err |= ios_base::failbit;
-                return minutes(0);
-            }
-            __hr = __hr * 10 + __cn - '0';
-        }
-        for (int i = 0; i < 2; ++i)
-        {
-            if (++__b == __e)
-            {
-                __err |= ios_base::eofbit | ios_base::failbit;
-                return minutes(0);
-            }
-            __cn = __ct.narrow(*__b, 0);
-            if (!('0' <= __cn && __cn <= '9'))
-            {
-                __err |= ios_base::failbit;
-                return minutes(0);
-            }
-            __minn = __minn * 10 + __cn - '0';
-        }
-        if (++__b == __e)
-            __err |= ios_base::eofbit;
-        __minn += __hr * 60;
-        __minn *= __sn;
-    }
-    else
-        __err |= ios_base::eofbit | ios_base::failbit;
-    return minutes(__minn);
-}
-
-template <class _CharT, class _Traits, class _Duration>
-basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>& __is,
-           time_point<system_clock, _Duration>& __tp)
-{
-    typename basic_istream<_CharT,_Traits>::sentry ok(__is);
-    if (ok)
-    {
-        ios_base::iostate err = ios_base::goodbit;
-        try
-        {
-            const _CharT* pb = nullptr;
-            const _CharT* pe = pb;
-            typedef timepunct<_CharT> F;
-            locale loc = __is.getloc();
-            timezone tz = utc;
-            if (has_facet<F>(loc))
-            {
-                const F& f = use_facet<F>(loc);
-                pb = f.fmt().data();
-                pe = pb + f.fmt().size();
-                tz = f.get_timezone();
-            }
-            const time_get<_CharT>& tg = use_facet<time_get<_CharT> >(loc);
-            const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(loc);
-            tm __tm = {0};
-            typedef istreambuf_iterator<_CharT, _Traits> _I;
-            if (pb == pe)
-            {
-                _CharT pattern[] = {'%', 'Y', '-', '%', 'm', '-', '%', 'd',
-                                    'T', '%', 'H', ':', '%', 'M', ':'};
-                pb = pattern;
-                pe = pb + sizeof(pattern) / sizeof(_CharT);
-                tg.get(__is, 0, __is, err, &__tm, pb, pe);
-                if (err & ios_base::failbit)
-                    goto __exit;
-                double __sec;
-                _CharT __c = _CharT();
-                __is >> __sec;
-                if (__is.fail())
-                {
-                    err |= ios_base::failbit;
-                    goto __exit;
-                }
-                _I __i(__is);
-                _I __eof;
-                __c = *__i;
-                if (++__i == __eof || __c != ' ')
-                {
-                    err |= ios_base::failbit;
-                    goto __exit;
-                }
-                minutes __minn = __extract_z(__i, __eof, err, __ct);
-                if (err & ios_base::failbit)
-                    goto __exit;
-                time_t __t;
-                __t = timegm(&__tm);
-                __tp = system_clock::from_time_t(__t) - __minn
-                                 + round<microseconds>(duration<double>(__sec));
-            }
-            else
-            {
-                const _CharT __z[2] = {'%', 'z'};
-                const _CharT* __fz = std::search(pb, pe, __z, __z+2);
-                tg.get(__is, 0, __is, err, &__tm, pb, __fz);
-                minutes __minn(0);
-                if (__fz != pe)
-                {
-                    if (err != ios_base::goodbit)
-                    {
-                        err |= ios_base::failbit;
-                        goto __exit;
-                    }
-                    _I __i(__is);
-                    _I __eof;
-                    __minn = __extract_z(__i, __eof, err, __ct);
-                    if (err & ios_base::failbit)
-                        goto __exit;
-                    if (__fz+2 != pe)
-                    {
-                        if (err != ios_base::goodbit)
-                        {
-                            err |= ios_base::failbit;
-                            goto __exit;
-                        }
-                        tg.get(__is, 0, __is, err, &__tm, __fz+2, pe);
-                        if (err & ios_base::failbit)
-                            goto __exit;
-                    }
-                }
-                __tm.tm_isdst = -1;
-                time_t __t;
-                if (tz == utc || __fz != pe)
-                    __t = timegm(&__tm);
-                else
-                    __t = mktime(&__tm);
-                __tp = system_clock::from_time_t(__t) - __minn;
-            }
-        }
-        catch (...)
-        {
-            err |= ios_base::badbit | ios_base::failbit;
-        }
-    __exit:
-        __is.setstate(err);
-    }
-    return __is;
-}
-
-#endif
-
-}  // chrono
-
-//_LIBCPP_END_NAMESPACE_STD
 }
 
 #endif

src/beast/beast/chrono/chrono_util.h

@@ -17,8 +17,8 @@
 */
 //==============================================================================
 
-#ifndef BEAST_CHRONO_UTIL_H_INCLUDED
-#define BEAST_CHRONO_UTIL_H_INCLUDED
+#ifndef BEAST_CHRONO_CHRONO_UTIL_H_INCLUDED
+#define BEAST_CHRONO_CHRONO_UTIL_H_INCLUDED
 
 // From Howard Hinnant
 // http://home.roadrunner.com/~hinnant/duration_io/chrono_util.html

src/beast/beast/chrono/impl/RelativeTime.cpp

@@ -256,7 +256,7 @@ std::string RelativeTime::to_string () const
 }
 
 }
-	
+
 #if BEAST_WINDOWS
 
 #include <windows.h>
@@ -266,12 +266,12 @@ namespace detail {
 
 static double monotonicCurrentTimeInSeconds()
 {
-	return GetTickCount64() / 1000.0;
+    return GetTickCount64() / 1000.0;
 }
  
 }
 }
-	
+
 #elif BEAST_MAC || BEAST_IOS
 
 #include <mach/mach_time.h>
@@ -279,39 +279,39 @@ static double monotonicCurrentTimeInSeconds()
 
 namespace beast {
 namespace detail {
-	
+    
 static double monotonicCurrentTimeInSeconds()
 {
-	struct StaticInitializer
-	{
-		StaticInitializer ()
-		{
-			double numerator;
-			double denominator;
+    struct StaticInitializer
+    {
+        StaticInitializer ()
+        {
+            double numerator;
+            double denominator;
 
-			mach_timebase_info_data_t timebase;
-			(void) mach_timebase_info (&timebase);
-			
-			if (timebase.numer % 1000000 == 0)
-			{
-				numerator   = timebase.numer / 1000000.0;
-				denominator = timebase.denom * 1000.0;
-			}
-			else
-			{
-				numerator   = timebase.numer;
+            mach_timebase_info_data_t timebase;
+            (void) mach_timebase_info (&timebase);
+            
+            if (timebase.numer % 1000000 == 0)
+            {
+                numerator   = timebase.numer / 1000000.0;
+                denominator = timebase.denom * 1000.0;
+            }
+            else
+            {
+                numerator   = timebase.numer;
                 // VFALCO NOTE I don't understand this code
-				//denominator = timebase.denom * (std::uint64_t) 1000000 * 1000.0;
+                //denominator = timebase.denom * (std::uint64_t) 1000000 * 1000.0;
                 denominator = timebase.denom * 1000000000.0;
-			}
-			
-			ratio = numerator / denominator;
-		}
+            }
+            
+            ratio = numerator / denominator;
+        }
 
-		double ratio;
-	};
-	
-	static StaticInitializer const data;
+        double ratio;
+    };
+    
+    static StaticInitializer const data;
 
     return mach_absolute_time() * data.ratio;
 }
@@ -319,7 +319,7 @@ static double monotonicCurrentTimeInSeconds()
 }
 
 #else
-	
+    
 #include <time.h>
 
 namespace beast {
@@ -327,14 +327,14 @@ namespace detail {
 
 static double monotonicCurrentTimeInSeconds()
 {
-	timespec t;
-	clock_gettime (CLOCK_MONOTONIC, &t);
-	return t.tv_sec + t.tv_nsec / 1000000000.0;
+    timespec t;
+    clock_gettime (CLOCK_MONOTONIC, &t);
+    return t.tv_sec + t.tv_nsec / 1000000000.0;
 }
 
 }
 }
-	
+    
 #endif
 
 namespace beast {
@@ -343,37 +343,37 @@ namespace detail {
 // Records and returns the time from process startup
 static double getStartupTime()
 {
-	struct StaticInitializer
-	{
-		StaticInitializer ()
-		{
+    struct StaticInitializer
+    {
+        StaticInitializer ()
+        {
             when = detail::monotonicCurrentTimeInSeconds();
         }
-		
+        
         double when;
-	};
+    };
 
-	static StaticInitializer const data;
+    static StaticInitializer const data;
 
-	return data.when;
+    return data.when;
 }
 
 // Used to call getStartupTime as early as possible
 struct StartupTimeStaticInitializer
 {
-	StartupTimeStaticInitializer ()
-	{
+    StartupTimeStaticInitializer ()
+    {
         getStartupTime();
     }
 };
 
 static StartupTimeStaticInitializer startupTimeStaticInitializer;
-	
+    
 }
 
 RelativeTime RelativeTime::fromStartup ()
 {
-	return RelativeTime (
+    return RelativeTime (
         detail::monotonicCurrentTimeInSeconds() - detail::getStartupTime());
 }
 

src/beast/beast/chrono/manual_clock.h

@@ -25,68 +25,73 @@
 namespace beast {
 
 /** Manual clock implementation.
+
     This concrete class implements the @ref abstract_clock interface and
     allows the time to be advanced manually, mainly for the purpose of
     providing a clock in unit tests.
-    @tparam The length of time, in seconds, corresponding to one tick.
+
+    @tparam Clock A type meeting these requirements:
+        http://en.cppreference.com/w/cpp/concept/Clock
 */
-template <class Duration, bool IsSteady = true>
-class manual_clock : public abstract_clock <Duration>
+template <class Clock>
+class manual_clock
+    : public abstract_clock<Clock>
 {
 public:
-    using typename abstract_clock <Duration>::rep;
-    using typename abstract_clock <Duration>::duration;
-    using typename abstract_clock <Duration>::time_point;
-
-    explicit manual_clock (time_point const& t = time_point (Duration (0)))
-        : m_now (t)
-    {
-    }
-
-    bool is_steady () const
-    {
-        return IsSteady;
-    }
-
-    time_point now () const
-    {
-        return m_now;
-    }
-
-#if 0
-    std::string to_string (time_point const& tp) const
-    {
-        std::stringstream ss;
-        ss << tp.time_since_epoch() << " from start";
-        return ss.str ();
-    }
-#endif
-
-    /** Set the current time of the manual clock.
-        Precondition:
-            ! IsSteady || t > now()
-    */
-    void set (time_point const& t)
-    {
-        //if (IsSteady)
-        m_now = t;
-    }
-
-    /** Convenience for setting the time using a duration in @ref rep units. */
-    void set (rep v)
-    {
-        set (time_point (duration (v)));
-    }
-
-    /** Convenience for advancing the clock by one. */
-    manual_clock& operator++ ()
-    {
-        m_now += duration (1);
-        return *this;
-    }
+    using typename abstract_clock<Clock>::rep;
+    using typename abstract_clock<Clock>::duration;
+    using typename abstract_clock<Clock>::time_point;
 
 private:
-    time_point m_now;
+    time_point now_;
+
+public:
+    explicit
+    manual_clock (time_point const& now = time_point(duration(0)))
+        : now_(now)
+    {
+    }
+
+    time_point
+    now() const override
+    {
+        return now_;
+    }
+
+    /** Set the current time of the manual clock. */
+    void
+    set (time_point const& when)
+    {
+        assert(! Clock::is_steady || when >= now_);
+        now_ = when;
+    }
+
+    /** Convenience for setting the time in seconds from epoch. */
+    template <class Integer>
+    void
+    set(Integer seconds_from_epoch)
+    {
+        set(time_point(duration(
+            std::chrono::seconds(seconds_from_epoch))));
+    }
+
+    /** Advance the clock by a duration. */
+    template <class Rep, class Period>
+    void
+    advance(std::chrono::duration<Rep, Period> const& elapsed)
+    {
+        assert(! Clock::is_steady ||
+            (now_ + elapsed) >= now_);
+        now_ += elapsed;
+    }
+
+    /** Convenience for advancing the clock by one second. */
+    manual_clock&
+    operator++ ()
+    {
+        advance(std::chrono::seconds(1));
+        return *this;
+    }
 };
 
 }

src/beast/beast/chrono/tests/abstract_clock.test.cpp

@@ -20,11 +20,8 @@
 // MODULES: ../impl/chrono_io.cpp
 
 #include <beast/chrono/abstract_clock.h>
-#include <beast/chrono/abstract_clock_io.h>
 #include <beast/chrono/manual_clock.h>
-
 #include <beast/unit_test/suite.h>
-
 #include <sstream>
 #include <string>
 #include <thread>
@@ -34,7 +31,8 @@ namespace beast {
 class abstract_clock_test : public unit_test::suite
 {
 public:
-    void test (abstract_clock <std::chrono::seconds>& c)
+    template <class Clock>
+    void test (abstract_clock<Clock>& c)
     {
         {
             auto const t1 (c.now ());
@@ -53,18 +51,18 @@ public:
 
     void test_manual ()
     {
-        typedef manual_clock <std::chrono::seconds> clock_type;
+        using clock_type = manual_clock<std::chrono::steady_clock>;
         clock_type c;
 
         std::stringstream ss;
 
-        ss << "now() = " << c.now () << std::endl;
+        ss << "now() = " << c.now().time_since_epoch() << std::endl;
 
-        c.set (clock_type::time_point (std::chrono::seconds (1)));
-        ss << "now() = " << c.now () << std::endl;
+        c.set (clock_type::time_point (std::chrono::seconds(1)));
+        ss << "now() = " << c.now().time_since_epoch() << std::endl;
 
-        c.set (clock_type::time_point (std::chrono::seconds (2)));
-        ss << "now() = " << c.now () << std::endl;
+        c.set (clock_type::time_point (std::chrono::seconds(2)));
+        ss << "now() = " << c.now().time_since_epoch() << std::endl;
 
         log << ss.str();
     }
@@ -72,16 +70,16 @@ public:
     void run ()
     {
         log << "steady_clock";
-        test (get_abstract_clock <std::chrono::steady_clock,
-            std::chrono::seconds> ());
+        test (get_abstract_clock<
+            std::chrono::steady_clock>());
 
         log << "system_clock";
-        test (get_abstract_clock <std::chrono::system_clock,
-            std::chrono::seconds> ());
+        test (get_abstract_clock<
+            std::chrono::system_clock>());
 
         log << "high_resolution_clock";
-        test (get_abstract_clock <std::chrono::high_resolution_clock,
-            std::chrono::seconds> ());
+        test (get_abstract_clock<
+            std::chrono::high_resolution_clock>());
 
         log << "manual_clock";
         test_manual ();
@@ -90,6 +88,6 @@ public:
     }
 };
 
-BEAST_DEFINE_TESTSUITE(abstract_clock,chrono,beast);
+BEAST_DEFINE_TESTSUITE_MANUAL(abstract_clock,chrono,beast);
 
 }

src/beast/beast/config/CompilerConfig.h

@@ -109,9 +109,12 @@ extern void beast_reportFatalError (char const* message, char const* fileName, i
 
 /** Writes a string to the standard error stream.
     This is only compiled in a debug build.
-    @see Logger::outputDebugString
 */
-#define BDBG(dbgtext)          { beast::String tempDbgBuf; tempDbgBuf << dbgtext; beast::Logger::outputDebugString (tempDbgBuf); }
+#define BDBG(dbgtext) { \
+    beast::String tempDbgBuf; \
+    tempDbgBuf << dbgtext; \
+    beast::outputDebugString (tempDbgBuf.toStdString ()); \
+}
 
 #if 0
 /** This will always cause an assertion failure.

src/beast/beast/config/ConfigCheck.h

@@ -44,10 +44,6 @@
 #define BEAST_DISABLE_CONTRACT_CHECKS 0
 #endif
 
-#ifndef BEAST_COMPILER_CHECKS_SOCKET_OVERRIDES
-#define BEAST_COMPILER_CHECKS_SOCKET_OVERRIDES 0
-#endif
-
 //------------------------------------------------------------------------------
 
 #ifndef BEAST_DONT_AUTOLINK_TO_WIN32_LIBRARIES

src/beast/beast/config/SelectCompilerConfig.h

@@ -20,6 +20,9 @@
 // Ideas from boost
 
 // Intel
+#ifndef BEAST_CONFIG_SELECTCOMPILERCONFIG_H_INCLUDED
+#define BEAST_CONFIG_SELECTCOMPILERCONFIG_H_INCLUDED
+
 #if defined(__INTEL_COMPILER) || defined(__ICL) || defined(__ICC) || defined(__ECC)
 #define BEAST_COMPILER_CONFIG "config/compiler/Intel.h"
 
@@ -42,3 +45,4 @@
 #error "Unsupported compiler."
 #endif
 
+#endif

src/beast/beast/config/SelectPlatformConfig.h

@@ -20,6 +20,9 @@
 // Ideas from boost
 
 // Android, which must be manually set by defining BEAST_ANDROID
+#ifndef BEAST_CONFIG_SELECTPLATFORMCONFIG_H_INCLUDED
+#define BEAST_CONFIG_SELECTPLATFORMCONFIG_H_INCLUDED
+
 #if defined(BEAST_ANDROID)
 #define BEAST_PLATFORM_CONFIG "config/platform/Android.h"
 
@@ -42,3 +45,4 @@
 #else
 #error "Unsupported platform."
 #endif
+#endif

src/beast/beast/config/compiler/VisualC.h

@@ -19,4 +19,8 @@
 
 // Microsoft Visual C++ compiler configuration
 
+#ifndef BEAST_CONFIG_COMPILER_VISUALC_H_INCLUDED
+#define BEAST_CONFIG_COMPILER_VISUALC_H_INCLUDED
+
 #include <beast/utility/noexcept.h>
+#endif

src/beast/beast/config/platform/Android.h

@@ -19,8 +19,12 @@
 
 // Android platform configuration
 
+#ifndef BEAST_CONFIG_PLATFORM_ANDROID_H_INCLUDED
+#define BEAST_CONFIG_PLATFORM_ANDROID_H_INCLUDED
+
 #ifdef BEAST_ANDROID
 #undef BEAST_ANDROID
 #endif
 #define BEAST_ANDROID 1
 
+#endif

src/beast/beast/container/Container.unity.cpp

@@ -21,10 +21,4 @@
 #include <BeastConfig.h>
 #endif
 
-#include <beast/container/impl/spookyv2.cpp>
-#include <beast/container/impl/siphash.cpp>
-
 #include <beast/container/tests/aged_associative_container.test.cpp>
-#include <beast/container/tests/buffer_view.test.cpp>
-#include <beast/container/tests/hardened_hash.test.cpp>
-#include <beast/container/tests/hash_append.test.cpp>

src/beast/beast/container/aged_map.h

@@ -31,12 +31,12 @@ namespace beast {
 template <
     class Key,
     class T,
-    class Duration = std::chrono::seconds,
+    class Clock = std::chrono::steady_clock,
     class Compare = std::less <Key>,
     class Allocator = std::allocator <std::pair <Key const, T>>
 >
 using aged_map = detail::aged_ordered_container <
-    false, true, Key, T, Duration, Compare, Allocator>;
+    false, true, Key, T, Clock, Compare, Allocator>;
 
 }
 

src/beast/beast/container/aged_multimap.h

@@ -31,12 +31,12 @@ namespace beast {
 template <
     class Key,
     class T,
-    class Duration = std::chrono::seconds,
+    class Clock = std::chrono::steady_clock,
     class Compare = std::less <Key>,
     class Allocator = std::allocator <std::pair <Key const, T>>
 >
 using aged_multimap = detail::aged_ordered_container <
-    true, true, Key, T, Duration, Compare, Allocator>;
+    true, true, Key, T, Clock, Compare, Allocator>;
 
 }
 

src/beast/beast/container/aged_multiset.h

@@ -30,12 +30,12 @@ namespace beast {
 
 template <
     class Key,
-    class Duration = std::chrono::seconds,
+    class Clock = std::chrono::steady_clock,
     class Compare = std::less <Key>,
     class Allocator = std::allocator <Key>
 >
 using aged_multiset = detail::aged_ordered_container <
-    true, false, Key, void, Duration, Compare, Allocator>;
+    true, false, Key, void, Clock, Compare, Allocator>;
 
 }
 

src/beast/beast/container/aged_set.h

@@ -30,12 +30,12 @@ namespace beast {
 
 template <
     class Key,
-    class Duration = std::chrono::seconds,
+    class Clock = std::chrono::steady_clock,
     class Compare = std::less <Key>,
     class Allocator = std::allocator <Key>
 >
 using aged_set = detail::aged_ordered_container <
-    false, false, Key, void, Duration, Compare, Allocator>;
+    false, false, Key, void, Clock, Compare, Allocator>;
 
 }
 

src/beast/beast/container/aged_unordered_map.h

@@ -31,13 +31,13 @@ namespace beast {
 template <
     class Key,
     class T,
-    class Duration = std::chrono::seconds,
+    class Clock = std::chrono::steady_clock,
     class Hash = std::hash <Key>,
     class KeyEqual = std::equal_to <Key>,
     class Allocator = std::allocator <std::pair <Key const, T>>
 >
 using aged_unordered_map = detail::aged_unordered_container <
-    false, true, Key, T, Duration, Hash, KeyEqual, Allocator>;
+    false, true, Key, T, Clock, Hash, KeyEqual, Allocator>;
 
 }
 

src/beast/beast/container/aged_unordered_multimap.h

@@ -31,13 +31,13 @@ namespace beast {
 template <
     class Key,
     class T,
-    class Duration = std::chrono::seconds,
+    class Clock = std::chrono::steady_clock,
     class Hash = std::hash <Key>,
     class KeyEqual = std::equal_to <Key>,
     class Allocator = std::allocator <std::pair <Key const, T>>
 >
 using aged_unordered_multimap = detail::aged_unordered_container <
-    true, true, Key, T, Duration, Hash, KeyEqual, Allocator>;
+    true, true, Key, T, Clock, Hash, KeyEqual, Allocator>;
 
 }
 

src/beast/beast/container/aged_unordered_multiset.h

@@ -30,13 +30,13 @@ namespace beast {
 
 template <
     class Key,
-    class Duration = std::chrono::seconds,
+    class Clock = std::chrono::steady_clock,
     class Hash = std::hash <Key>,
     class KeyEqual = std::equal_to <Key>,
     class Allocator = std::allocator <Key>
 >
 using aged_unordered_multiset = detail::aged_unordered_container <
-    true, false, Key, void, Duration, Hash, KeyEqual, Allocator>;
+    true, false, Key, void, Clock, Hash, KeyEqual, Allocator>;
 
 }
 

src/beast/beast/container/aged_unordered_set.h

@@ -30,13 +30,13 @@ namespace beast {
 
 template <
     class Key,
-    class Duration = std::chrono::seconds,
+    class Clock = std::chrono::steady_clock,
     class Hash = std::hash <Key>,
     class KeyEqual = std::equal_to <Key>,
     class Allocator = std::allocator <Key>
 >
 using aged_unordered_set = detail::aged_unordered_container <
-    false, false, Key, void, Duration, Hash, KeyEqual, Allocator>;
+    false, false, Key, void, Clock, Hash, KeyEqual, Allocator>;
 
 }
 

src/beast/beast/container/cyclic_iterator.h

@@ -27,8 +27,8 @@
 */
 //==============================================================================
 
-#ifndef BEAST_CYCLIC_ITERATOR_H_INCLUDED
-#define BEAST_CYCLIC_ITERATOR_H_INCLUDED
+#ifndef BEAST_CONTAINER_CYCLIC_ITERATOR_H_INCLUDED
+#define BEAST_CONTAINER_CYCLIC_ITERATOR_H_INCLUDED
 
 #include <iterator>
 #include <boost/iterator/iterator_facade.hpp>
@@ -141,154 +141,154 @@ Here is a short example demonstrating its use.
 \snippet cyclic_iterator.cpp cyclic_iterator
 */
 template<
-	typename ContainerIterator
+    typename ContainerIterator
 >
 class cyclic_iterator
 :
-	public detail::cyclic_iterator_base<
-		ContainerIterator
-	>::type
+    public detail::cyclic_iterator_base<
+        ContainerIterator
+    >::type
 {
 public:
-	/**
-	\brief The base type which is a <code>boost::iterator_facade</code>
-	*/
-	typedef typename detail::cyclic_iterator_base<
-		ContainerIterator
-	>::type base_type;
+    /**
+    \brief The base type which is a <code>boost::iterator_facade</code>
+    */
+    typedef typename detail::cyclic_iterator_base<
+        ContainerIterator
+    >::type base_type;
 
-	/**
-	\brief The underlying iterator type
-	*/
-	typedef ContainerIterator container_iterator_type;
+    /**
+    \brief The underlying iterator type
+    */
+    typedef ContainerIterator container_iterator_type;
 
-	/**
-	\brief The value type adapted from \a ContainerIterator
-	*/
-	typedef typename base_type::value_type value_type;
+    /**
+    \brief The value type adapted from \a ContainerIterator
+    */
+    typedef typename base_type::value_type value_type;
 
-	/**
-	\brief The reference type adapted from \a ContainerIterator
-	*/
-	typedef typename base_type::reference reference;
+    /**
+    \brief The reference type adapted from \a ContainerIterator
+    */
+    typedef typename base_type::reference reference;
 
-	/**
-	\brief The pointer type adapted from \a ContainerIterator
-	*/
-	typedef typename base_type::pointer pointer;
+    /**
+    \brief The pointer type adapted from \a ContainerIterator
+    */
+    typedef typename base_type::pointer pointer;
 
-	/**
-	\brief The difference type adapted from \a ContainerIterator
-	*/
-	typedef typename base_type::difference_type difference_type;
+    /**
+    \brief The difference type adapted from \a ContainerIterator
+    */
+    typedef typename base_type::difference_type difference_type;
 
-	/**
-	\brief The iterator category, either Forward or Bidirectional
-	*/
-	typedef typename base_type::iterator_category iterator_category;
+    /**
+    \brief The iterator category, either Forward or Bidirectional
+    */
+    typedef typename base_type::iterator_category iterator_category;
 
-	/**
-	\brief Creates a singular iterator
-	*/
-	cyclic_iterator();
+    /**
+    \brief Creates a singular iterator
+    */
+    cyclic_iterator();
 
-	/**
-	\brief Copy constructs from another cyclic iterator
+    /**
+    \brief Copy constructs from another cyclic iterator
 
-	Copy constructs from another cyclic iterator \a other. This only works
-	if the underlying iterators are convertible.
+    Copy constructs from another cyclic iterator \a other. This only works
+    if the underlying iterators are convertible.
 
-	\param other The iterator to copy construct from
-	*/
-	template<
-		typename OtherIterator
-	>
-	explicit
-	cyclic_iterator(
-		cyclic_iterator<OtherIterator> const &other
-	);
+    \param other The iterator to copy construct from
+    */
+    template<
+        typename OtherIterator
+    >
+    explicit
+    cyclic_iterator(
+        cyclic_iterator<OtherIterator> const &other
+    );
 
-	/**
-	\brief Constructs a new cyclic iterator
+    /**
+    \brief Constructs a new cyclic iterator
 
-	Constructs a new cyclic iterator, starting at \a it, inside
-	a range from \a begin to \a end.
+    Constructs a new cyclic iterator, starting at \a it, inside
+    a range from \a begin to \a end.
 
-	\param pos The start of the iterator
-	\param begin The beginning of the range
-	\param end The end of the range
+    \param pos The start of the iterator
+    \param begin The beginning of the range
+    \param end The end of the range
 
-	\warning The behaviour is undefined if \a pos isn't between \a begin
-	and \a end. Also, the behaviour is undefined, if \a begin and \a end
-	don't form a valid range.
-	*/
-	cyclic_iterator(
-		container_iterator_type const &pos,
-		container_iterator_type const &begin,
-		container_iterator_type const &end
-	);
+    \warning The behaviour is undefined if \a pos isn't between \a begin
+    and \a end. Also, the behaviour is undefined, if \a begin and \a end
+    don't form a valid range.
+    */
+    cyclic_iterator(
+        container_iterator_type const &pos,
+        container_iterator_type const &begin,
+        container_iterator_type const &end
+    );
 
-	/**
-	\brief Assigns from another cyclic iterator
+    /**
+    \brief Assigns from another cyclic iterator
 
-	Assigns from another cyclic iterator \a other. This only works if the
-	underlying iterators are convertible.
+    Assigns from another cyclic iterator \a other. This only works if the
+    underlying iterators are convertible.
 
-	\param other The iterator to assign from
+    \param other The iterator to assign from
 
-	\return <code>*this</code>
-	*/
-	template<
-		typename OtherIterator
-	>
-	cyclic_iterator<ContainerIterator> &
-	operator=(
-		cyclic_iterator<OtherIterator> const &other
-	);
+    \return <code>*this</code>
+    */
+    template<
+        typename OtherIterator
+    >
+    cyclic_iterator<ContainerIterator> &
+    operator=(
+        cyclic_iterator<OtherIterator> const &other
+    );
 
-	/**
-	\brief Returns the beginning of the range
-	*/
-	container_iterator_type
-	begin() const;
+    /**
+    \brief Returns the beginning of the range
+    */
+    container_iterator_type
+    begin() const;
 
-	/**
-	\brief Returns the end of the range
-	*/
-	container_iterator_type
-	end() const;
+    /**
+    \brief Returns the end of the range
+    */
+    container_iterator_type
+    end() const;
 
-	/**
-	\brief Returns the underlying iterator
-	*/
-	container_iterator_type
-	get() const;
+    /**
+    \brief Returns the underlying iterator
+    */
+    container_iterator_type
+    get() const;
 private:
-	friend class boost::iterator_core_access;
+    friend class boost::iterator_core_access;
 
-	void
-	increment();
+    void
+    increment();
 
-	void
-	decrement();
+    void
+    decrement();
 
-	bool
-	equal(
-		cyclic_iterator const &
-	) const;
+    bool
+    equal(
+        cyclic_iterator const &
+    ) const;
 
-	reference
-	dereference() const;
+    reference
+    dereference() const;
 
-	difference_type
-	distance_to(
-		cyclic_iterator const &
-	) const;
+    difference_type
+    distance_to(
+        cyclic_iterator const &
+    ) const;
 private:
-	container_iterator_type
-		it_,
-		begin_,
-		end_;
+    container_iterator_type
+        it_,
+        begin_,
+        end_;
 };
 
 //

src/beast/beast/container/detail/aged_associative_container.h

@@ -17,8 +17,8 @@
 */
 //==============================================================================
 
-#ifndef BEAST_CONTAINER_AGED_ASSOCIATIVE_CONTAINER_H_INCLUDED
-#define BEAST_CONTAINER_AGED_ASSOCIATIVE_CONTAINER_H_INCLUDED
+#ifndef BEAST_CONTAINER_DETAIL_AGED_ASSOCIATIVE_CONTAINER_H_INCLUDED
+#define BEAST_CONTAINER_DETAIL_AGED_ASSOCIATIVE_CONTAINER_H_INCLUDED
 
 #include <type_traits>
 

src/beast/beast/container/detail/aged_container_iterator.h

@@ -17,8 +17,8 @@
 */
 //==============================================================================
 
-#ifndef BEAST_CONTAINER_AGED_CONTAINER_ITERATOR_H_INCLUDED
-#define BEAST_CONTAINER_AGED_CONTAINER_ITERATOR_H_INCLUDED
+#ifndef BEAST_CONTAINER_DETAIL_AGED_CONTAINER_ITERATOR_H_INCLUDED
+#define BEAST_CONTAINER_DETAIL_AGED_CONTAINER_ITERATOR_H_INCLUDED
 
 #include <iterator>
 #include <type_traits>
@@ -49,7 +49,7 @@ class aged_container_iterator
     : public Base
 {
 public:
-    typedef typename Iterator::value_type::stashed::time_point time_point;
+    using time_point = typename Iterator::value_type::stashed::time_point;
 
     // Could be '= default', but Visual Studio 2013 chokes on it [Aug 2014]
     aged_container_iterator ()

src/beast/beast/container/detail/aged_ordered_container.h

@@ -17,20 +17,17 @@
 */
 //==============================================================================
 
-#ifndef BEAST_CONTAINER_AGED_ORDERED_CONTAINER_H_INCLUDED
-#define BEAST_CONTAINER_AGED_ORDERED_CONTAINER_H_INCLUDED
+#ifndef BEAST_CONTAINER_DETAIL_AGED_ORDERED_CONTAINER_H_INCLUDED
+#define BEAST_CONTAINER_DETAIL_AGED_ORDERED_CONTAINER_H_INCLUDED
 
 #include <beast/container/detail/aged_container_iterator.h>
 #include <beast/container/detail/aged_associative_container.h>
-
 #include <beast/container/aged_container.h>
-
 #include <beast/chrono/abstract_clock.h>
 #include <beast/utility/empty_base_optimization.h>
-
 #include <boost/intrusive/list.hpp>
 #include <boost/intrusive/set.hpp>
-
+#include <boost/version.hpp>
 #include <beast/cxx14/algorithm.h> // <algorithm>
 #include <functional>
 #include <initializer_list>
@@ -49,10 +46,17 @@ struct is_boost_reverse_iterator
     : std::false_type
 {};
 
+#if BOOST_VERSION >= 105800
+template <class It>
+struct is_boost_reverse_iterator<boost::intrusive::reverse_iterator<It>>
+    : std::true_type
+{};
+#else
 template <class It>
 struct is_boost_reverse_iterator<boost::intrusive::detail::reverse_iterator<It>>
     : std::true_type
 {};
+#endif
 
 /** Associative container where each element is also indexed by time.
 
@@ -75,7 +79,7 @@ template <
     bool IsMap,
     class Key,
     class T,
-    class Duration = std::chrono::seconds,
+    class Clock = std::chrono::steady_clock,
     class Compare = std::less <Key>,
     class Allocator = std::allocator <
         typename std::conditional <IsMap,
@@ -85,25 +89,20 @@ template <
 class aged_ordered_container
 {
 public:
-    typedef abstract_clock <Duration> clock_type;
-    typedef typename clock_type::time_point time_point;
-    typedef typename clock_type::duration duration;
-    typedef Key key_type;
-    typedef T mapped_type;
-    typedef typename std::conditional <
-        IsMap,
-        std::pair <Key const, T>,
-        Key>::type value_type;
-    typedef std::size_t size_type;
-    typedef std::ptrdiff_t difference_type;
+    using clock_type = abstract_clock<Clock>;
+    using time_point = typename clock_type::time_point;
+    using duration = typename clock_type::duration;
+    using key_type = Key;
+    using mapped_type = T;
+    using value_type = typename std::conditional <
+        IsMap, std::pair <Key const, T>, Key>::type;
+    using size_type = std::size_t;
+    using difference_type = std::ptrdiff_t;
 
     // Introspection (for unit tests)
-    typedef std::false_type is_unordered;
-    typedef std::integral_constant <bool, IsMulti> is_multi;
-    typedef std::integral_constant <bool, IsMap> is_map;
-
-    // VFALCO TODO How can we reorder the declarations to keep
-    //             all the public things together contiguously?
+    using is_unordered = std::false_type;
+    using is_multi = std::integral_constant <bool, IsMulti>;
+    using is_map = std::integral_constant <bool, IsMap>;
 
 private:
     static Key const& extract (value_type const& value)
@@ -126,8 +125,8 @@ private:
         // need to see the container declaration.
         struct stashed
         {
-            typedef typename aged_ordered_container::value_type value_type;
-            typedef typename aged_ordered_container::time_point time_point;
+            using value_type = typename aged_ordered_container::value_type;
+            using time_point = typename aged_ordered_container::time_point;
         };
 
         element (
@@ -244,11 +243,10 @@ private:
         }
     };
 
-    typedef typename boost::intrusive::make_list <element,
-        boost::intrusive::constant_time_size <false>
-            >::type list_type;
+    using list_type = typename boost::intrusive::make_list <element,
+        boost::intrusive::constant_time_size <false>>::type;
 
-    typedef typename std::conditional <
+    using cont_type = typename std::conditional <
         IsMulti,
         typename boost::intrusive::make_multiset <element,
             boost::intrusive::constant_time_size <true>
@@ -256,10 +254,10 @@ private:
         typename boost::intrusive::make_set <element,
             boost::intrusive::constant_time_size <true>
                 >::type
-        >::type cont_type;
+        >::type;
 
-    typedef typename std::allocator_traits <
-        Allocator>::template rebind_alloc <element> ElementAllocator;
+    using ElementAllocator = typename std::allocator_traits <
+        Allocator>::template rebind_alloc <element>;
 
     using ElementAllocatorTraits = std::allocator_traits <ElementAllocator>;
 
@@ -427,29 +425,29 @@ private:
     }
 
 public:
-    typedef Compare key_compare;
-    typedef typename std::conditional <
+    using key_compare = Compare;
+    using value_compare = typename std::conditional <
         IsMap,
         pair_value_compare,
-        Compare>::type value_compare;
-    typedef Allocator allocator_type;
-    typedef value_type& reference;
-    typedef value_type const& const_reference;
-    typedef typename std::allocator_traits <
-        Allocator>::pointer pointer;
-    typedef typename std::allocator_traits <
-        Allocator>::const_pointer const_pointer;
+        Compare>::type;
+    using allocator_type = Allocator;
+    using reference = value_type&;
+    using const_reference = value_type const&;
+    using pointer = typename std::allocator_traits <
+        Allocator>::pointer;
+    using const_pointer = typename std::allocator_traits <
+        Allocator>::const_pointer;
 
-    // A set (that is, !IsMap) iterator is aways const because the elements
-    // of a set are immutable.
-    typedef detail::aged_container_iterator <!IsMap,
-        typename cont_type::iterator> iterator;
-    typedef detail::aged_container_iterator <true,
-        typename cont_type::iterator> const_iterator;
-    typedef detail::aged_container_iterator <!IsMap,
-        typename cont_type::reverse_iterator> reverse_iterator;
-    typedef detail::aged_container_iterator <true,
-        typename cont_type::reverse_iterator> const_reverse_iterator;
+    // A set iterator (IsMap==false) is always const
+    // because the elements of a set are immutable.
+    using iterator = detail::aged_container_iterator<
+        ! IsMap, typename cont_type::iterator>;
+    using const_iterator = detail::aged_container_iterator<
+        true, typename cont_type::iterator>;
+    using reverse_iterator = detail::aged_container_iterator<
+        ! IsMap, typename cont_type::reverse_iterator>;
+    using const_reverse_iterator = detail::aged_container_iterator<
+        true, typename cont_type::reverse_iterator>;
 
     //--------------------------------------------------------------------------
     //
@@ -463,16 +461,16 @@ public:
     class chronological_t
     {
     public:
-        // A set (that is, !IsMap) iterator is aways const because the elements
-        // of a set are immutable.
-        typedef detail::aged_container_iterator <!IsMap,
-            typename list_type::iterator> iterator;
-        typedef detail::aged_container_iterator <true,
-            typename list_type::iterator> const_iterator;
-        typedef detail::aged_container_iterator <!IsMap,
-            typename list_type::reverse_iterator> reverse_iterator;
-        typedef detail::aged_container_iterator <true,
-            typename list_type::reverse_iterator> const_reverse_iterator;
+        // A set iterator (IsMap==false) is always const
+        // because the elements of a set are immutable.
+        using iterator = detail::aged_container_iterator<
+            ! IsMap, typename list_type::iterator>;
+        using const_iterator = detail::aged_container_iterator<
+            true, typename list_type::iterator>;
+        using reverse_iterator = detail::aged_container_iterator<
+            ! IsMap, typename list_type::reverse_iterator>;
+        using const_reverse_iterator = detail::aged_container_iterator<
+            true, typename list_type::reverse_iterator>;
 
         iterator begin ()
          {
@@ -570,6 +568,8 @@ public:
     //
     //--------------------------------------------------------------------------
 
+    aged_ordered_container() = delete;
+
     explicit aged_ordered_container (clock_type& clock);
 
     aged_ordered_container (clock_type& clock,
@@ -1237,8 +1237,8 @@ private:
 //------------------------------------------------------------------------------
 
 template <bool IsMulti, bool IsMap, class Key, class T,
-    class Duration, class Compare, class Allocator>
-aged_ordered_container <IsMulti, IsMap, Key, T, Duration, Compare, Allocator>::
+    class Clock, class Compare, class Allocator>
+aged_ordered_container <IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::
 aged_ordered_container (
     clock_type& clock)
     : m_config (clock)
@@ -1246,8 +1246,8 @@ aged_ordered_container (
 }
 
 template <bool IsMulti, bool IsMap, class Key, class T,
-    class Duration, class Compare, class Allocator>
-aged_ordered_container <IsMulti, IsMap, Key, T, Duration, Compare, Allocator>::
+    class Clock, class Compare, class Allocator>
+aged_ordered_container <IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::
 aged_ordered_container (
     clock_type& clock,
     Compare const& comp)
@@ -1256,8 +1256,8 @@ aged_ordered_container (
 }
 
 template <bool IsMulti, bool IsMap, class Key, class T,
-    class Duration, class Compare, class Allocator>
-aged_ordered_container <IsMulti, IsMap, Key, T, Duration, Compare, Allocator>::
+    class Clock, class Compare, class Allocator>
+aged_ordered_container <IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::
 aged_ordered_container (
     clock_type& clock,
     Allocator const& alloc)
@@ -1266,8 +1266,8 @@ aged_ordered_container (
 }
 
 template <bool IsMulti, bool IsMap, class Key, class T,
-    class Duration, class Compare, class Allocator>
-aged_ordered_container <IsMulti, IsMap, Key, T, Duration, Compare, Allocator>::
+    class Clock, class Compare, class Allocator>
+aged_ordered_container <IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::
 aged_ordered_container (
     clock_type& clock,
     Compare const& comp,
@@ -1277,9 +1277,9 @@ aged_ordered_container (
 }
 
 template <bool IsMulti, bool IsMap, class Key, class T,
-    class Duration, class Compare, class Allocator>
+    class Clock, class Compare, class Allocator>
 template <class InputIt>
-aged_ordered_container <IsMulti, IsMap, Key, T, Duration, Compare, Allocator>::
+aged_ordered_container <IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::
 aged_ordered_container (InputIt first, InputIt last,
     clock_type& clock)
     : m_config (clock)
@@ -1288,9 +1288,9 @@ aged_ordered_container (InputIt first, InputIt last,
 }
 
 template <bool IsMulti, bool IsMap, class Key, class T,
-    class Duration, class Compare, class Allocator>
+    class Clock, class Compare, class Allocator>
 template <class InputIt>
-aged_ordered_container <IsMulti, IsMap, Key, T, Duration, Compare, Allocator>::
+aged_ordered_container <IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::
 aged_ordered_container (InputIt first, InputIt last,
     clock_type& clock,
     Compare const& comp)
@@ -1300,9 +1300,9 @@ aged_ordered_container (InputIt first, InputIt last,
 }
 
 template <bool IsMulti, bool IsMap, class Key, class T,
-    class Duration, class Compare, class Allocator>
+    class Clock, class Compare, class Allocator>
 template <class InputIt>
-aged_ordered_container <IsMulti, IsMap, Key, T, Duration, Compare, Allocator>::
+aged_ordered_container <IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::
 aged_ordered_container (InputIt first, InputIt last,
     clock_type& clock,
     Allocator const& alloc)
@@ -1312,9 +1312,9 @@ aged_ordered_container (InputIt first, InputIt last,
 }
 
 template <bool IsMulti, bool IsMap, class Key, class T,
-    class Duration, class Compare, class Allocator>
+    class Clock, class Compare, class Allocator>
 template <class InputIt>
-aged_ordered_container <IsMulti, IsMap, Key, T, Duration, Compare, Allocator>::
+aged_ordered_container <IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::
 aged_ordered_container (InputIt first, InputIt last,
     clock_type& clock,
     Compare const& comp,
@@ -1325,8 +1325,8 @@ aged_ordered_container (InputIt first, InputIt last,
 }
 
 template <bool IsMulti, bool IsMap, class Key, class T,
-    class Duration, class Compare, class Allocator>
-aged_ordered_container <IsMulti, IsMap, Key, T, Duration, Compare, Allocator>::
+    class Clock, class Compare, class Allocator>
+aged_ordered_container <IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::
 aged_ordered_container (aged_ordered_container const& other)
     : m_config (other.m_config)
 {
@@ -1334,8 +1334,8 @@ aged_ordered_container (aged_ordered_container const& other)
 }
 
 template <bool IsMulti, bool IsMap, class Key, class T,
-    class Duration, class Compare, class Allocator>
-aged_ordered_container <IsMulti, IsMap, Key, T, Duration, Compare, Allocator>::
+    class Clock, class Compare, class Allocator>
+aged_ordered_container <IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::
 aged_ordered_container (aged_ordered_container const& other,
     Allocator const& alloc)
     : m_config (other.m_config, alloc)
@@ -1344,8 +1344,8 @@ aged_ordered_container (aged_ordered_container const& other,
 }
 
 template <bool IsMulti, bool IsMap, class Key, class T,
-    class Duration, class Compare, class Allocator>
-aged_ordered_container <IsMulti, IsMap, Key, T, Duration, Compare, Allocator>::
+    class Clock, class Compare, class Allocator>
+aged_ordered_container <IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::
 aged_ordered_container (aged_ordered_container&& other)
     : m_config (std::move (other.m_config))
     , m_cont (std::move (other.m_cont))
@@ -1354,8 +1354,8 @@ aged_ordered_container (aged_ordered_container&& other)
 }
 
 template <bool IsMulti, bool IsMap, class Key, class T,
-    class Duration, class Compare, class Allocator>
-aged_ordered_container <IsMulti, IsMap, Key, T, Duration, Compare, Allocator>::
+    class Clock, class Compare, class Allocator>
+aged_ordered_container <IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::
 aged_ordered_container (aged_ordered_container&& other,
     Allocator const& alloc)
     : m_config (std::move (other.m_config), alloc)
@@ -1365,8 +1365,8 @@ aged_ordered_container (aged_ordered_container&& other,
 }
 
 template <bool IsMulti, bool IsMap, class Key, class T,
-    class Duration, class Compare, class Allocator>
-aged_ordered_container <IsMulti, IsMap, Key, T, Duration, Compare, Allocator>::
+    class Clock, class Compare, class Allocator>
+aged_ordered_container <IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::
 aged_ordered_container (std::initializer_list <value_type> init,
     clock_type& clock)
     : m_config (clock)
@@ -1375,8 +1375,8 @@ aged_ordered_container (std::initializer_list <value_type> init,
 }
 
 template <bool IsMulti, bool IsMap, class Key, class T,
-    class Duration, class Compare, class Allocator>
-aged_ordered_container <IsMulti, IsMap, Key, T, Duration, Compare, Allocator>::
+    class Clock, class Compare, class Allocator>
+aged_ordered_container <IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::
 aged_ordered_container (std::initializer_list <value_type> init,
     clock_type& clock,
     Compare const& comp)
@@ -1386,8 +1386,8 @@ aged_ordered_container (std::initializer_list <value_type> init,
 }
 
 template <bool IsMulti, bool IsMap, class Key, class T,
-    class Duration, class Compare, class Allocator>
-aged_ordered_container <IsMulti, IsMap, Key, T, Duration, Compare, Allocator>::
+    class Clock, class Compare, class Allocator>
+aged_ordered_container <IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::
 aged_ordered_container (std::initializer_list <value_type> init,
     clock_type& clock,
     Allocator const& alloc)
@@ -1397,8 +1397,8 @@ aged_ordered_container (std::initializer_list <value_type> init,
 }
 
 template <bool IsMulti, bool IsMap, class Key, class T,
-    class Duration, class Compare, class Allocator>
-aged_ordered_container <IsMulti, IsMap, Key, T, Duration, Compare, Allocator>::
+    class Clock, class Compare, class Allocator>
+aged_ordered_container <IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::
 aged_ordered_container (std::initializer_list <value_type> init,
     clock_type& clock,
     Compare const& comp,
@@ -1409,17 +1409,17 @@ aged_ordered_container (std::initializer_list <value_type> init,
 }
 
 template <bool IsMulti, bool IsMap, class Key, class T,
-    class Duration, class Compare, class Allocator>
-aged_ordered_container <IsMulti, IsMap, Key, T, Duration, Compare, Allocator>::
+    class Clock, class Compare, class Allocator>
+aged_ordered_container <IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::
 ~aged_ordered_container()
 {
     clear();
 }
 
 template <bool IsMulti, bool IsMap, class Key, class T,
-    class Duration, class Compare, class Allocator>
+    class Clock, class Compare, class Allocator>
 auto
-aged_ordered_container <IsMulti, IsMap, Key, T, Duration, Compare, Allocator>::
+aged_ordered_container <IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::
 operator= (aged_ordered_container const& other) ->
     aged_ordered_container&
 {
@@ -1433,9 +1433,9 @@ operator= (aged_ordered_container const& other) ->
 }
 
 template <bool IsMulti, bool IsMap, class Key, class T,
-    class Duration, class Compare, class Allocator>
+    class Clock, class Compare, class Allocator>
 auto
-aged_ordered_container <IsMulti, IsMap, Key, T, Duration, Compare, Allocator>::
+aged_ordered_container <IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::
 operator= (aged_ordered_container&& other) ->
     aged_ordered_container&
 {
@@ -1447,9 +1447,9 @@ operator= (aged_ordered_container&& other) ->
 }
 
 template <bool IsMulti, bool IsMap, class Key, class T,
-    class Duration, class Compare, class Allocator>
+    class Clock, class Compare, class Allocator>
 auto
-aged_ordered_container <IsMulti, IsMap, Key, T, Duration, Compare, Allocator>::
+aged_ordered_container <IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::
 operator= (std::initializer_list <value_type> init) ->
     aged_ordered_container&
 {
@@ -1461,10 +1461,10 @@ operator= (std::initializer_list <value_type> init) ->
 //------------------------------------------------------------------------------
 
 template <bool IsMulti, bool IsMap, class Key, class T,
-    class Duration, class Compare, class Allocator>
+    class Clock, class Compare, class Allocator>
 template <class K, bool maybe_multi, bool maybe_map, class>
 typename std::conditional <IsMap, T, void*>::type&
-aged_ordered_container <IsMulti, IsMap, Key, T, Duration, Compare, Allocator>::
+aged_ordered_container <IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::
 at (K const& k)
 {
     auto const iter (m_cont.find (k,
@@ -1475,10 +1475,10 @@ at (K const& k)
 }
 
 template <bool IsMulti, bool IsMap, class Key, class T,
-    class Duration, class Compare, class Allocator>
+    class Clock, class Compare, class Allocator>
 template <class K, bool maybe_multi, bool maybe_map, class>
 typename std::conditional <IsMap, T, void*>::type const&
-aged_ordered_container <IsMulti, IsMap, Key, T, Duration, Compare, Allocator>::
+aged_ordered_container <IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::
 at (K const& k) const
 {
     auto const iter (m_cont.find (k,
@@ -1489,10 +1489,10 @@ at (K const& k) const
 }
 
 template <bool IsMulti, bool IsMap, class Key, class T,
-    class Duration, class Compare, class Allocator>
+    class Clock, class Compare, class Allocator>
 template <bool maybe_multi, bool maybe_map, class>
 typename std::conditional <IsMap, T, void*>::type&
-aged_ordered_container <IsMulti, IsMap, Key, T, Duration, Compare, Allocator>::
+aged_ordered_container <IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::
 operator[] (Key const& key)
 {
     typename cont_type::insert_commit_data d;
@@ -1511,10 +1511,10 @@ operator[] (Key const& key)
 }
 
 template <bool IsMulti, bool IsMap, class Key, class T,
-    class Duration, class Compare, class Allocator>
+    class Clock, class Compare, class Allocator>
 template <bool maybe_multi, bool maybe_map, class>
 typename std::conditional <IsMap, T, void*>::type&
-aged_ordered_container <IsMulti, IsMap, Key, T, Duration, Compare, Allocator>::
+aged_ordered_container <IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::
 operator[] (Key&& key)
 {
     typename cont_type::insert_commit_data d;
@@ -1536,9 +1536,9 @@ operator[] (Key&& key)
 //------------------------------------------------------------------------------
 
 template <bool IsMulti, bool IsMap, class Key, class T,
-    class Duration, class Compare, class Allocator>
+    class Clock, class Compare, class Allocator>
 void
-aged_ordered_container <IsMulti, IsMap, Key, T, Duration, Compare, Allocator>::
+aged_ordered_container <IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::
 clear()
 {
     for (auto iter (chronological.list.begin());
@@ -1550,10 +1550,10 @@ clear()
 
 // map, set
 template <bool IsMulti, bool IsMap, class Key, class T,
-    class Duration, class Compare, class Allocator>
+    class Clock, class Compare, class Allocator>
 template <bool maybe_multi>
 auto
-aged_ordered_container <IsMulti, IsMap, Key, T, Duration, Compare, Allocator>::
+aged_ordered_container <IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::
 insert (value_type const& value) ->
     typename std::enable_if <! maybe_multi,
         std::pair <iterator, bool>>::type
@@ -1573,10 +1573,10 @@ insert (value_type const& value) ->
 
 // multimap, multiset
 template <bool IsMulti, bool IsMap, class Key, class T,
-    class Duration, class Compare, class Allocator>
+    class Clock, class Compare, class Allocator>
 template <bool maybe_multi>
 auto
-aged_ordered_container <IsMulti, IsMap, Key, T, Duration, Compare, Allocator>::
+aged_ordered_container <IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::
 insert (value_type const& value) ->
     typename std::enable_if <maybe_multi,
         iterator>::type
@@ -1591,10 +1591,10 @@ insert (value_type const& value) ->
 
 // set
 template <bool IsMulti, bool IsMap, class Key, class T,
-    class Duration, class Compare, class Allocator>
+    class Clock, class Compare, class Allocator>
 template <bool maybe_multi, bool maybe_map>
 auto
-aged_ordered_container <IsMulti, IsMap, Key, T, Duration, Compare, Allocator>::
+aged_ordered_container <IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::
 insert (value_type&& value) ->
     typename std::enable_if <! maybe_multi && ! maybe_map,
         std::pair <iterator, bool>>::type
@@ -1614,10 +1614,10 @@ insert (value_type&& value) ->
 
 // multiset
 template <bool IsMulti, bool IsMap, class Key, class T,
-    class Duration, class Compare, class Allocator>
+    class Clock, class Compare, class Allocator>
 template <bool maybe_multi, bool maybe_map>
 auto
-aged_ordered_container <IsMulti, IsMap, Key, T, Duration, Compare, Allocator>::
+aged_ordered_container <IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::
 insert (value_type&& value) ->
     typename std::enable_if <maybe_multi && ! maybe_map,
         iterator>::type
@@ -1634,10 +1634,10 @@ insert (value_type&& value) ->
 
 // map, set
 template <bool IsMulti, bool IsMap, class Key, class T,
-    class Duration, class Compare, class Allocator>
+    class Clock, class Compare, class Allocator>
 template <bool maybe_multi>
 auto
-aged_ordered_container <IsMulti, IsMap, Key, T, Duration, Compare, Allocator>::
+aged_ordered_container <IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::
 insert (const_iterator hint, value_type const& value) ->
     typename std::enable_if <! maybe_multi,
         iterator>::type
@@ -1657,10 +1657,10 @@ insert (const_iterator hint, value_type const& value) ->
 
 // map, set
 template <bool IsMulti, bool IsMap, class Key, class T,
-    class Duration, class Compare, class Allocator>
+    class Clock, class Compare, class Allocator>
 template <bool maybe_multi>
 auto
-aged_ordered_container <IsMulti, IsMap, Key, T, Duration, Compare, Allocator>::
+aged_ordered_container <IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::
 insert (const_iterator hint, value_type&& value) ->
     typename std::enable_if <! maybe_multi,
         iterator>::type
@@ -1680,10 +1680,10 @@ insert (const_iterator hint, value_type&& value) ->
 
 // map, set
 template <bool IsMulti, bool IsMap, class Key, class T,
-    class Duration, class Compare, class Allocator>
+    class Clock, class Compare, class Allocator>
 template <bool maybe_multi, class... Args>
 auto
-aged_ordered_container <IsMulti, IsMap, Key, T, Duration, Compare, Allocator>::
+aged_ordered_container <IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::
 emplace (Args&&... args) ->
     typename std::enable_if <! maybe_multi,
         std::pair <iterator, bool>>::type
@@ -1707,10 +1707,10 @@ emplace (Args&&... args) ->
 
 // multiset, multimap
 template <bool IsMulti, bool IsMap, class Key, class T,
-    class Duration, class Compare, class Allocator>
+    class Clock, class Compare, class Allocator>
 template <bool maybe_multi, class... Args>
 auto
-aged_ordered_container <IsMulti, IsMap, Key, T, Duration, Compare, Allocator>::
+aged_ordered_container <IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::
 emplace (Args&&... args) ->
     typename std::enable_if <maybe_multi,
         iterator>::type
@@ -1726,10 +1726,10 @@ emplace (Args&&... args) ->
 
 // map, set
 template <bool IsMulti, bool IsMap, class Key, class T,
-    class Duration, class Compare, class Allocator>
+    class Clock, class Compare, class Allocator>
 template <bool maybe_multi, class... Args>
 auto
-aged_ordered_container <IsMulti, IsMap, Key, T, Duration, Compare, Allocator>::
+aged_ordered_container <IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::
 emplace_hint (const_iterator hint, Args&&... args) ->
     typename std::enable_if <! maybe_multi,
         std::pair <iterator, bool>>::type
@@ -1752,10 +1752,10 @@ emplace_hint (const_iterator hint, Args&&... args) ->
 }
 
 template <bool IsMulti, bool IsMap, class Key, class T,
-    class Duration, class Compare, class Allocator>
+    class Clock, class Compare, class Allocator>
 template <bool is_const, class Iterator, class Base, class>
 detail::aged_container_iterator <false, Iterator, Base>
-aged_ordered_container <IsMulti, IsMap, Key, T, Duration, Compare, Allocator>::
+aged_ordered_container <IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::
 erase (detail::aged_container_iterator <is_const, Iterator, Base> pos)
 {
     unlink_and_delete_element(&*((pos++).iterator()));
@@ -1764,10 +1764,10 @@ erase (detail::aged_container_iterator <is_const, Iterator, Base> pos)
 }
 
 template <bool IsMulti, bool IsMap, class Key, class T,
-    class Duration, class Compare, class Allocator>
+    class Clock, class Compare, class Allocator>
 template <bool is_const, class Iterator, class Base, class>
 detail::aged_container_iterator <false, Iterator, Base>
-aged_ordered_container <IsMulti, IsMap, Key, T, Duration, Compare, Allocator>::
+aged_ordered_container <IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::
 erase (detail::aged_container_iterator <is_const, Iterator, Base> first,
        detail::aged_container_iterator <is_const, Iterator, Base> last)
 {
@@ -1779,10 +1779,10 @@ erase (detail::aged_container_iterator <is_const, Iterator, Base> first,
 }
 
 template <bool IsMulti, bool IsMap, class Key, class T,
-    class Duration, class Compare, class Allocator>
+    class Clock, class Compare, class Allocator>
 template <class K>
 auto
-aged_ordered_container <IsMulti, IsMap, Key, T, Duration, Compare, Allocator>::
+aged_ordered_container <IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::
 erase (K const& k) ->
     size_type
 {
@@ -1805,9 +1805,9 @@ erase (K const& k) ->
 }
 
 template <bool IsMulti, bool IsMap, class Key, class T,
-    class Duration, class Compare, class Allocator>
+    class Clock, class Compare, class Allocator>
 void
-aged_ordered_container <IsMulti, IsMap, Key, T, Duration, Compare, Allocator>::
+aged_ordered_container <IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::
 swap (aged_ordered_container& other) noexcept
 {
     swap_data (other);
@@ -1818,10 +1818,10 @@ swap (aged_ordered_container& other) noexcept
 //------------------------------------------------------------------------------
 
 template <bool IsMulti, bool IsMap, class Key, class T,
-    class Duration, class Compare, class Allocator>
+    class Clock, class Compare, class Allocator>
 template <class K>
 auto
-aged_ordered_container <IsMulti, IsMap, Key, T, Duration, Compare, Allocator>::
+aged_ordered_container <IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::
 touch (K const& k) ->
     size_type
 {
@@ -1839,19 +1839,19 @@ touch (K const& k) ->
 //------------------------------------------------------------------------------
 
 template <bool IsMulti, bool IsMap, class Key, class T,
-    class Duration, class Compare, class Allocator>
+    class Clock, class Compare, class Allocator>
 template <bool OtherIsMulti, bool OtherIsMap,
     class OtherT, class OtherDuration, class OtherAllocator>
 bool
-aged_ordered_container <IsMulti, IsMap, Key, T, Duration, Compare, Allocator>::
+aged_ordered_container <IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::
 operator== (
     aged_ordered_container <OtherIsMulti, OtherIsMap,
         Key, OtherT, OtherDuration, Compare,
             OtherAllocator> const& other) const
 {
-    typedef aged_ordered_container <OtherIsMulti, OtherIsMap,
+    using Other = aged_ordered_container <OtherIsMulti, OtherIsMap,
         Key, OtherT, OtherDuration, Compare,
-            OtherAllocator> Other;
+            OtherAllocator>;
     if (size() != other.size())
         return false;
     std::equal_to <void> eq;
@@ -1866,10 +1866,10 @@ operator== (
 //------------------------------------------------------------------------------
 
 template <bool IsMulti, bool IsMap, class Key, class T,
-    class Duration, class Compare, class Allocator>
+    class Clock, class Compare, class Allocator>
 template <bool is_const, class Iterator, class Base, class>
 void
-aged_ordered_container <IsMulti, IsMap, Key, T, Duration, Compare, Allocator>::
+aged_ordered_container <IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::
 touch (detail::aged_container_iterator <
     is_const, Iterator, Base> pos,
         typename clock_type::time_point const& now)
@@ -1881,10 +1881,10 @@ touch (detail::aged_container_iterator <
 }
 
 template <bool IsMulti, bool IsMap, class Key, class T,
-    class Duration, class Compare, class Allocator>
+    class Clock, class Compare, class Allocator>
 template <bool maybe_propagate>
 typename std::enable_if <maybe_propagate>::type
-aged_ordered_container <IsMulti, IsMap, Key, T, Duration, Compare, Allocator>::
+aged_ordered_container <IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::
 swap_data (aged_ordered_container& other) noexcept
 {
     std::swap (m_config.key_compare(), other.m_config.key_compare());
@@ -1893,10 +1893,10 @@ swap_data (aged_ordered_container& other) noexcept
 }
 
 template <bool IsMulti, bool IsMap, class Key, class T,
-    class Duration, class Compare, class Allocator>
+    class Clock, class Compare, class Allocator>
 template <bool maybe_propagate>
 typename std::enable_if <! maybe_propagate>::type
-aged_ordered_container <IsMulti, IsMap, Key, T, Duration, Compare, Allocator>::
+aged_ordered_container <IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::
 swap_data (aged_ordered_container& other) noexcept
 {
     std::swap (m_config.key_compare(), other.m_config.key_compare());
@@ -1908,9 +1908,9 @@ swap_data (aged_ordered_container& other) noexcept
 //------------------------------------------------------------------------------
 
 template <bool IsMulti, bool IsMap, class Key, class T,
-    class Duration, class Compare, class Allocator>
+    class Clock, class Compare, class Allocator>
 struct is_aged_container <detail::aged_ordered_container <
-        IsMulti, IsMap, Key, T, Duration, Compare, Allocator>>
+        IsMulti, IsMap, Key, T, Clock, Compare, Allocator>>
     : std::true_type
 {
 };
@@ -1918,22 +1918,22 @@ struct is_aged_container <detail::aged_ordered_container <
 // Free functions
 
 template <bool IsMulti, bool IsMap, class Key, class T,
-    class Duration, class Compare, class Allocator>
+    class Clock, class Compare, class Allocator>
 void swap (
     detail::aged_ordered_container <IsMulti, IsMap,
-        Key, T, Duration, Compare, Allocator>& lhs,
+        Key, T, Clock, Compare, Allocator>& lhs,
     detail::aged_ordered_container <IsMulti, IsMap,
-        Key, T, Duration, Compare, Allocator>& rhs) noexcept
+        Key, T, Clock, Compare, Allocator>& rhs) noexcept
 {
     lhs.swap (rhs);
 }
 
 /** Expire aged container items past the specified age. */
 template <bool IsMulti, bool IsMap, class Key, class T,
-    class Duration, class Compare, class Allocator,
+    class Clock, class Compare, class Allocator,
         class Rep, class Period>
 std::size_t expire (detail::aged_ordered_container <
-    IsMulti, IsMap, Key, T, Duration, Compare, Allocator>& c,
+    IsMulti, IsMap, Key, T, Clock, Compare, Allocator>& c,
         std::chrono::duration <Rep, Period> const& age)
 {
     std::size_t n (0);