Set version to 0.30.1-hf2

When specifying that a result should be rounded up,
the code rounded up to a value suitable for a non-xrp
amount. When called with an xrp amount, if that rounded-up
value was less than one drop, the code rounded down to zero.

This could cause funded offers to be removed as unfunded.

.gitignore

@@ -24,6 +24,11 @@ bin/rippled
 Debug/*.*
 Release/*.*
 
+# Ignore coverage files.
+*.gcno
+*.gcda
+*.gcov
+
 # Ignore locally installed node_modules
 /node_modules
 

.travis.yml

@@ -1,70 +1,75 @@
+sudo: false
 language: cpp
-compiler:
-  - clang
-  - gcc
+
 env:
-  - TARGET=debug
-  - TARGET=debug.nounity
-  # We can specify any combination of builds here, for example, to
-  # include release builds, too, uncomment the following lines.
-  #- TARGET=release
-  #- TARGET=release.nounity
+  global:
+    # Maintenance note: to move to a new version
+    # of boost, update both BOOST_ROOT and BOOST_URL.
+    # Note that for simplicity, BOOST_ROOT's final
+    # namepart must match the folder name internal
+    # to boost's .tar.gz.
+    - BOOST_ROOT=$HOME/boost_1_59_0
+    - BOOST_URL='http://downloads.sourceforge.net/project/boost/boost/1.59.0/boost_1_59_0.tar.gz?r=http%3A%2F%2Fsourceforge.net%2Fprojects%2Fboost%2Ffiles%2Fboost%2F1.59.0%2Fboost_1_59_0.tar.gz%2Fdownload&ts=1441761349&use_mirror=skylineservers'
+
+
+packages: &gcc5_pkgs
+  - gcc-5
+  - g++-5
+  - python-software-properties
+  - protobuf-compiler
+  - libprotobuf-dev
+  - libssl-dev
+  - libstdc++6
+  - binutils-gold
+  # Provides a backtrace if the unittests crash
+  - gdb
+
+packages: &clang36_pkgs
+  - clang-3.6
+  - g++-5
+  - python-software-properties
+  - protobuf-compiler
+  - libprotobuf-dev
+  - libssl-dev
+  - libstdc++6
+  - binutils-gold
+  # Provides a backtrace if the unittests crash
+  - gdb
+
+matrix:
+  include:
+    - compiler: gcc
+      env: GCC_VER=5 TARGET=debug.nounity
+      addons: &ao_gcc5
+        apt:
+          sources: ['ubuntu-toolchain-r-test']
+          packages: *gcc5_pkgs
+
+    - compiler: gcc
+      env: GCC_VER=5 TARGET=coverage
+      addons: *ao_gcc5
+
+    - compiler: clang
+      env: GCC_VER=5 TARGET=debug CLANG_VER=3.6
+      addons: &ao_clang36
+        apt:
+          sources: ['ubuntu-toolchain-r-test', 'llvm-toolchain-precise-3.6']
+          packages: *clang36_pkgs
+
+    - compiler: clang
+      env: GCC_VER=5 TARGET=debug.nounity CLANG_VER=3.6
+      addons: *ao_clang36
+
+cache:
+  directories:
+  - $BOOST_ROOT
+
 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:afrank/boost
-  - sudo apt-get update -qq
-  - sudo apt-get install -qq g++-4.8
-  - 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$"
-  - sudo apt-get install -qq protobuf-compiler libprotobuf-dev libssl-dev exuberant-ctags
-  # We need gcc >= 4.8 for some c++11 features
-  - sudo apt-get install -qq gcc-4.8
-  - sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-4.8 40 --slave /usr/bin/g++ g++ /usr/bin/g++-4.8
-  - sudo update-alternatives --set gcc /usr/bin/gcc-4.8
-  # Stuff is gold. Nuff said ;)
-  - sudo apt-get -y install binutils-gold
-  # We can get a backtrace if the guy crashes
-  - sudo apt-get -y install gdb
-  # 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
+  - bin/ci/ubuntu/install-dependencies.sh
 
 script:
-  # Set so any failing command will abort the build
-  - set -e
-  # 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.$TARGET
-  # We can be sure we're using the build/$CC.$TARGET variant (-f so never err)
-  - rm -f build/rippled 
-  - export RIPPLED_PATH="$PWD/build/$CC.$TARGET/rippled"
-  # See what we've actually built
-  - 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 $RIPPLED_PATH --unittest
-  - npm install
-  # Use build/(gcc|clang).$TARGET/rippled
-  - |
-    echo "exports.default_server_config = {\"rippled_path\" : \"$RIPPLED_PATH\"};" > test/config.js
+  - bin/ci/ubuntu/build-and-test.sh
 
-  # Run integration tests
-  - npm test
 notifications:
   email:
     false

Builds/Fedora/install_rippled_depends_fedora.sh

@@ -0,0 +1,22 @@
+#!/usr/bin/env bash
+
+#
+# This scripts installs the dependencies needed by rippled. It should be run
+# with sudo.
+#
+
+if [ ! -f /etc/fedora-release ]; then
+    echo "This script is meant to be run on fedora"
+    exit 1
+fi
+
+fedora_release=$(grep -o '[0-9]*' /etc/fedora-release)
+
+if (( $(bc <<< "${fedora_release} < 22") )); then
+    echo "This script is meant to run on fedora 22 or greater"
+    exit 1
+fi
+
+yum -y update
+yum -y group install "Development Tools"
+yum -y install gcc-c++ scons openssl-devel openssl-static protobuf-devel protobuf-static boost-devel boost-static libstdc++-static

Builds/Test.py

@@ -17,18 +17,29 @@
 
 """
 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 "${@}"
+    ./Builds/Test.py - builds and tests all configurations
+
+The build must succeed without shell aliases for this to work.
+
+To pass flags to scons, put them at the very end of the command line, after
+the -- flag - like this:
+
+    ./Builds/Test.py -- -j4   # Pass -j4 to scons.
+
+
+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
 

Builds/Ubuntu/install_boost.sh

@@ -0,0 +1,39 @@
+#!/usr/bin/env bash
+
+#
+# This script builds boost with the correct ABI flags for ubuntu
+#
+
+version=59
+patch=0
+
+if hash lsb_release 2>/dev/null; then
+    if [ $(lsb_release -si) == "Ubuntu" ]; then
+        ubuntu_release=$(lsb_release -sr)
+    fi
+fi
+
+if [ -z "${ubuntu_release}" ]; then
+    echo "System not supported"
+    exit 1
+fi
+
+extra_defines=""
+if (( $(bc <<< "${ubuntu_release} < 15.1") )); then
+    extra_defines="define=_GLIBCXX_USE_CXX11_ABI=0"
+fi
+num_procs=$(lscpu -p | grep -v '^#' | sort -u -t, -k 2,4 | wc -l) # pysical cores
+printf "\nBuild command will be: ./b2 -j${num_procs} ${extra_defines}\n\n"
+
+boost_dir="boost_1_${version}_${patch}"
+boost_tag="boost-1.${version}.${patch}"
+git clone -b "${boost_tag}" --recursive https://github.com/boostorg/boost.git "${boost_dir}"
+
+cd ${boost_dir}
+git checkout --force ${boost_tag}
+git submodule foreach git checkout --force ${boost_tag}
+./bootstrap.sh
+./b2 headers
+./b2 -j${num_procs} ${extra_defines}
+echo "Build command was: ./b2 -j${num_procs} ${extra_defines}"
+echo "Don't forget to set BOOST_ROOT!"

Builds/Ubuntu/install_rippled_depends_ubuntu.sh

@@ -0,0 +1,55 @@
+#!/usr/bin/env bash
+
+#
+# This scripts installs the dependencies needed by rippled. It should be run
+# with sudo. For ubuntu < 15.10, it installs gcc 5 as the default compiler. gcc
+# 5 is ABI incompatable with gcc 4. If needed, the following will switch back to
+# gcc-4: `sudo update-alternatives --config gcc` and choosing the gcc-4
+# option.
+#
+
+if hash lsb_release 2>/dev/null; then
+    if [ $(lsb_release -si) == "Ubuntu" ]; then
+        ubuntu_release=$(lsb_release -sr)
+    fi
+fi
+
+if [ -z "${ubuntu_release}" ]; then
+    echo "System not supported"
+    exit 1
+fi
+
+if [ ${ubuntu_release} == "12.04" ]; then
+    apt-get install python-software-properties
+    add-apt-repository ppa:afrank/boost
+    add-apt-repository ppa:ubuntu-toolchain-r/test
+    apt-get update
+    apt-get -y upgrade
+    apt-get -y install curl git scons ctags pkg-config protobuf-compiler libprotobuf-dev libssl-dev python-software-properties boost1.57-all-dev nodejs g++-5 g++-4.9
+    update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-5 99 --slave /usr/bin/g++ g++ /usr/bin/g++-5
+    update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-4.9 99 --slave /usr/bin/g++ g++ /usr/bin/g++-4.9
+    exit 0
+fi
+
+if [ ${ubuntu_release} == "14.04" ] || [ ${ubuntu_release} == "15.04" ]; then
+    apt-get install python-software-properties
+    echo "deb [arch=amd64] https://mirrors.ripple.com/ubuntu/ trusty stable contrib" | sudo tee /etc/apt/sources.list.d/ripple.list 
+    wget -O- -q https://mirrors.ripple.com/mirrors.ripple.com.gpg.key | sudo apt-key add -
+    add-apt-repository ppa:ubuntu-toolchain-r/test
+    apt-get update
+    apt-get -y upgrade
+    apt-get -y install curl git scons ctags pkg-config protobuf-compiler libprotobuf-dev libssl-dev python-software-properties boost-all-dev nodejs g++-5 g++-4.9
+    update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-5 99 --slave /usr/bin/g++ g++ /usr/bin/g++-5
+    update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-4.9 99 --slave /usr/bin/g++ g++ /usr/bin/g++-4.9
+    exit 0
+fi
+
+if [ ${ubuntu_release} == "15.10" ]; then
+    apt-get update
+    apt-get -y upgrade
+    apt-get -y install python-software-properties curl git scons ctags pkg-config protobuf-compiler libprotobuf-dev libssl-dev python-software-properties libboost-all-dev nodejs 
+    exit 0
+fi
+
+echo "System not supported"
+exit 1

Builds/VisualStudio2015/README.md

@@ -0,0 +1,357 @@
+# Visual Studio 2015 Build Instructions
+
+## Important
+
+We do not recommend Windows for rippled production use at this time. Currently, the Ubuntu
+platform has received the highest level of quality assurance, testing, and support.
+Additionally, 32-bit Windows versions are not supported.
+
+## Prerequisites
+
+To clone the source code repository, create branches for inspection or modification,
+build rippled under Visual Studio, and run the unit tests you will need these
+software components:
+
+* [Visual Studio 2015](README.md#install-visual-studio-2015)
+* [Git for Windows](README.md#install-git-for-windows)
+* [Google Protocol Buffers Compiler](README.md#install-google-protocol-buffers-compiler)
+* (Optional) [Python and Scons](README.md#optional-install-python-and-scons)
+* [OpenSSL Library](README.md#install-openssl)
+* [Boost 1.59 library](README.md#build-boost)
+* [Node.js](README.md#install-nodejs)
+
+## Install Software
+
+### Install Visual Studio 2015
+
+If not already installed on your system, download your choice of installer from the
+[Visual Studio 2015 Download](https://www.visualstudio.com/downloads/download-visual-studio-vs)
+page, run the installer, and follow the directions. You may need to choose a "Custom"
+installation and ensure that "Visual C++" is selected under "Programming Languages".
+
+Any version of Visual Studio 2015 may be used to build rippled.
+The **Visual Studio 2015 Community** edition is available free of charge (see
+[the product page](https://www.visualstudio.com/products/visual-studio-community-vs)
+for licensing details), while paid editions may be used for an free initial trial period.
+
+### Install Git for Windows
+
+Git is a distributed revision control system. The Windows version also provides the
+bash shell and many Windows versions of Unix commands. While there are other
+varieties of Git (such as TortoiseGit, which has a native Windows interface and
+integrates with the Explorer shell), we recommend installing
+[Git for Windows](https://git-scm.com/) since
+it provides a Unix-like command line environment useful for running shell scripts.
+Use of the bash shell under Windows is mandatory for running the unit tests.
+
+* NOTE: To gain full featured access to the
+  [git-subtree](https://blogs.atlassian.com/2013/05/alternatives-to-git-submodule-git-subtree/)
+  functionality used in the rippled repository we suggest Git version 2.6.2 or later.
+
+### Install Google Protocol Buffers Compiler
+
+Building rippled requires **protoc.exe** version 2.5.1 or later. At your option you
+may build it yourself from the sources in the
+[Google Protocol Buffers](https://github.com/google/protobuf) repository,
+or you may download a
+[protoc.exe](https://ripple.github.io/Downloads/protoc/2.5.1/protoc.exe)
+([alternate link](https://github.com/ripple/Downloads/raw/gh-pages/protoc/2.5.1/protoc.exe))
+precompiled Windows executable from the
+[Ripple Organization](https://github.com/ripple).
+
+Either way, once you have the required version of **protoc.exe**, copy it into
+a folder in your command line `%PATH%`.
+
+* **NOTE:** If you use an older version of the compiler, the build will
+  fail with errors related to a mismatch of the version of protocol
+  buffer headers versus the compiler.
+
+### (Optional) Install Python and Scons
+
+[Python](https://www.python.org/downloads/) and
+[Scons](http://scons.org/download.php) are not required to build
+rippled with Visual Studio, but can be used to build from the
+command line and in scripts, and are required to properly update
+the `RippleD.vcxproj` file.
+
+If you wish to build with scons, a version after 2.3.5 is required
+for Visual Studio 2015 support.
+
+## Configure Dependencies
+
+### Install OpenSSL
+
+[Download OpenSSL.](http://slproweb.com/products/Win32OpenSSL.html)
+There will be four variants available:
+
+1. 64-bit. Use this if you are running 64-bit windows. As of this writing, the link is called: "Win64 OpenSSL v1.0.2d".
+2. 64-bit light - Don't use this. It is missing files needed to build rippled. As of this writing, the link is called: "Win64 OpenSSL v1.0.2d Light"
+
+Run the installer, and choose an appropriate location for your OpenSSL
+installation. In this guide we use **C:\lib\OpenSSL-Win64** as the
+destination location.
+
+You may be informed on running the installer that "Visual C++ 2008
+Redistributables" must first be installed first. If so, download it
+from the [same page](http://slproweb.com/products/Win32OpenSSL.html),
+again making sure to get the correct 32-/64-bit variant.
+
+* NOTE: Since rippled links statically to OpenSSL, it does not matter
+  where the OpenSSL .DLL files are placed, or what version they are.
+  rippled does not use or require any external .DLL files to run
+  other than the standard operating system ones.
+
+### Build Boost
+
+After [downloading boost](http://www.boost.org/users/download/) and
+unpacking it, open a **Developer Command Prompt** for
+Visual Studio, change to the directory containing boost, then
+bootstrap the build tools:
+
+```powershell
+cd C:\lib\boost_1_59_0
+bootstrap
+```
+
+The rippled application is linked statically to the standard runtimes and external
+dependencies on Windows, to ensure that the behavior of the executable is not
+affected by changes in outside files. Therefore, it is necessary to build the
+required boost static libraries using this command:
+
+```powershell
+bjam --toolset=msvc-14.0 --build-type=complete variant=debug,release link=static runtime-link=static address-model=64
+```
+
+Building the boost libraries may take considerable time. When the build process
+is completed, take note of both the reported compiler include paths and linker
+library paths as they will be required later.
+
+* NOTE: If older versions of Visual Studio are also installed, the build may fail.
+  If this happens, make sure that only Visual Studio 2015 is installed. Due to
+  defects in the uninstallation procedures of these Microsoft products, it may
+  be necessary to start with a fresh install of the operating system with only
+  the necessary development environment components installed to have a successful build.
+
+### Clone the rippled repository
+
+If you are familiar with cloning github repositories, just follow your normal process
+and clone `git@github.com:ripple/rippled.git`. Otherwise follow this section for instructions.
+
+1. If you don't have a github account, sign up for one at
+  [github.com](https://github.com/).
+2. Make sure you have Github ssh keys. For help see
+  [generating-ssh-keys](https://help.github.com/articles/generating-ssh-keys).
+
+Open the "Git Bash" shell that was installed with "Git for Windows" in the
+step above. Navigate to the directory where you want to clone rippled (git
+bash uses `/c` for windows's `C:` and forward slash where windows uses
+backslash, so `C:\Users\joe\projs` would be `/c/Users/joe/projs` in git bash).
+Now clone the repository and optionally switch to the *master* branch.
+Type the following at the bash prompt:
+
+```powershell
+git clone git@github.com:ripple/rippled.git
+cd rippled
+git checkout master
+```
+
+* If you receive an error about not having the "correct access rights"
+  make sure you have Github ssh keys, as described above.
+
+### Configure Library Paths
+
+Open the solution file located at **Builds/Visual Studio 2015/ripple.sln**
+and select the "View->Other Windows->Property Manager" to bring up the Property Manager.
+Expand the *debug | x64* section and
+double click the *Microsoft.Cpp.x64.user* property sheet to bring up the
+*Property Pages* dialog. These are global properties applied to all
+64-bit build targets:
+
+![Visual Studio 2015 Global Properties](images/VS2015x64Properties.png)
+
+Go to *C/C++, General, Additional Include Directories* and add the
+location of the boost installation:
+
+![Visual Studio 2015 Include Directories](images/VS2015x64IncludeDirs.png)
+
+Then, go to *Linker, General, Additional Library Directories* and add
+the location of the compiled boost libraries reported at the completion
+of building the boost libraries:
+
+![Visual Studio 2015 Library Directories](images/VS2015x64LibraryDirs.png)
+
+Follow the same procedure for adding the `Additional Include Directories`
+and `Additional Library Directories` required for OpenSSL. In our example
+these directories are **C:\lib\OpenSSL-Win64\include** and
+**C:\lib\OpenSSL-Win64\lib** respectively.
+
+# Setup Environment
+
+## Create a working directory for rippled.cfg
+
+The rippled server uses the [Rippled.cfg](https://wiki.ripple.com/Rippled.cfg)
+file to read its configuration parameters. This section describes setting up
+a directory to hold the config file. The next sections describe how to tell
+the rippled server where that file is.
+
+1. Create a directory to hold the configuration file. In this example, the
+  ripple config directory was created in `C:\Users\joe\ripple\config`.
+2. Copy the example config file located in `doc\rippled-example.cfg` to the
+  new directory and rename it "rippled.cfg".
+3. Read the rippled.cfg file and edit as appropriate.
+
+## Change the Visual Studio Projects Debugging Properties
+
+1. If not already open, open the solution file located at **Builds/Visual Studio 2015/Ripple.sln**
+2. Select the correct solution platform in the solution platform dropdown (either *x64*
+  or *Win32* depending on machine type).
+3. Select the "Project->Properties" menu item to bring up RippleD's Properties Pages
+4. In "Configuration Properties" select "Debugging".
+5. In the upper-left Configurations drop down, select "All Configurations".
+6. In "Debugger to Launch" select "Local Windows Debugger".
+
+### Tell rippled where to find the configuration file.
+
+The `--conf` command-line switch to tell rippled where to find this file.
+In the "Command Arguments" field in the properties dialog (that you opened
+in the above section), add: `--conf="C:/Users/joe/ripple/config/rippled.cfg"`
+(of course replacing that path with the path you set up above).
+
+![Visual Studio 2013 Command Args Prop Page](images/VSCommandArgsPropPage.png)
+
+### Set the _NO_DEBUG_HEAP Environment Variable
+
+Rippled can run very slowly in the debugger when using the Windows Debug Heap.
+Set the `_NO_DEBUG_HEAP` environment variable to one to disable the debug heap.
+In the "Environment" field (that you opened in the above section), add:
+`_NO_DEBUG_HEAP=1`
+
+![Visual Studio 2013 No Debug Heap Prop Page](images/NoDebugHeapPropPage.png)
+
+# Build
+
+After these steps are complete, rippled should be ready to build. Simply
+set rippled as the startup project by right clicking on it in the
+Visual Studio Solution Explorer, choose **Set as Startup Project**,
+and then choose the **Build->Build Solution** menu item.
+
+# Unit Tests (Recommended)
+
+## Internal
+
+The internal rippled unit tests are written in C++ and are part
+of the rippled executable.
+
+From a Windows console, run the unit tests:
+
+```
+./build/msvc.debug/rippled.exe --unittest
+```
+
+Substitute the correct path to the executable to test different builds.
+
+## External
+
+The external rippled unit tests are written in Javascript using Node.js,
+and utilize the mocha unit test framework. To run the unit tests, it
+will be necessary to perform the following steps:
+
+### Install Node.js
+
+[Install Node.js](http://nodejs.org/download/). We recommend the Windows
+installer (**.msi** file) as it takes care of updating the *PATH* environment
+variable so that scripts can find the command. On Windows systems,
+**Node.js** comes with **npm**. A separate installation of **npm**
+is not necessary.
+
+### Create node_modules
+
+Open a windows console. From the root of your local rippled repository
+directory, invoke **npm** to bring in the necessary components:
+
+```
+npm install
+```
+
+If you get an error that looks like
+
+```
+Error: ENOENT, stat 'C:\Users\username\AppData\Roaming\npm'
+```
+
+simply create the indicated folder and try again.
+
+### Create a test config.js
+
+From a *bash* shell (installed with Git for Windows), copy the
+example configuration file into the appropriate location:
+
+```
+cp test/config-example.js test/config.js
+```
+
+Edit your version of test/config.js to reflect the correct path to the rippled executable:
+
+```
+exports.default_server_config = {
+  // Where to find the binary.
+  rippled_path: path.resolve(__dirname, "../build/msvc.debug/rippled.exe")
+};
+```
+
+Also in **test/config.js**, change any occurrences of the
+IP address *0.0.0.0* to *127.0.0.1*.
+
+### Run Tests
+
+From a windows console, run the unit tests:
+
+```
+npm test
+```
+
+Alternatively, run an individual test using mocha:
+
+```
+sh
+node_modules/mocha/bin/mocha test/account_tx-test.js
+```
+
+* NOTE: The version of ripple-lib provided by the npm install
+  facility is usually slightly behind the develop branch of the
+  authoritative ripple-lib repository. Therefore, some tests might fail.
+
+### Development ripple-lib
+
+To use the latest branch of **ripple-lib** during the unit tests,
+first clone the repository in a new location outside of your rippled
+repository. Then update the submodules. After, run **npm install**
+to set up the **node_modules** directory. Finally, install the
+**grunt** command line tools required to run **grunt** and
+build **ripple-lib**.
+
+```
+git clone git@github.com:ripple/ripple-lib.git
+cd ripple-lib
+git submodule update --init
+npm install
+npm install -g grunt-cli
+grunt
+```
+
+Now link this version of **ripple-lib** into the global packages:
+
+```
+sudo npm link
+```
+
+To make rippled use the newly linked global **ripple-lib** package
+instead of the one installed under **node_modules**, change
+directories to the local rippled repository and delete the old
+**ripple-lib** then link to the new one:
+
+```
+sh
+rm -rf node_modules/ripple-lib
+npm link ripple-lib
+```

Builds/VisualStudio2015/ripple.sln

@@ -1,9 +1,9 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio Express 2013 for Windows Desktop
-VisualStudioVersion = 12.0.31101.0
+# Visual Studio 14
+VisualStudioVersion = 14.0.23107.0
 MinimumVisualStudioVersion = 10.0.40219.1
-Project("{26B7D9AC-1A80-8EF8-6703-D061F1BECB75}") = "RippleD", "RippleD.vcxproj", "{26B7D9AC-1A80-8EF8-6703-D061F1BECB75}"
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "RippleD", "RippleD.vcxproj", "{26B7D9AC-1A80-8EF8-6703-D061F1BECB75}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution

Builds/rpm/rippled.spec

@@ -1,52 +0,0 @@
-Name:           rippled
-Version:        0.29.0
-Release:        1%{?dist}
-Summary:        Ripple peer-to-peer network daemon
-
-Group:          Applications/Internet
-License:        ISC
-URL:            https://github.com/ripple/rippled
-
-# curl -L -o SOURCES/rippled-release.zip https://github.com/ripple/rippled/archive/release.zip
-Source0:        rippled-release.zip
-BuildRoot:      %(mktemp -ud %{_tmppath}/%{name}-%{version}-%{release}-XXXXXX)
-
-BuildRequires:  gcc-c++ scons openssl-devel protobuf-devel
-Requires:       protobuf openssl
-
-
-%description
-Rippled is the server component of the Ripple network.
-
-
-%prep
-%setup -n rippled-release
-
-
-%build
-# Assume boost is manually installed
-export RIPPLED_BOOST_HOME=/usr/local/boost_1_55_0
-scons -j `grep -c processor /proc/cpuinfo` build/rippled
-
-
-%install
-rm -rf %{buildroot}
-mkdir -p %{buildroot}/usr/share/%{name}
-cp LICENSE %{buildroot}/usr/share/%{name}/
-mkdir -p %{buildroot}/usr/bin
-cp build/rippled %{buildroot}/usr/bin/rippled
-mkdir -p %{buildroot}/etc/%{name}
-cp doc/rippled-example.cfg %{buildroot}/etc/%{name}/rippled.cfg
-mkdir -p %{buildroot}/var/lib/%{name}/db
-mkdir -p %{buildroot}/var/log/%{name}
-
-
-%clean
-rm -rf %{buildroot}
-
-
-%files
-%defattr(-,root,root,-)
-/usr/bin/rippled
-/usr/share/rippled/LICENSE
-/etc/rippled/rippled-example.cfg

SConstruct

@@ -15,11 +15,13 @@
 
     clang           All clang variants
     clang.debug     clang debug variant
+    clang.coverage  clang coverage variant
     clang.release   clang release variant
     clang.profile   clang profile variant
 
     gcc             All gcc variants
     gcc.debug       gcc debug variant
+    gcc.coverage    gcc coverage variant
     gcc.release     gcc release variant
     gcc.profile     gcc profile variant
 
@@ -59,12 +61,34 @@ The following environment variables modify the build environment:
       Path to the boost directory.
     OPENSSL_ROOT
       Path to the openssl directory.
+    PROTOBUF_DIR
+      Path to the protobuf directory. This is usually only needed when
+      the installed protobuf library uses a different ABI than clang
+      (as with ubuntu 15.10).
 
 The following extra options may be used:
     --ninja         Generate a `build.ninja` build file for the specified target
                     (see: https://martine.github.io/ninja/). Only gcc and clang targets
                      are supported.
 
+    --static        On linux, link protobuf, openssl, libc++, and boost statically
+
+GCC 5: If the gcc toolchain is used, gcc version 5 or better is required. On
+    linux distros that ship with gcc 4 (ubuntu < 15.10), rippled will force gcc
+    to use gcc4's ABI (there was an ABI change between versions). This allows us
+    to use the package manager to install rippled dependencies. It also means if
+    the user builds C++ dependencies themselves - such as boost - they must
+    either be built with gcc 4 or with the preprocessor flag
+    `_GLIBCXX_USE_CXX11_ABI` set to zero.
+
+Clang on linux: Clang cannot use the new gcc 5 ABI (clang does not know about
+    the `abi_tag` attribute). On linux distros that ship with the gcc 5 ABI
+    (ubuntu >= 15.10), building with clang requires building boost and protobuf
+    with the old ABI (best to build them with clang). It is best to statically
+    link rippled in this scenario (use the `--static` with scons), as dynamic
+    linking may use a library with the incorrect ABI.
+
+
 '''
 #
 '''
@@ -98,29 +122,50 @@ import scons_to_ninja
 AddOption('--ninja', dest='ninja', action='store_true',
           help='generate ninja build file build.ninja')
 
-def parse_time(t):
-    return time.strptime(t, '%a %b %d %H:%M:%S %Z %Y')
+AddOption('--static', dest='static', action='store_true',
+          help='On linux, link protobuf, openssl, libc++, and boost statically')
+
+def parse_time(t):
+    l = len(t.split())
+    if l==5:
+        return time.strptime(t, '%a %b %d %H:%M:%S %Y')
+    elif l==3:
+        return time.strptime(t, '%d %b %Y')
+    else:
+        return time.strptime(t, '%a %b %d %H:%M:%S %Z %Y')
 
-CHECK_PLATFORMS = 'Debian', 'Ubuntu'
-CHECK_COMMAND = 'openssl version -a'
-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 memoize(function):
+  memo = {}
+  def wrapper(*args):
+    if args in memo:
+      return memo[args]
+    else:
+      rv = function(*args)
+      memo[args] = rv
+      return rv
+  return wrapper
+
 def check_openssl():
-    if Beast.system.platform in CHECK_PLATFORMS:
-        for line in subprocess.check_output(CHECK_COMMAND.split()).splitlines():
-            if line.startswith(CHECK_LINE):
-                line = line[len(CHECK_LINE):]
-                if parse_time(line) < parse_time(BUILD_TIME):
-                    raise Exception(OPENSSL_ERROR % (line, BUILD_TIME))
-                else:
-                    break
-        else:
-            raise Exception("Didn't find any '%s' line in '$ %s'" %
-                            (CHECK_LINE, CHECK_COMMAND))
+    if Beast.system.platform not in ['Debian', 'Ubuntu']:
+        return
+    line = subprocess.check_output('openssl version -b'.split()).strip()
+    check_line = 'built on: '
+    if not line.startswith(check_line):
+        raise Exception("Didn't find any '%s' line in '$ %s'" %
+                        (check_line, 'openssl version -b'))
+    d = line[len(check_line):]
+    if 'date unspecified' in d:
+        words = subprocess.check_output('openssl version'.split()).split()
+        if len(words)!=5:
+            raise Exception("Didn't find version date in '$ openssl version'")
+        d = ' '.join(words[-3:])
+    build_time = 'Mon Apr  7 20:33:19 UTC 2014'
+    if parse_time(d) < parse_time(build_time):
+        raise Exception('Your openSSL was built on %s; '
+                        'rippled needs a version built on or after %s.'
+                        % (line, build_time))
 
 
 def set_implicit_cache():
@@ -250,6 +295,41 @@ def print_coms(target, source, env):
     # TODO Add 'PROTOCCOM' to this list and make it work
     Beast.print_coms(['CXXCOM', 'CCCOM', 'LINKCOM'], env)
 
+def is_debug_variant(variant):
+  return variant in ('debug', 'coverage')
+
+@memoize
+def is_ubuntu():
+    try:
+        return "Ubuntu" == subprocess.check_output(['lsb_release', '-si'],
+                                                   stderr=subprocess.STDOUT).strip()
+    except:
+        return False
+
+@memoize
+def use_gcc4_abi(cc_cmd):
+    if os.getenv('RIPPLED_OLD_GCC_ABI'):
+        return True
+    gcc_ver = ''
+    ubuntu_ver = None
+    try:
+        if 'gcc' in cc_cmd:
+            gcc_ver = subprocess.check_output([cc_cmd, '-dumpversion'],
+                                            stderr=subprocess.STDOUT).strip()
+        else:
+            gcc_ver = '5' # assume gcc 5 for ABI purposes for clang
+
+        if is_ubuntu():
+            ubuntu_ver = float(
+                subprocess.check_output(['lsb_release', '-sr'],
+                    stderr=subprocess.STDOUT).strip())
+    except:
+        print("Unable to determine gcc version. Assuming native ABI.")
+        return False
+    if ubuntu_ver and ubuntu_ver < 15.1 and gcc_ver.startswith('5'):
+        return True
+    return False
+
 #-------------------------------------------------------------------------------
 
 # Set construction variables for the base environment
@@ -266,13 +346,13 @@ def config_base(env):
         'OPENSSL_NO_SSL2'
         ,'DEPRECATED_IN_MAC_OS_X_VERSION_10_7_AND_LATER'
         ,{'HAVE_USLEEP' : '1'}
+        ,{'SOCI_CXX_C11' : '1'}
+        ,'_SILENCE_STDEXT_HASH_DEPRECATION_WARNINGS'
+        ,'-DBOOST_NO_AUTO_PTR'
         ])
 
     try:
         BOOST_ROOT = os.path.normpath(os.environ['BOOST_ROOT'])
-        env.Append(CPPPATH=[
-            BOOST_ROOT,
-            ])
         env.Append(LIBPATH=[
             os.path.join(BOOST_ROOT, 'stage', 'lib'),
             ])
@@ -280,6 +360,12 @@ def config_base(env):
     except KeyError:
         pass
 
+    try:
+        protobuf_dir = os.environ['PROTOBUF_DIR']
+        env.Append(LIBPATH=[protobuf_dir])
+    except KeyError:
+        pass
+
     if Beast.system.windows:
         try:
             OPENSSL_ROOT = os.path.normpath(os.environ['OPENSSL_ROOT'])
@@ -287,7 +373,7 @@ def config_base(env):
                 os.path.join(OPENSSL_ROOT, 'include'),
                 ])
             env.Append(LIBPATH=[
-                os.path.join(OPENSSL_ROOT, 'lib', 'VC', 'static'),
+                os.path.join(OPENSSL_ROOT, 'lib'),
                 ])
         except KeyError:
             pass
@@ -307,18 +393,70 @@ def config_base(env):
         env.Append(CPPPATH=[os.path.join(profile_jemalloc, 'include')])
         env.Append(LINKFLAGS=['-Wl,-rpath,' + os.path.join(profile_jemalloc, 'lib')])
 
+def add_static_libs(env, static_libs, dyn_libs=None):
+    if not 'HASSTATICLIBS' in env:
+        env['HASSTATICLIBS'] = True
+        env.Replace(LINKCOM=env['LINKCOM'] + " -Wl,-Bstatic $STATICLIBS -Wl,-Bdynamic $DYNAMICLIBS")
+    for k,l in [('STATICLIBS', static_libs or []), ('DYNAMICLIBS', dyn_libs or [])]:
+        c = env.get(k, '')
+        for f in l:
+            c += ' -l' + f 
+        env[k] = c
+
+def get_libs(lib, static):
+    '''Returns a tuple of lists. The first element is the static libs,
+       the second element is the dynamic libs
+    '''
+    always_dynamic = ['dl', 'pthread', 'z', # for ubuntu
+                      'gssapi_krb5', 'krb5', 'com_err', 'k5crypto', # for fedora
+                      ]
+    try:
+        cmd = ['pkg-config', '--static', '--libs', lib]
+        libs = subprocess.check_output(cmd,
+                                       stderr=subprocess.STDOUT).strip()
+        all_libs = [l[2:] for l in libs.split() if l.startswith('-l')]
+        if not static:
+            return ([], all_libs)
+        static_libs = []
+        dynamic_libs = []
+        for l in all_libs:
+            if l in always_dynamic:
+                dynamic_libs.append(l)
+            else:
+                static_libs.append(l)
+        return (static_libs, dynamic_libs)
+    except:
+        raise Exception('pkg-config failed for ' + lib)
+
 # Set toolchain and variant specific construction variables
 def config_env(toolchain, variant, env):
-    if variant == 'debug':
+    if is_debug_variant(variant):
         env.Append(CPPDEFINES=['DEBUG', '_DEBUG'])
 
     elif variant == 'release' or variant == 'profile':
         env.Append(CPPDEFINES=['NDEBUG'])
 
+    if 'BOOST_ROOT' in env:
+        if toolchain == 'gcc':
+            env.Append(CCFLAGS=['-isystem' + env['BOOST_ROOT']])
+        else:
+            env.Append(CPPPATH=[
+                env['BOOST_ROOT'],
+                ])
+
+    if should_link_static() and not Beast.system.linux:
+        raise Exception("Static linking is only implemented for linux.")
+
     if toolchain in Split('clang gcc'):
         if Beast.system.linux:
-            env.ParseConfig('pkg-config --static --cflags --libs openssl')
-            env.ParseConfig('pkg-config --static --cflags --libs protobuf')
+            link_static = should_link_static()
+            for l in ['openssl', 'protobuf']:
+                static, dynamic = get_libs(l, link_static) 
+                if link_static:
+                    add_static_libs(env, static, dynamic)
+                else:
+                    env.Append(LIBS=dynamic)
+                env.ParseConfig('pkg-config --static --cflags ' + l)
 
         env.Prepend(CFLAGS=['-Wall'])
         env.Prepend(CXXFLAGS=['-Wall'])
@@ -351,7 +489,7 @@ def config_env(toolchain, variant, env):
 
         env.Append(CXXFLAGS=[
             '-frtti',
-            '-std=c++11',
+            '-std=c++14',
             '-Wno-invalid-offsetof'])
 
         env.Append(CPPDEFINES=['_FILE_OFFSET_BITS=64'])
@@ -370,9 +508,19 @@ def config_env(toolchain, variant, env):
                 '-Wno-unused-function',
                 ])
         else:
+            if should_link_static():
+                env.Append(LINKFLAGS=[
+                    '-static-libstdc++',
+                ])
+            if use_gcc4_abi(env['CC'] if 'CC' in env else 'gcc'):
+                env.Append(CPPDEFINES={
+                    '-D_GLIBCXX_USE_CXX11_ABI' : 0
+                })
             if toolchain == 'gcc':
+
                 env.Append(CCFLAGS=[
-                    '-Wno-unused-but-set-variable'
+                    '-Wno-unused-but-set-variable',
+                    '-Wno-deprecated',
                     ])
 
         boost_libs = [
@@ -385,16 +533,19 @@ def config_env(toolchain, variant, env):
             'boost_system',
             'boost_thread'
         ]
-        # We prefer static libraries for boost
-        if env.get('BOOST_ROOT'):
-            static_libs = ['%s/stage/lib/lib%s.a' % (env['BOOST_ROOT'], l) for
-                           l in boost_libs]
-            if all(os.path.exists(f) for f in static_libs):
-                boost_libs = [File(f) for f in static_libs]
-
-        env.Append(LIBS=boost_libs)
         env.Append(LIBS=['dl'])
 
+        if should_link_static():
+            add_static_libs(env, boost_libs)
+        else:
+            # We prefer static libraries for boost
+            if env.get('BOOST_ROOT'):
+                static_libs = ['%s/stage/lib/lib%s.a' % (env['BOOST_ROOT'], l) for
+                               l in boost_libs]
+                if all(os.path.exists(f) for f in static_libs):
+                    boost_libs = [File(f) for f in static_libs]
+            env.Append(LIBS=boost_libs)
+
         if Beast.system.osx:
             env.Append(LIBS=[
                 'crypto',
@@ -414,6 +565,12 @@ def config_env(toolchain, variant, env):
                 '-fno-strict-aliasing'
                 ])
 
+        if variant == 'coverage':
+             env.Append(CXXFLAGS=[
+                 '-fprofile-arcs', '-ftest-coverage'])
+             env.Append(LINKFLAGS=[
+                 '-fprofile-arcs', '-ftest-coverage'])
+
         if toolchain == 'clang':
             if Beast.system.osx:
                 env.Replace(CC='clang', CXX='clang++', LINK='clang++')
@@ -428,6 +585,8 @@ def config_env(toolchain, variant, env):
             env.Append(CXXFLAGS=[
                 '-Wno-mismatched-tags',
                 '-Wno-deprecated-register',
+                '-Wno-unused-local-typedefs',
+                '-Wno-unknown-warning-option',
                 ])
 
         elif toolchain == 'gcc':
@@ -441,7 +600,7 @@ def config_env(toolchain, variant, env):
             # If we are in debug mode, use GCC-specific functionality to add
             # extra error checking into the code (e.g. std::vector will throw
             # for out-of-bounds conditions)
-            if variant == 'debug':
+            if is_debug_variant(variant):
                 env.Append(CPPDEFINES={
                     '_FORTIFY_SOURCE': 2
                     })
@@ -485,9 +644,18 @@ def config_env(toolchain, variant, env):
             '_CRT_SECURE_NO_WARNINGS',
             'WIN32_CONSOLE',
             ])
+        if variant == 'debug':
+            env.Append(LIBS=[
+                'VC/static/ssleay32MTd.lib',
+                'VC/static/libeay32MTd.lib',
+                ])
+        else:
+            env.Append(LIBS=[
+                'VC/static/ssleay32MT.lib',
+                'VC/static/libeay32MT.lib',
+                ])
         env.Append(LIBS=[
-            'ssleay32MT.lib',
-            'libeay32MT.lib',
+            'legacy_stdio_definitions.lib',
             'Shlwapi.lib',
             'kernel32.lib',
             'user32.lib',
@@ -553,13 +721,14 @@ base.Append(CPPPATH=[
     os.path.join('src', 'beast'),
     os.path.join(build_dir, 'proto'),
     os.path.join('src','soci','src'),
+    os.path.join('src','soci','include'),
     ])
 
 base.Decider('MD5-timestamp')
 set_implicit_cache()
 
 # Configure the toolchains, variants, default toolchain, and default target
-variants = ['debug', 'release', 'profile']
+variants = ['debug', 'coverage', 'release', 'profile']
 all_toolchains = ['clang', 'gcc', 'msvc']
 if Beast.system.osx:
     toolchains = ['clang']
@@ -634,6 +803,7 @@ def get_soci_sources(style):
     result = []
     cpp_path = [
         'src/soci/src/core',
+        'src/soci/include/private',
         'src/sqlite', ]
     append_sources(result,
                    'src/ripple/unity/soci.cpp',
@@ -644,17 +814,36 @@ def get_soci_sources(style):
                        CPPPATH=cpp_path)
     return result
 
-def get_common_sources():
+def use_shp(toolchain):
+    '''
+    Return True if we want to use the --system-header-prefix command-line switch
+    '''
+    if toolchain != 'clang':
+        return False
+    if use_shp.cache is None:
+        try:
+            ver = subprocess.check_output(
+                ['clang', '--version'], stderr=subprocess.STDOUT).strip()
+            use_shp.cache = 'version 3.4' not in ver and 'version 3.0' not in ver
+        except:
+            use_shp.cache = False
+    return use_shp.cache
+use_shp.cache = None
+
+def get_common_sources(toolchain):
     result = []
+    if toolchain == 'msvc':
+        warning_flags = {}
+    else:
+        warning_flags = {'CCFLAGS': ['-Wno-unused-function']}
     append_sources(
         result,
         'src/ripple/unity/secp256k1.cpp',
-        CPPPATH=[
-            'src/secp256k1',
-        ])
+        CPPPATH=['src/secp256k1'],
+        **warning_flags)
     return result
 
-def get_classic_sources():
+def get_classic_sources(toolchain):
     result = []
     append_sources(
         result,
@@ -676,7 +865,13 @@ def get_classic_sources():
     append_sources(result, *list_sources('src/ripple/rpc', '.cpp'))
     append_sources(result, *list_sources('src/ripple/shamap', '.cpp'))
     append_sources(result, *list_sources('src/ripple/test', '.cpp'))
-   
+    append_sources(result, *list_sources('src/ripple/unl', '.cpp'))
+
+    if use_shp(toolchain):
+        cc_flags = {'CCFLAGS': ['--system-header-prefix=rocksdb2']}
+    else:
+        cc_flags = {}
+
     append_sources(
         result,
         *list_sources('src/ripple/nodestore', '.cpp'),
@@ -684,14 +879,15 @@ def get_classic_sources():
             'src/rocksdb2/include',
             'src/snappy/snappy',
             'src/snappy/config',
-        ])
+        ],
+        **cc_flags)
 
     result += get_soci_sources('classic')
-    result += get_common_sources()
+    result += get_common_sources(toolchain)
 
     return result
 
-def get_unity_sources():
+def get_unity_sources(toolchain):
     result = []
     append_sources(
         result,
@@ -713,8 +909,14 @@ def get_unity_sources():
         'src/ripple/unity/rpcx.cpp',
         'src/ripple/unity/shamap.cpp',
         'src/ripple/unity/test.cpp',
+        'src/ripple/unity/unl.cpp',
     )
 
+    if use_shp(toolchain):
+        cc_flags = {'CCFLAGS': ['--system-header-prefix=rocksdb2']}
+    else:
+        cc_flags = {}
+
     append_sources(
         result,
         'src/ripple/unity/nodestore.cpp',
@@ -722,10 +924,11 @@ def get_unity_sources():
             'src/rocksdb2/include',
             'src/snappy/snappy',
             'src/snappy/config',
-        ])
+        ],
+        **cc_flags)
 
     result += get_soci_sources('unity')
-    result += get_common_sources()
+    result += get_common_sources(toolchain)
 
     return result
 
@@ -763,6 +966,13 @@ def should_prepare_targets(style, toolchain, variant):
         if should_prepare_target(t, style, toolchain, variant):
             return True
 
+def should_link_static():
+    """
+    Return True if libraries should be linked statically
+
+    """
+    return GetOption('static')
+
 def should_build_ninja(style, toolchain, variant):
     """
     Return True if a ninja build file should be generated.
@@ -789,15 +999,11 @@ def should_build_ninja(style, toolchain, variant):
     return False
 
 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':
+            if variant in ['profile', 'coverage'] and toolchain == 'msvc':
                 continue
             # Configure this variant's construction environment
             env = base.Clone()
@@ -817,6 +1023,10 @@ for tu_style in ['classic', 'unity']:
 
             object_builder = ObjectBuilder(env, variant_dirs)
 
+            if tu_style == 'classic':
+                sources = get_classic_sources(toolchain)
+            else:
+                sources = get_unity_sources(toolchain)
             for s, k in sources:
                 object_builder.add_source_files(*s, **k)
 
@@ -832,6 +1042,11 @@ for tu_style in ['classic', 'unity']:
                 'src/ripple/unity/git_id.cpp',
                 **git_commit_tag)
 
+            if use_shp(toolchain):
+                cc_flags = {'CCFLAGS': ['--system-header-prefix=rocksdb2']}
+            else:
+                cc_flags = {}
+
             object_builder.add_source_files(
                 'src/beast/beast/unity/hash_unity.cpp',
                 'src/ripple/unity/beast.cpp',
@@ -840,8 +1055,8 @@ for tu_style in ['classic', 'unity']:
                 'src/ripple/unity/ripple.proto.cpp',
                 'src/ripple/unity/resource.cpp',
                 'src/ripple/unity/server.cpp',
-                'src/ripple/unity/validators.cpp',
-                'src/ripple/unity/websocket02.cpp'
+                'src/ripple/unity/websocket02.cpp',
+                **cc_flags
             )
 
             object_builder.add_source_files(
@@ -849,9 +1064,11 @@ for tu_style in ['classic', 'unity']:
                 CCFLAGS = ([] if toolchain == 'msvc' else ['-Wno-array-bounds']))
 
             if 'gcc' in toolchain:
-                no_uninitialized_warning = {'CCFLAGS': ['-Wno-maybe-uninitialized']}
+                cc_flags = {'CCFLAGS': ['-Wno-maybe-uninitialized']}
+            elif use_shp(toolchain):
+                cc_flags = {'CCFLAGS': ['--system-header-prefix=rocksdb2']}
             else:
-                no_uninitialized_warning = {}
+                cc_flags = {}
 
             object_builder.add_source_files(
                 'src/ripple/unity/ed25519.c',
@@ -868,7 +1085,7 @@ for tu_style in ['classic', 'unity']:
                     'src/snappy/snappy',
                     'src/snappy/config',
                 ],
-                **no_uninitialized_warning
+                **cc_flags
             )
 
             object_builder.add_source_files(
@@ -926,7 +1143,7 @@ for key, value in aliases.iteritems():
     env.Alias(key, value)
 
 vcxproj = base.VSProject(
-    os.path.join('Builds', 'VisualStudio2013', 'RippleD'),
+    os.path.join('Builds', 'VisualStudio2015', 'RippleD'),
     source = [],
     VSPROJECT_ROOT_DIRS = ['src/beast', 'src', '.'],
     VSPROJECT_CONFIGS = msvc_configs)

appveyor.yml

@@ -6,20 +6,22 @@ environment:
   # 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
+  RIPPLED_DEPS_URL: https://ripple.github.io/Downloads/appveyor/rippled_deps15.01.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
+  BOOST_ROOT: C:/rippled_deps15.01/boost
+  OPENSSL_ROOT: C:/rippled_deps15.01/openssl
+
+os: Visual Studio 2015
 
 # At the end of each successful build we cache this directory. It must be less
 # than 100MB total compressed.
 cache:
-  - "C:\\rippled_deps"
+  - "C:\\rippled_deps15.01"
 
 # This means we'll download a zip of the branch we want, rather than the full
 # history.
@@ -27,7 +29,7 @@ shallow_clone: true
 
 install:
   # We want easy_install, python and protoc.exe on PATH.
-  - SET PATH=%PYTHON%;%PYTHON%/Scripts;C:/rippled_deps;%PATH%
+  - SET PATH=%PYTHON%;%PYTHON%/Scripts;C:/rippled_deps15.01;%PATH%
 
   # `ps` prefix means the command is executed by powershell.
   - ps: Start-FileDownload $env:PIP_URL
@@ -46,9 +48,17 @@ install:
   # Download dependencies if appveyor didn't restore them from the cache.
   # Use 7zip to unzip.
   - ps: |
-        if (-not(Test-Path 'C:/rippled_deps')) {
+        if (-not(Test-Path 'C:/rippled_deps15.01')) {
+            echo "Download from $env:RIPPLED_DEPS_URL"
             Start-FileDownload "$env:RIPPLED_DEPS_URL"
-            7z x rippled_deps.zip -oC:\ -y > $null
+            7z x rippled_deps15.01.zip -oC:\ -y > $null
+        }
+
+  # Newer DEPS include a versions file.
+  # Dump it so we can verify correct behavior.
+  - ps: |
+        if (Test-Path 'C:/rippled_deps15.01/versions.txt') {
+          cat 'C:/rippled_deps15.01/versions.txt'
         }
 
 # TODO: This is giving me grief
@@ -58,7 +68,7 @@ install:
 
 build_script:
   # We set the environment variables needed to put compilers on the PATH.
-  - '"%VS120COMNTOOLS%../../VC/vcvarsall.bat" x86_amd64'
+  - '"%VS140COMNTOOLS%../../VC/vcvarsall.bat" x86_amd64'
   # Show which version of the compiler we are using.
   - cl
   - scons msvc.debug -j%NUMBER_OF_PROCESSORS%

bin/ci/ubuntu/build-and-test.sh

@@ -0,0 +1,41 @@
+#!/bin/bash -u
+# We use set -e and bash with -u to bail on first non zero exit code of any
+# processes launched or upon any unbound variable
+set -e
+__dirname=$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )
+echo "using CC: $CC"
+echo "using TARGET: $TARGET"
+export RIPPLED_PATH="$PWD/build/$CC.$TARGET/rippled"
+echo "using RIPPLED_PATH: $RIPPLED_PATH"
+# Make sure vcxproj is up to date
+scons vcxproj
+git diff --exit-code
+# $CC will be either `clang` or `gcc`
+# http://docs.travis-ci.com/user/migrating-from-legacy/?utm_source=legacy-notice&utm_medium=banner&utm_campaign=legacy-upgrade
+#   indicates that 2 cores are available to containers.
+scons -j${NUM_PROCESSORS:-2} $CC.$TARGET
+# We can be sure we're using the build/$CC.$TARGET variant
+# (-f so never err)
+rm -f build/rippled
+
+# See what we've actually built
+ldd $RIPPLED_PATH
+if [[ $TARGET == "coverage" ]]; then
+  $RIPPLED_PATH --unittest
+  # We pass along -p to keep path segments so as to avoid collisions
+  codecov --gcov-args=-p --gcov-source-match='^src/(ripple|beast)'
+else
+  if [[ $CC == "clang" ]]; then
+    # gdb segfaults with a clang build
+    $RIPPLED_PATH --unittest
+  else
+    # Run unittests (under gdb)
+    cat $__dirname/unittests.gdb | gdb \
+        --return-child-result \
+        --args $RIPPLED_PATH --unittest
+  fi
+fi
+
+# Run NPM tests
+npm install
+npm test --rippled=$RIPPLED_PATH

bin/ci/ubuntu/install-dependencies.sh

@@ -0,0 +1,34 @@
+#!/bin/bash -u
+# Exit if anything fails.
+set -e
+# Override gcc version to $GCC_VER.
+# Put an appropriate symlink at the front of the path.
+mkdir -v $HOME/bin
+for g in gcc g++ gcov gcc-ar gcc-nm gcc-ranlib
+do
+  test -x $( type -p ${g}-$GCC_VER )
+  ln -sv $(type -p ${g}-$GCC_VER) $HOME/bin/${g}
+done
+for c in clang clang++
+do
+    test -x $( type -p ${c}-$CLANG_VER )
+    ln -sv $(type -p ${c}-$CLANG_VER) $HOME/bin/${c}
+done
+export PATH=$PWD/bin:$PATH
+
+# What versions are we ACTUALLY running?
+if [ -x $HOME/bin/g++ ]; then
+    $HOME/bin/g++ -v
+fi
+if [ -x $HOME/bin/clang ]; then
+    $HOME/bin/clang -v
+fi
+# 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
+chown -Rc $USER ~/.npm
+# We use this so we can filter the subtrees from our coverage report
+pip install --user https://github.com/sublimator/codecov-python/zipball/source-match
+
+bash bin/sh/install-boost.sh

bin/ci/ubuntu/unittests.gdb

@@ -0,0 +1,4 @@
+set env MALLOC_CHECK_=3
+set print thread-events off
+run
+backtrace full

bin/sh/install-boost.sh

@@ -0,0 +1,22 @@
+#!/bin/sh
+# Assumptions:
+# 1) BOOST_ROOT and BOOST_URL are already defined,
+# and contain valid values.
+# 2) The last namepart of BOOST_ROOT matches the
+# folder name internal to boost's .tar.gz
+# When testing you can force a boost build by clearing travis caches:
+# https://travis-ci.org/ripple/rippled/caches
+set -e
+if [ ! -d "$BOOST_ROOT/lib" ]
+then
+  wget $BOOST_URL -O /tmp/boost.tar.gz
+  cd `dirname $BOOST_ROOT`
+  rm -fr ${BOOST_ROOT}
+  tar xzf /tmp/boost.tar.gz
+  cd $BOOST_ROOT && \
+    ./bootstrap.sh --prefix=$BOOST_ROOT && \
+    ./b2 -d1 define=_GLIBCXX_USE_CXX11_ABI=0 && ./b2 -d0 define=_GLIBCXX_USE_CXX11_ABI=0 install
+else
+  echo "Using cached boost at $BOOST_ROOT"
+fi
+

circle.yml

@@ -3,28 +3,33 @@ machine:
     - 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 'deb http://llvm.org/apt/precise/ llvm-toolchain-precise-3.6 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
+    - sudo apt-get install -qq clang-3.6 gcc-5 g++-5 libobjc-5-dev libgcc-5-dev libstdc++-5-dev libclang1-3.6 libgcc1 libgomp1 libstdc++6 scons protobuf-compiler libprotobuf-dev libssl-dev exuberant-ctags
+    - lsb_release -a
+    - sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-5 99
+    - sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-5 99
+    - sudo update-alternatives --force --install /usr/bin/clang clang /usr/bin/clang-3.6 99 --slave /usr/bin/clang++ clang++ /usr/bin/clang++-3.6
     - gcc --version
     - clang --version
+    - clang++ --version
 test:
   pre:
     - scons clang.debug
   override:
     - | # create gdb script
-      echo "set env MALLOC_CHECK_=3" > script.gdb 
+      echo "set env MALLOC_CHECK_=3" > script.gdb
       echo "run" >> script.gdb
-      echo "backtrace full" >> 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
+    # gdb segfaults
+    # - cat script.gdb | gdb --ex 'set print thread-events off' --return-child-result --args build/clang.debug/rippled --unittest
+    - build/clang.debug/rippled --unittest
     - npm install
     # Use build/(gcc|clang).debug/rippled
     - |

doc/CHANGELOG

@@ -26,3 +26,4 @@ A list of rippled version numbers, and the Github pull requests they contain.
 0.28.2-b7: Includes pulls 1077, 1080, 1086, 1095, 1098, 1106 and 1112.
 0.28.2-b8: Includes pulls 1078, 1100, 1108, 1114, 1118, 1119 and 1121.
 0.28.2-b9: Includes pulls 1053, 1109, 1111, 1117, 1122 and 1123.
+0.29.1-b11: Includes pulls 1279, 1271, 1289, 1291, 1290, 1267, 1294, 1276, 1231, and 1286.

doc/rippled-example.cfg

@@ -212,6 +212,29 @@
 #       in the submitted JSON for any administrative command requests when
 #       invoking JSON-RPC commands on remote servers.
 #
+#   secure_gateway = [ IP, IP, IP, ... ]
+#
+#       A comma-separated list of IP addresses.
+#
+#       When set, allows the specified IP addresses to pass HTTP headers
+#       containing username and remote IP address for each session. If a
+#       non-empty username is passed in this way, then resource controls
+#       such as often resulting in "tooBusy" errors will be lifted. However,
+#       administrative RPC commands such as "stop" will not be allowed.
+#       The HTTP headers that secure_gateway hosts can set are X-User and
+#       X-Forwarded-For. Only the X-User header affects resource controls.
+#       However, both header values are logged to help identify user activity.
+#       If no X-User header is passed, or if its value is empty, then
+#       resource controls will default to those for non-administrative users.
+#
+#       The secure_gateway IP addresses are intended to represent
+#       proxies. Since rippled trusts these hosts, they must be
+#       responsible for properly authenticating the remote user.
+#
+#       The same IP address cannot be used in both "admin" and "secure_gateway"
+#       lists for the same port. In this case, rippled will abort with an error
+#       message to the console shortly after startup
+#
 #   ssl_key = <filename>
 #   ssl_cert = <filename>
 #   ssl_chain = <filename>
@@ -293,6 +316,7 @@
 #   [ips]
 #   r.ripple.com 51235
 #
+#   The default is: [ips_fixed] addresses (if present) or r.ripple.com 51235
 #
 #
 # [ips_fixed]
@@ -359,37 +383,50 @@
 #
 #
 #
-# [overlay] EXPERIMENTAL
+# [overlay]
+#
+#   Controls settings related to the peer to peer overlay.
+#
+#   A set of key/value pair parameters to configure the overlay.
+#
+#   public_ip = <IP-address>
+#
+#       If the server has a known, fixed public IPv4 address,
+#       specify that IP address here in dotted decimal notation.
+#       Peers will use this information to reject attempt to proxy
+#       connections to or from this server.
+#
+#   ip_limit = <number>
+#
+#       The maximum number of incoming peer connections allowed by a single
+#       IP that isn't classified as "private" in RFC1918. The implementation
+#       imposes some hard and soft upper limits on this value to prevent a
+#       single host from consuming all inbound slots. If the value is not
+#       present the server will autoconfigure an appropriate limit.
+#
+#
+#
+# [transaction_queue] EXPERIMENTAL
 #
 #   This section is EXPERIMENTAL, and should not be
 #   present for production configuration settings.
 #
-#   A set of key/value pair parameters to configure the overlay.
+#   A set of key/value pair parameters to tune the performance of the
+#   transaction queue.
 #
-#   auto_connect = 0 | 1
+#   ledgers_in_queue = <number>
 #
-#       When set, activates the autoconnect feature. This maintains outgoing
-#       connections using PeerFinder's "Outgoing Connection Strategy."
+#       The queue will be limited to this <number> of average ledgers'
+#       worth of transactions. If the queue fills up, the transactions
+#       with the lowest fees will be dropped from the queue any time a
+#       transaction with a higher fee level is added. Default: 20.
 #
-#   become_superpeer = 'never' | 'always' | 'auto'
+#   retry_sequence_percent = <number>
 #
-#       Controls the selection of peer roles:
-#
-#       '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).
-#
-#       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.
-#
-#       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.
+#       If a client resubmits a transaction, the new transaction's fee
+#       must be more than <number> percent higher than the original
+#       transaction's fee, or meet the current open ledger fee to be
+#       considered. Default: 125.
 #
 #
 #
@@ -523,6 +560,9 @@
 # [path_search_max]
 #   When searching for paths, the minimum and maximum search aggressiveness.
 #
+#   If you do not need pathfinding, you can set path_search_max to zero to
+#   disable it and avoid some expensive bookkeeping.
+#
 #   The default for 'path_search_fast' is 2. The default for 'path_search_max' is 10.
 #
 # [path_search_old]
@@ -687,7 +727,7 @@
 #
 # [debug_logfile]
 #
-#   Specifies were a debug logfile is kept. By default, no debug log is kept.
+#   Specifies where a debug logfile is kept. By default, no debug log is kept.
 #   Unless absolute, the path is relative the directory containing this file.
 #
 #   Example: debug.log

package.json

@@ -7,20 +7,20 @@
     "test": "test"
   },
   "dependencies": {
+    "assert-diff": "^1.0.1",
     "async": "~0.2.9",
+    "babel": "^5.8.21",
+    "coffee-script": "^1.8.0",
     "deep-equal": "0.0.0",
     "extend": "~1.2.0",
     "lodash": "^3.5.0",
+    "mocha": "^2.1.0",
     "request": "^2.47.0",
-    "ripple-lib": "0.10.0",
+    "ripple-lib": "0.13.0-rc6.0",
     "simple-jsonrpc": "~0.0.2"
   },
-  "devDependencies": {
-    "assert-diff": "^1.0.1",
-    "coffee-script": "^1.8.0",
-    "mocha": "^2.1.0"
-  },
   "scripts": {
+    "pretest": "node test/pretest.js",
     "test": "mocha test/websocket-test.js test/server-test.js test/*-test.{js,coffee}"
   },
   "repository": {

src/BeastConfig.h

@@ -164,37 +164,9 @@
 #define RIPPLE_SINGLE_IO_SERVICE_THREAD 0
 #endif
 
-/** Config: RIPPLE_HOOK_VALIDATORS
-    Activates code for handling validations and validators (work in progress).
-*/
-#ifndef RIPPLE_HOOK_VALIDATORS
-#define RIPPLE_HOOK_VALIDATORS 0
-#endif
-
-/** Config: RIPPLE_ENABLE_TICKETS
-    Enables processing of ticket transactions
-*/
-#ifndef RIPPLE_ENABLE_TICKETS
-#define RIPPLE_ENABLE_TICKETS 0
-#endif
-
-/** Config: RIPPLE_ENABLE_MULTI_SIGN
-    When set, activates the current state of the multi-sign feature which is
-    under development.  When the feature is complete and released this
-    #define should be removed.
-*/
-#ifndef RIPPLE_ENABLE_MULTI_SIGN
-#define RIPPLE_ENABLE_MULTI_SIGN 0
-#endif
-
 // Uses OpenSSL instead of alternatives
 #ifndef RIPPLE_USE_OPENSSL
