Set version to 0.26.1

* Activate async code path
* Tidy up HTTP server code
* Use shared_ptr in HTTP server
* Remove check for unspecified IP
* Remove hairtrigger
* Fix missing HTTP authorization check
* Fix multisocket flags in RPC-HTTP server
* Fix authorization failure when no credentials required
* Addresses RIPD-159, RIPD-161, RIPD-390

.gitattributes

@@ -1,5 +1,5 @@
 # Set default behaviour, in case users don't have core.autocrlf set.
-* text=auto
+#* text=auto
 
 # These annoying files
 rippled.1 binary

.gitignore

@@ -72,3 +72,6 @@ My Amplifier XE Results - RippleD
 
 # Compiler intermediate output
 /out.txt
+
+# Build Log
+rippled-build.log

.travis.yml

@@ -12,6 +12,14 @@ before_install:
   - sudo apt-get install -qq libboost1.55-all-dev 
   # We want debug symbols for boost as we install gdb later
   - sudo apt-get install -qq libboost1.55-dbg
+  - | # Setup the BOOST_ROOT
+      export BOOST_ROOT=$HOME/boost_root
+      mkdir -p $BOOST_ROOT/stage
+      ln -s /usr/lib/x86_64-linux-gnu $BOOST_ROOT/stage/lib
+      ln -s /usr/include/boost $BOOST_ROOT/boost
+  - | # Try to patch boost
+      sudo patch /usr/include/boost/bimap/detail/debug/static_error.hpp Builds/travis/static_error.boost.patch
+      sudo patch /usr/include/boost/config/compiler/clang.hpp Builds/travis/clang.boost.patch
   - sudo apt-get install -qq mlocate
   - sudo updatedb
   - sudo locate libboost | grep /lib | grep -e ".a$"

Builds/ArchLinux/PKGBUILD

@@ -0,0 +1,41 @@
+# Maintainer: Roberto Catini <roberto.catini@gmail.com> 
+
+pkgname=rippled
+pkgrel=1
+pkgver=0
+pkgdesc="Ripple peer-to-peer network daemon"
+arch=('i686' 'x86_64')
+url="https://github.com/ripple/rippled"
+license=('custom:ISC')
+depends=('protobuf' 'openssl' 'boost-libs')
+makedepends=('git' 'scons' 'boost')
+checkdepends=('nodejs')
+backup=("etc/$pkgname/rippled.cfg")
+source=("git://github.com/ripple/rippled.git#branch=master")
+sha512sums=('SKIP')
+
+pkgver() {
+	cd "$srcdir/$pkgname"
+	git describe --long --tags | sed -r 's/([^-]*-g)/r\1/;s/-/./g'
+}
+
+build() {
+	cd "$srcdir/$pkgname"
+	scons build/rippled
+}
+
+check() {
+	cd "$srcdir/$pkgname"
+	npm install
+	npm test
+	build/rippled --unittest
+}
+
+package() {
+	cd "$srcdir/$pkgname"
+	install -D -m644 LICENSE "$pkgdir/usr/share/licenses/$pkgname/LICENSE"
+	install -D build/rippled "$pkgdir/usr/bin/rippled"
+	install -D -m644 doc/rippled-example.cfg "$pkgdir/etc/$pkgname/rippled.cfg"
+	mkdir -p "$pkgdir/var/lib/$pkgname/db"
+	mkdir -p "$pkgdir/var/log/$pkgname"
+}

Builds/Docker/Dockerfile

@@ -0,0 +1,30 @@
+# rippled
+
+# use the ubuntu base image
+FROM ubuntu
+MAINTAINER Roberto Catini roberto.catini@gmail.com
+
+# make sure the package repository is up to date
+RUN apt-get update
+RUN apt-get -y upgrade
+
+# install the dependencies
+RUN apt-get -y install git scons pkg-config protobuf-compiler libprotobuf-dev libssl-dev libboost1.55-all-dev
+
+# download source code from official repository
+RUN git clone https://github.com/ripple/rippled.git src; cd src/; git checkout master
+
+# compile
+RUN cd src/; scons build/rippled
+
+# move to root directory and strip
+RUN cp src/build/rippled rippled; strip rippled
+
+# copy default config
+RUN cp src/doc/rippled-example.cfg rippled.cfg
+
+# clean source
+RUN rm -r src
+
+# launch rippled when launching the container
+ENTRYPOINT ./rippled

Builds/QtCreator/rippled.pro

@@ -45,7 +45,6 @@ linux-g++:QMAKE_CXXFLAGS += \
     -pthread
 
 INCLUDEPATH += \
-    "../../src/BeastConfig/" \
     "../../src/leveldb/" \
     "../../src/leveldb/port" \
     "../../src/leveldb/include" \
@@ -63,42 +62,42 @@ UI_HEADERS_DIR += ../../src/ripple_basics
 # New style
 #
 SOURCES += \
-    ../../src/ripple/beast/ripple_beast.cpp \
+    ../../src/ripple/beast/ripple_beast.unity.cpp \
     ../../src/ripple/beast/ripple_beastc.c \
-    ../../src/ripple/common/ripple_common.cpp \
-    ../../src/ripple/http/ripple_http.cpp \
-    ../../src/ripple/json/ripple_json.cpp \
-    ../../src/ripple/peerfinder/ripple_peerfinder.cpp \
-    ../../src/ripple/radmap/ripple_radmap.cpp \
-    ../../src/ripple/resource/ripple_resource.cpp \
-    ../../src/ripple/sitefiles/ripple_sitefiles.cpp \
-    ../../src/ripple/sslutil/ripple_sslutil.cpp \
-    ../../src/ripple/testoverlay/ripple_testoverlay.cpp \
-    ../../src/ripple/types/ripple_types.cpp \
-    ../../src/ripple/validators/ripple_validators.cpp
+    ../../src/ripple/common/ripple_common.unity.cpp \
+    ../../src/ripple/http/ripple_http.unity.cpp \
+    ../../src/ripple/json/ripple_json.unity.cpp \
+    ../../src/ripple/peerfinder/ripple_peerfinder.unity.cpp \
+    ../../src/ripple/radmap/ripple_radmap.unity.cpp \
+    ../../src/ripple/resource/ripple_resource.unity.cpp \
+    ../../src/ripple/sitefiles/ripple_sitefiles.unity.cpp \
+    ../../src/ripple/sslutil/ripple_sslutil.unity.cpp \
+    ../../src/ripple/testoverlay/ripple_testoverlay.unity.cpp \
+    ../../src/ripple/types/ripple_types.unity.cpp \
+    ../../src/ripple/validators/ripple_validators.unity.cpp
 
 # ---------
 # Old style
 #
 SOURCES += \
-    ../../src/ripple_app/ripple_app.cpp \
-    ../../src/ripple_app/ripple_app_pt1.cpp \
-    ../../src/ripple_app/ripple_app_pt2.cpp \
-    ../../src/ripple_app/ripple_app_pt3.cpp \
-    ../../src/ripple_app/ripple_app_pt4.cpp \
-    ../../src/ripple_app/ripple_app_pt5.cpp \
-    ../../src/ripple_app/ripple_app_pt6.cpp \
-    ../../src/ripple_app/ripple_app_pt7.cpp \
-    ../../src/ripple_app/ripple_app_pt8.cpp \
-    ../../src/ripple_basics/ripple_basics.cpp \
-    ../../src/ripple_core/ripple_core.cpp \
-    ../../src/ripple_data/ripple_data.cpp \
-    ../../src/ripple_hyperleveldb/ripple_hyperleveldb.cpp \
-    ../../src/ripple_leveldb/ripple_leveldb.cpp \
-    ../../src/ripple_net/ripple_net.cpp \
-    ../../src/ripple_overlay/ripple_overlay.cpp \
-    ../../src/ripple_rpc/ripple_rpc.cpp \
-    ../../src/ripple_websocket/ripple_websocket.cpp
+    ../../src/ripple_app/ripple_app.unity.cpp \
+    ../../src/ripple_app/ripple_app_pt1.unity.cpp \
+    ../../src/ripple_app/ripple_app_pt2.unity.cpp \
+    ../../src/ripple_app/ripple_app_pt3.unity.cpp \
+    ../../src/ripple_app/ripple_app_pt4.unity.cpp \
+    ../../src/ripple_app/ripple_app_pt5.unity.cpp \
+    ../../src/ripple_app/ripple_app_pt6.unity.cpp \
+    ../../src/ripple_app/ripple_app_pt7.unity.cpp \
+    ../../src/ripple_app/ripple_app_pt8.unity.cpp \
+    ../../src/ripple_basics/ripple_basics.unity.cpp \
+    ../../src/ripple_core/ripple_core.unity.cpp \
+    ../../src/ripple_data/ripple_data.unity.cpp \
+    ../../src/ripple_hyperleveldb/ripple_hyperleveldb.unity.cpp \
+    ../../src/ripple_leveldb/ripple_leveldb.unity.cpp \
+    ../../src/ripple_net/ripple_net.unity.cpp \
+    ../../src/ripple_overlay/ripple_overlay.unity.cpp \
+    ../../src/ripple_rpc/ripple_rpc.unity.cpp \
+    ../../src/ripple_websocket/ripple_websocket.unity.cpp
 
 LIBS += \
     -lboost_date_time-mt\

Builds/VisualStudio2013/.gitattributes

@@ -0,0 +1,4 @@
+RippleD.vcxproj             -text
+RippleD.vcxproj.filters     -text
+
+

Builds/VisualStudio2013/RippleD.props

@@ -1,31 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ImportGroup Label="PropertySheets" />
-  <PropertyGroup Label="UserMacros">
-    <RepoDir>..\..</RepoDir>
-  </PropertyGroup>
-  <PropertyGroup>
-    <OutDir>$(RepoDir)\build\VisualStudio2013\$(Configuration).$(Platform)\</OutDir>
-    <IntDir>$(RepoDir)\build\obj\VisualStudio2013\$(Configuration).$(Platform)\</IntDir>
-    <TargetName>rippled</TargetName>
-  </PropertyGroup>
-  <ItemDefinitionGroup>
-    <ClCompile>
-      <PreprocessorDefinitions>_VARIADIC_MAX=10;_WIN32_WINNT=0x0600;_SCL_SECURE_NO_WARNINGS;_CRT_SECURE_NO_WARNINGS;WIN32;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <MultiProcessorCompilation>true</MultiProcessorCompilation>
-      <WarningLevel>Level3</WarningLevel>
-      <AdditionalIncludeDirectories>$(RepoDir)\src\BeastConfig;$(RepoDir)\src\protobuf\src;$(RepoDir)\src\protobuf\vsprojects;$(RepoDir)\src\leveldb;$(RepoDir)\src\leveldb\include;$(RepoDir)\build\proto;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
-      <ExceptionHandling>Async</ExceptionHandling>
-      <DisableSpecificWarnings>4018;4244</DisableSpecificWarnings>
-    </ClCompile>
-    <Link>
-      <AdditionalDependencies>Shlwapi.lib;%(AdditionalDependencies)</AdditionalDependencies>
-    </Link>
-  </ItemDefinitionGroup>
-  <ItemGroup>
-    <BuildMacro Include="RepoDir">
-      <Value>$(RepoDir)</Value>
-    </BuildMacro>
-  </ItemGroup>
-</Project>

Builds/VisualStudio2013/ripple.sln

@@ -1,11 +1,9 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio 2013
+# Visual Studio Express 2013 for Windows Desktop
 VisualStudioVersion = 12.0.30110.0
 MinimumVisualStudioVersion = 10.0.40219.1
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "beast", "..\..\src\beast\Builds\VisualStudio2013\beast.vcxproj", "{73C5A0F0-7629-4DE7-9194-BE7AC6C19535}"
-EndProject
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "RippleD", "RippleD.vcxproj", "{B7F39ECD-473C-484D-BC34-31F8362506A5}"
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "RippleD", "RippleD.vcxproj", "{26B7D9AC-1A80-8EF8-6703-D061F1BECB75}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
@@ -15,22 +13,12 @@ Global
 		Release|x64 = Release|x64
 	EndGlobalSection
 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{73C5A0F0-7629-4DE7-9194-BE7AC6C19535}.Debug|Win32.ActiveCfg = Debug|Win32
-		{73C5A0F0-7629-4DE7-9194-BE7AC6C19535}.Debug|Win32.Build.0 = Debug|Win32
-		{73C5A0F0-7629-4DE7-9194-BE7AC6C19535}.Debug|x64.ActiveCfg = Debug|x64
-		{73C5A0F0-7629-4DE7-9194-BE7AC6C19535}.Debug|x64.Build.0 = Debug|x64
-		{73C5A0F0-7629-4DE7-9194-BE7AC6C19535}.Release|Win32.ActiveCfg = Release|Win32
-		{73C5A0F0-7629-4DE7-9194-BE7AC6C19535}.Release|Win32.Build.0 = Release|Win32
-		{73C5A0F0-7629-4DE7-9194-BE7AC6C19535}.Release|x64.ActiveCfg = Release|x64
-		{73C5A0F0-7629-4DE7-9194-BE7AC6C19535}.Release|x64.Build.0 = Release|x64
-		{B7F39ECD-473C-484D-BC34-31F8362506A5}.Debug|Win32.ActiveCfg = Debug|Win32
-		{B7F39ECD-473C-484D-BC34-31F8362506A5}.Debug|Win32.Build.0 = Debug|Win32
-		{B7F39ECD-473C-484D-BC34-31F8362506A5}.Debug|x64.ActiveCfg = Debug|x64
-		{B7F39ECD-473C-484D-BC34-31F8362506A5}.Debug|x64.Build.0 = Debug|x64
-		{B7F39ECD-473C-484D-BC34-31F8362506A5}.Release|Win32.ActiveCfg = Release|Win32
-		{B7F39ECD-473C-484D-BC34-31F8362506A5}.Release|Win32.Build.0 = Release|Win32
-		{B7F39ECD-473C-484D-BC34-31F8362506A5}.Release|x64.ActiveCfg = Release|x64
-		{B7F39ECD-473C-484D-BC34-31F8362506A5}.Release|x64.Build.0 = Release|x64
+		{26B7D9AC-1A80-8EF8-6703-D061F1BECB75}.Debug|Win32.ActiveCfg = debug|x64
+		{26B7D9AC-1A80-8EF8-6703-D061F1BECB75}.Debug|x64.ActiveCfg = debug|x64
+		{26B7D9AC-1A80-8EF8-6703-D061F1BECB75}.Debug|x64.Build.0 = debug|x64
+		{26B7D9AC-1A80-8EF8-6703-D061F1BECB75}.Release|Win32.ActiveCfg = release|x64
+		{26B7D9AC-1A80-8EF8-6703-D061F1BECB75}.Release|x64.ActiveCfg = release|x64
+		{26B7D9AC-1A80-8EF8-6703-D061F1BECB75}.Release|x64.Build.0 = release|x64
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

Builds/rpm/rippled.spec

@@ -0,0 +1,53 @@
+Name:           rippled
+Version:        0.26.1
+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
+

Builds/travis/clang.boost.patch

@@ -0,0 +1,13 @@
+--- /usr/include/boost/config/compiler/clang.hpp 2013-07-20 13:17:10.000000000 -0400
++++ /usr/include/boost/config/compiler/clang.rippled.hpp 2014-03-11 16:40:51.000000000 -0400
+@@ -39,6 +39,10 @@
+ // Clang supports "long long" in all compilation modes.
+ #define BOOST_HAS_LONG_LONG
+
++#if defined(__SIZEOF_INT128__)
++#  define BOOST_HAS_INT128
++#endif
++
+ //
+ // Dynamic shared object (DSO) and dynamic-link library (DLL) support
+ //

Builds/travis/static_error.boost.patch

@@ -0,0 +1,10 @@
+--- /usr/include/boost/bimap/detail/debug/static_error.hpp   2008-03-22 17:45:55.000000000 -0400
++++ /usr/include/boost/bimap/detail/debug/static_error.rippled.hpp   2014-03-12 19:40:05.000000000 -0400
+@@ -25,7 +25,6 @@
+ // a static error.
+ /*===========================================================================*/
+ #define BOOST_BIMAP_STATIC_ERROR(MESSAGE,VARIABLES)                           \
+-        struct BOOST_PP_CAT(BIMAP_STATIC_ERROR__,MESSAGE) {};                 \
+         BOOST_MPL_ASSERT_MSG(false,                                           \
+                              BOOST_PP_CAT(BIMAP_STATIC_ERROR__,MESSAGE),      \
+                              VARIABLES)

README.md

@@ -1,8 +1,8 @@
-#Ripple - P2P Payment Network
+#rippled - Ripple P2P server
 
 ##[![Build Status](https://travis-ci.org/ripple/rippled.png?branch=develop)](https://travis-ci.org/ripple/rippled)
 
-This is the repository for Ripple's `rippled`, reference P2P network server.
+This is the repository for Ripple's `rippled`, reference P2P server.
 
 ###Build instructions:
 * https://ripple.com/wiki/Rippled_build_instructions
@@ -33,20 +33,8 @@ README for more details.
 Javascript / Mocha tests.
 
 ## License
-
-Provided under the terms of the ISC License:
-
-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.
+Ripple is open source and permissively licensed under the ISC license. See the
+LICENSE file for more details.
 
 ###For more information:
 * https://ripple.com

SConstruct

@@ -1,334 +1,605 @@
+# rippled SConstruct
 #
-# Ripple - SConstruct
-#
+'''
 
-import commands
-import copy
-import glob
+    Target          Builds
+    ----------------------------------------------------------------------------
+
+    <none>          Same as 'install'
+    install         Default target and copies it to build/rippled (default)
+
+    all             All available variants
+    debug           All available debug variants
+    release         All available release variants
+
+    clang           All clang variants
+    clang.debug     clang debug variant
+    clang.release   clang release variant
+
+    gcc             All gcc variants
+    gcc.debug       gcc debug variant
+    gcc.release     gcc release variant
+
+    msvc            All msvc variants
+    msvc.debug      MSVC debug variant
+    msvc.release    MSVC release variant
+
+    vcxproj         Generate Visual Studio 2013 project file
+
+If the clang toolchain is detected, then the default target will use it, else
+the gcc toolchain will be used. On Windows environments, the MSVC toolchain is
+also detected.
+
+'''
+#
+'''
+
+TODO
+
+- Fix git-describe support
+- Fix printing exemplar command lines
+- Fix toolchain detection
+
+
+'''
+#-------------------------------------------------------------------------------
+
+import collections
 import os
-import platform
-import re
+import subprocess
 import sys
+import textwrap
+import time
+import SCons.Action
 
-OSX = bool(platform.mac_ver()[0])
-FreeBSD = bool('FreeBSD' == platform.system())
-Linux   = bool('Linux' == platform.system())
-Ubuntu  = bool(Linux and 'Ubuntu' == platform.linux_distribution()[0])
-Debian  = bool(Linux and 'debian' == platform.linux_distribution()[0])
-Archlinux  = bool(Linux and ('','','') == platform.linux_distribution()) #Arch still has issues with the platform module
+sys.path.append(os.path.join('src', 'beast', 'site_scons'))
 
-USING_CLANG = OSX or os.environ.get('CC', None) == 'clang'
+import Beast
 
-#
-# We expect this to be set
-#
-BOOST_HOME = os.environ.get("RIPPLED_BOOST_HOME", None)
+#------------------------------------------------------------------------------
+
+def parse_time(t):
+    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.')
+
+def check_openssl():
+    if Beast.system.platform in CHECK_PLATFORMS:
+        for line in subprocess.check_output(CHECK_COMMAND.split()).splitlines():
+            if line.startswith(CHECK_LINE):
+                line = line[len(CHECK_LINE):]
+                if parse_time(line) < parse_time(BUILD_TIME):
+                    raise Exception(OPENSSL_ERROR % (line, BUILD_TIME))
+                else:
+                    break
+        else:
+            raise Exception("Didn't find any '%s' line in '$ %s'" %
+                            (CHECK_LINE, CHECK_COMMAND))
 
 
-if OSX or Ubuntu or Debian or Archlinux:
-    CTAGS = 'ctags'
-elif FreeBSD:
-    CTAGS = 'exctags'
-else:
-    CTAGS = 'exuberant-ctags'
+def import_environ(env):
+    '''Imports environment settings into the construction environment'''
+    def set(keys):
+        if type(keys) == list:
+            for key in keys:
+                set(key)
+            return
+        if keys in os.environ:
+            value = os.environ[keys]
+            env[keys] = value
+    set(['GNU_CC', 'GNU_CXX', 'GNU_LINK'])
+    set(['CLANG_CC', 'CLANG_CXX', 'CLANG_LINK'])
 
-#
-# scons tools
-#
+def detect_toolchains(env):
+    def is_compiler(comp_from, comp_to):
+        return comp_from and comp_to in comp_from
 
-HONOR_ENVS = ['CC', 'CXX', 'PATH']
+    def detect_clang(env):
+        n = sum(x in env for x in ['CLANG_CC', 'CLANG_CXX', 'CLANG_LINK'])
+        if n > 0:
+            if n == 3:
+                return True
+            raise ValueError('CLANG_CC, CLANG_CXX, and CLANG_LINK must be set together')
+        cc = env.get('CC')
+        cxx = env.get('CXX')
+        link = env.subst(env.get('LINK'))
+        if (cc and cxx and link and
+            is_compiler(cc, 'clang') and
+            is_compiler(cxx, 'clang') and
+            is_compiler(link, 'clang')):
+            env['CLANG_CC'] = cc
+            env['CLANG_CXX'] = cxx
+            env['CLANG_LINK'] = link
+            return True
+        cc = env.WhereIs('clang')
+        cxx = env.WhereIs('clang++')
+        link = cxx
+        if (is_compiler(cc, 'clang') and
+            is_compiler(cxx, 'clang') and
+            is_compiler(link, 'clang')):
+           env['CLANG_CC'] = cc
+           env['CLANG_CXX'] = cxx
+           env['CLANG_LINK'] = link
+           return True
+        env['CLANG_CC'] = 'clang'
+        env['CLANG_CXX'] = 'clang++'
+        env['CLANG_LINK'] = env['LINK']
+        return False
 
-env = Environment(
-    tools = ['default', 'protoc'],
-    #ENV = dict((k, os.environ[k]) for k in HONOR_ENVS)
-    ENV = dict((k, os.environ[k]) for k in HONOR_ENVS if k in os.environ)
-)
+    def detect_gcc(env):
+        n = sum(x in env for x in ['GNU_CC', 'GNU_CXX', 'GNU_LINK'])
+        if n > 0:
+            if n == 3:
+                return True
+            raise ValueError('GNU_CC, GNU_CXX, and GNU_LINK must be set together')
+        cc = env.get('CC')
+        cxx = env.get('CXX')
+        link = env.subst(env.get('LINK'))
+        if (cc and cxx and link and
+            is_compiler(cc, 'gcc') and
+            is_compiler(cxx, 'g++') and
+            is_compiler(link, 'g++')):
+            env['GNU_CC'] = cc
+            env['GNU_CXX'] = cxx
+            env['GNU_LINK'] = link
+            return True
+        cc = env.WhereIs('gcc')
+        cxx = env.WhereIs('g++')
+        link = cxx
+        if (is_compiler(cc, 'gcc') and
+            is_compiler(cxx, 'g++') and
+            is_compiler(link, 'g++')):
+           env['GNU_CC'] = cc
+           env['GNU_CXX'] = cxx
+           env['GNU_LINK'] = link
+           return True
+        env['GNU_CC'] = 'gcc'
+        env['GNU_CXX'] = 'g++'
+        env['GNU_LINK'] = env['LINK']
+        return False
 
