Set version to 0.30.1-rc2

Commit 6ec5fa9cae fixed a bug that
would cause a crash when a transaction signed with a secp256r1 was
presented. This adds a regression test, ensuring that such
signatures fail gracefully.

.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 "${@}"
+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-hf1
-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')
 
+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:
+    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, CHECK_COMMAND))
+                        (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,15 +533,18 @@ def config_env(toolchain, variant, env):
             'boost_system',
             'boost_thread'
         ]
+        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)
-        env.Append(LIBS=['dl'])
 
         if Beast.system.osx:
             env.Append(LIBS=[
@@ -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=[
-            'ssleay32MT.lib',
-            'libeay32MT.lib',
+                'VC/static/ssleay32MTd.lib',
+                'VC/static/libeay32MTd.lib',
+                ])
+        else:
+            env.Append(LIBS=[
+                'VC/static/ssleay32MT.lib',
+                'VC/static/libeay32MT.lib',
+                ])
+        env.Append(LIBS=[
+            '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,6 +865,12 @@ 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,
@@ -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,18 +3,21 @@ 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
@@ -24,7 +27,9 @@ test:
       echo "run" >> script.gdb
       echo "backtrace full" >> script.gdb
       # gdb --help
-    - cat script.gdb | gdb --ex 'set print thread-events off' --return-child-result --args build/clang.debug/rippled --unittest
+    # 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/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/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/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>
 

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,7 +29,6 @@
 
 #include <beast/Config.h>
 
-#include <beast/utility/noexcept.h>
 #include <ctime>
 #include <locale>
 

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/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/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>
 

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>

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>
 

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 {
@@ -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/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/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/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 {

src/beast/beast/http/message.h

@@ -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

@@ -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()

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/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 ();
 

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 {
 

src/beast/beast/module/core/core.unity.cpp

@@ -26,6 +26,7 @@
 #endif
 
 //==============================================================================
+
 #include <beast/module/core/native/BasicNativeHeaders.h>
 #include <beast/module/core/core.h>
 
@@ -46,7 +47,10 @@
  #include <ws2tcpip.h>
 
  #if ! BEAST_MINGW
+  #pragma warning ( push )
+  #pragma warning ( disable: 4091 )
   #include <Dbghelp.h>
+  #pragma warning ( pop )
 
   #if ! BEAST_DONT_AUTOLINK_TO_WIN32_LIBRARIES
    #pragma comment (lib, "DbgHelp.lib")

src/beast/beast/module/core/diagnostic/FatalError.cpp

@@ -20,6 +20,7 @@
 #include <beast/module/core/diagnostic/FatalError.h>
 
 #include <atomic>
+#include <cstdlib>
 #include <exception>
 #include <iostream>
 #include <mutex>
@@ -27,25 +28,19 @@
 namespace beast {
 
 //------------------------------------------------------------------------------
+[[noreturn]]
 void
-FatalError (char const* message, char const* file, int line)
+FatalError (
+    char const* message,
+    char const* file,
+    int line) noexcept
 {
-    static std::atomic <int> error_count (0);
-    static std::recursive_mutex gate;
+    static std::mutex gate;
 
     // We only allow one thread to report a fatal error. Other threads that
     // encounter fatal errors while we are reporting get blocked here.
-    std::lock_guard<std::recursive_mutex> lock(gate);
+    std::lock_guard<std::mutex> lock(gate);
 
-    // If we encounter a recursive fatal error, then we want to terminate
-    // unconditionally.
-    if (error_count++ != 0)
-        return std::terminate ();
-
-    // We protect this entire block of code since writing to cerr might trigger
-    // exceptions.
-    try
-    {
     std::cerr << "An error has occurred. The application will terminate.\n";
 
     if (message != nullptr && message [0] != 0)
@@ -63,13 +58,8 @@ FatalError (char const* message, char const* file, int line)
         for (auto const& frame : backtrace)
             std::cerr << "    " << frame << '\n';
     }
-    }
-    catch (...)
-    {
-        // nothing we can do - just fall through and terminate
-    }
 
-    return std::terminate ();
+    std::abort ();
 }
 
 } // beast

src/beast/beast/module/core/diagnostic/FatalError.h

@@ -35,8 +35,12 @@ namespace beast
     If multiple threads raise an error, only one will succeed while the others
     will be blocked before the process terminates.
 */
+[[noreturn]]
 void
-FatalError (char const* message, char const* file = nullptr, int line = 0);
+FatalError (
+    char const* message,
+    char const* file = nullptr,
+    int line = 0) noexcept;
 
 } // beast
 

src/beast/beast/module/core/diagnostic/SemanticVersion.h

@@ -23,8 +23,6 @@
 #include <vector>
 #include <string>
 
-#include <beast/utility/noexcept.h>
-
 namespace beast {
 
 /** A Semantic Version number.

src/beast/beast/module/core/files/DirectoryIterator.cpp

@@ -21,7 +21,7 @@
 */
 //==============================================================================
 
-#include <beast/cxx14/memory.h> // <memory>
+#include <memory>
 
 namespace beast {
 

src/beast/beast/module/core/files/File.cpp

@@ -21,7 +21,6 @@
 */
 //==============================================================================
 
-#include <beast/utility/static_initializer.h>
 #include <algorithm>
 #include <memory>
 
@@ -29,8 +28,8 @@ namespace beast {
 
 File const& File::nonexistent()
 {
-    static beast::static_initializer<File> instance;
-    return *instance;
+    static File const instance;
+    return instance;
 }
 
 //------------------------------------------------------------------------------

src/beast/beast/module/core/native/BasicNativeHeaders.h

@@ -106,7 +106,10 @@
  #include <mapi.h>
  #include <float.h>
  #include <process.h>
+ #pragma warning ( push )
+ #pragma warning ( disable: 4091 )
  #include <shlobj.h>
+ #pragma warning ( pop )
  #include <shlwapi.h>
  #include <mmsystem.h>
 

src/beast/beast/module/core/streams/MemoryOutputStream.h

@@ -117,7 +117,7 @@ public:
         capacity off the block, so that its length matches the amount of actual data that
         has been written so far.
     */
-    void flush();
+    void flush() override;
 
     bool write (const void*, size_t) override;
     std::int64_t getPosition() override                                 { return position; }

src/beast/beast/module/core/text/LexicalCast.h

@@ -28,7 +28,7 @@
 #include <iterator>
 #include <limits>
 #include <string>
-#include <beast/cxx14/type_traits.h> // <type_traits>
+#include <type_traits>
 #include <typeinfo>
 #include <utility>
 

src/beast/beast/module/core/thread/DeadlineTimer.cpp

@@ -17,8 +17,6 @@
 */
 //==============================================================================
 
-#include <beast/utility/static_initializer.h>
-
 namespace beast
 {
 
@@ -47,8 +45,8 @@ public:
     Manager&
     instance()
     {
-        static beast::static_initializer<Manager> m;
-        return *m;
+        static Manager m;
+        return m;
     }
 
     // Okay to call on an active timer.

src/beast/beast/net/IPAddress.h

@@ -24,7 +24,6 @@
 #include <beast/net/IPAddressV6.h>
 #include <beast/hash/hash_append.h>
 #include <beast/hash/uhash.h>
-#include <beast/utility/noexcept.h>
 #include <boost/functional/hash.hpp>
 #include <cassert>
 #include <cstdint>

src/beast/beast/net/impl/IPAddressV4.cpp

@@ -147,8 +147,7 @@ bool is_public (AddressV4 const& addr)
 {
     return
         ! is_private (addr) &&
-        ! is_multicast (addr) &&
-        (addr != AddressV4::broadcast (addr));
+        ! is_multicast (addr);
 }
 
 //------------------------------------------------------------------------------

src/beast/beast/nudb/detail/field.h

@@ -25,7 +25,7 @@
 #include <cstddef>
 #include <cstdint>
 #include <stdexcept>
-#include <beast/cxx14/type_traits.h> // <type_traits>
+#include <type_traits>
 
 namespace beast {
 namespace nudb {

src/beast/beast/nudb/detail/format.h

@@ -31,7 +31,7 @@
 #include <cstring>
 #include <memory>
 #include <stdexcept>
-#include <beast/cxx14/type_traits.h> // <type_traits>
+#include <type_traits>
 
 namespace beast {
 namespace nudb {

src/beast/beast/nudb/detail/gentex.h

@@ -20,7 +20,6 @@
 #ifndef BEAST_NUDB_DETAIL_GENTEX_H_INCLUDED
 #define BEAST_NUDB_DETAIL_GENTEX_H_INCLUDED
 
-#include <beast/utility/noexcept.h>
 #include <condition_variable>
 #include <cstddef>
 #include <mutex>

src/beast/beast/nudb/detail/varint.h

@@ -23,7 +23,7 @@
 #include <beast/config/CompilerConfig.h> // for BEAST_CONSTEXPR
 #include <beast/nudb/detail/stream.h>
 #include <cstdint>
-#include <beast/cxx14/type_traits.h> // <type_traits>
+#include <type_traits>
 
 namespace beast {
 namespace nudb {

src/beast/beast/nudb/store.h

@@ -45,7 +45,7 @@
 #include <cstring>
 #include <exception>
 #include <limits>
-#include <beast/cxx14/memory.h> // <memory>
+#include <memory>
 #include <mutex>
 #include <stdexcept>
 #include <string>

src/beast/beast/random/rngfill.h

@@ -23,7 +23,7 @@
 #include <array>
 #include <cstdint>
 #include <cstring>
-#include <beast/cxx14/type_traits.h> // <type_traits>
+#include <type_traits>
 
 namespace beast {
 

src/beast/beast/streams/basic_scoped_ostream.h

@@ -20,7 +20,7 @@
 #ifndef BEAST_STREAMS_BASIC_SCOPED_OSTREAM_H_INCLUDED
 #define BEAST_STREAMS_BASIC_SCOPED_OSTREAM_H_INCLUDED
 
-#include <beast/cxx14/memory.h> // <memory>
+#include <memory>
 
 #include <functional>
 #include <memory>

src/beast/beast/threads/SharedData.h

@@ -1,287 +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_THREADS_SHAREDDATA_H_INCLUDED
-#define BEAST_THREADS_SHAREDDATA_H_INCLUDED
-
-#include <beast/threads/RecursiveMutex.h>
-#include <beast/threads/SharedMutexAdapter.h>
-
-namespace beast {
-
-/** Structured, multi-threaded access to a shared state.
-
-    This container combines locking semantics with data access semantics to
-    create an alternative to the typical synchronization method of first
-    acquiring a lock and then accessing data members.
-
-    With this container, access to the underlying data is only possible after
-    first acquiring a lock. The steps of acquiring the lock and obtaining
-    a const or non-const reference to the data are combined into one
-    RAII style operation.
-
-    There are three types of access:
-
-    - Access
-        Provides access to the shared state via a non-const reference or pointer.
-        Access acquires a unique lock on the mutex associated with the
-        container.
-
-    - ConstAccess
-        Provides access to the shared state via a const reference or pointer.
-        ConstAccess acquires a shared lock on the mutex associated with the
-        container.
-
-    - ConstUnlockedAccess
-        Provides access to the shared state via a const reference or pointer.
-        No locking is performed. It is the callers responsibility to ensure that
-        the operation is synchronized. This can be useful for diagnostics or
-        assertions, or for when it is known that no other threads can access
-        the data.
-
-    - UnlockedAccess
-        Provides access to the shared state via a reference or pointer.
-        No locking is performed. It is the callers responsibility to ensure that
-        the operation is synchronized. This can be useful for diagnostics or
-        assertions, or for when it is known that no other threads can access
-        the data.
-
-    Usage example:
-
-    @code
-
-    struct State
-    {
-        int value1;
-        String value2;
-    };
-
-    using SharedState = SharedData <State>;
-
-    SharedState m_state;
-
-    void readExample ()
-    {
-        SharedState::ConstAccess state (m_state);
-
-        print (state->value1);   // read access
-        print (state->value2);   // read access
-
-        state->value1 = 42;      // write disallowed: compile error
-    }
-
-    void writeExample ()
-    {
-        SharedState::Access state (m_state);
-
-        state->value2 = "Label"; // write access, allowed
-    }
-
-    @endcode
-
-    Requirements for Value:
-        Constructible
-        Destructible
-
-    Requirements for SharedMutexType:
-        X is SharedMutexType, a is an instance of X:
-        X a;                    DefaultConstructible
-        X::LockGuardType        Names a type that implements the LockGuard concept.
-        X::SharedLockGuardType  Names a type that implements the SharedLockGuard concept.
-
-    @tparam Value The type which the container holds.
-    @tparam SharedMutexType The type of shared mutex to use.
-*/
-template <typename Value, class SharedMutexType =
-    SharedMutexAdapter <RecursiveMutex> >
-class SharedData
-{
-private:
-    using LockGuardType = typename SharedMutexType::LockGuardType;
-    using SharedLockGuardType = typename SharedMutexType::SharedLockGuardType;
-
-public:
-    using ValueType = Value;
-
-    class Access;
-    class ConstAccess;
-    class UnlockedAccess;
-    class ConstUnlockedAccess;
-
-    /** Create a shared data container.
-        Up to 8 parameters can be specified in the constructor. These parameters
-        are forwarded to the corresponding constructor in Data. If no
-        constructor in Data matches the parameter list, a compile error is
-        generated.
-    */
-    /** @{ */
-    SharedData () = default;
-
-    template <class T1>
-    explicit SharedData (T1 t1)
-        : m_value (t1) { }
-
-    template <class T1, class T2>
-    SharedData (T1 t1, T2 t2)
-        : m_value (t1, t2) { }
-
-    template <class T1, class T2, class T3>
-    SharedData (T1 t1, T2 t2, T3 t3)
-        : m_value (t1, t2, t3) { }
-
-    template <class T1, class T2, class T3, class T4>
-    SharedData (T1 t1, T2 t2, T3 t3, T4 t4)
-        : m_value (t1, t2, t3, t4) { }
-
-    template <class T1, class T2, class T3, class T4, class T5>
-    SharedData (T1 t1, T2 t2, T3 t3, T4 t4, T5 t5)
-        : m_value (t1, t2, t3, t4, t5) { }
-
-    template <class T1, class T2, class T3, class T4, class T5, class T6>
-    SharedData (T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6)
-        : m_value (t1, t2, t3, t4, t5, t6) { }
-
-    template <class T1, class T2, class T3, class T4, class T5, class T6, class T7>
-    SharedData (T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7) : m_value (t1, t2, t3, t4, t5, t6, t7) { }
-
-    template <class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8>
-    SharedData (T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8)
-        : m_value (t1, t2, t3, t4, t5, t6, t7, t8) { }
-    /** @} */
-
-    SharedData (SharedData const&) = delete;
-    SharedData& operator= (SharedData const&) = delete;
-
-private:
-    Value m_value;
-    SharedMutexType m_mutex;
-};
-
-//------------------------------------------------------------------------------
-
-/** Provides non-const access to the contents of a SharedData.
-    This acquires a unique lock on the underlying mutex.
-*/
-template <class Data, class SharedMutexType>
-class SharedData <Data, SharedMutexType>::Access
-{
-public:
-    explicit Access (SharedData& state)
-        : m_state (state)
-        , m_lock (m_state.m_mutex)
-        { }
-
-    Access (Access const&) = delete;
-    Access& operator= (Access const&) = delete;
-
-    Data const& get () const { return m_state.m_value; }
-    Data const& operator* () const { return get (); }
-    Data const* operator-> () const { return &get (); }
-    Data& get () { return m_state.m_value; }
-    Data& operator* () { return get (); }
-    Data* operator-> () { return &get (); }
-
-private:
-    SharedData& m_state;
-    typename SharedData::LockGuardType m_lock;
-};
-
-//------------------------------------------------------------------------------
-
-/** Provides const access to the contents of a SharedData.
-    This acquires a shared lock on the underlying mutex.
-*/
-template <class Data, class SharedMutexType>
-class SharedData <Data, SharedMutexType>::ConstAccess
-{
-public:
-    /** Create a ConstAccess from the specified SharedData */
-    explicit ConstAccess (SharedData const volatile& state)
-        : m_state (const_cast <SharedData const&> (state))
-        , m_lock (m_state.m_mutex)
-        { }
-
-    ConstAccess (ConstAccess const&) = delete;
-    ConstAccess& operator= (ConstAccess const&) = delete;
-
-    Data const& get () const { return m_state.m_value; }
-    Data const& operator* () const { return get (); }
-    Data const* operator-> () const { return &get (); }
-
-private:
-    SharedData const& m_state;
-    typename SharedData::SharedLockGuardType m_lock;
-};
-
-//------------------------------------------------------------------------------
-
-/** Provides const access to the contents of a SharedData.
-    This acquires a shared lock on the underlying mutex.
-*/
-template <class Data, class SharedMutexType>
-class SharedData <Data, SharedMutexType>::ConstUnlockedAccess
-{
-public:
-    /** Create an UnlockedAccess from the specified SharedData */
-    explicit ConstUnlockedAccess (SharedData const volatile& state)
-        : m_state (const_cast <SharedData const&> (state))
-        { }
-
-    ConstUnlockedAccess (ConstUnlockedAccess const&) = delete;
-    ConstUnlockedAccess& operator= (ConstUnlockedAccess const&) = delete;
-
-    Data const& get () const { return m_state.m_value; }
-    Data const& operator* () const { return get (); }
-    Data const* operator-> () const { return &get (); }
-
-private:
-    SharedData const& m_state;
-};
-
-//------------------------------------------------------------------------------
-
-/** Provides access to the contents of a SharedData.
-    This acquires a shared lock on the underlying mutex.
-*/
-template <class Data, class SharedMutexType>
-class SharedData <Data, SharedMutexType>::UnlockedAccess
-{
-public:
-    /** Create an UnlockedAccess from the specified SharedData */
-    explicit UnlockedAccess (SharedData& state)
-        : m_state (state)
-        { }
-
-    UnlockedAccess (UnlockedAccess const&) = delete;
-    UnlockedAccess& operator= (UnlockedAccess const&) = delete;
-
-    Data const& get () const { return m_state.m_value; }
-    Data const& operator* () const { return get (); }
-    Data const* operator-> () const { return &get (); }
-    Data& get () { return m_state.m_value; }
-    Data& operator* () { return get (); }
-    Data* operator-> () { return &get (); }
-
-private:
-    SharedData& m_state;
-};
-
-}
-
-#endif

src/beast/beast/threads/SpinLock.h

@@ -25,7 +25,6 @@
 #define BEAST_THREADS_SPINLOCK_H_INCLUDED
 
 #include <beast/threads/UnlockGuard.h>
-#include <beast/utility/noexcept.h>
 #include <atomic>
 #include <cassert>
 #include <mutex>

src/beast/beast/threads/Stoppable.h

@@ -22,10 +22,11 @@
 
 #include <beast/intrusive/LockFreeStack.h>
 #include <beast/utility/Journal.h>
-
 #include <beast/threads/WaitableEvent.h>
-
 #include <atomic>
+#include <chrono>
+#include <condition_variable>
+#include <mutex>
 
 namespace beast {
 
@@ -189,6 +190,15 @@ public:
     /** Returns `true` if all children have stopped. */
     bool areChildrenStopped () const;
 
+    /** Sleep or wake up on stop.
+
+        @return `true` if we are stopping
+    */
+    template <class Rep, class Period>
+    bool
+    alertable_sleep_for(
+        std::chrono::duration<Rep, Period> const& d);
+
 protected:
     /** Called by derived classes to indicate that the stoppable has stopped. */
     void stopped ();
@@ -266,8 +276,8 @@ private:
 
     void prepareRecursive ();
     void startRecursive ();
-    void stopAsyncRecursive ();
-    void stopRecursive (Journal journal);
+    void stopAsyncRecursive (Journal j);
+    void stopRecursive (Journal j);
 
     std::string m_name;
     RootStoppable& m_root;
@@ -314,22 +324,55 @@ public:
         Thread safety:
             Safe to call from any thread not associated with a Stoppable.
     */
-    void stop (Journal journal = Journal());
+    void stop (Journal j);
+
+    /** Sleep or wake up on stop.
+
+        @return `true` if we are stopping
+    */
+    template <class Rep, class Period>
+    bool
+    alertable_sleep_for(
+        std::chrono::duration<Rep, Period> const& d);
+
 private:
-    /** Notify a root stoppable and children to stop, without waiting.
+    /*  Notify a root stoppable and children to stop, without waiting.
         Has no effect if the stoppable was already notified.
 
         Thread safety:
             Safe to call from any thread at any time.
     */
-    void stopAsync ();
+    void stopAsync(Journal j);
 
     std::atomic<bool> m_prepared;
-    std::atomic<bool> m_calledStop;
+    bool m_calledStop;
     std::atomic<bool> m_calledStopAsync;
+    std::mutex m_;
+    std::condition_variable c_;
 };
 /** @} */
 
+//------------------------------------------------------------------------------
+
+template <class Rep, class Period>
+bool
+RootStoppable::alertable_sleep_for(
+    std::chrono::duration<Rep, Period> const& d)
+{
+    std::unique_lock<std::mutex> lock(m_);
+    if (m_calledStop)
+        return true;
+    return c_.wait_for(lock, d, [this]{return m_calledStop;});
+}
+
+template <class Rep, class Period>
+bool
+Stoppable::alertable_sleep_for(
+    std::chrono::duration<Rep, Period> const& d)
+{
+    return m_root.alertable_sleep_for(d);
+}
+
 }
 
 #endif

src/beast/beast/threads/impl/Stoppable.cpp

@@ -106,21 +106,28 @@ void Stoppable::startRecursive ()
         iter->stoppable->startRecursive ();
 }
 
-void Stoppable::stopAsyncRecursive ()
+void Stoppable::stopAsyncRecursive (Journal j)
 {
+    using namespace std::chrono;
+    auto const start = high_resolution_clock::now();
     onStop ();
+    auto const ms = duration_cast<milliseconds>(
+        high_resolution_clock::now() - start).count();
+    if (ms >= 10)
+        j.fatal << m_name << "::onStop took " << ms << "ms";
+
     for (Children::const_iterator iter (m_children.cbegin ());
         iter != m_children.cend(); ++iter)
-        iter->stoppable->stopAsyncRecursive ();
+        iter->stoppable->stopAsyncRecursive(j);
 }
 
-void Stoppable::stopRecursive (Journal journal)
+void Stoppable::stopRecursive (Journal j)
 {
     // Block on each child from the bottom of the tree up.
     //
     for (Children::const_iterator iter (m_children.cbegin ());
         iter != m_children.cend(); ++iter)
-        iter->stoppable->stopRecursive (journal);
+        iter->stoppable->stopRecursive (j);
 
     // if we get here then all children have stopped
     //
@@ -132,7 +139,7 @@ void Stoppable::stopRecursive (Journal journal)
     bool const timedOut (! m_stoppedEvent.wait (1 * 1000)); // milliseconds
     if (timedOut)
     {
-        journal.warning << "Waiting for '" << m_name << "' to stop";
+        j.warning << "Waiting for '" << m_name << "' to stop";
         m_stoppedEvent.wait ();
     }
 
@@ -171,25 +178,29 @@ void RootStoppable::start ()
         startRecursive ();
 }
 
-void RootStoppable::stop (Journal journal)
+void RootStoppable::stop (Journal j)
 {
     // Must have a prior call to start()
     bassert (m_started);
 
-    if (m_calledStop.exchange (true) == true)
     {
-        journal.warning << "Stoppable::stop called again";
+        std::lock_guard<std::mutex> lock(m_);
+        if (m_calledStop)
+        {
+            j.warning << "Stoppable::stop called again";
             return;
         }
-
-    stopAsync ();
-    stopRecursive (journal);
+        m_calledStop = true;
+        c_.notify_all();
+    }
+    stopAsync (j);
+    stopRecursive (j);
 }
 
-void RootStoppable::stopAsync ()
+void RootStoppable::stopAsync(Journal j)
 {
     if (m_calledStopAsync.exchange (true) == false)
-        stopAsyncRecursive ();
+        stopAsyncRecursive(j);
 }
 
 }

src/beast/beast/threads/impl/Stoppable.test.cpp

@@ -403,7 +403,7 @@ class Stoppable_test
         {
             prepare();
             start();
-            stop();
+            stop(Journal{});
         }
 
         void onPrepare() override

src/beast/beast/unit_test/suite.h

@@ -22,7 +22,6 @@
 
 #include <beast/unit_test/runner.h>
 
-#include <beast/utility/noexcept.h>
 #include <string>
 #include <sstream>
 
@@ -62,6 +61,7 @@ private:
         }
     };
 
+public:
     // Memberspace
     class log_t
     {
@@ -80,6 +80,7 @@ private:
         abstract_ostream&
         stream();
     };
+private:
 
     class scoped_testcase;
 
@@ -176,6 +177,48 @@ public:
         return expect (shouldBeTrue, "");
     }
 
+    /** Expect an exception from f() */
+    /** @{ */
+    template <class F, class String>
+    bool
+    except (F&& f, String const& reason);
+
+    template <class F>
+    bool
+    except (F&& f)
+    {
+        return except(f, "");
+    }
+    /** @} */
+
+    /** Expect an exception of the given type from f() */
+    /** @{ */
+    template <class E, class F, class String>
+    bool
+    except (F&& f, String const& reason);
+
+    template <class E, class F>
+    bool
+    except (F&& f)
+    {
+        return except<E>(f, "");
+    }
+    /** @} */
+
+    /** Fail if f() throws */
+    /** @{ */
+    template <class F, class String>
+    bool
+    unexcept (F&& f, String const& reason);
+
+    template <class F>
+    bool
+    unexcept (F&& f)
+    {
+        return unexcept(f, "");
+    }
+    /** @} */
+
     /** Return the argument associated with the runner. */
     std::string const&
     arg() const
@@ -355,6 +398,57 @@ suite::expect (Condition shouldBeTrue,
     return b;
 }
 
+template <class F, class String>
+bool
+suite::except (F&& f, String const& reason)
+{
+    try
+    {
+        f();
+        fail(reason);
+        return false;
+    }
+    catch(...)
+    {
+        pass();
+    }
+    return true;
+}
+
+template <class E, class F, class String>
+bool
+suite::except (F&& f, String const& reason)
+{
+    try
+    {
+        f();
+        fail(reason);
+        return false;
+    }
+    catch(E const&)
+    {
+        pass();
+    }
+    return true;
+}
+
+template <class F, class String>
+bool
+suite::unexcept (F&& f, String const& reason)
+{
+    try
+    {
+        f();
+        pass();
+        return true;
+    }
+    catch(...)
+    {
+        fail(reason);
+    }
+    return false;
+}
+
 template <class Condition, class String>
 inline
 bool

src/beast/beast/unit_test/thread.h

@@ -20,7 +20,6 @@
 #ifndef BEAST_UNIT_TEST_THREAD_H_INCLUDED
 #define BEAST_UNIT_TEST_THREAD_H_INCLUDED
 
-#include <beast/utility/noexcept.h>
 #include <beast/unit_test/suite.h>
 #include <functional>
 #include <thread>

src/beast/beast/utility/PropertyStream.h

@@ -21,9 +21,9 @@
 #define BEAST_UTILITY_PROPERTYSTREAM_H_INCLUDED
 
 #include <beast/intrusive/List.h>
-#include <beast/threads/SharedData.h>
 
 #include <cstdint>
+#include <mutex>
 #include <sstream>
 #include <string>
 #include <utility>
@@ -274,31 +274,11 @@ public:
 class PropertyStream::Source
 {
 private:
-    struct State
-    {
-        explicit State (Source* source)
-            : item (source)
-            , parent (nullptr)
-            { }
-
-        Item item;
-        Source* parent;
-        List <Item> children;
-    };
-
-    using SharedState = SharedData <State>;
-
     std::string const m_name;
-    SharedState m_state;
-
-    //--------------------------------------------------------------------------
-
-    void remove    (SharedState::Access& state,
-                    SharedState::Access& childState);
-
-    void removeAll (SharedState::Access& state);
-
-    void write     (SharedState::Access& state, PropertyStream& stream);
+    std::recursive_mutex lock_;
+    Item item_;
+    Source* parent_;
+    List <Item> children_;
 
 public:
     explicit Source (std::string const& name);
@@ -326,7 +306,7 @@ public:
     /** Remove a child source from this Source. */
     void remove (Source& child);
 
-    /** Remove all child sources of this Source. */
+    /** Remove all child sources from this Source. */
     void removeAll ();
 
     /** Write only this Source to the stream. */

src/beast/beast/utility/Utility.unity.cpp

@@ -28,7 +28,6 @@
 #include <beast/utility/tests/bassert.test.cpp>
 #include <beast/utility/tests/empty_base_optimization.test.cpp>
 #include <beast/utility/tests/Journal.test.cpp>
-#include <beast/utility/tests/static_initializer.test.cpp>
 #include <beast/utility/tests/tagged_integer.test.cpp>
 #include <beast/utility/tests/weak_fn.test.cpp>
 #include <beast/utility/tests/Zero.test.cpp>

src/beast/beast/utility/WrappedSink.h

@@ -69,17 +69,17 @@ public:
     }
 
     beast::Journal::Severity
-    severity() const
+    severity() const override
     {
         return sink_.severity();
     }
 
-    void severity (beast::Journal::Severity level)
+    void severity (beast::Journal::Severity level) override
     {
         sink_.severity (level);
     }
 
-    void write (beast::Journal::Severity level, std::string const& text)
+    void write (beast::Journal::Severity level, std::string const& text) override
     {
         using beast::Journal;
         sink_.write (level, prefix_ + text);

src/beast/beast/utility/ci_char_traits.h

@@ -20,8 +20,8 @@
 #ifndef BEAST_UTILITY_CI_CHAR_TRAITS_H_INCLUDED
 #define BEAST_UTILITY_CI_CHAR_TRAITS_H_INCLUDED
 
-#include <beast/cxx14/algorithm.h> // <algorithm>
-#include <beast/cxx14/type_traits.h> // <type_traits>
+#include <algorithm>
+#include <type_traits>
 #include <cctype>
 #include <iterator>
 #include <string>

src/beast/beast/utility/empty_base_optimization.h

@@ -21,7 +21,6 @@
 #ifndef BEAST_UTILITY_EMPTY_BASE_OPTIMIZATION_H_INCLUDED
 #define BEAST_UTILITY_EMPTY_BASE_OPTIMIZATION_H_INCLUDED
 
-#include <beast/utility/noexcept.h>
 #include <type_traits>
 #include <utility>
 

src/beast/beast/utility/impl/Journal.cpp

@@ -18,7 +18,6 @@
 //==============================================================================
 
 #include <beast/utility/Journal.h>
-#include <beast/utility/static_initializer.h>
 
 namespace beast {
 
@@ -60,8 +59,8 @@ public:
 
 Journal::Sink& Journal::getNullSink ()
 {
-    static beast::static_initializer<NullJournalSink> sink;
-    return *sink;
+    static NullJournalSink sink;
+    return sink;
 }
 
 //------------------------------------------------------------------------------

src/beast/beast/utility/impl/PropertyStream.cpp

@@ -173,16 +173,17 @@ PropertyStream const& PropertyStream::Set::stream() const
 
 PropertyStream::Source::Source (std::string const& name)
     : m_name (name)
-    , m_state (this)
+    , item_ (this)
+    , parent_ (nullptr)
 {
 }
 
 PropertyStream::Source::~Source ()
 {
-    SharedState::Access state (m_state);
-    if (state->parent != nullptr)
-        state->parent->remove (*this);
-    removeAll (state);
+    std::lock_guard<std::recursive_mutex> _(lock_);
+    if (parent_ != nullptr)
+        parent_->remove (*this);
+    removeAll ();
 }
 
 std::string const& PropertyStream::Source::name () const
@@ -192,37 +193,35 @@ std::string const& PropertyStream::Source::name () const
 
 void PropertyStream::Source::add (Source& source)
 {
-    SharedState::Access state (m_state);
-    SharedState::Access childState (source.m_state);
-    bassert (childState->parent == nullptr);
-    state->children.push_back (childState->item);
-    childState->parent = this;
+    std::lock(lock_, source.lock_);
+    std::lock_guard<std::recursive_mutex> lk1(lock_, std::adopt_lock);
+    std::lock_guard<std::recursive_mutex> lk2(source.lock_, std::adopt_lock);
+
+    bassert (source.parent_ == nullptr);
+    children_.push_back (source.item_);
+    source.parent_ = this;
 }
 
 void PropertyStream::Source::remove (Source& child)
 {
-    SharedState::Access state (m_state);
-    SharedState::Access childState (child.m_state);
-    remove (state, childState);
+    std::lock(lock_, child.lock_);
+    std::lock_guard<std::recursive_mutex> lk1(lock_, std::adopt_lock);
+    std::lock_guard<std::recursive_mutex> lk2(child.lock_, std::adopt_lock);
+
+    bassert (child.parent_ == this);
+    children_.erase (
+        children_.iterator_to (
+            child.item_));
+    child.parent_ = nullptr;
 }
 
 void PropertyStream::Source::removeAll ()
 {
-    SharedState::Access state (m_state);
-    removeAll (state);
-}
-
-//------------------------------------------------------------------------------
-
-void PropertyStream::Source::write (
-    SharedState::Access& state, PropertyStream &stream)
-{
-    for (List <Item>::iterator iter (state->children.begin());
-        iter != state->children.end(); ++iter)
+    std::lock_guard<std::recursive_mutex> _(lock_);
+    for (auto iter = children_.begin(); iter != children_.end(); )
     {
-        Source& source (iter->source());
-        Map map (source.name(), stream);
-        source.write (stream);
+        std::lock_guard<std::recursive_mutex> _cl((*iter)->lock_);
+        remove (*(*iter));
     }
 }
 
@@ -239,14 +238,10 @@ void PropertyStream::Source::write (PropertyStream& stream)
     Map map (m_name, stream);
     onWrite (map);
 
-    SharedState::Access state (m_state);
+    std::lock_guard<std::recursive_mutex> _(lock_);
 
-    for (List <Item>::iterator iter (state->children.begin());
-        iter != state->children.end(); ++iter)
-    {
-        Source& source (iter->source());
-        source.write (stream);
-    }
+    for (auto& child : children_)
+        child.source().write (stream);
 }
 
 void PropertyStream::Source::write (PropertyStream& stream, std::string const& path)
@@ -330,8 +325,9 @@ PropertyStream::Source* PropertyStream::Source::find_one_deep (std::string const
     Source* found = find_one (name);
     if (found != nullptr)
         return found;
-    SharedState::Access state (this->m_state);
-    for (auto& s : state->children)
+
+    std::lock_guard<std::recursive_mutex> _(lock_);
+    for (auto& s : children_)
     {
         found = s.source().find_one_deep (name);
         if (found != nullptr)
@@ -360,8 +356,8 @@ PropertyStream::Source* PropertyStream::Source::find_path (std::string path)
 // If no immediate children match, then return nullptr
 PropertyStream::Source* PropertyStream::Source::find_one (std::string const& name)
 {
-    SharedState::Access state (this->m_state);
-    for (auto& s : state->children)
+    std::lock_guard<std::recursive_mutex> _(lock_);
+    for (auto& s : children_)
     {
         if (s.source().m_name == name)
             return &s.source();
@@ -373,28 +369,6 @@ void PropertyStream::Source::onWrite (Map&)
 {
 }
 
-//------------------------------------------------------------------------------
-
-void PropertyStream::Source::remove (
-    SharedState::Access& state, SharedState::Access& childState)
-{
-    bassert (childState->parent == this);
-    state->children.erase (
-        state->children.iterator_to (
-            childState->item));
-    childState->parent = nullptr;
-}
-
-void PropertyStream::Source::removeAll (SharedState::Access& state)
-{
-    for (List <Item>::iterator iter (state->children.begin());
-        iter != state->children.end();)
-    {
-        SharedState::Access childState ((*iter)->m_state);
-        remove (state, childState);
-    }
-}
-
 //------------------------------------------------------------------------------
 //
 // PropertyStream

src/beast/beast/utility/meta.h

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