-#define RIPPLE_USE_OPENSSL 0
-#endif
-
-// Enables the experimental OpenLedger
-#ifndef RIPPLE_OPEN_LEDGER
-#define RIPPLE_OPEN_LEDGER 0
+#define RIPPLE_USE_OPENSSL 1
 #endif
 
 #endif

src/beast/beast/Arithmetic.h

@@ -26,8 +26,6 @@
 
 #include <beast/Config.h>
 
-#include <beast/utility/noexcept.h>
-
 #include <cmath>
 #include <cstdint>
 #include <algorithm>

src/beast/beast/ByteOrder.h

@@ -194,7 +194,7 @@ namespace detail
 {
 
 /** Specialized helper class template for swapping bytes.
-    
+
     Normally you won't use this directly, use the helper function
     byteSwap instead. You can specialize this class for your
     own user defined types, as was done for uint24.
@@ -204,7 +204,7 @@ namespace detail
 template <typename IntegralType>
 struct SwapBytes
 {
-    inline IntegralType operator() (IntegralType value) const noexcept 
+    inline IntegralType operator() (IntegralType value) const noexcept
     {
         return ByteOrder::swap (value);
     }
@@ -215,7 +215,7 @@ struct SwapBytes
 template <>
 struct SwapBytes <std::int16_t>
 {
-    inline std::int16_t operator() (std::int16_t value) const noexcept 
+    inline std::int16_t operator() (std::int16_t value) const noexcept
     {
         return static_cast <std::int16_t> (ByteOrder::swap (static_cast <std::uint16_t> (value)));
     }
@@ -224,7 +224,7 @@ struct SwapBytes <std::int16_t>
 template <>
 struct SwapBytes <std::int32_t>
 {
-    inline std::int32_t operator() (std::int32_t value) const noexcept 
+    inline std::int32_t operator() (std::int32_t value) const noexcept
     {
         return static_cast <std::int32_t> (ByteOrder::swap (static_cast <std::uint32_t> (value)));
     }
@@ -233,7 +233,7 @@ struct SwapBytes <std::int32_t>
 template <>
 struct SwapBytes <std::int64_t>
 {
-    inline std::int64_t operator() (std::int64_t value) const noexcept 
+    inline std::int64_t operator() (std::int64_t value) const noexcept
     {
         return static_cast <std::int64_t> (ByteOrder::swap (static_cast <std::uint64_t> (value)));
     }

src/beast/beast/Config.h

@@ -56,5 +56,5 @@
 
 // Suffix
 #include <beast/config/Suffix.h>
-    
+
 #endif

src/beast/beast/Memory.h

@@ -25,7 +25,7 @@
 #define BEAST_MEMORY_H_INCLUDED
 
 #include <cstring>
-    
+
 #include <beast/Config.h>
 
 namespace beast {
@@ -86,7 +86,7 @@ Type* createCopyIfNotNull (const Type* pointer)
 
     ScopedAutoReleasePool(ScopedAutoReleasePool const&) = delete;
     ScopedAutoReleasePool& operator= (ScopedAutoReleasePool const&) = delete;
-    
+
  private:
      void* pool;
  };

src/beast/beast/Threads.h

@@ -24,7 +24,6 @@
 #include <beast/threads/TryLockGuard.h>
 #include <beast/threads/SharedLockGuard.h>
 #include <beast/threads/SharedMutexAdapter.h>
-#include <beast/threads/SharedData.h>
 #include <beast/threads/SpinLock.h>
 #include <beast/threads/Stoppable.h>
 #include <beast/threads/Thread.h>

src/beast/beast/asio/README.md

@@ -6,9 +6,9 @@ Wrappers and utilities to make working with boost::asio easier.
 
 If an object calls asynchronous initiating functions it must either:
 
-	1. Manage its lifetime by being reference counted
+    1. Manage its lifetime by being reference counted
 
-	or
+    or
 
-	2. Wait for all pending completion handlers to be called before
-	   allowing itself to be destroyed.
+    2. Wait for all pending completion handlers to be called before
+       allowing itself to be destroyed.

src/beast/beast/asio/bind_handler.h

@@ -25,8 +25,8 @@
 #include <boost/asio/detail/handler_invoke_helpers.hpp>
 
 #include <functional>
-#include <beast/cxx14/type_traits.h> // <type_traits>
-#include <beast/cxx14/utility.h> // <utility>
+#include <type_traits>
+#include <utility>
 
 namespace beast {
 namespace asio {

src/beast/beast/asio/error.h

@@ -34,7 +34,7 @@ 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);

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

@@ -41,8 +41,8 @@ asio_message (boost::system::error_code const& ec)
             + ","
             + boost::lexical_cast<std::string> (ERR_GET_REASON (ec.value ()))
             + ") ";
-        
-        // 
+
+        //
         char buf[errorBufferSize];
         ::ERR_error_string_n (ec.value (), buf, errorBufferSize);
         error += buf;

src/beast/beast/asio/streambuf.h

@@ -28,7 +28,7 @@
 #include <cassert>
 #include <memory>
 #include <exception>
-#include <beast/cxx14/type_traits.h> // <type_traits>
+#include <type_traits>
 #include <string>
 #include <utility>
 
@@ -112,7 +112,7 @@ private:
         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

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

@@ -28,7 +28,7 @@ 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 ());

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

@@ -145,7 +145,7 @@ public:
             b.commit(10);
             expect(to_str(b.data()) == "567890ABCD");
         }
-        
+
         test_prepare();
         test_commit();
         test_consume();

src/beast/beast/asio/waitable_executor.h

@@ -27,7 +27,7 @@
 #include <functional>
 #include <memory>
 #include <mutex>
-#include <beast/cxx14/type_traits.h> // <type_traits>
+#include <type_traits>
 #include <utility>
 #include <vector>
 

src/beast/beast/chrono/RelativeTime.h

@@ -27,7 +27,6 @@
 #include <beast/Config.h>
 #include <beast/strings/String.h>
 
-#include <beast/utility/noexcept.h>
 #include <string>
 #include <sstream>
 

src/beast/beast/chrono/abstract_clock.h

@@ -69,12 +69,6 @@ public:
 
     /** Returns the current time. */
     virtual time_point now() const = 0;
-
-    /** Returning elapsed ticks since the epoch. */
-    rep elapsed() const
-    {
-        return now().time_since_epoch().count();
-    }
 };
 
 //------------------------------------------------------------------------------