-# Use a newer gcc on FreeBSD
-if FreeBSD:
-    env.Replace(CC = 'gcc46')
-    env.Replace(CXX = 'g++46')
-    env.Append(CCFLAGS = ['-Wl,-rpath=/usr/local/lib/gcc46'])
-    env.Append(LINKFLAGS = ['-Wl,-rpath=/usr/local/lib/gcc46'])
+    toolchains = []
+    if detect_clang(env):
+        toolchains.append('clang')
+    if detect_gcc(env):
+        toolchains.append('gcc')
+    if env.Detect('cl'):
+        toolchains.append('msvc')
+    return toolchains
 
-if USING_CLANG:
-    env.Replace(CC= 'clang')
-    env.Replace(CXX= 'clang++')
+def files(base):
+    def _iter(base):
+        for parent, _, files in os.walk(base):
+            for path in files:
+                path = os.path.join(parent, path)
+                yield os.path.normpath(path)
+    return list(_iter(base))
 
-    if Linux:
-        env.Append(CXXFLAGS = ['-std=c++11', '-stdlib=libstdc++'])
-        env.Append(LINKFLAGS='-stdlib=libstdc++')
+def print_coms(target, source, env):
+    '''Display command line exemplars for an environment'''
+    print ('Target: ' + Beast.yellow(str(target[0])))
+    # TODO Add 'PROTOCCOM' to this list and make it work
+    Beast.print_coms(['CXXCOM', 'CCCOM', 'LINKCOM'], env)
 
-    if OSX:
-        env.Append(CXXFLAGS = ['-std=c++11', '-stdlib=libc++', 
-                               '-Wno-deprecated-register'])
-        env.Append(LINKFLAGS='-stdlib=libc++')
-        env['FRAMEWORKS'] = ['AppKit','Foundation']
+#-------------------------------------------------------------------------------
 
-GCC_VERSION = re.split('\.', commands.getoutput(env['CXX'] + ' -dumpversion'))
+# Set construction variables for the base environment
+def config_base(env):
+    if False:
+        env.Replace(
+            CCCOMSTR='Compiling ' + Beast.blue('$SOURCES'),
+            CXXCOMSTR='Compiling ' + Beast.blue('$SOURCES'),
+            LINKCOMSTR='Linking ' + Beast.blue('$TARGET'),
+            )
+    check_openssl()
 
-# Add support for ccache. Usage: scons ccache=1
-ccache = ARGUMENTS.get('ccache', 0)
-if int(ccache):
-    env.Prepend(CC = ['ccache'])
-    env.Prepend(CXX = ['ccache'])
-    ccache_dir = os.getenv('CCACHE_DIR')
-    if ccache_dir:
-        env.Replace(CCACHE_DIR = ccache_dir)
+    env.Append(CPPDEFINES=['OPENSSL_NO_SSL2'])
 
-#
-# Builder for CTags
-#
-ctags = Builder(action = '$CTAGS $CTAGSOPTIONS -f $TARGET $SOURCES')
-env.Append(BUILDERS = { 'CTags' : ctags })
-if OSX:
-    env.Replace(CTAGS = CTAGS)
-else:
-    env.Replace(CTAGS = CTAGS, CTAGSOPTIONS = '--tag-relative')
+    #git = Beast.Git(env) #  TODO(TOM)
+    if False: #git.exists:
+        env.Append(CPPDEFINES={'GIT_COMMIT_ID' : '"%s"' % git.commit_id})
 
-# Use openssl
-env.ParseConfig('pkg-config --static --cflags --libs openssl')
-# Use protobuf
-env.ParseConfig('pkg-config --static --cflags --libs protobuf')
+    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'),
+            ])
+        env['BOOST_ROOT'] = BOOST_ROOT
+    except KeyError:
+        pass
 
-# Beast uses kvm on FreeBSD
-if FreeBSD:
-    env.Append (
-        LIBS = [
-            'kvm'
+    if Beast.system.windows:
+        try:
+            OPENSSL_ROOT = os.path.normpath(os.environ['OPENSSL_ROOT'])
+            env.Append(CPPPATH=[
+                os.path.join(OPENSSL_ROOT, 'include'),
+                ])
+            env.Append(LIBPATH=[
+                os.path.join(OPENSSL_ROOT, 'lib', 'VC', 'static'),
+                ])
+        except KeyError:
+            pass
+    elif Beast.system.osx:
+        OSX_OPENSSL_ROOT = '/usr/local/Cellar/openssl/'
+        most_recent = sorted(os.listdir(OSX_OPENSSL_ROOT))[-1]
+        openssl = os.path.join(OSX_OPENSSL_ROOT, most_recent)
+        env.Prepend(CPPPATH='%s/include' % openssl)
+        env.Prepend(LIBPATH=['%s/lib' % openssl])
+
+# Set toolchain and variant specific construction variables
+def config_env(toolchain, variant, env):
+    if variant == 'debug':
+        env.Append(CPPDEFINES=['DEBUG', '_DEBUG'])
+
+    elif variant == 'release':
+        env.Append(CPPDEFINES=['NDEBUG'])
+
+    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')
+
+        env.Prepend(CCFLAGS=['-Wall'])
+
+        env.Append(CCFLAGS=[
+            '-Wno-sign-compare',
+            '-Wno-char-subscripts',
+            '-Wno-format',
+            '-Wno-deprecated-register'
+            ])
+
+        env.Append(CXXFLAGS=[
+            '-frtti',
+            '-std=c++11',
+            '-Wno-invalid-offsetof'])
+
+        if Beast.system.osx:
+            env.Append(CPPDEFINES={
+                'BEAST_COMPILE_OBJECTIVE_CPP': 1,
+                })
+
+        # These should be the same regardless of platform...
+        if Beast.system.osx:
+            env.Append(CCFLAGS=[
+                '-Wno-deprecated',
+                '-Wno-deprecated-declarations',
+                '-Wno-unused-variable',
+                '-Wno-unused-function',
+                ])
+        else:
+            if toolchain == 'gcc':
+                env.Append(CCFLAGS=[
+                    '-Wno-unused-but-set-variable'
+                    ])
+
+        boost_libs = [
+            'boost_date_time',
+            'boost_filesystem',
+            'boost_program_options',
+            'boost_regex',
+            'boost_system',
+            'boost_thread'
         ]
-    )
+        # We prefer static libraries for boost
+        if env.get('BOOST_ROOT'):
+            static_libs = ['%s/stage/lib/lib%s.a' % (env['BOOST_ROOT'], l) for
+                           l in boost_libs]
+            if all(os.path.exists(f) for f in static_libs):
+                boost_libs = [File(f) for f in static_libs]
 
-# The required version of boost is documented in the README file.
-BOOST_LIBS = [
-    'boost_date_time',
-    'boost_filesystem',
-    'boost_program_options',
-    'boost_regex',
-    'boost_system',
-    'boost_thread',
-]
+        env.Append(LIBS=boost_libs)
+        env.Append(LIBS=['dl'])
 
-# We whitelist platforms where the non -mt version is linked with pthreads. This
-# can be verified with: ldd libboost_filesystem.* If a threading library is
-# included the platform can be whitelisted.
-# if FreeBSD or Ubuntu or Archlinux:
+        if Beast.system.osx:
+            env.Append(LIBS=[
+                'crypto',
+                'protobuf',
+                'ssl',
+                ])
+            env.Append(FRAMEWORKS=[
+                'AppKit',
+                'Foundation'
+                ])
+        else:
+            env.Append(LIBS=['rt'])
 
-if not (USING_CLANG and Linux) and (FreeBSD or Ubuntu or Archlinux or Debian or OSX):
-    # non-mt libs do link with pthreads.
-    env.Append(
-        LIBS = BOOST_LIBS
-    )
-elif Linux and USING_CLANG and Ubuntu:
-    # It's likely going to be here if using boost 1.55 
-    boost_statics = [ ("/usr/lib/x86_64-linux-gnu/lib%s.a" % a) for a in 
-                      BOOST_LIBS ]
+        env.Append(LINKFLAGS=[
+            '-rdynamic'
+            ])
 
-    if not all(os.path.exists(f) for f in boost_statics):
-        # Else here
-        boost_statics = [("/usr/lib/lib%s.a" % a) for a in BOOST_LIBS]
-    
-    env.Append(LIBS = [File(f) for f in boost_statics])
-else:
-    env.Append(
-        LIBS = [l + '-mt' for l in BOOST_LIBS]
-    )
+        if variant == 'debug':
+            env.Append(CCFLAGS=[
+                '-g'
+                ])
+        elif variant == 'release':
+            env.Append(CCFLAGS=[
+                '-O3',
+                '-fno-strict-aliasing'
+                ])
 
-#-------------------------------------------------------------------------------
-#
-# VFALCO NOTE Clean area.
-#
-#-------------------------------------------------------------------------------
-#
-# Nothing having to do with directories, source files,
-# or include paths should reside outside the boundaries.
-#
+        if toolchain == 'clang':
+            if Beast.system.osx:
+                env.Replace(CC='clang', CXX='clang++', LINK='clang++')
+            elif 'CLANG_CC' in env and 'CLANG_CXX' in env and 'CLANG_LINK' in env:
+                env.Replace(CC=env['CLANG_CC'], CXX=env['CLANG_CXX'], LINK=env['CLANG_LINK'])
+            # C and C++
+            # Add '-Wshorten-64-to-32'
+            env.Append(CCFLAGS=[])
+            # C++ only
+            env.Append(CXXFLAGS=['-Wno-mismatched-tags'])
 
-# List of includes passed to the C++ compiler.
-# These are all relative to the repo dir.
-#
-INCLUDE_PATHS = [
-    '.',
-    'src/BeastConfig',
-    'src/leveldb',
-    'src/leveldb/port',
-    'src/leveldb/include',
-    'build/proto'
-    ]
+        elif toolchain == 'gcc':
+            if 'GNU_CC' in env and 'GNU_CXX' in env and 'GNU_LINK' in env:
+                env.Replace(CC=env['GNU_CC'], CXX=env['GNU_CXX'], LINK=env['GNU_LINK'])
+            # Why is this only for gcc?!
+            env.Append(CCFLAGS=['-Wno-unused-local-typedefs'])
 
-# if BOOST_HOME:
-#     INCLUDE_PATHS.append(BOOST_HOME)
+    elif toolchain == 'msvc':
+        env.Append (CPPPATH=[
+            os.path.join('src', 'protobuf', 'src'),
+            os.path.join('src', 'protobuf', 'vsprojects'),
+            ])
+        env.Append(CCFLAGS=[
+            '/bigobj',              # Increase object file max size
+            '/EHa',                 # ExceptionHandling all
+            '/fp:precise',          # Floating point behavior
+            '/Gd',                  # __cdecl calling convention
+            '/Gm-',                 # Minimal rebuild: disabled
+            '/GR',                  # Enable RTTI
+            '/Gy-',                 # Function level linking: disabled
+            '/FS',
+            '/MP',                  # Multiprocessor compilation
+            '/openmp-',             # pragma omp: disabled
+            '/Zc:forScope',         # Language extension: for scope
+            '/Zi',                  # Generate complete debug info
+            '/errorReport:none',    # No error reporting to Internet
+            '/nologo',              # Suppress login banner
+            #'/Fd${TARGET}.pdb',     # Path: Program Database (.pdb)
+            '/W3',                  # Warning level 3
+            '/WX-',                 # Disable warnings as errors
+            '/wd"4018"',
+            '/wd"4244"',
+            '/wd"4267"',
+            '/wd"4800"',            # Disable C4800 (int to bool performance)
+            ])
+        env.Append(CPPDEFINES={
+            '_WIN32_WINNT' : '0x6000',
+            })
+        env.Append(CPPDEFINES=[
+            '_SCL_SECURE_NO_WARNINGS',
+            '_CRT_SECURE_NO_WARNINGS',
+            'WIN32_CONSOLE',
+            ])
+        env.Append(LIBS=[
+            'ssleay32MT.lib',
+            'libeay32MT.lib',
+            'Shlwapi.lib',
+            'kernel32.lib',
+            'user32.lib',
+            'gdi32.lib',
+            'winspool.lib',
+            'comdlg32.lib',
+            'advapi32.lib',
+            'shell32.lib',
+            'ole32.lib',
+            'oleaut32.lib',
+            'uuid.lib',
+            'odbc32.lib',
+            'odbccp32.lib',
+            ])
+        env.Append(LINKFLAGS=[
+            '/DEBUG',
+            '/DYNAMICBASE',
+            '/ERRORREPORT:NONE',
+            #'/INCREMENTAL',
+            '/MACHINE:X64',
+            '/MANIFEST',
+            #'''/MANIFESTUAC:"level='asInvoker' uiAccess='false'"''',
+            '/nologo',
+            '/NXCOMPAT',
+            '/SUBSYSTEM:CONSOLE',
+            '/TLBID:1',
+            ])
 
-#-------------------------------------------------------------------------------
-#
-# Compiled sources
-#
+        if variant == 'debug':
+            env.Append(CCFLAGS=[
+                '/GS',              # Buffers security check: enable
+                '/MTd',             # Language: Multi-threaded Debug CRT
+                '/Od',              # Optimization: Disabled
+                '/RTC1',            # Run-time error checks:
+                ])
+            env.Append(CPPDEFINES=[
+                '_CRTDBG_MAP_ALLOC'
+                ])
+        else:
+            env.Append(CCFLAGS=[
+                '/MT',              # Language: Multi-threaded CRT
+                '/Ox',              # Optimization: Full
+                ])
 
-COMPILED_FILES = []
-
-# -------------------
-# Beast unity sources
-#
-if OSX:
-    # OSX: Use the Objective C++ version of beast_core
-    COMPILED_FILES.extend (['src/ripple/beast/ripple_beastobjc.mm'])
-else:
-    COMPILED_FILES.extend (['src/ripple/beast/ripple_beast.cpp'])
-COMPILED_FILES.extend (['src/ripple/beast/ripple_beastc.c'])
-
-# ------------------------------
-# New-style Ripple unity sources
-#
-COMPILED_FILES.extend([
-    'src/ripple/http/ripple_http.cpp',
-    'src/ripple/json/ripple_json.cpp',
-    'src/ripple/peerfinder/ripple_peerfinder.cpp',
-    'src/ripple/radmap/ripple_radmap.cpp',
-    'src/ripple/resource/ripple_resource.cpp',
-    'src/ripple/rocksdb/ripple_rocksdb.cpp',
-    'src/ripple/sitefiles/ripple_sitefiles.cpp',
-    'src/ripple/sslutil/ripple_sslutil.cpp',
-    'src/ripple/testoverlay/ripple_testoverlay.cpp',
-    'src/ripple/types/ripple_types.cpp',
-    'src/ripple/validators/ripple_validators.cpp',
-	'src/ripple/common/ripple_common.cpp',
-    ])
-
-# ------------------------------
-# Old-style Ripple unity sources
-#
-COMPILED_FILES.extend([
-    'src/ripple_app/ripple_app.cpp',
-    'src/ripple_app/ripple_app_pt1.cpp',
-    'src/ripple_app/ripple_app_pt2.cpp',
-    'src/ripple_app/ripple_app_pt3.cpp',
-    'src/ripple_app/ripple_app_pt4.cpp',
-    'src/ripple_app/ripple_app_pt5.cpp',
-    'src/ripple_app/ripple_app_pt6.cpp',
-    'src/ripple_app/ripple_app_pt7.cpp',
-    'src/ripple_app/ripple_app_pt8.cpp',
-    'src/ripple_app/ripple_app_pt9.cpp',
-    'src/ripple_basics/ripple_basics.cpp',
-    'src/ripple_core/ripple_core.cpp',
-    'src/ripple_data/ripple_data.cpp',
-    'src/ripple_hyperleveldb/ripple_hyperleveldb.cpp',
-    'src/ripple_leveldb/ripple_leveldb.cpp',
-    'src/ripple_net/ripple_net.cpp',
-    'src/ripple_overlay/ripple_overlay.cpp',
-    'src/ripple_rpc/ripple_rpc.cpp',
-    'src/ripple_websocket/ripple_websocket.cpp'
-    ])
-
-#
-#
-#-------------------------------------------------------------------------------
-
-# Map top level source directories to their location in the outputs
-#
-
-VariantDir('build/obj/src', 'src', duplicate=0)
-
-#-------------------------------------------------------------------------------
-
-# Add the list of includes to compiler include paths.
-#
-for path in INCLUDE_PATHS:
-    env.Append (CPPPATH = [ path ])
-
-if BOOST_HOME:
-    env.Prepend (CPPPATH = [ BOOST_HOME ])
-
-#-------------------------------------------------------------------------------
-
-# Apparently, only linux uses -ldl
-if Linux: # not FreeBSD:
-    env.Append(
-        LIBS = [
-            'dl', # dynamic linking for linux
-        ]
-    )
-
-env.Append(
-    LIBS = \
-        # rt is for clock_nanosleep in beast
-        ['rt'] if not OSX else [] +\
-        [
-            'z'
-        ]
-)
-
-# We prepend, in case there's another BOOST somewhere on the path
-# such, as installed into `/usr/lib/`
-if BOOST_HOME is not None:
-    env.Prepend(
-        LIBPATH = ["%s/stage/lib" % BOOST_HOME])
-
-if not OSX:
-    env.Append(LINKFLAGS = [
-        '-rdynamic',
-        '-pthread',
-        ])
-
-DEBUGFLAGS  = ['-g', '-DDEBUG', '-D_DEBUG']
-
-env.Append(CCFLAGS = ['-pthread', '-Wall', '-Wno-sign-compare', '-Wno-char-subscripts']+DEBUGFLAGS)
-if not USING_CLANG:
-     more_warnings = ['-Wno-unused-local-typedefs']
-else:
-     # This disables the "You said it was a struct AND a class, wth is going on
-     # warnings"
-     more_warnings = ['-Wno-mismatched-tags']
-     # This needs to be a CCFLAGS not a CXXFLAGS
-     env.Append(CCFLAGS = more_warnings)
-
-env.Append(CXXFLAGS = ['-O1','-pthread', '-Wno-invalid-offsetof', '-Wformat']+more_warnings+DEBUGFLAGS)
-
-# RTTI is required for Beast and CountedObject.
-#
-env.Append(CXXFLAGS = ['-frtti'])
-
-UBUNTU_GCC_48_INSTALL_STEPS = '''
-https://ripple.com/wiki/Ubuntu_build_instructions#Ubuntu_versions_older_than_13.10_:_Install_gcc_4.8'''
-
-if not USING_CLANG:
-    if (int(GCC_VERSION[0]) == 4 and int(GCC_VERSION[1]) < 8):
-        print "\nrippled, using c++11, requires g++ version >= 4.8 to compile"
-
-        if Ubuntu:
-          print UBUNTU_GCC_48_INSTALL_STEPS
-
-        sys.exit(1)
     else:
-        env.Append(CXXFLAGS = ['-std=c++11'])
+        raise SCons.UserError('Unknown toolchain == "%s"' % toolchain)
 
-# FreeBSD doesn't support O_DSYNC
-if FreeBSD:
-    env.Append(CPPFLAGS = ['-DMDB_DSYNC=O_SYNC'])
+#-------------------------------------------------------------------------------
 
-if OSX:
-    env.Append(LINKFLAGS = ['-L/usr/local/opt/openssl/lib'])
-    env.Append(CXXFLAGS = ['-I/usr/local/opt/openssl/include'])
+def addSource(path, env, variant_dirs, CPPPATH=[]):
+    if CPPPATH:
+        env = env.Clone()
+        env.Prepend(CPPPATH=CPPPATH)
+    return env.Object(Beast.variantFile(path, variant_dirs))
 
-PROTO_SRCS = env.Protoc([], 'src/ripple_data/protocol/ripple.proto', PROTOCOUTDIR='build/proto', PROTOCPYTHONOUTDIR=None)
-env.Clean(PROTO_SRCS, 'site_scons/site_tools/protoc.pyc')
+#-------------------------------------------------------------------------------
 
-# Only tag actual Ripple files.
-TAG_SRCS    = copy.copy(COMPILED_FILES)
+# Configure the base construction environment
+root_dir = Dir('#').srcnode().get_abspath() # Path to this SConstruct file
+build_dir = os.path.join('build')
+base = Environment(
+    toolpath=[os.path.join ('src', 'beast', 'site_scons', 'site_tools')],
+    tools=['default', 'Protoc', 'VSProject'],
+    ENV=os.environ,
+    TARGET_ARCH='x86_64')
+import_environ(base)
+config_base(base)
+base.Append(CPPPATH=[
+    'src',
+    os.path.join('src', 'beast'),
+    os.path.join(build_dir, 'proto'),
+    ])
 
-# Derive the object files from the source files.
-OBJECT_FILES = []
+# Configure the toolchains, variants, default toolchain, and default target
+variants = ['debug', 'release']
+all_toolchains = ['clang', 'gcc', 'msvc']
+if Beast.system.osx:
+    toolchains = ['clang']
+    default_toolchain = 'clang'
+else:
+    toolchains = detect_toolchains(base)
+    if not toolchains:
+        raise ValueError('No toolchains detected!')
+    if 'msvc' in toolchains:
+        default_toolchain = 'msvc'
+    elif 'gcc' in toolchains:
+        if 'clang' in toolchains:
+            cxx = os.environ.get('CXX', 'g++')
+            default_toolchain = 'clang' if 'clang' in cxx else 'gcc'
+        else:
+            default_toolchain = 'gcc'
+    elif 'clang' in toolchains:
+        default_toolchain = 'clang'
+    else:
+        raise ValueError("Don't understand toolchains in " + str(toolchains))
+default_variant = 'debug'
+default_target = None
 
-OBJECT_FILES.append(PROTO_SRCS[0])
+for source in [
+    'src/ripple/proto/ripple.proto',
+    ]:
+    base.Protoc([],
+        source,
+        PROTOCPROTOPATH=[os.path.dirname(source)],
+        PROTOCOUTDIR=os.path.join(build_dir, 'proto'),
+        PROTOCPYTHONOUTDIR=None)
 
-for file in COMPILED_FILES:
-    OBJECT_FILES.append('build/obj/' + file)
+# Declare the targets
+aliases = collections.defaultdict(list)
+msvc_configs = []
+for toolchain in all_toolchains:
+    for variant in variants:
+        # Configure this variant's construction environment
+        env = base.Clone()
+        config_env(toolchain, variant, env)
+        variant_name = '%s.%s' % (toolchain, variant)
+        variant_dir = os.path.join(build_dir, variant_name)
+        variant_dirs = {
+            os.path.join(variant_dir, 'src') :
+                'src',
+            os.path.join(variant_dir, 'proto') :
+                os.path.join (build_dir, 'proto'),
+            }
+        for dest, source in variant_dirs.iteritems():
+            env.VariantDir(dest, source, duplicate=0)
+        objects = []
+        objects.append(addSource('src/ripple/unity/app.cpp', env, variant_dirs))
+        objects.append(addSource('src/ripple/unity/app1.cpp', env, variant_dirs))
+        objects.append(addSource('src/ripple/unity/app2.cpp', env, variant_dirs))
+        objects.append(addSource('src/ripple/unity/app3.cpp', env, variant_dirs))
+        objects.append(addSource('src/ripple/unity/app4.cpp', env, variant_dirs))
+        objects.append(addSource('src/ripple/unity/app5.cpp', env, variant_dirs))
+        objects.append(addSource('src/ripple/unity/app6.cpp', env, variant_dirs))
+        objects.append(addSource('src/ripple/unity/app7.cpp', env, variant_dirs))
+        objects.append(addSource('src/ripple/unity/app8.cpp', env, variant_dirs))
+        objects.append(addSource('src/ripple/unity/app9.cpp', env, variant_dirs))
+        objects.append(addSource('src/ripple/unity/basics.cpp', env, variant_dirs))
+        objects.append(addSource('src/ripple/unity/beast.cpp', env, variant_dirs))
+        objects.append(addSource('src/ripple/unity/beastc.c', env, variant_dirs))
+        objects.append(addSource('src/ripple/unity/common.cpp', env, variant_dirs))
+        objects.append(addSource('src/ripple/unity/core.cpp', env, variant_dirs))
+        objects.append(addSource('src/ripple/unity/data.cpp', env, variant_dirs))
+        objects.append(addSource('src/ripple/unity/http.cpp', env, variant_dirs))
+        objects.append(addSource('src/ripple/unity/json.cpp', env, variant_dirs))
+        objects.append(addSource('src/ripple/unity/net.cpp', env, variant_dirs))
+        objects.append(addSource('src/ripple/unity/overlay.cpp', env, variant_dirs))
+        objects.append(addSource('src/ripple/unity/peerfinder.cpp', env, variant_dirs))
+        objects.append(addSource('src/ripple/unity/protobuf.cpp', env, variant_dirs))
+        objects.append(addSource('src/ripple/unity/ripple.proto.cpp', env, variant_dirs))
+        objects.append(addSource('src/ripple/unity/radmap.cpp', env, variant_dirs))
+        objects.append(addSource('src/ripple/unity/resource.cpp', env, variant_dirs))
+        objects.append(addSource('src/ripple/unity/rpcx.cpp', env, variant_dirs))
+        objects.append(addSource('src/ripple/unity/sitefiles.cpp', env, variant_dirs))
+        objects.append(addSource('src/ripple/unity/sslutil.cpp', env, variant_dirs))
+        objects.append(addSource('src/ripple/unity/testoverlay.cpp', env, variant_dirs))
+        objects.append(addSource('src/ripple/unity/types.cpp', env, variant_dirs))
+        objects.append(addSource('src/ripple/unity/validators.cpp', env, variant_dirs))
+        objects.append(addSource('src/ripple/unity/websocket.cpp', env, variant_dirs))
 
-#
-# Targets
-#
+        objects.append(addSource('src/ripple/unity/nodestore.cpp', env, variant_dirs, [
+            'src/leveldb/include',
+            #'src/hyperleveldb/include', # hyper 
+            'src/rocksdb/include',
+            ]))
 
-rippled = env.Program('build/rippled', OBJECT_FILES)
+        objects.append(addSource('src/ripple/unity/leveldb.cpp', env, variant_dirs, [
+            'src/leveldb/',
+            'src/leveldb/include',
+            'src/snappy/snappy',
+            'src/snappy/config',
+            ]))
 
-tags    = env.CTags('tags', TAG_SRCS)
+        objects.append(addSource('src/ripple/unity/hyperleveldb.cpp', env, variant_dirs, [
+            'src/hyperleveldb',
+            'src/snappy/snappy',
+            'src/snappy/config',
+            ]))
 
-Default(rippled, tags)
+        objects.append(addSource('src/ripple/unity/rocksdb.cpp', env, variant_dirs, [
+            'src/rocksdb',
+            'src/rocksdb/include',
+            'src/snappy/snappy',
+            'src/snappy/config',
+            ]))
+
+        objects.append(addSource('src/ripple/unity/snappy.cpp', env, variant_dirs, [
+            'src/snappy/snappy',
+            'src/snappy/config',
+            ]))
+
+        if toolchain == "clang" and Beast.system.osx:
+            objects.append(addSource('src/ripple/unity/beastobjc.mm', env, variant_dirs))
+
+        target = env.Program(
+            target = os.path.join(variant_dir, 'rippled'),
+            source = objects
+            )
+
+        if toolchain == default_toolchain and variant == default_variant:
+            default_target = target
+            install_target = env.Install (build_dir, source = default_target)
+            env.Alias ('install', install_target)
+            env.Default (install_target)
+            aliases['all'].extend(install_target)
+        if toolchain == 'msvc':
+            config = env.VSProjectConfig(variant, 'x64', target, env)
+            msvc_configs.append(config)
+        if toolchain in toolchains:
+            aliases['all'].extend(target)
+            aliases[variant].extend(target)
+            aliases[toolchain].extend(target)
+            env.Alias(variant_name, target)
+
+for key, value in aliases.iteritems():
+    env.Alias(key, value)
+
+vcxproj = base.VSProject(
+    os.path.join('Builds', 'VisualStudio2013', 'RippleD'),
+    source = [],
+    VSPROJECT_ROOT_DIRS = ['src/beast', 'src', '.'],
+    VSPROJECT_CONFIGS = msvc_configs)
+base.Alias('vcxproj', vcxproj)

bin/network-build

@@ -1,6 +0,0 @@
-#!/bin/sh -x
-
-cd ~/NewCoin
-git pull
-scons -j 2
-cp -p newcoind bin/

bin/network-init

@@ -1,10 +0,0 @@
-#!/bin/sh
-
-# XXX Should not need to make db directory. newcoind should do this.
-for SITE in $HOSTS
-do
-	echo "Clearing db for:" $SITE
-	DB_DIR="/var/www/$SITE/db/"
-	mkdir -p "/var/www/$SITE/db/"
-	rm -rf "/var/www/$SITE/db/*"
-done

bin/network-restart

@@ -1,5 +0,0 @@
-#!/bin/sh -x
-
-network-stop
-sleep 1
-network-start

bin/network-start

@@ -1,6 +0,0 @@
-#!/bin/sh
-
-for SITE in $HOSTS
-do
-	(nx $SITE &)
-done

bin/network-stop

@@ -1,6 +0,0 @@
-#!/bin/sh
-
-for SITE in $HOSTS
-do
-	(nx $SITE stop &)
-done

bin/network-update

@@ -1,5 +0,0 @@
-#!/bin/sh -x
-echo "Building and restarting."
-
-network-build
-network-restart

bin/nx

@@ -1,7 +0,0 @@
-#!/bin/sh
-
-SITE=$1
-shift
-COMMAND=$@
-cd "/var/www/$SITE"
-newcoind $COMMAND 

doc/rippled-example.service

@@ -0,0 +1,10 @@
+[Unit]
+Description=Ripple Peer-to-Peer Network Daemon
+ 
+[Service]
+Type=simple
+User=nobody
+ExecStart=/usr/bin/rippled --conf=/etc/rippled/rippled.cfg
+ 
+[Install]
+WantedBy=multi-user.target

doc/todo/VFALCO_TODO.txt

@@ -1,204 +0,0 @@
---------------------------------------------------------------------------------
-RIPPLE TODO
---------------------------------------------------------------------------------
-
-Vinnie's List: Changes day to day, descending priority
-- PeerFinder work
-- Validators work
-- HTTPClient improvements based on HTTPServer
-- HTTPMessage improvements
-- Ditch old HTTPClient so I can take the name
-- Finish RPCAsyncServer, RPCService and RPCService::Manager
-- Fix RPCDoor to respect config setting for [rpc_secure]
-- Clean up calculation of COnfig file location.
-- Remove TESTNET and all related code and settings.
-- Remove addRpcSub, findRpcSub, and notify the appropriate partner(s)
-
-David Features:
-- override config items from command line
-- change config via RPC, this is for debugging
-
---------------------------------------------------------------------------------
-
-- std::priority_queue for DeadlineTimer
-
-- Validators should delay the application of newly downloaded lists from
-  sources, to mitigate the effects of attacks. Unless there's no validators
-  in the list.
-
-- Validators RPC options to immediately apply UNL,
-  manually revisit sources, etc...
-
-- Look into using CMake
-
-- IPv6 support in IP::Endpoint
-
-- Configuration list for Jenkins
-
-- Fix all crash and leaks on exit
-    Say there's a leak, a ledger that can never be accessed is locked in some
-        structure. If the organized teardown code frees that structure, the leak
-        will not be reported.
-    Yes, so you'll detect some small subset of leaks that way.
-    You'll still have to be vigilant for the leaks that won't detect.
-    The problem is ordering. There are lots of circular dependencies.
-    The biggest problem is the order of destruction of global objects. (I think)
-    Getting rid of global objects is a good solution to that.
-    Vinnie Falco: Those I can resolve with my ReferenceCountedSingleton. And
-                  yeah thats a good approach, one that I am doing slowly anyway
-    Yeah, that's good for other reasons too, not just the unpredictability of
-        creation order that can hide bugs.
-    There may also just be some missing destructors.
-    Some of it may be things being shut down in the wrong order. Like if you shut
-        down the cache and then something that uses the cache, objects may get
-        put in the cache after it was shut down.
-
-- Do something about the throw() reporting weaknesses:
-  * Make sure all Sconstruct and .pro builds have debug symbols in release
-  * Replace all throw with beast::Throw()
-    (Only in ripple sources, not in Subtrees/, protobuf, or websocket)
-  - Improved Beast exception object, provides __FILE__ and __LINE__
-  - Add file and line capabilities to beast::Throw()
-  - Allow beast::Throw to be hooked for logging
-  - Add stack trace capability to beast::Throw() diagnostics via the hook
-    (use the existing beast::SystemStats::getStackBacktrace())
-  - Implement getStackBacktrace for BEAST_BSD targets
-  - Add UnhandledExceptionCatcher to beast
-  - Return EXIT_FAILURE on unhandled exception
-
-- Consolidate JSON code maybe use Beast
-
-- Deeply create directories specified in config settings
-
-- Refactor Section code into ConfigFile
-
-- Supress useless gcc warnings
-  http://stackoverflow.com/questions/3378560/how-to-disable-gcc-warnings-for-a-few-lines-of-code
-
-- Get rid of boost::filesystem
-
-- What the heck is up with site_scons/site_tools/protoc.py?
-
-- Add convenience variadic functions to JobQueue that do the bind for you
-
-- Consolidate databases
-
-- Figure out why we need WAL sqlite mode if we no longer use sqlite for the node store
-
-- Add "skipped" field to beginTestCase() to disable a test but still record
-  that it was skipped in the output. Like for mdb import.
-
-- Get rid of 'ref' typedefs that really mean const&
-
-- Use secp256k1 from beast
-
-- Fix xsd/dtd line in JUnit XML output
-
-- Get rid of the WriteLog() stuff in the ripple tests and make it report the
-  message directly to the UnitTest object. Then update the JUnit XML output
-  routines to also write the auxiliary messages.
-
-* Restyle all the macros in ConfigSection.h
-
-- Move src/protobuf to Subtrees and deal with protobuf_core.cpp
-
-- Replace home-made database wrappers with beast::sqdb
-
-- Use static creation member functions instead of endless constructor
-  variations in base_uint, uint256, and family.
-
-- Raise the warning level and fix everything
-
-- Replace base_uint and uintXXX with UnsignedInteger
-  * Need to specialize UnsignedInteger to work efficiently with 4 and 8 byte
-    multiples of the size.
-
-- Rewrite boost program_options in Beast
-
-- Replace endian conversion calls with beast calls:
-  htobe32, be32toh, ntohl, etc...
-  Start by removing the system headers which provide these routines, if possible
-
-- Rename RPCHandler to CallHandler
-
-- Rename "fullBelow" to something like haveAllDescendants or haveAllChildren.
-
-- Rewrite Sustain to use Beast and work on Windows as well
-  * Do not enable watchdog process if a debugger is attached
-
-- Make sure the leak detector output appears on Linux and FreeBSD debug builds.
-
-- Rename LoadMonitor to LoadMeter, change LoadEvent to LoadMeter::ScopedSample
-
-- Rename LedgerMaster to Ledgers, create ILedgers interface.
-
-- Replace all NULL with nullptr
-
-- Make TxFormats a member of ICore instead of a singleton.
-  PROBLEM: STObject derived classes like STInt16 make direct use of the
-           singleton. It might have to remain a singleton. At the very least,
-           it should be a SharedSingleton to resolve ordering issues.
-
-- Replace C11X with BEAST_COMPILER_SUPPORTS_MOVE_SEMANTICS
-
-- Remove "ENABLE_INSECURE" when the time is right.
-
-- lift unique_ptr / auto_ptr into ripple namespace,
-  or replace with ScopedPointer (preferred)
-
-- Go searching through VFALCO notes and fix everything
-
-- Deal with function-level statics used for SqliteDatabase (like in
-  HSBESQLite::visitAll)
-
-- Document in order:
-    SerializedType
-    STObject
-    SerializedLedgerEntry
-
-- Consolidate SQLite database classes: DatabaseCon, Database, SqliteDatabase.
-
---------------------------------------------------------------------------------
-WEBSOCKET TODO
---------------------------------------------------------------------------------
-
-- Rewrite for sanity
-
---------------------------------------------------------------------------------
-PROTOCOL BUFFERS TODO
---------------------------------------------------------------------------------
-
-- Create/maintain the protobuf Git repo (original uses SVN)
-
-- Update the subtree
-
-- Make a Visual Studio 2012 Project for source browsing
-
---------------------------------------------------------------------------------
-Davidisms
---------------------------------------------------------------------------------
-
-(Figure out a good place to record information like this permanently)
-
-Regarding a defect where a failing transaction was being submitted over and over
-  again on the network (July 3, 2013)
-
-  The core problem was an interaction between two bits of logic.
-  1) Normally, we won't relay a transaction again if we already recently relayed
-     it. But this is bypassed if the transaction failed in a way that could
-     allow it to succeed later. This way, if one server discovers a transaction
-     can now work, it can get all servers to retry it.
-  2) Normally, we won't relay a transaction if we think it can't claim a fee.
-     But if we're not sure it can't claim a fee because we're in an unhealthy
-     state, we propagate the transaction to let other servers decide if they
-     think it can claim a fee.
-  With these two bits of logic, two unhealthy servers could infinitely propagate
-     a transaction back and forth between each other.
-
-A node is "full below" if we believe we have (either in the database or
-  scheduled to be stored in the database) the contents of every node below that
-  node in a hash tree. When trying to acquire a hash tree/map, if a node is
-  full below, we know not to bother with anything below that node.
-
-The fullBelowCache is a cache of hashes of nodes that are full below. Which means
-  there are no missing children

doc/validators-example.txt

@@ -20,6 +20,8 @@
 #
 
 [validators]
-n9KPnVLn7ewVzHvn218DcEYsnWLzKerTDwhpofhk4Ym1RUq4TeGw	first
-n9LFzWuhKNvXStHAuemfRKFVECLApowncMAM5chSCL9R5ECHGN4V	second
-n94rSdgTyBNGvYg8pZXGuNt59Y5bGAZGxbxyvjDaqD9ceRAgD85P	third
+n949f75evCHwgyP4fPVgaHqNHxUVN15PsJEZ3B3HnXPcPjcZAoy7 RL1
+n9MD5h24qrQqiyBC8aeqqCWvpiBiYQ3jxSr91uiDvmrkyHRdYLUj RL2
+n9L81uNCaPgtUJfaHh89gmdvXKAmSt5Gdsw2g1iPWaPkAHW5Nm4C RL3
+n9KiYM9CgngLvtRCQHZwgC2gjpdaZcCcbt3VboxiNFcKuwFVujzS RL4
+n9LdgEtkmGB9E2h3K4Vp7iGUaKuq23Zr32ehxiU8FWY7xoxbWTSA RL5

package.json

@@ -10,7 +10,7 @@
   },
 
   "dependencies": {
-    "ripple-lib": "0.7.25",
+    "ripple-lib": "0.7.37",
     "async": "~0.2.9",
     "extend": "~1.2.0",
     "simple-jsonrpc": "~0.0.2",
@@ -31,4 +31,4 @@
   },
 
   "readmeFilename": "README.md"
-}
+}

site_scons/site_tools/protoc.py

@@ -1,88 +0,0 @@
-#!python
-""" 
-protoc.py: Protoc Builder for SCons
-
-This Builder invokes protoc to generate C++ and Python 
-from a .proto file.  
-
-NOTE: Java is not currently supported.
-
-From: http://www.scons.org/wiki/ProtocBuilder
-"""
-
-__author__ = "Scott Stafford"
-
-import SCons.Action
-import SCons.Builder
-import SCons.Defaults
-import SCons.Node.FS
-import SCons.Util
-
-from SCons.Script import File, Dir
-
-import os.path
-
-protocs = 'protoc'
-
-ProtocAction = SCons.Action.Action('$PROTOCCOM', '$PROTOCCOMSTR')
-def ProtocEmitter(target, source, env):
-    dirOfCallingSConscript = Dir('.').srcnode()
-    env.Prepend(PROTOCPROTOPATH = dirOfCallingSConscript.path)
-    
-    source_with_corrected_path = []
-    for src in source:
-        commonprefix = os.path.commonprefix([dirOfCallingSConscript.path, src.srcnode().path])
-        if len(commonprefix)>0:
-            source_with_corrected_path.append( src.srcnode().path[len(commonprefix + os.sep):] )
-        else:
-            source_with_corrected_path.append( src.srcnode().path )
-        
-    source = source_with_corrected_path
-    
-    for src in source:
-        modulename = os.path.splitext(os.path.basename(src))[0]
-
-        if env['PROTOCOUTDIR']:            
-            base = os.path.join(env['PROTOCOUTDIR'] , modulename)
-            target.extend( [ base + '.pb.cc', base + '.pb.h' ] )
-        
-        if env['PROTOCPYTHONOUTDIR']:
-            base = os.path.join(env['PROTOCPYTHONOUTDIR'] , modulename)
-            target.append( base + '_pb2.py' )
-
-    try:
-        target.append(env['PROTOCFDSOUT'])
-    except KeyError:
-        pass
-
-    # XXX KLUDGE: Force things to be right.
-    env['PROTOCOUTDIR']	    = 'build/proto'
-    env['PROTOCPROTOPATH']  = ['src/ripple_data/protocol']
-
-    #~ print "PROTOC SOURCE:", [str(s) for s in source]
-    #~ print "PROTOC TARGET:", [str(s) for s in target]
-
-    return target, source
-
-ProtocBuilder = SCons.Builder.Builder(action = ProtocAction,
-                                   emitter = ProtocEmitter,
-                                   srcsuffix = '$PROTOCSRCSUFFIX')
-
-def generate(env):
-    """Add Builders and construction variables for protoc to an Environment."""
-    try:
-        bld = env['BUILDERS']['Protoc']
-    except KeyError:
-        bld = ProtocBuilder
-        env['BUILDERS']['Protoc'] = bld
-        
-    env['PROTOC']        = env.Detect(protocs) or 'protoc'
-    env['PROTOCFLAGS']   = SCons.Util.CLVar('')
-    env['PROTOCPROTOPATH'] = SCons.Util.CLVar('')
-    env['PROTOCCOM']     = '$PROTOC ${["-I%s"%x for x in PROTOCPROTOPATH]} $PROTOCFLAGS --cpp_out=$PROTOCCPPOUTFLAGS$PROTOCOUTDIR ${PROTOCPYTHONOUTDIR and ("--python_out="+PROTOCPYTHONOUTDIR) or ""} ${PROTOCFDSOUT and ("-o"+PROTOCFDSOUT) or ""} ${SOURCES}'
-    env['PROTOCOUTDIR'] = '${SOURCE.dir}'
-    env['PROTOCPYTHONOUTDIR'] = "python"
-    env['PROTOCSRCSUFFIX']  = '.proto'
-
-def exists(env):
-    return env.Detect(protocs)

src/.gitignore

@@ -1,2 +0,0 @@
-# boost subtree
-/boost

src/BeastConfig.h

@@ -27,6 +27,21 @@
     @file BeastConfig.h
 */
 
+//------------------------------------------------------------------------------
+//
+// Unit Tests
+//
+//------------------------------------------------------------------------------
+
+/** Config: BEAST_NO_UNIT_TEST_INLINE
+    Prevents unit test definitions from being inserted into a global table.
+    The default is to include inline unit test definitions.
+*/
+
+#ifndef BEAST_NO_UNIT_TEST_INLINE
+//#define BEAST_NO_UNIT_TEST_INLINE 1
+#endif
+
 //------------------------------------------------------------------------------
 //
 // Diagnostics
@@ -151,16 +166,6 @@
 #define RIPPLE_DUMP_LEAKS_ON_EXIT 1
 #endif
 
-/** Config: RIPPLE_TRACK_MUTEXES
-    Turns on a feature that enables tracking and diagnostics for mutex
-    and recursive mutex objects. This affects the type of lock used
-    by RippleMutex and RippleRecursiveMutex
-    @note This can slow down performance considerably.
-*/
-#ifndef RIPPLE_TRACK_MUTEXES
-#define RIPPLE_TRACK_MUTEXES 0
-#endif
-
 //------------------------------------------------------------------------------
 
 // These control whether or not certain functionality gets
@@ -184,4 +189,48 @@
 #define RIPPLE_USE_VALIDATORS 0
 #endif
 
+/** Config: BEAST_USE_BOOST_FEATURES
+    This activates boost specific features and improvements. If this is
+    turned on, the include paths for your build environment must be set
+    correctly to find the boost headers.
+*/
+#ifndef   BEAST_USE_BOOST_FEATURES
+//#define BEAST_USE_BOOST_FEATURES 1
+#endif
+
+/** Config: RIPPLE_PROPOSE_FEATURES
+    This determines whether to add any features to the proposed transaction set.
+*/
+#ifndef RIPPLE_PROPOSE_AMENDMENTS
+#define RIPPLE_PROPOSE_AMENDMENTS 0
+#endif
+
+/** Config: RIPPLE_ENABLE_AUTOBRIDGING
+    This determines whether ripple implements offer autobridging via XRP.
+*/
+#ifndef RIPPLE_ENABLE_AUTOBRIDGING
+#define RIPPLE_ENABLE_AUTOBRIDGING 0
+#endif
+
+/** Config: RIPPLE_SINGLE_IO_SERVICE_THREAD
+    When set, restricts the number of threads calling io_service::run to one.
+    This is useful when debugging.
+*/
+#ifndef RIPPLE_SINGLE_IO_SERVICE_THREAD
+#define RIPPLE_SINGLE_IO_SERVICE_THREAD 0
+#endif
+
+/** Config: RIPPLE_STRUCTURED_OVERLAY
+    Enables Structured Overlay support (unfinished)
+*/
+#ifndef RIPPLE_STRUCTURED_OVERLAY
+#define RIPPLE_STRUCTURED_OVERLAY 0
+#endif
+
+/** Config: RIPPLE_ASYNC_RPC_HANDLER
+*/
+#ifndef RIPPLE_ASYNC_RPC_HANDLER
+#define RIPPLE_ASYNC_RPC_HANDLER 1
+#endif
+
 #endif

src/beast/.gitignore

@@ -27,3 +27,4 @@ Builds/VisualStudio2012/Debug
 Builds/VisualStudio2012/Release
 project.xcworkspace
 modules/beast_cryptopp
+bin/

src/beast/.travis.yml

@@ -0,0 +1,26 @@
+language: cpp
+
+compiler:
+  - gcc
+  - clang
+before_install:
+  - sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test
+  - sudo add-apt-repository -y ppa:boost-latest/ppa
+  - sudo apt-get update -qq
+  - sudo apt-get install -qq python-software-properties
+  - sudo apt-get install -qq g++-4.8
+  - sudo apt-get install -qq libboost1.55-all-dev 
+  - sudo apt-get install -qq libssl-dev
+  - 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
+#  - sudo apt-get -y install binutils-gold
+  - g++ -v
+  - clang -v
+script:
+  # Abort build on failure
+  - set -e
+  - scons 
+notifications:
+  email:
+    false