src/beast/beast/chrono/chrono_io.h

@@ -29,10 +29,9 @@
 
 #include <beast/Config.h>
 
-#include <beast/utility/noexcept.h>
 #include <ctime>
 #include <locale>
-    
+
 /*
 
     chrono_io synopsis
@@ -58,7 +57,7 @@ public:
 
     explicit durationpunct(size_t refs = 0);
     explicit durationpunct(duration_style fmt, size_t refs = 0);
-    
+
     bool is_symbol_name() const noexcept;
     bool is_prefix_name() const noexcept;
 };

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

@@ -268,7 +268,7 @@ static double monotonicCurrentTimeInSeconds()
 {
     return GetTickCount64() / 1000.0;
 }
- 
+
 }
 }
 
@@ -279,7 +279,7 @@ static double monotonicCurrentTimeInSeconds()
 
 namespace beast {
 namespace detail {
-    
+
 static double monotonicCurrentTimeInSeconds()
 {
     struct StaticInitializer
@@ -291,7 +291,7 @@ static double monotonicCurrentTimeInSeconds()
 
             mach_timebase_info_data_t timebase;
             (void) mach_timebase_info (&timebase);
-            
+
             if (timebase.numer % 1000000 == 0)
             {
                 numerator   = timebase.numer / 1000000.0;
@@ -304,13 +304,13 @@ static double monotonicCurrentTimeInSeconds()
                 //denominator = timebase.denom * (std::uint64_t) 1000000 * 1000.0;
                 denominator = timebase.denom * 1000000000.0;
             }
-            
+
             ratio = numerator / denominator;
         }
 
         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 {
@@ -334,7 +334,7 @@ static double monotonicCurrentTimeInSeconds()
 
 }
 }
-    
+
 #endif
 
 namespace beast {
@@ -349,7 +349,7 @@ static double getStartupTime()
         {
             when = detail::monotonicCurrentTimeInSeconds();
         }
-        
+
         double when;
     };
 
@@ -368,7 +368,7 @@ struct StartupTimeStaticInitializer
 };
 
 static StartupTimeStaticInitializer startupTimeStaticInitializer;
-    
+
 }
 
 RelativeTime RelativeTime::fromStartup ()

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

@@ -22,5 +22,4 @@
 #ifndef BEAST_CONFIG_COMPILER_VISUALC_H_INCLUDED
 #define BEAST_CONFIG_COMPILER_VISUALC_H_INCLUDED
 
-#include <beast/utility/noexcept.h>
 #endif

src/beast/beast/container/buffer_view.h

@@ -28,8 +28,8 @@
 #include <iterator>
 #include <memory>
 #include <string>
+#include <type_traits>
 #include <vector>
-#include <beast/cxx14/type_traits.h> // <type_traits>
 
 namespace beast {
 

src/beast/beast/container/cyclic_iterator.h

@@ -115,7 +115,7 @@ struct cyclic_iterator_base
 }
 
 //
-// cyclic_iterator_decl.hpp 
+// cyclic_iterator_decl.hpp
 //
 
 /**

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

@@ -25,15 +25,17 @@
 #include <beast/container/aged_container.h>
 #include <beast/chrono/abstract_clock.h>
 #include <beast/utility/empty_base_optimization.h>
+#include <beast/utility/empty_base_optimization.h>
+#include <beast/cxx14/type_traits.h>
 #include <boost/intrusive/list.hpp>
 #include <boost/intrusive/set.hpp>
 #include <boost/version.hpp>
-#include <beast/cxx14/algorithm.h> // <algorithm>
+#include <algorithm>
 #include <functional>
 #include <initializer_list>
 #include <iterator>
 #include <memory>
-#include <beast/cxx14/type_traits.h> // <type_traits>
+#include <type_traits>
 #include <utility>
 
 namespace beast {

src/beast/beast/container/detail/aged_unordered_container.h

@@ -27,12 +27,12 @@
 #include <beast/utility/empty_base_optimization.h>
 #include <boost/intrusive/list.hpp>
 #include <boost/intrusive/unordered_set.hpp>
-#include <beast/cxx14/algorithm.h> // <algorithm>
+#include <algorithm>
 #include <functional>
 #include <initializer_list>
 #include <iterator>
 #include <memory>
-#include <beast/cxx14/type_traits.h> // <type_traits>
+#include <type_traits>
 #include <utility>
 
 /*

src/beast/beast/crypto/base64.h

@@ -25,7 +25,7 @@
 
 namespace beast {
 
-/* 
+/*
    Portions from http://www.adp-gmbh.ch/cpp/common/base64.html
    Copyright notice:
 

src/beast/beast/crypto/detail/mac_facade.h

@@ -22,7 +22,6 @@
 
 #include <beast/crypto/secure_erase.h>
 #include <beast/hash/endian.h>
-#include <beast/utility/noexcept.h>
 #include <type_traits>
 #include <array>
 
@@ -44,7 +43,7 @@ public:
         std::array<std::uint8_t,
             Context::digest_size>;
 
-    mac_facade() noexcept 
+    mac_facade() noexcept
     {
         init(ctx_);
     }

src/beast/beast/crypto/detail/ripemd_context.h

@@ -20,7 +20,6 @@
 #ifndef BEAST_CRYPTO_RIPEMD_CONTEXT_H_INCLUDED
 #define BEAST_CRYPTO_RIPEMD_CONTEXT_H_INCLUDED
 
-#include <beast/utility/noexcept.h>
 #include <array>
 #include <cstdint>
 #include <cstring>
@@ -71,12 +70,12 @@ struct ripemd160_context
 #define BEAST_RIPEMD_ROL(x, n)  (((x) << (n)) | ((x) >> (32-(n))))
 
 // the five basic functions F(), G() and H()
-#define BEAST_RIPEMD_F(x, y, z)  ((x) ^  (y) ^ (z)) 
-#define BEAST_RIPEMD_G(x, y, z) (((x) &  (y)) | (~(x) & (z))) 
+#define BEAST_RIPEMD_F(x, y, z)  ((x) ^  (y) ^ (z))
+#define BEAST_RIPEMD_G(x, y, z) (((x) &  (y)) | (~(x) & (z)))
 #define BEAST_RIPEMD_H(x, y, z) (((x) | ~(y)) ^ (z))
-#define BEAST_RIPEMD_I(x, y, z) (((x) &  (z)) | ((y) & ~(z))) 
+#define BEAST_RIPEMD_I(x, y, z) (((x) &  (z)) | ((y) & ~(z)))
 #define BEAST_RIPEMD_J(x, y, z)  ((x) ^  ((y) | ~(z)))
-  
+
 // the ten basic operations FF() through III()
 #define BEAST_RIPEMD_FF(a, b, c, d, e, x, s) {      \
       (a) += BEAST_RIPEMD_F((b), (c), (d)) + (x);   \
@@ -166,7 +165,7 @@ void ripemd_compress (ripemd160_context& ctx,
     BEAST_RIPEMD_FF(cc, dd, ee, aa, bb, X[13],  7);
     BEAST_RIPEMD_FF(bb, cc, dd, ee, aa, X[14],  9);
     BEAST_RIPEMD_FF(aa, bb, cc, dd, ee, X[15],  8);
-                             
+
     // round 2
     BEAST_RIPEMD_GG(ee, aa, bb, cc, dd, X[ 7],  7);
     BEAST_RIPEMD_GG(dd, ee, aa, bb, cc, X[ 4],  6);
@@ -258,7 +257,7 @@ void ripemd_compress (ripemd160_context& ctx,
     BEAST_RIPEMD_JJJ(aaa, bbb, ccc, ddd, eee, X[12],  6);
 
     // parallel round 2
-    BEAST_RIPEMD_III(eee, aaa, bbb, ccc, ddd, X[ 6],  9); 
+    BEAST_RIPEMD_III(eee, aaa, bbb, ccc, ddd, X[ 6],  9);
     BEAST_RIPEMD_III(ddd, eee, aaa, bbb, ccc, X[11], 13);
     BEAST_RIPEMD_III(ccc, ddd, eee, aaa, bbb, X[ 3], 15);
     BEAST_RIPEMD_III(bbb, ccc, ddd, eee, aaa, X[ 7],  7);

src/beast/beast/crypto/detail/sha2_context.h

@@ -20,7 +20,6 @@
 #ifndef BEAST_CRYPTO_SHA512_CONTEXT_H_INCLUDED
 #define BEAST_CRYPTO_SHA512_CONTEXT_H_INCLUDED
 
-#include <beast/utility/noexcept.h>
 #include <cstdint>
 #include <cstring>
 
@@ -34,7 +33,7 @@ namespace detail {
 /*
  * Updated to C++, zedwood.com 2012
  * Based on Olivier Gay's version
- * See Modified BSD License below: 
+ * See Modified BSD License below:
  *
  * FIPS 180-2 SHA-224/256/384/512 implementation
  * Issue date:  04/30/2005
@@ -83,7 +82,7 @@ struct sha512_context
 {
     static unsigned int const block_size = 128;
     static unsigned int const digest_size = 64;
- 
+
     unsigned int tot_len;
     unsigned int len;
     unsigned char block[2 * block_size];
@@ -369,7 +368,7 @@ void init (sha512_context& ctx) noexcept
     ctx.h[3] = 0xa54ff53a5f1d36f1ULL;
     ctx.h[4] = 0x510e527fade682d1ULL;
     ctx.h[5] = 0x9b05688c2b3e6c1fULL;
-    ctx.h[6] = 0x1f83d9abfb41bd6bULL; 
+    ctx.h[6] = 0x1f83d9abfb41bd6bULL;
     ctx.h[7] = 0x5be0cd19137e2179ULL;
 }
 

src/beast/beast/cxx14/algorithm.h

@@ -1,94 +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_CXX14_ALGORITHM_H_INCLUDED
-#define BEAST_CXX14_ALGORITHM_H_INCLUDED
-
-#include <beast/cxx14/config.h>
-#include <beast/cxx14/functional.h>
-
-#include <algorithm>
-
-#if ! BEAST_NO_CXX14_EQUAL
-
-namespace std {
-
-namespace detail {
-
-template <class Pred, class FwdIt1, class FwdIt2>
-bool equal (FwdIt1 first1, FwdIt1 last1,
-    FwdIt2 first2, FwdIt2 last2, Pred pred,
-        std::input_iterator_tag, std::input_iterator_tag)
-{
-    for (; first1 != last1 && first2 != last2; ++first1, ++first2)
-        if (! pred (*first1, *first2))
-            return false;
-    return first1 == last1 && first2 == last2;
-}
-
-template <class Pred, class RanIt1, class RanIt2>
-bool equal (RanIt1 first1, RanIt1 last1,
-    RanIt2 first2, RanIt2 last2, Pred pred,
-        random_access_iterator_tag,
-            random_access_iterator_tag )
-{
-    if (std::distance (first1, last1) !=
-            std::distance (first2, last2))
-        return false;
-    for (; first1 != last1; ++first1, ++first2)
-        if (! pred (*first1, *first2))
-            return false;
-    return true;
-}
-
-}
-
-/** C++14 implementation of std::equal. */
-/** @{ */
-template <class FwdIt1, class FwdIt2>
-bool equal (FwdIt1 first1, FwdIt1 last1,
-    FwdIt2 first2, FwdIt2 last2)
-{
-    return std::detail::equal (first1, last1,
-        first2, last2, std::equal_to <void>(),
-            typename std::iterator_traits <
-                FwdIt1>::iterator_category(),
-                    typename std::iterator_traits <
-                        FwdIt2>::iterator_category());
-}
-
-template <class FwdIt1, class FwdIt2, class Pred>
-bool equal (FwdIt1 first1, FwdIt1 last1,
-    FwdIt2 first2, FwdIt2 last2, Pred pred)
-{
-    return std::detail::equal <
-        typename std::add_lvalue_reference <Pred>::type> (
-            first1, last1, first2, last2, pred,
-                typename std::iterator_traits <
-                    FwdIt1>::iterator_category(),
-                        typename std::iterator_traits <
-                            FwdIt2>::iterator_category());
-}
-/** @} */
-
-}
-
-#endif
-
-#endif

src/beast/beast/cxx14/config.h

@@ -1,84 +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_CXX14_CONFIG_H_INCLUDED
-#define BEAST_CXX14_CONFIG_H_INCLUDED
-
-#include <ciso646>  // detect libc++ verison
-
-// Sets C++14 compatibility configuration macros based on build environment
-
-// Disables beast c++14 compatibility additions when set to 1
-// Note, some compatibilty features are enabled or disabled individually.
-//
-#ifndef BEAST_NO_CXX14_COMPATIBILITY
-# ifdef _MSC_VER
-#  define BEAST_NO_CXX14_COMPATIBILITY 1
-# elif defined(__clang__) && defined(_LIBCPP_VERSION) && __cplusplus >= 201402
-#  define BEAST_NO_CXX14_COMPATIBILITY 1
-# else
-#  define BEAST_NO_CXX14_COMPATIBILITY 0
-# endif
-#endif
-
-// Disables beast's std::make_unique
-#ifndef BEAST_NO_CXX14_MAKE_UNIQUE
-# ifdef _MSC_VER
-#  define BEAST_NO_CXX14_MAKE_UNIQUE 1
-# elif defined(__clang__) && defined(_LIBCPP_VERSION) && __cplusplus >= 201402
-#  define BEAST_NO_CXX14_MAKE_UNIQUE 1
-# else
-#  define BEAST_NO_CXX14_MAKE_UNIQUE 0
-# endif
-#endif
-
-// Disables beast's std::equal safe iterator overloads
-#ifndef BEAST_NO_CXX14_EQUAL
-# ifdef _MSC_VER
-#  define BEAST_NO_CXX14_EQUAL 0
-# elif defined(__clang__) && defined(_LIBCPP_VERSION) && __cplusplus >= 201402
-#  define BEAST_NO_CXX14_EQUAL 1
-# else
-#  define BEAST_NO_CXX14_EQUAL 0
-# endif
-#endif
-
-// Disables beast's std::integer_sequence
-#ifndef BEAST_NO_CXX14_INTEGER_SEQUENCE
-# ifdef _MSC_VER
-#  define BEAST_NO_CXX14_INTEGER_SEQUENCE 0
-# elif defined(__clang__) && defined(_LIBCPP_VERSION) && __cplusplus >= 201402
-#  define BEAST_NO_CXX14_INTEGER_SEQUENCE 1
-# else
-#  define BEAST_NO_CXX14_INTEGER_SEQUENCE 0
-# endif
-#endif
-
-// Disables beast's std::make_reverse_iterator
-#ifndef BEAST_NO_CXX14_MAKE_REVERSE_ITERATOR
-# ifdef _MSC_VER
-#  define BEAST_NO_CXX14_MAKE_REVERSE_ITERATOR 0
-# elif defined(__clang__) && defined(_LIBCPP_VERSION) && __cplusplus >= 201402
-#  define BEAST_NO_CXX14_MAKE_REVERSE_ITERATOR 1
-# else
-#  define BEAST_NO_CXX14_MAKE_REVERSE_ITERATOR 0
-# endif
-#endif
-
-#endif