src/beast/BeastConfig.h

@@ -27,6 +27,19 @@
     @file BeastConfig.h
 */
 
+//------------------------------------------------------------------------------
+//
+// Unit Tests
+//
+//------------------------------------------------------------------------------
+
+/** Config: BEAST_NO_UNIT_TEST_INLINE
+    Prevents unit test definitions from being inserted into a global table.
+*/
+#ifndef BEAST_NO_UNIT_TEST_INLINE
+#define BEAST_NO_UNIT_TEST_INLINE 0
+#endif
+
 //------------------------------------------------------------------------------
 //
 // Diagnostics

src/beast/Builds/VisualStudio2013/Beast.props

@@ -1,22 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ImportGroup Label="PropertySheets" />
-  <PropertyGroup Label="UserMacros">
-    <RepoDir>..\..</RepoDir>
-  </PropertyGroup>
-  <PropertyGroup />
-  <ItemDefinitionGroup>
-    <ClCompile>
-      <WarningLevel>Level4</WarningLevel>
-      <PreprocessorDefinitions>BEAST_COMPILING_STATIC_LIBARARY=1;_CRTDBG_MAP_ALLOC;_WIN32_WINNT=0x0600;_SCL_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <MultiProcessorCompilation>true</MultiProcessorCompilation>
-      <MinimalRebuild>false</MinimalRebuild>
-      <AdditionalIncludeDirectories>$(RepoDir)\config;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-    </ClCompile>
-  </ItemDefinitionGroup>
-  <ItemGroup>
-    <BuildMacro Include="RepoDir">
-      <Value>$(RepoDir)</Value>
-    </BuildMacro>
-  </ItemGroup>
-</Project>

src/beast/CodingStyle.md

@@ -1,228 +0,0 @@
-Write code in a clear, self-documenting style but use comments where necessary.
-Use Test Driven Development. It encourages designing interfaces first, before implementation.
-Don't Repeat Yourself, <20>D.R.Y.<2E>. Put redundant code in a class so it can be re-used and unit tested.
-Expose as little of a class as possible. Prefer private over protected. Prefer protected over public. The smaller the interface footprint, the easier it is to write unit tests and comprehend the operation of the class. This is the Interface Segregation Principle.
-Use language constants (enum or static const) with descriptive names instead of hard-coded <20>magic numbers.<2E>
-Make classes depend on as few external classes or routines as possible. Ideally, no dependencies.
-Don't limit flexibility of parameters by forcing the caller to use specific types where general types would work.
-
---------------------------------------------------------------------------------
-
-# Coding Standards
-
-Coding standards used here are extreme strict and consistent. The style
-evolved gradually over the years, incorporating generally acknowledged
-best-practice C++ advice, experience, and personal preference.
-
-## Don't Repeat Yourself!
-
-The [Don't Repeat Yourself][1] principle summarises the essence of what it
-means to write good code, in all languages, at all levels.
-
-## Formatting
-
-The goal of source code formatting should always be to make things as easy to
-read as possible. White space is used to guide the eye so that details are not
-overlooked. Blank lines are used to separate code into "paragraphs."
-
-* No tab characters please.
-* Tab stops are set to 4 spaces.
-* Braces are indented in the [Allman style][2].
-* Always place a space before and after all binary operators,
-  especially assignments (`operator=`).
-* The `!` operator should always be followed by a space.
-* The `~` operator should be preceded by a space, but not followed by one.
-* The `++` and `--` operators should have no spaces between the operator and
-  the operand.
-* A space never appears before a comma, and always appears after a comma.
-* Always place a space before an opening parenthesis. One exception is if
-  the parentheses are empty.
-* Don't put spaces after a parenthesis. A typical member function call might
-  look like this: `foobar (1, 2, 3);`
-* In general, leave a blank line before an `if` statement.
-* In general, leave a blank line after a closing brace `}`.
-* Do not place code or comments on the same line as any opening or
-  closing brace.
-* Do not write `if` statements all-on-one-line. The exception to this is when
-  you've got a sequence of similar `if` statements, and are aligning them all
-  vertically to highlight their similarities.
-* In an `if-else` statement, if you surround one half of the statement with
-  braces, you also need to put braces around the other half, to match.
-* When writing a pointer type, use this spacing: `SomeObject* myObject`.
-  Technically, a more correct spacing would be `SomeObject *myObject`, but
-  it makes more sense for the asterisk to be grouped with the type name,
-  since being a pointer is part of the type, not the variable name. The only
-  time that this can lead to any problems is when you're declaring multiple
-  pointers of the same type in the same statement - which leads on to the next
-  rule:
-* When declaring multiple pointers, never do so in a single statement, e.g.
-  `SomeObject* p1, *p2;` - instead, always split them out onto separate lines
-  and write the type name again, to make it quite clear what's going on, and
-  avoid the danger of missing out any vital asterisks.
-* The previous point also applies to references, so always put the `&` next to
-  the type rather than the variable, e.g. `void foo (Thing const& thing)`. And
-  don't put a space on both sides of the `*` or `&` - always put a space after
-  it, but never before it.
-* The word `const` should be placed to the right of the thing that it modifies,
-  for consistency. For example `int const` refers to an int which is const.
-  `int const*` is a pointer to an int which is const. `int *const` is a const
-  pointer to an int.
-* Always place a space in between the template angle brackets and the type
-  name. Template code is already hard enough to read!
-
-## Naming conventions
-
-* Member variables and method names are written with camel-case, and never
-  begin with a capital letter.
-* Class names are also written in camel-case, but always begin with a capital
-  letter.
-* For global variables... well, you shouldn't have any, so it doesn't matter.
-* Class data members begin with `m_`, static data members begin with `s_`.
-  Global variables begin with `g_`. This is so the scope of the corresponding
-  declaration can be easily determined.
-* Avoid underscores in your names, especially leading or trailing underscores.
-  In particular, leading underscores should be avoided, as these are often used
-  in standard library code, so to use them in your own code looks quite jarring.
-* If you really have to write a macro for some reason, then make it all caps,
-  with underscores to separate the words. And obviously make sure that its name
-  is unlikely to clash with symbols used in other libraries or 3rd party code.
-
-## Types, const-correctness
-
-* If a method can (and should!) be const, make it const!
-* If a method definitely doesn't throw an exception (be careful!), mark it as
-  `noexcept`
-* When returning a temporary object, e.g. a String, the returned object should
-  be non-const, so that if the class has a C++11 move operator, it can be used.
-* If a local variable can be const, then make it const!
-* Remember that pointers can be const as well as primitives; For example, if
-  you have a `char*` whose contents are going to be altered, you may still be
-  able to make the pointer itself const, e.g. `char* const foobar = getFoobar();`.
-* Do not declare all your local variables at the top of a function or method
-  (i.e. in the old-fashioned C-style). Declare them at the last possible moment,
-  and give them as small a scope as possible.
-* Object parameters should be passed as `const&` wherever possible. Only
-  pass a parameter as a copy-by-value object if you really need to mutate
-  a local copy inside the method, and if making a local copy inside the method
-  would be difficult.
-* Use portable `for()` loop variable scoping (i.e. do not have multiple for
-  loops in the same scope that each re-declare the same variable name, as
-  this fails on older compilers)
-* When you're testing a pointer to see if it's null, never write
-  `if (myPointer)`. Always avoid that implicit cast-to-bool by writing it more
-  fully: `if (myPointer != nullptr)`. And likewise, never ever write
-  `if (! myPointer)`, instead always write `if (myPointer == nullptr)`.
-  It is more readable that way.
-* Avoid C-style casts except when converting between primitive numeric types.
-  Some people would say "avoid C-style casts altogether", but `static_cast` is
-  a bit unreadable when you just want to cast an `int` to a `float`. But
-  whenever a pointer is involved, or a non-primitive object, always use
-  `static_cast`. And when you're reinterpreting data, always use
-  `reinterpret_cast`.
-* Until C++ gets a universal 64-bit primitive type (part of the C++11
-  standard), it's best to stick to the `int64` and `uint64` typedefs.
-
-## Object lifetime and ownership
-
-* Absolutely do NOT use `delete`, `deleteAndZero`, etc. There are very very few
-  situations where you can't use a `ScopedPointer` or some other automatic
-  lifetime management class.
-* Do not use `new` unless there's no alternative. Whenever you type `new`, always
-  treat it as a failure to find a better solution. If a local variable can be
-  allocated on the stack rather than the heap, then always do so.
-* Do not ever use `new` or `malloc` to allocate a C++ array. Always use a
-  `HeapBlock` instead.
-* And just to make it doubly clear: Never use `malloc` or `calloc`.
-* If a parent object needs to create and own some kind of child object, always
-  use composition as your first choice. If that's not possible (e.g. if the
-  child needs a pointer to the parent for its constructor), then use a
-  `ScopedPointer`.
-* If possible, pass an object as a reference rather than a pointer. If possible,
-  make it a `const` reference.
-* Obviously avoid static and global values. Sometimes there's no alternative,
-  but if there is an alternative, then use it, no matter how much effort it
-  involves.
-* If allocating a local POD structure (e.g. an operating-system structure in
-  native code), and you need to initialise it with zeros, use the `= { 0 };`
-  syntax as your first choice for doing this. If for some reason that's not
-  appropriate, use the `zerostruct()` function, or in case that isn't suitable,
-  use `zeromem()`. Don't use `memset()`.
-
-## Classes
-
-* Declare a class's public section first, and put its constructors and
-  destructor first. Any protected items come next, and then private ones.
-* Use the most restrictive access-specifier possible for each member. Prefer
-  `private` over `protected`, and `protected` over `public`. Don't expose
-  things unnecessarily.
-* Preferred positioning for any inherited classes is to put them to the right
-  of the class name, vertically aligned, e.g.:
-        class Thing  : public Foo, 
-                       private Bar
-        {
-        }
-* Put a class's member variables (which should almost always be private, of course),
-  after all the public and protected method declarations.
-* Any private methods can go towards the end of the class, after the member
-  variables.
-* If your class does not have copy-by-value semantics, derive the class from
-  `Uncopyable`.
-* If your class is likely to be leaked, then derive your class from
-  `LeakChecked<>`.
-* Constructors that take a single parameter should be default be marked
-  `explicit`. Obviously there are cases where you do want implicit conversion,
-  but always think about it carefully before writing a non-explicit constructor.
-* Do not use `NULL`, `null`, or 0 for a null-pointer. And especially never use
-  '0L', which is particulary burdensome. Use `nullptr` instead - this is the
-  C++2011 standard, so get used to it. There's a fallback definition for `nullptr`
-  in Beast, so it's always possible to use it even if your compiler isn't yet
-  C++2011 compliant.
-* All the C++ 'guru' books and articles are full of excellent and detailed advice
-  on when it's best to use inheritance vs composition. If you're not already
-  familiar with the received wisdom in these matters, then do some reading!
-
-## Miscellaneous
-
-* Constrain the scope of identifiers to the smallest area that needs it. Consider
-  using nested classes or classes inside functions, if doing so will expose less
-  interface and implementation overall.
-* `goto` statements should not be used at all, even if the alternative is
-  more verbose code. The only exception is when implementing an algorithm in
-  a function as a state machine.
-* Don't use macros! OK, obviously there are many situations where they're the
-  right tool for the job, but treat them as a last resort. Certainly don't ever
-  use a macro just to hold a constant value or to perform any kind of function
-  that could have been done as a real inline function. And it goes without saying
-  that you should give them names which aren't going to clash with other code.
-  And `#undef` them after you've used them, if possible.
-* When using the `++` or `--` operators, never use post-increment if
-  pre-increment could be used instead. Although it doesn't matter for
-  primitive types, it's good practice to pre-increment since this can be
-  much more efficient for more complex objects. In particular, if you're
-  writing a for loop, always use pre-increment,
-  e.g. `for (int = 0; i < 10; ++i)`
-* Never put an "else" statement after a "return"! This is well-explained in the
-  LLVM coding standards...and a couple of other very good pieces of advice from
-  the LLVM standards are in there as well.
-* When getting a possibly-null pointer and using it only if it's non-null, limit
-  the scope of the pointer as much as possible - e.g. Do NOT do this:
-
-        Foo* f = getFoo ();
-        if (f != nullptr)
-            f->doSomething ();
-        // other code
-        f->doSomething ();  // oops! f may be null!
-
-  ..instead, prefer to write it like this, which reduces the scope of the
-  pointer, making it impossible to write code that accidentally uses a null
-  pointer:
-
-        if (Foo* f = getFoo ())
-            f->doSomethingElse ();
-
-        // f is out-of-scope here, so impossible to use it if it's null
-
-  (This also results in smaller, cleaner code)
-
-[1]: http://en.wikipedia.org/wiki/Don%27t_repeat_yourself
-[2]: http://en.wikipedia.org/wiki/Indent_style#Allman_style

src/beast/Doxyfile

@@ -102,7 +102,7 @@ INPUT_ENCODING         = UTF-8
 FILE_PATTERNS          =
 RECURSIVE              = YES
 EXCLUDE                = modules/beast_core/beast_core.h \
-                         modules/beast_core/beast_core.cpp \
+                         modules/beast_core/beast_core.unity.cpp \
                          modules/beast_basics/beast_basics.cpp \
                          modules/beast_basics/native \
                          modules/beast_basics/zip/zlib

src/beast/SConstruct

@@ -0,0 +1,139 @@
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+import copy
+import itertools
+import ntpath
+import os
+import random
+import sys
+
+def add_beast_to_path():
+    python_home = os.path.join(os.getcwd(), 'python')
+    if python_home not in sys.path:
+        sys.path.append(python_home)
+
+add_beast_to_path()
+
+from beast.env.AddCommonFlags import add_common_flags
+from beast.env.AddUserEnv import add_user_env
+from beast.env import Print
+from beast.platform import GetEnvironment
+from beast.util import Boost
+from beast.util import File
+from beast.util import Tests
+
+VARIANT_DIRECTORIES = {
+    'beast': ('bin', 'beast'),
+    'modules': ('bin', 'modules'),
+}
+
+BOOST_LIBRARIES = '' #boost_system'
+MAIN_PROGRAM_FILE = 'beast/unit_test/tests/main.cpp'
+DOTFILE = '~/.scons'
+
+def main():
+    File.validate_libraries(Boost.LIBPATH, BOOST_LIBRARIES)
+    defaults = GetEnvironment.get_environment(ARGUMENTS)
+    working = copy.deepcopy(defaults)
+    add_common_flags(defaults)
+
+    add_user_env(working, DOTFILE)
+    add_common_flags(working)
+    Print.print_build_config(working, defaults)
+
+    env = Environment(**working)
+
+    for name, path in VARIANT_DIRECTORIES.items():
+        env.VariantDir(os.path.join(*path), name, duplicate=0)
+    env.Replace(PRINT_CMD_LINE_FUNC=Print.print_cmd_line)
+    #Tests.run_tests(env, MAIN_PROGRAM_FILE, '.', '.test.cpp')
+
+#main()
+
+#-------------------------------------------------------------------------------
+
+def is_unity(path):
+    b, e = os.path.splitext(path)
+    return os.path.splitext(b)[1] == '.unity' and e in ['.c', '.cpp']
+
+def files(base):
+    for parent, _, files in os.walk(base):
+        for path in files:
+            path = os.path.join(parent, path)
+            yield os.path.normpath(path)
+
+#-------------------------------------------------------------------------------
+
+'''
+/MP /GS /W3 /wd"4018" /wd"4244" /wd"4267" /Gy- /Zc:wchar_t
+/I"D:\lib\OpenSSL-Win64\include" /I"D:\lib\boost_1_55_0"
+/I"..\..\src\protobuf\src" /I"..\..\src\protobuf\vsprojects"
+/I"..\..\src\leveldb" /I"..\..\src\leveldb\include" /I"..\..\build\proto"
+/Zi /Gm- /Od /Fd"..\..\build\obj\VisualStudio2013\Debug.x64\vc120.pdb"
+/fp:precise /D "_CRTDBG_MAP_ALLOC" /D "WIN32" /D "_DEBUG" /D "_CONSOLE"
+/D "_VARIADIC_MAX=10" /D "_WIN32_WINNT=0x0600" /D "_SCL_SECURE_NO_WARNINGS"
+/D "_CRT_SECURE_NO_WARNINGS" /D "_MBCS" /errorReport:prompt /WX- /Zc:forScope
+/RTC1 /GR /Gd /MTd /openmp- /Fa"..\..\build\obj\VisualStudio2013\Debug.x64\"
+/EHa /nologo /Fo"..\..\build\obj\VisualStudio2013\Debug.x64\"
+/Fp"..\..\build\obj\VisualStudio2013\Debug.x64\rippled.pch" 
+'''
+
+# Path to this SConstruct file
+base_dir = Dir('#').srcnode().get_abspath()
+
+base_env = Environment(
+    tools = ['default', 'VSProject'],
+    CCCOMSTR = '',
+    CMDLINE_QUIET = 1,
+    CPPPATH = [
+        os.environ['BOOST_ROOT'],
+        os.environ['OPENSSL_ROOT']
+        ],
+    CPPDEFINES = [
+        '_WIN32_WINNT=0x6000']
+        )
+
+#base_env.Replace(PRINT_CMD_LINE_FUNC=Print.print_cmd_line)
+
+env = base_env
+
+bin_dir = os.path.join(base_dir, 'bin')
+
+srcs = filter(is_unity, list(files('beast')) + list(files('modules')))
+for variant in ['Debug']: #, 'Release']:
+    for platform in ['Win32']:
+        #env = base_env.Clone()
+        #env.Replace(PRINT_CMD_LINE_FUNC=Print.print_cmd_line)
+        variant_dir = os.path.join(bin_dir, variant + '.' + platform)
+        env.VariantDir(os.path.join(variant_dir, 'beast'), 'beast', duplicate=0)
+        env.VariantDir(os.path.join(variant_dir, 'modules'), 'modules', duplicate=0)
+        env.Append(CCFLAGS=[
+            '/EHsc',
+            '/bigobj',
+            '/Fd${TARGET}.pdb'
+            ])
+        if variant == 'Debug':
+            env.Append(CCFLAGS=[
+                '/MTd',
+                '/Od',
+                '/Zi'
+                ])
+        else:
+            env.Append(CCFLAGS=[
+                '/MT',
+                '/Ox'
+                ])
+        variant_srcs = [os.path.join(variant_dir, os.path.relpath(f, base_dir)) for f in srcs]
+
+        beast = env.StaticLibrary(
+            target = os.path.join(variant_dir, 'beast.lib'),
+            source = variant_srcs)
+
+env.VSProject (
+    'out',
+    buildtarget = beast,
+    source = filter(is_unity, list(files('beast')) + list(files('modules'))))
+
+env.Default ('out.vcxproj')
+#env.Default (os.path.join(bin_dir,'Debug.Win32', 'beast.lib'))
+

src/beast/TODO.txt

@@ -1,72 +0,0 @@
---------------------------------------------------------------------------------
-BEAST TODO
---------------------------------------------------------------------------------
-
-- Use SemanticVersion for beast version numbers to replace BEAST_VERSION
-
-- add support for a __PRETTY_FUNCTION__ equivalent for all environments
-
-- add expectThrow() to UnitTest, where it expects an exception
-
-- Import secp256k1 from sipa
-
-- Set sqlite thread safety model to '2' in beast_sqlite
-
-- Document and rename all the sqdb files and classes
-
-- Specialize UnsignedInteger<> for peformance in the storage format
-
-- Rename HeapBlock routines to not conflict with _CRTDBG_MAP_ALLOC macros
-
-- Design a WeakPtr / SharedPtr / SharedObject intrusive system
-
-- Implement beast::Bimap?
-
-- Use Bimap for storage in the DeadlineTimer::Manager, to support
-  thousands of timers.
-
-- Think about adding a shouldStop bool to InterruptibleThread, along
-  with a shouldStop () function returning bool, and a stop() method.
-
-- Make OwnedArray add routines return a pointer instead of reference
-
-- Tidy up CacheLine, MemoryAlignment
-
-- Remove anything having to do with DLL builds like
-  BEAST_DLL, BEAST_DLL_BUILD, BEAST_DISABLE_DLL_ALLOCATORS
-
-- Fix FifoFreeStoreWithTLS reference counting bug
-
-- Implement a reasonable substitute for boost's thread_local_storage
-
-- Think about doing away with BEAST_CALLTYPE and BEAST_API
-
-- Decide if headers should just include BeastConfig.h instead of making the
-  host program do it.
-
-- Rename malloc/calloc JUCE members that conflict with the debug CRT from MSVC
-
-- Reformat every Doxygen comment
-- Fix Doxygen metatags
-- update Beast Doxyfile
-
-- Rename include guards to boost style, e.g. BEAST_THROW_H_INCLUDED
-
-- Clean up CacheLine, StaticObject
-
-- Clean up ConcurrentObject
-
-- Rename SharedData to SharedState or something?
-
-- Figure out what to do with ReadWriteLock, and NamedPipe which uses it?
-
-- Put BEAST_PUBLIC_FUNCTION in front of all loose functions
-
-- restructure the repo sources to look like this:
-  /Source/beast/beast_core/beast_core.h
-  etc...
-- Put the BeastConfig.h at the root of the repo.
-- Make sure the template BeastConfig.h is included in the Doxyfile
-
-- Implement robust key/value database with bulk write
-

src/beast/beast/Arithmetic.h

@@ -24,10 +24,12 @@
 #ifndef BEAST_ARITHMETIC_H_INCLUDED
 #define BEAST_ARITHMETIC_H_INCLUDED
 
-#include "Config.h"
-#include "CStdInt.h"
+#include <beast/Config.h>
+
+#include <beast/utility/noexcept.h>
 
 #include <cmath>