src/beast/beast/cxx14/cxx14.unity.cpp

@@ -1,20 +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/cxx14/tests/integer_sequence.test.cpp>

src/beast/beast/cxx14/functional.h

@@ -1,53 +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_CXX14_FUNCTIONAL_H_INCLUDED
-#define BEAST_CXX14_FUNCTIONAL_H_INCLUDED
-
-#include <beast/cxx14/config.h>
-
-#include <functional>
-#include <type_traits>
-#include <utility>
-
-#if ! BEAST_NO_CXX14_COMPATIBILITY
-
-namespace std {
-
-// C++14 implementation of std::equal_to <void> specialization.
-// This supports heterogeneous comparisons.
-template <>
-struct equal_to <void>
-{
-    // VFALCO NOTE Its not clear how to support is_transparent pre c++14
-    using is_transparent = std::true_type;
-
-    template <class T, class U>
-    auto operator() (T&& lhs, U&& rhs) const ->
-        decltype (std::forward <T> (lhs) == std::forward <U> (rhs))
-    {
-        return std::forward <T> (lhs) == std::forward <U> (rhs);
-    }
-};
-
-}
-
-#endif
-
-#endif

src/beast/beast/cxx14/iterator.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_CXX14_ITERATOR_H_INCLUDED
-#define BEAST_CXX14_ITERATOR_H_INCLUDED
-
-#include <beast/cxx14/config.h>
-
-#include <iterator>
-
-#if ! BEAST_NO_CXX14_MAKE_REVERSE_ITERATOR
-
-namespace std {
-
-// C++14 implementation of std::make_reverse_iterator to allow creation of a
-// reverse iterator from a given iterator.
-template <class Iter>
-inline
-reverse_iterator<Iter>
-make_reverse_iterator(Iter i)
-{
-    return reverse_iterator<Iter>(i);
-}
-
-}
-
-#endif
-
-#endif

src/beast/beast/cxx14/memory.h

@@ -1,39 +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_CXX14_MEMORY_H_INCLUDED
-#define BEAST_CXX14_MEMORY_H_INCLUDED
-
-#include <beast/cxx14/config.h>
-
-#include <memory>
-
-namespace std {
-
-#if ! BEAST_NO_CXX14_MAKE_UNIQUE
-template <class T, class... Args>
-std::unique_ptr <T> make_unique (Args&&... args)
-{
-    return std::unique_ptr <T> (new T (std::forward <Args> (args)...));
-}
-#endif
-
-}
-
-#endif

src/beast/beast/cxx14/tests/integer_sequence.test.cpp

@@ -1,113 +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
-
-#if ! BEAST_NO_CXX14_INTEGER_SEQUENCE
-
-#include <beast/cxx14/utility.h>
-
-#include <beast/unit_test/suite.h>
-
-namespace beast {
-namespace asio {
-
-class integer_sequence_test : public unit_test::suite
-{
-public:
-    template <class AtContainer, class T, T... I>
-    static
-    auto
-    extract (AtContainer const& t,
-        std::integer_sequence <T, I...>) ->
-            decltype (std::make_tuple (std::get <I> (t)...))
-    {
-        return std::make_tuple (std::get <I> (t)...);
-    }
-
-    void run()
-    {
-        // Code from
-        // http://llvm.org/svn/llvm-project/libcxx/trunk/test/utilities/intseq/intseq.general/integer_seq.pass.cpp
-
-        //  Make a couple of sequences
-        using int3    = std::make_integer_sequence<int, 3>;     // generates int:    0,1,2
-        using size7   = std::make_integer_sequence<size_t, 7>;  // generates size_t: 0,1,2,3,4,5,6
-        using size4   = std::make_index_sequence<4>;            // generates size_t: 0,1,2,3
-        using size2   = std::index_sequence_for<int, size_t>;   // generates size_t: 0,1
-        using intmix  = std::integer_sequence<int, 9, 8, 7, 2>; // generates int:    9,8,7,2
-        using sizemix = std::index_sequence<1, 1, 2, 3, 5>;     // generates size_t: 1,1,2,3,5
-    
-        // Make sure they're what we expect
-        static_assert ( std::is_same <int3::value_type, int>::value, "int3 type wrong" );
-        static_assert ( int3::static_size == 3, "int3 size wrong" );
-    
-        static_assert ( std::is_same <size7::value_type, size_t>::value, "size7 type wrong" );
-        static_assert ( size7::static_size == 7, "size7 size wrong" );
-    
-        static_assert ( std::is_same <size4::value_type, size_t>::value, "size4 type wrong" );
-        static_assert ( size4::static_size == 4, "size4 size wrong" );
-    
-        static_assert ( std::is_same <size2::value_type, size_t>::value, "size2 type wrong" );
-        static_assert ( size2::static_size == 2, "size2 size wrong" );
-    
-        static_assert ( std::is_same <intmix::value_type, int>::value, "intmix type wrong" );
-        static_assert ( intmix::static_size == 4, "intmix size wrong" );
-
-        static_assert ( std::is_same <sizemix::value_type, size_t>::value, "sizemix type wrong" );
-        static_assert ( sizemix::static_size == 5, "sizemix size wrong" );
-
-        auto tup = std::make_tuple ( 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20 );
-    
-        //  Use them
-        auto t3 = extract ( tup, int3() );
-        static_assert ( std::tuple_size<decltype(t3)>::value == int3::static_size, "t3 size wrong");
-        expect ( t3 == std::make_tuple ( 10, 11, 12 ));
-
-        auto t7 = extract ( tup, size7 ());
-        static_assert ( std::tuple_size<decltype(t7)>::value == size7::static_size, "t7 size wrong");
-        expect ( t7 == std::make_tuple ( 10, 11, 12, 13, 14, 15, 16 ));
-
-        auto t4 = extract ( tup, size4 ());
-        static_assert ( std::tuple_size<decltype(t4)>::value == size4::static_size, "t4 size wrong");
-        expect ( t4 == std::make_tuple ( 10, 11, 12, 13 ));
-
-        auto t2 = extract ( tup, size2 ());
-        static_assert ( std::tuple_size<decltype(t2)>::value == size2::static_size, "t2 size wrong");
-        expect ( t2 == std::make_tuple ( 10, 11 ));
-
-        auto tintmix = extract ( tup, intmix ());
-        static_assert ( std::tuple_size<decltype(tintmix)>::value == intmix::static_size, "tintmix size wrong");
-        expect ( tintmix == std::make_tuple ( 19, 18, 17, 12 ));
-
-        auto tsizemix = extract ( tup, sizemix ());
-        static_assert ( std::tuple_size<decltype(tsizemix)>::value == sizemix::static_size, "tsizemix size wrong");
-        expect ( tsizemix == std::make_tuple ( 11, 11, 12, 13, 15 ));
-        pass();
-    }
-};
-
-BEAST_DEFINE_TESTSUITE(integer_sequence,cxx14,beast);
-
-}
-}
-
-#endif

src/beast/beast/cxx14/type_traits.h

@@ -20,8 +20,6 @@
 #ifndef BEAST_CXX14_TYPE_TRAITS_H_INCLUDED
 #define BEAST_CXX14_TYPE_TRAITS_H_INCLUDED
 
-#include <beast/cxx14/config.h>
-
 #include <tuple>
 #include <type_traits>
 #include <utility>
@@ -43,105 +41,6 @@ struct is_constructible <pair <T, U>>
 {
 };
 
-namespace detail {
-
-template <bool...>
-struct compile_time_all;
-
-template <>
-struct compile_time_all <>
-{
-    static const bool value = true;
-};
-
-template <bool Arg0, bool ... Argn>
-struct compile_time_all <Arg0, Argn...>
-{
-    static const bool value =
-        Arg0 && compile_time_all <Argn...>::value;
-};
-
-}
-
-template <class ...T>
-struct is_constructible <tuple <T...>>
-    : integral_constant <bool,
-        detail::compile_time_all <
-            is_default_constructible <T>::value...>::value>
-{
-};
-
-//------------------------------------------------------------------------------
-
-#if ! BEAST_NO_CXX14_COMPATIBILITY
-
-// From http://llvm.org/svn/llvm-project/libcxx/trunk/include/type_traits
-
-// const-volatile modifications:
-template <class T>
-using remove_const_t    = typename remove_const<T>::type;  // C++14
-template <class T>
-using remove_volatile_t = typename remove_volatile<T>::type;  // C++14
-template <class T>
-using remove_cv_t       = typename remove_cv<T>::type;  // C++14
-template <class T>
-using add_const_t       = typename add_const<T>::type;  // C++14
-template <class T>
-using add_volatile_t    = typename add_volatile<T>::type;  // C++14
-template <class T>
-using add_cv_t          = typename add_cv<T>::type;  // C++14
-  
-// reference modifications:
-template <class T>
-using remove_reference_t     = typename remove_reference<T>::type;  // C++14
-template <class T>
-using add_lvalue_reference_t = typename add_lvalue_reference<T>::type;  // C++14
-template <class T>
-using add_rvalue_reference_t = typename add_rvalue_reference<T>::type;  // C++14
-  
-// sign modifications:
-template <class T>
-using make_signed_t   = typename make_signed<T>::type;  // C++14
-template <class T>
-using make_unsigned_t = typename make_unsigned<T>::type;  // C++14
-  
-// array modifications:
-template <class T>
-using remove_extent_t      = typename remove_extent<T>::type;  // C++14
-template <class T>
-using remove_all_extents_t = typename remove_all_extents<T>::type;  // C++14
-
-// pointer modifications:
-template <class T>
-using remove_pointer_t = typename remove_pointer<T>::type;  // C++14
-template <class T>
-using add_pointer_t    = typename add_pointer<T>::type;  // C++14
-
-// other transformations:
-
-#if 0
-// This is not easy to implement in C++11
-template <size_t Len, std::size_t Align=std::alignment_of<max_align_t>::value>
-using aligned_storage_t = typename aligned_storage<Len,Align>::type;  // C++14
-template <std::size_t Len, class... Types>
-using aligned_union_t   = typename aligned_union<Len,Types...>::type;  // C++14
-#endif
-
-template <class T>
-using decay_t           = typename decay<T>::type;  // C++14
-template <bool b, class T=void>
-using enable_if_t       = typename enable_if<b,T>::type;  // C++14
-template <bool b, class T, class F>
-using conditional_t     = typename conditional<b,T,F>::type;  // C++14
-template <class... T>
-using common_type_t     = typename common_type<T...>::type;  // C++14
-template <class T>
-using underlying_type_t = typename underlying_type<T>::type;  // C++14
-template <class F, class... ArgTypes>
-using result_of_t       = typename result_of<F(ArgTypes...)>::type;  // C++14
-
-#endif
-
 }
 
 #endif

src/beast/beast/cxx14/utility.h

@@ -1,173 +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_CXX14_UTILITY_H_INCLUDED
-#define BEAST_CXX14_UTILITY_H_INCLUDED
-
-#include <beast/cxx14/config.h>
-
-#include <cstddef>
-#include <type_traits>
-#include <utility>
-
-#if ! BEAST_NO_CXX14_INTEGER_SEQUENCE
-
-namespace std {
-
-template <class T, T... Ints>
-struct integer_sequence
-{
-    using value_type = T;
-    static_assert (is_integral<T>::value,
-        "std::integer_sequence can only be instantiated with an integral type" );
-
-    static const size_t static_size = sizeof...(Ints);
-
-    static /* constexpr */ size_t size() /* noexcept */
-    {
-        return sizeof...(Ints);
-    }
-};
-
-template <size_t... Ints>
-using index_sequence = integer_sequence <size_t, Ints...>;
-
-namespace detail {
-
-// This workaround is needed for msvc broken sizeof...
-template <class... Args>
-struct sizeof_workaround
-{
-    static size_t const size = sizeof... (Args);
-};
-
-} // detail
-
-#ifdef _MSC_VER
-
-// This implementation compiles on MSVC and clang but not gcc
-
-namespace detail {
-
-template <class T, unsigned long long N, class Seq>
-struct make_integer_sequence_unchecked;
-
-template <class T, unsigned long long N, unsigned long long ...Indices>
-struct make_integer_sequence_unchecked <
-    T, N, integer_sequence <T, Indices...>>
-{
-    using type = typename make_integer_sequence_unchecked<
-        T, N-1, integer_sequence<T, N-1, Indices...>>::type;
-};
-
-template <class T, unsigned long long ...Indices>
-struct make_integer_sequence_unchecked <
-    T, 0, integer_sequence<T, Indices...>>
-{
-    using type = integer_sequence <T, Indices...>;
-};
-
-template <class T, T N>
-struct make_integer_sequence_checked
-{
-    static_assert (is_integral <T>::value,
-        "T must be an integral type");
-
-    static_assert (N >= 0,
-        "N must be non-negative");
-
-    using type = typename make_integer_sequence_unchecked <
-        T, N, integer_sequence<T>>::type;
-};
-
-} // detail
-
-template <class T, T N>
-using make_integer_sequence =
-    typename detail::make_integer_sequence_checked <T, N>::type;
-
-template <size_t N>
-using make_index_sequence = make_integer_sequence <size_t, N>;
-
-template <class... Args>
-using index_sequence_for =
-    make_index_sequence <detail::sizeof_workaround <Args...>::size>;
-
-#else
-
-// This implementation compiles on gcc but not MSVC
-
-namespace detail {
-
-template <size_t... Ints>
-struct index_tuple
-{
-    using next = index_tuple <Ints..., sizeof... (Ints)>;
-
-};
-
-template <size_t N>
-struct build_index_tuple
-{
-    using type = typename build_index_tuple <N-1>::type::next;
-};
-
-template <>
-struct build_index_tuple <0>
-{
-    using type = index_tuple<>;
-};
-
-template <class T, T N,
-    class Seq = typename build_index_tuple <N>::type
->
-struct make_integer_sequence;
-
-template <class T, T N, size_t... Ints>
-struct make_integer_sequence <T, N, index_tuple <Ints...>>
-{
-    static_assert (is_integral <T>::value,
-        "T must be an integral type");
-
-    static_assert (N >= 0,
-        "N must be non-negative");
-
-    using type = integer_sequence <T, static_cast <T> (Ints)...>;
-};
-
-} // detail
-
-template <class T, T N>
-using make_integer_sequence =
-    typename detail::make_integer_sequence <T, N>::type;
-
-template <size_t N>
-using make_index_sequence = make_integer_sequence <size_t, N>;
-
-template <class... Args>
-using index_sequence_for =
-    make_index_sequence <detail::sizeof_workaround <Args...>::size>;
-
-#endif
-
-}
-
-#endif
-
-#endif

src/beast/beast/hash/fnv1a.h

@@ -21,10 +21,9 @@
 #ifndef BEAST_HASH_FNV1A_H_INCLUDED
 #define BEAST_HASH_FNV1A_H_INCLUDED
 
-#include <beast/utility/noexcept.h>
 #include <cstddef>
 #include <cstdint>