+#include <cstdint>
 #include <algorithm>
 
 namespace beast {
@@ -195,12 +197,6 @@ inline bool isPositiveAndNotGreaterThan (const int valueToTest, const int upperL
 }
 
 //==============================================================================
-/** Handy function to swap two values. */
-template <typename Type>
-inline void swapVariables (Type& variable1, Type& variable2)
-{
-    std::swap (variable1, variable2);
-}
 
 /** Handy function for getting the number of elements in a simple const C array.
     E.g.
@@ -218,54 +214,12 @@ int numElementsInArray (Type (&array)[N])
     return N;
 }
 
-//==============================================================================
-// Some useful maths functions that aren't always present with all compilers and build settings.
-
-/** Using beast_hypot is easier than dealing with the different types of hypot function
-    that are provided by the various platforms and compilers. */
-template <typename Type>
-inline Type beast_hypot (Type a, Type b) noexcept
-{
-   #if BEAST_MSVC
-    return static_cast <Type> (_hypot (a, b));
-   #else
-    return static_cast <Type> (hypot (a, b));
-   #endif
-}
-
 /** 64-bit abs function. */
-inline int64 abs64 (const int64 n) noexcept
+inline std::int64_t abs64 (const std::int64_t n) noexcept
 {
     return (n >= 0) ? n : -n;
 }
 
-//==============================================================================
-/** A predefined value for Pi, at double-precision.
-    @see float_Pi
-*/
-const double  double_Pi  = 3.1415926535897932384626433832795;
-
-/** A predefined value for Pi, at single-precision.
-    @see double_Pi
-*/
-const float   float_Pi   = 3.14159265358979323846f;
-
-
-//==============================================================================
-/** The isfinite() method seems to vary between platforms, so this is a
-    platform-independent function for it.
-*/
-template <typename FloatingPointType>
-inline bool beast_isfinite (FloatingPointType value)
-{
-   #if BEAST_WINDOWS
-    return _finite (value);
-   #elif BEAST_ANDROID
-    return isfinite (value);
-   #else
-    return std::isfinite (value);
-   #endif
-}
 
 //==============================================================================
 #if BEAST_MSVC
@@ -309,149 +263,6 @@ inline int roundToInt (const FloatType value) noexcept
  #pragma optimize ("", on)  // resets optimisations to the project defaults
 #endif
 
-/** Fast floating-point-to-integer conversion.
-
-    This is a slightly slower and slightly more accurate version of roundDoubleToInt(). It works
-    fine for values above zero, but negative numbers are rounded the wrong way.
-*/
-inline int roundToIntAccurate (const double value) noexcept
-{
-   #ifdef __INTEL_COMPILER
-    #pragma float_control (pop)
-   #endif
-
-    return roundToInt (value + 1.5e-8);
-}
-
-/** Fast floating-point-to-integer conversion.
-
-    This is faster than using the normal c++ cast to convert a double to an int, and
-    it will round the value to the nearest integer, rather than rounding it down
-    like the normal cast does.
-
-    Note that this routine gets its speed at the expense of some accuracy, and when
-    rounding values whose floating point component is exactly 0.5, odd numbers and
-    even numbers will be rounded up or down differently. For a more accurate conversion,
-    see roundDoubleToIntAccurate().
-*/
-inline int roundDoubleToInt (const double value) noexcept
-{
-    return roundToInt (value);
-}
-
-/** Fast floating-point-to-integer conversion.
-
-    This is faster than using the normal c++ cast to convert a float to an int, and
-    it will round the value to the nearest integer, rather than rounding it down
-    like the normal cast does.
-
-    Note that this routine gets its speed at the expense of some accuracy, and when
-    rounding values whose floating point component is exactly 0.5, odd numbers and
-    even numbers will be rounded up or down differently.
-*/
-inline int roundFloatToInt (const float value) noexcept
-{
-    return roundToInt (value);
-}
-
-//==============================================================================
-/** Returns true if the specified integer is a power-of-two.
-*/
-template <typename IntegerType>
-bool isPowerOfTwo (IntegerType value)
-{
-   return (value & (value - 1)) == 0;
-}
-
-/** Returns the smallest power-of-two which is equal to or greater than the given integer.
-*/
-inline int nextPowerOfTwo (int n) noexcept
-{
-    --n;
-    n |= (n >> 1);
-    n |= (n >> 2);
-    n |= (n >> 4);
-    n |= (n >> 8);
-    n |= (n >> 16);
-    return n + 1;
-}
-
-/** Performs a modulo operation, but can cope with the dividend being negative.
-    The divisor must be greater than zero.
-*/
-template <typename IntegerType>
-IntegerType negativeAwareModulo (IntegerType dividend, const IntegerType divisor) noexcept
-{
-    bassert (divisor > 0);
-    dividend %= divisor;
-    return (dividend < 0) ? (dividend + divisor) : dividend;
-}
-
-//==============================================================================
-#if (BEAST_INTEL && BEAST_32BIT) || defined (DOXYGEN)
- /** This macro can be applied to a float variable to check whether it contains a denormalised
-     value, and to normalise it if necessary.
-     On CPUs that aren't vulnerable to denormalisation problems, this will have no effect.
- */
- #define BEAST_UNDENORMALISE(x)   x += 1.0f; x -= 1.0f;
-#else
- #define BEAST_UNDENORMALISE(x)
-#endif
-
-//==============================================================================
-/** This namespace contains a few template classes for helping work out class type variations.
-*/
-namespace TypeHelpers
-{
-   #if BEAST_VC8_OR_EARLIER
-    #define PARAMETER_TYPE(type) const type&
-   #else
-    /** The ParameterType struct is used to find the best type to use when passing some kind
-        of object as a parameter.
-
-        Of course, this is only likely to be useful in certain esoteric template situations.
-
-        Because "typename TypeHelpers::ParameterType<SomeClass>::type" is a bit of a mouthful, there's
-        a PARAMETER_TYPE(SomeClass) macro that you can use to get the same effect.
-
-        E.g. "myFunction (PARAMETER_TYPE (int), PARAMETER_TYPE (MyObject))"
-        would evaluate to "myfunction (int, const MyObject&)", keeping any primitive types as
-        pass-by-value, but passing objects as a const reference, to avoid copying.
-    */
-    template <typename Type> struct ParameterType                   { typedef const Type& type; };
-
-   #if ! DOXYGEN
-    template <typename Type> struct ParameterType <Type&>           { typedef Type& type; };
-    template <typename Type> struct ParameterType <Type*>           { typedef Type* type; };
-    template <>              struct ParameterType <char>            { typedef char type; };
-    template <>              struct ParameterType <unsigned char>   { typedef unsigned char type; };
-    template <>              struct ParameterType <short>           { typedef short type; };
-    template <>              struct ParameterType <unsigned short>  { typedef unsigned short type; };
-    template <>              struct ParameterType <int>             { typedef int type; };
-    template <>              struct ParameterType <unsigned int>    { typedef unsigned int type; };
-    template <>              struct ParameterType <long>            { typedef long type; };
-    template <>              struct ParameterType <unsigned long>   { typedef unsigned long type; };
-    template <>              struct ParameterType <int64>           { typedef int64 type; };
-    template <>              struct ParameterType <uint64>          { typedef uint64 type; };
-    template <>              struct ParameterType <bool>            { typedef bool type; };
-    template <>              struct ParameterType <float>           { typedef float type; };
-    template <>              struct ParameterType <double>          { typedef double type; };
-   #endif
-
-    /** A helpful macro to simplify the use of the ParameterType template.
-        @see ParameterType
-    */
-    #define PARAMETER_TYPE(a)    typename TypeHelpers::ParameterType<a>::type
-   #endif
-
-
-    /** These templates are designed to take a type, and if it's a double, they return a double
-        type; for anything else, they return a float type.
-    */
-    template <typename Type> struct SmallestFloatType             { typedef float  type; };
-    template <>              struct SmallestFloatType <double>    { typedef double type; };
-}
-
 }
 
 #endif

src/beast/beast/Atomic.h

@@ -24,9 +24,12 @@
 #ifndef BEAST_ATOMIC_H_INCLUDED
 #define BEAST_ATOMIC_H_INCLUDED
 
-#include "Config.h"
-#include "CStdInt.h"
-#include "StaticAssert.h"
+#include <beast/Config.h>
+#include <beast/StaticAssert.h>
+
+#include <beast/utility/noexcept.h>
+
+#include <cstdint>
 
 namespace beast {
 
@@ -156,10 +159,10 @@ private:
     template <typename Dest, typename Source>
     static inline Dest castTo (Source value) noexcept { union { Dest d; Source s; } u; u.s = value; return u.d; }
 
-    static inline Type castFrom32Bit (int32 value) noexcept { return castTo <Type, int32> (value); }
-    static inline Type castFrom64Bit (int64 value) noexcept { return castTo <Type, int64> (value); }
-    static inline int32 castTo32Bit (Type value) noexcept { return castTo <int32, Type> (value); }
-    static inline int64 castTo64Bit (Type value) noexcept { return castTo <int64, Type> (value); }
+    static inline Type castFrom32Bit (std::int32_t value) noexcept { return castTo <Type, std::int32_t> (value); }
+    static inline Type castFrom64Bit (std::int64_t value) noexcept { return castTo <Type, std::int64_t> (value); }
+    static inline std::int32_t castTo32Bit (Type value) noexcept { return castTo <std::int32_t, Type> (value); }
+    static inline std::int64_t castTo64Bit (Type value) noexcept { return castTo <std::int64_t, Type> (value); }
 
 
     Type operator++ (int); // better to just use pre-increment with atomics..
@@ -172,14 +175,14 @@ private:
         return sizeof (ValueType) == 1 ? (ValueType) -(signed char) n
             : (sizeof (ValueType) == 2 ? (ValueType) -(short) n
             : (sizeof (ValueType) == 4 ? (ValueType) -(int) n
-            : ((ValueType) -(int64) n)));
+            : ((ValueType) -(std::int64_t) n)));
     }
 
     /** This templated negate function will negate pointers as well as integers */
     template <typename PointerType>
     inline PointerType* negateValue (PointerType* n) noexcept
     {
-        return reinterpret_cast <PointerType*> (-reinterpret_cast <pointer_sized_int> (n));
+        return reinterpret_cast <PointerType*> (-reinterpret_cast <std::intptr_t> (n));
     }
 };
 
@@ -272,14 +275,14 @@ template <typename Type>
 inline Type Atomic<Type>::get() const noexcept
 {
   #if BEAST_ATOMICS_MAC
-    return sizeof (Type) == 4 ? castFrom32Bit ((int32) OSAtomicAdd32Barrier ((int32_t) 0, (BEAST_MAC_ATOMICS_VOLATILE int32_t*) &value))
-                              : castFrom64Bit ((int64) OSAtomicAdd64Barrier ((int64_t) 0, (BEAST_MAC_ATOMICS_VOLATILE int64_t*) &value));
+    return sizeof (Type) == 4 ? castFrom32Bit ((std::int32_t) OSAtomicAdd32Barrier ((int32_t) 0, (BEAST_MAC_ATOMICS_VOLATILE int32_t*) &value))
+                              : castFrom64Bit ((std::int64_t) OSAtomicAdd64Barrier ((int64_t) 0, (BEAST_MAC_ATOMICS_VOLATILE int64_t*) &value));
   #elif BEAST_ATOMICS_WINDOWS
-    return sizeof (Type) == 4 ? castFrom32Bit ((int32) beast_InterlockedExchangeAdd ((volatile long*) &value, (long) 0))
-                              : castFrom64Bit ((int64) beast_InterlockedExchangeAdd64 ((volatile __int64*) &value, (__int64) 0));
+    return sizeof (Type) == 4 ? castFrom32Bit ((std::int32_t) beast_InterlockedExchangeAdd ((volatile long*) &value, (long) 0))
+                              : castFrom64Bit ((std::int64_t) beast_InterlockedExchangeAdd64 ((volatile __int64*) &value, (__int64) 0));
   #elif BEAST_ATOMICS_GCC
-    return sizeof (Type) == 4 ? castFrom32Bit ((int32) __sync_add_and_fetch ((volatile int32*) &value, 0))
-                              : castFrom64Bit ((int64) __sync_add_and_fetch ((volatile int64*) &value, 0));
+    return sizeof (Type) == 4 ? castFrom32Bit ((std::int32_t) __sync_add_and_fetch ((volatile std::int32_t*) &value, 0))
+                              : castFrom64Bit ((std::int64_t) __sync_add_and_fetch ((volatile std::int64_t*) &value, 0));
   #endif
 }
 
@@ -291,8 +294,8 @@ inline Type Atomic<Type>::exchange (const Type newValue) noexcept
     while (! compareAndSetBool (newValue, currentVal)) { currentVal = value; }
     return currentVal;
   #elif BEAST_ATOMICS_WINDOWS
-    return sizeof (Type) == 4 ? castFrom32Bit ((int32) beast_InterlockedExchange ((volatile long*) &value, (long) castTo32Bit (newValue)))
-                              : castFrom64Bit ((int64) beast_InterlockedExchange64 ((volatile __int64*) &value, (__int64) castTo64Bit (newValue)));
+    return sizeof (Type) == 4 ? castFrom32Bit ((std::int32_t) beast_InterlockedExchange ((volatile long*) &value, (long) castTo32Bit (newValue)))
+                              : castFrom64Bit ((std::int64_t) beast_InterlockedExchange64 ((volatile __int64*) &value, (__int64) castTo64Bit (newValue)));
   #endif
 }
 
@@ -377,8 +380,8 @@ inline bool Atomic<Type>::compareAndSetBool (const Type newValue, const Type val
   #elif BEAST_ATOMICS_WINDOWS
     return compareAndSetValue (newValue, valueToCompare) == valueToCompare;
   #elif BEAST_ATOMICS_GCC
-    return sizeof (Type) == 4 ? __sync_bool_compare_and_swap ((volatile int32*) &value, castTo32Bit (valueToCompare), castTo32Bit (newValue))
-                              : __sync_bool_compare_and_swap ((volatile int64*) &value, castTo64Bit (valueToCompare), castTo64Bit (newValue));
+    return sizeof (Type) == 4 ? __sync_bool_compare_and_swap ((volatile std::int32_t*) &value, castTo32Bit (valueToCompare), castTo32Bit (newValue))
+                              : __sync_bool_compare_and_swap ((volatile std::int64_t*) &value, castTo64Bit (valueToCompare), castTo64Bit (newValue));
   #endif
 }
 
@@ -397,11 +400,11 @@ inline Type Atomic<Type>::compareAndSetValue (const Type newValue, const Type va
     }
 
   #elif BEAST_ATOMICS_WINDOWS
-    return sizeof (Type) == 4 ? castFrom32Bit ((int32) beast_InterlockedCompareExchange ((volatile long*) &value, (long) castTo32Bit (newValue), (long) castTo32Bit (valueToCompare)))
-                              : castFrom64Bit ((int64) beast_InterlockedCompareExchange64 ((volatile __int64*) &value, (__int64) castTo64Bit (newValue), (__int64) castTo64Bit (valueToCompare)));
+    return sizeof (Type) == 4 ? castFrom32Bit ((std::int32_t) beast_InterlockedCompareExchange ((volatile long*) &value, (long) castTo32Bit (newValue), (long) castTo32Bit (valueToCompare)))
+                              : castFrom64Bit ((std::int64_t) beast_InterlockedCompareExchange64 ((volatile __int64*) &value, (__int64) castTo64Bit (newValue), (__int64) castTo64Bit (valueToCompare)));
   #elif BEAST_ATOMICS_GCC
-    return sizeof (Type) == 4 ? castFrom32Bit ((int32) __sync_val_compare_and_swap ((volatile int32*) &value, castTo32Bit (valueToCompare), castTo32Bit (newValue)))
-                              : castFrom64Bit ((int64) __sync_val_compare_and_swap ((volatile int64*) &value, castTo64Bit (valueToCompare), castTo64Bit (newValue)));
+    return sizeof (Type) == 4 ? castFrom32Bit ((std::int32_t) __sync_val_compare_and_swap ((volatile std::int32_t*) &value, castTo32Bit (valueToCompare), castTo32Bit (newValue)))
+                              : castFrom64Bit ((std::int64_t) __sync_val_compare_and_swap ((volatile std::int64_t*) &value, castTo64Bit (valueToCompare), castTo64Bit (newValue)));
   #endif
 }
 

src/beast/beast/Boost.h

@@ -22,6 +22,6 @@
 
 // These classes require boost in order to be used.
 
-#include "boost/ErrorCode.h"
+#include <beast/boost/ErrorCode.h>
 
 #endif

src/beast/beast/ByteOrder.h

@@ -24,9 +24,10 @@
 #ifndef BEAST_BYTEORDER_H_INCLUDED
 #define BEAST_BYTEORDER_H_INCLUDED
 
-#include "Config.h"
-#include "CStdInt.h"
-#include "Uncopyable.h"
+#include <beast/Config.h>
+#include <beast/Uncopyable.h>
+
+#include <cstdint>
 
 namespace beast {
 
@@ -39,51 +40,51 @@ class ByteOrder : public Uncopyable
 public:
     //==============================================================================
     /** Swaps the upper and lower bytes of a 16-bit integer. */
-    static uint16 swap (uint16 value);
+    static std::uint16_t swap (std::uint16_t value);
 
     /** Reverses the order of the 4 bytes in a 32-bit integer. */
-    static uint32 swap (uint32 value);
+    static std::uint32_t swap (std::uint32_t value);
 
     /** Reverses the order of the 8 bytes in a 64-bit integer. */
-    static uint64 swap (uint64 value);
+    static std::uint64_t swap (std::uint64_t value);
 
     //==============================================================================
     /** Swaps the byte order of a 16-bit int if the CPU is big-endian */
-    static uint16 swapIfBigEndian (uint16 value);
+    static std::uint16_t swapIfBigEndian (std::uint16_t value);
 
     /** Swaps the byte order of a 32-bit int if the CPU is big-endian */
-    static uint32 swapIfBigEndian (uint32 value);
+    static std::uint32_t swapIfBigEndian (std::uint32_t value);
 
     /** Swaps the byte order of a 64-bit int if the CPU is big-endian */
-    static uint64 swapIfBigEndian (uint64 value);
+    static std::uint64_t swapIfBigEndian (std::uint64_t value);
 
     /** Swaps the byte order of a 16-bit int if the CPU is little-endian */
-    static uint16 swapIfLittleEndian (uint16 value);
+    static std::uint16_t swapIfLittleEndian (std::uint16_t value);
 
     /** Swaps the byte order of a 32-bit int if the CPU is little-endian */
-    static uint32 swapIfLittleEndian (uint32 value);
+    static std::uint32_t swapIfLittleEndian (std::uint32_t value);
 
     /** Swaps the byte order of a 64-bit int if the CPU is little-endian */
-    static uint64 swapIfLittleEndian (uint64 value);
+    static std::uint64_t swapIfLittleEndian (std::uint64_t value);
 
     //==============================================================================
     /** Turns 2 bytes into a little-endian integer. */
-    static uint16 littleEndianShort (const void* bytes);
+    static std::uint16_t littleEndianShort (const void* bytes);
 
     /** Turns 4 bytes into a little-endian integer. */
-    static uint32 littleEndianInt (const void* bytes);
+    static std::uint32_t littleEndianInt (const void* bytes);
 
     /** Turns 4 bytes into a little-endian integer. */
-    static uint64 littleEndianInt64 (const void* bytes);
+    static std::uint64_t littleEndianInt64 (const void* bytes);
 
     /** Turns 2 bytes into a big-endian integer. */
-    static uint16 bigEndianShort (const void* bytes);
+    static std::uint16_t bigEndianShort (const void* bytes);
 
     /** Turns 4 bytes into a big-endian integer. */
-    static uint32 bigEndianInt (const void* bytes);
+    static std::uint32_t bigEndianInt (const void* bytes);
 
     /** Turns 4 bytes into a big-endian integer. */
-    static uint64 bigEndianInt64 (const void* bytes);
+    static std::uint64_t bigEndianInt64 (const void* bytes);
 
     //==============================================================================
     /** Converts 3 little-endian bytes into a signed 24-bit value (which is sign-extended to 32 bits). */
@@ -111,16 +112,16 @@ private:
  #pragma intrinsic (_byteswap_ulong)
 #endif
 
-inline uint16 ByteOrder::swap (uint16 n)
+inline std::uint16_t ByteOrder::swap (std::uint16_t n)
 {
    #if BEAST_USE_INTRINSICSxxx // agh - the MS compiler has an internal error when you try to use this intrinsic!
-    return static_cast <uint16> (_byteswap_ushort (n));
+    return static_cast <std::uint16_t> (_byteswap_ushort (n));
    #else
-    return static_cast <uint16> ((n << 8) | (n >> 8));
+    return static_cast <std::uint16_t> ((n << 8) | (n >> 8));
    #endif
 }
 
-inline uint32 ByteOrder::swap (uint32 n)
+inline std::uint32_t ByteOrder::swap (std::uint32_t n)
 {
    #if BEAST_MAC || BEAST_IOS
     return OSSwapInt32 (n);
@@ -143,48 +144,48 @@ inline uint32 ByteOrder::swap (uint32 n)
    #endif
 }
 
-inline uint64 ByteOrder::swap (uint64 value)
+inline std::uint64_t ByteOrder::swap (std::uint64_t value)
 {
    #if BEAST_MAC || BEAST_IOS
     return OSSwapInt64 (value);
    #elif BEAST_USE_INTRINSICS
     return _byteswap_uint64 (value);
    #else
-    return (((int64) swap ((uint32) value)) << 32) | swap ((uint32) (value >> 32));
+    return (((std::int64_t) swap ((std::uint32_t) value)) << 32) | swap ((std::uint32_t) (value >> 32));
    #endif
 }
 
 #if BEAST_LITTLE_ENDIAN
- inline uint16 ByteOrder::swapIfBigEndian (const uint16 v)                                  { return v; }
- inline uint32 ByteOrder::swapIfBigEndian (const uint32 v)                                  { return v; }
- inline uint64 ByteOrder::swapIfBigEndian (const uint64 v)                                  { return v; }
- inline uint16 ByteOrder::swapIfLittleEndian (const uint16 v)                               { return swap (v); }
- inline uint32 ByteOrder::swapIfLittleEndian (const uint32 v)                               { return swap (v); }
- inline uint64 ByteOrder::swapIfLittleEndian (const uint64 v)                               { return swap (v); }
- inline uint16 ByteOrder::littleEndianShort (const void* const bytes)                       { return *static_cast <const uint16*> (bytes); }
- inline uint32 ByteOrder::littleEndianInt (const void* const bytes)                         { return *static_cast <const uint32*> (bytes); }
- inline uint64 ByteOrder::littleEndianInt64 (const void* const bytes)                       { return *static_cast <const uint64*> (bytes); }
- inline uint16 ByteOrder::bigEndianShort (const void* const bytes)                          { return swap (*static_cast <const uint16*> (bytes)); }
- inline uint32 ByteOrder::bigEndianInt (const void* const bytes)                            { return swap (*static_cast <const uint32*> (bytes)); }
- inline uint64 ByteOrder::bigEndianInt64 (const void* const bytes)                          { return swap (*static_cast <const uint64*> (bytes)); }
+ inline std::uint16_t ByteOrder::swapIfBigEndian (const std::uint16_t v)                                  { return v; }
+ inline std::uint32_t ByteOrder::swapIfBigEndian (const std::uint32_t v)                                  { return v; }
+ inline std::uint64_t ByteOrder::swapIfBigEndian (const std::uint64_t v)                                  { return v; }
+ inline std::uint16_t ByteOrder::swapIfLittleEndian (const std::uint16_t v)                               { return swap (v); }
+ inline std::uint32_t ByteOrder::swapIfLittleEndian (const std::uint32_t v)                               { return swap (v); }
+ inline std::uint64_t ByteOrder::swapIfLittleEndian (const std::uint64_t v)                               { return swap (v); }
+ inline std::uint16_t ByteOrder::littleEndianShort (const void* const bytes)                       { return *static_cast <const std::uint16_t*> (bytes); }
+ inline std::uint32_t ByteOrder::littleEndianInt (const void* const bytes)                         { return *static_cast <const std::uint32_t*> (bytes); }
+ inline std::uint64_t ByteOrder::littleEndianInt64 (const void* const bytes)                       { return *static_cast <const std::uint64_t*> (bytes); }
+ inline std::uint16_t ByteOrder::bigEndianShort (const void* const bytes)                          { return swap (*static_cast <const std::uint16_t*> (bytes)); }
+ inline std::uint32_t ByteOrder::bigEndianInt (const void* const bytes)                            { return swap (*static_cast <const std::uint32_t*> (bytes)); }
+ inline std::uint64_t ByteOrder::bigEndianInt64 (const void* const bytes)                          { return swap (*static_cast <const std::uint64_t*> (bytes)); }
  inline bool ByteOrder::isBigEndian()                                                       { return false; }
 #else
- inline uint16 ByteOrder::swapIfBigEndian (const uint16 v)                                  { return swap (v); }
- inline uint32 ByteOrder::swapIfBigEndian (const uint32 v)                                  { return swap (v); }
- inline uint64 ByteOrder::swapIfBigEndian (const uint64 v)                                  { return swap (v); }
- inline uint16 ByteOrder::swapIfLittleEndian (const uint16 v)                               { return v; }
- inline uint32 ByteOrder::swapIfLittleEndian (const uint32 v)                               { return v; }
- inline uint64 ByteOrder::swapIfLittleEndian (const uint64 v)                               { return v; }
- inline uint32 ByteOrder::littleEndianInt (const void* const bytes)                         { return swap (*static_cast <const uint32*> (bytes)); }
- inline uint16 ByteOrder::littleEndianShort (const void* const bytes)                       { return swap (*static_cast <const uint16*> (bytes)); }
- inline uint16 ByteOrder::bigEndianShort (const void* const bytes)                          { return *static_cast <const uint16*> (bytes); }
- inline uint32 ByteOrder::bigEndianInt (const void* const bytes)                            { return *static_cast <const uint32*> (bytes); }
- inline uint64 ByteOrder::bigEndianInt64 (const void* const bytes)                          { return *static_cast <const uint64*> (bytes); }
+ inline std::uint16_t ByteOrder::swapIfBigEndian (const std::uint16_t v)                                  { return swap (v); }
+ inline std::uint32_t ByteOrder::swapIfBigEndian (const std::uint32_t v)                                  { return swap (v); }
+ inline std::uint64_t ByteOrder::swapIfBigEndian (const std::uint64_t v)                                  { return swap (v); }
+ inline std::uint16_t ByteOrder::swapIfLittleEndian (const std::uint16_t v)                               { return v; }
+ inline std::uint32_t ByteOrder::swapIfLittleEndian (const std::uint32_t v)                               { return v; }
+ inline std::uint64_t ByteOrder::swapIfLittleEndian (const std::uint64_t v)                               { return v; }
+ inline std::uint32_t ByteOrder::littleEndianInt (const void* const bytes)                         { return swap (*static_cast <const std::uint32_t*> (bytes)); }
+ inline std::uint16_t ByteOrder::littleEndianShort (const void* const bytes)                       { return swap (*static_cast <const std::uint16_t*> (bytes)); }
+ inline std::uint16_t ByteOrder::bigEndianShort (const void* const bytes)                          { return *static_cast <const std::uint16_t*> (bytes); }
+ inline std::uint32_t ByteOrder::bigEndianInt (const void* const bytes)                            { return *static_cast <const std::uint32_t*> (bytes); }
+ inline std::uint64_t ByteOrder::bigEndianInt64 (const void* const bytes)                          { return *static_cast <const std::uint64_t*> (bytes); }
  inline bool ByteOrder::isBigEndian()                                                       { return true; }
 #endif
 
-inline int  ByteOrder::littleEndian24Bit (const char* const bytes)                          { return (((int) bytes[2]) << 16) | (((int) (uint8) bytes[1]) << 8) | ((int) (uint8) bytes[0]); }
-inline int  ByteOrder::bigEndian24Bit (const char* const bytes)                             { return (((int) bytes[0]) << 16) | (((int) (uint8) bytes[1]) << 8) | ((int) (uint8) bytes[2]); }
+inline int  ByteOrder::littleEndian24Bit (const char* const bytes)                          { return (((int) bytes[2]) << 16) | (((int) (std::uint8_t) bytes[1]) << 8) | ((int) (std::uint8_t) bytes[0]); }
+inline int  ByteOrder::bigEndian24Bit (const char* const bytes)                             { return (((int) bytes[0]) << 16) | (((int) (std::uint8_t) bytes[1]) << 8) | ((int) (std::uint8_t) bytes[2]); }
 inline void ByteOrder::littleEndian24BitToChars (const int value, char* const destBytes)    { destBytes[0] = (char)(value & 0xff); destBytes[1] = (char)((value >> 8) & 0xff); destBytes[2] = (char)((value >> 16) & 0xff); }
 inline void ByteOrder::bigEndian24BitToChars (const int value, char* const destBytes)       { destBytes[0] = (char)((value >> 16) & 0xff); destBytes[1] = (char)((value >> 8) & 0xff); destBytes[2] = (char)(value & 0xff); }
 
@@ -211,29 +212,29 @@ struct SwapBytes
 // Specializations for signed integers
 
 template <>
-struct SwapBytes <int16>
+struct SwapBytes <std::int16_t>
 {
-    inline int16 operator() (int16 value) const noexcept 
+    inline std::int16_t operator() (std::int16_t value) const noexcept 
     {
-        return static_cast <int16> (ByteOrder::swap (static_cast <uint16> (value)));
+        return static_cast <std::int16_t> (ByteOrder::swap (static_cast <std::uint16_t> (value)));
     }
 };
 
 template <>
-struct SwapBytes <int32>
+struct SwapBytes <std::int32_t>
 {
-    inline int32 operator() (int32 value) const noexcept 
+    inline std::int32_t operator() (std::int32_t value) const noexcept 
     {
-        return static_cast <int32> (ByteOrder::swap (static_cast <uint32> (value)));
+        return static_cast <std::int32_t> (ByteOrder::swap (static_cast <std::uint32_t> (value)));
     }
 };
 
 template <>
-struct SwapBytes <int64>
+struct SwapBytes <std::int64_t>
 {
-    inline int64 operator() (int64 value) const noexcept 
+    inline std::int64_t operator() (std::int64_t value) const noexcept 
     {
-        return static_cast <int64> (ByteOrder::swap (static_cast <uint64> (value)));
+        return static_cast <std::int64_t> (ByteOrder::swap (static_cast <std::uint64_t> (value)));
     }
 };
 

src/beast/beast/CStdInt.h

@@ -1,88 +0,0 @@
-//------------------------------------------------------------------------------
-/*
-    This file is part of Beast: https://github.com/vinniefalco/Beast
-    Copyright 2013, Vinnie Falco <vinnie.falco@gmail.com>
-
-    Portions of this file are from JUCE.
-    Copyright (c) 2013 - Raw Material Software Ltd.
-    Please visit http://www.juce.com
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose  with  or without fee is hereby granted, provided that the above
-    copyright notice and this permission notice appear in all copies.
-
-    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
-    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
-    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-*/
-//==============================================================================
-
-#ifndef BEAST_CSTDINT_H_INCLUDED
-#define BEAST_CSTDINT_H_INCLUDED
-
-#include "Config.h"
-
-namespace beast {
-
-typedef signed char                 int8;
-typedef signed short                int16;
-typedef signed int                  int32;
-typedef unsigned char               uint8;
-typedef unsigned short              uint16;
-typedef unsigned int                uint32;
-
-#if BEAST_MSVC
-  typedef __int64                   int64;
-  typedef unsigned __int64          uint64;
-
-  /** A platform-independent macro for writing 64-bit literals, needed because
-      different compilers have different syntaxes for this.
-
-      E.g. writing literal64bit (0x1000000000) will translate to 0x1000000000LL for
-      GCC, or 0x1000000000 for MSVC.
-  */
-  #define literal64bit(longLiteral)     ((__int64) longLiteral)
-
-#else
-  /** A platform-independent 64-bit integer type. */
-  typedef long long                 int64;
-  /** A platform-independent 64-bit unsigned integer type. */
-  typedef unsigned long long        uint64;
-  /** A platform-independent macro for writing 64-bit literals, needed because
-      different compilers have different syntaxes for this.
-
-      E.g. writing literal64bit (0x1000000000) will translate to 0x1000000000LL for
-      GCC, or 0x1000000000 for MSVC.
-  */
-  #define literal64bit(longLiteral)     (longLiteral##LL)
-
-#endif
-
-#if BEAST_64BIT
-  /** A signed integer type that's guaranteed to be large enough to hold a pointer without truncating it. */
-  typedef int64                     pointer_sized_int;
-  /** An unsigned integer type that's guaranteed to be large enough to hold a pointer without truncating it. */
-  typedef uint64                    pointer_sized_uint;
-#elif BEAST_MSVC
-  /** A signed integer type that's guaranteed to be large enough to hold a pointer without truncating it. */
-  typedef _W64 int                  pointer_sized_int;
-  /** An unsigned integer type that's guaranteed to be large enough to hold a pointer without truncating it. */
-  typedef _W64 unsigned int         pointer_sized_uint;
-#else
-  /** A signed integer type that's guaranteed to be large enough to hold a pointer without truncating it. */
-  typedef int                       pointer_sized_int;
-  /** An unsigned integer type that's guaranteed to be large enough to hold a pointer without truncating it. */
-  typedef unsigned int              pointer_sized_uint;
-#endif
-
-#if BEAST_MSVC
-  typedef pointer_sized_int ssize_t;
-#endif
-
-}
-
-#endif

src/beast/beast/Chrono.h

@@ -20,15 +20,13 @@
 #ifndef BEAST_CHRONO_H_INCLUDED
 #define BEAST_CHRONO_H_INCLUDED
 
-#include "chrono/abstract_clock.h"
-#include "chrono/basic_seconds_clock.h"
-#include "chrono/chrono_io.h"
-#include "chrono/chrono_util.h"
-#include "chrono/manual_clock.h"
-#include "chrono/ratio_io.h"
+#include <beast/chrono/abstract_clock.h>
+#include <beast/chrono/basic_seconds_clock.h>
+#include <beast/chrono/chrono_io.h>
+#include <beast/chrono/chrono_util.h>
+#include <beast/chrono/manual_clock.h>
+#include <beast/chrono/ratio_io.h>
 
-#include "chrono/CPUMeter.h"
-#include "chrono/RelativeTime.h"
-#include "chrono/ScopedTimeInterval.h"
+#include <beast/chrono/RelativeTime.h>
 
 #endif

src/beast/beast/Config.h

@@ -26,35 +26,38 @@
 
 // VFALCO NOTE this is analogous to <boost/config.hpp>
 
+// Assert to boost that we always have std::array support
+#define BOOST_ASIO_HAS_STD_ARRAY 1
+
 #if !defined(BEAST_COMPILER_CONFIG) && !defined(BEAST_NO_COMPILER_CONFIG) && !defined(BEAST_NO_CONFIG)
-#include "config/SelectCompilerConfig.h"
+#include <beast/config/SelectCompilerConfig.h>
 #endif
 #ifdef   BEAST_COMPILER_CONFIG
 #include BEAST_COMPILER_CONFIG
 #endif
 
 #if !defined(BEAST_STDLIB_CONFIG) && !defined(BEAST_NO_STDLIB_CONFIG) && !defined(BEAST_NO_CONFIG) && defined(__cplusplus)
-#include "config/SelectStdlibConfig.h"
+#include <beast/config/SelectStdlibConfig.h>
 #endif
 #ifdef   BEAST_STDLIB_CONFIG
 #include BEAST_STDLIB_CONFIG
 #endif
 
 #if !defined(BEAST_PLATFORM_CONFIG) && !defined(BEAST_NO_PLATFORM_CONFIG) && !defined(BEAST_NO_CONFIG)
-#include "config/SelectCompilerConfig.h"
+#include <beast/config/SelectCompilerConfig.h>
 #endif
 #ifdef   BEAST_PLATFORM_CONFIG
 #include BEAST_PLATFORM_CONFIG
 #endif
 
 // Legacy
-#include "Version.h"
-#include "config/PlatformConfig.h"
-#include "config/CompilerConfig.h"
-#include "config/StandardConfig.h"
-#include "config/ConfigCheck.h"
+#include <beast/Version.h>
+#include <beast/config/PlatformConfig.h>
+#include <beast/config/CompilerConfig.h>
+#include <beast/config/StandardConfig.h>
+#include <beast/config/ConfigCheck.h>
 
 // Suffix
-#include "config/Suffix.h"
+#include <beast/config/Suffix.h>
     
 #endif

src/beast/beast/Crypto.h

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

src/beast/beast/FixedArray.h

@@ -1,166 +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_FIXEDARRAY_H_INCLUDED
-#define BEAST_FIXEDARRAY_H_INCLUDED
-
-#include "Config.h"
-
-#include <cstddef>
-#include <iterator>
-#include <stdexcept>
-
-namespace beast {
-
-// Ideas from Boost
-
-/** An array whose size is determined at compile-time.
-    The interface tries to follow std::vector as closely as possible within
-    the limitations of having a fixed size.
-*/
-template <class T, std::size_t N>
-class FixedArray
-{
-public:
-    T values [N];
-
-    typedef T                value_type;
-    typedef T*               iterator;
-    typedef T const*         const_iterator;
-    typedef T&               reference;
-    typedef T const&         const_reference;
-    typedef std::size_t      size_type;
-    typedef std::ptrdiff_t   difference_type;
-
-    // iterators
-    iterator        begin()       { return values; }
-    const_iterator  begin() const { return values; }
-    const_iterator cbegin() const { return values; }
-    iterator        end()       { return values+N; }
-    const_iterator  end() const { return values+N; }
-    const_iterator cend() const { return values+N; }
-
-    typedef std::reverse_iterator <iterator> reverse_iterator;
-    typedef std::reverse_iterator <const_iterator> const_reverse_iterator;
-
-    reverse_iterator rbegin() { return reverse_iterator(end()); }
-    const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
-    const_reverse_iterator crbegin() const { return const_reverse_iterator(end()); }
-    reverse_iterator rend() { return reverse_iterator(begin()); }
-    const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }
-    const_reverse_iterator crend() const { return const_reverse_iterator(begin()); }
-
-    reference operator[](size_type i)
-    {
-        bassert (i < N);
-        return values[i];
-    }
-
-    const_reference operator[](size_type i) const
-    {
-        bassert (i < N);
-        return values[i];
-    }
-
-    reference at(size_type i) { rangecheck(i); return values[i]; }
-    const_reference at(size_type i) const { rangecheck(i); return values[i]; }
-
-    reference front() { return values[0]; }
-    reference back()  { return values[N-1]; }
-    const_reference front () const { return values[0]; }
-    const_reference back()   const { return values[N-1]; }
-
-    static size_type size() { return N; }
-    static bool empty() { return false; }
-    static size_type max_size() { return N; }
-    
-    enum { static_size = N };
-
-    T const* data() const { return values; }
-    T* data() { return values; }
-    T* c_array() { return values; }
-
-    template <typename T2>
-    FixedArray<T,N>& operator= (FixedArray<T2,N> const& rhs)
-    {
-        std::copy (rhs.begin(), rhs.end(), begin());
-        return *this;
-    }
-
-    void assign (T const& value) { fill (value); }
-
-    void fill (T const& value)
-    {
-        std::fill_n (begin(), size(), value);
-    }
-
-    void clear ()
-    {
-        fill (T ());
-    }
-
-    static void rangecheck (size_type i)
-    {
-        if (i >= size())
-            throw std::out_of_range ("FixedArray<>: index out of range");
-    }
-};
-
-//------------------------------------------------------------------------------
-
-template <class T, std::size_t N>
-bool operator== (FixedArray <T, N> const& lhs, FixedArray <T, N> const& rhs)
-{
-    return std::equal (lhs.begin(), lhs.end(), rhs.begin());
-}
-
-template <class T, std::size_t N>
-bool operator!= (FixedArray <T, N> const& lhs, FixedArray <T, N> const& rhs)
-{
-    return !(lhs==rhs);
-}
-
-template <class T, std::size_t N>
-bool operator< (FixedArray <T, N> const& lhs, FixedArray <T, N> const& rhs)
-{
-    return std::lexicographical_compare (
-        lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
-}
-
-template <class T, std::size_t N>
-bool operator> (FixedArray <T, N> const& lhs, FixedArray <T, N> const& rhs)
-{
-    return rhs<lhs;
-}
-
-template <class T, std::size_t N>
-bool operator<= (FixedArray <T, N> const& lhs, FixedArray <T, N> const& rhs)
-{
-    return !(rhs<lhs);
-}
-
-template <class T, std::size_t N>
-bool operator>= (FixedArray <T, N> const& lhs, FixedArray <T, N> const& rhs)
-{
-    return !(lhs<rhs);
-}
-
-}
-
-#endif

src/beast/beast/HeapBlock.h

@@ -28,8 +28,8 @@
 #include <cstdlib>
 #include <stdexcept>
 
-#include "Memory.h"
-#include "Uncopyable.h"
+#include <beast/Memory.h>
+#include <beast/Uncopyable.h>
 
 // If the MSVC debug heap headers were included, disable
 // the macros during the juce include since they conflict.
@@ -119,7 +119,7 @@ namespace HeapBlockHelper
     then a failed allocation will just leave the heapblock with a null pointer (assuming
     that the system's malloc() function doesn't throw).
 
-    @see Array, OwnedArray, MemoryBlock
+    @see Array, MemoryBlock
 */
 template <class ElementType, bool throwOnFailure = false>
 class HeapBlock : public Uncopyable
@@ -294,7 +294,7 @@ public:
         The semantics of this method are the same as malloc() and calloc(), but it
         uses realloc() to keep as much of the existing data as possible.
     */
-    void realloc (const size_t newNumElements, const size_t elementSize = sizeof (ElementType))
+    void reallocate (const size_t newNumElements, const size_t elementSize = sizeof (ElementType))
     {
         data = static_cast <ElementType*> (data == nullptr ? std::malloc (newNumElements * elementSize)
                                                            : std::realloc (data, newNumElements * elementSize));
@@ -304,7 +304,7 @@ public:
     /** Frees any currently-allocated data.
         This will free the data and reset this object to be a null pointer.
     */
-    void free()
+    void free_up()
     {
         std::free (data);
         data = nullptr;
@@ -339,10 +339,6 @@ private:
     {
         HeapBlockHelper::ThrowOnFail<throwOnFailure>::check (data);
     }
-
-   #if ! (defined (BEAST_DLL) || defined (BEAST_DLL_BUILD))
-    BEAST_PREVENT_HEAP_ALLOCATION // Creating a 'new HeapBlock' would be missing the point!
-   #endif
 };
 
 }

src/beast/beast/Insight.h

@@ -20,18 +20,18 @@
 #ifndef BEAST_INSIGHT_H_INCLUDED
 #define BEAST_INSIGHT_H_INCLUDED
 
-#include "insight/Counter.h"
-#include "insight/CounterImpl.h"
-#include "insight/Event.h"
-#include "insight/EventImpl.h"
-#include "insight/Gauge.h"
-#include "insight/GaugeImpl.h"
-#include "insight/Group.h"
-#include "insight/Groups.h"
-#include "insight/Hook.h"
-#include "insight/HookImpl.h"
-#include "insight/Collector.h"
-#include "insight/NullCollector.h"
-#include "insight/StatsDCollector.h"
+#include <beast/insight/Counter.h>
+#include <beast/insight/CounterImpl.h>
+#include <beast/insight/Event.h>
+#include <beast/insight/EventImpl.h>
+#include <beast/insight/Gauge.h>
+#include <beast/insight/GaugeImpl.h>
+#include <beast/insight/Group.h>
+#include <beast/insight/Groups.h>
+#include <beast/insight/Hook.h>
+#include <beast/insight/HookImpl.h>
+#include <beast/insight/Collector.h>
+#include <beast/insight/NullCollector.h>
+#include <beast/insight/StatsDCollector.h>
 
 #endif

src/beast/beast/Intrusive.h

@@ -20,7 +20,7 @@
 #ifndef BEAST_INTRUSIVE_H_INCLUDED
 #define BEAST_INTRUSIVE_H_INCLUDED
 
-#include "intrusive/List.h"
-#include "intrusive/LockFreeStack.h"
+#include <beast/intrusive/List.h>
+#include <beast/intrusive/LockFreeStack.h>
 
 #endif

src/beast/beast/Memory.h

@@ -26,8 +26,8 @@
 
 #include <cstring>
     
-#include "Config.h"
-#include "Uncopyable.h"
+#include <beast/Config.h>
+#include <beast/Uncopyable.h>
 
 namespace beast {
 
@@ -43,7 +43,7 @@ void zerostruct (Type& structure) noexcept
 
 /** Delete an object pointer, and sets the pointer to null.
 
-    Remember that it's not good c++ practice to use delete directly - always try to use a ScopedPointer
+    Remember that it's not good c++ practice to use delete directly - always try to use a std::unique_ptr
     or other automatic lifetime-management system rather than resorting to deleting raw pointers!
 */
 template <typename Type>
@@ -78,7 +78,7 @@ Type* createCopyIfNotNull (const Type* pointer)
  /** A handy C++ wrapper that creates and deletes an NSAutoreleasePool object using RAII.
      You should use the BEAST_AUTORELEASEPOOL macro to create a local auto-release pool on the stack.
  */
- class BEAST_API ScopedAutoReleasePool : public Uncopyable
+ class ScopedAutoReleasePool : public Uncopyable
  {
  public:
      ScopedAutoReleasePool();

src/beast/beast/SafeBool.h

@@ -1,95 +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_SAFEBOOL_H_INCLUDED
-#define BEAST_SAFEBOOL_H_INCLUDED
-
-namespace beast {
-
-namespace detail {
-
-class SafeBoolBase
-{
-private:
-    void disallowed () const { }
-
-public:
-    void allowed () const { }
-
-protected:
-    typedef void (SafeBoolBase::*boolean_t) () const;
-
-    SafeBoolBase () { }
-    SafeBoolBase (SafeBoolBase const&) { }
-    SafeBoolBase& operator= (SafeBoolBase const&)
-    {
-        return *this;
-    }
-    ~SafeBoolBase () { }
-};
-
-}
-
-/** Safe evaluation of class as `bool`.
-
-    This allows a class to be safely evaluated as a bool without the usual
-    harmful side effects of the straightforward operator conversion approach.
-    To use it, derive your class from SafeBool and implement `asBoolean()` as:
-
-    @code
-
-    bool asBoolean () const;
-
-    @endcode
-
-    Ideas from http://www.artima.com/cppsource/safebool.html
-
-    @class SafeBool
-*/
-template <typename T = void>
-class SafeBool : public detail::SafeBoolBase
-{
-public:
-    operator detail::SafeBoolBase::boolean_t () const
-    {
-        return (static_cast <T const*> (this))->asBoolean ()
-               ? &SafeBoolBase::allowed : 0;
-    }
-
-protected:
-    ~SafeBool () { }
-};
-
-template <typename T, typename U>
-void operator== (SafeBool <T> const& lhs, SafeBool <U> const& rhs)
-{
-    lhs.disallowed ();
-}
-
-template <typename T, typename U>
-void operator!= (SafeBool <T> const& lhs, SafeBool <U> const& rhs)
-{
-    lhs.disallowed ();
-}
-
-}
-
-#endif
-
-

src/beast/beast/SmartPtr.h

@@ -20,12 +20,9 @@
 #ifndef BEAST_SMARTPTR_H_INCLUDED
 #define BEAST_SMARTPTR_H_INCLUDED
 
-#include "Config.h"
+#include <beast/Config.h>
 
-#include "smart_ptr/AbstractObject.h"
-#include "smart_ptr/ContainerDeletePolicy.h"
-#include "smart_ptr/SharedObject.h"
-#include "smart_ptr/SharedPtr.h"
-#include "smart_ptr/ScopedPointer.h"
+#include <beast/smart_ptr/SharedObject.h>
+#include <beast/smart_ptr/SharedPtr.h>
 
 #endif

src/beast/beast/Strings.h

@@ -20,8 +20,8 @@
 #ifndef BEAST_STRINGS_H_INCLUDED
 #define BEAST_STRINGS_H_INCLUDED
 
-#include "strings/String.h"
-#include "strings/NewLine.h"
+#include <beast/strings/String.h>
+#include <beast/strings/NewLine.h>
 
 #endif
 

src/beast/beast/Threads.h

@@ -20,20 +20,19 @@
 #ifndef BEAST_THREADS_H_INCLUDED
 #define BEAST_THREADS_H_INCLUDED
 
-#include "threads/LockGuard.h"
-#include "threads/UnlockGuard.h"
-#include "threads/TryLockGuard.h"
-#include "threads/SharedLockGuard.h"
-#include "threads/SharedMutexAdapter.h"
-#include "threads/SharedData.h"
-#include "threads/ServiceQueue.h"
-#include "threads/SpinLock.h"
-#include "threads/Stoppable.h"
-#include "threads/Thread.h"
-#include "threads/ThreadLocalValue.h"
-#include "threads/WaitableEvent.h"
-#include "threads/ScopedWrapperContext.h"
+#include <beast/threads/UnlockGuard.h>
+#include <beast/threads/TryLockGuard.h>
+#include <beast/threads/SharedLockGuard.h>
+#include <beast/threads/SharedMutexAdapter.h>
+#include <beast/threads/SharedData.h>
+#include <beast/threads/ServiceQueue.h>
+#include <beast/threads/SpinLock.h>
+#include <beast/threads/Stoppable.h>
+#include <beast/threads/Thread.h>
+#include <beast/threads/ThreadLocalValue.h>
+#include <beast/threads/WaitableEvent.h>
+#include <beast/threads/ScopedWrapperContext.h>
 
-#include "threads/semaphore.h"
+#include <beast/threads/semaphore.h>
 
 #endif

src/beast/beast/asio/Asio.cpp

@@ -1,28 +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 "BeastConfig.h"
-
-#include "impl/IPAddressConversion.cpp"
-
-#include "tests/wrap_handler_tests.cpp"
-#include "tests/bind_handler_tests.cpp"
-#include "tests/shared_handler_tests.cpp"
-
-#include "abstract_socket.cpp" // TEMPORARY!

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

@@ -0,0 +1,32 @@
+//------------------------------------------------------------------------------
+/*
+    This file is part of Beast: https://github.com/vinniefalco/Beast
+    Copyright 2013, Vinnie Falco <vinnie.falco@gmail.com>
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose  with  or without fee is hereby granted, provided that the above
+    copyright notice and this permission notice appear in all copies.
+
+    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
+    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
+    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+//==============================================================================
+
+#if BEAST_INCLUDE_BEASTCONFIG
+#include <BeastConfig.h>
+#endif
+
+#include <beast/asio/impl/IPAddressConversion.cpp>
+
+#include <beast/asio/tests/wrap_handler.test.cpp>
+#include <beast/asio/tests/bind_handler.test.cpp>
+#include <beast/asio/tests/enable_wait_for_async.test.cpp>
+#include <beast/asio/tests/shared_handler.test.cpp>
+
+#include <beast/asio/abstract_socket.cpp> // TEMPORARY!
+

src/beast/beast/asio/IPAddressConversion.h

@@ -20,7 +20,7 @@
 #ifndef BEAST_ASIO_IPADDRESSCONVERSION_H_INCLUDED
 #define BEAST_ASIO_IPADDRESSCONVERSION_H_INCLUDED
 
-#include "../net/IPEndpoint.h"
+#include <beast/net/IPEndpoint.h>
 
 #include <sstream>
 

src/beast/beast/asio/README.md

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

src/beast/beast/asio/abstract_socket.cpp

@@ -17,8 +17,8 @@
 */
 //==============================================================================
 
-#include "abstract_socket.h"
-#include "bind_handler.h"
+#include <beast/asio/abstract_socket.h>
+#include <beast/asio/bind_handler.h>
 
 namespace beast {
 namespace asio {

src/beast/beast/asio/abstract_socket.h

@@ -20,9 +20,9 @@
 #ifndef BEAST_ASIO_ABSTRACT_SOCKET_H_INCLUDED
 #define BEAST_ASIO_ABSTRACT_SOCKET_H_INCLUDED
 
-#include "buffer_sequence.h"
-#include "shared_handler.h"
-
+#include <beast/asio/buffer_sequence.h>
+#include <beast/asio/shared_handler.h>
+#include <boost/asio/io_service.hpp>
 #include <boost/asio/socket_base.hpp>
 #include <boost/asio/ssl/stream_base.hpp>
 

src/beast/beast/asio/bind_handler.h

@@ -25,8 +25,8 @@
 #include <boost/asio/detail/handler_invoke_helpers.hpp>
 
 #include <functional>
-#include "../cxx14/type_traits.h" // <type_traits>
-#include "../cxx14/utility.h" // <utility>
+#include <beast/cxx14/type_traits.h> // <type_traits>
+#include <beast/cxx14/utility.h> // <utility>
 
 namespace beast {
 namespace asio {
@@ -56,6 +56,7 @@ private:
 public:
     typedef void result_type;
 
+    explicit
     bound_handler (DeducedHandler&& handler, Args&&... args)
         : m_handler (std::forward <DeducedHandler> (handler))
         , m_args (std::forward <Args> (args)...)

src/beast/beast/asio/buffer_sequence.h

@@ -22,9 +22,10 @@
 
 #include <boost/asio/buffer.hpp>
 
+#include <beast/utility/noexcept.h>
 #include <algorithm>
 #include <iterator>
-#include "../cxx14/type_traits.h" // <type_traits>
+#include <beast/cxx14/type_traits.h> // <type_traits>
 #include <vector>
 
 namespace beast {
@@ -99,6 +100,21 @@ public:
     {
         return m_buffers.end ();
     }
+
+#if 0
+    template <class ConstBufferSequence>
+    void
+    assign (ConstBufferSequence const& buffers)
+    {
+        auto const n (std::distance (
+            std::begin (buffers), std::end (buffers)));
+
+        for (int i = 0, auto iter (std::begin (buffers));
+            iter != std::end (buffers); ++iter, ++i)
+            m_buffers[i] = Buffer (boost::asio::buffer_cast <void*> (
+                *iter), boost::asio::buffer_size (*iter));
+    }
+#endif
 };
 
 typedef buffer_sequence <boost::asio::const_buffer> const_buffers;

src/beast/beast/asio/enable_wait_for_async.h

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

src/beast/beast/asio/impl/IPAddressConversion.cpp

@@ -17,7 +17,7 @@
 */
 //==============================================================================
 
-#include "../IPAddressConversion.h"
+#include <beast/asio/IPAddressConversion.h>
 
 namespace beast {
 namespace IP {
@@ -33,7 +33,7 @@ Endpoint from_asio (boost::asio::ip::address const& address)
     }
 
     // VFALCO TODO IPv6 support
-    bassertfalse;
+    assert(false);
     return Endpoint();
 }
 
@@ -52,7 +52,7 @@ boost::asio::ip::address to_asio_address (Endpoint const& endpoint)
     }
 
     // VFALCO TODO IPv6 support
-    bassertfalse;
+    assert(false);
     return boost::asio::ip::address (
         boost::asio::ip::address_v6 ());
 }

src/beast/beast/asio/memory_buffer.h

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

src/beast/beast/asio/shared_handler.h

@@ -20,18 +20,20 @@
 #ifndef BEAST_ASIO_SHARED_HANDLER_H_INCLUDED
 #define BEAST_ASIO_SHARED_HANDLER_H_INCLUDED
 
-#include "../mpl/IsCallPossible.h"
+#include <beast/Config.h>
 
-#include <functional>
-#include <memory>
-#include "../cxx14/type_traits.h" // <type_traits>
+#include <beast/utility/is_call_possible.h>
 
 #include <boost/utility/base_from_member.hpp>
-
 #include <boost/asio/detail/handler_alloc_helpers.hpp>
 #include <boost/asio/detail/handler_cont_helpers.hpp>
 #include <boost/asio/detail/handler_invoke_helpers.hpp>
 
+#include <beast/utility/noexcept.h>
+#include <functional>
+#include <memory>
+#include <beast/cxx14/type_traits.h> // <type_traits>
+
 #ifndef BEAST_ASIO_NO_ALLOCATE_SHARED
 #define BEAST_ASIO_NO_ALLOCATE_SHARED 0
 #endif
@@ -260,9 +262,7 @@ public:
 //------------------------------------------------------------------------------
 
 /** Handler shared reference that provides io_service execution guarantees. */
-template <
-    class Signature
->
+template <class Signature>
 class shared_handler
 {
 private:
@@ -318,6 +318,7 @@ public:
     operator= (std::nullptr_t)
     {
         m_ptr = nullptr;
+        return *this;
     }
 
     shared_handler&
@@ -327,15 +328,17 @@ public:
         return *this;
     }
 
-    bool
-    empty() const
+    shared_handler&
+    operator= (shared_handler&& rhs)
     {
-        return ! m_ptr.operator bool();
+        m_ptr = std::move (rhs.m_ptr);
+        return *this;
     }
 
-    operator bool() const
+    explicit
+    operator bool() const noexcept
     {
-        return !empty();
+        return m_ptr.operator bool();
     }
 
     void

src/beast/beast/asio/socket_wrapper.h

@@ -20,8 +20,10 @@
 #ifndef BEAST_ASIO_SOCKET_WRAPPER_H_INCLUDED
 #define BEAST_ASIO_SOCKET_WRAPPER_H_INCLUDED
 
-#include "abstract_socket.h"
-#include "bind_handler.h"
+#include <beast/asio/abstract_socket.h>
+#include <beast/asio/bind_handler.h>
+
+#include <beast/utility/noexcept.h>
 
 namespace beast {
 namespace asio {
@@ -225,14 +227,9 @@ private:
 
     boost::asio::io_service& get_io_service () override
     {
-#if 0
-        // Apparently has_get_io_service always results in false
         return get_io_service (
             Enabled <has_get_io_service <this_layer_type,
                 boost::asio::io_service&()> > ());
-#else
-        return get_io_service (std::true_type ());
-#endif
     }
 
     boost::asio::io_service& get_io_service (

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

@@ -17,42 +17,39 @@
 */
 //==============================================================================
 
-#include "BeastConfig.h"
+// LIBS: boost_system
 
-#include "../../../modules/beast_core/beast_core.h" // for UnitTest
+#if BEAST_INCLUDE_BEASTCONFIG
+#include <BeastConfig.h>
+#endif
 
-#include "../bind_handler.h"
+#include <beast/unit_test/suite.h>
+
+#include <beast/asio/bind_handler.h>
 
 #include <functional>
 
 namespace beast {
 namespace asio {
 
-class bind_handler_Tests : public UnitTest
+class bind_handler_test : public unit_test::suite
 {
 public:
     static void foo (int)
     {
     }
 
-    void runTest()
+    void run()
     {
-        beginTestCase ("call");
-
-        auto f (bind_handler (std::bind (&foo, std::placeholders::_1),
+        auto f (bind_handler (
+            std::bind (&foo, std::placeholders::_1),
             42));
-
         f();
-
         pass();
     }
-
-    bind_handler_Tests() : UnitTest ("bind_handler", "beast", runManual)
-    {
-    }
 };
 
-static bind_handler_Tests bind_handler_tests;
+BEAST_DEFINE_TESTSUITE(bind_handler,asio,beast);
 
 }
 }

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

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

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

@@ -17,11 +17,13 @@
 */
 //==============================================================================
 
-#include "BeastConfig.h"
+#if BEAST_INCLUDE_BEASTCONFIG
+#include <BeastConfig.h>
+#endif
 
-#include "../../../modules/beast_core/beast_core.h" // for UnitTest
+#include <beast/unit_test/suite.h>
 
-#include "../shared_handler.h"
+#include <beast/asio/shared_handler.h>
 
 // Disables is_constructible tests for std::function
 // Visual Studio std::function fails the is_constructible tests
@@ -35,7 +37,7 @@
 
 namespace beast {
 
-class shared_handler_Tests : public UnitTest
+class shared_handler_test : public unit_test::suite
 {
 public:
     struct test_results
@@ -137,10 +139,8 @@ public:
         async_op (handler);
     }
 
-    void runTest()
+    void run()
     {
-        beginTestCase ("hooks");
-
     #if ! BEAST_NO_STD_FUNCTION_CONSTRUCTIBLE
         static_assert (! std::is_constructible <
             std::function <void(void)>, int&&>::value,
@@ -228,12 +228,8 @@ public:
             expect (r.cont);
         }
     }
-
-    shared_handler_Tests() : UnitTest ("shared_handler", "beast")
-    {
-    }
 };
 
-static shared_handler_Tests shared_handler_tests;
+BEAST_DEFINE_TESTSUITE(shared_handler,asio,beast);
 
 }

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

@@ -17,11 +17,13 @@
 */
 //==============================================================================
 
-#include "BeastConfig.h"
+#if BEAST_INCLUDE_BEASTCONFIG
+#include <BeastConfig.h>
+#endif
 
-#include "../../../modules/beast_core/beast_core.h" // for UnitTest
+#include <beast/unit_test/suite.h>
 
-#include "../wrap_handler.h"
+#include <beast/asio/wrap_handler.h>
 
 #include <boost/version.hpp>
 
@@ -36,7 +38,7 @@ namespace asio {
 
 // Displays the order of destruction of parameters in the bind wrapper
 //
-class boost_bind_Tests : public UnitTest
+class boost_bind_test : public unit_test::suite
 {
 public:
     struct Result
@@ -82,10 +84,8 @@ public:
     {
     }
 
-    void runTest()
+    void run()
     {
-        beginTestCase ("order");
-        
         {
             Result r;
             {
@@ -94,7 +94,8 @@ public:
                     Arg (r, "two"),
                     Arg (r, "three"));
             }
-            logMessage (std::string ("boost::bind (") + r.text + ")");
+            log <<
+                std::string ("boost::bind (") + r.text + ")";
         }
 
         {
@@ -105,22 +106,20 @@ public:
                     Arg (r, "two"),
                     Arg (r, "three"));
             }
-            logMessage (std::string ("std::bind (") + r.text + ")");
+            
+            log <<
+                std::string ("std::bind (") + r.text + ")";
         }
 
         pass();
     }
-
-    boost_bind_Tests() : UnitTest ("bind", "beast", runManual)
-    {
-    }
 };
 
-static boost_bind_Tests boost_bind_tests;
+BEAST_DEFINE_TESTSUITE(boost_bind,asio,beast);
 
 //------------------------------------------------------------------------------
 
-class wrap_handler_handler_Tests : public UnitTest
+class wrap_handler_test : public unit_test::suite
 {
 public:
     struct test_results
@@ -216,10 +215,8 @@ public:
         return boost_asio_handler_cont_helpers::is_continuation (handler);
     }
 
-    void runTest()
+    void run()
     {
-        beginTestCase ("hooks");
-
         // Hooks called when using the raw handler
         {
             test_results r;
@@ -274,13 +271,9 @@ public:
             expect (f.call);
         }
     }
-
-    wrap_handler_handler_Tests() : UnitTest ("wrap_handler", "beast")
-    {
-    }
 };
 
-static wrap_handler_handler_Tests wrap_handler_handler_tests;
+BEAST_DEFINE_TESTSUITE(wrap_handler,asio,beast);
 
 }
 }

src/beast/beast/asio/wrap_handler.h

@@ -24,7 +24,7 @@
 #include <boost/asio/detail/handler_cont_helpers.hpp>
 #include <boost/asio/detail/handler_invoke_helpers.hpp>
 
-#include <type_traits>
+#include <beast/cxx14/type_traits.h> // <type_traits>
 #include <utility>
 
 namespace beast {

src/beast/beast/boost/Boost.unity.cpp

@@ -17,9 +17,11 @@
 */
 //==============================================================================
 
-#include "BeastConfig.h"
+#if BEAST_INCLUDE_BEASTCONFIG
+#include <BeastConfig.h>
+#endif
 
-#include "ErrorCode.h"
+#include <beast/boost/ErrorCode.h>
 
 namespace detail {
 

src/beast/beast/chrono/CPUMeter.h

@@ -1,159 +0,0 @@
-//------------------------------------------------------------------------------
-/*
-    This file is part of Beast: https://github.com/vinniefalco/Beast
-    Copyright 2013, Vinnie Falco <vinnie.falco@gmail.com>
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose  with  or without fee is hereby granted, provided that the above
-    copyright notice and this permission notice appear in all copies.
-
-    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
-    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
-    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-*/
-//==============================================================================
-
-#ifndef BEAST_CHRONO_CPUMETER_H_INCLUDED
-#define BEAST_CHRONO_CPUMETER_H_INCLUDED
-
-#include "RelativeTime.h"
-#include "ScopedTimeInterval.h"
-#include "../threads/SharedData.h"
-#include "../Atomic.h"
-
-namespace beast {
-
-/** Measurements of CPU utilization. */
-class CPUMeter
-{
-private:
-    struct MeasureIdle
-    {
-        explicit MeasureIdle (CPUMeter& meter)
-            : m_meter (&meter)
-            { }
-        void operator() (RelativeTime const& interval) const
-            { m_meter->addIdleTime (interval); }
-        CPUMeter* m_meter;
-    };
-
-    struct MeasureActive
-    {
-        explicit MeasureActive (CPUMeter& meter)
-            : m_meter (&meter)
-            { }
-        void operator() (RelativeTime const& interval) const
-            { m_meter->addActiveTime (interval); }
-        CPUMeter* m_meter;
-    };
-
-    enum
-    {
-        // The amount of time an aggregate must accrue before a swap
-        secondsPerAggregate     = 3
-
-        // The number of aggregates in the rolling history buffer
-        ,numberOfAggregates     = 20
-    };
-
-    // Aggregated sample data
-    struct Aggregate
-    {
-        RelativeTime idle;
-        RelativeTime active;
-
-        // Returns the total number of seconds in the aggregate
-        double seconds () const
-            { return idle.inSeconds() + active.inSeconds(); }
-
-        // Reset the accumulated times
-        void clear ()
-            { idle = RelativeTime (0); active = RelativeTime (0); }
-
-        Aggregate& operator+= (Aggregate const& other)
-            { idle += other.idle; active += other.active; return *this; }
-
-        Aggregate& operator-= (Aggregate const& other)
-            { idle -= other.idle; active -= other.active; return *this; }
-    };
-
-    struct State
-    {
-        State () : index (0)
-        {
-        }
-
-        // Returns a reference to the current aggregate
-        Aggregate& front ()
-        {
-            return history [index];
-        }
-
-        // Checks the current aggregate to see if we should advance
-        void update()
-        {
-            if (front().seconds() >= secondsPerAggregate)
-                advance();
-        }
-
-        // Advance the index in the rolling history
-        void advance ()
-        {
-            usage += history [index];
-            index = (index+1) % numberOfAggregates;
-            usage -= history [index];
-            history [index].clear ();
-        }
-
-        // Index of the current aggregate we are accumulating
-        int index;
-
-        // Delta summed usage over the entire history buffer
-        Aggregate usage;
-
-        // The rolling history buffer
-        Aggregate history [numberOfAggregates];
-    };
-
-    typedef SharedData <State> SharedState;
-
-    SharedState m_state;
-
-    void addIdleTime (RelativeTime const& interval)
-    {
-        SharedState::Access state (m_state);
-        state->front().idle += interval;
-        state->update();
-    }
-
-    void addActiveTime (RelativeTime const& interval)
-    {
-        SharedState::Access state (m_state);
-        state->front().active += interval;
-        state->update();
-    }
-
-public:
-    /** The type of container that measures idle time. */
-    typedef ScopedTimeInterval <MeasureIdle>    ScopedIdleTime;
-    typedef ScopedTimeInterval <MeasureActive>  ScopedActiveTime;
-
-    /** Returns the fraction of time that the CPU is being used. */
-    double getUtilization () const
-    {
-        SharedState::ConstAccess state (m_state);
-
-        double const seconds (state->usage.seconds());
-        if (seconds > 0)
-            return (state->usage.active.inSeconds() / seconds);
-        return 0;
-    }
-};
-
-}
-
-#endif

src/beast/beast/chrono/Chrono.cpp

@@ -1,30 +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 "BeastConfig.h"
-
-#include "../Config.h"
-#include "../../modules/beast_core/beast_core.h" // for UnitTest
-
-#include "impl/abstract_clock.cpp"
-#include "impl/chrono_io.cpp"
-#include "impl/basic_seconds_clock.cpp"
-
-#include "impl/CPUMeter.cpp"
-#include "impl/RelativeTime.cpp"

src/beast/beast/chrono/Chrono.unity.cpp

@@ -17,26 +17,14 @@
 */
 //==============================================================================
 
-#if BEAST_USE_BOOST_FEATURES
-
-namespace boost
-{
-
-namespace placeholders
-{
-
-boost::arg<1> _1;
-boost::arg<2> _2;
-boost::arg<3> _3;
-boost::arg<4> _4;
-boost::arg<5> _5;
-boost::arg<6> _6;
-boost::arg<7> _7;
-boost::arg<8> _8;
-boost::arg<9> _9;
-
-}
-
-}
-
+#if BEAST_INCLUDE_BEASTCONFIG
+#include <BeastConfig.h>
 #endif
+
+#include <beast/Config.h>
+
+#include <beast/chrono/impl/chrono_io.cpp>
+#include <beast/chrono/impl/RelativeTime.cpp>
+
+#include <beast/chrono/tests/abstract_clock.test.cpp>
+#include <beast/chrono/tests/basic_seconds_clock.test.cpp>

src/beast/beast/chrono/RelativeTime.h

@@ -24,9 +24,10 @@
 #ifndef BEAST_CHRONO_RELATIVETIME_H_INCLUDED
 #define BEAST_CHRONO_RELATIVETIME_H_INCLUDED
 
-#include "../Config.h"
-#include "../strings/String.h"
+#include <beast/Config.h>
+#include <beast/strings/String.h>
 
+#include <beast/utility/noexcept.h>
 #include <string>
 #include <sstream>
 
@@ -40,7 +41,7 @@ namespace beast {
 
     If you need an absolute time, (i.e. a date + time), see the Time class.
 */
-class BEAST_API  RelativeTime
+class  RelativeTime
 {
 public:
     //==============================================================================
@@ -87,7 +88,7 @@ public:
     /** Creates a new RelativeTime object representing a number of milliseconds.
         @see seconds, minutes, hours, days, weeks
     */
-    static RelativeTime milliseconds (int64 milliseconds) noexcept;
+    static RelativeTime milliseconds (std::int64_t milliseconds) noexcept;
 
     /** Creates a new RelativeTime object representing a number of seconds.
         @see milliseconds, minutes, hours, days, weeks
@@ -118,7 +119,7 @@ public:
     /** Returns the number of milliseconds this time represents.
         @see milliseconds, inSeconds, inMinutes, inHours, inDays, inWeeks
     */
-    int64 inMilliseconds() const noexcept;
+    std::int64_t inMilliseconds() const noexcept;
 
     /** Returns the number of seconds this time represents.
         @see inMilliseconds, inMinutes, inHours, inDays, inWeeks

src/beast/beast/chrono/abstract_clock.h

@@ -21,8 +21,7 @@
 #define BEAST_CHRONO_ABSTRACT_CLOCK_H_INCLUDED
 
 #include <chrono>
-
-#include "chrono_io.h"
+#include <string>
 
 namespace beast {
 
@@ -74,9 +73,10 @@ public:
     /** Returns the current time. */
     virtual time_point now () const = 0;
 
+#if 0
     /** Convert the specified time point to a string. */
     /** @{ */
-    virtual std::string to_string (time_point const& tp) const = 0;
+    //virtual std::string to_string (time_point const& tp) const = 0;
 
     template <class Duration2>
     std::string to_string (
@@ -86,6 +86,7 @@ public:
             std::chrono::time_point_cast <Duration> (tp));
     }
     /** @} */
+#endif
 
     /** Returning elapsed ticks since the epoch. */
     rep elapsed () const
@@ -122,6 +123,7 @@ struct abstract_clock_wrapper
     : public basic_abstract_clock_wrapper <TrivialClock, Duration>
 {
     // generic conversion displays the duration
+    /*
     std::string to_string (typename basic_abstract_clock_wrapper <
         TrivialClock, Duration>::time_point const& tp) const
     {
@@ -129,6 +131,7 @@ struct abstract_clock_wrapper
         ss << tp.time_since_epoch();
         return ss.str ();
     }
+    */
 };
 
 /*

src/beast/beast/chrono/abstract_clock_io.h

@@ -17,23 +17,20 @@
 */
 //==============================================================================
 
-#ifndef BEAST_TYPE_TRAITS_INTEGRALCONSTANT_H_INCLUDED
-#define BEAST_TYPE_TRAITS_INTEGRALCONSTANT_H_INCLUDED
+#ifndef BEAST_CHRONO_ABSTRACT_CLOCK_IO_H_INCLUDED
+#define BEAST_CHRONO_ABSTRACT_CLOCK_IO_H_INCLUDED
+
+#include <beast/chrono/chrono_io.h>
 
 namespace beast {
 
-// ideas from boost
-
-template <class T, T val>
-struct IntegralConstant
+template <class CharT, class Traits, class Duration, class Resolution>
+std::basic_ostream <CharT, Traits>&
+operator<< (std::basic_ostream <CharT, Traits>& os,
+    std::chrono::time_point <abstract_clock <Resolution>, Duration> const& tp)
 {
-   typedef IntegralConstant <T, val> type;
-   typedef T                         value_type;
-   static const T value = val;
-};
-
-typedef IntegralConstant <bool, true>  TrueType;
-typedef IntegralConstant <bool, false> FalseType;
+    return os << tp.time_since_epoch() << " since epoch";
+}
 
 }
 

src/beast/beast/chrono/basic_seconds_clock.h

@@ -20,40 +20,14 @@
 #ifndef BEAST_CHRONO_BASIC_SECONDS_CLOCK_H_INCLUDED
 #define BEAST_CHRONO_BASIC_SECONDS_CLOCK_H_INCLUDED
 
+#include <beast/chrono/chrono_util.h>
+
 #include <algorithm>
 #include <chrono>
-
-#ifndef BEAST_BASIC_SECONDS_CLOCK_BOOST_WORKAROUND
-# ifdef _MSC_VER
-// Visual Studio 2012, 2013 have a bug in std::thread that
-// causes a hang on exit, in the library function atexit()
-#  if BEAST_USE_BOOST_FEATURES
-#   define BEAST_BASIC_SECONDS_CLOCK_BOOST_WORKAROUND 1
-#  else
-#   define BEAST_BASIC_SECONDS_CLOCK_BOOST_WORKAROUND 0
-#  endif
-# else
-#  define BEAST_BASIC_SECONDS_CLOCK_BOOST_WORKAROUND 0
-# endif
-#endif
-
-#if BEAST_BASIC_SECONDS_CLOCK_BOOST_WORKAROUND
-# include <boost/version.hpp>
-# if BOOST_VERSION >= 105500
-#  include <boost/thread/thread.hpp>
-#  include <boost/thread/mutex.hpp>
-#  include <boost/thread/condition_variable.hpp>
-#  include <boost/chrono.hpp>
-# else
-#  error "Boost version 1.55.0 or later is required"
-# endif
-#else
-# include <condition_variable>
-# include <mutex>
-# include <thread>
-#endif
-
-#include "../chrono/chrono_util.h"
+#include <condition_variable>
+#include <mutex>
+#include <thread>
+#include <vector>
 
 namespace beast {
 
@@ -71,15 +45,6 @@ public:
 class seconds_clock_thread
 {
 public:
-#if BEAST_BASIC_SECONDS_CLOCK_BOOST_WORKAROUND
-    typedef boost::mutex mutex;
-    typedef boost::condition_variable cond_var;
-    typedef boost::lock_guard <mutex> lock_guard;
-    typedef boost::unique_lock <mutex> unique_lock;
-    typedef boost::chrono::steady_clock clock_type;
-    typedef boost::chrono::seconds seconds;
-    typedef boost::thread thread;
-#else
     typedef std::mutex mutex;
     typedef std::condition_variable cond_var;
     typedef std::lock_guard <mutex> lock_guard;
@@ -87,7 +52,6 @@ public:
     typedef std::chrono::steady_clock clock_type;
     typedef std::chrono::seconds seconds;
     typedef std::thread thread;
-#endif
     typedef std::vector <seconds_clock_worker*> workers;
 
     bool m_stop;
@@ -105,12 +69,7 @@ public:
 
     ~seconds_clock_thread ()
     {
-        {
-            lock_guard lock (m_mutex);
-            m_stop = true;
-        }
-        m_cond.notify_all();
-        m_thread.join ();
+        stop();
     }
 
     void add (seconds_clock_worker& w)
@@ -126,7 +85,20 @@ public:
             m_workers.begin (), m_workers.end(), &w));
     }
 
-    void run ()
+    void stop()
+    {
+        if (m_thread.joinable())
+        {
+            {
+                lock_guard lock (m_mutex);
+                m_stop = true;
+            }
+            m_cond.notify_all();
+            m_thread.join();
+        }
+    }
+
+    void run()
     {
         unique_lock lock (m_mutex);;
 
@@ -156,6 +128,20 @@ public:
 
 //------------------------------------------------------------------------------
 
+/** Called before main exits to terminate the utility thread.
+    This is a workaround for Visual Studio 2013:
+    http://connect.microsoft.com/VisualStudio/feedback/details/786016/creating-a-global-c-object-that-used-thread-join-in-its-destructor-causes-a-lockup
+    http://stackoverflow.com/questions/10915233/stdthreadjoin-hangs-if-called-after-main-exits-when-using-vs2012-rc
+*/
+inline
+void
+basic_seconds_clock_main_hook()
+{
+#ifdef _MSC_VER
+    detail::seconds_clock_thread::instance().stop();
+#endif
+}
+
 /** A clock whose minimum resolution is one second.
     The purpose of this class is to optimize the performance of the now()
     member function call. It uses a dedicated thread that wakes up at least

src/beast/beast/chrono/chrono_io.h

@@ -27,8 +27,9 @@
 #ifndef BEAST_CHRONO_CHRONO_IO_H_INCLUDED
 #define BEAST_CHRONO_CHRONO_IO_H_INCLUDED
 
-#include "../Config.h"
+#include <beast/Config.h>
 
+#include <beast/utility/noexcept.h>
 #include <ctime>
 #include <locale>
 
@@ -155,7 +156,7 @@ template <class charT, class Traits, class Duration>
 */
 
 #include <chrono>
-#include "ratio_io.h"
+#include <beast/chrono/ratio_io.h>
 
 //_LIBCPP_BEGIN_NAMESPACE_STD
 namespace std {

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

@@ -21,7 +21,7 @@
 */
 //==============================================================================
 
-#include "../RelativeTime.h"
+#include <beast/chrono/RelativeTime.h>
 
 // VFALCO TODO Migrate the localizable strings interfaces for this file
 
@@ -54,7 +54,7 @@ RelativeTime RelativeTime::milliseconds (const int milliseconds) noexcept
     return RelativeTime (milliseconds * 0.001);
 }
 
-RelativeTime RelativeTime::milliseconds (const int64 milliseconds) noexcept
+RelativeTime RelativeTime::milliseconds (const std::int64_t milliseconds) noexcept
 {
     return RelativeTime (milliseconds * 0.001);
 }
@@ -86,9 +86,9 @@ RelativeTime RelativeTime::weeks (const RelativeTime::value_type numberOfWeeks)
 
 //==============================================================================
 
-int64 RelativeTime::inMilliseconds() const noexcept
+std::int64_t RelativeTime::inMilliseconds() const noexcept
 {
-    return (int64) (numSeconds * 1000.0);
+    return (std::int64_t) (numSeconds * 1000.0);
 }
 
 RelativeTime::value_type RelativeTime::inMinutes() const noexcept
@@ -301,7 +301,7 @@ static double monotonicCurrentTimeInSeconds()
 			{
 				numerator   = timebase.numer;
                 // VFALCO NOTE I don't understand this code
-				//denominator = timebase.denom * (uint64) 1000000 * 1000.0;
+				//denominator = timebase.denom * (std::uint64_t) 1000000 * 1000.0;
                 denominator = timebase.denom * 1000000000.0;
 			}
 			

src/beast/beast/chrono/impl/chrono_io.cpp

@@ -24,7 +24,7 @@
 //  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt).
 
-#include "../chrono_io.h"
+#include <beast/chrono/chrono_io.h>
 
 //_LIBCPP_BEGIN_NAMESPACE_STD
 namespace std {

src/beast/beast/chrono/manual_clock.h

@@ -20,7 +20,7 @@
 #ifndef BEAST_CHRONO_MANUAL_CLOCK_H_INCLUDED
 #define BEAST_CHRONO_MANUAL_CLOCK_H_INCLUDED
 
-#include "abstract_clock.h"
+#include <beast/chrono/abstract_clock.h>
 
 namespace beast {
 
@@ -53,12 +53,14 @@ public:
         return m_now;
     }
 
+#if 0
     std::string to_string (time_point const& tp) const
     {
         std::stringstream ss;
         ss << tp.time_since_epoch() << " from start";
         return ss.str ();
     }
+#endif
 
     /** Set the current time of the manual clock.
         Precondition:

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

@@ -17,17 +17,21 @@
 */
 //==============================================================================
 
-#include "../abstract_clock.h"
-#include "../manual_clock.h"
+// MODULES: ../impl/chrono_io.cpp
 
-#include <thread>
+#include <beast/chrono/abstract_clock.h>
+#include <beast/chrono/abstract_clock_io.h>
+#include <beast/chrono/manual_clock.h>
+
+#include <beast/unit_test/suite.h>
 
-#include <string>
 #include <sstream>
+#include <string>
+#include <thread>
 
 namespace beast {
 
-class abstract_clock_tests : public UnitTest
+class abstract_clock_test : public unit_test::suite
 {
 public:
     void test (abstract_clock <std::chrono::seconds>& c)
@@ -40,10 +44,10 @@ public:
 
             std::stringstream ss;
             ss <<
-                "t1= " << c.to_string (t1) <<
-                ", t2= " << c.to_string (t2) <<
+                "t1= " << t1.time_since_epoch() <<
+                ", t2= " << t2.time_since_epoch() <<
                 ", elapsed= " << (t2 - t1);
-            logMessage (ss.str());
+            log << ss.str();
         }
     }
 
@@ -54,45 +58,38 @@ public:
 
         std::stringstream ss;
 
-        ss << "now() = " << c.to_string (c.now ()) << std::endl;
+        ss << "now() = " << c.now () << std::endl;
 
         c.set (clock_type::time_point (std::chrono::seconds (1)));
-        ss << "now() = " << c.to_string (c.now ()) << std::endl;
+        ss << "now() = " << c.now () << std::endl;
 
         c.set (clock_type::time_point (std::chrono::seconds (2)));
-        ss << "now() = " << c.to_string (c.now ()) << std::endl;
+        ss << "now() = " << c.now () << std::endl;
 
-        logMessage (ss.str());
+        log << ss.str();
     }
 
-    void runTest ()
+    void run ()
     {
-        beginTestCase ("Syntax");
-
-        logMessage ("steady_clock");
+        log << "steady_clock";
         test (get_abstract_clock <std::chrono::steady_clock,
             std::chrono::seconds> ());
 
-        logMessage ("system_clock");
+        log << "system_clock";
         test (get_abstract_clock <std::chrono::system_clock,
             std::chrono::seconds> ());
 
-        logMessage ("high_resolution_clock");
+        log << "high_resolution_clock";
         test (get_abstract_clock <std::chrono::high_resolution_clock,
             std::chrono::seconds> ());
 
-        logMessage ("manual_clock");
+        log << "manual_clock";
         test_manual ();
 
         pass ();
     }
-
-    abstract_clock_tests ()
-        : UnitTest ("abstract_clock", "beast", runManual)
-    {
-    }
 };
 
-static abstract_clock_tests abstract_clock_tests_;
+BEAST_DEFINE_TESTSUITE(abstract_clock,chrono,beast);
 
 }

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

@@ -0,0 +1,40 @@
+//------------------------------------------------------------------------------
+/*
+    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/unit_test/suite.h>
+
+#include <beast/chrono/basic_seconds_clock.h>
+
+namespace beast {
+
+class basic_seconds_clock_test : public unit_test::suite
+{
+public:
+    void
+    run()
+    {
+        basic_seconds_clock <
+            std::chrono::steady_clock>::now ();
+        pass ();
+    }
+};
+
+BEAST_DEFINE_TESTSUITE(basic_seconds_clock,chrono,beast);
+
+}

src/beast/beast/config/CompilerConfig.h

@@ -24,13 +24,8 @@
 #ifndef BEAST_CONFIG_COMPILERCONFIG_H_INCLUDED
 #define BEAST_CONFIG_COMPILERCONFIG_H_INCLUDED
 
-// This file has to work when included in a C source file.
-
-#ifndef BEAST_CONFIG_PLATFORMCONFIG_H_INCLUDED
-#error "PlatformConfig.h must come first!"
-#endif
-
 #include <assert.h>
+#include <beast/config/PlatformConfig.h>
 
 // This file defines miscellaneous macros for debugging, assertions, etc.
 
@@ -42,13 +37,20 @@
 /** This macro defines the C calling convention used as the standard for Beast calls.
 */
 #if BEAST_MSVC
-# define BEAST_CALLTYPE   __stdcall
 # define BEAST_CDECL      __cdecl
 #else
-# define BEAST_CALLTYPE
 # define BEAST_CDECL
 #endif
 
+/** This macro fixes C++'s constexpr for VS2012, which doesn't understand it.
+*/
+#if BEAST_MSVC
+# define BEAST_CONSTEXPR const
+#else
+# define BEAST_CONSTEXPR constexpr
+#endif
+
+
 // Debugging and assertion macros
 
 #if BEAST_LOG_ASSERTIONS || BEAST_DEBUG
@@ -148,16 +150,6 @@ extern void beast_reportFatalError (char const* message, char const* fileName, i
 
 //------------------------------------------------------------------------------
 
-/** This macro can be added to class definitions to disable the use of new/delete to
-    allocate the object on the heap, forcing it to only be used as a stack or member variable.
-*/
-#define BEAST_PREVENT_HEAP_ALLOCATION \
-   private: \
-    static void* operator new (size_t); \
-    static void operator delete (void*);
-
-//------------------------------------------------------------------------------
-
 #if ! DOXYGEN
  #define BEAST_JOIN_MACRO_HELPER(a, b) a ## b
  #define BEAST_STRINGIFY_MACRO_HELPER(a) #a
@@ -175,19 +167,6 @@ extern void beast_reportFatalError (char const* message, char const* fileName, i
 
 //------------------------------------------------------------------------------
 
-#if BEAST_DEBUG || DOXYGEN
-/** A platform-independent way of forcing an inline function.
-    Use the syntax: @code
-    forcedinline void myfunction (int x)
-    @endcode
-*/
-# define forcedinline inline
-#elif BEAST_MSVC
-# define forcedinline __forceinline
-#else
-# define forcedinline inline __attribute__((always_inline))
-#endif
-
 #if BEAST_MSVC || DOXYGEN
 /** This can be placed before a stack or member variable declaration to tell
     the compiler to align it to the specified number of bytes.
@@ -278,35 +257,10 @@ extern void beast_reportFatalError (char const* message, char const* fileName, i
 # define BEAST_MOVE_CAST(type) type
 #endif
 
-//------------------------------------------------------------------------------
-
-// Declare some fake versions of nullptr and noexcept, for older compilers:
-#if ! (DOXYGEN || BEAST_COMPILER_SUPPORTS_NOEXCEPT)
-# ifdef noexcept
-#  undef noexcept
-# endif
-# define noexcept  throw()
-# if defined (_MSC_VER) && _MSC_VER > 1600
-#  define _ALLOW_KEYWORD_MACROS 1 // (to stop VC2012 complaining)
-# endif
-#endif
-
-#if ! (DOXYGEN || BEAST_COMPILER_SUPPORTS_NULLPTR)
-#ifdef nullptr
-#undef nullptr
-#endif
-#define nullptr (0)
-#endif
-
-#if ! (DOXYGEN || BEAST_COMPILER_SUPPORTS_OVERRIDE_AND_FINAL)
-#undef  override
-#define override
-#endif
-
 #ifdef __cplusplus
 namespace beast {
 bool beast_isRunningUnderDebugger();
-void logAssertion (char const* file, int line) noexcept;
+void logAssertion (char const* file, int line);
 }
 #endif
 

src/beast/beast/config/ConfigCheck.h

@@ -20,25 +20,6 @@
 #ifndef BEAST_CONFIG_CONFIGCHECK_H_INCLUDED
 #define BEAST_CONFIG_CONFIGCHECK_H_INCLUDED
 
-// This file makes sure that BeastConfig.h was included.
-// It also sets defaults for all config options.
-
-/*  If you fail to make sure that all your compile units are building Beast with
-    the same set of option flags, then there's a risk that different compile
-    units will treat the classes as having different memory layouts, leading to
-    very nasty memory corruption errors when they all get linked together.
-    That's why it's best to always include the BeastConfig.h file before any
-    beast headers.
-*/
-#ifndef BEAST_BEASTCONFIG_H_INCLUDED
-# ifdef _MSC_VER
-#  pragma message ("Have you included your BeastConfig.h file before including the Beast headers?")
-# else
-#  warning "Have you included your BeastConfig.h file before including the Beast headers?"
-# endif
-# error "BeastConfig.h must be included before any Beast headers!"
-#endif
-
 //
 // Apply sensible defaults for the configuration settings
 //

src/beast/beast/config/ContractChecks.h

@@ -24,13 +24,10 @@
 
 #if defined (fatal_error) || \
     defined (fatal_condition) || \
-    defined (fatal_assert) || \
     defined (meets_condition) || \
     defined (meets_precondition) || \
     defined (meets_postcondition) || \
     defined (meets_invariant) || \
-    defined (check_precondition) || \
-    defined (check_postcondition) || \
     defined (check_invariant)
 #error "Programming by contract macros cannot be overriden!"
 #endif
@@ -52,13 +49,6 @@
     (((!!(condition)) || (beast_reportFatalError ( \
         category " '" BEAST_STRINGIFY(condition) "' failed.", __FILE__, __LINE__), 0)))
 
-/** Replacement for assert which generates a fatal error if the condition is false.
-    The condition is always evaluated regardless of compilation settings.
-    Meets this declaration syntax:
-    @code inline void fatal_assert (bool condition); @endcode
-*/
-#define fatal_assert(condition) fatal_condition(condition,"Assertion")
-
 /** Reports a fatal error message type if the condition is false
     The condition is always evaluated regardless of settings.
     Meets this declaration syntax:
@@ -87,12 +77,8 @@
 */
 /** @{ */
 #if ! BEAST_DISABLE_CONTRACT_CHECKS
-# define check_precondition(condition)  meets_precondition(condition)
-# define check_postcondition(condition) meets_postcondition(condition)
 # define check_invariant(condition)     meets_invariant(condition)
 #else
-# define check_precondition(condition)  ((void)0)
-# define check_postcondition(condition) ((void)0)
 # define check_invariant(condition)     ((void)0)
 #endif
 /** @} */

src/beast/beast/config/PlatformConfig.h

@@ -101,10 +101,6 @@
     #define BEAST_DEBUG 1
   #endif
 
-  #if ! (defined (DEBUG) || defined (_DEBUG) || defined (NDEBUG) || defined (_NDEBUG))
-    #warning "Neither NDEBUG or DEBUG has been defined - you should set one of these to make it clear whether this is a release build,"
-  #endif
-
   #ifdef __LITTLE_ENDIAN__
     #define BEAST_LITTLE_ENDIAN 1
   #else
@@ -213,4 +209,3 @@
 #define BEAST_FILEANDLINE_ __FILE__ "(" BEAST_PP_STR1_(__LINE__) "): warning:"
 
 #endif
-

src/beast/beast/config/StandardConfig.h

@@ -35,28 +35,28 @@
 #endif
 
 #if BEAST_USE_INTRINSICS
-# include <intrin.h>
+#include <intrin.h>
 #endif
 
 #if BEAST_MAC || BEAST_IOS
-# include <libkern/OSAtomic.h>
+#include <libkern/OSAtomic.h>
 #endif
 
 #if BEAST_LINUX
-# include <signal.h>
+#include <signal.h>
 # if __INTEL_COMPILER
 #  if __ia64__
-#   include <ia64intrin.h>
+#include <ia64intrin.h>
 #  else
-#   include <ia32intrin.h>
+#include <ia32intrin.h>
 #  endif
 # endif
 #endif
 
 #if BEAST_MSVC && BEAST_DEBUG
-# include <crtdbg.h>
-# include <stdlib.h>
-# include <malloc.h>
+#include <crtdbg.h>
+#include <stdlib.h>
+#include <malloc.h>
 #endif
 
 #if BEAST_MSVC
@@ -74,40 +74,4 @@
 #undef max
 #undef min
 
-//------------------------------------------------------------------------------
-
-// DLL building settings on Windows
-//
-// VFALCO TODO Deprecate this
-//
-#if BEAST_MSVC
- #ifdef BEAST_DLL_BUILD
-  #define BEAST_API __declspec (dllexport)
-  #pragma warning (disable: 4251)
- #elif defined (BEAST_DLL)
-  #define BEAST_API __declspec (dllimport)
-  #pragma warning (disable: 4251)
- #endif
- #ifdef __INTEL_COMPILER
-  #pragma warning (disable: 1125) // (virtual override warning)
- #endif
-#elif defined (BEAST_DLL) || defined (BEAST_DLL_BUILD)
- #define BEAST_API __attribute__ ((visibility("default")))
-#endif
-
-//------------------------------------------------------------------------------
-
-#ifndef BEAST_API
-#define BEAST_API  /**< This macro is added to all beast public class declarations. */
-#endif
-
-#if BEAST_MSVC && BEAST_DLL_BUILD
-#define BEAST_PUBLIC_IN_DLL_BUILD(decl)  public: decl; private:
-#else
-#define BEAST_PUBLIC_IN_DLL_BUILD(decl)  decl;
-#endif
-
-/** This macro is added to all beast public function declarations. */
-#define BEAST_PUBLIC_FUNCTION        BEAST_API BEAST_CALLTYPE
-
 #endif

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

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

src/beast/beast/container/Container.cpp

@@ -1,25 +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 "BeastConfig.h"
-
-#include "impl/aged_associative_container.cpp"
-
-#include "tests/buffer_view.test.cpp"
-

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

@@ -17,10 +17,13 @@
 */
 //==============================================================================
 
-#ifndef BEAST_HTTP_H_INCLUDED
-#define BEAST_HTTP_H_INCLUDED
-
-#include "http/URL.h"
-#include "http/ParsedURL.h"
-
+#if BEAST_INCLUDE_BEASTCONFIG
+#include <BeastConfig.h>
 #endif
+
+#include <beast/container/impl/spookyv2.cpp>
+
+#include <beast/container/tests/aged_associative_container.test.cpp>
+#include <beast/container/tests/buffer_view.test.cpp>
+#include <beast/container/tests/hardened_hash.test.cpp>
+#include <beast/container/tests/hash_append.test.cpp>

src/beast/beast/container/aged_container_utility.h

@@ -20,7 +20,7 @@
 #ifndef BEAST_CONTAINER_AGED_CONTAINER_UTILITY_H_INCLUDED
 #define BEAST_CONTAINER_AGED_CONTAINER_UTILITY_H_INCLUDED
 
-#include "aged_container.h"
+#include <beast/container/aged_container.h>
 
 #include <type_traits>