-#include <beast/cxx14/type_traits.h> // <type_traits>
+#include <type_traits>
 
 namespace beast {
 

src/beast/beast/hash/hash_append.h

@@ -24,8 +24,8 @@
 #include <beast/config/CompilerConfig.h> // for constexpr
 #include <beast/hash/endian.h>
 #include <beast/utility/meta.h>
-#include <beast/utility/noexcept.h>
 #include <array>
+#include <chrono>
 #include <cstdint>
 #include <cstring>
 #include <functional>
@@ -37,8 +37,8 @@
 #include <tuple>
 #include <unordered_map>
 #include <unordered_set>
-#include <beast/cxx14/type_traits.h> // <type_traits>
-#include <beast/cxx14/utility.h> // <utility>
+#include <type_traits>
+#include <utility>
 #include <vector>
 
 namespace beast {
@@ -90,9 +90,9 @@ maybe_reverse_bytes(T& t, Hasher&)
 // is_uniquely_represented<T>
 
 // A type T is contiguously hashable if for all combinations of two values of
-// 	a type, say x and y, if x == y, then it must also be true that
-// 	memcmp(addressof(x), addressof(y), sizeof(T)) == 0. I.e. if x == y,
-// 	then x and y have the same bit pattern representation.
+// a type, say x and y, if x == y, then it must also be true that
+// memcmp(addressof(x), addressof(y), sizeof(T)) == 0. I.e. if x == y,
+// then x and y have the same bit pattern representation.
 
 template <class T>
 struct is_uniquely_represented
@@ -120,7 +120,7 @@ struct is_uniquely_represented<T const volatile>
 
 template <class T, class U>
 struct is_uniquely_represented<std::pair<T, U>>
-    : public std::integral_constant<bool, is_uniquely_represented<T>::value && 
+    : public std::integral_constant<bool, is_uniquely_represented<T>::value &&
                                           is_uniquely_represented<U>::value &&
                                           sizeof(T) + sizeof(U) == sizeof(std::pair<T, U>)>
 {
@@ -131,7 +131,7 @@ struct is_uniquely_represented<std::pair<T, U>>
 template <class ...T>
 struct is_uniquely_represented<std::tuple<T...>>
     : public std::integral_constant<bool,
-            static_and<is_uniquely_represented<T>::value...>::value && 
+            static_and<is_uniquely_represented<T>::value...>::value &&
             static_sum<sizeof(T)...>::value == sizeof(std::tuple<T...>)>
 {
 };
@@ -148,7 +148,7 @@ struct is_uniquely_represented<T[N]>
 
 template <class T, std::size_t N>
 struct is_uniquely_represented<std::array<T, N>>
-    : public std::integral_constant<bool, is_uniquely_represented<T>::value && 
+    : public std::integral_constant<bool, is_uniquely_represented<T>::value &&
                                           sizeof(T)*N == sizeof(std::array<T, N>)>
 {
 };
@@ -159,7 +159,7 @@ struct is_uniquely_represented<std::array<T, N>>
     combination of possible values of `T` held in `x` and `y`,
     if `x == y`, then it must be true that `memcmp(&x, &y, sizeof(T))`
     return 0; i.e. that `x` and `y` are represented by the same bit pattern.
-   
+
     For example:  A two's complement `int` should be contiguously hashable.
     Every bit pattern produces a unique value that does not compare equal to
     any other bit pattern's value.  A IEEE floating point should not be
@@ -206,7 +206,7 @@ struct is_contiguously_hashable<T[N], HashAlgorithm>
             Never
         Effect:
             Returns the reslting hash of all the input data.
-*/  
+*/
 /** @{ */
 
 // scalars
@@ -271,21 +271,21 @@ hash_append(Hasher& h, T (&a)[N]) noexcept;
 template <class Hasher, class CharT, class Traits, class Alloc>
 std::enable_if_t
 <
-    !is_contiguously_hashable<CharT, Hasher>::value 
+    !is_contiguously_hashable<CharT, Hasher>::value
 >
 hash_append(Hasher& h, std::basic_string<CharT, Traits, Alloc> const& s) noexcept;
 
 template <class Hasher, class CharT, class Traits, class Alloc>
 std::enable_if_t
 <
-    is_contiguously_hashable<CharT, Hasher>::value 
+    is_contiguously_hashable<CharT, Hasher>::value
 >
 hash_append(Hasher& h, std::basic_string<CharT, Traits, Alloc> const& s) noexcept;
 
 template <class Hasher, class T, class U>
 std::enable_if_t
 <
-    !is_contiguously_hashable<std::pair<T, U>, Hasher>::value 
+    !is_contiguously_hashable<std::pair<T, U>, Hasher>::value
 >
 hash_append (Hasher& h, std::pair<T, U> const& p) noexcept;
 
@@ -348,7 +348,7 @@ template <class Hasher, class CharT, class Traits, class Alloc>
 inline
 std::enable_if_t
 <
-    !is_contiguously_hashable<CharT, Hasher>::value 
+    !is_contiguously_hashable<CharT, Hasher>::value
 >
 hash_append(Hasher& h, std::basic_string<CharT, Traits, Alloc> const& s) noexcept
 {
@@ -361,7 +361,7 @@ template <class Hasher, class CharT, class Traits, class Alloc>
 inline
 std::enable_if_t
 <
-    is_contiguously_hashable<CharT, Hasher>::value 
+    is_contiguously_hashable<CharT, Hasher>::value
 >
 hash_append(Hasher& h, std::basic_string<CharT, Traits, Alloc> const& s) noexcept
 {
@@ -473,6 +473,24 @@ hash_append (Hasher& h, std::shared_ptr<T> const& p) noexcept
     hash_append(h, p.get());
 }
 
+// chrono
+
+template <class Hasher, class Rep, class Period>
+inline
+void
+hash_append (Hasher& h, std::chrono::duration<Rep, Period> const& d) noexcept
+{
+    hash_append(h, d.count());
+}
+
+template <class Hasher, class Clock, class Duration>
+inline
+void
+hash_append (Hasher& h, std::chrono::time_point<Clock, Duration> const& tp) noexcept
+{
+    hash_append(h, tp.time_since_epoch());
+}
+
 // variadic
 
 template <class Hasher, class T0, class T1, class ...T>

src/beast/beast/hash/impl/siphash.cpp

@@ -1,27 +1,27 @@
 //------------------------------- siphash.h ------------------------------------
-// 
+//
 // This software is in the public domain.  The only restriction on its use is
 // that no one can remove it from the public domain by claiming ownership of it,
 // including the original authors.
-// 
+//
 // There is no warranty of correctness on the software contained herein.  Use
 // at your own risk.
 //
 // Derived from:
-// 
+//
 // SipHash reference C implementation
-// 
+//
 // Written in 2012 by Jean-Philippe Aumasson <jeanphilippe.aumasson@gmail.com>
 // Daniel J. Bernstein <djb@cr.yp.to>
-// 
+//
 // To the extent possible under law, the author(s) have dedicated all copyright
 // and related and neighboring rights to this software to the public domain
 // worldwide. This software is distributed without any warranty.
-// 
+//
 // You should have received a copy of the CC0 Public Domain Dedication along
 // with this software. If not, see
 // <http://creativecommons.org/publicdomain/zero/1.0/>.
-// 
+//
 //------------------------------------------------------------------------------
 
 #include <beast/hash/siphash.h>

src/beast/beast/hash/impl/spookyv2.cpp

@@ -21,7 +21,7 @@
 #define ALLOW_UNALIGNED_READS 1
 
 //
-// short hash ... it could be used on any message, 
+// short hash ... it could be used on any message,
 // but it's used by Spooky just for short messages.
 //
 void SpookyHash::Short(
@@ -31,16 +31,16 @@ void SpookyHash::Short(
     uint64 *hash2)
 {
     uint64 buf[2*sc_numVars];
-    union 
-    { 
-        const uint8 *p8; 
+    union
+    {
+        const uint8 *p8;
         uint32 *p32;
-        uint64 *p64; 
-        size_t i; 
+        uint64 *p64;
+        size_t i;
     } u;
 
     u.p8 = (const uint8 *)message;
-    
+
     if (!ALLOW_UNALIGNED_READS && (u.i & 0x7))
     {
         memcpy(buf, message, length);
@@ -56,7 +56,7 @@ void SpookyHash::Short(
     if (length > 15)
     {
         const uint64 *end = u.p64 + (length/32)*4;
-        
+
         // handle all complete sets of 32 bytes
         for (; u.p64 < end; u.p64 += 4)
         {
@@ -66,7 +66,7 @@ void SpookyHash::Short(
             a += u.p64[2];
             b += u.p64[3];
         }
-        
+
         //Handle the case of 16+ remaining bytes.
         if (remainder >= 16)
         {
@@ -77,7 +77,7 @@ void SpookyHash::Short(
             remainder -= 16;
         }
     }
-    
+
     // Handle the last 0..15 bytes, and its length
     d += ((uint64)length) << 56;
     switch (remainder)
@@ -131,9 +131,9 @@ void SpookyHash::Short(
 
 // do the whole hash in one call
 void SpookyHash::Hash128(
-    const void *message, 
-    size_t length, 
-    uint64 *hash1, 
+    const void *message,
+    size_t length,
+    uint64 *hash1,
     uint64 *hash2)
 {
     if (length < sc_bufSize)
@@ -145,18 +145,18 @@ void SpookyHash::Hash128(
     uint64 h0,h1,h2,h3,h4,h5,h6,h7,h8,h9,h10,h11;
     uint64 buf[sc_numVars];
     uint64 *end;
-    union 
-    { 
-        const uint8 *p8; 
-        uint64 *p64; 
-        size_t i; 
+    union
+    {
+        const uint8 *p8;
+        uint64 *p64;
+        size_t i;
     } u;
     size_t remainder;
-    
+
     h0=h3=h6=h9  = *hash1;
     h1=h4=h7=h10 = *hash2;
     h2=h5=h8=h11 = sc_const;
-    
+
     u.p8 = (const uint8 *)message;
     end = u.p64 + (length/sc_blockSize)*sc_numVars;
 
@@ -164,7 +164,7 @@ void SpookyHash::Hash128(
     if (ALLOW_UNALIGNED_READS || ((u.i & 0x7) == 0))
     {
         while (u.p64 < end)
-        { 
+        {
             Mix(u.p64, h0,h1,h2,h3,h4,h5,h6,h7,h8,h9,h10,h11);
         u.p64 += sc_numVars;
         }
@@ -185,8 +185,8 @@ void SpookyHash::Hash128(
     memset(((uint8 *)buf)+remainder, 0, sc_blockSize-remainder);
     ((uint8 *)buf)[sc_blockSize-1] =
         static_cast<uint8>(remainder);
-    
-    // do some final mixing 
+
+    // do some final mixing
     End(buf, h0,h1,h2,h3,h4,h5,h6,h7,h8,h9,h10,h11);
     *hash1 = h0;
     *hash2 = h1;
@@ -210,14 +210,14 @@ void SpookyHash::Update(const void *message, size_t length)
     uint64 h0,h1,h2,h3,h4,h5,h6,h7,h8,h9,h10,h11;
     size_t newLength = length + m_remainder;
     uint8  remainder;
-    union 
-    { 
-        const uint8 *p8; 
-        uint64 *p64; 
-        size_t i; 
+    union
+    {
+        const uint8 *p8;
+        uint64 *p64;
+        size_t i;
     } u;
     const uint64 *end;
-    
+
     // Is this message fragment too short?  If it is, stuff it away.
     if (newLength < sc_bufSize)
     {
@@ -226,7 +226,7 @@ void SpookyHash::Update(const void *message, size_t length)
         m_remainder = (uint8)newLength;
         return;
     }
-    
+
     // init the variables
     if (m_length < sc_bufSize)
     {
@@ -250,7 +250,7 @@ void SpookyHash::Update(const void *message, size_t length)
         h11 = m_state[11];
     }
     m_length = length + m_length;
-    
+
     // if we've got anything stuffed away, use it now
     if (m_remainder)
     {
@@ -266,14 +266,14 @@ void SpookyHash::Update(const void *message, size_t length)
     {
         u.p8 = (const uint8 *)message;
     }
-    
+
     // handle all whole blocks of sc_blockSize bytes
     end = u.p64 + (length/sc_blockSize)*sc_numVars;
     remainder = (uint8)(length-((const uint8 *)end-u.p8));
     if (ALLOW_UNALIGNED_READS || (u.i & 0x7) == 0)
     {
         while (u.p64 < end)
-        { 
+        {
             Mix(u.p64, h0,h1,h2,h3,h4,h5,h6,h7,h8,h9,h10,h11);
         u.p64 += sc_numVars;
         }
@@ -281,7 +281,7 @@ void SpookyHash::Update(const void *message, size_t length)
     else
     {
         while (u.p64 < end)
-        { 
+        {
             memcpy(m_data, u.p8, sc_blockSize);
             Mix(m_data, h0,h1,h2,h3,h4,h5,h6,h7,h8,h9,h10,h11);
         u.p64 += sc_numVars;
@@ -291,7 +291,7 @@ void SpookyHash::Update(const void *message, size_t length)
     // stuff away the last few bytes
     m_remainder = remainder;
     memcpy(m_data, end, remainder);
-    
+
     // stuff away the variables
     m_state[0] = h0;
     m_state[1] = h1;
@@ -319,10 +319,10 @@ void SpookyHash::Final(uint64 *hash1, uint64 *hash2)
         Short( m_data, m_length, hash1, hash2);
         return;
     }
-    
+
     const uint64 *data = (const uint64 *)m_data;
     uint8 remainder = m_remainder;
-    
+
     uint64 h0 = m_state[0];
     uint64 h1 = m_state[1];
     uint64 h2 = m_state[2];
@@ -348,7 +348,7 @@ void SpookyHash::Final(uint64 *hash1, uint64 *hash2)
     memset(&((uint8 *)data)[remainder], 0, (sc_blockSize-remainder));
 
     ((uint8 *)data)[sc_blockSize-1] = remainder;
-    
+
     // do some final mixing
     End(data, h0,h1,h2,h3,h4,h5,h6,h7,h8,h9,h10,h11);
 

src/beast/beast/hash/impl/spookyv2.h

@@ -8,7 +8,7 @@
 //   Feb  5 2012: adjusted definitions of uint* to be more portable
 //   Mar 30 2012: 3 bytes/cycle, not 4.  Alpha was 4 but wasn't thorough enough.
 //   August 5 2012: SpookyV2 (different results)
-// 
+//
 // Up to 3 bytes/cycle for long messages.  Reasonably fast for short messages.
 // All 1 or 2 bit deltas achieve avalanche within 1% bias per output bit.
 //
@@ -20,9 +20,9 @@
 //
 // Google's CityHash has similar specs to SpookyHash, and CityHash is faster
 // on new Intel boxes.  MD4 and MD5 also have similar specs, but they are orders
-// of magnitude slower.  CRCs are two or more times slower, but unlike 
-// SpookyHash, they have nice math for combining the CRCs of pieces to form 
-// the CRCs of wholes.  There are also cryptographic hashes, but those are even 
+// of magnitude slower.  CRCs are two or more times slower, but unlike
+// SpookyHash, they have nice math for combining the CRCs of pieces to form
+// the CRCs of wholes.  There are also cryptographic hashes, but those are even
 // slower than MD5.
 //
 
@@ -91,7 +91,7 @@ public:
     void Init(
         uint64 seed1,       // any 64-bit value will do, including 0
         uint64 seed2);      // different seeds produce independent hashes
-    
+
     //
     // Update: add a piece of a message to a SpookyHash state
     //
@@ -134,7 +134,7 @@ public:
     // I tried 3 pairs of each; they all differed by at least 212 bits.
     //
     static INLINE void Mix(
-        const uint64 *data, 
+        const uint64 *data,
         uint64 &s0, uint64 &s1, uint64 &s2, uint64 &s3,
         uint64 &s4, uint64 &s5, uint64 &s6, uint64 &s7,
         uint64 &s8, uint64 &s9, uint64 &s10,uint64 &s11)
@@ -171,7 +171,7 @@ public:
     //
     static INLINE void EndPartial(
         uint64 &h0, uint64 &h1, uint64 &h2, uint64 &h3,
-        uint64 &h4, uint64 &h5, uint64 &h6, uint64 &h7, 
+        uint64 &h4, uint64 &h5, uint64 &h6, uint64 &h7,
         uint64 &h8, uint64 &h9, uint64 &h10,uint64 &h11)
     {
         h11+= h1;    h2 ^= h11;   h1 = Rot64(h1,44);
@@ -189,9 +189,9 @@ public:
     }
 
     static INLINE void End(
-        const uint64 *data, 
+        const uint64 *data,
         uint64 &h0, uint64 &h1, uint64 &h2, uint64 &h3,
-        uint64 &h4, uint64 &h5, uint64 &h6, uint64 &h7, 
+        uint64 &h4, uint64 &h5, uint64 &h6, uint64 &h7,
         uint64 &h8, uint64 &h9, uint64 &h10,uint64 &h11)
     {
         h0 += data[0];   h1 += data[1];   h2 += data[2];   h3 += data[3];
@@ -203,7 +203,7 @@ public:
     }
 
     //
-    // The goal is for each bit of the input to expand into 128 bits of 
+    // The goal is for each bit of the input to expand into 128 bits of
     //   apparent entropy before it is fully overwritten.
     // n trials both set and cleared at least m bits of h0 h1 h2 h3
     //   n: 2   m: 29
@@ -259,7 +259,7 @@ public:
         h0 ^= h3;  h3 = Rot64(h3,25);  h0 += h3;
         h1 ^= h0;  h0 = Rot64(h0,63);  h1 += h0;
     }
-    
+
 private:
 
     //
@@ -267,7 +267,7 @@ private:
     // Short has a low startup cost, the normal mode is good for long
     // keys, the cost crossover is at about 192 bytes.  The two modes were
     // held to the same quality bar.
-    // 
+    //
     static void Short(
         const void *message,  // message (array of bytes, not necessarily aligned)
         size_t length,        // length of message (in bytes)

src/beast/beast/hash/siphash.h

@@ -21,7 +21,6 @@
 #ifndef BEAST_HASH_SIPHASH_H_INCLUDED
 #define BEAST_HASH_SIPHASH_H_INCLUDED
 
-#include <beast/utility/noexcept.h>
 #include <cstddef>
 #include <cstdint>
 

src/beast/beast/hash/tests/hash_append_test.cpp

@@ -206,7 +206,7 @@ class spooky
 private:
     SpookyHash state_;
 
-public: 
+public:
     static beast::endian const endian = beast::endian::native;
 
     spooky(std::size_t seed1 = 1, std::size_t seed2 = 2) noexcept
@@ -429,9 +429,9 @@ public:
     {
         auto const start (
             std::chrono::high_resolution_clock::now());
-        
+
         auto const hashes (make_hashes <Hasher> (keys));
-        
+
         results.elapsed = std::chrono::duration_cast <std::chrono::milliseconds> (
             std::chrono::high_resolution_clock::now() - start);
 

src/beast/beast/hash/xxhasher.h

@@ -28,8 +28,7 @@
 
 #include <beast/hash/endian.h>
 #include <beast/hash/impl/xxhash.h>
-#include <beast/utility/noexcept.h>
-#include <beast/cxx14/type_traits.h> // <type_traits>
+#include <type_traits>
 #include <cstddef>
 
 namespace beast {

src/beast/beast/http/URL.h

@@ -52,22 +52,7 @@ public:
     URL& operator= (URL const& other) = default;
 
     /** Move construct a URL. */
-#ifdef _MSC_VER
-    URL (URL&& other)
-        : m_scheme(std::move(other.m_scheme))
-        , m_host(std::move(other.m_host))
-        , m_port(other.m_port)
-        , m_port_string(std::move(other.m_port_string))
-        , m_path(std::move(other.m_path))
-        , m_query(std::move(other.m_query))
-        , m_fragment(std::move(other.m_fragment))
-        , m_userinfo(std::move(other.m_userinfo))
-    {
-    }
-
-#else
     URL (URL&& other) = default;
-#endif
 
     /** Returns `true` if this is an empty URL. */
     bool

src/beast/beast/http/basic_parser.h

@@ -27,7 +27,6 @@
 #include <cstdint>
 #include <memory>
 #include <string>
-#include <beast/utility/noexcept.h>
 
 namespace beast {
 

src/beast/beast/http/body.h

@@ -25,7 +25,7 @@
 #include <boost/asio/buffer.hpp>
 #include <boost/asio/streambuf.hpp>
 #include <boost/optional.hpp>
-#include <beast/cxx14/memory.h> // <memory>
+#include <memory>
 #include <string>
 
 namespace beast {

src/beast/beast/http/chunk_encode.h

@@ -26,7 +26,7 @@
 #include <cassert>
 #include <cstddef>
 #include <iterator>
-#include <beast/cxx14/type_traits.h> // <type_traits>
+#include <type_traits>
 
 namespace beast {
 namespace http {

src/beast/beast/http/headers.h

@@ -396,4 +396,4 @@ build_map (headers const& h)
 } // http
 } // beast
 
-#endif
+#endif

src/beast/beast/http/impl/URL.cpp

@@ -187,7 +187,7 @@ to_string (URL const& url)
 
         s.append (url.scheme ());
         s.append ("://");
-        
+
         if (!url.userinfo ().empty ())
         {
             s.append (url.userinfo ());

src/beast/beast/http/impl/basic_parser.cpp

@@ -20,7 +20,6 @@
 #include <beast/http/basic_parser.h>
 #include <beast/http/impl/joyent_parser.h>
 #include <beast/http/rfc2616.h>
-#include <beast/utility/noexcept.h>
 #include <boost/system/error_code.hpp>
 
 namespace beast {
@@ -94,7 +93,7 @@ basic_parser::basic_parser (bool request) noexcept
     h->on_headers_complete  = &basic_parser::cb_headers_complete;
     h->on_body              = &basic_parser::cb_body;
     h->on_message_complete  = &basic_parser::cb_message_complete;
-    
+
     joyent::http_parser_init (s, request
         ? joyent::http_parser_type::HTTP_REQUEST
         : joyent::http_parser_type::HTTP_RESPONSE);

src/beast/beast/http/impl/basic_url.cpp

@@ -31,7 +31,7 @@ basic_url_base::parse_impl (string_ref s, boost::system::error_code& ec)
     joyent::http_parser_url p;
 
     value_type const* const data (s.data());
-    
+
     int const error (joyent::http_parser_parse_url (
         data, s.size(), false, &p));
 

src/beast/beast/http/impl/joyent_parser.cpp

@@ -140,7 +140,7 @@ convert_http_errno (joyent::http_errno err)
         {
             return default_error_condition (code) == condition;
         }
-        
+
         bool
         equivalent (error_code const& code, int condition
             ) const noexcept override
@@ -151,7 +151,7 @@ convert_http_errno (joyent::http_errno err)
     };
 
     static http_error_category_t http_error_category;
-    
+
     return boost::system::error_code (
         err, http_error_category);
 }

src/beast/beast/http/impl/joyent_parser.h

@@ -25,7 +25,7 @@
 // TODO Use <system_error>
 #include <boost/system/error_code.hpp>
 
-// Wraps the C-language joyent http parser header in a namespace 
+// Wraps the C-language joyent http parser header in a namespace
 
 namespace beast {
 namespace joyent {

src/beast/beast/http/message.h

@@ -58,7 +58,7 @@ private:
     // request
     beast::http::method_t method_;
     std::string url_;
-    
+
     // response
     int status_;
     std::string reason_;
@@ -76,16 +76,9 @@ public:
     template <class = void>
     message();
 
-#if defined(_MSC_VER) && _MSC_VER <= 1800
-    message (message&& other);
-    message& operator= (message&& other);
-
-#else
     message (message&& other) = default;
     message& operator= (message&& other) = default;
 
-#endif
-
     // Memberspace
     beast::http::headers headers;
 
@@ -220,38 +213,6 @@ message::message()
 {
 }
 
-#if defined(_MSC_VER) && _MSC_VER <= 1800
-inline
-message::message (message&& other)
-    : request_ (other.request_)
-    , method_ (std::move(other.method_))
-    , url_ (std::move(other.url_))
-    , status_ (other.status_)
-    , reason_ (std::move(other.reason_))
-    , version_ (other.version_)
-    , keep_alive_ (other.keep_alive_)
-    , upgrade_ (other.upgrade_)
-    , headers (std::move(other.headers))
-{
-}
-
-inline
-message&
-message::operator= (message&& other)
-{
-    request_ = other.request_;
-    method_ = std::move(other.method_);
-    url_ = std::move(other.url_);
-    status_ = other.status_;
-    reason_ = std::move(other.reason_);
-    version_ = other.version_;
-    keep_alive_ = other.keep_alive_;
-    upgrade_ = other.upgrade_;
-    headers = std::move(other.headers);
-    return *this;    
-}
-#endif
-
 //------------------------------------------------------------------------------
 
 template <class Streambuf>

src/beast/beast/http/parser.h

@@ -49,7 +49,7 @@ public:
             message& m, bool request)
         : beast::http::basic_parser (request)
         , message_(m)
-        , write_body_(std::move(write_body)) 
+        , write_body_(std::move(write_body))
     {
         message_.get().request(request);
     }
@@ -66,14 +66,8 @@ public:
         message_.get().request(request);
     }
 
-#if defined(_MSC_VER) && _MSC_VER <= 1800
-    parser& operator= (parser&& other);
-
-#else
     parser& operator= (parser&& other) = default;
 
-#endif
-
 private:
     template <class = void>
     void
@@ -141,18 +135,6 @@ private:
 };
 
 //------------------------------------------------------------------------------
-
-#if defined(_MSC_VER) && _MSC_VER <= 1800
-inline
-parser&
-parser::operator= (parser&& other)
-{
-    basic_parser::operator= (std::move(other));
-    message_ = std::move (other.message_);
-    return *this;
-}
-#endif
-
 template <class>
 void
 parser::do_start()
@@ -208,4 +190,4 @@ parser::do_complete()
 } // http
 } // beast
 
-#endif
+#endif

src/beast/beast/http/tests/URL.test.cpp

@@ -37,7 +37,7 @@ public:
 
     void test_url_parsing ()
     {
-        char const* const urls[] = 
+        char const* const urls[] =
         {
             "http://en.wikipedia.org/wiki/URI#Examples_of_URI_references",
             "ftp://ftp.funet.fi/pub/standards/RFC/rfc959.txt"

src/beast/beast/http/tests/chunked_encoder.test.cpp

@@ -55,7 +55,7 @@ public:
             log << encode (std::string(
                 boost::asio::buffer_cast<char const*>(buf),
                     boost::asio::buffer_size(buf)));
-    } 
+    }
 
     // Convert a ConstBufferSequence to a string
     template <class ConstBufferSequence>

src/beast/beast/http/tests/urls_large_data.cpp

@@ -18,7 +18,7 @@
 //==============================================================================
 
 #include <beast/http/tests/urls_large_data.h>
-    
+
 namespace beast {
 namespace http {
 

src/beast/beast/insight/Collector.h

@@ -49,7 +49,7 @@ public:
     virtual ~Collector() = 0;
 
     /** Create a hook.
-        
+
         A hook is called at each collection interval, on an implementation
         defined thread. This is a convenience facility for gathering metrics
         in the polling style. The typical usage is to update all the metrics
@@ -75,7 +75,7 @@ public:
     */
     /** @{ */
     virtual Counter make_counter (std::string const& name) = 0;
-    
+
     Counter make_counter (std::string const& prefix, std::string const& name)
     {
         if (prefix.empty ())
@@ -98,7 +98,7 @@ public:
     }
     /** @} */
 
-    /** Create a gauge with the specified name. 
+    /** Create a gauge with the specified name.
         @see Gauge
     */
     /** @{ */

src/beast/beast/insight/Counter.h

@@ -29,7 +29,7 @@ namespace beast {
 namespace insight {
 
 /** A metric for measuring an integral value.
-    
+
     A counter is a gauge calculated at the server. The owner of the counter
     may increment and decrement the value by an amount.
 

src/beast/beast/insight/CounterImpl.h

@@ -33,7 +33,7 @@ class CounterImpl
 {
 public:
     using value_type = std::int64_t;
-   
+
     virtual ~CounterImpl () = 0;
     virtual void increment (value_type amount) = 0;
 };

src/beast/beast/insight/Event.h

@@ -32,7 +32,7 @@ namespace beast {
 namespace insight {
 
 /** A metric for reporting event timing.
-    
+
     An event is an operation that has an associated millisecond time, or
     other integral value. Because events happen at a specific moment, the
     metric only supports a push-style interface.

src/beast/beast/insight/Gauge.h

@@ -29,7 +29,7 @@ namespace beast {
 namespace insight {
 
 /** A metric for measuring an integral value.
-    
+
     A gauge is an instantaneous measurement of a value, like the gas gauge
     in a car. The caller directly sets the value, or adjusts it by a
     specified amount. The value is kept in the client rather than the collector.

src/beast/beast/insight/Hook.h

@@ -27,7 +27,7 @@
 
 namespace beast {
 namespace insight {
-    
+
 /** A reference to a handler for performing polled collection. */
 class Hook : public Base
 {

src/beast/beast/insight/Meter.h

@@ -29,7 +29,7 @@ namespace beast {
 namespace insight {
 
 /** A metric for measuring an integral value.
-    
+
     A meter may be thought of as an increment-only counter.
 
     This is a lightweight reference wrapper which is cheap to copy and assign.

src/beast/beast/insight/NullCollector.h

@@ -24,7 +24,7 @@
 
 namespace beast {
 namespace insight {
-    
+
 /** A Collector which does not collect metrics. */
 class NullCollector : public Collector
 {

src/beast/beast/insight/impl/Groups.cpp

@@ -19,7 +19,7 @@
 
 #include <unordered_map>
 #include <beast/hash/uhash.h>
-#include <beast/cxx14/memory.h> // <memory>
+#include <memory>
 
 namespace beast {
 namespace insight {

src/beast/beast/insight/impl/NullCollector.cpp

@@ -117,7 +117,7 @@ public:
     {
         return Gauge (std::make_shared <detail::NullGaugeImpl> ());
     }
-    
+
     Meter make_meter (std::string const&)
     {
         return Meter (std::make_shared <detail::NullMeterImpl> ());

src/beast/beast/insight/impl/StatsDCollector.cpp

@@ -20,13 +20,13 @@
 #include <beast/asio/IPAddressConversion.h>
 #include <beast/asio/placeholders.h>
 #include <beast/intrusive/List.h>
-#include <beast/threads/SharedData.h>
 #include <boost/asio/ip/tcp.hpp>
 #include <boost/optional.hpp>
 #include <cassert>
 #include <climits>
 #include <deque>
 #include <functional>
+#include <mutex>
 #include <set>
 #include <sstream>
 #include <thread>
@@ -192,13 +192,6 @@ private:
         max_packet_size = 1472
     };
 
-    struct StateType
-    {
-        List <StatsDMetricBase> metrics;
-    };
-
-    using State = SharedData <StateType>;
-
     Journal m_journal;
     IP::Endpoint m_address;
     std::string m_prefix;
@@ -208,7 +201,8 @@ private:
     boost::asio::deadline_timer m_timer;
     boost::asio::ip::udp::socket m_socket;
     std::deque <std::string> m_data;
-    State m_state;
+    std::recursive_mutex metricsLock_;
+    List <StatsDMetricBase> metrics_;
 
     // Must come last for order of init
     std::thread m_thread;
@@ -288,14 +282,14 @@ public:
 
     void add (StatsDMetricBase& metric)
     {
-        State::Access state (m_state);
-        state->metrics.push_back (metric);
+        std::lock_guard<std::recursive_mutex> _(metricsLock_);
+        metrics_.push_back (metric);
     }
 
     void remove (StatsDMetricBase& metric)
     {
-        State::Access state (m_state);
-        state->metrics.erase (state->metrics.iterator_to (metric));
+        std::lock_guard<std::recursive_mutex> _(metricsLock_);
+        metrics_.erase (metrics_.iterator_to (metric));
     }
 
     //--------------------------------------------------------------------------
@@ -425,11 +419,10 @@ public:
             return;
         }
 
-        State::Access state (m_state);
+        std::lock_guard<std::recursive_mutex> _(metricsLock_);
 
-        for (List <StatsDMetricBase>::iterator iter (state->metrics.begin());
-            iter != state->metrics.end(); ++iter)
-            iter->do_process();
+        for (auto& m : metrics_)
+            m.do_process();
 
         send_buffers ();
 
@@ -616,7 +609,7 @@ void StatsDGaugeImpl::flush ()
 void StatsDGaugeImpl::do_set (GaugeImpl::value_type value)
 {
     m_value = value;
-    
+
     if (m_value != m_last_value)
     {
         m_last_value = m_value;
@@ -641,7 +634,7 @@ void StatsDGaugeImpl::do_increment (GaugeImpl::difference_type amount)
     {
         GaugeImpl::value_type const d (
             static_cast <GaugeImpl::value_type> (-amount));
-        value = (d >= value) ? 0 : value - d; 
+        value = (d >= value) ? 0 : value - d;
     }
 
     do_set (value);

src/beast/beast/intrusive/List.h

@@ -160,91 +160,91 @@ private:
 }
 
 /** Intrusive doubly linked list.
-  
+
     This intrusive List is a container similar in operation to std::list in the
     Standard Template Library (STL). Like all @ref intrusive containers, List
     requires you to first derive your class from List<>::Node:
-  
+
     @code
-  
+
     struct Object : List <Object>::Node
     {
         explicit Object (int value) : m_value (value)
         {
         }
-  
+
         int m_value;
     };
-  
+
     @endcode
-  
+
     Now we define the list, and add a couple of items.
-  
+
     @code
-  
+
     List <Object> list;
-  
+
     list.push_back (* (new Object (1)));
     list.push_back (* (new Object (2)));
-  
+
     @endcode
-  
+
     For compatibility with the standard containers, push_back() expects a
     reference to the object. Unlike the standard container, however, push_back()
     places the actual object in the list and not a copy-constructed duplicate.
-  
+
     Iterating over the list follows the same idiom as the STL:
-  
+
     @code
-  
+
     for (List <Object>::iterator iter = list.begin(); iter != list.end; ++iter)
         std::cout << iter->m_value;
-  
+
     @endcode
-  
+
     You can even use BOOST_FOREACH, or range based for loops:
-  
+
     @code
-  
+
     BOOST_FOREACH (Object& object, list)  // boost only
         std::cout << object.m_value;
-  
+
     for (Object& object : list)           // C++11 only
         std::cout << object.m_value;
-  
+
     @endcode
-  
+
     Because List is mostly STL compliant, it can be passed into STL algorithms:
     e.g. `std::for_each()` or `std::find_first_of()`.
-  
+
     In general, objects placed into a List should be dynamically allocated
     although this cannot be enforced at compile time. Since the caller provides
     the storage for the object, the caller is also responsible for deleting the
     object. An object still exists after being removed from a List, until the
     caller deletes it. This means an element can be moved from one List to
     another with practically no overhead.
-  
+
     Unlike the standard containers, an object may only exist in one list at a
     time, unless special preparations are made. The Tag template parameter is
     used to distinguish between different list types for the same object,
     allowing the object to exist in more than one list simultaneously.
-  
+
     For example, consider an actor system where a global list of actors is
     maintained, so that they can each be periodically receive processing
     time. We wish to also maintain a list of the subset of actors that require
     a domain-dependent update. To achieve this, we declare two tags, the
     associated list types, and the list element thusly:
-  
+
     @code
-  
+
     struct Actor;         // Forward declaration required
-  
+
     struct ProcessTag { };
     struct UpdateTag { };
-  
+
     using ProcessList = List <Actor, ProcessTag>;
     using UpdateList = List <Actor, UpdateTag>;
-  
+
     // Derive from both node types so we can be in each list at once.
     //
     struct Actor : ProcessList::Node, UpdateList::Node
@@ -252,15 +252,15 @@ private:
         bool process ();    // returns true if we need an update
         void update ();
     };
-  
+
     @endcode
-  
+
     @tparam T The base type of element which the list will store
                     pointers to.
-  
+
     @tparam Tag An optional unique type name used to distinguish lists and nodes,
                 when the object can exist in multiple lists simultaneously.
-  
+
     @ingroup beast_core intrusive
 */
 template <typename T, typename Tag = void>

src/beast/beast/intrusive/LockFreeStack.h

@@ -146,7 +146,7 @@ public:
     class Node
     {
     public:
-        Node () 
+        Node ()
             : m_next (nullptr)
         { }
 
@@ -159,7 +159,7 @@ public:
 
     private:
         friend class LockFreeStack;
-        
+
         template <class Container, bool IsConst>
         friend class LockFreeStackIterator;
 
@@ -262,7 +262,7 @@ public:
     {
         return iterator (&m_end);
     }
-    
+
     const_iterator begin () const
     {
         return const_iterator (m_head.load ());
@@ -272,7 +272,7 @@ public:
     {
         return const_iterator (&m_end);
     }
-    
+
     const_iterator cbegin () const
     {
         return const_iterator (m_head.load ());

src/beast/beast/is_call_possible.h

@@ -20,7 +20,7 @@
 #ifndef BEAST_IS_CALL_POSSIBLE_H_INCLUDED
 #define BEAST_IS_CALL_POSSIBLE_H_INCLUDED
 
-#include <beast/cxx14/type_traits.h> // <type_traits>
+#include <type_traits>
 
 namespace beast {