Set version to 0.50.0

The existing configuration includes 512 and 1024 bit DH
parameters and supports ciphers such as RC4 and 3DES and
hash algorithms like SHA-1 which are no longer considered
secure.

Going forward, use only 2048-bit DH parameters and define
a new default set of modern ciphers to use:

    HIGH:!aNULL:!MD5:!DSS:!SHA1:!3DES:!RC4:!EXPORT:!DSS

Additionally, allow administrators who wish to have different
settings to configure custom global and per-port ciphers suites
in the configuration file using the `ssl_ciphers` directive.

.gitignore

@@ -1,5 +1,9 @@
 # .gitignore
 
+bin/boostbook_catalog.xml
+bin/config.log
+bin/project-cache.jam
+
 # Ignore vim swap files.
 *.swp
 
@@ -73,10 +77,6 @@ DerivedData
 # Intel Parallel Studio 2013 XE
 My Amplifier XE Results - RippleD
 
-# KeyvaDB files
-*.key
-*.val
-
 # Compiler intermediate output
 /out.txt
 
@@ -85,3 +85,12 @@ rippled-build.log
 
 # Profiling data
 gmon.out
+
+Builds/VisualStudio2015/*.db
+Builds/VisualStudio2015/*.user
+Builds/VisualStudio2015/*.opendb
+Builds/VisualStudio2015/*.sdf
+
+# MSVC
+*.pdb
+.vs/

.gitmodules

@@ -0,0 +1,12 @@
+[submodule "docs/docca"]
+	path = docs/docca
+	url = https://github.com/vinniefalco/docca.git
+[submodule "src/nudb/extras/beast"]
+	path = src/nudb/extras/beast
+	url = https://github.com/vinniefalco/Beast.git
+[submodule "src/nudb/extras/rocksdb"]
+	path = src/nudb/extras/rocksdb
+	url = https://github.com/facebook/rocksdb.git
+[submodule "src/nudb/doc/docca"]
+	path = src/nudb/doc/docca
+	url = https://github.com/vinniefalco/docca.git

.travis.yml

@@ -3,72 +3,65 @@ language: cpp
 
 env:
   global:
+    - LLVM_VERSION=3.8.0
     # Maintenance note: to move to a new version
     # of boost, update both BOOST_ROOT and BOOST_URL.
     # Note that for simplicity, BOOST_ROOT's final
     # namepart must match the folder name internal
     # to boost's .tar.gz.
-    - BOOST_ROOT=$HOME/boost_1_59_0
-    - BOOST_URL='http://downloads.sourceforge.net/project/boost/boost/1.59.0/boost_1_59_0.tar.gz?r=http%3A%2F%2Fsourceforge.net%2Fprojects%2Fboost%2Ffiles%2Fboost%2F1.59.0%2Fboost_1_59_0.tar.gz%2Fdownload&ts=1441761349&use_mirror=skylineservers'
+    - LCOV_ROOT=$HOME/lcov
+    - BOOST_ROOT=$HOME/boost_1_60_0
+    - BOOST_URL='http://sourceforge.net/projects/boost/files/boost/1.60.0/boost_1_60_0.tar.gz'
 
-
-packages: &gcc5_pkgs
-  - gcc-5
-  - g++-5
-  - python-software-properties
-  - protobuf-compiler
-  - libprotobuf-dev
-  - libssl-dev
-  - libstdc++6
-  - binutils-gold
-  # Provides a backtrace if the unittests crash
-  - gdb
-
-packages: &clang36_pkgs
-  - clang-3.6
-  - g++-5
-  - python-software-properties
-  - protobuf-compiler
-  - libprotobuf-dev
-  - libssl-dev
-  - libstdc++6
-  - binutils-gold
-  # Provides a backtrace if the unittests crash
-  - gdb
+addons:
+  apt:
+    sources: ['ubuntu-toolchain-r-test']
+    packages:
+      - gcc-5
+      - g++-5
+      - python-software-properties
+      - protobuf-compiler
+      - libprotobuf-dev
+      - libssl-dev
+      - libstdc++6
+      - binutils-gold
+      # Provides a backtrace if the unittests crash
+      - gdb
 
 matrix:
   include:
+    # Default BUILD is "scons".
+
     - compiler: gcc
-      env: GCC_VER=5 TARGET=debug.nounity
-      addons: &ao_gcc5
-        apt:
-          sources: ['ubuntu-toolchain-r-test']
-          packages: *gcc5_pkgs
+      env: GCC_VER=5 BUILD=cmake TARGET=debug.nounity PATH=$PWD/cmake/bin:$PATH
 
     - compiler: gcc
       env: GCC_VER=5 TARGET=coverage
-      addons: *ao_gcc5
 
     - compiler: clang
-      env: GCC_VER=5 TARGET=debug CLANG_VER=3.6
-      addons: &ao_clang36
-        apt:
-          sources: ['ubuntu-toolchain-r-test', 'llvm-toolchain-precise-3.6']
-          packages: *clang36_pkgs
+      env: GCC_VER=5 TARGET=debug CLANG_VER=3.8 PATH=$PWD/llvm-$LLVM_VERSION/bin:$PATH
 
     - compiler: clang
-      env: GCC_VER=5 TARGET=debug.nounity CLANG_VER=3.6
-      addons: *ao_clang36
+      env: GCC_VER=5 TARGET=debug.nounity CLANG_VER=3.8 PATH=$PWD/llvm-$LLVM_VERSION/bin:$PATH
+
+    # The clang cmake builds do not link.
+    # - compiler: clang
+    #   env: GCC_VER=5 BUILD=cmake TARGET=debug CLANG_VER=3.8 PATH=$PWD/llvm-$LLVM_VERSION/bin:$PWD/cmake/bin:$PATH
+
+    # - compiler: clang
+    #   env: GCC_VER=5 BUILD=cmake TARGET=debug.nounity CLANG_VER=3.8 PATH=$PWD/llvm-$LLVM_VERSION/bin:$PWD/cmake/bin:$PATH
 
 cache:
   directories:
   - $BOOST_ROOT
+  - llvm-$LLVM_VERSION
+  - cmake
 
 before_install:
   - bin/ci/ubuntu/install-dependencies.sh
 
 script:
-  - bin/ci/ubuntu/build-and-test.sh
+  - travis_retry bin/ci/ubuntu/build-and-test.sh
 
 notifications:
   email:

Builds/ArchLinux/PKGBUILD

@@ -9,7 +9,6 @@ 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')
@@ -26,8 +25,6 @@ build() {
 
 check() {
 	cd "$srcdir/$pkgname"
-	npm install
-	npm test
 	build/rippled --unittest
 }
 

Builds/CMake/CMakeFuncs.cmake

@@ -0,0 +1,658 @@
+# This is a set of common functions and settings for rippled
+# and derived products.
+
+############################################################
+
+cmake_minimum_required(VERSION 3.1.0)
+
+if("${CMAKE_SOURCE_DIR}" STREQUAL "${CMAKE_BINARY_DIR}")
+  message(WARNING "Builds are strongly discouraged in "
+    "${CMAKE_SOURCE_DIR}.")
+endif()
+
+macro(parse_target)
+
+  if (NOT target AND NOT CMAKE_BUILD_TYPE)
+    if (APPLE)
+      set(target clang.debug)
+    elseif(WIN32)
+      set(target msvc)
+    else()
+      set(target gcc.debug)
+    endif()
+  endif()
+
+  if (target)
+    # Parse the target
+    set(remaining ${target})
+    while (remaining)
+      # get the component up to the next dot or end
+      string(REGEX REPLACE "^\\.?([^\\.]+).*$" "\\1" cur_component ${remaining})
+      string(REGEX REPLACE "^\\.?[^\\.]+(.*$)" "\\1" remaining ${remaining})
+
+      if (${cur_component} STREQUAL gcc)
+        if (DEFINED ENV{GNU_CC})
+          set(CMAKE_C_COMPILER $ENV{GNU_CC})
+        elseif ($ENV{CXX} MATCHES .*gcc.*)
+          set(CMAKE_CXX_COMPILER $ENV{CC})
+        else()
+          find_program(CMAKE_C_COMPILER gcc)
+        endif()
+
+        if (DEFINED ENV{GNU_CXX})
+          set(CMAKE_C_COMPILER $ENV{GNU_CXX})
+        elseif ($ENV{CXX} MATCHES .*g\\+\\+.*)
+          set(CMAKE_C_COMPILER $ENV{CC})
+        else()
+          find_program(CMAKE_CXX_COMPILER g++)
+        endif()
+      endif()
+
+      if (${cur_component} STREQUAL clang)
+        if (DEFINED ENV{CLANG_CC})
+          set(CMAKE_C_COMPILER $ENV{CLANG_CC})
+        elseif ($ENV{CXX} MATCHES .*clang.*)
+          set(CMAKE_CXX_COMPILER $ENV{CC})
+        else()
+          find_program(CMAKE_C_COMPILER clang)
+        endif()
+
+        if (DEFINED ENV{CLANG_CXX})
+          set(CMAKE_C_COMPILER $ENV{CLANG_CXX})
+        elseif ($ENV{CXX} MATCHES .*clang.*)
+          set(CMAKE_C_COMPILER $ENV{CC})
+        else()
+          find_program(CMAKE_CXX_COMPILER clang++)
+        endif()
+      endif()
+
+      if (${cur_component} STREQUAL msvc)
+        # TBD
+      endif()
+
+      if (${cur_component} STREQUAL unity)
+        set(unity true)
+        set(nonunity false)
+      endif()
+
+      if (${cur_component} STREQUAL nounity)
+        set(unity false)
+        set(nonunity true)
+      endif()
+
+      if (${cur_component} STREQUAL debug)
+        set(release false)
+      endif()
+
+      if (${cur_component} STREQUAL release)
+        set(release true)
+      endif()
+
+      if (${cur_component} STREQUAL coverage)
+        set(coverage true)
+        set(debug true)
+      endif()
+
+      if (${cur_component} STREQUAL profile)
+        set(profile true)
+      endif()
+
+      if (${cur_component} STREQUAL ci)
+        # Workarounds that make various CI builds work, but that
+        # we don't want in the general case.
+        set(ci true)
+        set(openssl_min 1.0.1)
+      endif()
+
+    endwhile()
+
+    if (release)
+      set(CMAKE_BUILD_TYPE Release)
+    else()
+      set(CMAKE_BUILD_TYPE Debug)
+    endif()
+
+    if (NOT unity)
+      set(CMAKE_BUILD_TYPE ${CMAKE_BUILD_TYPE}Classic)
+    endif()
+  endif()
+
+endmacro()
+
+############################################################
+
+macro(setup_build_cache)
+  set(san "" CACHE STRING "On gcc & clang, add sanitizer
+    instrumentation")
+  set_property(CACHE san PROPERTY STRINGS ";address;thread")
+  set(assert false CACHE BOOL "Enables asserts, even in release builds")
+  set(static false CACHE BOOL
+    "On linux, link protobuf, openssl, libc++, and boost statically")
+
+  if (static AND (WIN32 OR APPLE))
+    message(FATAL_ERROR "Static linking is only supported on linux.")
+  endif()
+
+  if (${CMAKE_GENERATOR} STREQUAL "Unix Makefiles" AND NOT CMAKE_BUILD_TYPE)
+    set(CMAKE_BUILD_TYPE Debug)
+  endif()
+
+  # Can't exclude files from configurations, so can't support both
+  # unity and nonunity configurations at the same time
+  if (NOT DEFINED unity OR unity)
+    set(CMAKE_CONFIGURATION_TYPES
+      Debug
+      Release)
+  else()
+    set(CMAKE_CONFIGURATION_TYPES
+      DebugClassic
+      ReleaseClassic)
+    if(${CMAKE_BUILD_TYPE} STREQUAL "Debug")
+      set(CMAKE_BUILD_TYPE DebugClassic)
+    elseif(${CMAKE_BUILD_TYPE} STREQUAL "Release")
+      set(CMAKE_BUILD_TYPE ReleaseClassic)
+    endif()
+  endif()
+
+  set(CMAKE_CONFIGURATION_TYPES
+    ${CMAKE_CONFIGURATION_TYPES} CACHE STRING "" FORCE)
+endmacro()
+
+############################################################
+
+function(prepend var prefix)
+  set(listVar "")
+  foreach(f ${ARGN})
+    list(APPEND listVar "${prefix}${f}")
+  endforeach(f)
+  set(${var} "${listVar}" PARENT_SCOPE)
+endfunction()
+
+macro(append_flags name)
+  foreach (arg ${ARGN})
+    set(${name} "${${name}} ${arg}")
+  endforeach()
+endmacro()
+
+macro(group_sources curdir)
+  file(GLOB children RELATIVE ${PROJECT_SOURCE_DIR}/${curdir}
+    ${PROJECT_SOURCE_DIR}/${curdir}/*)
+  foreach (child ${children})
+    if (IS_DIRECTORY ${PROJECT_SOURCE_DIR}/${curdir}/${child})
+      group_sources(${curdir}/${child})
+    else()
+      string(REPLACE "/" "\\" groupname ${curdir})
+      source_group(${groupname} FILES
+        ${PROJECT_SOURCE_DIR}/${curdir}/${child})
+    endif()
+  endforeach()
+endmacro()
+
+macro(add_with_props src_var files)
+  list(APPEND ${src_var} ${files})
+  foreach (arg ${ARGN})
+    set(props "${props} ${arg}")
+  endforeach()
+  set_source_files_properties(
+    ${files}
+    PROPERTIES COMPILE_FLAGS
+    ${props})
+endmacro()
+
+############################################################
+
+macro(determine_build_type)
+  if ("${CMAKE_CXX_COMPILER_ID}" MATCHES ".*Clang") # both Clang and AppleClang
+    set(is_clang true)
+  elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+    set(is_gcc true)
+  elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
+    set(is_msvc true)
+  endif()
+
+  if (${CMAKE_GENERATOR} STREQUAL "Xcode")
+    set(is_xcode true)
+  else()
+    set(is_xcode false)
+  endif()
+
+  if (NOT is_gcc AND NOT is_clang AND NOT is_msvc)
+    message("Current compiler is ${CMAKE_CXX_COMPILER_ID}")
+    message(FATAL_ERROR "Missing compiler. Must be GNU, Clang, or MSVC")
+  endif()
+endmacro()
+
+############################################################
+
+macro(check_gcc4_abi)
+  # Check if should use gcc4's ABI
+  set(gcc4_abi false)
+
+  if ($ENV{RIPPLED_OLD_GCC_ABI})
+    set(gcc4_abi true)
+  endif()
+
+  if (is_gcc AND NOT gcc4_abi)
+    if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 5)
+      execute_process(COMMAND lsb_release -si OUTPUT_VARIABLE lsb)
+      string(STRIP "${lsb}" lsb)
+      if ("${lsb}" STREQUAL "Ubuntu")
+        execute_process(COMMAND lsb_release -sr OUTPUT_VARIABLE lsb)
+        string(STRIP ${lsb} lsb)
+        if (${lsb} VERSION_LESS 15.1)
+          set(gcc4_abi true)
+        endif()
+      endif()
+    endif()
+  endif()
+
+  if (gcc4_abi)
+    add_definitions(-D_GLIBCXX_USE_CXX11_ABI=0)
+  endif()
+endmacro()
+
+############################################################
+
+macro(special_build_flags)
+  if (coverage)
+    add_compile_options(-fprofile-arcs -ftest-coverage)
+    append_flags(CMAKE_EXE_LINKER_FLAGS -fprofile-arcs -ftest-coverage)
+  endif()
+
+  if (profile)
+    add_compile_options(-p -pg)
+    append_flags(CMAKE_EXE_LINKER_FLAGS -p -pg)
+  endif()
+endmacro()
+
+############################################################
+
+# Params: Boost components to search for.
+macro(use_boost)
+    if ((NOT DEFINED BOOST_ROOT) AND (DEFINED ENV{BOOST_ROOT}))
+        set(BOOST_ROOT $ENV{BOOST_ROOT})
+    endif()
+    if(WIN32 OR CYGWIN)
+        # Workaround for MSVC having two boost versions - x86 and x64 on same PC in stage folders
+        if(DEFINED BOOST_ROOT)
+            if(CMAKE_SIZEOF_VOID_P EQUAL 8 AND IS_DIRECTORY ${BOOST_ROOT}/stage64/lib)
+                set(Boost_LIBRARY_DIR ${BOOST_ROOT}/stage64/lib)
+            else()
+                set(Boost_LIBRARY_DIR ${BOOST_ROOT}/stage/lib)
+            endif()
+        endif()
+    endif()
+
+    if (is_clang AND DEFINED ENV{CLANG_BOOST_ROOT})
+      set(BOOST_ROOT $ENV{CLANG_BOOST_ROOT})
+    endif()
+
+    set(Boost_USE_STATIC_LIBS on)
+    set(Boost_USE_MULTITHREADED on)
+    set(Boost_USE_STATIC_RUNTIME off)
+    find_package(Boost COMPONENTS
+      ${ARGN})
+
+    if (Boost_FOUND OR
+        ((CYGWIN OR WIN32) AND Boost_INCLUDE_DIRS AND Boost_LIBRARY_DIRS))
+      if(NOT Boost_FOUND)
+        message(WARNING "Boost directory found, but not all components. May not be able to build.")
+      endif()
+      include_directories(SYSTEM ${Boost_INCLUDE_DIRS})
+      link_directories(${Boost_LIBRARY_DIRS})
+    else()
+      message(FATAL_ERROR "Boost not found")
+    endif()
+endmacro()
+
+macro(use_pthread)
+  if (NOT WIN32)
+    set(THREADS_PREFER_PTHREAD_FLAG ON)
+    find_package(Threads)
+    add_compile_options(${CMAKE_THREAD_LIBS_INIT})
+  endif()
+endmacro()
+
+macro(use_openssl openssl_min)
+  if (APPLE AND NOT DEFINED ENV{OPENSSL_ROOT_DIR})
+    find_program(HOMEBREW brew)
+    if (NOT HOMEBREW STREQUAL "HOMEBREW-NOTFOUND")
+      execute_process(COMMAND brew --prefix openssl
+        OUTPUT_VARIABLE OPENSSL_ROOT_DIR
+        OUTPUT_STRIP_TRAILING_WHITESPACE)
+    endif()
+  endif()
+
+  if (WIN32)
+    if (DEFINED ENV{OPENSSL_ROOT})
+      include_directories($ENV{OPENSSL_ROOT}/include)
+      link_directories($ENV{OPENSSL_ROOT}/lib)
+    endif()
+  else()
+    if (static)
+      set(tmp CMAKE_FIND_LIBRARY_SUFFIXES)
+      set(CMAKE_FIND_LIBRARY_SUFFIXES .a)
+    endif()
+
+    find_package(OpenSSL)
+
+    if (static)
+      set(CMAKE_FIND_LIBRARY_SUFFIXES tmp)
+    endif()
+
+    if (OPENSSL_FOUND)
+      include_directories(${OPENSSL_INCLUDE_DIR})
+    else()
+      message(FATAL_ERROR "OpenSSL not found")
+    endif()
+    if (UNIX AND NOT APPLE AND ${OPENSSL_VERSION} VERSION_LESS ${openssl_min})
+      message(FATAL_ERROR
+        "Your openssl is Version: ${OPENSSL_VERSION}, ${openssl_min} or better is required.")
+    endif()
+  endif()
+endmacro()
+
+macro(use_protobuf)
+  if (WIN32)
+    if (DEFINED ENV{PROTOBUF_ROOT})
+      include_directories($ENV{PROTOBUF_ROOT}/src)
+      link_directories($ENV{PROTOBUF_ROOT}/src/.libs)
+    endif()
+
+    # Modified from FindProtobuf.cmake
+    FUNCTION(PROTOBUF_GENERATE_CPP SRCS HDRS PROTOFILES)
+      # argument parsing
+      IF(NOT PROTOFILES)
+        MESSAGE(SEND_ERROR "Error: PROTOBUF_GENERATE_CPP() called without any proto files")
+        RETURN()
+      ENDIF()
+
+      SET(OUTPATH ${CMAKE_CURRENT_BINARY_DIR})
+      SET(PROTOROOT ${CMAKE_CURRENT_SOURCE_DIR})
+      # the real logic
+      SET(${SRCS})
+      SET(${HDRS})
+      FOREACH(PROTOFILE ${PROTOFILES})
+        # ensure that the file ends with .proto
+        STRING(REGEX MATCH "\\.proto$$" PROTOEND ${PROTOFILE})
+        IF(NOT PROTOEND)
+          MESSAGE(SEND_ERROR "Proto file '${PROTOFILE}' does not end with .proto")
+        ENDIF()
+
+        GET_FILENAME_COMPONENT(PROTO_PATH ${PROTOFILE} PATH)
+        GET_FILENAME_COMPONENT(ABS_FILE ${PROTOFILE} ABSOLUTE)
+        GET_FILENAME_COMPONENT(FILE_WE ${PROTOFILE} NAME_WE)
+
+        STRING(REGEX MATCH "^${PROTOROOT}" IN_ROOT_PATH ${PROTOFILE})
+        STRING(REGEX MATCH "^${PROTOROOT}" IN_ROOT_ABS_FILE ${ABS_FILE})
+
+        IF(IN_ROOT_PATH)
+          SET(MATCH_PATH ${PROTOFILE})
+        ELSEIF(IN_ROOT_ABS_FILE)
+          SET(MATCH_PATH ${ABS_FILE})
+        ELSE()
+          MESSAGE(SEND_ERROR "Proto file '${PROTOFILE}' is not in protoroot '${PROTOROOT}'")
+        ENDIF()
+
+        # build the result file name
+        STRING(REGEX REPLACE "^${PROTOROOT}(/?)" "" ROOT_CLEANED_FILE ${MATCH_PATH})
+        STRING(REGEX REPLACE "\\.proto$$" "" EXT_CLEANED_FILE ${ROOT_CLEANED_FILE})
+
+        SET(CPP_FILE "${OUTPATH}/${EXT_CLEANED_FILE}.pb.cc")
+        SET(H_FILE "${OUTPATH}/${EXT_CLEANED_FILE}.pb.h")
+
+        LIST(APPEND ${SRCS} "${CPP_FILE}")
+        LIST(APPEND ${HDRS} "${H_FILE}")
+
+        ADD_CUSTOM_COMMAND(
+          OUTPUT "${CPP_FILE}" "${H_FILE}"
+          COMMAND ${CMAKE_COMMAND} -E make_directory ${OUTPATH}
+          COMMAND ${PROTOBUF_PROTOC_EXECUTABLE}
+          ARGS "--cpp_out=${OUTPATH}" --proto_path "${PROTOROOT}" "${MATCH_PATH}"
+          DEPENDS ${ABS_FILE}
+          COMMENT "Running C++ protocol buffer compiler on ${MATCH_PATH} with root ${PROTOROOT}, generating: ${CPP_FILE}"
+          VERBATIM)
+
+      ENDFOREACH()
+
+      SET_SOURCE_FILES_PROPERTIES(${${SRCS}} ${${HDRS}} PROPERTIES GENERATED TRUE)
+      SET(${SRCS} ${${SRCS}} PARENT_SCOPE)
+      SET(${HDRS} ${${HDRS}} PARENT_SCOPE)
+
+    ENDFUNCTION()
+
+    set(PROTOBUF_PROTOC_EXECUTABLE Protoc) # must be on path
+  else()
+    if (static)
+      set(tmp CMAKE_FIND_LIBRARY_SUFFIXES)
+      set(CMAKE_FIND_LIBRARY_SUFFIXES .a)
+    endif()
+
+    find_package(Protobuf REQUIRED)
+
+    if (static)
+      set(CMAKE_FIND_LIBRARY_SUFFIXES tmp)
+    endif()
+
+    if (is_clang AND DEFINED ENV{CLANG_PROTOBUF_ROOT})
+      link_directories($ENV{CLANG_PROTOBUF_ROOT}/src/.libs)
+      include_directories($ENV{CLANG_PROTOBUF_ROOT}/src)
+    else()
+      include_directories(${PROTOBUF_INCLUDE_DIRS})
+    endif()
+  endif()
+  include_directories(${CMAKE_CURRENT_BINARY_DIR})
+
+  file(GLOB ripple_proto src/ripple/proto/*.proto)
+  PROTOBUF_GENERATE_CPP(PROTO_SRCS PROTO_HDRS ${ripple_proto})
+
+  if (WIN32)
+    include_directories(src/protobuf/src
+      src/protobuf/vsprojects
+      ${CMAKE_CURRENT_BINARY_DIR}/src/ripple/proto)
+  endif()
+
+endmacro()
+
+############################################################
+
+macro(setup_build_boilerplate)
+  if (NOT WIN32 AND san)
+    add_compile_options(-fsanitize=${san} -fno-omit-frame-pointer)
+
+    append_flags(CMAKE_EXE_LINKER_FLAGS
+      -fsanitize=${san})
+
+    string(TOLOWER ${san} ci_san)
+    if (${ci_san} STREQUAL address)
+      set(SANITIZER_LIBRARIES asan)
+      add_definitions(-DSANITIZER=ASAN)
+    endif()
+    if (${ci_san} STREQUAL thread)
+      set(SANITIZER_LIBRARIES tsan)
+      add_definitions(-DSANITIZER=TSAN)
+    endif()
+  endif()
+
+  ############################################################
+
+  add_definitions(
+    -DOPENSSL_NO_SSL2
+    -DDEPRECATED_IN_MAC_OS_X_VERSION_10_7_AND_LATER
+    -DHAVE_USLEEP=1
+    -DSOCI_CXX_C11=1
+    -D_SILENCE_STDEXT_HASH_DEPRECATION_WARNINGS
+    -DBOOST_NO_AUTO_PTR
+    )
+
+  if (is_gcc)
+    add_compile_options(-Wno-unused-but-set-variable -Wno-deprecated)
+  endif()
+
+  # Generator expressions are not supported in add_definitions, use set_property instead
+  set_property(
+    DIRECTORY
+    APPEND
+    PROPERTY COMPILE_DEFINITIONS
+    $<$<OR:$<CONFIG:Debug>,$<CONFIG:DebugClassic>>:DEBUG _DEBUG>)
+
+  if (NOT assert)
+    set_property(
+      DIRECTORY
+      APPEND
+      PROPERTY COMPILE_DEFINITIONS
+      $<$<OR:$<BOOL:${profile}>,$<CONFIG:Release>,$<CONFIG:ReleaseClassic>>:NDEBUG>)
+  endif()
+
+  if (NOT WIN32)
+    add_definitions(-D_FILE_OFFSET_BITS=64)
+    append_flags(CMAKE_CXX_FLAGS -frtti -std=c++14 -Wno-invalid-offsetof
+      -DBOOST_COROUTINE_NO_DEPRECATION_WARNING -DBOOST_COROUTINES_NO_DEPRECATION_WARNING)
+    add_compile_options(-Wall -Wno-sign-compare -Wno-char-subscripts -Wno-format
+      -Wno-unused-local-typedefs -g)
+    # There seems to be an issue using generator experssions with multiple values,
+    # split the expression
+    add_compile_options($<$<OR:$<CONFIG:Release>,$<CONFIG:ReleaseClassic>>:-O3>)
+    add_compile_options($<$<OR:$<CONFIG:Release>,$<CONFIG:ReleaseClassic>>:-fno-strict-aliasing>)
+    append_flags(CMAKE_EXE_LINKER_FLAGS -rdynamic -g)
+
+    if (is_clang)
+      add_compile_options(
+        -Wno-redeclared-class-member -Wno-mismatched-tags -Wno-deprecated-register)
+      add_definitions(-DBOOST_ASIO_HAS_STD_ARRAY)
+    endif()
+
+    if (APPLE)
+      add_definitions(-DBEAST_COMPILE_OBJECTIVE_CPP=1
+        -DNO_LOG_UNHANDLED_EXCEPTIONS)
+      add_compile_options(
+        -Wno-deprecated -Wno-deprecated-declarations -Wno-unused-variable -Wno-unused-function)
+    endif()
+
+    if (is_gcc)
+      add_compile_options(-Wno-unused-but-set-variable -Wno-unused-local-typedefs)
+      add_compile_options($<$<OR:$<CONFIG:Debug>,$<CONFIG:DebugClassic>>:-O0>)
+    endif (is_gcc)
+  else(NOT WIN32)
+    add_compile_options(
+      /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
+      /W3                  # Warning level 3
+      /WX-                 # Disable warnings as errors
+      /wd"4018"
+      /wd"4244"
+      /wd"4267"
+      /wd"4800"            # Disable C4800(int to bool performance)
+      /wd"4503"            # Decorated name length exceeded, name was truncated
+      )
+    add_definitions(
+      -D_WIN32_WINNT=0x6000
+      -D_SCL_SECURE_NO_WARNINGS
+      -D_CRT_SECURE_NO_WARNINGS
+      -DWIN32_CONSOLE
+      -DNOMINMAX
+      -DBOOST_COROUTINE_NO_DEPRECATION_WARNING
+      -DBOOST_COROUTINES_NO_DEPRECATION_WARNING)
+    append_flags(CMAKE_EXE_LINKER_FLAGS
+      /DEBUG
+      /DYNAMICBASE
+      /ERRORREPORT:NONE
+      /MACHINE:X64
+      /MANIFEST
+      /nologo
+      /NXCOMPAT
+      /SUBSYSTEM:CONSOLE
+      /TLBID:1)
+
+
+    # There seems to be an issue using generator experssions with multiple values,
+    # split the expression
+    # /GS  Buffers security check: enable
+    add_compile_options($<$<OR:$<CONFIG:Debug>,$<CONFIG:DebugClassic>>:/GS>)
+    # /MTd Language: Multi-threaded Debug CRT
+    add_compile_options($<$<OR:$<CONFIG:Debug>,$<CONFIG:DebugClassic>>:/MTd>)
+    # /Od  Optimization: Disabled
+    add_compile_options($<$<OR:$<CONFIG:Debug>,$<CONFIG:DebugClassic>>:/Od>)
+    # /RTC1 Run-time error checks:
+    add_compile_options($<$<OR:$<CONFIG:Debug>,$<CONFIG:DebugClassic>>:/RTC1>)
+
+    # Generator expressions are not supported in add_definitions, use set_property instead
+    set_property(
+      DIRECTORY
+      APPEND
+      PROPERTY COMPILE_DEFINITIONS
+      $<$<OR:$<CONFIG:Debug>,$<CONFIG:DebugClassic>>:_CRTDBG_MAP_ALLOC>)
+
+    # /MT Language: Multi-threaded CRT
+    add_compile_options($<$<OR:$<CONFIG:Release>,$<CONFIG:ReleaseClassic>>:/MT>)
+    add_compile_options($<$<OR:$<CONFIG:Release>,$<CONFIG:ReleaseClassic>>:/Ox>)
+    # /Ox Optimization: Full
+
+  endif (NOT WIN32)
+
+  if (static)
+    append_flags(CMAKE_EXE_LINKER_FLAGS -static-libstdc++)
+    # set_target_properties(ripple-libpp PROPERTIES LINK_SEARCH_START_STATIC 1)
+    # set_target_properties(ripple-libpp PROPERTIES LINK_SEARCH_END_STATIC 1)
+  endif()
+endmacro()
+
+############################################################
+
+macro(create_build_folder cur_project)
+  if (NOT WIN32)
+    ADD_CUSTOM_TARGET(build_folder ALL
+      COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_CURRENT_BINARY_DIR}
+      COMMENT "Creating build output folder")
+    add_dependencies(${cur_project} build_folder)
+  endif()
+endmacro()
+
+macro(set_startup_project cur_project)
+  if (WIN32 AND NOT ci)
+    if (CMAKE_VERSION VERSION_LESS 3.6)
+      message(WARNING
+        "Setting the VS startup project requires cmake 3.6 or later. Please upgrade.")
+    endif()
+    set_property(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} PROPERTY
+      VS_STARTUP_PROJECT ${cur_project})
+  endif()
+endmacro()
+
+macro(link_common_libraries cur_project)
+  if (NOT MSVC)
+    target_link_libraries(${cur_project} ${Boost_LIBRARIES})
+    target_link_libraries(${cur_project} dl)
+    target_link_libraries(${cur_project} Threads::Threads)
+    if (APPLE)
+      find_library(app_kit AppKit)
+      find_library(foundation Foundation)
+      target_link_libraries(${cur_project}
+        crypto ssl ${app_kit} ${foundation})
+    else()
+      target_link_libraries(${cur_project} rt)
+    endif()
+  else(NOT MSVC)
+    target_link_libraries(${cur_project}
+      $<$<OR:$<CONFIG:Debug>,$<CONFIG:DebugClassic>>:VC/static/ssleay32MTd>
+      $<$<OR:$<CONFIG:Debug>,$<CONFIG:DebugClassic>>:VC/static/libeay32MTd>)
+    target_link_libraries(${cur_project}
+      $<$<OR:$<CONFIG:Release>,$<CONFIG:ReleaseClassic>>:VC/static/ssleay32MT>
+      $<$<OR:$<CONFIG:Release>,$<CONFIG:ReleaseClassic>>:VC/static/libeay32MT>)
+    target_link_libraries(${cur_project}
+      legacy_stdio_definitions.lib Shlwapi kernel32 user32 gdi32 winspool comdlg32
+      advapi32 shell32 ole32 oleaut32 uuid odbc32 odbccp32)
+  endif (NOT MSVC)
+endmacro()

Builds/Test.py

@@ -48,18 +48,39 @@ import itertools
 import os
 import platform
 import re
-import subprocess
+import shutil
 import sys
+import subprocess
+
+
+def powerset(iterable):
+    """powerset([1,2,3]) --> () (1,) (2,) (3,) (1,2) (1,3) (2,3) (1,2,3)"""
+    s = list(iterable)
+    return itertools.chain.from_iterable(itertools.combinations(s, r) for r in range(len(s) + 1))
 
 IS_WINDOWS = platform.system().lower() == 'windows'
+IS_OS_X = platform.system().lower() == 'darwin'
 
-if IS_WINDOWS:
-    BINARY_RE = re.compile(r'build\\([^\\]+)\\rippled.exe')
-
+if IS_WINDOWS or IS_OS_X:
+    ALL_TARGETS = [('debug',), ('release',)]
 else:
-    BINARY_RE = re.compile(r'build/([^/]+)/rippled')
+    ALL_TARGETS = [(cc + "." + target,)
+                   for cc in ['gcc', 'clang']
+                   for target in ['debug', 'release', 'coverage', 'profile',
+                                  'debug.nounity', 'release.nounity', 'coverage.nounity', 'profile.nounity']]
 
-ALL_TARGETS = ['debug', 'release']
+# list of tuples of all possible options
+if IS_WINDOWS or IS_OS_X:
+    ALL_OPTIONS = [tuple(x) for x in powerset(['--assert'])]
+else:
+    ALL_OPTIONS = list(set(
+        [tuple(x) for x in powerset(['--ninja', '--static', '--assert', '--sanitize=address'])] +
+        [tuple(x) for x in powerset(['--ninja', '--static', '--assert', '--sanitize=thread'])]))
+
+# list of tuples of all possible options + all possible targets
+ALL_BUILDS = [options + target
+              for target in ALL_TARGETS
+              for options in ALL_OPTIONS]
 
 parser = argparse.ArgumentParser(
     description='Test.py - run ripple tests'
@@ -75,55 +96,68 @@ parser.add_argument(
     '--keep_going', '-k',
     action='store_true',
     help='Keep going after one configuration has failed.',
- )
+)
 
 parser.add_argument(
     '--silent', '-s',
     action='store_true',
     help='Silence all messages except errors',
- )
+)
 
 parser.add_argument(
     '--verbose', '-v',
     action='store_true',
     help=('Report more information about which commands are executed and the '
           'results.'),
- )
+)
 
 parser.add_argument(
     '--test', '-t',
     default='',
     help='Add a prefix for unit tests',
- )
+)
+
+parser.add_argument(
+    '--clean', '-c',
+    action='store_true',
+    help='delete all build artifacts after testing',
+)
 
 parser.add_argument(
     'scons_args',
     default=(),
     nargs='*'
-    )
+)
 
 ARGS = parser.parse_args()
 
-def shell(*cmd, **kwds):
-    "Execute a shell command and return the output."
-    silent = kwds.pop('silent', ARGS.silent)
-    verbose = not silent and kwds.pop('verbose', ARGS.verbose)
+
+def shell(cmd, args=(), silent=False):
+    """"Execute a shell command and return the output."""
+    silent = ARGS.silent or silent
+    verbose = not silent and ARGS.verbose
     if verbose:
-        print('$', ' '.join(cmd))
-    kwds['shell'] = IS_WINDOWS
+        print('$' + cmd, *args)
+
+    command = (cmd,) + args
 
     process = subprocess.Popen(
-        cmd,
+        command,
         stdin=subprocess.PIPE,
         stdout=subprocess.PIPE,
         stderr=subprocess.STDOUT,
-        **kwds)
+        shell=IS_WINDOWS)
     lines = []
     count = 0
     for line in process.stdout:
-        lines.append(line)
+        # Python 2 vs. Python 3
+        if isinstance(line, str):
+            decoded = line
+        else:
+            decoded = line.decode()
+        lines.append(decoded)
         if verbose:
-            print(line, end='')
+            print(decoded, end='')
         elif not silent:
             count += 1
             if count >= 80:
@@ -137,27 +171,16 @@ def shell(*cmd, **kwds):
     process.wait()
     return process.returncode, lines
 
-if __name__ == '__main__':
-    args = list(ARGS.scons_args)
-    if ARGS.all:
-        for a in ALL_TARGETS:
-            if a not in args:
-                args.append(a)
-    print('Building:', *(args or ['(default)']))
 
-    # Build everything.
-    resultcode, lines = shell('scons', *args)
-    if resultcode:
-        print('Build FAILED:')
-        if not ARGS.verbose:
-            print(*lines, sep='')
-        exit(1)
-
-    # Now extract the executable names and corresponding targets.
+def run_tests(args):
     failed = []
-    _, lines = shell('scons', '-n', '--tree=derived', *args, silent=True)
+    if IS_WINDOWS:
+        binary_re = re.compile(r'build\\([^\\]+)\\rippled.exe')
+    else:
+        binary_re = re.compile(r'build/([^/]+)/rippled')
+    _, lines = shell('scons', ('-n', '--tree=derived',) + args, silent=True)
     for line in lines:
-        match = BINARY_RE.search(line)
+        match = binary_re.search(line)
         if match:
             executable, target = match.group(0, 1)
 
@@ -165,27 +188,79 @@ if __name__ == '__main__':
             testflag = '--unittest'
             if ARGS.test:
                 testflag += ('=' + ARGS.test)
+            resultcode, lines = shell(executable, (testflag,))
 
-            resultcode, lines = shell(executable, testflag)
             if resultcode:
-                print('ERROR:', *lines, sep='')
+                if not ARGS.verbose:
+                    print('ERROR:', *lines, sep='')
                 failed.append([target, 'unittest'])
                 if not ARGS.keep_going:
                     break
-            ARGS.verbose and print(*lines, sep='')
 
-            print('npm tests for', target)
-            resultcode, lines = shell('npm', 'test', '--rippled=' + executable)
-            if resultcode:
-                print('ERROR:\n', *lines, sep='')
-                failed.append([target, 'npm'])
-                if not ARGS.keep_going:
-                    break
-            else:
-                ARGS.verbose and print(*lines, sep='')
+    return failed
 
-    if failed:
-        print('FAILED:', *(':'.join(f) for f in failed))
-        exit(1)
+
+def run_build(args=None):
+    print('Building:', *args or ('(default)',))
+    resultcode, lines = shell('scons', args)
+
+    if resultcode:
+        print('Build FAILED:')
+        if not ARGS.verbose:
+            print(*lines, sep='')
+        sys.exit(1)
+    if '--ninja' in args:
+        resultcode, lines = shell('ninja')
+
+        if resultcode:
+            print('Ninja build FAILED:')
+            if not ARGS.verbose:
+                print(*lines, sep='')
+            sys.exit(1)
+
+
+def main():
+    if ARGS.all:
+        to_build = ALL_BUILDS
     else:
-        print('Success')
+        to_build = [tuple(ARGS.scons_args)]
+
+    all_failed = []
+
+    for build in to_build:
+        args = ()
+        # additional arguments come first
+        for arg in list(ARGS.scons_args):
+            if arg not in build:
+                args += (arg,)
+        args += build
+
+        run_build(args)
+        failed = run_tests(args)
+
+        if failed:
+            print('FAILED:', *(':'.join(f) for f in failed))
+            if not ARGS.keep_going:
+                sys.exit(1)
+            else:
+                all_failed.extend([','.join(build), ':'.join(f)]
+                    for f in failed)
+        else:
+            print('Success')
+
+        if ARGS.clean:
+            shutil.rmtree('build')
+            if '--ninja' in args:
+                os.remove('build.ninja')
+                os.remove('.ninja_deps')
+                os.remove('.ninja_log')
+
+    if all_failed:
+        if len(to_build) > 1:
+            print()
+            print('FAILED:', *(':'.join(f) for f in all_failed))
+        sys.exit(1)
+
+if __name__ == '__main__':
+    main()
+    sys.exit(0)

Builds/Ubuntu/build_clang_libs.sh

@@ -0,0 +1,82 @@
+#!/usr/bin/env bash
+
+#
+# This scripts installs boost and protobuf built with clang. This is needed on
+# ubuntu 15.10 when building with clang
+# It will build these in a 'clang' subdirectory that it creates below the directory
+# this script is run from. If a clang directory already exists the script will refuse
+# to run.
+
+if hash lsb_release 2>/dev/null; then
+    if [ $(lsb_release -si) == "Ubuntu" ]; then
+        ubuntu_release=$(lsb_release -sr)
+    fi
+fi
+
+if [ -z "${ubuntu_release}" ]; then
+    echo "System not supported"
+    exit 1
+fi
+
+if ! hash clang 2>/dev/null; then
+    clang_version=3.7
+    if [ ${ubuntu_release} == "16.04" ]; then
+        clang_version=3.8
+    fi
+    sudo apt-get -y install clang-${clang_version}
+    update-alternatives --install /usr/bin/clang clang /usr/bin/clang-${clang_version} 99 clang++
+    hash -r
+    if ! hash clang 2>/dev/null; then
+        echo "Please install clang"
+        exit 1
+    fi
+fi
+
+if [ ${ubuntu_release} != "16.04" ] && [ ${ubuntu_release} != "15.10" ]; then
+    echo "clang specific boost and protobuf not needed"
+    exit 0
+fi
+
+if [ -d clang ]; then
+    echo "clang directory already exists. Cowardly refusing to run"
+    exit 1
+fi
+
+if ! hash wget 2>/dev/null; then
+    sudo apt-get -y install wget
+    hash -r
+    if ! hash wget 2>/dev/null; then
+        echo "Please install wget"
+        exit 1
+    fi
+fi
+
+num_procs=$(lscpu -p | grep -v '^#' | sort -u -t, -k 2,4 | wc -l) # pysical cores
+
+mkdir clang
+pushd clang > /dev/null
+
+# Install protobuf
+pb=protobuf-2.6.1
+pb_tar=${pb}.tar.gz 
+wget -O ${pb_tar} https://github.com/google/protobuf/releases/download/v2.6.1/${pb_tar}
+tar xf ${pb_tar}
+rm ${pb_tar}
+pushd ${pb} > /dev/null
+./configure CC=clang CXX=clang++ CXXFLAGS='-std=c++14 -O3 -g'
+make -j${num_procs}
+popd > /dev/null
+
+# Install boost
+boost_ver=1.60.0
+bd=boost_${boost_ver//./_}
+bd_tar=${bd}.tar.gz
+wget -O ${bd_tar} http://sourceforge.net/projects/boost/files/boost/${boost_ver}/${bd_tar}
+tar xf ${bd_tar}
+rm ${bd_tar}
+pushd ${bd} > /dev/null
+./bootstrap.sh
+./b2 toolset=clang -j${num_procs}
+popd > /dev/null
+
+popd > /dev/null

Builds/Ubuntu/install_rippled_depends_ubuntu.sh

@@ -25,7 +25,7 @@ if [ ${ubuntu_release} == "12.04" ]; then
     add-apt-repository ppa:ubuntu-toolchain-r/test
     apt-get update
     apt-get -y upgrade
-    apt-get -y install curl git scons ctags pkg-config protobuf-compiler libprotobuf-dev libssl-dev python-software-properties boost1.57-all-dev nodejs g++-5 g++-4.9
+    apt-get -y install curl git scons ctags pkg-config protobuf-compiler libprotobuf-dev libssl-dev python-software-properties boost1.57-all-dev g++-5 g++-4.9
     update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-5 99 --slave /usr/bin/g++ g++ /usr/bin/g++-5
     update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-4.9 99 --slave /usr/bin/g++ g++ /usr/bin/g++-4.9
     exit 0
@@ -33,21 +33,21 @@ fi
 
 if [ ${ubuntu_release} == "14.04" ] || [ ${ubuntu_release} == "15.04" ]; then
     apt-get install python-software-properties
-    echo "deb [arch=amd64] https://mirrors.ripple.com/ubuntu/ trusty stable contrib" | sudo tee /etc/apt/sources.list.d/ripple.list 
+    echo "deb [arch=amd64] https://mirrors.ripple.com/ubuntu/ trusty stable contrib" | sudo tee /etc/apt/sources.list.d/ripple.list
     wget -O- -q https://mirrors.ripple.com/mirrors.ripple.com.gpg.key | sudo apt-key add -
     add-apt-repository ppa:ubuntu-toolchain-r/test
     apt-get update
     apt-get -y upgrade
-    apt-get -y install curl git scons ctags pkg-config protobuf-compiler libprotobuf-dev libssl-dev python-software-properties boost-all-dev nodejs g++-5 g++-4.9
+    apt-get -y install curl git scons ctags pkg-config protobuf-compiler libprotobuf-dev libssl-dev python-software-properties boost-all-dev g++-5 g++-4.9
     update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-5 99 --slave /usr/bin/g++ g++ /usr/bin/g++-5
     update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-4.9 99 --slave /usr/bin/g++ g++ /usr/bin/g++-4.9
     exit 0
 fi
 
-if [ ${ubuntu_release} == "15.10" ]; then
+if [ ${ubuntu_release} == "16.04" ] || [ ${ubuntu_release} == "15.10" ]; then
     apt-get update
     apt-get -y upgrade
-    apt-get -y install python-software-properties curl git scons ctags pkg-config protobuf-compiler libprotobuf-dev libssl-dev python-software-properties libboost-all-dev nodejs 
+    apt-get -y install python-software-properties curl git scons ctags pkg-config protobuf-compiler libprotobuf-dev libssl-dev python-software-properties libboost-all-dev
     exit 0
 fi
 

Builds/VisualStudio2015/README.md

@@ -17,8 +17,7 @@ software components:
 * [Google Protocol Buffers Compiler](README.md#install-google-protocol-buffers-compiler)
 * (Optional) [Python and Scons](README.md#optional-install-python-and-scons)
 * [OpenSSL Library](README.md#install-openssl)
-* [Boost 1.59 library](README.md#build-boost)
-* [Node.js](README.md#install-nodejs)
+* [Boost library](README.md#build-boost)
 
 ## Install Software
 
@@ -84,8 +83,8 @@ for Visual Studio 2015 support.
 [Download OpenSSL.](http://slproweb.com/products/Win32OpenSSL.html)
 There will be four variants available:
 
-1. 64-bit. Use this if you are running 64-bit windows. As of this writing, the link is called: "Win64 OpenSSL v1.0.2d".
-2. 64-bit light - Don't use this. It is missing files needed to build rippled. As of this writing, the link is called: "Win64 OpenSSL v1.0.2d Light"
+1. 64-bit. Use this if you are running 64-bit windows. As of this writing, the link is called: "Win64 OpenSSL v1.0.2j".
+2. 64-bit light - Don't use this. It is missing files needed to build rippled. As of this writing, the link is called: "Win64 OpenSSL v1.0.2j Light"
 
 Run the installer, and choose an appropriate location for your OpenSSL
 installation. In this guide we use **C:\lib\OpenSSL-Win64** as the
@@ -108,8 +107,13 @@ unpacking it, open a **Developer Command Prompt** for
 Visual Studio, change to the directory containing boost, then
 bootstrap the build tools:
 
+(As of this writing, the most recent version of boost is 1.62.0, which
+will unpack into a directory named `boost_1_62_0`. For higher versions
+of boost, adjust the directories provided in these examples as
+appropriate.)
+
 ```powershell
-cd C:\lib\boost_1_59_0
+cd C:\lib\boost_1_62_0
 bootstrap
 ```
 
@@ -119,7 +123,7 @@ affected by changes in outside files. Therefore, it is necessary to build the
 required boost static libraries using this command:
 
 ```powershell
-bjam --toolset=msvc-14.0 --build-type=complete variant=debug,release link=static runtime-link=static address-model=64
+bjam --toolset=msvc-14.0 address-model=64 architecture=x86 link=static threading=multi runtime-link=shared,static stage --stagedir=stage64
 ```
 
 Building the boost libraries may take considerable time. When the build process
@@ -161,7 +165,7 @@ git checkout master
 ### Configure Library Paths
 
 Open the solution file located at **Builds/Visual Studio 2015/ripple.sln**
-and select the "View->Other Windows->Property Manager" to bring up the Property Manager.
+and select the "View->Property Manager" to bring up the Property Manager.
 Expand the *debug | x64* section and
 double click the *Microsoft.Cpp.x64.user* property sheet to bring up the
 *Property Pages* dialog. These are global properties applied to all
@@ -237,9 +241,7 @@ and then choose the **Build->Build Solution** menu item.
 
 # Unit Tests (Recommended)
 
-## Internal
-
-The internal rippled unit tests are written in C++ and are part
+The rippled unit tests are written in C++ and are part
 of the rippled executable.
 
 From a Windows console, run the unit tests:
@@ -250,108 +252,4 @@ From a Windows console, run the unit tests:
 
 Substitute the correct path to the executable to test different builds.
 
-## External
 
-The external rippled unit tests are written in Javascript using Node.js,
-and utilize the mocha unit test framework. To run the unit tests, it
-will be necessary to perform the following steps:
-
-### Install Node.js
-
-[Install Node.js](http://nodejs.org/download/). We recommend the Windows
-installer (**.msi** file) as it takes care of updating the *PATH* environment
-variable so that scripts can find the command. On Windows systems,
-**Node.js** comes with **npm**. A separate installation of **npm**
-is not necessary.
-
-### Create node_modules
-
-Open a windows console. From the root of your local rippled repository
-directory, invoke **npm** to bring in the necessary components:
-
-```
-npm install
-```
-
-If you get an error that looks like
-
-```
-Error: ENOENT, stat 'C:\Users\username\AppData\Roaming\npm'
-```
-
-simply create the indicated folder and try again.
-
-### Create a test config.js
-
-From a *bash* shell (installed with Git for Windows), copy the
-example configuration file into the appropriate location:
-
-```
-cp test/config-example.js test/config.js
-```
-
-Edit your version of test/config.js to reflect the correct path to the rippled executable:
-
-```
-exports.default_server_config = {
-  // Where to find the binary.
-  rippled_path: path.resolve(__dirname, "../build/msvc.debug/rippled.exe")
-};
-```
-
-Also in **test/config.js**, change any occurrences of the
-IP address *0.0.0.0* to *127.0.0.1*.
-
-### Run Tests
-
-From a windows console, run the unit tests:
-
-```
-npm test
-```
-
-Alternatively, run an individual test using mocha:
-
-```
-sh
-node_modules/mocha/bin/mocha test/account_tx-test.js
-```
-
-* NOTE: The version of ripple-lib provided by the npm install
-  facility is usually slightly behind the develop branch of the
-  authoritative ripple-lib repository. Therefore, some tests might fail.
-
-### Development ripple-lib
-
-To use the latest branch of **ripple-lib** during the unit tests,
-first clone the repository in a new location outside of your rippled
-repository. Then update the submodules. After, run **npm install**
-to set up the **node_modules** directory. Finally, install the
-**grunt** command line tools required to run **grunt** and
-build **ripple-lib**.
-
-```
-git clone git@github.com:ripple/ripple-lib.git
-cd ripple-lib
-git submodule update --init
-npm install
-npm install -g grunt-cli
-grunt
-```
-
-Now link this version of **ripple-lib** into the global packages:
-
-```
-sudo npm link
-```
-
-To make rippled use the newly linked global **ripple-lib** package
-instead of the one installed under **node_modules**, change
-directories to the local rippled repository and delete the old
-**ripple-lib** then link to the new one:
-
-```
-sh
-rm -rf node_modules/ripple-lib
-npm link ripple-lib
-```

Builds/VisualStudio2015/ripple.sln

@@ -1,26 +1,34 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
 # Visual Studio 14
-VisualStudioVersion = 14.0.23107.0
+VisualStudioVersion = 14.0.25123.0
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "RippleD", "RippleD.vcxproj", "{26B7D9AC-1A80-8EF8-6703-D061F1BECB75}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		debug.classic|x64 = debug.classic|x64
+		debug.classic|x86 = debug.classic|x86
 		debug|x64 = debug|x64
+		debug|x86 = debug|x86
 		release.classic|x64 = release.classic|x64
+		release.classic|x86 = release.classic|x86
 		release|x64 = release|x64
+		release|x86 = release|x86
 	EndGlobalSection
 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
 		{26B7D9AC-1A80-8EF8-6703-D061F1BECB75}.debug.classic|x64.ActiveCfg = debug.classic|x64
 		{26B7D9AC-1A80-8EF8-6703-D061F1BECB75}.debug.classic|x64.Build.0 = debug.classic|x64
+		{26B7D9AC-1A80-8EF8-6703-D061F1BECB75}.debug.classic|x86.ActiveCfg = debug.classic|x64
 		{26B7D9AC-1A80-8EF8-6703-D061F1BECB75}.debug|x64.ActiveCfg = debug|x64
 		{26B7D9AC-1A80-8EF8-6703-D061F1BECB75}.debug|x64.Build.0 = debug|x64
+		{26B7D9AC-1A80-8EF8-6703-D061F1BECB75}.debug|x86.ActiveCfg = debug|x64
 		{26B7D9AC-1A80-8EF8-6703-D061F1BECB75}.release.classic|x64.ActiveCfg = release.classic|x64
 		{26B7D9AC-1A80-8EF8-6703-D061F1BECB75}.release.classic|x64.Build.0 = release.classic|x64
+		{26B7D9AC-1A80-8EF8-6703-D061F1BECB75}.release.classic|x86.ActiveCfg = release.classic|x64
 		{26B7D9AC-1A80-8EF8-6703-D061F1BECB75}.release|x64.ActiveCfg = release|x64
 		{26B7D9AC-1A80-8EF8-6703-D061F1BECB75}.release|x64.Build.0 = release|x64
+		{26B7D9AC-1A80-8EF8-6703-D061F1BECB75}.release|x86.ActiveCfg = release|x64
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

Builds/XCode/README.md

@@ -0,0 +1,177 @@
+# macos Build Instructions
+
+## Important
+
+We don't recommend OS X for rippled production use at this time. Currently, the
+Ubuntu platform has received the highest level of quality assurance and
+testing.
+
+## Prerequisites
+
+You'll need OSX 10.8 or later
+
+To clone the source code repository, create branches for inspection or
+modification, build rippled using clang, and run the system tests you will need
+these software components:
+
+* [XCode](https://developer.apple.com/xcode/)
+* [Homebrew](http://brew.sh/)
+* [Git](http://git-scm.com/)
+* [Scons](http://www.scons.org/)
+
+## Install Software
+
+### Install XCode
+
+If not already installed on your system, download and install XCode using the
+appstore or by using [this link](https://developer.apple.com/xcode/).
+
+For more info, see "Step 1: Download and Install the Command Line Tools"
+[here](http://www.moncefbelyamani.com/how-to-install-xcode-homebrew-git-rvm-ruby-on-mac)
+
+The command line tools can be installed through the terminal with the command:
+
+```
+xcode-select --install
+```
+
+### Install Homebrew
+
+> "[Homebrew](http://brew.sh/) installs the stuff you need that Apple didn’t."
+
+Open a terminal and type:
+
+```
+ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"
+```
+
+For more info, see "Step 3: Install Homebrew"
+[here](http://www.moncefbelyamani.com/how-to-install-xcode-homebrew-git-rvm-ruby-on-mac)
+
+### Install Git
+
+```
+brew update brew install git
+```
+
+For more info, see "Step 4: Install Git"
+[here](http://www.moncefbelyamani.com/how-to-install-xcode-homebrew-git-rvm-ruby-on-mac)
+
+**NOTE**: To gain full featured access to the
+[git-subtree](http://blogs.atlassian.com/2013/05/alternatives-to-git-submodule-git-subtree/)
+functionality used in the rippled repository, we suggest Git version 1.8.3.2 or
+later.
+
+### Install Scons
+
+Requires version 2.3.0 or later
+
+```
+brew install scons
+```
+
+`brew` will generally install the latest stable version of any package, which
+will satisfy the scons minimum version requirement for rippled.
+
+### Install Package Config
+
+```
+brew install pkg-config
+```
+
+## Install/Build/Configure Dependencies
+
+### Build Google Protocol Buffers Compiler
+
+Building rippled on osx requires `protoc` version 2.5.x or 2.6.x (later versions
+do not work with rippled at this time).
+
+Download [this](https://github.com/google/protobuf/releases/download/v2.6.1/protobuf-2.6.1.tar.bz2)
+
+We want to compile protocol buffers with clang/libc++:
+
+```
+tar xfvj protobuf-2.6.1.tar.bz2
+cd protobuf-2.6.1
+./configure CC=clang CXX=clang++ CXXFLAGS='-std=c++11 -stdlib=libc++ -O3 -g' LDFLAGS='-stdlib=libc++' LIBS="-lc++ -lc++abi"
+make -j 4
+sudo make install
+```
+
+If you have installed `protobuf` via brew - either directly or indirectly as a
+dependency of some other package - this is likely to conflict with our specific
+version requirements. The simplest way to avoid conflicts is to uninstall it.
+`brew ls --versions protobuf` will list any versions of protobuf
+you currently have installed.
+
+### Install OpenSSL
+
+```
+brew install openssl
+```
+
+### Build Boost
+
+We want to compile boost with clang/libc++
+
+Download [a release](https://sourceforge.net/projects/boost/files/boost/1.61.0/boost_1_61_0.tar.bz2)
+
+Extract it to a folder, making note of where, open a terminal, then:
+
+```
+./bootstrap.sh ./b2 toolset=clang threading=multi runtime-link=static link=static cxxflags="-stdlib=libc++" linkflags="-stdlib=libc++" address-model=64
+```
+
+Create an environment variable `BOOST_ROOT` in one of your `rc` files, pointing
+to the root of the extracted directory.
+
+### Clone the rippled repository
+
+From the terminal
+
+```
+git clone git@github.com:ripple/rippled.git
+cd rippled
+```
+
+Choose the master branch or one of the tagged releases listed on
+[GitHub](https://github.com/ripple/rippled/releases GitHub).
+
+```
+git checkout master
+```
+
+or to test the latest release candidate, choose the `release` branch.
+
+```
+git checkout release
+```
+
+### Configure Library Paths
+
+If you didn't persistently set the `BOOST_ROOT` environment variable to the
+root of the extracted directory above, then you should set it temporarily.
+
+For example, assuming your username were `Abigail` and you extracted Boost
+1.61.0 in `/Users/Abigail/Downloads/boost_1_61_0`, you would do for any
+shell in which you want to build:
+
+```
+export BOOST_ROOT=/Users/Abigail/Downloads/boost_1_61_0
+```
+
+## Build
+
+```
+scons
+```
+
+See: [here](https://ripple.com/wiki/Rippled_build_instructions#Building)
+
+## Unit Tests (Recommended)
+
+rippled builds a set of unit tests into the server executable. To run these unit
+tests after building, pass the `--unittest` option to the compiled `rippled`
+executable. The executable will exit after running the unit tests.
+
+

Builds/XCode/README.txt

@@ -1 +0,0 @@
-Place XCode project file here!

Builds/build_all.sh

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+
+num_procs=$(lscpu -p | grep -v '^#' | sort -u -t, -k 2,4 | wc -l) # number of physical cores
+
+cd ..
+./Builds/Test.py -a -c -- -j${num_procs}

CMakeLists.txt

@@ -0,0 +1,517 @@
+# !!! The official build system is SConstruct !!!
+# This is an experimental cmake build file for rippled
+#
+# cmake support in rippled. Currently supports:
+#
+#  * unity/nounity debug/release
+#  * running protobuf
+#  * sanitizer builds
+#  * optional release build with assert turned on
+#  * `target` variable to easily set compiler/debug/unity
+#     (i.e. -Dtarget=gcc.debug.nounity)
+#  * gcc/clang/visual studio/xcode
+#  * linux/mac/win
+#  * gcc 4 ABI, when needed
+#  * ninja builds
+#  * check openssl version on linux
+#  * static builds (swd TBD: needs to be tested by building & deploying on different systems)
+#
+# TBD:
+#  * jemalloc support
+#  * count
+#  * Windows protobuf compiler puts generated file in src directory instead of build directory.
+#
+# Notes:
+#  * Use the -G"Visual Studio 14 2015 Win64" generator on Windows. Without this
+#    a 32-bit project will be created. There is no way to set the generator or
+#    force a 64-bit build in CMakeLists.txt (setting CMAKE_GENERATOR_PLATFORM won't work).
+#    The best solution may be to wrap cmake with a script.
+#
+#  * It is not possible to generate a visual studio project on linux or
+#    mac. The visual studio generator is only available on windows.
+#
+#  * The visual studio project can be _either_ unity or
+#    non-unity (selected at generation time).  It does not appear possible
+#    to disable compilation based on configuration.
+#
+#  * Language is _much_ worse than python, poor documentation and "quirky"
+#    language support (for example, generator expressions can only be used
+#    in limited contexts and seem to work differently based on
+#    context (set_property can set multiple values, add_compile_options
+#    can not/or is buggy)
+#
+#  * Could not call out to `sed` because cmake messed with the regular
+#    expression before calling the external command. I did not see a way
+#    around this.
+#
+#  * Makefile generators want to be single target. It wants a separate
+#    directory for each target type. I saw some mentions on the web for
+#    ways around this bug haven't look into it. The visual studio project
+#    does support debug/release configurations in the same project (but
+#    not unity/non-unity).
+
+############################################################
+
+cmake_minimum_required(VERSION 3.1.0)
+
+if("${CMAKE_SOURCE_DIR}" STREQUAL "${CMAKE_BINARY_DIR}")
+  set(dir "build")
+  set(cmd "cmake")
+  if (target)
+    set(dir "${dir}/${target}")
+    set(cmd "${cmd} -Dtarget=${target}")
+  elseif(CMAKE_BUILD_TYPE)
+    set(dir "${dir}/${CMAKE_BUILD_TYPE}")
+    set(cmd "${cmd} -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}")
+  else()
+    set(dir "${dir}/default")
+  endif()
+  set(cmd "${cmd} ${CMAKE_SOURCE_DIR}")
+
+  message(FATAL_ERROR "Builds are not allowed in ${CMAKE_SOURCE_DIR}.\n"
+    "Instead:\n"
+    "1) Remove the CMakeCache.txt file and CMakeFiles directory "
+   "from ${CMAKE_SOURCE_DIR}.\n"
+    "2) Create a directory to hold your build files, for example: ${dir}.\n"
+    "3) Change to that directory.\n"
+    "4) Run cmake targetting ${CMAKE_SOURCE_DIR}, for example: ${cmd}")
+endif()
+if("${CMAKE_GENERATOR}" MATCHES "Visual Studio" AND
+    NOT ("${CMAKE_GENERATOR}" MATCHES .*Win64.*))
+  message(FATAL_ERROR "Visual Studio 32-bit build is unsupported. Use
+    -G\"${CMAKE_GENERATOR} Win64\"")
+endif()
+
+set(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/Builds/CMake")
+include(CMakeFuncs)
+
+set(openssl_min 1.0.2)
+
+parse_target()
+
+if (NOT DEFINED unity)
+  set(unity true)
+  set(nonunity false)
+endif()
+
+setup_build_cache()
+
+project(rippled)
+
+if(nonunity)
+    get_cmake_property(allvars VARIABLES)
+    string(REGEX MATCHALL "[^;]*(DEBUG|RELEASE)[^;]*" matchvars "${allvars}")
+    foreach(var IN LISTS matchvars)
+        string(REGEX REPLACE "(DEBUG|RELEASE)" "\\1CLASSIC" newvar ${var})
+        set(${newvar} ${${var}})
+    endforeach()
+
+    get_cmake_property(allvars CACHE_VARIABLES)
+    string(REGEX MATCHALL "[^;]*(DEBUG|RELEASE)[^;]*" matchvars "${allvars}")
+    foreach(var IN LISTS matchvars)
+        string(REGEX REPLACE "(DEBUG|RELEASE)" "\\1CLASSIC" newvar ${var})
+        set(${newvar} ${${var}} CACHE STRING "Copied from ${var}")
+    endforeach()
+endif()
+
+determine_build_type()
+
+check_gcc4_abi()
+
+############################################################
+
+include_directories(
+  src
+  src/beast
+  src/beast/include
+  src/beast/extras
+  src/nudb/include
+  src/soci/src
+  src/soci/include)
+
+special_build_flags()
+
+############################################################
+
+use_boost(
+  # resist the temptation to alphabetize these. coroutine
+  # must come before context.
+  chrono
+  coroutine
+  context
+  date_time
+  filesystem
+  program_options
+  regex
+  system
+  thread)
+
+use_pthread()
+
+use_openssl(${openssl_min})
+
+use_protobuf()
+
+setup_build_boilerplate()
+
+############################################################
+
+if (is_clang)
+  set(rocks_db_system_header --system-header-prefix=rocksdb2)
+else()
+  unset(rocks_db_system_header)
+endif()
+
+set(soci_extra_includes
+  -I"${CMAKE_SOURCE_DIR}/"src/soci/src/core
+  -I"${CMAKE_SOURCE_DIR}/"src/soci/include/private
+  -I"${CMAKE_SOURCE_DIR}/"src/sqlite)
+
+############################################################
+
+# Unity sources
+prepend(beast_unity_srcs
+src/ripple/beast/unity/
+beast_insight_unity.cpp
+beast_net_unity.cpp
+beast_utility_unity.cpp)
+
+prepend(ripple_unity_srcs
+src/ripple/unity/
+app_ledger.cpp
+app_main.cpp
+app_misc.cpp
+app_paths.cpp
+app_tx.cpp
+conditions.cpp
+core.cpp
+basics.cpp
+crypto.cpp
+ledger.cpp
+net.cpp
+overlay.cpp
+peerfinder.cpp
+json.cpp
+protocol.cpp
+rpcx.cpp
+shamap.cpp
+server.cpp)
+
+prepend(test_unity_srcs
+src/test/unity/
+app_test_unity.cpp
+basics_test_unity.cpp
+beast_test_unity.cpp
+conditions_test_unity.cpp
+core_test_unity.cpp
+json_test_unity.cpp
+ledger_test_unity.cpp
+overlay_test_unity.cpp
+peerfinder_test_unity.cpp
+protocol_test_unity.cpp
+resource_test_unity.cpp
+rpc_test_unity.cpp
+server_test_unity.cpp
+shamap_test_unity.cpp
+support_unity.cpp)
+
+list(APPEND rippled_src_unity ${beast_unity_srcs} ${ripple_unity_srcs} ${test_unity_srcs})
+
+add_with_props(rippled_src_unity src/test/unity/nodestore_test_unity.cpp
+-I"${CMAKE_SOURCE_DIR}/"src/rocksdb2/include
+-I"${CMAKE_SOURCE_DIR}/"src/snappy/snappy
+-I"${CMAKE_SOURCE_DIR}/"src/snappy/config
+${rocks_db_system_header})
+
+add_with_props(rippled_src_unity src/ripple/unity/nodestore.cpp
+-I"${CMAKE_SOURCE_DIR}/"src/rocksdb2/include
+-I"${CMAKE_SOURCE_DIR}/"src/snappy/snappy
+-I"${CMAKE_SOURCE_DIR}/"src/snappy/config
+${rocks_db_system_header})
+
+add_with_props(rippled_src_unity src/ripple/unity/soci_ripple.cpp ${soci_extra_includes})
+
+list(APPEND ripple_unity_srcs ${beast_unity_srcs} ${test_unity_srcs}
+src/ripple/unity/nodestore.cpp
+src/ripple/unity/soci_ripple.cpp
+src/test/unity/nodestore_test_unity.cpp)
+
+############################################################
+
+# Non-unity sources
+file(GLOB_RECURSE core_srcs src/ripple/core/*.cpp)
+add_with_props(rippled_src_nonunity "${core_srcs}"
+    -I"${CMAKE_SOURCE_DIR}/"src/soci/src/core
+    -I"${CMAKE_SOURCE_DIR}/"src/sqlite)
+
+set(non_unity_srcs ${core_srcs})
+
+foreach(curdir
+        beast/clock
+        beast/container
+        beast/insight
+        beast/net
+        beast/utility
+        app
+        basics
+        conditions
+        crypto
+        json
+        ledger
+        legacy
+        net
+        overlay
+        peerfinder
+        protocol
+        rpc
+        server
+        shamap)
+    file(GLOB_RECURSE cursrcs src/ripple/${curdir}/*.cpp)
+    list(APPEND rippled_src_nonunity "${cursrcs}")
+    list(APPEND non_unity_srcs "${cursrcs}")
+endforeach()
+
+file(GLOB_RECURSE nodestore_srcs src/ripple/nodestore/*.cpp
+    src/test/nodestore/*.cpp)
+
+add_with_props(rippled_src_nonunity "${nodestore_srcs}"
+    -I"${CMAKE_SOURCE_DIR}/"src/rocksdb2/include
+    -I"${CMAKE_SOURCE_DIR}/"src/snappy/snappy
+    -I"${CMAKE_SOURCE_DIR}/"src/snappy/config
+    ${rocks_db_system_header})
+
+list(APPEND non_unity_srcs "${nodestore_srcs}")
+
+# unit test sources
+foreach(curdir
+        app
+        basics
+        beast
+        conditions
+        core
+        json
+        ledger
+        nodestore
+        overlay
+        peerfinder
+        protocol
+        resource
+        rpc
+        server
+        shamap
+        jtx)
+    file(GLOB_RECURSE cursrcs src/test/${curdir}/*.cpp)
+    list(APPEND test_srcs "${cursrcs}")
+endforeach()
+
+add_with_props(rippled_src_nonunity "${test_srcs}"
+    -I"${CMAKE_SOURCE_DIR}/"src/rocksdb2/include
+    -I"${CMAKE_SOURCE_DIR}/"src/snappy/snappy
+    -I"${CMAKE_SOURCE_DIR}/"src/snappy/config
+    ${rocks_db_system_header})
+
+list(APPEND non_unity_srcs "${test_srcs}")
+
+if(WIN32 OR is_xcode)
+    # Rippled headers. Only needed for IDEs.
+    file(GLOB_RECURSE rippled_headers src/*.h src/*.hpp)
+    list(APPEND rippled_headers Builds/CMake/CMakeFuncs.cmake)
+    foreach(curdir
+            beast/asio
+            beast/core
+            beast/crypto
+            beast/cxx17
+            beast/hash
+            proto
+            resource
+            validators
+            websocket)
+        file(GLOB_RECURSE cursrcs src/ripple/${curdir}/*.cpp)
+        list(APPEND rippled_headers "${cursrcs}")
+    endforeach()
+    list(APPEND rippled_src_nonunity "${rippled_headers}")
+
+    set_property(
+        SOURCE ${rippled_headers}
+        APPEND
+        PROPERTY HEADER_FILE_ONLY
+        true)
+        # Doesn't work
+        # $<OR:$<CONFIG:Debug>,$<CONFIG:Release>>)
+endif()
+
+if (WIN32 OR is_xcode)
+  # Documentation sources. Only needed for IDEs.
+  prepend(doc_srcs
+    docs/
+    Jamfile.v2
+    boostbook.dtd
+    index.xml
+    main.qbk
+    quickref.xml
+    reference.xsl
+    source.dox)
+
+  set_property(
+    SOURCE ${doc_srcs}
+    APPEND
+    PROPERTY HEADER_FILE_ONLY
+    true)
+    # Doesn't work
+    # $<OR:$<CONFIG:Debug>,$<CONFIG:Release>>)
+endif()
+
+############################################################
+
+add_with_props(rippled_src_all src/ripple/unity/soci.cpp
+  ${soci_extra_includes})
+
+if (NOT is_msvc)
+  set(no_unused_w -Wno-unused-function)
+else()
+  unset(no_unused_w)
+endif()
+
+add_with_props(rippled_src_all src/ripple/unity/secp256k1.cpp
+  -I"${CMAKE_SOURCE_DIR}/"src/secp256k1
+  ${no_unused_w}
+  )
+
+foreach(cursrc
+    src/ripple/beast/unity/beast_hash_unity.cpp
+    src/ripple/unity/beast.cpp
+    src/ripple/unity/lz4.c
+    src/ripple/unity/protobuf.cpp
+    src/ripple/unity/ripple.proto.cpp
+    src/ripple/unity/resource.cpp)
+
+  add_with_props(rippled_src_all ${cursrc}
+    ${rocks_db_system_header}
+    )
+
+endforeach()
+
+if (NOT is_msvc)
+  set(extra_props -Wno-array-bounds)
+else()
+  unset(extra_props)
+endif()
+
+add_with_props(rippled_src_all src/sqlite/sqlite_unity.c
+  ${extra_props})
+
+add_with_props(rippled_src_all src/ripple/unity/ed25519_donna.c
+  -I"${CMAKE_SOURCE_DIR}/"src/ed25519-donna)
+
+if (is_gcc)
+  set(no_init_w -Wno-maybe-uninitialized)
+else()
+  unset(no_init_w)
+endif()
+
+add_with_props(rippled_src_all src/ripple/unity/rocksdb.cpp
+  -I"${CMAKE_SOURCE_DIR}/"src/rocksdb2
+  -I"${CMAKE_SOURCE_DIR}/"src/rocksdb2/include
+  -I"${CMAKE_SOURCE_DIR}/"src/snappy/snappy
+  -I"${CMAKE_SOURCE_DIR}/"src/snappy/config
+  ${no_init_w} ${rocks_db_system_header})
+
+if (NOT is_msvc)
+  set(no_unused_w -Wno-unused-function)
+endif()
+
+add_with_props(rippled_src_all src/ripple/unity/snappy.cpp
+  -I"${CMAKE_SOURCE_DIR}/"src/snappy/snappy
+  -I"${CMAKE_SOURCE_DIR}/"src/snappy/config
+  ${no_unused_w})
+
+if (APPLE AND is_clang)
+  list(APPEND rippled_src_all src/ripple/unity/beastobjc.mm)
+endif()
+
+list(APPEND rippled_src_unity "${rippled_src_all}")
+list(APPEND rippled_src_nonunity "${rippled_src_all}")
+
+############################################################
+
+if (WIN32 OR is_xcode)
+  group_sources(src)
+  group_sources(docs)
+  group_sources(Builds)
+endif()
+
+if(unity)
+    add_executable(rippled ${rippled_src_unity} ${PROTO_HDRS})
+    add_executable(rippled_classic EXCLUDE_FROM_ALL ${rippled_src_nonunity} ${PROTO_HDRS})
+    set(other_target rippled_classic)
+else()
+    add_executable(rippled ${rippled_src_nonunity} ${PROTO_HDRS})
+    add_executable(rippled_unity EXCLUDE_FROM_ALL ${rippled_src_unity} ${PROTO_HDRS})
+    set(other_target rippled_unity)
+endif()
+list(APPEND targets "rippled")
+list(APPEND targets ${other_target})
+# Not the same as EXCLUDE_FROM_ALL. Prevents Visual Studio from building the
+# other_target when the user builds the solution (default when pressing <F7>)
+set_property(TARGET ${other_target} PROPERTY EXCLUDE_FROM_DEFAULT_BUILD true)
+
+find_program(
+  B2_EXE
+  NAMES b2
+  HINTS ${BOOST_ROOT}
+  PATHS ${BOOST_ROOT}
+  DOC "Location of the b2 build executable from Boost")
+if(${B2_EXE} STREQUAL "B2_EXE-NOTFOUND")
+  message(WARNING
+    "Boost b2 executable not found. docs target will not be buildable")
+elseif(NOT BOOST_ROOT)
+    if(Boost_INCLUDE_DIRS)
+        set(BOOST_ROOT ${Boost_INCLUDE_DIRS})
+    else()
+        get_filename_component(BOOST_ROOT ${B2_EXE} DIRECTORY)
+    endif()
+endif()
+# The value for BOOST_ROOT will be determined based on
+#   1) The environment BOOST_ROOT
+#   2) The Boost_INCLUDE_DIRS found by `get_boost`
+#   3) The folder the `b2` executable is found in.
+# If those checks don't yield the correct path, BOOST_ROOT
+# can be defined on the cmake command line:
+#    cmake <path> -DBOOST_ROOT=<boost_path>
+if(BOOST_ROOT)
+    set(B2_PARAMS "-sBOOST_ROOT=${BOOST_ROOT}")
+endif()
+
+# Find bash to help Windows avoid file association problems
+find_program(
+    BASH_EXE
+    NAMES bash sh
+    DOC "Location of the bash shell executable"
+    )
+if(${BASH_EXE} STREQUAL "BASH_EXE-NOTFOUND")
+    message(WARNING
+        "Unable to find bash executable. docs target may not be buildable")
+    set(BASH_EXE "")
+endif()
+
+add_custom_target(docs
+  COMMAND ${CMAKE_COMMAND} -E env "PATH=$ENV{PATH} " ${BASH_EXE} ./makeqbk.sh
+  COMMAND ${B2_EXE} ${B2_PARAMS}
+  BYPRODUCTS "${CMAKE_SOURCE_DIR}/docs/html/index.html"
+  WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}/docs"
+  SOURCES "${doc_srcs}"
+  )
+
+set_startup_project(rippled)
+
+foreach(target IN LISTS targets)
+    target_link_libraries(${target}
+      ${OPENSSL_LIBRARIES} ${PROTOBUF_LIBRARIES} ${SANITIZER_LIBRARIES})
+
+    link_common_libraries(${target})
+endforeach()
+
+if (NOT CMAKE_SIZEOF_VOID_P EQUAL 8)
+  message(WARNING "Rippled requires a 64 bit target architecture.\n"
+    "The most likely cause of this warning is trying to build rippled with a 32-bit OS.")
+endif()

Jamroot

@@ -0,0 +1,11 @@
+#
+# Copyright (c) 2013-2016 Vinnie Falco (vinnie dot falco at gmail dot com)
+#
+# Distributed under the Boost Software License, Version 1.0. (See accompanying
+# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#
+
+import boost ;
+
+boost.use-project ;
+

README.md

@@ -1,129 +1,91 @@
 ![Ripple](/images/ripple.png)
 
-#The World’s Fastest and Most Secure Payment System
+# What is Ripple?
+Ripple is a network of computers which use the [Ripple consensus algorithm]
+(https://www.youtube.com/watch?v=pj1QVb1vlC0) to atomically settle and record
+transactions on a secure distributed database, the Ripple Consensus Ledger
+(RCL). Because of its distributed nature, the RCL offers transaction immutability
+without a central operator. The RCL contains a built-in currency exchange and its
+path-finding algorithm finds competitive exchange rates across order books
+and currency pairs.
 
-**What is Ripple?**
+### Key Features
+- **Distributed**
+  - Direct account-to-account settlement with no central operator
+  - Decentralized global market for competitive FX
+- **Secure**
+  - Transactions are cryptographically signed using ECDSA or Ed25519
+  - Multi-signing capabilities
+- **Scalable**
+  - Capacity to process the world’s cross-border payments volume
+  - Easy access to liquidity through a competitive FX marketplace
 
-Ripple is the open-source, distributed payment protocol that enables instant
-payments with low fees, no chargebacks, and currency flexibility (for example
-dollars, yen, euros, bitcoins, or even loyalty points). Businesses of any size
-can easily build payment solutions such as banking or remittance apps, and
-accelerate the movement of money. Ripple enables the world to move value the
-way it moves information on the Internet.
+## Cross-border payments
+Ripple enables banks to settle cross-border payments in real-time, with
+end-to-end transparency, and at lower costs. Banks can provide liquidity
+for FX themselves or source it from third parties.
 
-![Ripple Network](images/network.png)
+As Ripple adoption grows, so do the number of currencies and counterparties.
+Liquidity providers need to maintain accounts with each counterparty for
+each currency – a capital- and time-intensive endeavor that spreads liquidity
+thin. Further, some transactions, such as exotic currency trades, will require
+multiple trading parties, who each layer costs to the transaction. Thin
+liquidity and many intermediary trading parties make competitive pricing
+challenging.
 
-**What is a Gateway?**
+![Flow - Direct](images/flow1.png)
 
-Ripple works with gateways: independent businesses which hold customer
-deposits in various currencies such as U.S. dollars (USD) or Euros (EUR),
-in exchange for providing cryptographically-signed issuances that users can
-send and trade with one another in seconds on the Ripple network. Within the
-protocol, exchanges between multiple currencies can occur atomically without
-any central authority to monitor them. Later, customers can withdraw their
-Ripple balances from the gateways that created those issuances.
+### XRP as a Bridge Currency
+Ripple can bridge even exotic currency pairs directly through XRP. Similar to
+USD in today’s currency market, XRP allows liquidity providers to focus on
+offering competitive FX rates on fewer pairs and adding depth to order books.
+Unlike USD, trading through XRP does not require bank accounts, service fees,
+counterparty risk, or additional operational costs. By using XRP, liquidity
+providers can specialize in certain currency corridors, reduce operational
+costs, and ultimately, offer more competitive FX pricing.
 
-**How do Ripple payments work?**
+![Flow - Bridged over XRP](images/flow2.png)
 
-A sender specifies the amount and currency the recipient should receive and
-Ripple automatically converts the sender’s available currencies using the
-distributed order books integrated into the Ripple protocol. Independent third
-parties acting as  market makers provide liquidity in these order books.
+# rippled - Ripple server
+`rippled` is the reference server implementation of the Ripple
+protocol. To learn more about how to build and run a `rippled`
+server, visit https://ripple.com/build/rippled-setup/
 
-Ripple uses a pathfinding algorithm that considers currency pairs when
-converting from the source to the destination currency. This algorithm searches
-for a series of currency swaps that gives the user the lowest cost. Since
-anyone can participate as a market maker, market forces drive fees to the
-lowest practical level.
+[![travis-ci.org: Build Status](https://travis-ci.org/ripple/rippled.png?branch=develop)](https://travis-ci.org/ripple/rippled)
+[![codecov.io: Code Coverage](https://codecov.io/gh/ripple/rippled/branch/develop/graph/badge.svg)](https://codecov.io/gh/ripple/rippled)
 
-**What can you do with Ripple?**
+### License
+`rippled` is open source and permissively licensed under the
+ISC license. See the LICENSE file for more details.
 
-The protocol is entirely open-source and the network’s shared ledger is public
-information, so no central authority prevents anyone from participating. Anyone
-can become a market maker, create a wallet or a gateway, or monitor network
-behavior. Competition drives down spreads and fees, making the network useful
-to everyone.
+#### Repository Contents
 
+| Folder  | Contents |
+|---------|----------|
+| ./bin   | Scripts and data files for Ripple integrators. |
+| ./build | Intermediate and final build outputs.          |
+| ./Builds| Platform or IDE-specific project files.        |
+| ./doc   | Documentation and example configuration files. |
+| ./src   | Source code.                                   |
 
-###Key Protocol Features
-1. XRP is Ripple’s native [cryptocurrency]
-(http://en.wikipedia.org/wiki/Cryptocurrency) with a fixed supply that
-decreases slowly over time, with no mining. XRP acts as a bridge currency, and
-pays for transaction fees that protect the network against spam.
-![XRP as a bridge currency](/images/vehicle_currency.png)
+Some of the directories under `src` are external repositories inlined via
+git-subtree. See the corresponding README for more details.
 
-2. Pathfinding discovers cheap and efficient payment paths through multiple
-[order books](https://www.ripplecharts.com) allowing anyone to [trade](https://www.rippletrade.com) anything. When two accounts aren’t linked by relationships of trust, the Ripple pathfinding engine considers intermediate links and order books to produce a set of possible paths the transaction can take. When the payment is processed, the liquidity along these paths is iteratively consumed in best-first order.
-![Pathfinding from Dollars to Euro](/images/pathfinding.png)
+##For more information:
 
-3. [Consensus](https://www.youtube.com/watch?v=pj1QVb1vlC0) confirms
-transactions in an atomic fashion, without mining, ensuring efficient use of
-resources.
+* [Ripple Knowledge Center](https://ripple.com/learn/)
+* [Ripple Developer Center](https://ripple.com/build/)
+* [Ripple Whitepapers & Reports](https://ripple.com/whitepapers-reports/)
+  * [Ripple Consensus Whitepaper](https://ripple.com/consensus-whitepaper/)
+  * [Ripple Solutions Guide](https://ripple.com/files/ripple_solutions_guide.pdf)
 
-[transact]: https://ripple.com/files/ripple-FIs.pdf
-[build]:    https://ripple.com/build/
-
-[transact.png]:   /images/transact.png
-[build.png]:      /images/build.png
-[contribute.png]: /images/contribute.png
-
-###Join The Ripple Community
-|![Transact][transact.png]|![Build][build.png]|![Contribute][contribute.png]|
-|:-----------------------:|:-----------------:|:---------------------------:|
-|[Transact on the fastest payment infrastructure][transact]|[Build Imaginative Apps][build]|Contribute to the Ripple Protocol Implementation|
-
-#rippled - Ripple P2P server
-
-##[![Build Status](https://travis-ci.org/ripple/rippled.png?branch=develop)](https://travis-ci.org/ripple/rippled)
-
-This is the repository for Ripple's `rippled`, reference P2P server.
-
-###Build instructions:
-* https://ripple.com/wiki/Rippled_build_instructions
-
-###Setup instructions:
-* https://ripple.com/wiki/Rippled_setup_instructions
-
-###Issues
-* https://ripplelabs.atlassian.net/browse/RIPD
-
-### Repository Contents
-
-#### ./bin
-Scripts and data files for Ripple integrators.
-
-#### ./build
-Intermediate and final build outputs.
-
-#### ./Builds
-Platform or IDE-specific project files.
-
-#### ./doc
-Documentation and example configuration files.
-
-#### ./src
-Source code directory. Some of the directories contained here are
-external repositories inlined via git-subtree, see the corresponding
-README for more details.
-
-#### ./test
-Javascript / Mocha tests.
-
-## License
-Ripple is open source and permissively licensed under the ISC license. See the
-LICENSE file for more details.
-
-###For more information:
-* Ripple Wiki - https://ripple.com/wiki/
-* Ripple Primer - https://ripple.com/ripple_primer.pdf
-* Ripple Primer (Market Making) - https://ripple.com/ripple-mm.pdf
-* Ripple Gateway Primer - https://ripple.com/ripple-gateways.pdf
-* Consensus - https://wiki.ripple.com/Consensus
+To learn about how Ripple is transforming global payments visit
+[https://ripple.com/contact/](https://ripple.com/contact/)
 
 - - -
 
 Copyright © 2015, Ripple Labs. All rights reserved.
 
-Portions of this document, including but not limited to the Ripple logo, images
-and image templates are the property of Ripple Labs and cannot be copied or
-used without permission.
+Portions of this document, including but not limited to the Ripple logo,
+images and image templates are the property of Ripple Labs and cannot be
+copied or used without permission.

SConstruct

@@ -61,10 +61,16 @@ The following environment variables modify the build environment:
       Path to the boost directory.
     OPENSSL_ROOT
       Path to the openssl directory.
-    PROTOBUF_DIR
-      Path to the protobuf directory. This is usually only needed when
-      the installed protobuf library uses a different ABI than clang
-      (as with ubuntu 15.10).
+    PROTOBUF_ROOT
+      Path to the protobuf directory.
+    CLANG_PROTOBUF_ROOT
+      Override the path to the protobuf directory for the clang toolset. This is
+      usually only needed when the installed protobuf library uses a different
+      ABI than clang (as with ubuntu 15.10).
+    CLANG_BOOST_ROOT
+      Override the path to the boost directory for the clang toolset. This is
+      usually only needed when the installed protobuf library uses a different
+      ABI than clang (as with ubuntu 15.10).
 
 The following extra options may be used:
     --ninja         Generate a `build.ninja` build file for the specified target
@@ -73,6 +79,10 @@ The following extra options may be used:
 
     --static        On linux, link protobuf, openssl, libc++, and boost statically
 
+    --sanitize=[address, thread]  On gcc & clang, add sanitizer instrumentation
+
+    --assert Enable asserts, even in release builds.
+
 GCC 5: If the gcc toolchain is used, gcc version 5 or better is required. On
     linux distros that ship with gcc 4 (ubuntu < 15.10), rippled will force gcc
     to use gcc4's ABI (there was an ABI change between versions). This allows us
@@ -105,13 +115,19 @@ TODO
 
 import collections
 import os
+import platform
 import subprocess
 import sys
 import textwrap
 import time
+import glob
 import SCons.Action
 
-sys.path.append(os.path.join('src', 'beast', 'site_scons'))
+if (not platform.machine().endswith('64')):
+    print('Warning: Detected {} architecture. Rippled requires a 64-bit OS.'.format(
+          platform.machine()));
+
+sys.path.append(os.path.join('src', 'ripple', 'beast', 'site_scons'))
 sys.path.append(os.path.join('src', 'ripple', 'site_scons'))
 
 import Beast
@@ -122,9 +138,15 @@ import scons_to_ninja
 AddOption('--ninja', dest='ninja', action='store_true',
           help='generate ninja build file build.ninja')
 
+AddOption('--sanitize', dest='sanitize', choices=['address', 'thread'],
+          help='Build with sanitizer support (gcc and clang only).')
+
 AddOption('--static', dest='static', action='store_true',
           help='On linux, link protobuf, openssl, libc++, and boost statically')
 
+AddOption('--assert', dest='assert', action='store_true',
+          help='Enable asserts, even in release mode')
+
 def parse_time(t):
     l = len(t.split())
     if l==5:
@@ -348,24 +370,9 @@ def config_base(env):
         ,{'HAVE_USLEEP' : '1'}
         ,{'SOCI_CXX_C11' : '1'}
         ,'_SILENCE_STDEXT_HASH_DEPRECATION_WARNINGS'
-        ,'-DBOOST_NO_AUTO_PTR'
+        ,'BOOST_NO_AUTO_PTR'
         ])
 
-    try:
-        BOOST_ROOT = os.path.normpath(os.environ['BOOST_ROOT'])
-        env.Append(LIBPATH=[
-            os.path.join(BOOST_ROOT, 'stage', 'lib'),
-            ])
-        env['BOOST_ROOT'] = BOOST_ROOT
-    except KeyError:
-        pass
-
-    try:
-        protobuf_dir = os.environ['PROTOBUF_DIR']
-        env.Append(LIBPATH=[protobuf_dir])
-    except KeyError:
-        pass
-
     if Beast.system.windows:
         try:
             OPENSSL_ROOT = os.path.normpath(os.environ['OPENSSL_ROOT'])
@@ -378,11 +385,15 @@ def config_base(env):
         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])
+        try:
+            openssl = subprocess.check_output(['brew', '--prefix','openssl'],
+                                              stderr=subprocess.STDOUT).strip()
+            env.Prepend(CPPPATH='%s/include' % openssl)
+            env.Prepend(LIBPATH=['%s/lib' % openssl])
+        except:
+            pass
+        if not 'vcxproj' in COMMAND_LINE_TARGETS:
+            env.Append(CPPDEFINES=['NO_LOG_UNHANDLED_EXCEPTIONS'])
 
     # handle command-line arguments
     profile_jemalloc = ARGUMENTS.get('profile-jemalloc')
@@ -400,7 +411,7 @@ def add_static_libs(env, static_libs, dyn_libs=None):
     for k,l in [('STATICLIBS', static_libs or []), ('DYNAMICLIBS', dyn_libs or [])]:
         c = env.get(k, '')
         for f in l:
-            c += ' -l' + f 
+            c += ' -l' + f
         env[k] = c
 
 def get_libs(lib, static):
@@ -425,33 +436,90 @@ def get_libs(lib, static):
             else:
                 static_libs.append(l)
         return (static_libs, dynamic_libs)
-    except:
-        raise Exception('pkg-config failed for ' + lib)
+    except Exception as e:
+        raise Exception('pkg-config failed for ' + lib + '; Exception: ' + str(e))
 
-# Set toolchain and variant specific construction variables
-def config_env(toolchain, variant, env):
-    if is_debug_variant(variant):
-        env.Append(CPPDEFINES=['DEBUG', '_DEBUG'])
+def add_sanitizer (toolchain, env):
+    san = GetOption('sanitize')
+    if not san: return
+    san_to_lib = {'address': 'asan', 'thread': 'tsan'}
+    if toolchain not in Split('clang gcc'):
+        raise Exception("Sanitizers are only supported for gcc and clang")
+    env.Append(CCFLAGS=['-fsanitize='+san, '-fno-omit-frame-pointer'])
+    env.Append(LINKFLAGS=['-fsanitize='+san])
+    add_static_libs(env, [san_to_lib[san]])
+    env.Append(CPPDEFINES=['SANITIZER='+san_to_lib[san].upper()])
 
-    elif variant == 'release' or variant == 'profile':
-        env.Append(CPPDEFINES=['NDEBUG'])
+def add_boost_and_protobuf(toolchain, env):
+    def get_environ_value(candidates):
+        for c in candidates:
+            try:
+                return os.environ[c]
+            except KeyError:
+                pass
+        raise KeyError('Environment variable not set')
 
-    if 'BOOST_ROOT' in env:
-        if toolchain == 'gcc':
+    try:
+        br_cands = ['CLANG_BOOST_ROOT'] if toolchain == 'clang' else []
+        br_cands.append('BOOST_ROOT')
+        BOOST_ROOT = os.path.normpath(get_environ_value(br_cands))
+        stage64_path = os.path.join(BOOST_ROOT, 'stage64', 'lib')
+        if os.path.exists(stage64_path):
+          env.Append(LIBPATH=[
+              stage64_path,
+              ])
+        else:
+          env.Append(LIBPATH=[
+              os.path.join(BOOST_ROOT, 'stage', 'lib'),
+              ])
+        env['BOOST_ROOT'] = BOOST_ROOT
+        if toolchain in ['gcc', 'clang']:
             env.Append(CCFLAGS=['-isystem' + env['BOOST_ROOT']])
         else:
             env.Append(CPPPATH=[
                 env['BOOST_ROOT'],
                 ])
+    except KeyError:
+        pass
+
+    try:
+        pb_cands = ['CLANG_PROTOBUF_ROOT'] if toolchain == 'clang' else []
+        pb_cands.append('PROTOBUF_ROOT')
+        PROTOBUF_ROOT = os.path.normpath(get_environ_value(pb_cands))
+        env.Append(LIBPATH=[PROTOBUF_ROOT + '/src/.libs'])
+        if not should_link_static() and toolchain in['clang', 'gcc']:
+            env.Append(LINKFLAGS=['-Wl,-rpath,' + PROTOBUF_ROOT + '/src/.libs'])
+        env['PROTOBUF_ROOT'] = PROTOBUF_ROOT
+        env.Append(CPPPATH=[env['PROTOBUF_ROOT'] + '/src',])
+    except KeyError:
+        pass
+
+def enable_asserts ():
+    return GetOption('assert')
+
+# Set toolchain and variant specific construction variables
+def config_env(toolchain, variant, env):
+    add_boost_and_protobuf(toolchain, env)
+    env.Append(CPPDEFINES=[
+        'BOOST_COROUTINE_NO_DEPRECATION_WARNING',
+        'BOOST_COROUTINES_NO_DEPRECATION_WARNING'
+        ])
+    if is_debug_variant(variant):
+        env.Append(CPPDEFINES=['DEBUG', '_DEBUG'])
+
+    elif (variant == 'release' or variant == 'profile') and (not enable_asserts()):
+        env.Append(CPPDEFINES=['NDEBUG'])
 
     if should_link_static() and not Beast.system.linux:
         raise Exception("Static linking is only implemented for linux.")
 
+    add_sanitizer(toolchain, env)
+
     if toolchain in Split('clang gcc'):
         if Beast.system.linux:
             link_static = should_link_static()
             for l in ['openssl', 'protobuf']:
-                static, dynamic = get_libs(l, link_static) 
+                static, dynamic = get_libs(l, link_static)
                 if link_static:
                     add_static_libs(env, static, dynamic)
                 else:
@@ -490,7 +558,8 @@ def config_env(toolchain, variant, env):
         env.Append(CXXFLAGS=[
             '-frtti',
             '-std=c++14',
-            '-Wno-invalid-offsetof'])
+            '-Wno-invalid-offsetof'
+            ])
 
         env.Append(CPPDEFINES=['_FILE_OFFSET_BITS=64'])
 
@@ -524,6 +593,9 @@ def config_env(toolchain, variant, env):
                     ])
 
         boost_libs = [
+            # resist the temptation to alphabetize these. coroutine
+            # must come before context.
+            'boost_chrono',
             'boost_coroutine',
             'boost_context',
             'boost_date_time',
@@ -540,9 +612,13 @@ def config_env(toolchain, variant, env):
         else:
             # We prefer static libraries for boost
             if env.get('BOOST_ROOT'):
+                static_libs64 = ['%s/stage64/lib/lib%s.a' % (env['BOOST_ROOT'], l) for
+                               l in boost_libs]
                 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):
+                if all(os.path.exists(f) for f in static_libs64):
+                    boost_libs = [File(f) for f in static_libs64]
+                elif all(os.path.exists(f) for f in static_libs):
                     boost_libs = [File(f) for f in static_libs]
             env.Append(LIBS=boost_libs)
 
@@ -601,9 +677,6 @@ def config_env(toolchain, variant, env):
             # extra error checking into the code (e.g. std::vector will throw
             # for out-of-bounds conditions)
             if is_debug_variant(variant):
-                env.Append(CPPDEFINES={
-                    '_FORTIFY_SOURCE': 2
-                    })
                 env.Append(CCFLAGS=[
                     '-O0'
                     ])
@@ -635,6 +708,7 @@ def config_env(toolchain, variant, env):
             '/wd"4244"',
             '/wd"4267"',
             '/wd"4800"',            # Disable C4800 (int to bool performance)
+            '/wd"4503"',            # Disable C4503 (Decorated name length exceeded)
             ])
         env.Append(CPPDEFINES={
             '_WIN32_WINNT' : '0x6000',
@@ -643,6 +717,7 @@ def config_env(toolchain, variant, env):
             '_SCL_SECURE_NO_WARNINGS',
             '_CRT_SECURE_NO_WARNINGS',
             'WIN32_CONSOLE',
+            'NOMINMAX'
             ])
         if variant == 'debug':
             env.Append(LIBS=[
@@ -710,7 +785,7 @@ 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')],
+    toolpath=[os.path.join ('src', 'ripple', 'beast', 'site_scons', 'site_tools')],
     tools=['default', 'Protoc', 'VSProject'],
     ENV=os.environ,
     TARGET_ARCH='x86_64')
@@ -719,6 +794,9 @@ config_base(base)
 base.Append(CPPPATH=[
     'src',
     os.path.join('src', 'beast'),
+    os.path.join('src', 'beast', 'include'),
+    os.path.join('src', 'beast', 'extras'),
+    os.path.join('src', 'nudb', 'include'),
     os.path.join(build_dir, 'proto'),
     os.path.join('src','soci','src'),
     os.path.join('src','soci','include'),
@@ -852,8 +930,14 @@ def get_classic_sources(toolchain):
             'src/soci/src/core',
             'src/sqlite']
     )
+    append_sources(result, *list_sources('src/ripple/beast/clock', '.cpp'))
+    append_sources(result, *list_sources('src/ripple/beast/container', '.cpp'))
+    append_sources(result, *list_sources('src/ripple/beast/insight', '.cpp'))
+    append_sources(result, *list_sources('src/ripple/beast/net', '.cpp'))
+    append_sources(result, *list_sources('src/ripple/beast/utility', '.cpp'))
     append_sources(result, *list_sources('src/ripple/app', '.cpp'))
     append_sources(result, *list_sources('src/ripple/basics', '.cpp'))
+    append_sources(result, *list_sources('src/ripple/conditions', '.cpp'))
     append_sources(result, *list_sources('src/ripple/crypto', '.cpp'))
     append_sources(result, *list_sources('src/ripple/json', '.cpp'))
     append_sources(result, *list_sources('src/ripple/ledger', '.cpp'))
@@ -864,9 +948,24 @@ def get_classic_sources(toolchain):
     append_sources(result, *list_sources('src/ripple/protocol', '.cpp'))
     append_sources(result, *list_sources('src/ripple/rpc', '.cpp'))
     append_sources(result, *list_sources('src/ripple/shamap', '.cpp'))
-    append_sources(result, *list_sources('src/ripple/test', '.cpp'))
-    append_sources(result, *list_sources('src/ripple/unl', '.cpp'))
+    append_sources(result, *list_sources('src/ripple/server', '.cpp'))
+    append_sources(result, *list_sources('src/test/app', '.cpp'))
+    append_sources(result, *list_sources('src/test/basics', '.cpp'))
+    append_sources(result, *list_sources('src/test/beast', '.cpp'))
+    append_sources(result, *list_sources('src/test/conditions', '.cpp'))
+    append_sources(result, *list_sources('src/test/core', '.cpp'))
+    append_sources(result, *list_sources('src/test/json', '.cpp'))
+    append_sources(result, *list_sources('src/test/ledger', '.cpp'))
+    append_sources(result, *list_sources('src/test/overlay', '.cpp'))
+    append_sources(result, *list_sources('src/test/peerfinder', '.cpp'))
+    append_sources(result, *list_sources('src/test/protocol', '.cpp'))
+    append_sources(result, *list_sources('src/test/resource', '.cpp'))
+    append_sources(result, *list_sources('src/test/rpc', '.cpp'))
+    append_sources(result, *list_sources('src/test/server', '.cpp'))
+    append_sources(result, *list_sources('src/test/shamap', '.cpp'))
+    append_sources(result, *list_sources('src/test/jtx', '.cpp'))
 
+    
     if use_shp(toolchain):
         cc_flags = {'CCFLAGS': ['--system-header-prefix=rocksdb2']}
     else:
@@ -874,7 +973,7 @@ def get_classic_sources(toolchain):
 
     append_sources(
         result,
-        *list_sources('src/ripple/nodestore', '.cpp'),
+        *(list_sources('src/ripple/nodestore', '.cpp') + list_sources('src/test/nodestore', '.cpp')),
         CPPPATH=[
             'src/rocksdb2/include',
             'src/snappy/snappy',
@@ -891,12 +990,15 @@ def get_unity_sources(toolchain):
     result = []
     append_sources(
         result,
+        'src/ripple/beast/unity/beast_insight_unity.cpp',
+        'src/ripple/beast/unity/beast_net_unity.cpp',
+        'src/ripple/beast/unity/beast_utility_unity.cpp',
         'src/ripple/unity/app_ledger.cpp',
         'src/ripple/unity/app_main.cpp',
         'src/ripple/unity/app_misc.cpp',
         'src/ripple/unity/app_paths.cpp',
-        'src/ripple/unity/app_tests.cpp',
         'src/ripple/unity/app_tx.cpp',
+        'src/ripple/unity/conditions.cpp',
         'src/ripple/unity/core.cpp',
         'src/ripple/unity/basics.cpp',
         'src/ripple/unity/crypto.cpp',
@@ -908,8 +1010,22 @@ def get_unity_sources(toolchain):
         'src/ripple/unity/protocol.cpp',
         'src/ripple/unity/rpcx.cpp',
         'src/ripple/unity/shamap.cpp',
-        'src/ripple/unity/test.cpp',
-        'src/ripple/unity/unl.cpp',
+        'src/ripple/unity/server.cpp',
+        'src/test/unity/app_test_unity.cpp',
+        'src/test/unity/basics_test_unity.cpp',
+        'src/test/unity/beast_test_unity.cpp',
+        'src/test/unity/core_test_unity.cpp',
+        'src/test/unity/conditions_test_unity.cpp',
+        'src/test/unity/json_test_unity.cpp',
+        'src/test/unity/ledger_test_unity.cpp',
+        'src/test/unity/overlay_test_unity.cpp',
+        'src/test/unity/peerfinder_test_unity.cpp',
+        'src/test/unity/protocol_test_unity.cpp',
+        'src/test/unity/resource_test_unity.cpp',
+        'src/test/unity/rpc_test_unity.cpp',
+        'src/test/unity/server_test_unity.cpp',
+        'src/test/unity/shamap_test_unity.cpp',
+        'src/test/unity/support_unity.cpp'
     )
 
     if use_shp(toolchain):
@@ -920,6 +1036,7 @@ def get_unity_sources(toolchain):
     append_sources(
         result,
         'src/ripple/unity/nodestore.cpp',
+        'src/test/unity/nodestore_test_unity.cpp',
         CPPPATH=[
             'src/rocksdb2/include',
             'src/snappy/snappy',
@@ -1030,37 +1147,23 @@ for tu_style in ['classic', 'unity']:
             for s, k in sources:
                 object_builder.add_source_files(*s, **k)
 
-            git_commit_tag = {}
-            if toolchain != 'msvc':
-                git = Beast.Git(env)
-                if git.exists:
-                    id = '%s+%s.%s' % (git.tags, git.user, git.branch)
-                    git_commit_tag = {'CPPDEFINES':
-                                      {'GIT_COMMIT_ID' : '\'"%s"\'' % id }}
-
-            object_builder.add_source_files(
-                'src/ripple/unity/git_id.cpp',
-                **git_commit_tag)
-
             if use_shp(toolchain):
                 cc_flags = {'CCFLAGS': ['--system-header-prefix=rocksdb2']}
             else:
                 cc_flags = {}
 
             object_builder.add_source_files(
-                'src/beast/beast/unity/hash_unity.cpp',
+                'src/ripple/beast/unity/beast_hash_unity.cpp',
                 'src/ripple/unity/beast.cpp',
                 'src/ripple/unity/lz4.c',
                 'src/ripple/unity/protobuf.cpp',
                 'src/ripple/unity/ripple.proto.cpp',
                 'src/ripple/unity/resource.cpp',
-                'src/ripple/unity/server.cpp',
-                'src/ripple/unity/websocket02.cpp',
                 **cc_flags
             )
 
             object_builder.add_source_files(
-                'src/ripple/unity/beastc.c',
+                'src/sqlite/sqlite_unity.c',
                 CCFLAGS = ([] if toolchain == 'msvc' else ['-Wno-array-bounds']))
 
             if 'gcc' in toolchain:
@@ -1071,7 +1174,7 @@ for tu_style in ['classic', 'unity']:
                 cc_flags = {}
 
             object_builder.add_source_files(
-                'src/ripple/unity/ed25519.c',
+                'src/ripple/unity/ed25519_donna.c',
                 CPPPATH=[
                     'src/ed25519-donna',
                 ]
@@ -1097,11 +1200,6 @@ for tu_style in ['classic', 'unity']:
                 ]
             )
 
-            object_builder.add_source_files(
-                'src/ripple/unity/websocket04.cpp',
-                CPPPATH='src/websocketpp',
-            )
-
             if toolchain == "clang" and Beast.system.osx:
                 object_builder.add_source_files('src/ripple/unity/beastobjc.mm')
 
@@ -1145,7 +1243,13 @@ for key, value in aliases.iteritems():
 vcxproj = base.VSProject(
     os.path.join('Builds', 'VisualStudio2015', 'RippleD'),
     source = [],
-    VSPROJECT_ROOT_DIRS = ['src/beast', 'src', '.'],
+    VSPROJECT_ROOT_DIRS = [
+        'build/',
+        'src/beast/extras',
+        'src/beast/include',
+        'src/nudb/include',
+        'src',
+        '.'],
     VSPROJECT_CONFIGS = msvc_configs)
 base.Alias('vcxproj', vcxproj)
 
@@ -1167,10 +1271,10 @@ def do_count(target, source, env):
                     path = os.path.join(parent, path)
                     r = os.path.splitext(path)
                     if r[1] in suffixes:
-                        if r[0].endswith('.test'):
+                        if r[0].endswith('_test'):
                             yield os.path.normpath(path)
         return list(_iter(base))
-    testfiles = list_testfiles(os.path.join('src', 'ripple'), env.get('CPPSUFFIXES'))
+    testfiles = list_testfiles(os.path.join('src', 'test'), env.get('CPPSUFFIXES'))
     lines = 0
     for f in testfiles:
         lines = lines + sum(1 for line in open(f))

appveyor.yml

@@ -6,22 +6,39 @@ environment:
   # that it's a small download. We also use appveyor's free cache, avoiding fees
   # downloading from S3 each time. 
   # TODO: script to create this package.
-  RIPPLED_DEPS_URL: https://ripple.github.io/Downloads/appveyor/rippled_deps15.01.zip
+  RIPPLED_DEPS_PATH: rippled_deps15.02
+  RIPPLED_DEPS_URL: https://ripple.github.io/Downloads/appveyor/%RIPPLED_DEPS_PATH%.zip
 
   # Other dependencies we just download each time.
-  PIP_URL: https://bootstrap.pypa.io/get-pip.py
-  PYWIN32_URL: https://downloads.sourceforge.net/project/pywin32/pywin32/Build%20219/pywin32-219.win-amd64-py2.7.exe
+  PIP_PATH: get-pip.py
+  PIP_URL: https://bootstrap.pypa.io/%PIP_PATH%
+  # The % in this URL messes up variable substition, so any updates will
+  # need to update both PYWIN32_PATH and PYWIN32_URL
+  PYWIN32_PATH: pywin32-220.win-amd64-py2.7.exe
+  PYWIN32_URL: https://downloads.sourceforge.net/project/pywin32/pywin32/Build%20220/pywin32-220.win-amd64-py2.7.exe
 
   # Scons honours these environment variables, setting the include/lib paths.
-  BOOST_ROOT: C:/rippled_deps15.01/boost
-  OPENSSL_ROOT: C:/rippled_deps15.01/openssl
+  BOOST_ROOT: C:/%RIPPLED_DEPS_PATH%/boost
+  OPENSSL_ROOT: C:/%RIPPLED_DEPS_PATH%/openssl
+
+  matrix:
+  # This build works, but our current Appveyor config runs matrix builds
+  # sequentially, and the one build is already slow enough.
+  # - build: scons
+  #   target: msvc.debug
+  - build: cmake
+    target: msvc.debug
+    buildconfig: Debug
 
 os: Visual Studio 2015
 
-# At the end of each successful build we cache this directory. It must be less
-# than 100MB total compressed.
+# At the end of each successful build we cache this directory.
+# https://www.appveyor.com/docs/build-cache/
+# Resulting archive should not exceed 100 MB.
 cache:
-  - "C:\\rippled_deps15.01"
+  - 'C:\%RIPPLED_DEPS_PATH%'
+  - '%PIP_PATH%'
+  - '%PYWIN32_PATH%'
 
 # This means we'll download a zip of the branch we want, rather than the full
 # history.
@@ -29,36 +46,37 @@ shallow_clone: true
 
 install:
   # We want easy_install, python and protoc.exe on PATH.
-  - SET PATH=%PYTHON%;%PYTHON%/Scripts;C:/rippled_deps15.01;%PATH%
+  - SET PATH=%PYTHON%;%PYTHON%/Scripts;C:/%RIPPLED_DEPS_PATH%;%PATH%
 
   # `ps` prefix means the command is executed by powershell.
-  - ps: Start-FileDownload $env:PIP_URL
-  - ps: Start-FileDownload $env:PYWIN32_URL
-
-  # Installing pip will install setuptools/easy_install.
-  - python get-pip.py
-
-  # Pip has some problems installing scons on windows so we use easy install.
-  - easy_install scons
-
-  # Scons has problems with parallel builds on windows without pywin32.
-  - easy_install pywin32-219.win-amd64-py2.7.exe
-  # (easy_install can do headless installs of .exe wizards)
+  - ps: |
+        if ($env:build -eq "scons") {
+          if(-not(Test-Path $env:PIP_PATH)) {
+            echo "Download from $env:PIP_URL"
+            Start-FileDownload $env:PIP_URL
+          }
+          if(-not(Test-Path $env:PYWIN32_PATH)) {
+            echo "Download from $env:PYWIN32_URL"
+            Start-FileDownload $env:PYWIN32_URL
+          }
+        }
+  - bin/ci/windows/install-dependencies.bat
 
   # Download dependencies if appveyor didn't restore them from the cache.
   # Use 7zip to unzip.
   - ps: |
-        if (-not(Test-Path 'C:/rippled_deps15.01')) {
+        if (-not(Test-Path 'C:/$env:RIPPLED_DEPS_PATH')) {
             echo "Download from $env:RIPPLED_DEPS_URL"
             Start-FileDownload "$env:RIPPLED_DEPS_URL"
-            7z x rippled_deps15.01.zip -oC:\ -y > $null
+            7z x "$($env:RIPPLED_DEPS_PATH).zip" -oC:\ -y > $null
+            if ($LastExitCode -ne 0) { throw "7z failed" }
         }
 
   # Newer DEPS include a versions file.
   # Dump it so we can verify correct behavior.
   - ps: |
-        if (Test-Path 'C:/rippled_deps15.01/versions.txt') {
-          cat 'C:/rippled_deps15.01/versions.txt'
+        if (Test-Path "C:/$env:RIPPLED_DEPS_PATH/versions.txt") {
+          cat "C:/$env:RIPPLED_DEPS_PATH/versions.txt"
         }
 
 # TODO: This is giving me grief
@@ -71,17 +89,46 @@ build_script:
   - '"%VS140COMNTOOLS%../../VC/vcvarsall.bat" x86_amd64'
   # Show which version of the compiler we are using.
   - cl
-  - scons msvc.debug -j%NUMBER_OF_PROCESSORS%
+  - ps: |
+        if ($env:build -eq "scons") {
+          # Build with scons
+          scons $env:target -j%NUMBER_OF_PROCESSORS%
+          if ($LastExitCode -ne 0) { throw "scons build failed" }
+        }
+        else
+        {
+          # Build with cmake
+          cmake --version
+          $cmake_target="$($env:target).ci"
+          "$cmake_target"
+          New-Item -ItemType Directory -Force -Path "build/$cmake_target"
+          Push-Location "build/$cmake_target"
+          cmake -G"Visual Studio 14 2015 Win64" -Dtarget="$cmake_target" ../..
+          if ($LastExitCode -ne 0) { throw "CMake failed" }
+          cmake --build . --config $env:buildconfig -- -m
+          if ($LastExitCode -ne 0) { throw "CMake build failed" }
+          Pop-Location
+        }
 
 after_build:
-  # Put our executable in a place where npm test can find it.
-  - ps: cp build/msvc.debug/rippled.exe build
-  - ps: ls build
+  - ps: |
+        if ($env:build -eq "scons") {
+          cp build/$($env:target)/rippled.exe build
+          ls build
+          $exe="build/rippled"
+        }
+        else
+        {
+          $exe="build/$cmake_target/$env:buildconfig/rippled"
+        }
+        "Exe is at $exe"
 
 test_script:
-  # Run the unit tests
-  - build\\rippled --unittest
+  - ps: |
+        & {
+          # Run the rippled unit tests
+          & $exe --unittest
+          # https://connect.microsoft.com/PowerShell/feedback/details/751703/option-to-stop-script-if-command-line-exe-fails
+          if ($LastExitCode -ne 0) { throw "Unit tests failed" }
+        }
 
-  # Run the integration tests
-  - npm install
-  - npm test

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

@@ -1,41 +1,92 @@
 #!/bin/bash -u
 # We use set -e and bash with -u to bail on first non zero exit code of any
-# processes launched or upon any unbound variable
-set -e
+# processes launched or upon any unbound variable.
+# We use set -x to print commands before running them to help with
+# debugging.
+set -ex
 __dirname=$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )
 echo "using CC: $CC"
 echo "using TARGET: $TARGET"
-export RIPPLED_PATH="$PWD/build/$CC.$TARGET/rippled"
-echo "using RIPPLED_PATH: $RIPPLED_PATH"
-# Make sure vcxproj is up to date
-scons vcxproj
-git diff --exit-code
-# $CC will be either `clang` or `gcc`
-# http://docs.travis-ci.com/user/migrating-from-legacy/?utm_source=legacy-notice&utm_medium=banner&utm_campaign=legacy-upgrade
-#   indicates that 2 cores are available to containers.
-scons -j${NUM_PROCESSORS:-2} $CC.$TARGET
+
+# Ensure APP defaults to rippled if it's not set.
+: ${APP:=rippled}
+if [[ ${BUILD:-scons} == "cmake" ]]; then
+  echo "cmake building ${APP}"
+  CMAKE_TARGET=$CC.$TARGET
+  if [[ ${CI:-} == true ]]; then
+    CMAKE_TARGET=$CMAKE_TARGET.ci
+  fi
+  mkdir -p "build/${CMAKE_TARGET}"
+  pushd "build/${CMAKE_TARGET}"
+  cmake ../.. -Dtarget=$CMAKE_TARGET
+  cmake --build . -- -j${NUM_PROCESSORS:-2}
+  popd
+  export APP_PATH="$PWD/build/${CMAKE_TARGET}/${APP}"
+  echo "using APP_PATH: $APP_PATH"
+
+else
+  export APP_PATH="$PWD/build/$CC.$TARGET/${APP}"
+  echo "using APP_PATH: $APP_PATH"
+  # Make sure vcxproj is up to date
+  scons vcxproj
+  git diff --exit-code
+  # $CC will be either `clang` or `gcc`
+  # http://docs.travis-ci.com/user/migrating-from-legacy/?utm_source=legacy-notice&utm_medium=banner&utm_campaign=legacy-upgrade
+  #   indicates that 2 cores are available to containers.
+  scons -j${NUM_PROCESSORS:-2} $CC.$TARGET
+fi
 # We can be sure we're using the build/$CC.$TARGET variant
 # (-f so never err)
-rm -f build/rippled
+rm -f build/${APP}
 
 # See what we've actually built
-ldd $RIPPLED_PATH
-if [[ $TARGET == "coverage" ]]; then
-  $RIPPLED_PATH --unittest
-  # We pass along -p to keep path segments so as to avoid collisions
-  codecov --gcov-args=-p --gcov-source-match='^src/(ripple|beast)'
+ldd $APP_PATH
+
+if [[ ${APP} == "rippled" ]]; then
+  export APP_ARGS="--unittest"
+  # Only report on src/ripple files
+  export LCOV_FILES="*/src/ripple/*"
+  # Nothing to explicitly exclude
+  export LCOV_EXCLUDE_FILES="LCOV_NO_EXCLUDE"
 else
-  if [[ $CC == "clang" ]]; then
-    # gdb segfaults with a clang build
-    $RIPPLED_PATH --unittest
-  else
-    # Run unittests (under gdb)
-    cat $__dirname/unittests.gdb | gdb \
-        --return-child-result \
-        --args $RIPPLED_PATH --unittest
-  fi
+  : ${APP_ARGS:=}
+  : ${LCOV_FILES:="*/src/*"}
+  # Don't exclude anything
+  : ${LCOV_EXCLUDE_FILES:="LCOV_NO_EXCLUDE"}
 fi
 
-# Run NPM tests
-npm install
-npm test --rippled=$RIPPLED_PATH
+if [[ $TARGET == "coverage" ]]; then
+  export PATH=$PATH:$LCOV_ROOT/usr/bin
+
+  # Create baseline coverage data file
+  lcov --no-external -c -i -d . -o baseline.info
+fi
+
+# Execute unit tests under gdb, printing a call stack
+# if we get a crash.
+gdb -return-child-result -quiet -batch \
+    -ex "set env MALLOC_CHECK_=3" \
+    -ex "set print thread-events off" \
+    -ex run \
+    -ex "thread apply all backtrace full" \
+    -ex "quit" \
+    --args $APP_PATH --unittest
+
+if [[ $TARGET == "coverage" ]]; then
+  # Create test coverage data file
+  lcov --no-external -c -d . -o tests.info
+
+  # Combine baseline and test coverage data
+  lcov -a baseline.info -a tests.info -o lcov-all.info
+
+  # Included files
+  lcov -e "lcov-all.info" "${LCOV_FILES}" -o lcov.pre.info
+
+  # Excluded files
+  lcov --remove lcov.pre.info "${LCOV_EXCLUDE_FILES}" -o lcov.info
+
+  # Push the results (lcov.info) to codecov
+  codecov -X gcov # don't even try and look for .gcov files ;)
+fi
+
+

bin/ci/ubuntu/install-dependencies.sh

@@ -1,6 +1,11 @@
 #!/bin/bash -u
-# Exit if anything fails.
-set -e
+# Exit if anything fails. Echo commands to aid debugging.
+set -ex
+
+# Target working dir - defaults to current dir.
+# Can be set from caller, or in the first parameter
+TWD=$( cd ${TWD:-${1:-${PWD:-$( pwd )}}}; pwd )
+echo "Target path is: $TWD"
 # Override gcc version to $GCC_VER.
 # Put an appropriate symlink at the front of the path.
 mkdir -v $HOME/bin
@@ -9,26 +14,54 @@ do
   test -x $( type -p ${g}-$GCC_VER )
   ln -sv $(type -p ${g}-$GCC_VER) $HOME/bin/${g}
 done
-for c in clang clang++
-do
-    test -x $( type -p ${c}-$CLANG_VER )
-    ln -sv $(type -p ${c}-$CLANG_VER) $HOME/bin/${c}
-done
-export PATH=$PWD/bin:$PATH
+
+if [[ -n ${CLANG_VER:-} ]]; then
+    # There are cases where the directory exists, but the exe is not available.
+    # Use this workaround for now.
+    if [[ ! -x ${TWD}/llvm-${LLVM_VERSION}/bin/llvm-config && -d ${TWD}/llvm-${LLVM_VERSION} ]]; then
+        rm -fr ${TWD}/llvm-${LLVM_VERSION}
+    fi
+    if [[ ! -d ${TWD}/llvm-${LLVM_VERSION} ]]; then
+        mkdir ${TWD}/llvm-${LLVM_VERSION}
+        LLVM_URL="http://llvm.org/releases/${LLVM_VERSION}/clang+llvm-${LLVM_VERSION}-x86_64-linux-gnu-ubuntu-14.04.tar.xz"
+        wget -O - ${LLVM_URL} | tar -Jxvf - --strip 1 -C ${TWD}/llvm-${LLVM_VERSION}
+    fi
+    ${TWD}/llvm-${LLVM_VERSION}/bin/llvm-config --version;
+    export LLVM_CONFIG="${TWD}/llvm-${LLVM_VERSION}/bin/llvm-config";
+fi
+
+if [[ ${BUILD:-} == cmake ]]; then
+    # There are cases where the directory exists, but the exe is not available.
+    # Use this workaround for now.
+    if [[ ! -x ${TWD}/cmake/bin/cmake && -d ${TWD}/cmake ]]; then
+        rm -fr ${TWD}/cmake
+    fi
+    if [[ ! -d ${TWD}/cmake ]]; then
+      CMAKE_URL="https://www.cmake.org/files/v3.6/cmake-3.6.1-Linux-x86_64.tar.gz"
+      wget --version
+      # wget version 1.13.4 thinks this certificate is invalid, even though it's fine.
+      # "ERROR: no certificate subject alternative name matches"
+      # See also: https://github.com/travis-ci/travis-ci/issues/5059
+      mkdir ${TWD}/cmake &&
+        wget -O - --no-check-certificate ${CMAKE_URL} | tar --strip-components=1 -xz -C ${TWD}/cmake
+      cmake --version
+    fi
+fi
 
 # What versions are we ACTUALLY running?
 if [ -x $HOME/bin/g++ ]; then
     $HOME/bin/g++ -v
 fi
-if [ -x $HOME/bin/clang ]; then
-    $HOME/bin/clang -v
-fi
-# Avoid `spurious errors` caused by ~/.npm permission issues
-# Does it already exist? Who owns? What permissions?
-ls -lah ~/.npm || mkdir ~/.npm
-# Make sure we own it
-chown -Rc $USER ~/.npm
-# We use this so we can filter the subtrees from our coverage report
-pip install --user https://github.com/sublimator/codecov-python/zipball/source-match
+
+pip install --user https://github.com/codecov/codecov-python/archive/master.zip
 
 bash bin/sh/install-boost.sh
+
+# Install lcov
+# Download the archive
+wget https://github.com/linux-test-project/lcov/releases/download/v1.12/lcov-1.12.tar.gz
+# Extract to ~/lcov-1.12
+tar xfvz lcov-1.12.tar.gz -C $HOME
+# Set install path
+mkdir -p $LCOV_ROOT
+cd $HOME/lcov-1.12 && make install PREFIX=$LCOV_ROOT

bin/ci/ubuntu/unittests.gdb

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

bin/ci/windows/install-dependencies.bat

@@ -0,0 +1,13 @@
+if "%build%" == "scons" (
+	rem Installing pip will install setuptools/easy_install.
+	python "%PIP_PATH%"
+
+	rem Pip has some problems installing scons on windows so we use easy install.
+	rem - easy_install scons
+	rem Workaround
+	easy_install https://pypi.python.org/packages/source/S/SCons/scons-2.5.0.tar.gz#md5=bda5530a70a41a7831d83c8b191c021e
+
+	rem Scons has problems with parallel builds on windows without pywin32.
+	easy_install "%PYWIN32_PATH%"
+	rem (easy_install can do headless installs of .exe wizards)
+)

bin/getInfoRippled.sh

@@ -0,0 +1,84 @@
+#!/usr/bin/env bash
+
+rippled_exe=/opt/ripple/bin/rippled
+conf_file=/etc/opt/ripple/rippled.cfg
+
+while getopts ":e:c:" opt; do
+    case $opt in
+        e)
+            rippled_exe=${OPTARG}
+            ;;
+        c)
+            conf_file=${OPTARG}
+            ;;
+        \?)
+            echo "Invalid option: -$OPTARG"
+    esac
+done
+
+tmp_loc=$(mktemp -d --tmpdir ripple_info.XXXX)
+cd /tmp
+chmod 751 ripple_info.*
+cd ~
+echo ${tmp_loc}
+
+cleaned_conf=${tmp_loc}/cleaned_rippled_cfg.txt
+
+if [[ -f ${conf_file} ]]
+then
+    db=$(sed -r -e 's/\<s[a-zA-Z0-9]{28}\>/secretsecretsecretsecretmaybe/g' ${conf_file} |\
+            awk -v OUT_FILE=${cleaned_conf} '
+    BEGIN {skip=0; db_path="";print > OUT_FILE}
+    /^\[validation_seed\]/ {skip=1; next}
+    /^\[node_seed\]/ {skip=1; next}
+    /^\[.*\]/ {skip=0}
+    skip==1 {next}
+    save==1 {save=0;db_path=$0}
+    /^\[database_path\]/ {save=1}
+    {print >> OUT_FILE}
+    END {print db_path}
+    ')
+fi
+
+echo "database_path: ${db}"
+df ${db} > ${tmp_loc}/db_path_df.txt
+echo
+
+# Send output from this script to a log file
+## this captures any messages
+## or errors from the script itself
+
+log_file=${tmp_loc}/get_info.log
+exec 3>&1 1>>${log_file} 2>&1
+
+## Send all stdout files to /tmp
+
+if [[ -x ${rippled_exe} ]]
+then
+    pgrep rippled && \
+    ${rippled_exe} --conf ${conf_file} \
+    -- server_info                  > ${tmp_loc}/server_info.txt
+fi
+
+df -h                               > ${tmp_loc}/free_disk_space.txt
+cat /proc/meminfo                   > ${tmp_loc}/amount_mem.txt
+cat /proc/swaps                     > ${tmp_loc}/swap_space.txt
+ulimit -a                           > ${tmp_loc}/reported_current_limits.txt
+
+for dev_path in $(df | awk '$1 ~ /^\/dev\// {print $1}'); do
+    # strip numbers from end and remove '/dev/'
+    dev=$(basename ${dev_path%%[0-9]})
+    if [[ "$(cat /sys/block/${dev}/queue/rotational)" = 0 ]]
+    then
+        echo "${dev} : SSD" >> ${tmp_loc}/is_ssd.txt
+    else
+        echo "${dev} : NO SSD" >> ${tmp_loc}/is_ssd.txt
+    fi
+done
+
+pushd ${tmp_loc}
+tar -czvf info-package.tar.gz *.txt *.log
+popd
+
+echo "Use the following command on your local machine to download from your rippled instance: scp <remote_rippled_username>@<remote_host>:${tmp_loc}/info-package.tar.gz <path/to/local_machine/directory>"| tee /dev/fd/3
+

bin/python/Manifest.py

@@ -4,4 +4,4 @@ import sys
 from ripple.util import Sign
 
 result = Sign.run_command(sys.argv[1:])
-exit(0 if result else -1)
+sys.exit(0 if result else -1)

bin/python/README.md

@@ -5,4 +5,11 @@ To run the Python unit tests, execute:
 
      python -m unittest discover
 
-from this directory.
+from this directory.
+
+To run Python unit tests from a particular file (such as
+`ripple/util/test_Sign.py`), execute:
+
+     python -m unittest ripple.util.test_Sign
+
+Add `-v` to run tests in verbose mode.

bin/python/jsonpath_rw/jsonpath.py

@@ -52,7 +52,7 @@ class DatumInContext(object):
     """
     Represents a datum along a path from a context.
 
-    Essentially a zipper but with a structure represented by JsonPath, 
+    Essentially a zipper but with a structure represented by JSONPath, 
     and where the context is more of a parent pointer than a proper 
     representation of the context.
 

bin/python/ripple/ledger/SField.py

@@ -49,3 +49,4 @@ sfSequence          = field_code(STI_UINT32, 4)
 sfPublicKey         = field_code(STI_VL, 1)
 sfSigningPubKey     = field_code(STI_VL, 3)
 sfSignature         = field_code(STI_VL, 6)
+sfMasterSignature   = field_code(STI_VL, 18)

bin/python/ripple/util/Sign.py

@@ -5,23 +5,27 @@ from __future__ import print_function
 import base64, os, random, struct, sys
 import ed25519
 import ecdsa
+import hashlib
 from ripple.util import Base58
 from ripple.ledger import SField
 
 ED25519_BYTE = chr(0xed)
-WRAP_COLUMNS = 60
+WRAP_COLUMNS = 72
 
 USAGE = """\
 Usage:
     create
         Create a new master public/secret key pair.
 
+    create <master-secret>
+        Generate master key pair using provided secret.
+
     check <key>
         Check an existing key for validity.
 
-    sign <sequence> <validator-public> <master-secret>
+    sign <sequence> <validation-public-key> <validation-private-key> <master-secret>
         Create a new signed manifest with the given sequence
-        number, validator public key, and master secret key.
+        number and keys.
     """
 
 def prepend_length_byte(b):
@@ -38,17 +42,17 @@ def make_seed(urandom=os.urandom):
     return urandom(16)
 
 def make_ed25519_keypair(urandom=os.urandom):
-    private_key = urandom(32)
-    return private_key, ed25519.publickey(private_key)
+    sk = urandom(32)
+    return sk, ed25519.publickey(sk)
 
-def make_ecdsa_keypair():
+def make_ecdsa_keypair(urandom=None):
     # This is not used.
-    private_key = ecdsa.SigningKey.generate(curve=ecdsa.SECP256k1)
+    sk = ecdsa.SigningKey.generate(curve=ecdsa.SECP256k1, entropy=urandom)
     # Can't be unit tested easily - need a mock for ecdsa.
-    vk = private_key.get_verifying_key()
-    sig = private_key.sign('message')
+    vk = sk.get_verifying_key()
+    sig = sk.sign('message')
     assert vk.verify(sig, 'message')
-    return private_key, vk
+    return sk, vk
 
 def make_seed_from_passphrase(passphrase):
     # For convenience, like say testing against rippled we can hash a passphrase
@@ -56,18 +60,58 @@ def make_seed_from_passphrase(passphrase):
     # an optional arg, which can be a base58 encoded seed, or a passphrase.
     return hashlib.sha512(passphrase).digest()[:16]
 
-def make_manifest(public_key, validator_public_key, seq):
+def make_manifest(master_pk, validation_pk, seq):
+    """create a manifest
+
+    Parameters
+    ----------
+    master_pk : string
+        validator's master public key (binary, _not_ BASE58 encoded)
+    validation_pk : string
+        validator's validation public key (binary, _not_ BASE58 encoded)
+    seq : int
+        manifest sequence number
+
+    Returns
+    ----------
+    string
+        String with fields for seq, master_pk, validation_pk
+    """
     return ''.join([
         SField.sfSequence,
         to_int32(seq),
-        SField.sfPublicKey,      # Master public key.
-        prepend_length_byte(public_key),
-        SField.sfSigningPubKey,  # Ephemeral public key.
-        prepend_length_byte(validator_public_key)])
+        SField.sfPublicKey,
+        prepend_length_byte(master_pk),
+        SField.sfSigningPubKey,
+        prepend_length_byte(validation_pk)])
 
-def sign_manifest(manifest, private_key, public_key):
-    sig = ed25519.signature('MAN\0' + manifest, private_key, public_key)
-    return manifest + SField.sfSignature + prepend_length_byte(sig)
+def sign_manifest(manifest, validation_sk, master_sk, master_pk):
+    """sign a validator manifest
+
+    Parameters
+    ----------
+    manifest : string
+        manifest to sign
+    validation_sk : string
+        validator's validation secret key (binary, _not_ BASE58 encoded)
+        This is one of the keys that will sign the manifest.
+    master_sk : string
+        validator's master secret key (binary, _not_ BASE58 encoded)
+        This is one of the keys that will sign the manifest.
+    master_pk : string
+        validator's master public key (binary, _not_ BASE58 encoded)
+
+    Returns
+    ----------
+    string
+        manifest signed by both the validation and master keys
+    """
+    man_hash = hashlib.sha512('MAN\0' + manifest).digest()[:32]
+    validation_sig = validation_sk.sign_digest_deterministic(
+        man_hash, hashfunc=hashlib.sha256, sigencode=ecdsa.util.sigencode_der_canonize)
+    master_sig = ed25519.signature('MAN\0' + manifest, master_sk, master_pk)
+    return manifest + SField.sfSignature + prepend_length_byte(validation_sig) + \
+        SField.sfMasterSignature + prepend_length_byte(master_sig)
 
 def wrap(s, cols=WRAP_COLUMNS):
     if s:
@@ -77,47 +121,64 @@ def wrap(s, cols=WRAP_COLUMNS):
     return s
 
 def create_ed_keys(urandom=os.urandom):
-    private_key, public_key = make_ed25519_keypair(urandom)
-    public_key_human = Base58.encode_version(
-        Base58.VER_NODE_PUBLIC, ED25519_BYTE + public_key)
-    private_key_human = Base58.encode_version(
-        Base58.VER_NODE_PRIVATE, private_key)
-    return public_key_human, private_key_human
+    sk, pk = make_ed25519_keypair(urandom)
+    pk_human = Base58.encode_version(
+        Base58.VER_NODE_PUBLIC, ED25519_BYTE + pk)
+    sk_human = Base58.encode_version(
+        Base58.VER_NODE_PRIVATE, sk)
+    return pk_human, sk_human
 
-def check_validator_public(v, validator_public_key):
+def create_ed_public_key(sk_human):
+    v, sk = Base58.decode_version(sk_human)
+    check_secret_key(v, sk)
+
+    pk = ed25519.publickey(sk)
+    pk_human = Base58.encode_version(
+        Base58.VER_NODE_PUBLIC, ED25519_BYTE + pk)
+    return pk_human
+
+def check_validation_public_key(v, pk):
     Base58.check_version(v, Base58.VER_NODE_PUBLIC)
-    if len(validator_public_key) != 33:
-        raise ValueError('Validator key should be length 33, is %s' %
-                         len(validator_public_key))
-    b = ord(validator_public_key[0])
+    if len(pk) != 33:
+        raise ValueError('Validation public key should be length 33, is %s' %
+                         len(pk))
+    b = ord(pk[0])
     if b not in (2, 3):
-        raise ValueError('First validator key byte must be 2 or 3, is %d' % b)
+        raise ValueError('First validation public key byte must be 2 or 3, is %d' % b)
 
-def check_master_secret(v, private_key):
+def check_secret_key(v, sk):
     Base58.check_version(v, Base58.VER_NODE_PRIVATE)
-    if len(private_key) != 32:
+    if len(sk) != 32:
         raise ValueError('Length of master secret should be 32, is %s' %
-                         len(private_key))
+                         len(sk))
 
+def get_signature(seq, validation_pk_human, validation_sk_human, master_sk_human):
+    v, validation_pk = Base58.decode_version(validation_pk_human)
+    check_validation_public_key(v, validation_pk)
 
-def get_signature(seq, validator_public_key_human, private_key_human):
-    v, validator_public_key = Base58.decode_version(validator_public_key_human)
-    check_validator_public(v, validator_public_key)
+    v, validation_sk_str = Base58.decode_version(validation_sk_human)
+    check_secret_key(v, validation_sk_str)
+    validation_sk = ecdsa.SigningKey.from_string(validation_sk_str, curve=ecdsa.SECP256k1)
 
-    v, private_key = Base58.decode_version(private_key_human)
-    check_master_secret(v, private_key)
+    v, master_sk = Base58.decode_version(master_sk_human)
+    check_secret_key(v, master_sk)
 
-    pk = ed25519.publickey(private_key)
+    pk = ed25519.publickey(master_sk)
     apk = ED25519_BYTE + pk
-    m = make_manifest(apk, validator_public_key, seq)
-    m1 = sign_manifest(m, private_key, pk)
+    m = make_manifest(apk, validation_pk, seq)
+    m1 = sign_manifest(m, validation_sk, master_sk, pk)
     return base64.b64encode(m1)
 
-
 # Testable versions of functions.
 def perform_create(urandom=os.urandom, print=print):
-    public, private = create_ed_keys(urandom)
-    print('[validator_keys]', public, '', '[master_secret]', private, sep='\n')
+    pk, sk = create_ed_keys(urandom)
+    print('[validator_keys]', pk, '', '[master_secret]', sk, sep='\n')
+
+def perform_create_public(sk_human, print=print):
+    pk_human = create_ed_public_key(sk_human)
+    print(
+        '[validator_keys]',pk_human, '',
+        '[master_secret]', sk_human, sep='\n')
 
 def perform_check(s, print=print):
     version, b = Base58.decode_version(s)
@@ -126,21 +187,29 @@ def perform_check(s, print=print):
     assert Base58.encode_version(version, b) == s
 
 def perform_sign(
-        seq, validator_public_key_human, private_key_human, print=print):
+        seq, validation_pk_human, validation_sk_human, master_sk_human, print=print):
     print('[validation_manifest]')
     print(wrap(get_signature(
-        int(seq), validator_public_key_human, private_key_human)))
+        int(seq), validation_pk_human, validation_sk_human, master_sk_human)))
+
+def perform_verify(
+        seq, validation_pk_human, master_pk_human, signature, print=print):
+    verify_signature(
+        int(seq), validation_pk_human, master_pk_human, signature)
+    print('Signature valid for', master_pk_human)
 
 # Externally visible versions of functions.
-def create():
-    perform_create()
+def create(sk_human=None):
+    if sk_human:
+        perform_create_public(sk_human)
+    else:
+        perform_create()
 
 def check(s):
     perform_check(s)
 
-def sign(seq, validator_public_key_human, private_key_human):
-    perform_sign(seq, validator_public_key_human, private_key_human)
-
+def sign(seq, validation_pk_human, validation_sk_human, master_sk_human):
+    perform_sign(seq, validation_pk_human, validation_sk_human, master_sk_human)
 
 def usage(*errors):
     if errors:

bin/python/ripple/util/test_Sign.py

@@ -10,10 +10,7 @@ BINARY = 'nN9kfUnKTf7PpgLG'
 
 class test_Sign(TestCase):
     SEQUENCE = 23
-    SIGNATURE = (
-        'JAAAABdxIe2DIKUZd9jDjKikknxnDfWCHkSXYZReFenvsmoVCdIw6nMhAnZ2dnZ2'
-        'dnZ2dnZ2dnZ2dnZ2dnZ2dnZ2dnZ2dnZ2dnZ2dkDOjlWtQSvRTjuwe+4iNusg0sJM'
-        'zqkBJwDz30b2SkxZ7Fte/Vx4htM/kkfUfJCaxmxE5N4dHSKuiO9iDHsktqIA')
+    VALIDATOR_KEY_HUMAN = 'n9JijuoCv8ubEy5ag3LiX3hyq27GaLJsitZPbQ6APkwx2MkUXq8E'
 
     def setUp(self):
         self.results = []
@@ -55,13 +52,17 @@ class test_Sign(TestCase):
             '\xef*\x97\x16n<\xa6\xf2\xe4\xfb\xfc\xcd\x80P[\xf1s\x06verify')
 
     def test_sign_manifest(self):
+        ssk, spk = Sign.make_ecdsa_keypair(self.urandom)
         sk, pk = Sign.make_ed25519_keypair(self.urandom)
-        s = Sign.sign_manifest('manifest', sk, pk)
+        s = Sign.sign_manifest('manifest', ssk, sk, pk)
         self.assertEquals(
-            s, 'manifestv@\xe5\x84\xbe\xc4\x80N\xa0v"\xb2\x80A\x88\x06\xc0'
-            '\xd2\xbae\x92\x89\xa8\'!\xdd\x00\x88\x06s\xe0\xf74\xe3Yg\xad{$'
-            '\x17\xd3\x99\xaa\x16\xb0\xeaZ\xd7]\r\xb3\xdc\x1b\x8f\xc1Z\xdfHU'
-            '\xb5\x92\xac\x82jI\x02')
+            s, 'manifestvF0D\x02 \x04\x85\x95p\x0f\xb8\x17\x7f\xdf\xdd\x04'
+            '\xaa+\x16q1W\xf6\xfd\xe8X\xb12l\xd5\xc3\xf1\xd6\x05\x1b\x1c\x9a'
+            '\x02 \x18\\.(o\xa8 \xeb\x87\xfa&~\xbd\xe6,\xfb\xa61\xd1\xcd\xcd'
+            '\xc8\r\x16[\x81\x9a\x19\xda\x93i\xcdp\x12@\xe5\x84\xbe\xc4\x80N'
+            '\xa0v"\xb2\x80A\x88\x06\xc0\xd2\xbae\x92\x89\xa8\'!\xdd\x00\x88'
+            '\x06s\xe0\xf74\xe3Yg\xad{$\x17\xd3\x99\xaa\x16\xb0\xeaZ\xd7]\r'
+            '\xb3\xdc\x1b\x8f\xc1Z\xdfHU\xb5\x92\xac\x82jI\x02')
 
     def test_wrap(self):
         wrap = lambda s: Sign.wrap(s, 5)
@@ -79,22 +80,31 @@ class test_Sign(TestCase):
         self.assertEquals(
             skh, 'pnEp13Zu7xTeKQVQ2RZVaUraE9GXKqFtnXQVUFKXbTE6wsP4wne')
 
+    def test_create_ed_public_key(self):
+        pkh = Sign.create_ed_public_key(
+            'pnEp13Zu7xTeKQVQ2RZVaUraE9GXKqFtnXQVUFKXbTE6wsP4wne')
+        self.assertEquals(
+            pkh, 'nHUUaKHpxyRP4TZZ79tTpXuTpoM8pRNs5crZpGVA5jdrjib5easY')
+
     def get_test_keypair(self):
         public = (Base58.VER_NODE_PUBLIC, '\x02' + (32 * 'v'))
         private = (Base58.VER_NODE_PRIVATE, 32 * 'k')
 
-        Sign.check_validator_public(*public)
-        Sign.check_master_secret(*private)
+        Sign.check_validation_public_key(*public)
+        Sign.check_secret_key(*private)
 
         return (Base58.encode_version(*public), Base58.encode_version(*private))
 
     def test_get_signature(self):
-        signature = Sign.get_signature(self.SEQUENCE, *self.get_test_keypair())
+        pk, sk = self.get_test_keypair()
+        signature = Sign.get_signature(self.SEQUENCE, pk, sk, sk)
         self.assertEquals(
             signature,
             'JAAAABdxIe2DIKUZd9jDjKikknxnDfWCHkSXYZReFenvsmoVCdIw6nMhAnZ2dnZ2'
-            'dnZ2dnZ2dnZ2dnZ2dnZ2dnZ2dnZ2dnZ2dnZ2dkDOjlWtQSvRTjuwe+4iNusg0sJM'
-            'zqkBJwDz30b2SkxZ7Fte/Vx4htM/kkfUfJCaxmxE5N4dHSKuiO9iDHsktqIA')
+            'dnZ2dnZ2dnZ2dnZ2dnZ2dnZ2dnZ2dnZ2dnZ2dkYwRAIgXyobHA8sDQxmDJNLE6HI'
+            'aARlzvcd79/wT068e113gUkCIHkI540JQT2LHwAD7/y3wFE5X3lEXMfgZRkpLZTx'
+            'kpticBJAzo5VrUEr0U47sHvuIjbrINLCTM6pAScA899G9kpMWexbXv1ceIbTP5JH'
+            '1HyQmsZsROTeHR0irojvYgx7JLaiAA==')
 
     def test_check(self):
         public = Base58.encode_version(Base58.VER_NODE_PRIVATE, 32 * 'k')
@@ -114,14 +124,26 @@ class test_Sign(TestCase):
                'pnEp13Zu7xTeKQVQ2RZVaUraE9GXKqFtnXQVUFKXbTE6wsP4wne'],
               {'sep': '\n'}]])
 
+    def test_create_public(self):
+        Sign.perform_create_public(
+            'pnEp13Zu7xTeKQVQ2RZVaUraE9GXKqFtnXQVUFKXbTE6wsP4wne', self.print)
+        self.assertEquals(
+            self.results,
+            [[['[validator_keys]',
+               'nHUUaKHpxyRP4TZZ79tTpXuTpoM8pRNs5crZpGVA5jdrjib5easY',
+               '',
+               '[master_secret]',
+               'pnEp13Zu7xTeKQVQ2RZVaUraE9GXKqFtnXQVUFKXbTE6wsP4wne'],
+              {'sep': '\n'}]])
+
     def test_sign(self):
         public, private = self.get_test_keypair()
-        Sign.perform_sign(self.SEQUENCE, public, private, print=self.print)
+        Sign.perform_sign(self.SEQUENCE, public, private, private, print=self.print)
         self.assertEquals(
             self.results,
             [[['[validation_manifest]'], {}],
-             [['JAAAABdxIe2DIKUZd9jDjKikknxnDfWCHkSXYZReFenvsmo\n'
-               'VCdIw6nMhAnZ2dnZ2dnZ2dnZ2dnZ2dnZ2dnZ2dnZ2dnZ2dn\n'
-               'Z2dnZ2dkDOjlWtQSvRTjuwe+4iNusg0sJMzqkBJwDz30b2S\n'
-               'kxZ7Fte/Vx4htM/kkfUfJCaxmxE5N4dHSKuiO9iDHsktqIA'],
+             [['JAAAABdxIe2DIKUZd9jDjKikknxnDfWCHkSXYZReFenvsmoVCdIw6nMhAnZ2dnZ2dnZ2dnZ2\n'
+               'dnZ2dnZ2dnZ2dnZ2dnZ2dnZ2dnZ2dkYwRAIgXyobHA8sDQxmDJNLE6HIaARlzvcd79/wT068\n'
+               'e113gUkCIHkI540JQT2LHwAD7/y3wFE5X3lEXMfgZRkpLZTxkpticBJAzo5VrUEr0U47sHvu\n'
+               'IjbrINLCTM6pAScA899G9kpMWexbXv1ceIbTP5JH1HyQmsZsROTeHR0irojvYgx7JLaiAA=='],
               {}]])

bin/sh/install-boost.sh

@@ -7,6 +7,7 @@
 # When testing you can force a boost build by clearing travis caches:
 # https://travis-ci.org/ripple/rippled/caches
 set -e
+
 if [ ! -d "$BOOST_ROOT/lib" ]
 then
   wget $BOOST_URL -O /tmp/boost.tar.gz
@@ -15,7 +16,8 @@ then
   tar xzf /tmp/boost.tar.gz
   cd $BOOST_ROOT && \
     ./bootstrap.sh --prefix=$BOOST_ROOT && \
-    ./b2 -d1 define=_GLIBCXX_USE_CXX11_ABI=0 && ./b2 -d0 define=_GLIBCXX_USE_CXX11_ABI=0 install
+    ./b2 -d1 define=_GLIBCXX_USE_CXX11_ABI=0 -j${NUM_PROCESSORS:-2} &&\
+    ./b2 -d0 define=_GLIBCXX_USE_CXX11_ABI=0 install
 else
   echo "Using cached boost at $BOOST_ROOT"
 fi

circle.yml

@@ -3,13 +3,11 @@ machine:
     - docker
 dependencies:
   pre:
-    - sudo apt-add-repository -y 'deb http://llvm.org/apt/precise/ llvm-toolchain-precise-3.6 main'
     - sudo apt-add-repository -y ppa:ubuntu-toolchain-r/test
-    - sudo add-apt-repository -y ppa:afrank/boost
-    - wget -q -O - http://llvm.org/apt/llvm-snapshot.gpg.key | sudo apt-key add -
+    - echo "deb [arch=amd64 trusted=yes] https://test-mirrors.ripple.com/ubuntu/ trusty testing" | sudo tee /etc/apt/sources.list.d/ripple.list
     - sudo apt-get update -qq
     - sudo apt-get purge -qq libboost1.48-dev
-    - sudo apt-get install -qq libboost1.57-all-dev
+    - sudo apt-get install -qq libboost1.60-all-dev
     - sudo apt-get install -qq clang-3.6 gcc-5 g++-5 libobjc-5-dev libgcc-5-dev libstdc++-5-dev libclang1-3.6 libgcc1 libgomp1 libstdc++6 scons protobuf-compiler libprotobuf-dev libssl-dev exuberant-ctags
     - lsb_release -a
     - sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-5 99
@@ -22,26 +20,5 @@ test:
   pre:
     - scons clang.debug
   override:
-    - | # create gdb script
-      echo "set env MALLOC_CHECK_=3" > script.gdb
-      echo "run" >> script.gdb
-      echo "backtrace full" >> script.gdb
-      # gdb --help
-    # gdb segfaults
-    # - cat script.gdb | gdb --ex 'set print thread-events off' --return-child-result --args build/clang.debug/rippled --unittest
-    - build/clang.debug/rippled --unittest
-    - npm install
-    # Use build/(gcc|clang).debug/rippled
-    - |
-      echo "exports.default_server_config = {\"rippled_path\" : \"$HOME/rippled/build/clang.debug/rippled\"};" > test/config.js
-
-    # Run integration tests
-    - npm test
-  post:
-    - ./Builds/Docker/build-ci.sh
-    - docker images
-deployment:
-  docker:
-    branch: /.*/
-    commands:
-      - ./Builds/Docker/push-to-hub.sh
+    # Execute unit tests under gdb
+    - gdb -return-child-result -quiet -batch -ex "set env MALLOC_CHECK_=3" -ex "set print thread-events off" -ex run -ex "thread apply all backtrace full" -ex "quit" --args build/clang.debug/rippled --unittest

doc/manifest-tool-guide.md

@@ -22,10 +22,10 @@ master key pair:
 Sample output:
 ```
   [validator_keys]
-  nHUSSzGw4A9zEmFtK2Q2NcWDH9xmGdXMHc1MsVej3QkLTgvDNeBr
+  nHDwNP6jbJgVKj5zSEjMn8SJhTnPV54Fx5sSiNpwqLbb42nmh3Ln
 
   [master_secret]
-  pnxayCakmZRQE2qhEVRbFjiWCunReSbN1z64vPL36qwyLgogyYc
+  paamfhAn5m1NM4UUu5mmvVaHQy8Fb65bkpbaNrvKwX3YMKdjzi2
 ```
 
 The first value is the master public key. Add the public key to the config
@@ -54,10 +54,11 @@ Sample output:
   Securely connecting to 127.0.0.1:5005
   {
      "result" : {
-      "status" : "success",
-      "validation_key" : "TOO EDNA SHUN FEUD STAB JOAN BIAS FLEA WISE BOHR LOSS WEEK",
-      "validation_public_key" : "n9JzKV3ZrcZ3DW5pwjakj4hpijJ9oMiyrPDGJc3mpsndL6Gf3zwd",
-      "validation_seed" : "sahzkAajS2dyhjXg2yovjdZhXmjsx"
+       "status" : "success",
+       "validation_key" : "MIN HEAT NUN FAWN HIP KAHN BORG PHI BALK ANN TWIG RACY",
+       "validation_private_key" : "pn6kTqE4WyeRQzZrRp5FnJ5J2vLdSCB5KD3DEyfVw6C9woDBfED",
+       "validation_public_key" : "n9LtZ9haqYMbzJ92cDd3pu3Lko6uEznrXuYea3ehuhVcwDHF5coX",
+       "validation_seed" : "sh8bLqqkGBknGcsgRTrFMxcciwytm"
      }
   }
 ```
@@ -68,36 +69,37 @@ number as a comment as well (sequence numbers are be explained below):
 
 ```
   [validation_seed]
-  sahzkAajS2dyhjXg2yovjdZhXmjsx
-  # validation_public_key: n9JzKV3ZrcZ3DW5pwjakj4hpijJ9oMiyrPDGJc3mpsndL6Gf3zwd
+  sh8bLqqkGBknGcsgRTrFMxcciwytm
+  # validation_public_key: n9LtZ9haqYMbzJ92cDd3pu3Lko6uEznrXuYea3ehuhVcwDHF5coX
   # sequence number: 1
 ```
 
 A manifest is a signed message used to inform other servers of this validator's
 ephemeral public key. A manifest contains a sequence number, the new ephemeral
-public key, and it is signed with the master secret key. The sequence number
-should be higher than the previous sequence number (if it is not, the manifest
-will be ignored). Usually the previous sequence number will be incremented by
-one. Use the `manifest` script to create a manifest. It has the form:
+public key, and it is signed with both the ephemeral and master secret keys.
+The sequence number should be higher than the previous sequence number (if it
+is not, the manifest will be ignored). Usually the previous sequence number
+will be incremented by one. Use the `manifest` script to create a manifest.
+It has the form:
 
 ```
- $ bin/manifest sign sequence_number validation_public_key master_secret
+ $ bin/manifest sign sequence validation_public_key validation_private_key master_secret
 ```
 
 For example:
 
 ```
-  $ bin/manifest sign 1 n9JzKV3Z...L6Gf3zwd pnxayCak...yLgogyYc
+  $ bin/manifest sign 1 n9LtZ9ha...wDHF5coX pn6kTqE4...9woDBfED paamfhAn...YMKdjzi2
 ```
 
 Sample output:
 
 ```
   [validation_manifest]
-  JAAAAAFxIe2PEzNhe996gykB1PJQNoDxvr/Y0XhDELw8d/i
-  Fcgz3A3MhAjqhKsgZTmK/3BPEI+kzjV1p9ip7pl/AtF7CKd
-  NSfAH9dkCxezV6apS4FLYzAcQilONx315HvebwAB/pLPaM4
-  2sWCEppSuLNKN/JJjTABOo9tmAiNnnstF83yvecKMJzniwN
+  JAAAAAFxIe3t8rIb4Ba8JHI97CbwpxmTq0LhN/7ZAbsNaSwrbHaypHMhAzTuu07YGOvVvB3+
+  aS0jhP+q0TVgTjGJKhx+yTY1Da3ddkYwRAIgDkmIt3dPNsfeCH3ApMZgpwqG4JwtIlKEymqK
+  S7v+VqkCIFQXg20ZMpXXT86vmLdlmPspgeUN1scWsuFoPYUUJywycBJAl93+/bZbfZ4quTeM
+  5y80/OSIcVoWPcHajwrAl68eiAW4MVFeJXvShXNfnT+XsxMjDh0VpOkhvyp971i1MgjBAA==
 ```  
 
 Copy this to the config for this validator. Don't forget to update the comment
@@ -107,4 +109,4 @@ noting the sequence number.
 
 If a master key is compromised, the key may be revoked permanently. To revoke a
 master key, sign a manifest with the highest possible sequence number:
-`4,294,967,295`
+`4294967295`

doc/rippled-example.cfg

@@ -260,6 +260,19 @@
 #           If you need a certificate chain, specify the path to the
 #           certificate chain here. The chain may include the end certificate.
 #
+#   ssl_ciphers = <cipherlist>
+#
+#       Control the ciphers which the server will support over SSL on the port,
+#       specified using the OpenSSL "cipher list format".
+#
+#       NOTE    If unspecified, rippled will automatically configure a modern
+#               cipher suite. This default suite should be widely supported.
+#
+#               You should not modify this string unless you have a specific
+#               reason and cryptographic expertise. Incorrect modification may
+#               keep rippled from connecting to other instances of rippled or
+#               prevent RPC and WebSocket clients from connecting.
+#
 #
 #
 # [rpc_startup]
@@ -418,16 +431,77 @@
 #
 #       The queue will be limited to this <number> of average ledgers'
 #       worth of transactions. If the queue fills up, the transactions
-#       with the lowest fees will be dropped from the queue any time a
-#       transaction with a higher fee level is added. Default: 20.
+#       with the lowest fee levels will be dropped from the queue any
+#       time a transaction with a higher fee level is added.
+#       Default: 20.
 #
 #   retry_sequence_percent = <number>
 #
-#       If a client resubmits a transaction, the new transaction's fee
-#       must be more than <number> percent higher than the original
-#       transaction's fee, or meet the current open ledger fee to be
-#       considered. Default: 125.
+#       If a client replaces a transaction in the queue (same sequence
+#       number as a transaction already in the queue), the new
+#       transaction's fee must be more than <number> percent higher
+#       than the original transaction's fee, or meet the current open
+#       ledger fee to be considered. Default: 25.
 #
+#   multi_txn_percent = <number>
+#
+#       If a client submits multiple transactions (different sequence
+#       numbers), later transactions must pay a fee at least <number>
+#       percent higher than the transaction with the previous sequence
+#       number.
+#       Default: -90.
+#
+#   minimum_escalation_multiplier = <number>
+#
+#       At ledger close time, the median fee level of the transactions
+#       in that ledger is used as a multiplier in escalation
+#       calculations of the next ledger. This minimum value ensures that
+#       the escalation is significant. Default: 500.
+#
+#   minimum_txn_in_ledger = <number>
+#
+#       Minimum number of transactions that must be allowed into the
+#       ledger at the minimum required fee before the required fee
+#       escalates. Default: 5.
+#
+#   minimum_txn_in_ledger_standalone = <number>
+#
+#       Like minimum_txn_in_ledger when rippled is running in standalone
+#       mode. Default: 1000.
+#
+#   target_txn_in_ledger = <number>
+#
+#       Number of transactions allowed into the ledger at the minimum
+#       required fee that the queue will "work toward" as long as
+#       consensus stays healthy. The limit will grow quickly until it
+#       reaches or exceeds this number. After that the limit may still
+#       change, but will stay above the target. If consensus is not
+#       healthy, the limit will be clamped to this value or lower.
+#       Default: 50.
+#
+#   maximum_txn_in_ledger = <number>
+#
+#       (Optional) Maximum number of transactions that will be allowed
+#       into the ledger at the minimum required fee before the required
+#       fee escalates. Default: no maximum.
+#
+#   maximum_txn_per_account = <number>
+#
+#       Maximum number of transactions that one account can have in the
+#       queue at any given time. Default: 10.
+#
+#   minimum_last_ledger_buffer = <number>
+#
+#       If a transaction has a LastLedgerSequence, it must be at least
+#       this much larger than the current open ledger sequence number.
+#       Default: 2.
+#
+#   zero_basefee_transaction_feelevel = <number>
+#
+#       So we don't deal with infinite fee levels, treat any transaction
+#       with a 0 base fee (ie. SetRegularKey password recovery) as
+#       having this fee level.
+#       Default: 256000.
 #
 #
 #-------------------------------------------------------------------------------
@@ -452,14 +526,6 @@
 #
 #
 #
-# [validation_quorum]
-#
-#   Sets the minimum number of trusted validations a ledger must have before
-#   the server considers it fully validated. Note that if you are validating,
-#   your validation counts.
-#
-#
-#
 # [ledger_history]
 #
 #   The number of past ledgers to acquire on server startup and the minimum to
@@ -501,53 +567,36 @@
 #
 #
 #
-# [validators]
-#
-#   List of nodes to always accept as validators. Nodes are specified by domain
-#   or public key.
-#
-#   For domains, rippled will probe for https web servers at the specified
-#   domain in the following order: ripple.DOMAIN, www.DOMAIN, DOMAIN
-#
-#   For public key entries, a comment may optionally be specified after adding
-#   a space to the public key.
-#
-#   Examples:
-#    ripple.com
-#    n9KorY8QtTdRx7TVDpwnG9NvyxsDwHUKUEeDLY3AkiGncVaSXZi5
-#    n9MqiExBcoG19UXwoLjBJnhsxEhAZMuWwJDRdkyDz1EkEkwzQTNt John Doe
-#
-#
-#
 # [validators_file]
 #
-#   Path to file contain a list of nodes to always accept as validators. Use
-#   this to specify a file other than this file to manage your validators list.
+#   Path or name of a file that contains the validation public keys of nodes
+#   to always accept as validators as well as the minimum number of validators
+#   needed to accept consensus.
 #
-#   If this entry is not present or empty and no nodes from previous runs were
-#   found in the database, rippled will look for a validators.txt in the config
-#   directory.  If not found there, it will attempt to retrieve the file from
-#   the [validators_site] web site.
+#   The contents of the file should include a [validators] and a
+#   [validation_quorum] entry. [validators] should be followed by
+#   a list of validation public keys of nodes, one per line, optionally
+#   followed by a comment separated by whitespace.
+#   [validation_quorum] should be followed by a number.
 #
-#   After specifying a different [validators_file] or changing the contents of
-#   the validators file, issue a RPC unl_load command to have rippled load the
-#   file.
-#
-#   Specify the file by specifying its full path.
+#   Specify the file by its name or path.
+#   Unless an absolute path is specified, it will be considered relative to
+#   the folder in which the rippled.cfg file is located.
 #
 #   Examples:
-#    C:/home/johndoe/ripple/validators.txt
-#    /home/johndoe/ripple/validators.txt
+#    /home/ripple/validators.txt
+#    C:/home/ripple/validators.txt
 #
+#   Example content:
+#    [validators]
+#    n949f75evCHwgyP4fPVgaHqNHxUVN15PsJEZ3B3HnXPcPjcZAoy7 RL1
+#    n9MD5h24qrQqiyBC8aeqqCWvpiBiYQ3jxSr91uiDvmrkyHRdYLUj RL2
+#    n9L81uNCaPgtUJfaHh89gmdvXKAmSt5Gdsw2g1iPWaPkAHW5Nm4C RL3
+#    n9KiYM9CgngLvtRCQHZwgC2gjpdaZcCcbt3VboxiNFcKuwFVujzS RL4
+#    n9LdgEtkmGB9E2h3K4Vp7iGUaKuq23Zr32ehxiU8FWY7xoxbWTSA RL5
 #
-#
-# [validators_site]
-#
-#   Specifies where to find validators.txt for UNL boostrapping and RPC
-#   unl_network command.
-#
-#   Example: ripple.com
-#
+#    [validation_quorum]
+#    3
 #
 #
 # [path_search]
@@ -938,22 +987,11 @@ pool.ntp.org
 [ips]
 r.ripple.com 51235
 
-# Public keys of the validators that this rippled instance trusts.  The latest
-# list of validators can be obtained from https://ripple.com/ripple.txt
-#
-# See also https://wiki.ripple.com/Ripple.txt
-#
-[validators]
-n949f75evCHwgyP4fPVgaHqNHxUVN15PsJEZ3B3HnXPcPjcZAoy7    RL1
-n9MD5h24qrQqiyBC8aeqqCWvpiBiYQ3jxSr91uiDvmrkyHRdYLUj    RL2
-n9L81uNCaPgtUJfaHh89gmdvXKAmSt5Gdsw2g1iPWaPkAHW5Nm4C    RL3
-n9KiYM9CgngLvtRCQHZwgC2gjpdaZcCcbt3VboxiNFcKuwFVujzS    RL4
-n9LdgEtkmGB9E2h3K4Vp7iGUaKuq23Zr32ehxiU8FWY7xoxbWTSA    RL5
-
-# The number of validators rippled needs to accept a consensus.
-# Don't change this unless you know what you're doing.
-[validation_quorum]
-3
+# File containing validation quorum and trusted validator keys.
+# Unless an absolute path is specified, it will be considered relative to the
+# folder in which the rippled.cfg file is located.
+[validators_file]
+validators.txt
 
 # Turn down default logging to save disk space in the long run.
 # Valid values here are trace, debug, info, warning, error, and fatal

doc/validators-example.txt

@@ -8,20 +8,41 @@
 # Blank lines and lines starting with a '#' are ignored.
 # All other lines should be hankos or domain names.
 #
-# [validators]:
-#   List of nodes to accept as validators specified by public key or domain.
 #
-#   For domains, rippled will probe for https web servers at the specified
-#   domain in the following order: ripple.DOMAIN, www.DOMAIN, DOMAIN
 #
-#   Examples: redstem.com
-#             n9KorY8QtTdRx7TVDpwnG9NvyxsDwHUKUEeDLY3AkiGncVaSXZi5
-#             n9MqiExBcoG19UXwoLjBJnhsxEhAZMuWwJDRdkyDz1EkEkwzQTNt John Doe
+# [validators]
+#
+#   List of the validation public keys of nodes to always accept as validators.
+#   A comment may, optionally, be associated with each entry, separated by
+#   whitespace from the validation public key.
+#
+#   The latest list of recommended validators can be obtained from
+#   https://ripple.com/ripple.txt
+#
+#   See also https://wiki.ripple.com/Ripple.txt
+#
+#   Examples:
+#    n9KorY8QtTdRx7TVDpwnG9NvyxsDwHUKUEeDLY3AkiGncVaSXZi5
+#    n9MqiExBcoG19UXwoLjBJnhsxEhAZMuWwJDRdkyDz1EkEkwzQTNt John Doe
+#
+#
+#
+# [validation_quorum]
+#
+#   Sets the minimum number of trusted validations a ledger must have before
+#   the server considers it fully validated. Note that if you are validating,
+#   your validation counts.
 #
 
+# Public keys of the validators that this rippled instance trusts.
 [validators]
 n949f75evCHwgyP4fPVgaHqNHxUVN15PsJEZ3B3HnXPcPjcZAoy7 RL1
 n9MD5h24qrQqiyBC8aeqqCWvpiBiYQ3jxSr91uiDvmrkyHRdYLUj RL2
 n9L81uNCaPgtUJfaHh89gmdvXKAmSt5Gdsw2g1iPWaPkAHW5Nm4C RL3
 n9KiYM9CgngLvtRCQHZwgC2gjpdaZcCcbt3VboxiNFcKuwFVujzS RL4
 n9LdgEtkmGB9E2h3K4Vp7iGUaKuq23Zr32ehxiU8FWY7xoxbWTSA RL5
+
+# The number of validators rippled needs to accept a consensus.
+# Don't change this unless you know what you're doing.
+[validation_quorum]
+3

docs/.gitignore

@@ -0,0 +1,3 @@
+html
+temp
+out.txt

docs/Dockerfile

@@ -0,0 +1,22 @@
+FROM ubuntu:16.04
+
+RUN apt-get update
+RUN apt-get -y install build-essential g++ git libbz2-dev wget python-dev
+
+# Install Boost
+ENV BOOST_SHA 440a59f8bc4023dbe6285c9998b0f7fa288468b889746b1ef00e8b36c559dce1
+RUN wget https://sourceforge.net/projects/boost/files/boost/1.62.0/boost_1_62_0.tar.gz
+RUN echo "$BOOST_SHA  boost_1_62_0.tar.gz" | sha256sum -c
+RUN tar xzf boost_1_62_0.tar.gz
+RUN cd boost_1_62_0 && ./bootstrap.sh --prefix=/usr/local
+RUN cd boost_1_62_0 && ./b2 install
+ENV BOOST_ROOT=/boost_1_62_0
+
+# Install dependencies
+RUN apt-get -y install doxygen
+RUN apt-get -y install xsltproc
+
+CMD cd /opt/rippled/docs && \
+    chmod +x makeqbk.sh && \
+    ./makeqbk.sh && \
+    $BOOST_ROOT/b2

docs/Jamfile.v2

@@ -0,0 +1,71 @@
+#
+# Copyright (c) 2015-2016 Vinnie Falco (vinnie dot falco at gmail dot com)
+#
+# Distributed under the Boost Software License, Version 1.0. (See accompanying
+# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#
+
+import os ;
+
+local broot = [ os.environ BOOST_ROOT ] ;
+
+project rippled/doc ;
+
+using boostbook ;
+using quickbook ;
+using doxygen ;
+
+path-constant out : . ;
+
+install stylesheets
+    :
+        $(broot)/doc/src/boostbook.css
+    :
+        <location>$(out)/html
+    ;
+
+explicit stylesheets ;
+
+install images
+    :
+        [ glob $(broot)/doc/src/images/*.png ]
+    :
+        <location>$(out)/html/images
+    ;
+
+explicit images ;
+
+install callouts
+    :
+        [ glob $(broot)/doc/src/images/callouts/*.png ]
+    :
+        <location>$(out)/html/images/callouts
+    ;
+
+explicit callout ;
+
+xml doc
+    :
+        main.qbk
+    :
+        <location>temp
+        <include>$(broot)/tools/boostbook/dtd
+    ;
+
+boostbook boostdoc
+    :
+        doc
+    :
+        <xsl:param>chapter.autolabel=0
+        <xsl:param>boost.root=$(broot)
+        <xsl:param>chunk.first.sections=1               # Chunk the first top-level section?
+        <xsl:param>chunk.section.depth=8                # Depth to which sections should be chunked
+        <xsl:param>generate.section.toc.level=1         # Control depth of TOC generation in sections
+        <xsl:param>toc.max.depth=2                      # How many levels should be created for each TOC?
+        <xsl:param>toc.section.depth=2                  # How deep should recursive sections appear in the TOC?
+        <xsl:param>generate.toc="chapter toc section toc"
+    :
+        <location>temp
+        <dependency>stylesheets
+        <dependency>images
+    ;

docs/README.md

@@ -0,0 +1,84 @@
+# Building documentation
+
+## Specifying Files
+
+To specify the source files for which to build documentation, modify `INPUT`
+and its related fields in `docs/source.dox`. Note that the `INPUT` paths are
+relative to the `docs/` directory.
+
+## Install Dependencies
+
+### Windows
+
+Install these dependencies:
+
+1. Install [Doxygen](http://www.stack.nl/~dimitri/doxygen/download.html)
+2. Download the following zip files from [xsltproc](https://www.zlatkovic.com/pub/libxml/)
+  (Alternate download: ftp://ftp.zlatkovic.com/libxml/),
+  and extract the `bin\` folder contents into any folder in your path.
+  * iconv
+  * libxml2
+  * libxslt
+  * zlib
+3. Download [Boost](http://www.boost.org/users/download/)
+  1. Extract the compressed file contents to your (new) `$BOOST_ROOT` location.
+  2. Open a command prompt or shell in the `$BOOST_ROOT`.
+  3. `./bootstrap.bat`
+  4. (Optional, if you also plan to build rippled) `./bjam.exe --toolset=msvc-14.0
+   --build-type=complete variant=debug,release link=static runtime-link=static
+   address-model=64 stage`
+  5. If it is not already there, add your `$BOOST_ROOT` to your environment `$PATH`.
+
+### MacOS
+
+1. Install doxygen:
+  * Use homebrew to install: `brew install doxygen`.  The executable will be
+    installed in `/usr/local/bin` which is already in your path.
+  * Alternatively, install from here: [doxygen](http://www.stack.nl/~dimitri/doxygen/download.html).
+    You'll then need to make doxygen available to your command line.  You can
+    do this by adding a symbolic link from `/usr/local/bin` to the doxygen
+    executable.  For example, `$ ln -s /Applications/Doxygen.app/Contents/Resources/doxygen /usr/local/bin/doxygen`
+2. Install [Boost](http://www.boost.org/users/download/)
+  1. Extract the compressed file contents to your (new) `$BOOST_ROOT` location.
+  2. Open a command prompt or shell in the `$BOOST_ROOT`.
+  3. `$ ./bootstrap.bat`
+  4. (Optional, if you also plan to build rippled)
+     `$ ./b2 toolset=clang threading=multi runtime-link=static  link=static
+     cxxflags="-stdlib=libc++" linkflags="-stdlib=libc++" adress-model=64`
+  5. If it is not already there, add your `$BOOST_ROOT` to your environment
+     `$PATH`.  This makes the `b2` command available to the command line.
+3. That should be all that's required.  In OS X 10.11, at least, libxml2 and
+   libxslt come pre-installed.
+
+### Linux
+
+1. Install [Docker](https://docs.docker.com/engine/installation/)
+2. Build Docker image. From the rippled root folder:
+```
+sudo docker build -t rippled-docs docs/
+```
+
+## Setup project submodules
+
+1. Open a shell in your rippled root folder.
+2. `git submodule init`
+3. `git submodule update docs/docca`
+
+## Do it
+
+### Windows & MacOS
+
+From the rippled root folder:
+```
+cd docs
+./makeqbk.sh && b2
+```
+The output will be in `docs/html`.
+
+### Linux
+
+From the rippled root folder:
+```
+sudo docker run -v $PWD:/opt/rippled --rm rippled-docs
+```
+The output will be in `docs/html`.

docs/boostbook.dtd

@@ -0,0 +1,439 @@
+<!--
+   BoostBook DTD - development version
+
+   For further information, see: http://www.crystalclearsoftware.com/cgi-bin/boost_wiki/wiki.pl?Boost_Documentation_Format
+
+   Copyright (c) 2002 by Peter Simons <simons@cryp.to>
+   Copyright (c) 2003-2004 by Douglas Gregor <doug.gregor -at- gmail.com>
+   Copyright (c) 2007 by Frank Mori Hess <fmhess@users.sourceforge.net>
+
+   Distributed under the Boost Software License, Version 1.0.
+   (See accompanying file LICENSE_1_0.txt or copy at
+   http://www.boost.org/LICENSE_1_0.txt)
+
+   The latest stable DTD module is identified by the PUBLIC and SYSTEM identifiers:
+
+   PUBLIC "-//Boost//DTD BoostBook XML V1.1//EN"
+   SYSTEM "http://www.boost.org/tools/boostbook/dtd/1.1/boostbook.dtd"
+
+   $Revision$
+   $Date$
+-->
+
+<!--========== Define XInclude features. ==========-->
+<!-- This is not really integrated into the DTD yet. Needs more
+     research. -->
+<!--
+<!ELEMENT xi:include (xi:fallback)?>
+<!ATTLIST xi:include
+    xmlns:xi   CDATA       #FIXED    "http://www.w3.org/2001/XInclude"
+    href       CDATA       #REQUIRED
+    parse      (xml|text)  "xml"
+    encoding   CDATA       #IMPLIED>
+
+<!ELEMENT xi:fallback ANY>
+<!ATTLIST xi:fallback
+    xmlns:xi   CDATA   #FIXED   "http://www.w3.org/2001/XInclude">
+ -->
+
+<!ENTITY % local.common.attrib "last-revision CDATA  #IMPLIED">
+
+<!--========== Define the BoostBook extensions ==========-->
+<!ENTITY % boost.common.attrib "%local.common.attrib;
+                                id            CDATA  #IMPLIED">
+
+<!ENTITY % boost.namespace.mix
+        "class|class-specialization|struct|struct-specialization|
+         union|union-specialization|typedef|enum|
+         free-function-group|function|overloaded-function|
+         namespace">
+
+<!ENTITY % boost.template.mix
+        "template-type-parameter|template-nontype-parameter|template-varargs">
+
+<!ENTITY % boost.class.members
+        "static-constant|typedef|enum|
+         copy-assignment|constructor|destructor|method-group|
+         method|overloaded-method|data-member|class|class-specialization|struct|
+         struct-specialization|union|union-specialization">
+
+<!ENTITY % boost.class.mix
+        "%boost.class.members;|free-function-group|function|overloaded-function">
+
+<!ENTITY % boost.class.content
+             "template?, inherit*, purpose?, description?,
+              (%boost.class.mix;|access)*">
+
+<!ENTITY % boost.class-specialization.content
+             "template?, specialization?, inherit?, purpose?, description?,
+              (%boost.class.mix;|access)*">
+
+<!ENTITY % boost.function.semantics
+        "purpose?, description?, requires?, effects?, postconditions?,
+         returns?, throws?, complexity?, notes?, rationale?">
+
+<!ENTITY % library.content
+        "libraryinfo, (title, ((section|library-reference|testsuite))+)?">
+
+<!ELEMENT library (%library.content;)>
+<!ATTLIST library
+    name      CDATA   #REQUIRED
+    dirname   CDATA   #REQUIRED
+    html-only CDATA   #IMPLIED
+    url       CDATA   #IMPLIED
+    %boost.common.attrib;>
+
+<!ELEMENT boostbook (title, (chapter|library)*)>
+<!ATTLIST boostbook %boost.common.attrib;>
+
+<!ELEMENT libraryinfo (author+, copyright*, legalnotice*, librarypurpose, librarycategory*)>
+<!ATTLIST libraryinfo %boost.common.attrib;>
+
+<!ELEMENT librarypurpose (#PCDATA|code|ulink|functionname|methodname|classname|macroname|headername|enumname|globalname)*>
+<!ATTLIST librarypurpose %boost.common.attrib;>
+
+<!ELEMENT librarycategory (#PCDATA)>
+<!ATTLIST librarycategory
+    name  CDATA  #REQUIRED
+    %boost.common.attrib;>
+
+<!ELEMENT libraryname  (#PCDATA)>
+<!ATTLIST libraryname %boost.common.attrib;>
+
+<!ELEMENT library-reference ANY>
+<!ATTLIST library-reference
+    %boost.common.attrib;>
+
+<!ELEMENT librarylist EMPTY>
+<!ATTLIST librarylist %boost.common.attrib;>
+
+<!ELEMENT librarycategorylist (librarycategorydef)*>
+<!ATTLIST librarycategorylist %boost.common.attrib;>
+
+<!ELEMENT librarycategorydef (#PCDATA)>
+<!ATTLIST librarycategorydef
+         name   CDATA   #REQUIRED
+         %boost.common.attrib;>
+
+<!ELEMENT header ANY>
+<!ATTLIST header
+    name  CDATA  #REQUIRED
+    %boost.common.attrib;>
+
+<!ELEMENT namespace (%boost.namespace.mix;)*>
+<!ATTLIST namespace
+    name  CDATA  #REQUIRED
+    %boost.common.attrib;>
+
+<!ELEMENT class (%boost.class.content;)>
+<!ATTLIST class
+    name  CDATA  #REQUIRED
+    %boost.common.attrib;>
+
+<!ELEMENT struct (%boost.class.content;)>
+<!ATTLIST struct
+    name  CDATA  #REQUIRED
+    %boost.common.attrib;>
+
+<!ELEMENT union (%boost.class.content;)>
+<!ATTLIST union
+    name  CDATA  #REQUIRED
+    %boost.common.attrib;>
+
+<!ELEMENT class-specialization (%boost.class-specialization.content;)>
+<!ATTLIST class-specialization
+    name  CDATA  #REQUIRED
+    %boost.common.attrib;>
+
+<!ELEMENT struct-specialization (%boost.class-specialization.content;)>
+<!ATTLIST struct-specialization
+    name  CDATA  #REQUIRED
+    %boost.common.attrib;>
+
+<!ELEMENT union-specialization (%boost.class-specialization.content;)>
+<!ATTLIST union-specialization
+    name  CDATA  #REQUIRED
+    %boost.common.attrib;>
+
+<!ELEMENT access (%boost.class.members;)+>
+<!ATTLIST access
+    name CDATA #REQUIRED
+    %boost.common.attrib;>
+
+<!--========= C++ Templates =========-->
+<!ELEMENT template (%boost.template.mix;)*>
+<!ATTLIST template %boost.common.attrib;>
+
+<!ELEMENT template-type-parameter (default?, purpose?)>
+<!ATTLIST template-type-parameter
+    name                     CDATA  #REQUIRED
+    pack                     CDATA  #IMPLIED 
+    %boost.common.attrib;>
+
+<!ELEMENT template-nontype-parameter (type, default?, purpose?)>
+<!ATTLIST template-nontype-parameter
+    name                     CDATA  #REQUIRED
+    pack                     CDATA  #IMPLIED 
+    %boost.common.attrib;>
+
+<!ELEMENT template-varargs EMPTY>
+<!ATTLIST template-varargs %boost.common.attrib;>
+
+<!ELEMENT specialization (template-arg)*>
+<!ATTLIST specialization %boost.common.attrib;>
+
+<!ELEMENT template-arg ANY>
+<!ATTLIST template-arg
+    pack    CDATA  #IMPLIED 
+    %boost.common.attrib;>
+
+<!ELEMENT default ANY>
+<!ATTLIST default %boost.common.attrib;>
+
+<!ELEMENT inherit (type, purpose?)>
+<!ATTLIST inherit
+    access  CDATA  #IMPLIED
+    pack    CDATA  #IMPLIED 
+    %boost.common.attrib;>
+
+<!ELEMENT purpose ANY>
+<!ATTLIST purpose %boost.common.attrib;>
+
+<!ELEMENT description ANY>
+<!ATTLIST description %boost.common.attrib;>
+
+<!ELEMENT type ANY>
+<!ATTLIST type %boost.common.attrib;>
+
+<!ELEMENT typedef (type, purpose?, description?)>
+<!ATTLIST typedef
+    name     CDATA  #REQUIRED
+    %boost.common.attrib;>
+
+<!ELEMENT enum (enumvalue*, purpose?, description?)>
+<!ATTLIST enum
+    name     CDATA  #REQUIRED
+    %boost.common.attrib;>
+
+<!ELEMENT enumvalue (default?, purpose?, description?)>
+<!ATTLIST enumvalue
+    name     CDATA  #REQUIRED
+    %boost.common.attrib;>
+
+<!ELEMENT static-constant (type, default, purpose?, description?)>
+<!ATTLIST static-constant
+    name   CDATA  #REQUIRED
+    %boost.common.attrib;>
+
+<!ELEMENT data-member (type, purpose?, description?)>
+<!ATTLIST data-member
+    name         CDATA  #REQUIRED
+    specifiers   CDATA  #IMPLIED
+    %boost.common.attrib;>
+
+<!ELEMENT paramtype ANY>
+<!ATTLIST paramtype %boost.common.attrib;>
+
+<!ELEMENT effects ANY>
+<!ATTLIST effects %boost.common.attrib;>
+
+<!ELEMENT postconditions ANY>
+<!ATTLIST postconditions %boost.common.attrib;>
+
+<!ELEMENT method-group (method|overloaded-method)*>
+<!ATTLIST method-group
+    name  CDATA  #REQUIRED
+    %boost.common.attrib;>
+
+<!ELEMENT constructor (template?, parameter*, %boost.function.semantics;)>
+<!ATTLIST constructor
+    specifiers   CDATA  #IMPLIED
+    %boost.common.attrib;>
+
+<!ELEMENT destructor (%boost.function.semantics;)>
+<!ATTLIST destructor
+    specifiers   CDATA  #IMPLIED
+    %boost.common.attrib;>
+
+<!ELEMENT method (template?, type, parameter*, %boost.function.semantics;)>
+<!ATTLIST method
+    name         CDATA  #REQUIRED
+    cv           CDATA  #IMPLIED
+    specifiers   CDATA  #IMPLIED
+    %boost.common.attrib;>
+
+<!ELEMENT function (template?, type, parameter*, %boost.function.semantics;)>
+<!ATTLIST function
+    name         CDATA  #REQUIRED
+    specifiers   CDATA  #IMPLIED
+    %boost.common.attrib;>
+
+<!ELEMENT overloaded-method (signature*, %boost.function.semantics;)>
+<!ATTLIST overloaded-method
+    name  CDATA  #REQUIRED
+    %boost.common.attrib;>
+
+<!ELEMENT overloaded-function (signature*, %boost.function.semantics;)>
+<!ATTLIST overloaded-function
+    name  CDATA  #REQUIRED
+    %boost.common.attrib;>
+
+<!ELEMENT signature (template?, type, parameter*)>
+<!ATTLIST signature
+    cv           CDATA  #IMPLIED
+    specifiers   CDATA  #IMPLIED
+    %boost.common.attrib;>
+
+<!ELEMENT requires ANY>
+<!ATTLIST requires %boost.common.attrib;>
+
+<!ELEMENT returns ANY>
+<!ATTLIST returns %boost.common.attrib;>
+
+<!ELEMENT throws ANY>
+<!ATTLIST throws %boost.common.attrib;>
+
+<!ELEMENT complexity ANY>
+<!ATTLIST complexity %boost.common.attrib;>
+
+<!ELEMENT notes ANY>
+<!ATTLIST notes %boost.common.attrib;>
+
+<!ELEMENT rationale ANY>
+<!ATTLIST rationale %boost.common.attrib;>
+
+<!ELEMENT functionname (#PCDATA)>
+<!ATTLIST functionname
+    alt          CDATA  #IMPLIED
+    %boost.common.attrib;>
+
+<!ELEMENT enumname (#PCDATA)>
+<!ATTLIST enumname
+    alt          CDATA  #IMPLIED
+    %boost.common.attrib;>
+
+<!ELEMENT macroname (#PCDATA)>
+<!ATTLIST macroname
+    alt          CDATA  #IMPLIED
+    %boost.common.attrib;>
+
+<!ELEMENT headername (#PCDATA)>
+<!ATTLIST headername
+    alt          CDATA  #IMPLIED
+    %boost.common.attrib;>
+
+<!ELEMENT globalname (#PCDATA)>
+<!ATTLIST globalname
+    alt          CDATA  #IMPLIED
+    %boost.common.attrib;>
+
+<!ELEMENT copy-assignment
+    (template?, type?, parameter*, %boost.function.semantics;)>
+<!ATTLIST copy-assignment
+    cv           CDATA  #IMPLIED
+    specifiers   CDATA  #IMPLIED
+    %boost.common.attrib;>
+
+<!ELEMENT free-function-group (function|overloaded-function)*>
+<!ATTLIST free-function-group
+    name  CDATA  #REQUIRED
+    %boost.common.attrib;>
+
+<!ELEMENT precondition ANY>
+<!ATTLIST precondition %boost.common.attrib;>
+
+<!ELEMENT code ANY>
+<!ATTLIST code %boost.common.attrib;>
+
+<!ELEMENT using-namespace EMPTY>
+<!ATTLIST using-namespace
+    name   CDATA  #REQUIRED
+    %boost.common.attrib;>
+
+<!ELEMENT using-class EMPTY>
+<!ATTLIST using-class
+     name        CDATA #REQUIRED
+     %boost.common.attrib;>
+
+<!--========== Boost Testsuite Extensions ==========-->
+<!ENTITY % boost.testsuite.tests
+        "compile-test|link-test|run-test|
+         compile-fail-test|link-fail-test|run-fail-test">
+<!ENTITY % boost.testsuite.test.content
+        "source*, lib*, requirement*, purpose, if-fails?">
+
+<!ELEMENT testsuite ((%boost.testsuite.tests;)+)>
+<!ATTLIST testsuite %boost.common.attrib;>
+
+<!ELEMENT compile-test (%boost.testsuite.test.content;)>
+<!ATTLIST compile-test
+     filename CDATA #REQUIRED
+     name     CDATA #IMPLIED>
+
+<!ELEMENT link-test (%boost.testsuite.test.content;)>
+<!ATTLIST link-test
+     filename CDATA #REQUIRED
+     name     CDATA #IMPLIED>
+
+<!ELEMENT run-test (%boost.testsuite.test.content;)>
+<!ATTLIST run-test
+     filename CDATA #REQUIRED
+     name     CDATA #IMPLIED>
+
+<!ELEMENT compile-fail-test (%boost.testsuite.test.content;)>
+<!ATTLIST compile-fail-test
+     filename CDATA #REQUIRED
+     name     CDATA #IMPLIED>
+
+<!ELEMENT link-fail-test (%boost.testsuite.test.content;)>
+<!ATTLIST link-fail-test
+     filename CDATA #REQUIRED
+     name     CDATA #IMPLIED>
+
+<!ELEMENT run-fail-test (%boost.testsuite.test.content;)>
+<!ATTLIST run-fail-test
+     filename CDATA #REQUIRED
+     name     CDATA #IMPLIED>
+
+<!ELEMENT source (#PCDATA|snippet)*>
+
+<!ELEMENT snippet EMPTY>
+<!ATTLIST snippet
+     name CDATA #REQUIRED>
+
+<!ELEMENT lib (#PCDATA)>
+
+<!ELEMENT requirement (#PCDATA)>
+<!ATTLIST requirement
+     name CDATA #REQUIRED>
+
+<!ELEMENT if-fails ANY>
+
+<!ELEMENT parameter (paramtype, default?, description?)>
+<!ATTLIST parameter
+     name CDATA #IMPLIED
+     pack CDATA #IMPLIED>
+
+<!ELEMENT programlisting ANY>
+<!ATTLIST programlisting
+     name        CDATA #IMPLIED>
+
+<!--========== Customize the DocBook DTD ==========-->
+<!ENTITY % local.tech.char.class "|functionname|libraryname|enumname|headername|macroname|code">
+<!ENTITY % local.para.class
+        "|using-namespace|using-class|librarylist|librarycategorylist">
+<!ENTITY % local.descobj.class "|libraryinfo">
+<!ENTITY % local.classname.attrib "alt CDATA #IMPLIED">
+<!ENTITY % local.methodname.attrib "alt CDATA #IMPLIED">
+<!ENTITY % local.refentry.class "|library-reference|testsuite">
+<!ENTITY % local.title.char.mix "">
+<!ENTITY % programlisting.module "IGNORE">
+<!ENTITY % parameter.module      "IGNORE">
+<!ENTITY % function.module       "IGNORE">
+<!ENTITY % type.module           "IGNORE">
+
+<!--========== Import DocBook DTD ==========-->
+<!ENTITY % DocBook PUBLIC "-//OASIS//DTD DocBook XML V4.2//EN"
+           "http://www.oasis-open.org/docbook/xml/4.2/docbookx.dtd">
+
+%DocBook;

docs/index.xml

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN" "boostbook.dtd">
+
+<!--
+  Copyright (c) 2013-2016 Vinnie Falco (vinnie dot falco at gmail dot com)
+
+  Distributed under the Boost Software License, Version 1.0. (See accompanying
+  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+-->
+
+<section id="rippled.index">
+  <title>Index</title>
+  <index/>
+</section>

docs/main.qbk

@@ -1,7 +1,5 @@
-//------------------------------------------------------------------------------
-/*
-    This file is part of Beast: https://github.com/vinniefalco/Beast
-    Copyright 2013, Vinnie Falco <vinnie.falco@gmail.com>
+[/
+    Copyright (c) Copyright (c) 2012, 2013 Ripple Labs Inc.
 
     Permission to use, copy, modify, and/or distribute this software for any
     purpose  with  or without fee is hereby granted, provided that the above
@@ -14,15 +12,26 @@
     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_SMARTPTR_H_INCLUDED
-#define BEAST_SMARTPTR_H_INCLUDED
+[library rippled
+    [quickbook 1.6]
+    [copyright 2012 - 2016 Ripple Labs Inc.]
+    [purpose C++ Library]
+    [license
+        Distributed under the ISC License
+    ]
+    [authors [Labs, Ripple]]
+    [category template]
+    [category generic]
+]
 
-#include <beast/Config.h>
+[template mdash[] '''&mdash; ''']
+[template indexterm1[term1] '''<indexterm><primary>'''[term1]'''</primary></indexterm>''']
+[template indexterm2[term1 term2] '''<indexterm><primary>'''[term1]'''</primary><secondary>'''[term2]'''</secondary></indexterm>''']
 
-#include <beast/smart_ptr/SharedObject.h>
-#include <beast/smart_ptr/SharedPtr.h>
+[section:ref Reference]
+[include temp/reference.qbk]
+[endsect]
 
-#endif
+[xinclude index.xml]

docs/makeqbk.sh

@@ -0,0 +1,11 @@
+#!/bin/bash
+
+# Copyright (c) 2013-2016 Vinnie Falco (vinnie dot falco at gmail dot com)
+#
+# Distributed under the Boost Software License, Version 1.0. (See accompanying
+# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+mkdir -p temp
+doxygen source.dox
+xsltproc temp/combine.xslt temp/index.xml > temp/all.xml
+xsltproc reference.xsl temp/all.xml > temp/reference.qbk

docs/quickref.xml

@@ -0,0 +1,61 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN" "boostbook.dtd">
+
+<!--
+  Copyright (c) Copyright (c) 2012, 2013 Ripple Labs Inc.
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose  with  or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
+  MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+-->
+
+<informaltable frame="all">
+  <tgroup cols="3">
+    <colspec colname="a"/>
+    <colspec colname="b"/>
+    <colspec colname="c"/>
+    <thead>
+      <row>
+        <entry valign="center" namest="a" nameend="c">
+          <bridgehead renderas="sect2">Core</bridgehead>
+        </entry>
+      </row>
+    </thead>
+    <tbody>
+      <row>
+        <entry valign="top">
+          <bridgehead renderas="sect3">Classes</bridgehead>
+          <simplelist type="vert" columns="1">
+          </simplelist>
+          <bridgehead renderas="sect3">Constants</bridgehead>
+          <simplelist type="vert" columns="1">
+          </simplelist>
+        </entry>
+        <entry valign="top">
+          <bridgehead renderas="sect3">Functions</bridgehead>
+          <simplelist type="vert" columns="1">
+          </simplelist>
+          <bridgehead renderas="sect3">Type Traits</bridgehead>
+          <simplelist type="vert" columns="1">
+          </simplelist>
+        </entry>
+        <entry valign="top">
+          <bridgehead renderas="sect3">Types</bridgehead>
+          <simplelist type="vert" columns="1">
+          </simplelist>
+          <bridgehead renderas="sect3">Concepts</bridgehead>
+          <simplelist type="vert" columns="1">
+          </simplelist>
+        </entry>
+      </row>
+    </tbody>
+  </tgroup>
+</informaltable>

docs/reference.xsl

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="utf-8"?>
+<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
+
+<!-- Variables (Edit for your project) -->
+<xsl:variable name="doc-ref" select="'rippled.ref.'"/>
+<xsl:variable name="doc-ns" select="'ripple'"/>
+<xsl:variable name="debug" select="0"/>
+<xsl:variable name="private" select="0"/>
+<!-- End Variables -->
+
+<xsl:include href="docca/include/docca/doxygen.xsl"/>
+
+</xsl:stylesheet>
+

docs/source.dox

@@ -0,0 +1,341 @@
+#---------------------------------------------------------------------------
+# Project related configuration options
+#---------------------------------------------------------------------------
+DOXYFILE_ENCODING      = UTF-8
+PROJECT_NAME           = "rippled"
+PROJECT_NUMBER         =
+PROJECT_BRIEF          = C++ Library
+PROJECT_LOGO           =
+OUTPUT_DIRECTORY       =
+CREATE_SUBDIRS         = NO
+ALLOW_UNICODE_NAMES    = NO
+OUTPUT_LANGUAGE        = English
+BRIEF_MEMBER_DESC      = YES
+REPEAT_BRIEF           = YES
+ABBREVIATE_BRIEF       =
+ALWAYS_DETAILED_SEC    = NO
+INLINE_INHERITED_MEMB  = YES
+FULL_PATH_NAMES        = NO
+STRIP_FROM_PATH        = ../src/
+STRIP_FROM_INC_PATH    =
+SHORT_NAMES            = NO
+JAVADOC_AUTOBRIEF      = YES
+QT_AUTOBRIEF           = NO
+MULTILINE_CPP_IS_BRIEF = NO
+INHERIT_DOCS           = YES
+SEPARATE_MEMBER_PAGES  = NO
+TAB_SIZE               = 4
+ALIASES                =
+TCL_SUBST              =
+OPTIMIZE_OUTPUT_FOR_C  = NO
+OPTIMIZE_OUTPUT_JAVA   = NO
+OPTIMIZE_FOR_FORTRAN   = NO
+OPTIMIZE_OUTPUT_VHDL   = NO
+EXTENSION_MAPPING      =
+MARKDOWN_SUPPORT       = YES
+AUTOLINK_SUPPORT       = YES
+BUILTIN_STL_SUPPORT    = NO
+CPP_CLI_SUPPORT        = NO
+SIP_SUPPORT            = NO
+IDL_PROPERTY_SUPPORT   = YES
+DISTRIBUTE_GROUP_DOC   = NO
+GROUP_NESTED_COMPOUNDS = NO
+SUBGROUPING            = YES
+INLINE_GROUPED_CLASSES = NO
+INLINE_SIMPLE_STRUCTS  = NO
+TYPEDEF_HIDES_STRUCT   = NO
+LOOKUP_CACHE_SIZE      = 0
+
+#---------------------------------------------------------------------------
+# Build related configuration options
+#---------------------------------------------------------------------------
+EXTRACT_ALL            = YES
+EXTRACT_PRIVATE        = YES
+EXTRACT_PACKAGE        = NO
+EXTRACT_STATIC         = YES
+EXTRACT_LOCAL_CLASSES  = YES
+EXTRACT_LOCAL_METHODS  = YES
+EXTRACT_ANON_NSPACES   = NO
+HIDE_UNDOC_MEMBERS     = NO
+HIDE_UNDOC_CLASSES     = NO
+HIDE_FRIEND_COMPOUNDS  = NO
+HIDE_IN_BODY_DOCS      = NO
+INTERNAL_DOCS          = NO
+CASE_SENSE_NAMES       = YES
+HIDE_SCOPE_NAMES       = NO
+HIDE_COMPOUND_REFERENCE= NO
+SHOW_INCLUDE_FILES     = NO
+SHOW_GROUPED_MEMB_INC  = NO
+FORCE_LOCAL_INCLUDES   = NO
+INLINE_INFO            = NO
+SORT_MEMBER_DOCS       = NO
+SORT_BRIEF_DOCS        = NO
+SORT_MEMBERS_CTORS_1ST = YES
+SORT_GROUP_NAMES       = NO
+SORT_BY_SCOPE_NAME     = NO
+STRICT_PROTO_MATCHING  = NO
+GENERATE_TODOLIST      = NO
+GENERATE_TESTLIST      = NO
+GENERATE_BUGLIST       = NO
+GENERATE_DEPRECATEDLIST= NO
+ENABLED_SECTIONS       =
+MAX_INITIALIZER_LINES  = 30
+SHOW_USED_FILES        = NO
+SHOW_FILES             = NO
+SHOW_NAMESPACES        = NO
+FILE_VERSION_FILTER    =
+LAYOUT_FILE            =
+CITE_BIB_FILES         =
+
+#---------------------------------------------------------------------------
+# Configuration options related to warning and progress messages
+#---------------------------------------------------------------------------
+QUIET                  = NO
+WARNINGS               = YES
+WARN_IF_UNDOCUMENTED   = YES
+WARN_IF_DOC_ERROR      = YES
+WARN_NO_PARAMDOC       = NO
+WARN_AS_ERROR          = NO
+WARN_FORMAT            = "$file:$line: $text"
+WARN_LOGFILE           =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the input files
+#---------------------------------------------------------------------------
+INPUT                  = \
+\
+    ../src/ripple/protocol/STObject.h \
+    ../src/ripple/protocol/JsonFields.h \
+    ../src/test/support/AbstractClient.h \
+    ../src/test/support/JSONRPCClient.h \
+    ../src/test/support/WSClient.h \
+
+
+INPUT_ENCODING         = UTF-8
+FILE_PATTERNS          =
+RECURSIVE              = NO
+EXCLUDE                =
+EXCLUDE_SYMLINKS       = NO
+EXCLUDE_PATTERNS       =
+EXCLUDE_SYMBOLS        =
+EXAMPLE_PATH           =
+EXAMPLE_PATTERNS       =
+EXAMPLE_RECURSIVE      = NO
+IMAGE_PATH             =
+INPUT_FILTER           =
+FILTER_PATTERNS        =
+FILTER_SOURCE_FILES    = NO
+FILTER_SOURCE_PATTERNS =
+USE_MDFILE_AS_MAINPAGE =
+
+#---------------------------------------------------------------------------
+# Configuration options related to source browsing
+#---------------------------------------------------------------------------
+SOURCE_BROWSER         = NO
+INLINE_SOURCES         = NO
+STRIP_CODE_COMMENTS    = YES
+REFERENCED_BY_RELATION = NO
+REFERENCES_RELATION    = NO
+REFERENCES_LINK_SOURCE = YES
+SOURCE_TOOLTIPS        = YES
+USE_HTAGS              = NO
+VERBATIM_HEADERS       = YES
+CLANG_ASSISTED_PARSING = NO
+CLANG_OPTIONS          =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the alphabetical class index
+#---------------------------------------------------------------------------
+ALPHABETICAL_INDEX     = YES
+COLS_IN_ALPHA_INDEX    = 5
+IGNORE_PREFIX          =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the HTML output
+#---------------------------------------------------------------------------
+GENERATE_HTML          = NO
+HTML_OUTPUT            = dhtm
+HTML_FILE_EXTENSION    = .html
+HTML_HEADER            =
+HTML_FOOTER            =
+HTML_STYLESHEET        =
+HTML_EXTRA_STYLESHEET  =
+HTML_EXTRA_FILES       =
+HTML_COLORSTYLE_HUE    = 220
+HTML_COLORSTYLE_SAT    = 100
+HTML_COLORSTYLE_GAMMA  = 80
+HTML_TIMESTAMP         = NO
+HTML_DYNAMIC_SECTIONS  = NO
+HTML_INDEX_NUM_ENTRIES = 100
+GENERATE_DOCSET        = NO
+DOCSET_FEEDNAME        = "Doxygen generated docs"
+DOCSET_BUNDLE_ID       = org.doxygen.Project
+DOCSET_PUBLISHER_ID    = org.doxygen.Publisher
+DOCSET_PUBLISHER_NAME  = Publisher
+GENERATE_HTMLHELP      = NO
+CHM_FILE               =
+HHC_LOCATION           =
+GENERATE_CHI           = NO
+CHM_INDEX_ENCODING     =
+BINARY_TOC             = NO
+TOC_EXPAND             = NO
+GENERATE_QHP           = NO
+QCH_FILE               =
+QHP_NAMESPACE          = org.doxygen.Project
+QHP_VIRTUAL_FOLDER     = doc
+QHP_CUST_FILTER_NAME   =
+QHP_CUST_FILTER_ATTRS  =
+QHP_SECT_FILTER_ATTRS  =
+QHG_LOCATION           =
+GENERATE_ECLIPSEHELP   = NO
+ECLIPSE_DOC_ID         = org.doxygen.Project
+DISABLE_INDEX          = NO
+GENERATE_TREEVIEW      = NO
+ENUM_VALUES_PER_LINE   = 4
+TREEVIEW_WIDTH         = 250
+EXT_LINKS_IN_WINDOW    = NO
+FORMULA_FONTSIZE       = 10
+FORMULA_TRANSPARENT    = YES
+USE_MATHJAX            = NO
+MATHJAX_FORMAT         = HTML-CSS
+MATHJAX_RELPATH        = http://cdn.mathjax.org/mathjax/latest
+MATHJAX_EXTENSIONS     =
+MATHJAX_CODEFILE       =
+SEARCHENGINE           = YES
+SERVER_BASED_SEARCH    = NO
+EXTERNAL_SEARCH        = NO
+SEARCHENGINE_URL       =
+SEARCHDATA_FILE        = searchdata.xml
+EXTERNAL_SEARCH_ID     =
+EXTRA_SEARCH_MAPPINGS  =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the LaTeX output
+#---------------------------------------------------------------------------
+GENERATE_LATEX         = NO
+LATEX_OUTPUT           = latex
+LATEX_CMD_NAME         = latex
+MAKEINDEX_CMD_NAME     = makeindex
+COMPACT_LATEX          = NO
+PAPER_TYPE             = a4
+EXTRA_PACKAGES         =
+LATEX_HEADER           =
+LATEX_FOOTER           =
+LATEX_EXTRA_STYLESHEET =
+LATEX_EXTRA_FILES      =
+PDF_HYPERLINKS         = YES
+USE_PDFLATEX           = YES
+LATEX_BATCHMODE        = NO
+LATEX_HIDE_INDICES     = NO
+LATEX_SOURCE_CODE      = NO
+LATEX_BIB_STYLE        = plain
+LATEX_TIMESTAMP        = NO
+
+#---------------------------------------------------------------------------
+# Configuration options related to the RTF output
+#---------------------------------------------------------------------------
+GENERATE_RTF           = NO
+RTF_OUTPUT             = rtf
+COMPACT_RTF            = NO
+RTF_HYPERLINKS         = NO
+RTF_STYLESHEET_FILE    =
+RTF_EXTENSIONS_FILE    =
+RTF_SOURCE_CODE        = NO
+
+#---------------------------------------------------------------------------
+# Configuration options related to the man page output
+#---------------------------------------------------------------------------
+GENERATE_MAN           = NO
+MAN_OUTPUT             = man
+MAN_EXTENSION          = .3
+MAN_SUBDIR             =
+MAN_LINKS              = NO
+
+#---------------------------------------------------------------------------
+# Configuration options related to the XML output
+#---------------------------------------------------------------------------
+GENERATE_XML           = YES
+XML_OUTPUT             = temp/
+XML_PROGRAMLISTING     = YES
+
+#---------------------------------------------------------------------------
+# Configuration options related to the DOCBOOK output
+#---------------------------------------------------------------------------
+GENERATE_DOCBOOK       = NO
+DOCBOOK_OUTPUT         = docbook
+DOCBOOK_PROGRAMLISTING = NO
+
+#---------------------------------------------------------------------------
+# Configuration options for the AutoGen Definitions output
+#---------------------------------------------------------------------------
+GENERATE_AUTOGEN_DEF   = NO
+GENERATE_PERLMOD       = NO
+PERLMOD_LATEX          = NO
+PERLMOD_PRETTY         = YES
+PERLMOD_MAKEVAR_PREFIX =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the preprocessor
+#---------------------------------------------------------------------------
+ENABLE_PREPROCESSING   = YES
+MACRO_EXPANSION        = YES
+EXPAND_ONLY_PREDEF     = YES
+SEARCH_INCLUDES        = YES
+INCLUDE_PATH           = ../
+INCLUDE_FILE_PATTERNS  =
+PREDEFINED             = DOXYGEN \
+                         GENERATING_DOCS \
+                         _MSC_VER \
+                         NUDB_POSIX_FILE=1
+
+EXPAND_AS_DEFINED      =
+SKIP_FUNCTION_MACROS   = YES
+
+#---------------------------------------------------------------------------
+# Configuration options related to external references
+#---------------------------------------------------------------------------
+TAGFILES               =
+GENERATE_TAGFILE       =
+ALLEXTERNALS           = NO
+EXTERNAL_GROUPS        = YES
+EXTERNAL_PAGES         = YES
+PERL_PATH              = /usr/bin/perl
+
+#---------------------------------------------------------------------------
+# Configuration options related to the dot tool
+#---------------------------------------------------------------------------
+CLASS_DIAGRAMS         = NO
+MSCGEN_PATH            =
+DIA_PATH               =
+HIDE_UNDOC_RELATIONS   = YES
+HAVE_DOT               = NO
+DOT_NUM_THREADS        = 0
+DOT_FONTNAME           = Helvetica
+DOT_FONTSIZE           = 10
+DOT_FONTPATH           =
+CLASS_GRAPH            = YES
+COLLABORATION_GRAPH    = YES
+GROUP_GRAPHS           = YES
+UML_LOOK               = NO
+UML_LIMIT_NUM_FIELDS   = 10
+TEMPLATE_RELATIONS     = NO
+INCLUDE_GRAPH          = YES
+INCLUDED_BY_GRAPH      = YES
+CALL_GRAPH             = NO
+CALLER_GRAPH           = NO
+GRAPHICAL_HIERARCHY    = YES
+DIRECTORY_GRAPH        = YES
+DOT_IMAGE_FORMAT       = png
+INTERACTIVE_SVG        = NO
+DOT_PATH               =
+DOTFILE_DIRS           =
+MSCFILE_DIRS           =
+DIAFILE_DIRS           =
+PLANTUML_JAR_PATH      =
+PLANTUML_INCLUDE_PATH  =
+DOT_GRAPH_MAX_NODES    = 50
+MAX_DOT_GRAPH_DEPTH    = 0
+DOT_TRANSPARENT        = NO
+DOT_MULTI_TARGETS      = NO
+GENERATE_LEGEND        = YES
+DOT_CLEANUP            = YES

package.json

@@ -1,31 +0,0 @@
-{
-  "name": "rippled",
-  "version": "0.0.1",
-  "description": "Rippled Server",
-  "private": true,
-  "directories": {
-    "test": "test"
-  },
-  "dependencies": {
-    "assert-diff": "^1.0.1",
-    "async": "~0.2.9",
-    "babel": "^5.8.21",
-    "coffee-script": "^1.8.0",
-    "deep-equal": "0.0.0",
-    "extend": "~1.2.0",
-    "lodash": "^3.5.0",
-    "mocha": "^2.1.0",
-    "request": "^2.47.0",
-    "ripple-lib": "0.13.0-rc6.0",
-    "simple-jsonrpc": "~0.0.2"
-  },
-  "scripts": {
-    "pretest": "node test/pretest.js",
-    "test": "mocha test/websocket-test.js test/server-test.js test/*-test.{js,coffee}"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git://github.com/ripple/rippled.git"
-  },
-  "readmeFilename": "README.md"
-}

src/BeastConfig.h

@@ -149,13 +149,6 @@
 #define RIPPLE_USE_VALIDATORS 0
 #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_SINGLE_IO_SERVICE_THREAD
     When set, restricts the number of threads calling io_service::run to one.
     This is useful when debugging.

src/beast/.gitignore

@@ -1,30 +1,2 @@
-Docs
-._*
-*.mode1v3
-*.pbxuser
-*.perspectivev3
-*.user
-*.ncb
-*.suo
-*.obj
-*.ilk
-*.pch
-*.pdb
-*.dep
-*.idb
-*.manifest
-*.manifest.res
-*.o
-*.opensdf
-*.d
-*.sdf
-xcuserdata
-contents.xcworkspacedata
-.DS_Store
-.svn
-profile
-Builds/VisualStudio2012/Debug
-Builds/VisualStudio2012/Release
-project.xcworkspace
-modules/beast_cryptopp
 bin/
+bin64/

src/beast/.travis.yml

@@ -1,26 +1,88 @@
+sudo: false
 language: cpp
 
-compiler:
-  - gcc
-  - clang
+env:
+  global:
+    - LLVM_VERSION=3.8.0
+    # Maintenance note: to move to a new version
+    # of boost, update both BOOST_ROOT and BOOST_URL.
+    # Note that for simplicity, BOOST_ROOT's final
+    # namepart must match the folder name internal
+    # to boost's .tar.gz.
+    - LCOV_ROOT=$HOME/lcov
+    - VALGRIND_ROOT=$HOME/valgrind-install
+    - BOOST_ROOT=$HOME/boost_1_61_0
+    - BOOST_URL='http://sourceforge.net/projects/boost/files/boost/1.61.0/boost_1_61_0.tar.gz'
+packages: &gcc5_pkgs
+  - gcc-5
+  - g++-5
+  - python-software-properties
+  - libssl-dev
+  - libffi-dev
+  - libstdc++6
+  - binutils-gold
+  # Provides a backtrace if the unittests crash
+  - gdb
+  # Needed for installing valgrind
+  - subversion
+  - automake
+  - autotools-dev
+  - libc6-dbg
+
+matrix:
+  include:
+    # GCC/Coverage/Autobahn (if master or develop branch)
+    - compiler: gcc
+      env:
+        - GCC_VER=5
+        - VARIANT=coverage
+        - ADDRESS_MODEL=64
+        - BUILD_SYSTEM=cmake
+        - PATH=$PWD/cmake/bin:$PATH
+      addons: &ao_gcc5
+        apt:
+          sources: ['ubuntu-toolchain-r-test']
+          packages: *gcc5_pkgs
+
+    # Clang/UndefinedBehaviourSanitizer
+    - compiler: clang
+      env:
+        - GCC_VER=5
+        - VARIANT=usan
+        - CLANG_VER=3.8
+        - ADDRESS_MODEL=64
+        - UBSAN_OPTIONS='print_stacktrace=1'
+        - BUILD_SYSTEM=cmake
+        - PATH=$PWD/cmake/bin:$PATH
+        - PATH=$PWD/llvm-$LLVM_VERSION/bin:$PATH
+      addons: *ao_gcc5
+
+    # Clang/AddressSanitizer
+    - compiler: clang
+      env:
+        - GCC_VER=5
+        - VARIANT=asan
+        - CLANG_VER=3.8
+        - ADDRESS_MODEL=64
+        - PATH=$PWD/llvm-$LLVM_VERSION/bin:$PATH
+      addons: *ao_gcc5
+
+cache:
+  directories:
+  - $BOOST_ROOT
+  - $VALGRIND_ROOT
+  - llvm-$LLVM_VERSION
+  - cmake
+
 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
+  - scripts/install-dependencies.sh
+
 script:
-  # Abort build on failure
-  - set -e
-  - scons 
+  - travis_retry scripts/build-and-test.sh
+
+after_script:
+  - cat nohup.out || echo "nohup.out already deleted"
+
 notifications:
   email:
     false

src/beast/BeastConfig.h

@@ -1,139 +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_BEASTCONFIG_H_INCLUDED
-#define BEAST_BEASTCONFIG_H_INCLUDED
-
-/** Configuration file for Beast.
-    This sets various configurable options for Beast. In order to compile you
-    must place a copy of this file in a location where your build environment
-    can find it, and then customize its contents to suit your needs.
-    @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
-//
-//------------------------------------------------------------------------------
-
-/** Config: BEAST_FORCE_DEBUG
-    Normally, BEAST_DEBUG is set to 1 or 0 based on compiler and project
-    settings, but if you define this value, you can override this to force it
-    to be true or false.
-*/
-#ifndef   BEAST_FORCE_DEBUG
-//#define BEAST_FORCE_DEBUG 1
-#endif
-
-/** Config: BEAST_CHECK_MEMORY_LEAKS
-    Enables a memory-leak check for certain objects when the app terminates.
-    See the LeakChecked class for more details about enabling leak checking for
-    specific classes.
-*/
-#ifndef   BEAST_CHECK_MEMORY_LEAKS
-//#define BEAST_CHECK_MEMORY_LEAKS 0
-#endif
-
-//------------------------------------------------------------------------------
-//
-// Libraries
-//
-//------------------------------------------------------------------------------
-
-/** Config: BEAST_DONT_AUTOLINK_TO_WIN32_LIBRARIES
-    In a Visual C++  build, this can be used to stop the required system libs
-    being automatically added to the link stage.
-*/
-#ifndef   BEAST_DONT_AUTOLINK_TO_WIN32_LIBRARIES
-//#define BEAST_DONT_AUTOLINK_TO_WIN32_LIBRARIES 1
-#endif
-
-/** Config: BEAST_INCLUDE_ZLIB_CODE
-    This can be used to disable Beast's embedded 3rd-party zlib code.
-    You might need to tweak this if you're linking to an external zlib library
-    in your app, but for normal apps, this option should be left alone.
-
-    If you disable this, you might also want to set a value for
-    BEAST_ZLIB_INCLUDE_PATH, to specify the path where your zlib headers live.
-*/
-#ifndef   BEAST_INCLUDE_ZLIB_CODE
-//#define BEAST_INCLUDE_ZLIB_CODE 1
-#endif
-
-/** Config: BEAST_ZLIB_INCLUDE_PATH
-    This is included when BEAST_INCLUDE_ZLIB_CODE is set to zero.
-*/
-#ifndef BEAST_ZLIB_INCLUDE_PATH
-#define BEAST_ZLIB_INCLUDE_PATH <zlib.h>
-#endif
-
-/** Config: BEAST_SQLITE_FORCE_NDEBUG
-    Setting this option forces sqlite into release mode even if NDEBUG is not set
-*/
-#ifndef   BEAST_SQLITE_FORCE_NDEBUG
-//#define BEAST_SQLITE_FORCE_NDEBUG 1
-#endif
-
-/** Config: BEAST_FUNCTIONAL_USES_###
-    <functional> source configuration.
-    Set one of these to manually force a particular implementation of bind().
-    If nothing is chosen then beast will use whatever is appropriate for your
-    environment based on what is available.
-    If you override these, set ONE to 1 and the rest to 0
-*/
-#ifndef   BEAST_FUNCTIONAL_USES_STD
-//#define BEAST_FUNCTIONAL_USES_STD    0
-#endif
-#ifndef   BEAST_FUNCTIONAL_USES_TR1
-//#define BEAST_FUNCTIONAL_USES_TR1    0
-#endif
-#ifndef   BEAST_FUNCTIONAL_USES_BOOST
-//#define BEAST_FUNCTIONAL_USES_BOOST  0
-#endif
-
-//------------------------------------------------------------------------------
-//
-// Boost
-//
-//------------------------------------------------------------------------------
-
-/** 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
-
-#endif

src/beast/CHANGELOG.md

@@ -0,0 +1,277 @@
+1.0.0-b23
+
+* Tune websocket echo server for performance
+* Add file and line number to thrown exceptions
+* Better logging in async echo server
+* Add copy special members
+* Fix message constructor and special members
+* Travis CI improvements 
+
+--------------------------------------------------------------------------------
+
+1.0.0-b22
+
+* Fix broken Intellisense
+* Implement the Asio deallocation-before-invocation guarantee
+* Add handler helpers
+* Avoid copies in handler_alloc
+* Update README.md example programs
+* Fix websocket stream read documentation
+* Disable Boost.Coroutine deprecation warning
+* Update documentation examples
+
+--------------------------------------------------------------------------------
+
+1.0.0-b21
+
+* Remove extraneous includes
+
+--------------------------------------------------------------------------------
+
+1.0.0-b20
+
+ZLib
+
+* Add ZLib module
+
+API Changes:
+
+* Rename HTTP identifiers
+
+--------------------------------------------------------------------------------
+
+1.0.0-b19
+
+* Boost library min/max guidance
+* Improvements to code coverage
+* Use boost::lexical_cast instead of std::to_string
+* Fix prepare_buffers value_type
+* Fix consuming_buffers value_type
+* Better buffer_cat
+
+HTTP
+
+* Make chunk_encode public
+* Add write, async_write, operator<< for message_headers
+* Add read, async_read for message_headers
+* Fix with_body example
+
+WebSocket
+
+* Optimize utf8 validation
+* Optimize mask operations
+
+API Changes:
+
+* Refactor message and message_headers declarations
+* prepared_buffers is private
+* consume_buffers is removed
+
+--------------------------------------------------------------------------------
+
+1.0.0-b18
+
+* Increase optimization settings for MSVC builds
+
+HTTP
+
+* Check invariants in parse_op:
+* Clean up message docs
+
+WebSocket
+
+* Write buffer option does not change capacity
+* Close connection during async_read on close frame
+* Add pong, async pong to stream
+
+Core
+
+* Meet DynamicBuffer requirements for static_streambuf
+* Fix write_frame masking and auto-fragment handling
+
+Extras
+
+* unit_test::suite fixes:
+  - New overload of fail() specifies file and line
+  - BEAST_EXPECTS only evaluates the reason string on a failure
+* Add zlib module
+
+--------------------------------------------------------------------------------
+
+1.0.0-b17
+
+* Change implicit to default value in example
+* Tidy up some declarations
+* Fix basic_streambuf::capacity
+* Add basic_streambuf::alloc_size
+* Parser callbacks may not throw
+* Fix Reader concept doc typo
+* Add is_Reader trait
+* Tidy up basic_headers for documentation
+* Tidy up documentation
+* Add basic_parser_v1::reset
+* Fix handling of body_what::pause in basic_parser_v1
+* Add headers_parser
+* Engaged invokable is destructible
+* Improve websocket example in README.md
+* Refactor read_size_helper
+
+API Changes:
+
+* Added init() to Reader requirements
+* Reader must be nothrow constructible
+* Reader is now constructed right before reading the body
+  - The message passed on construction is filled in
+* Rework HTTP concepts:
+  - Writer uses write instead of operator()
+  - Refactor traits to use void_t
+  - Remove is_ReadableBody, is_WritableBody
+  - Add has_reader, has_writer, is_Reader, is_Writer
+  - More friendly compile errors on failed concept checks
+* basic_parser_v1 requires all callbacks present
+* on_headers parser callback now returns void
+* on_body_what is a new required parser callback returning body_what
+
+--------------------------------------------------------------------------------
+
+1.0.0-b16
+
+* Make value optional in param-list
+* Frame processing routines are member functions
+* Fix on_headers called twice from basic_parser_v1
+* Constrain parser_v1 constructor
+* Improve first line serialization
+* Add pause option to on_headers interface
+* Refactor base_parser_v1 callback traits:
+* Refine Parser concept
+* Relax ForwardIterator requirements in FieldSequence
+* Fix websocket failure testing
+* Refine Writer concept and fix exemplar in documentation
+
+API Changes:
+
+* Rename mask_buffer_size to write_buffer_size
+* Make auto_fragment a boolean option
+
+The message class hierarchy is refactored (breaking change):
+
+* One message class now models both HTTP/1 and HTTP/2 messages
+* message_v1, request_v1, response_v1 removed
+* New classes basic_request and basic_response model
+  messages without the body.
+
+    Error resolution: Callers should use message, request,
+    and response instead of message_v1, request_v1, and
+    response_v1 respectively.
+
+--------------------------------------------------------------------------------
+
+1.0.0-b15
+
+* rfc7230 section 3.3.2 compliance
+* Add HTTPS example
+* Add Secure WebSocket example
+* Fix message_v1 constructor
+* Tidy up DynamicBuffer requirements
+* Tidy up error types and headers
+* Fix handling empty HTTP headers in parser_v1
+
+--------------------------------------------------------------------------------
+
+1.0.0-b14
+
+* Add missing rebind to handler_alloc
+* Fix error handling in http server examples
+* Fix CMake scripts for MinGW
+* Use BOOST_ASSERT
+* Better WebSocket decorator
+* Update and tidy documentation
+
+--------------------------------------------------------------------------------
+
+1.0.0-b13
+
+* dstream improvements
+* Remove bin and bin64 directories
+* Tidy up .vcxproj file groupings
+
+--------------------------------------------------------------------------------
+
+1.0.0-b12
+
+* Use -p to print suites from unit test main.
+* BEAST_EXPECTS to add a reason string to test failures
+* Fix unit test runner to output all case names
+* Update README for build requirements
+* Rename to CHANGELOG.md
+
+--------------------------------------------------------------------------------
+
+1.0.0-b11
+
+* Set URI in generated WebSocket Upgrade requests
+* Rename echo server class and file names
+* Rename to DynamicBuffer in some code and documentation
+* Fix integer warnings in Windows builds
+* Add 32 and 64 bit Windows build support
+* Update README for build instructions and more
+* Add repository and documention banners
+
+--------------------------------------------------------------------------------
+
+1.0.0-b10
+
+* Fix compilation warnings
+* Add websocketpp comparison to HTML documentation
+
+--------------------------------------------------------------------------------
+
+1.0.0-b9
+
+* Fix CMakeLists.txt
+
+--------------------------------------------------------------------------------
+
+1.0.0-b8
+
+* Fix include in example code
+* Fix basic_headers rfc2616 Section 4.2 compliance
+
+--------------------------------------------------------------------------------
+
+1.0.0-b7
+
+* Fix prepare by calling init. prepare() can throw depending on the
+  implementation of Writer. Publicly provided beast::http writers never throw.
+* Fixes to example HTTP server
+* Fully qualify ambiguous calls to read and parse
+* Remove deprecated http::stream wrapper
+* Example HTTP server now calculates the MIME-type
+* Fixes and documentation for teardown and use with SSL:
+* Add example code to rfc7230 javadocs
+* Remove extraneous header file <beast/http/status.hpp>
+* Add skip_body parser option
+
+--------------------------------------------------------------------------------
+
+1.0.0-b6
+
+* Use SFINAE on return values
+* Use beast::error_code instead of nested types
+* Tidy up use of GENERATING_DOCS
+* Remove obsolete RFC2616 functions
+* Add message swap members and free functions
+* Add HTTP field value parser containers: ext_list, param_list, token_list
+* Fixes for some corner cases in basic_parser_v1
+* Configurable limits on headers and body sizes in basic_parser_v1
+
+API Changes:
+
+* ci_equal is moved to beast::http namespace, in rfc7230.hpp
+
+* "DynamicBuffer","dynabuf" renamed from "Streambuf", "streambuf". See:
+  http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4478.html#requirements.dynamic_buffers
+
+* basic_parser_v1 adheres to rfc7230 as strictly as possible
+
+--------------------------------------------------------------------------------

src/beast/CMakeLists.txt

@@ -0,0 +1,120 @@
+# Part of Beast
+
+cmake_minimum_required (VERSION 3.2)
+
+project (Beast)
+
+set_property (GLOBAL PROPERTY USE_FOLDERS ON)
+
+if (MSVC)
+    set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4244 /MP /W4 /wd4100 /bigobj /D _WIN32_WINNT=0x0601 /D _SCL_SECURE_NO_WARNINGS=1 /D _CRT_SECURE_NO_WARNINGS=1")
+    set (CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /MTd")
+    set (CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /Ob2 /Oi /Ot /GL /MT")
+    set (CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} /Oi /Ot /MT")
+
+    set (CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /SAFESEH:NO")
+    set (CMAKE_EXE_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS_RELEASE} /LTCG")
+
+    # for RelWithDebInfo builds, disable incremental linking
+    # since CMake sets it ON by default for that build type and it
+    # causes warnings
+    string (REPLACE "/INCREMENTAL" "/INCREMENTAL:NO" replacement_flags
+        ${CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO})
+    set (CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO ${replacement_flags})
+
+else()
+    set(Boost_USE_STATIC_LIBS ON)
+    set(Boost_USE_MULTITHREADED ON)
+    find_package(Boost REQUIRED COMPONENTS coroutine context thread filesystem program_options system)
+    include_directories(SYSTEM ${Boost_INCLUDE_DIRS})
+    link_directories(${Boost_LIBRARY_DIR})
+
+    set(THREADS_PREFER_PTHREAD_FLAG ON)
+    find_package(Threads)
+
+    set(CMAKE_CXX_FLAGS
+      "${CMAKE_CXX_FLAGS} -std=c++11 -Wall -Wextra -Wpedantic -Wno-unused-parameter")
+endif()
+
+add_definitions ("-DBOOST_COROUTINES_NO_DEPRECATION_WARNING")
+
+if (APPLE AND NOT DEFINED ENV{OPENSSL_ROOT_DIR})
+  find_program(HOMEBREW brew)
+  if (NOT HOMEBREW STREQUAL "HOMEBREW-NOTFOUND")
+    execute_process(COMMAND brew --prefix openssl
+      OUTPUT_VARIABLE OPENSSL_ROOT_DIR
+      OUTPUT_STRIP_TRAILING_WHITESPACE)
+  endif()
+endif()
+
+find_package(OpenSSL)
+
+if (MINGW)
+    link_libraries(${Boost_LIBRARIES} ws2_32 mswsock)
+endif()
+
+if ("${VARIANT}" STREQUAL "coverage")
+    set(CMAKE_CXX_FLAGS
+      "${CMAKE_CXX_FLAGS} -fprofile-arcs -ftest-coverage")
+    set(CMAKE_BUILD_TYPE RELWITHDEBINFO)
+    set (CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -lgcov")
+elseif ("${VARIANT}" STREQUAL "asan")
+    set(CMAKE_CXX_FLAGS
+      "${CMAKE_CXX_FLAGS} -fsanitize=address -fno-omit-frame-pointer")
+    set (CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fsanitize=address")
+    set(CMAKE_BUILD_TYPE RELWITHDEBINFO)
+elseif ("${VARIANT}" STREQUAL "usan")
+    set(CMAKE_CXX_FLAGS
+      "${CMAKE_CXX_FLAGS} -fsanitize=undefined -fno-omit-frame-pointer")
+    set (CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fsanitize=undefined")
+    set(CMAKE_BUILD_TYPE RELWITHDEBINFO)
+elseif ("${VARIANT}" STREQUAL "debug")
+    set(CMAKE_BUILD_TYPE DEBUG)
+elseif ("${VARIANT}" STREQUAL "release")
+    set(CMAKE_BUILD_TYPE RELEASE)
+endif()
+
+function(DoGroupSources curdir rootdir folder)
+    file(GLOB children RELATIVE ${PROJECT_SOURCE_DIR}/${curdir} ${PROJECT_SOURCE_DIR}/${curdir}/*)
+    foreach(child ${children})
+        if(IS_DIRECTORY ${PROJECT_SOURCE_DIR}/${curdir}/${child})
+            DoGroupSources(${curdir}/${child} ${rootdir} ${folder})
+        elseif(${child} STREQUAL "CMakeLists.txt")
+            source_group("" FILES ${PROJECT_SOURCE_DIR}/${curdir}/${child})
+        else()
+            string(REGEX REPLACE ^${rootdir} ${folder} groupname ${curdir})
+            string(REPLACE "/" "\\" groupname ${groupname})
+            source_group(${groupname} FILES ${PROJECT_SOURCE_DIR}/${curdir}/${child})
+        endif()
+    endforeach()
+endfunction()
+
+function(GroupSources curdir folder)
+    DoGroupSources(${curdir} ${curdir} ${folder})
+endfunction()
+
+include_directories (extras)
+include_directories (include)
+
+file(GLOB_RECURSE BEAST_INCLUDES
+    ${PROJECT_SOURCE_DIR}/include/beast/*.hpp
+    ${PROJECT_SOURCE_DIR}/include/beast/*.ipp
+)
+
+file(GLOB_RECURSE EXTRAS_INCLUDES
+    ${PROJECT_SOURCE_DIR}/extras/beast/*.hpp
+    ${PROJECT_SOURCE_DIR}/extras/beast/*.ipp
+)
+
+add_subdirectory (examples)
+if (NOT OPENSSL_FOUND)
+    message("OpenSSL not found. Not building examples/ssl")
+else()
+    add_subdirectory (examples/ssl)
+endif()
+
+add_subdirectory (test)
+add_subdirectory (test/core)
+add_subdirectory (test/http)
+add_subdirectory (test/websocket)
+add_subdirectory (test/zlib)

src/beast/Jamroot

@@ -0,0 +1,122 @@
+#
+# Copyright (c) 2013-2016 Vinnie Falco (vinnie dot falco at gmail dot com)
+#
+# Distributed under the Boost Software License, Version 1.0. (See accompanying
+# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#
+
+import os ;
+import feature ;
+import boost ;
+
+boost.use-project ;
+
+if [ os.name ] = SOLARIS
+{
+  lib socket ;
+  lib nsl ;
+}
+else if [ os.name ] = NT
+{
+  lib ws2_32 ;
+  lib mswsock ;
+}
+else if [ os.name ] = HPUX
+{
+  lib ipv6 ;
+}
+else if [ os.name ] = QNXNTO
+{
+  lib socket ;
+}
+else if [ os.name ] = HAIKU
+{
+  lib network ;
+}
+
+if [ os.name ] = NT
+{
+  lib ssl : : <name>ssleay32 ;
+  lib crypto : : <name>libeay32 ;
+}
+else
+{
+  lib ssl ;
+  lib crypto ;
+}
+
+variant coverage
+  :
+    debug
+  :
+    <cxxflags>"-fprofile-arcs -ftest-coverage"
+    <linkflags>"-lgcov"
+  ;
+
+variant asan
+  :
+    release
+  :
+    <cxxflags>"-fsanitize=address -fno-omit-frame-pointer"
+    <linkflags>"-fsanitize=address"
+  ;
+
+variant msan
+  :
+    debug
+  :
+    <cxxflags>"-fsanitize=memory -fno-omit-frame-pointer -fsanitize-memory-track-origins=2 -fsanitize-memory-use-after-dtor"
+    <linkflags>"-fsanitize=memory"
+  ;
+
+variant usan
+  :
+    debug
+  :
+    <cxxflags>"-fsanitize=undefined -fno-omit-frame-pointer"
+    <linkflags>"-fsanitize=undefined"
+  ;
+
+project beast
+  : requirements
+    <include>.
+    <include>./extras
+    <include>./include
+    #<use>/boost//headers
+    <library>/boost/system//boost_system
+    <library>/boost/coroutine//boost_coroutine
+    <library>/boost/filesystem//boost_filesystem
+    <library>/boost/program_options//boost_program_options
+    <define>BOOST_ALL_NO_LIB=1
+    <threading>multi
+    <runtime-link>shared
+    <debug-symbols>on
+    <toolset>gcc:<cxxflags>-std=c++11
+    <toolset>gcc:<cxxflags>-Wno-unused-parameter
+    <toolset>clang:<cxxflags>-std=c++11
+    <toolset>clang:<cxxflags>-Wno-unused-parameter
+    <toolset>gcc:<cxxflags>-Wno-unused-variable   # Temporary until we can figure out -isystem
+    <toolset>clang:<cxxflags>-Wno-unused-variable # Temporary until we can figure out -isystem
+    <toolset>msvc:<define>_SCL_SECURE_NO_WARNINGS=1
+    <toolset>msvc:<define>_CRT_SECURE_NO_WARNINGS=1
+    <toolset>msvc:<cxxflags>"/wd4100 /bigobj"
+    <toolset>msvc,<variant>release:<cxxflags>"/Ob2 /Oi /Ot"
+    <os>LINUX:<define>_XOPEN_SOURCE=600
+    <os>LINUX:<define>_GNU_SOURCE=1
+    <os>SOLARIS:<define>_XOPEN_SOURCE=500
+    <os>SOLARIS:<define>__EXTENSIONS__
+    <os>SOLARIS:<library>socket
+    <os>SOLARIS:<library>nsl
+    <os>NT:<define>_WIN32_WINNT=0x0601
+    <os>NT,<toolset>cw:<library>ws2_32
+    <os>NT,<toolset>cw:<library>mswsock
+    <os>NT,<toolset>gcc:<library>ws2_32
+    <os>NT,<toolset>gcc:<library>mswsock
+    <os>NT,<toolset>gcc-cygwin:<define>__USE_W32_SOCKETS
+  : usage-requirements
+  :
+    build-dir bin
+  ;
+
+build-project test ;
+build-project examples ;

src/beast/README.md

@@ -0,0 +1,231 @@
+<img width="880" height = "80" alt = "Beast"
+    src="https://raw.githubusercontent.com/vinniefalco/Beast/master/doc/images/readme.png">
+
+[![Join the chat at https://gitter.im/vinniefalco/Beast](https://badges.gitter.im/vinniefalco/Beast.svg)](https://gitter.im/vinniefalco/Beast?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge) [![Build Status]
+(https://travis-ci.org/vinniefalco/Beast.svg?branch=master)](https://travis-ci.org/vinniefalco/Beast) [![codecov]
+(https://codecov.io/gh/vinniefalco/Beast/branch/master/graph/badge.svg)](https://codecov.io/gh/vinniefalco/Beast) [![coveralls]
+(https://coveralls.io/repos/github/vinniefalco/Beast/badge.svg?branch=master)](https://coveralls.io/github/vinniefalco/Beast?branch=master) [![Documentation]
+(https://img.shields.io/badge/documentation-master-brightgreen.svg)](http://vinniefalco.github.io/beast/) [![License]
+(https://img.shields.io/badge/license-boost-brightgreen.svg)](LICENSE_1_0.txt)
+
+# HTTP and WebSocket implementations built on Boost.Asio
+
+---
+
+## Beast at CppCon 2016
+
+Presentation
+(slides: <a href="https://raw.githubusercontent.com/vinniefalco/Beast/master/doc/images/CppCon2016.pdf">CppCon2016.pdf</a>)
+
+<a href="https://www.youtube.com/watch?v=uJZgRcvPFwI">
+<img width="320" height = "180" alt = "Beast"
+    src="https://raw.githubusercontent.com/vinniefalco/Beast/master/doc/images/CppCon2016.png">
+</a>
+
+---
+
+## Contents
+
+- [Introduction](#introduction)
+- [Description](#description)
+- [Requirements](#requirements)
+- [Building](#building)
+- [Usage](#usage)
+- [Licence](#licence)
+- [Contact](#contact)
+
+## Introduction
+
+Beast is a header-only, cross-platform C++ library built on Boost.Asio and
+Boost, containing two modules implementing widely used network protocols.
+Beast.HTTP offers a universal model for describing, sending, and receiving
+HTTP messages while Beast.WebSocket provides a complete implementation of
+the WebSocket protocol. Their design achieves these goals:
+
+* **Symmetry.** Interfaces are role-agnostic; the same interfaces can be
+used to build clients, servers, or both.
+
+* **Ease of Use.** HTTP messages are modeled using simple, readily
+accessible objects. Functions and classes used to send and receive HTTP
+or WebSocket messages are designed to resemble Boost.Asio as closely as
+possible. Users familiar with Boost.Asio will be immediately comfortable
+using this library.
+
+* **Flexibility.** Interfaces do not mandate specific implementation
+strategies; important decisions such as buffer or thread management are
+left to users of the library.
+
+* **Performance.** The implementation performs competitively, making it a
+realistic choice for building high performance network servers.
+
+* **Scalability.** Development of network applications that scale to thousands
+of concurrent connections is possible with the implementation.
+
+* **Basis for further abstraction.** The interfaces facilitate the
+development of other libraries that provide higher levels of abstraction.
+
+Beast is used in [rippled](https://github.com/ripple/rippled), an
+open source server application that implements a decentralized
+cryptocurrency system.
+
+## Description
+
+This software is currently in beta: interfaces may change.
+For recent changes see the [CHANGELOG](CHANGELOG.md).
+The library has been submitted to the
+[Boost Library Incubator](http://rrsd.com/blincubator.com/bi_library/beast-2/?gform_post_id=1579)
+
+* [Project Site](http://vinniefalco.github.io/)
+* [Repository](https://github.com/vinniefalco/Beast)
+* [Project Documentation](http://vinniefalco.github.io/beast/)
+* [Autobahn.testsuite results](http://vinniefalco.github.io/autobahn/index.html)
+
+## Requirements
+
+* Boost 1.58 or higher
+* C++11 or greater
+* OpenSSL (optional)
+
+## Building
+
+Beast is header-only so there are no libraries to build or link with.
+To use Beast in your project, simply copy the Beast sources to your
+project's source tree (alternatively, bring Beast into your Git repository
+using the `git subtree` or `git submodule` commands). Then, edit your
+ build scripts to add the `include/` directory to the list of paths checked
+ by the C++ compiler when searching for includes. Beast `#include` lines
+ will look like this:
+```C++
+#include <beast/http.hpp>
+#include <beast/websocket.hpp>
+```
+
+To link your program successfully, you'll need to add the Boost.System
+library to link with. If you use coroutines you'll also need the
+Boost.Coroutine library. Please visit the Boost documentation for
+instructions on how to do this for your particular build system.
+
+For the examples and tests, Beast provides build scripts for Boost.Build (bjam)
+and CMake. Developers using Microsoft Visual Studio can generate Visual Studio
+project files by executing these commands from the root of the repository:
+
+
+```
+cd bin
+cmake ..                                    # for 32-bit Windows build
+
+cd ../bin64
+cmake ..                                    # for Linux/Mac builds, OR
+cmake -G"Visual Studio 14 2015 Win64" ..    # for 64-bit Windows builds
+```
+
+To build with Boost.Build, it is necessary to have the bjam executable
+in your path. And bjam needs to know how to find the Boost sources. The
+easiest way to do this is make sure that the version of bjam in your path
+is the one at the root of the Boost source tree, which is built when
+running `bootstrap.sh` (or `bootstrap.bat` on Windows).
+
+Once bjam is in your path, simply run bjam in the root of the Beast
+repository to automatically build the required Boost libraries if they
+are not already built, build the examples, then build and run the unit
+tests.
+
+The files in the repository are laid out thusly:
+
+```
+./
+    bin/            Holds executables and project files
+    bin64/          Holds 64-bit Windows executables and project files
+    doc/            Source code and scripts for the documentation
+    include/        Add this to your compiler includes
+        beast/
+    extras/         Additional APIs, may change
+    examples/       Self contained example programs
+    test/           Unit tests and benchmarks
+```
+
+
+## Usage
+
+These examples are complete, self-contained programs that you can build
+and run yourself (they are in the `examples` directory).
+
+Example WebSocket program:
+```C++
+#include <beast/core/to_string.hpp>
+#include <beast/websocket.hpp>
+#include <boost/asio.hpp>
+#include <iostream>
+#include <string>
+
+int main()
+{
+    // Normal boost::asio setup
+    std::string const host = "echo.websocket.org";
+    boost::asio::io_service ios;
+    boost::asio::ip::tcp::resolver r{ios};
+    boost::asio::ip::tcp::socket sock{ios};
+    boost::asio::connect(sock,
+        r.resolve(boost::asio::ip::tcp::resolver::query{host, "80"}));
+
+    // WebSocket connect and send message using beast
+    beast::websocket::stream<boost::asio::ip::tcp::socket&> ws{sock};
+    ws.handshake(host, "/");
+    ws.write(boost::asio::buffer(std::string("Hello, world!")));
+
+    // Receive WebSocket message, print and close using beast
+    beast::streambuf sb;
+    beast::websocket::opcode op;
+    ws.read(op, sb);
+    ws.close(beast::websocket::close_code::normal);
+    std::cout << beast::to_string(sb.data()) << "\n";
+}
+```
+
+Example HTTP program:
+```C++
+#include <beast/http.hpp>
+#include <boost/asio.hpp>
+#include <boost/lexical_cast.hpp>
+#include <iostream>
+#include <string>
+
+int main()
+{
+    // Normal boost::asio setup
+    std::string const host = "boost.org";
+    boost::asio::io_service ios;
+    boost::asio::ip::tcp::resolver r{ios};
+    boost::asio::ip::tcp::socket sock{ios};
+    boost::asio::connect(sock,
+        r.resolve(boost::asio::ip::tcp::resolver::query{host, "http"}));
+
+    // Send HTTP request using beast
+    beast::http::request<beast::http::empty_body> req;
+    req.method = "GET";
+    req.url = "/";
+    req.version = 11;
+    req.fields.replace("Host", host + ":" +
+        boost::lexical_cast<std::string>(sock.remote_endpoint().port()));
+    req.fields.replace("User-Agent", "Beast");
+    beast::http::prepare(req);
+    beast::http::write(sock, req);
+
+    // Receive and print HTTP response using beast
+    beast::streambuf sb;
+    beast::http::response<beast::http::streambuf_body> resp;
+    beast::http::read(sock, sb, resp);
+    std::cout << resp;
+}
+```
+
+## License
+
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file [LICENSE_1_0.txt](LICENSE_1_0.txt) or copy at
+http://www.boost.org/LICENSE_1_0.txt)
+
+## Contact
+
+Please report issues or questions here:
+https://github.com/vinniefalco/Beast/issues

src/beast/ReadMe.md

@@ -1,31 +0,0 @@
-# Beast: An amazing cross platform library
-
-Contains cross platform objects to do a variety of useful things.
-No external dependencies, no complicated build steps.
-
-Things people need for building peer to peer, concurrent, cryptographic systems.
-
-The hope is that this will replace the use of boost and other cumbersome jalopies.
-
-## JUCE
-
-Parts of Beast are based on the juce_core module which is provided under the ISC
-license. More information about JUCE is available at
-
-http://www.juce.com
-
-## License
-
-Beast is 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.

src/beast/SConstruct

@@ -1,139 +0,0 @@
-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

@@ -0,0 +1,58 @@
+* Add writer::prepare(msg&) interface to set Content-Type
+
+Boost.Http
+* Use enum instead of bool in isRequest
+
+Docs:
+* Include Example program listings in the docs
+* Fix index in docs
+* melpon sandbox?
+* Implement cleanup-param to remove spaces around template arguments
+  e.g. in basic_streambuf move constructor members
+* Don't put using namespace at file scope in examples,
+  do something like "using ba = boost::asio" instead.
+
+Core:
+* Replace Jamroot with Jamfile
+* Fix bidirectional buffers iterators operator->()
+* Complete allocator testing in basic_streambuf
+
+WebSocket:
+* Minimize sizeof(websocket::stream)
+* Move check for message size limit to account for compression
+* more invokable unit test coverage
+* More control over the HTTP request and response during handshakes
+* optimized versions of key/masking, choose prepared_key size
+* Give callers control over the http request/response used during handshake
+* Investigate poor autobahn results in Debug builds
+* Fall through composed operation switch cases
+* Use close_code::no_code instead of close_code::none
+* Make request_type, response_type public APIs,
+  use in stream member function signatures
+
+HTTP:
+* Define Parser concept in HTTP
+  - Need parse version of read() so caller can set parser options
+    like maximum size of headers, maximum body size, etc
+* add bool should_close(message_v1 const&) to replace the use
+  of eof return value from write and async_write
+* More fine grained parser errors
+* HTTP parser size limit with test (configurable?)
+* HTTP parser trailers with test
+* Decode chunk encoding parameters
+* URL parser, strong URL character checking in HTTP parser
+* Fix prepare() calling content_length() without init()
+* Complete allocator testing in basic_streambuf, basic_headers
+* Custom HTTP error codes for various situations
+* Branch prediction hints in parser
+* Check basic_parser_v1 against rfc7230 for leading message whitespace
+* Fix the order of message constructor parameters:
+  body first then headers (since body is constructed with arguments more often)
+* Unit tests for char tables
+* Remove status_code() from API when isRequest==true, et. al.
+* Permit sending trailers and parameters in chunk-encoding chunks
+
+Future:
+
+* SOCKS proxy client and server implementations
+

src/beast/beast/Arithmetic.h

@@ -1,106 +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_ARITHMETIC_H_INCLUDED
-#define BEAST_ARITHMETIC_H_INCLUDED
-
-#include <beast/Config.h>
-
-#include <cmath>
-#include <cstdint>
-#include <algorithm>
-
-namespace beast {
-
-//==============================================================================
-/** Constrains a value to keep it within a given range.
-
-    This will check that the specified value lies between the lower and upper bounds
-    specified, and if not, will return the nearest value that would be in-range. Effectively,
-    it's like calling bmax (lowerLimit, bmin (upperLimit, value)).
-
-    Note that it expects that lowerLimit <= upperLimit. If this isn't true,
-    the results will be unpredictable.
-
-    @param lowerLimit           the minimum value to return
-    @param upperLimit           the maximum value to return
-    @param valueToConstrain     the value to try to return
-    @returns    the closest value to valueToConstrain which lies between lowerLimit
-                and upperLimit (inclusive)
-    @see blimit0To, bmin, bmax
-*/
-template <typename Type>
-inline Type blimit (const Type lowerLimit,
-                    const Type upperLimit,
-                    const Type valueToConstrain) noexcept
-{
-    // if these are in the wrong order, results are unpredictable.
-    bassert (lowerLimit <= upperLimit);
-
-    return (valueToConstrain < lowerLimit) ? lowerLimit
-                                           : ((upperLimit < valueToConstrain) ? upperLimit
-                                                                              : valueToConstrain);
-}
-
-/** Returns true if a value is at least zero, and also below a specified upper limit.
-    This is basically a quicker way to write:
-    @code valueToTest >= 0 && valueToTest < upperLimit
-    @endcode
-*/
-template <typename Type>
-inline bool isPositiveAndBelow (Type valueToTest, Type upperLimit) noexcept
-{
-    bassert (Type() <= upperLimit); // makes no sense to call this if the upper limit is itself below zero..
-    return Type() <= valueToTest && valueToTest < upperLimit;
-}
-
-template <>
-inline bool isPositiveAndBelow (const int valueToTest, const int upperLimit) noexcept
-{
-    bassert (upperLimit >= 0); // makes no sense to call this if the upper limit is itself below zero..
-    return static_cast <unsigned int> (valueToTest) < static_cast <unsigned int> (upperLimit);
-}
-
-
-//==============================================================================
-
-/** Handy function for getting the number of elements in a simple const C array.
-    E.g.
-    @code
-    static int myArray[] = { 1, 2, 3 };
-
-    int numElements = numElementsInArray (myArray) // returns 3
-    @endcode
-*/
-template <typename Type, int N>
-int numElementsInArray (Type (&array)[N])
-{
-    (void) array; // (required to avoid a spurious warning in MS compilers)
-    (void) sizeof (0[array]); // This line should cause an error if you pass an object with a user-defined subscript operator
-    return N;
-}
-
-}
-
-#endif
-

src/beast/beast/Config.h

@@ -1,60 +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_CONFIG_H_INCLUDED
-#define BEAST_CONFIG_H_INCLUDED
-
-// VFALCO NOTE this is analogous to <boost/config.hpp>
-
-#if !defined(BEAST_COMPILER_CONFIG) && !defined(BEAST_NO_COMPILER_CONFIG) && !defined(BEAST_NO_CONFIG)
-#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 <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 <beast/config/SelectCompilerConfig.h>
-#endif
-#ifdef   BEAST_PLATFORM_CONFIG
-#include BEAST_PLATFORM_CONFIG
-#endif
-
-// Legacy
-#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 <beast/config/Suffix.h>
-
-#endif

src/beast/beast/HeapBlock.h

@@ -1,360 +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_HEAPBLOCK_H_INCLUDED
-#define BEAST_HEAPBLOCK_H_INCLUDED
-
-#include <cstddef>
-#include <cstdlib>
-#include <stdexcept>
-
-#include <beast/Memory.h>
-
-// If the MSVC debug heap headers were included, disable
-// the macros during the juce include since they conflict.
-#ifdef _CRTDBG_MAP_ALLOC
-#pragma push_macro("calloc")
-#pragma push_macro("free")
-#pragma push_macro("malloc")
-#pragma push_macro("realloc")
-#pragma push_macro("_recalloc")
-#pragma push_macro("_aligned_free")
-#pragma push_macro("_aligned_malloc")
-#pragma push_macro("_aligned_offset_malloc")
-#pragma push_macro("_aligned_realloc")
-#pragma push_macro("_aligned_recalloc")
-#pragma push_macro("_aligned_offset_realloc")
-#pragma push_macro("_aligned_offset_recalloc")
-#pragma push_macro("_aligned_msize")
-#undef calloc
-#undef free
-#undef malloc
-#undef realloc
-#undef _recalloc
-#undef _aligned_free
-#undef _aligned_malloc
-#undef _aligned_offset_malloc
-#undef _aligned_realloc
-#undef _aligned_recalloc
-#undef _aligned_offset_realloc
-#undef _aligned_offset_recalloc
-#undef _aligned_msize
-#endif
-
-namespace beast {
-
-#ifndef DOXYGEN
-namespace HeapBlockHelper
-{
-    template <bool shouldThrow>
-    struct ThrowOnFail          { static void check (void*) {} };
-
-    template<>
-    struct ThrowOnFail <true>   { static void check (void* data) { if (data == nullptr) throw std::bad_alloc(); } };
-}
-#endif
-
-//==============================================================================
-/**
-    Very simple container class to hold a pointer to some data on the heap.
-
-    When you need to allocate some heap storage for something, always try to use
-    this class instead of allocating the memory directly using malloc/free.
-
-    A HeapBlock<char> object can be treated in pretty much exactly the same way
-    as an char*, but as long as you allocate it on the stack or as a class member,
-    it's almost impossible for it to leak memory.
-
-    It also makes your code much more concise and readable than doing the same thing
-    using direct allocations,
-
-    E.g. instead of this:
-    @code
-        int* temp = (int*) malloc (1024 * sizeof (int));
-        memcpy (temp, xyz, 1024 * sizeof (int));
-        free (temp);
-        temp = (int*) calloc (2048 * sizeof (int));
-        temp[0] = 1234;
-        memcpy (foobar, temp, 2048 * sizeof (int));
-        free (temp);
-    @endcode
-
-    ..you could just write this:
-    @code
-        HeapBlock <int> temp (1024);
-        memcpy (temp, xyz, 1024 * sizeof (int));
-        temp.calloc (2048);
-        temp[0] = 1234;
-        memcpy (foobar, temp, 2048 * sizeof (int));
-    @endcode
-
-    The class is extremely lightweight, containing only a pointer to the
-    data, and exposes malloc/realloc/calloc/free methods that do the same jobs
-    as their less object-oriented counterparts. Despite adding safety, you probably
-    won't sacrifice any performance by using this in place of normal pointers.
-
-    The throwOnFailure template parameter can be set to true if you'd like the class
-    to throw a std::bad_alloc exception when an allocation fails. If this is false,
-    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, MemoryBlock
-*/
-template <class ElementType, bool throwOnFailure = false>
-class HeapBlock
-{
-public:
-    //==============================================================================
-    /** Creates a HeapBlock which is initially just a null pointer.
-
-        After creation, you can resize the array using the malloc(), calloc(),
-        or realloc() methods.
-    */
-    HeapBlock() noexcept
-        : data (nullptr)
-    {
-    }
-
-    /** Creates a HeapBlock containing a number of elements.
-
-        The contents of the block are undefined, as it will have been created by a
-        malloc call.
-
-        If you want an array of zero values, you can use the calloc() method or the
-        other constructor that takes an InitialisationState parameter.
-    */
-    explicit HeapBlock (const size_t numElements)
-        : data (static_cast <ElementType*> (std::malloc (numElements * sizeof (ElementType))))
-    {
-        throwOnAllocationFailure();
-    }
-
-    /** Creates a HeapBlock containing a number of elements.
-
-        The initialiseToZero parameter determines whether the new memory should be cleared,
-        or left uninitialised.
-    */
-    HeapBlock (const size_t numElements, const bool initialiseToZero)
-        : data (static_cast <ElementType*> (initialiseToZero
-                                               ? std::calloc (numElements, sizeof (ElementType))
-                                               : std::malloc (numElements * sizeof (ElementType))))
-    {
-        throwOnAllocationFailure();
-    }
-
-
-    HeapBlock(HeapBlock const&) = delete;
-    HeapBlock& operator= (HeapBlock const&) = delete;
-
-    /** Destructor.
-        This will free the data, if any has been allocated.
-    */
-    ~HeapBlock()
-    {
-        std::free (data);
-    }
-
-   #if BEAST_COMPILER_SUPPORTS_MOVE_SEMANTICS
-    HeapBlock (HeapBlock&& other) noexcept
-        : data (other.data)
-    {
-        other.data = nullptr;
-    }
-
-    HeapBlock& operator= (HeapBlock&& other) noexcept
-    {
-        std::swap (data, other.data);
-        return *this;
-    }
-   #endif
-
-    //==============================================================================
-    /** Returns a raw pointer to the allocated data.
-        This may be a null pointer if the data hasn't yet been allocated, or if it has been
-        freed by calling the free() method.
-    */
-    inline operator ElementType*() const noexcept                           { return data; }
-
-    /** Returns a raw pointer to the allocated data.
-        This may be a null pointer if the data hasn't yet been allocated, or if it has been
-        freed by calling the free() method.
-    */
-    inline ElementType* getData() const noexcept                            { return data; }
-
-    /** Returns a void pointer to the allocated data.
-        This may be a null pointer if the data hasn't yet been allocated, or if it has been
-        freed by calling the free() method.
-    */
-    inline operator void*() const noexcept                                  { return static_cast <void*> (data); }
-
-    /** Returns a void pointer to the allocated data.
-        This may be a null pointer if the data hasn't yet been allocated, or if it has been
-        freed by calling the free() method.
-    */
-    inline operator const void*() const noexcept                            { return static_cast <const void*> (data); }
-
-    /** Lets you use indirect calls to the first element in the array.
-        Obviously this will cause problems if the array hasn't been initialised, because it'll
-        be referencing a null pointer.
-    */
-    inline ElementType* operator->() const  noexcept                        { return data; }
-
-    /** Returns a reference to one of the data elements.
-        Obviously there's no bounds-checking here, as this object is just a dumb pointer and
-        has no idea of the size it currently has allocated.
-    */
-    template <typename IndexType>
-    inline ElementType& operator[] (IndexType index) const noexcept         { return data [index]; }
-
-    /** Returns a pointer to a data element at an offset from the start of the array.
-        This is the same as doing pointer arithmetic on the raw pointer itself.
-    */
-    template <typename IndexType>
-    inline ElementType* operator+ (IndexType index) const noexcept          { return data + index; }
-
-    //==============================================================================
-    /** Compares the pointer with another pointer.
-        This can be handy for checking whether this is a null pointer.
-    */
-    inline bool operator== (const ElementType* const otherPointer) const noexcept   { return otherPointer == data; }
-
-    /** Compares the pointer with another pointer.
-        This can be handy for checking whether this is a null pointer.
-    */
-    inline bool operator!= (const ElementType* const otherPointer) const noexcept   { return otherPointer != data; }
-
-    //==============================================================================
-    /** Allocates a specified amount of memory.
-
-        This uses the normal malloc to allocate an amount of memory for this object.
-        Any previously allocated memory will be freed by this method.
-
-        The number of bytes allocated will be (newNumElements * elementSize). Normally
-        you wouldn't need to specify the second parameter, but it can be handy if you need
-        to allocate a size in bytes rather than in terms of the number of elements.
-
-        The data that is allocated will be freed when this object is deleted, or when you
-        call free() or any of the allocation methods.
-    */
-    void malloc (const size_t newNumElements, const size_t elementSize = sizeof (ElementType))
-    {
-        std::free (data);
-        data = static_cast <ElementType*> (std::malloc (newNumElements * elementSize));
-        throwOnAllocationFailure();
-    }
-
-    /** Allocates a specified amount of memory and clears it.
-        This does the same job as the malloc() method, but clears the memory that it allocates.
-    */
-    void calloc (const size_t newNumElements, const size_t elementSize = sizeof (ElementType))
-    {
-        std::free (data);
-        data = static_cast <ElementType*> (std::calloc (newNumElements, elementSize));
-        throwOnAllocationFailure();
-    }
-
-    /** Allocates a specified amount of memory and optionally clears it.
-        This does the same job as either malloc() or calloc(), depending on the
-        initialiseToZero parameter.
-    */
-    void allocate (const size_t newNumElements, bool initialiseToZero)
-    {
-        std::free (data);
-        data = static_cast <ElementType*> (initialiseToZero
-                                             ? std::calloc (newNumElements, sizeof (ElementType))
-                                             : std::malloc (newNumElements * sizeof (ElementType)));
-        throwOnAllocationFailure();
-    }
-
-    /** Re-allocates a specified amount of memory.
-
-        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 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));
-        throwOnAllocationFailure();
-    }
-
-    /** Frees any currently-allocated data.
-        This will free the data and reset this object to be a null pointer.
-    */
-    void free_up()
-    {
-        std::free (data);
-        data = nullptr;
-    }
-
-    /** Swaps this object's data with the data of another HeapBlock.
-        The two objects simply exchange their data pointers.
-    */
-    template <bool otherBlockThrows>
-    void swapWith (HeapBlock <ElementType, otherBlockThrows>& other) noexcept
-    {
-        std::swap (data, other.data);
-    }
-
-    /** This fills the block with zeros, up to the number of elements specified.
-        Since the block has no way of knowing its own size, you must make sure that the number of
-        elements you specify doesn't exceed the allocated size.
-    */
-    void clear (size_t numElements) noexcept
-    {
-        zeromem (data, sizeof (ElementType) * numElements);
-    }
-
-    /** This type alias can be used to get the type of the heapblock's elements. */
-    using Type = ElementType;
-
-private:
-    //==============================================================================
-    ElementType* data;
-
-    void throwOnAllocationFailure() const
-    {
-        HeapBlockHelper::ThrowOnFail<throwOnFailure>::check (data);
-    }
-};
-
-}
-
-#ifdef _CRTDBG_MAP_ALLOC
-#pragma pop_macro("_aligned_msize")
-#pragma pop_macro("_aligned_offset_recalloc")
-#pragma pop_macro("_aligned_offset_realloc")
-#pragma pop_macro("_aligned_recalloc")
-#pragma pop_macro("_aligned_realloc")
-#pragma pop_macro("_aligned_offset_malloc")
-#pragma pop_macro("_aligned_malloc")
-#pragma pop_macro("_aligned_free")
-#pragma pop_macro("_recalloc")
-#pragma pop_macro("realloc")
-#pragma pop_macro("malloc")
-#pragma pop_macro("free")
-#pragma pop_macro("calloc")
-#endif
-
-#endif
-

src/beast/beast/Strings.h

@@ -1,27 +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_STRINGS_H_INCLUDED
-#define BEAST_STRINGS_H_INCLUDED
-
-#include <beast/strings/String.h>
-#include <beast/strings/NewLine.h>
-
-#endif
-

src/beast/beast/Threads.h

@@ -1,35 +0,0 @@
-//------------------------------------------------------------------------------
-/*
-    This file is part of Beast: https://github.com/vinniefalco/Beast
-    Copyright 2013, Vinnie Falco <vinnie.falco@gmail.com>
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose  with  or without fee is hereby granted, provided that the above
-    copyright notice and this permission notice appear in all copies.
-
-    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
-    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
-    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-*/
-//==============================================================================
-
-#ifndef BEAST_THREADS_H_INCLUDED
-#define BEAST_THREADS_H_INCLUDED
-
-#include <beast/threads/UnlockGuard.h>
-#include <beast/threads/TryLockGuard.h>
-#include <beast/threads/SharedLockGuard.h>
-#include <beast/threads/SharedMutexAdapter.h>
-#include <beast/threads/SpinLock.h>
-#include <beast/threads/Stoppable.h>
-#include <beast/threads/Thread.h>
-#include <beast/threads/WaitableEvent.h>
-#include <beast/threads/ScopedWrapperContext.h>
-
-#include <beast/threads/semaphore.h>
-
-#endif

src/beast/beast/Version.h

@@ -1,45 +0,0 @@
-//------------------------------------------------------------------------------
-/*
-    This file is part of Beast: https://github.com/vinniefalco/Beast
-    Copyright 2013, Vinnie Falco <vinnie.falco@gmail.com>
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose  with  or without fee is hereby granted, provided that the above
-    copyright notice and this permission notice appear in all copies.
-
-    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
-    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
-    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-*/
-//==============================================================================
-
-#ifndef BEAST_VERSION_H_INCLUDED
-#define BEAST_VERSION_H_INCLUDED
-
-#include <string>
-
-/** Current BEAST version number. */
-unsigned int const BEAST_VERSION_MAJOR = 1;
-unsigned int const BEAST_VERSION_MINOR = 0;
-unsigned int const BEAST_VERSION_BUILD = 0;
-
-unsigned int const BEAST_VERSION =
-    (BEAST_VERSION_MAJOR << 16) +
-    (BEAST_VERSION_MINOR << 8) +
-    BEAST_VERSION_BUILD;
-
-inline
-std::string
-getBeastVersion()
-{
-    return "Beast v" + std::to_string (BEAST_VERSION_MAJOR) +
-                 "." + std::to_string (BEAST_VERSION_MINOR) +
-                 "." + std::to_string (BEAST_VERSION_BUILD);
-}
-
-#endif
-

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

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

src/beast/beast/asio/README.md

@@ -1,14 +0,0 @@
-# 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/bind_handler.h

@@ -1,164 +0,0 @@
-//------------------------------------------------------------------------------
-/*
-    This file is part of Beast: https://github.com/vinniefalco/Beast
-    Copyright 2013, Vinnie Falco <vinnie.falco@gmail.com>
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose  with  or without fee is hereby granted, provided that the above
-    copyright notice and this permission notice appear in all copies.
-
-    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
-    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
-    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-*/
-//==============================================================================
-
-#ifndef BEAST_ASIO_BIND_HANDLER_H_INCLUDED
-#define BEAST_ASIO_BIND_HANDLER_H_INCLUDED
-
-#include <boost/asio/detail/handler_alloc_helpers.hpp>
-#include <boost/asio/detail/handler_cont_helpers.hpp>
-#include <boost/asio/detail/handler_invoke_helpers.hpp>
-
-#include <functional>
-#include <type_traits>
-#include <utility>
-
-namespace beast {
-namespace asio {
-
-namespace detail {
-
-/** Nullary handler that calls Handler with bound arguments.
-    The rebound handler provides the same io_service execution
-    guarantees as the original handler.
-*/
-template <class DeducedHandler, class... Args>
-class bound_handler
-{
-private:
-    using args_type = std::tuple <std::decay_t <Args>...>;
-
-    std::decay_t <DeducedHandler> m_handler;
-    args_type m_args;
-
-    template <class Handler, class Tuple, std::size_t... S>
-    static void invoke (Handler& h, Tuple& args,
-        std::index_sequence <S...>)
-    {
-        h (std::get <S> (args)...);
-    }
-
-public:
-    using result_type = void;
-
-    explicit
-    bound_handler (DeducedHandler&& handler, Args&&... args)
-        : m_handler (std::forward <DeducedHandler> (handler))
-        , m_args (std::forward <Args> (args)...)
-    {
-    }
-
-    void
-    operator() ()
-    {
-        invoke (m_handler, m_args,
-            std::index_sequence_for <Args...> ());
-    }
-
-    void
-    operator() () const
-    {
-        invoke (m_handler, m_args,
-            std::index_sequence_for <Args...> ());
-    }
-
-    template <class Function>
-    friend
-    void
-    asio_handler_invoke (Function& f, bound_handler* h)
-    {
-        boost_asio_handler_invoke_helpers::
-            invoke (f, h->m_handler);
-    }
-
-    template <class Function>
-    friend
-    void
-    asio_handler_invoke (Function const& f, bound_handler* h)
-    {
-        boost_asio_handler_invoke_helpers::
-            invoke (f, h->m_handler);
-    }
-
-    friend
-    void*
-    asio_handler_allocate (std::size_t size, bound_handler* h)
-    {
-        return boost_asio_handler_alloc_helpers::
-            allocate (size, h->m_handler);
-    }
-
-    friend
-    void
-    asio_handler_deallocate (void* p, std::size_t size, bound_handler* h)
-    {
-        boost_asio_handler_alloc_helpers::
-            deallocate (p, size, h->m_handler);
-    }
-
-    friend
-    bool
-    asio_handler_is_continuation (bound_handler* h)
-    {
-        return boost_asio_handler_cont_helpers::
-            is_continuation (h->m_handler);
-    }
-};
-
-}
-
-//------------------------------------------------------------------------------
-
-/** Binds parameters to a handler to produce a nullary functor.
-    The returned handler provides the same io_service execution guarantees
-    as the original handler. This is designed to use as a replacement for
-    io_service::wrap, to ensure that the handler will not be invoked
-    immediately by the calling function.
-*/
-template <class DeducedHandler, class... Args>
-detail::bound_handler <DeducedHandler, Args...>
-bind_handler (DeducedHandler&& handler, Args&&... args)
-{
-    return detail::bound_handler <DeducedHandler, Args...> (
-        std::forward <DeducedHandler> (handler),
-            std::forward <Args> (args)...);
-}
-
-}
-}
-
-//------------------------------------------------------------------------------
-
-namespace std {
-
-template <class Handler, class... Args>
-void bind (beast::asio::detail::bound_handler <
-    Handler, Args...>, ...)  = delete;
-
-#if 0
-template <class Handler, class... Args>
-struct is_bind_expression <
-    beast::asio::detail::bound_handler <Handler, Args...>
-> : std::true_type
-{
-};
-#endif
-
-}
-
-#endif

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

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

src/beast/beast/asio/placeholders.h

@@ -1,41 +0,0 @@
-//------------------------------------------------------------------------------
-/*
-    This file is part of Beast: https://github.com/vinniefalco/Beast
-    Copyright 2013, Vinnie Falco <vinnie.falco@gmail.com>
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose  with  or without fee is hereby granted, provided that the above
-    copyright notice and this permission notice appear in all copies.
-
-    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
-    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
-    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-*/
-//==============================================================================
-
-#ifndef BEAST_ASIO_PLACEHOLDERS_H_INCLUDED
-#define BEAST_ASIO_PLACEHOLDERS_H_INCLUDED
-
-#include <functional>
-
-namespace beast {
-namespace asio {
-
-namespace placeholders {
-// asio placeholders that work with std::bind
-namespace {
-static auto const error (std::placeholders::_1);
-static auto const bytes_transferred (std::placeholders::_2);
-static auto const iterator (std::placeholders::_2);
-static auto const signal_number (std::placeholders::_2);
-}
-}
-
-}
-}
-
-#endif

src/beast/beast/asio/streambuf.h

@@ -1,679 +0,0 @@
-//------------------------------------------------------------------------------
-/*
-    This file is part of Beast: https://github.com/vinniefalco/Beast
-    Copyright 2013, Vinnie Falco <vinnie.falco@gmail.com>
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose  with  or without fee is hereby granted, provided that the above
-    copyright notice and this permission notice appear in all copies.
-
-    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
-    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
-    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-*/
-//==============================================================================
-
-#ifndef BEAST_ASIO_STREAMBUF_H_INCLUDED
-#define BEAST_ASIO_STREAMBUF_H_INCLUDED
-
-#include <beast/utility/empty_base_optimization.h>
-#include <boost/asio/buffer.hpp>
-#include <boost/intrusive/list.hpp>
-#include <boost/iterator/transform_iterator.hpp>
-#include <algorithm>
-#include <cassert>
-#include <memory>
-#include <exception>
-#include <type_traits>
-#include <string>
-#include <utility>
-
-namespace beast {
-namespace asio {
-
-/** Implements asio::streambuf interface using multiple buffers. */
-template <class Allocator>
-class basic_streambuf
-    : private empty_base_optimization<Allocator>
-{
-public:
-    using size_type = typename std::allocator_traits<Allocator>::size_type;
-    using const_buffer = boost::asio::const_buffer;
-    using mutable_buffer = boost::asio::mutable_buffer;
-
-private:
-    class element;
-
-    using alloc_traits = std::allocator_traits<Allocator>;
-    using list_type = typename boost::intrusive::make_list <element,
-        boost::intrusive::constant_time_size <true>>::type;
-    using iterator = typename list_type::iterator;
-    using const_iterator = typename list_type::const_iterator;
-
-    /*  These diagrams illustrate the layout and state variables.
-
-        Input and output contained entirely in one element:
-
-        0                            out_
-        |<-------------+------------------------------------------->|
-      in_pos_       out_pos_                                     out_end_
-
-
-        Output contained in first and second elements:
-
-                     out_
-        |<------+----------+------->|   |<----------+-------------->|
-              in_pos_   out_pos_                 out_end_
-
-
-        Output contained in the second element:
-
-                                                     out_
-        |<------------+------------>|   |<----+-------------------->|
-                    in_pos_                out_pos_              out_end_
-
-
-        Output contained in second and third elements:
-
-                                     out_
-        |<-----+-------->|   |<-------+------>|   |<--------------->|
-             in_pos_               out_pos_                      out_end_
-
-
-        Input sequence is empty:
-
-                     out_
-        |<------+------------------>|   |<-----------+------------->|
-             out_pos_                             out_end_
-              in_pos_
-
-
-        Output sequence is empty:
-
-                                                     out_
-        |<------+------------------>|   |<------+------------------>|
-              in_pos_                        out_pos_
-                                             out_end_
-
-
-        The end of output can point to the end of an element.
-        But out_pos_ should never point to the end:
-
-                                                     out_
-        |<------+------------------>|   |<------+------------------>|
-              in_pos_                        out_pos_            out_end_
-
-
-        When the input sequence entirely fills the last element and
-        the output sequence is empty, out_ will point to the end of
-        the list of buffers, and out_pos_ and out_end_ will be 0:
-
-
-        |<------+------------------>|   out_     == list_.end()
-              in_pos_                   out_pos_ == 0
-                                        out_end_ == 0
-    */
-
-    list_type list_;
-    size_type block_size_;
-    size_type block_size_next_;
-    size_type in_size_ = 0; // size of the input sequence
-    iterator out_;          // element that contains out_pos_
-    size_type in_pos_ = 0;  // input offset in list_.front()
-    size_type out_pos_ = 0; // output offset in *out_
-    size_type out_end_ = 0; // output end offset in list_.back()
-
-public:
-    class const_buffers_type;
-    class mutable_buffers_type;
-
-    basic_streambuf (basic_streambuf const& other) = delete;
-    basic_streambuf& operator= (basic_streambuf const& other) = delete;
-    basic_streambuf& operator= (basic_streambuf&& other) = delete;
-
-    ~basic_streambuf();
-
-    explicit
-    basic_streambuf(std::size_t block_size = 16*1024,
-        Allocator const& alloc = Allocator{});
-
-    basic_streambuf (basic_streambuf&& other);
-
-    /** Get the maximum size of the basic_streambuf. */
-    size_type
-    max_size() const
-    {
-        return std::numeric_limits<std::size_t>::max();
-    }
-
-    /** Get the size of the input sequence. */
-    size_type
-    size() const
-    {
-        return in_size_;
-    }
-
-    /** Get a list of buffers that represents the output sequence, with the given size. */
-    mutable_buffers_type
-    prepare (size_type n);
-
-    /** Move bytes from the output sequence to the input sequence. */
-    void
-    commit (size_type n);
-
-    /** Get a list of buffers that represents the input sequence. */
-    const_buffers_type
-    data() const;
-
-    /** Remove bytes from the input sequence. */
-    void
-    consume (size_type n);
-
-private:
-    void
-    debug_check() const;
-};
-
-//------------------------------------------------------------------------------
-
-template <class Allocator>
-class basic_streambuf<Allocator>::element
-    : public boost::intrusive::list_base_hook <
-        boost::intrusive::link_mode <boost::intrusive::normal_link>>
-{
-private:
-    size_type const size_;  // size of the allocation minus sizeof(element)
-
-public:
-    element (element const&) = delete;
-    element& operator= (element const&) = delete;
-
-    explicit
-    element (size_type block_size)
-        : size_(block_size)
-        { }
-
-    size_type
-    size() const
-    {
-        return size_;
-    }
-
-    size_type
-    alloc_size() const
-    {
-        return size_ + sizeof(*this);
-    }
-
-    char*
-    data() const
-    {
-        return const_cast<char*>(
-            reinterpret_cast<char const*>(this+1));
-    }
-};
-
-//------------------------------------------------------------------------------
-
-template <class Allocator>
-class basic_streambuf<Allocator>::const_buffers_type
-{
-public:
-    using value_type = const_buffer;
-
-private:
-    struct transform
-    {
-        using argument_type = element;
-        using result_type = value_type;
-
-        basic_streambuf const* streambuf_ = nullptr;
-
-        transform() = default;
-
-        explicit
-        transform (basic_streambuf const& streambuf)
-            : streambuf_ (&streambuf)
-        {
-        }
-
-        value_type const
-        operator() (element const& e) const;
-    };
-
-    basic_streambuf const* streambuf_ = nullptr;
-
-public:
-    using const_iterator = boost::transform_iterator<
-        transform, typename list_type::const_iterator,
-            value_type, value_type>;
-
-    const_buffers_type() = default;
-    const_buffers_type (const_buffers_type const&) = default;
-    const_buffers_type& operator= (const_buffers_type const&) = default;
-
-    const_iterator
-    begin() const
-    {
-        return const_iterator (streambuf_->list_.begin(),
-            transform(*streambuf_));
-    }
-
-    const_iterator
-    end() const
-    {
-        return const_iterator (streambuf_->out_ ==
-            streambuf_->list_.end() ? streambuf_->list_.end() :
-                std::next(streambuf_->out_), transform(*streambuf_));
-    }
-
-private:
-    friend class basic_streambuf;
-
-    explicit
-    const_buffers_type (basic_streambuf const& streambuf);
-};
-
-template <class Allocator>
-basic_streambuf<Allocator>::const_buffers_type::const_buffers_type (
-    basic_streambuf const& streambuf)
-    : streambuf_ (&streambuf)
-{
-}
-
-template <class Allocator>
-auto
-basic_streambuf<Allocator>::const_buffers_type::
-    transform::operator() (element const& e) const ->
-        value_type const
-{
-    return value_type (e.data(),
-        (streambuf_->out_ == streambuf_->list_.end() ||
-            &e != &*streambuf_->out_) ? e.size() : streambuf_->out_pos_) +
-                (&e == &*streambuf_->list_.begin() ?
-                    streambuf_->in_pos_ : 0);
-}
-
-//------------------------------------------------------------------------------
-
-template <class Allocator>
-class basic_streambuf<Allocator>::mutable_buffers_type
-{
-public:
-    using value_type = mutable_buffer;
-
-private:
-    struct transform
-    {
-        using argument_type = element;
-        using result_type = value_type;
-
-        basic_streambuf const* streambuf_ = nullptr;
-
-        transform() = default;
-
-        explicit
-        transform (basic_streambuf const& streambuf)
-            : streambuf_ (&streambuf)
-        {
-        }
-
-        value_type const
-        operator() (element const& e) const;
-    };
-
-    basic_streambuf const* streambuf_;
-
-public:
-    using const_iterator = boost::transform_iterator<
-        transform, typename list_type::const_iterator,
-            value_type, value_type>;
-
-    mutable_buffers_type() = default;
-    mutable_buffers_type (mutable_buffers_type const&) = default;
-    mutable_buffers_type& operator= (mutable_buffers_type const&) = default;
-
-    const_iterator
-    begin() const
-    {
-        return const_iterator (streambuf_->out_,
-            transform(*streambuf_));
-    }
-
-    const_iterator
-    end() const
-    {
-        return const_iterator (streambuf_->list_.end(),
-            transform(*streambuf_));
-    }
-
-private:
-    friend class basic_streambuf;
-    mutable_buffers_type (basic_streambuf const& streambuf);
-};
-
-template <class Allocator>
-basic_streambuf<Allocator>::mutable_buffers_type::mutable_buffers_type (
-    basic_streambuf const& streambuf)
-    : streambuf_ (&streambuf)
-{
-}
-
-template <class Allocator>
-auto
-basic_streambuf<Allocator>::mutable_buffers_type::
-    transform::operator() (element const& e) const ->
-        value_type const
-{
-    return value_type (e.data(), &e == &*std::prev(streambuf_->list_.end()) ?
-        streambuf_->out_end_ : e.size()) + (&e == &*streambuf_->out_ ?
-            streambuf_->out_pos_ : 0);
-}
-
-//------------------------------------------------------------------------------
-
-template <class Allocator>
-basic_streambuf<Allocator>::~basic_streambuf()
-{
-    for(auto iter = list_.begin(); iter != list_.end();)
-    {
-        auto& e = *iter++;
-        size_type const n = e.alloc_size();
-        alloc_traits::destroy(this->member(), &e);
-        alloc_traits::deallocate(this->member(),
-            reinterpret_cast<char*>(&e), n);
-    }
-}
-
-template <class Allocator>
-basic_streambuf<Allocator>::basic_streambuf(std::size_t block_size,
-        Allocator const& alloc)
-    : empty_base_optimization<Allocator>(alloc)
-    , block_size_ (block_size)
-    , block_size_next_ (block_size)
-    , out_ (list_.end())
-{
-    if (! (block_size > 0))
-        throw std::invalid_argument(
-            "basic_streambuf: invalid block_size");
-}
-
-template <class Allocator>
-basic_streambuf<Allocator>::basic_streambuf (basic_streambuf&& other)
-    : empty_base_optimization<Allocator>(other.member())
-    , list_ (std::move(other.list_))
-    , block_size_ (other.block_size_)
-    , block_size_next_ (other.block_size_next_)
-    , in_size_ (other.in_size_)
-    , out_ (other.out_)
-    , in_pos_ (other.in_pos_)
-    , out_pos_ (other.out_pos_)
-    , out_end_ (other.out_end_)
-{
-    other.in_size_ = 0;
-    other.out_ = other.list_.end();
-    other.in_pos_ = 0;
-    other.out_pos_ = 0;
-    other.out_end_ = 0;
-}
-
-template <class Allocator>
-auto
-basic_streambuf<Allocator>::prepare (size_type n) ->
-    mutable_buffers_type
-{
-    iterator pos = out_;
-    if (pos != list_.end())
-    {
-        auto const avail = pos->size() - out_pos_;
-        if (n > avail)
-        {
-            n -= avail;
-            while (++pos != list_.end())
-            {
-                if (n < pos->size())
-                {
-                    out_end_ = n;
-                    n = 0;
-                    ++pos;
-                    break;
-                }
-                n -= pos->size();
-            }
-        }
-        else
-        {
-            ++pos;
-            out_end_ = out_pos_ + n;
-            n = 0;
-        }
-        debug_check();
-    }
-
-    if (n > 0)
-    {
-        assert(pos == list_.end());
-        for(;;)
-        {
-            auto const avail = block_size_next_;
-            auto& e = *reinterpret_cast<element*>(alloc_traits::allocate(
-                this->member(), avail + sizeof(element)));
-            alloc_traits::construct(this->member(), &e, avail);
-            list_.push_back(e);
-            if (out_ == list_.end())
-            {
-                out_ = list_.iterator_to(e);
-                debug_check();
-            }
-            if (n <= avail)
-            {
-                out_end_ = n;
-                debug_check();
-                break;
-            }
-            n -= avail;
-        }
-    }
-    else
-    {
-        while (pos != list_.end())
-        {
-            auto& e = *pos++;
-            list_.erase(list_.iterator_to(e));
-            auto const len = e.alloc_size();
-            alloc_traits::destroy(this->member(), &e);
-            alloc_traits::deallocate(this->member(),
-                reinterpret_cast<char*>(&e), len);
-        }
-        debug_check();
-    }
-
-    return mutable_buffers_type (*this);
-}
-
-template <class Allocator>
-void
-basic_streambuf<Allocator>::commit (size_type n)
-{
-    if (list_.empty())
-        return;
-    if (out_ == list_.end())
-        return;
-    auto const last = std::prev(list_.end());
-    while (out_ != last)
-    {
-        auto const avail =
-            out_->size() - out_pos_;
-        if (n < avail)
-        {
-            out_pos_ += n;
-            in_size_ += n;
-            debug_check();
-            return;
-        }
-        ++out_;
-        n -= avail;
-        out_pos_ = 0;
-        in_size_ += avail;
-        debug_check();
-    }
-
-    n = std::min (n, out_end_ - out_pos_);
-    out_pos_ += n;
-    in_size_ += n;
-    if (out_pos_ == out_->size())
-    {
-        ++out_;
-        out_pos_ = 0;
-        out_end_ = 0;
-    }
-    debug_check();
-}
-
-template <class Allocator>
-auto
-basic_streambuf<Allocator>::data() const ->
-    const_buffers_type
-{
-    return const_buffers_type(*this);
-}
-
-template <class Allocator>
-void
-basic_streambuf<Allocator>::consume (size_type n)
-{
-    if (list_.empty())
-        return;
-
-    auto pos = list_.begin();
-    for(;;)
-    {
-        if (pos != out_)
-        {
-            auto const avail = pos->size() - in_pos_;
-            if (n < avail)
-            {
-                in_size_ -= n;
-                in_pos_ += n;
-                debug_check();
-                break;
-            }
-            n -= avail;
-            in_size_ -= avail;
-            in_pos_ = 0;
-            debug_check();
-
-            element& e = *pos++;
-            list_.erase(list_.iterator_to(e));
-            size_type const len = e.alloc_size();
-            alloc_traits::destroy(this->member(), &e);
-            alloc_traits::deallocate(this->member(),
-                reinterpret_cast<char*>(&e), len);
-        }
-        else
-        {
-            auto const avail = out_pos_ - in_pos_;
-            if (n < avail)
-            {
-                in_size_ -= n;
-                in_pos_ += n;
-            }
-            else
-            {
-                in_size_ -= avail;
-                if (out_pos_ != out_end_||
-                    out_ != list_.iterator_to(list_.back()))
-                {
-                    in_pos_ = out_pos_;
-                }
-                else
-                {
-                    // Use the whole buffer now.
-                    // Alternatively we could deallocate it.
-                    in_pos_ = 0;
-                    out_pos_ = 0;
-                    out_end_ = 0;
-                }
-            }
-            debug_check();
-            break;
-        }
-    }
-}
-
-template <class Allocator>
-void
-basic_streambuf<Allocator>::debug_check() const
-{
-#ifndef NDEBUG
-    if (list_.empty())
-    {
-        assert(in_pos_ == 0);
-        assert(in_size_ == 0);
-        assert(out_pos_ == 0);
-        assert(out_end_ == 0);
-        assert(out_ == list_.end());
-        return;
-    }
-
-    auto const& front = list_.front();
-
-    assert(in_pos_ < front.size());
-
-    if (out_ == list_.end())
-    {
-        assert(out_pos_ == 0);
-        assert(out_end_ == 0);
-    }
-    else
-    {
-        auto const& out = *out_;
-        auto const& back = list_.back();
-
-        assert(out_end_ <= back.size());
-        assert(out_pos_ <  out.size());
-        assert(&out != &front || out_pos_ >= in_pos_);
-        assert(&out != &front || out_pos_ - in_pos_ == in_size_);
-        assert(&out != &back  || out_pos_ <= out_end_);
-    }
-#endif
-}
-
-template <class Alloc, class T>
-basic_streambuf<Alloc>&
-operator<< (basic_streambuf<Alloc>& buf, T const& t)
-{
-    std::stringstream ss;
-    ss << t;
-    auto const& s = ss.str();
-    buf.commit(boost::asio::buffer_copy(
-        buf.prepare(s.size()), boost::asio::buffer(s)));
-    return buf;
-}
-
-//------------------------------------------------------------------------------
-
-using streambuf = basic_streambuf<std::allocator<char>>;
-
-/** Convert the entire basic_streambuf to a string.
-    @note It is more efficient to deal directly in the streambuf instead.
-*/
-template <class Allocator>
-std::string
-to_string (basic_streambuf<Allocator> const& buf)
-{
-    std::string s;
-    s.resize(buf.size());
-    boost::asio::buffer_copy(boost::asio::buffer(
-        &s[0], s.size()), buf.data());
-    return s;
-}
-
-}
-}
-
-#endif

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

@@ -1,55 +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.
-*/
-//==============================================================================
-
-// LIBS: boost_system
-
-#if BEAST_INCLUDE_BEASTCONFIG
-#include <BeastConfig.h>
-#endif
-
-#include <beast/unit_test/suite.h>
-
-#include <beast/asio/bind_handler.h>
-
-#include <functional>
-
-namespace beast {
-namespace asio {
-
-class bind_handler_test : public unit_test::suite
-{
-public:
-    static void foo (int)
-    {
-    }
-
-    void run()
-    {
-        auto f (bind_handler (
-            std::bind (&foo, std::placeholders::_1),
-            42));
-        f();
-        pass();
-    }
-};
-
-BEAST_DEFINE_TESTSUITE(bind_handler,asio,beast);
-
-}
-}

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

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

src/beast/beast/asio/waitable_executor.h

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

src/beast/beast/boost/ErrorCode.h

@@ -1,35 +0,0 @@
-//------------------------------------------------------------------------------
-/*
-    This file is part of Beast: https://github.com/vinniefalco/Beast
-    Copyright 2013, Vinnie Falco <vinnie.falco@gmail.com>
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose  with  or without fee is hereby granted, provided that the above
-    copyright notice and this permission notice appear in all copies.
-
-    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
-    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
-    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-*/
-//==============================================================================
-
-#ifndef BEAST_BOOST_ERRORCODE_H_INCLUDED
-#define BEAST_BOOST_ERRORCODE_H_INCLUDED
-
-#include <boost/system/error_code.hpp>
-
-namespace beast {
-
-// Lift this into our namespace. For now we will
-// use boost, and then switch to std::error_code when
-// it is available on all our supported platforms.
-//
-using ErrorCode = boost::system::error_code;
-
-}
-
-#endif

src/beast/beast/chrono/Chrono.unity.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.
-*/
-//==============================================================================
-
-#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/chrono_io.h

@@ -1,803 +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.
-*/
-//==============================================================================
-
-//  chrono_io
-//
-//  (C) Copyright Howard Hinnant
-//  Use, modification and distribution are subject to the Boost Software License,
-//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//  http://www.boost.org/LICENSE_1_0.txt).
-
-#ifndef BEAST_CHRONO_CHRONO_IO_H_INCLUDED
-#define BEAST_CHRONO_CHRONO_IO_H_INCLUDED
-
-#include <beast/Config.h>
-
-#include <ctime>
-#include <locale>
-
-/*
-
-    chrono_io synopsis
-
-#include <chrono>
-#include <ratio_io>
-
-namespace std
-{
-namespace chrono
-{
-
-enum duration_style {prefix, symbol};
-enum timezone {utc, local};
-
-// facets
-
-class durationpunct
-    : public locale::facet
-{
-public:
-    static locale::id id;
-
-    explicit durationpunct(size_t refs = 0);
-    explicit durationpunct(duration_style fmt, size_t refs = 0);
-
-    bool is_symbol_name() const noexcept;
-    bool is_prefix_name() const noexcept;
-};
-
-template <class charT>
-class timepunct
-    : public locale::facet
-{
-public:
-    typedef basic_string<charT> string_type;
-
-    static locale::id id;
-
-    explicit timepunct(size_t refs = 0);
-    timepunct(timezone tz, string_type fmt, size_t refs = 0);
-
-    const string_type& fmt() const noexcept;
-    std::chrono::timezone timezone() const noexcept;
-};
-
-// manipulators
-
-class duration_fmt
-{
-public:
-    explicit duration_fmt(duration_style f) noexcept;
-    explicit operator duration_style() const noexcept;
-};
-
-unspecified time_fmt(timezone tz);
-template<class charT>
-    unspecified time_fmt(timezone tz, basic_string<charT> fmt);
-template<class charT>
-    unspecified time_fmt(timezone tz, const charT* fmt);
-
-template<class charT, class traits>
-std::basic_ostream<charT, traits>&
-operator<<(std::basic_ostream<charT, traits>& os, duration_fmt d);
-
-template<class charT, class traits>
-std::basic_istream<charT, traits>&
-operator>>(std::basic_istream<charT, traits>& is, duration_fmt d);
-
-// duration I/O
-
-template <class charT, class Traits, class Rep, class Period>
-    basic_ostream<charT, Traits>&
-    operator<<(basic_ostream<charT, Traits>& os, const duration<Rep, Period>& d);
-
-template <class charT, class Traits, class Rep, class Period>
-    basic_istream<charT, Traits>&
-    operator>>(basic_istream<charT, Traits>& is, duration<Rep, Period>& d);
-
-// system_clock I/O
-
-template <class charT, class Traits, class Duration>
-    basic_ostream<charT, Traits>&
-    operator<<(basic_ostream<charT, Traits>& os,
-               const time_point<system_clock, Duration>& tp);
-
-template <class charT, class Traits, class Duration>
-    basic_istream<charT, Traits>&
-    operator>>(basic_istream<charT, Traits>& is,
-               time_point<system_clock, Duration>& tp);
-
-// steady_clock I/O
-
-template <class charT, class Traits, class Duration>
-    basic_ostream<charT, Traits>&
-    operator<<(basic_ostream<charT, Traits>& os,
-               const time_point<steady_clock, Duration>& tp);
-
-template <class charT, class Traits, class Duration>
-    basic_istream<charT, Traits>&
-    operator>>(basic_istream<charT, Traits>& is,
-               time_point<steady_clock, Duration>& tp);
-
-// high_resolution_clock I/O
-
-template <class charT, class Traits, class Duration>
-    basic_ostream<charT, Traits>&
-    operator<<(basic_ostream<charT, Traits>& os,
-               const time_point<high_resolution_clock, Duration>& tp);
-
-template <class charT, class Traits, class Duration>
-    basic_istream<charT, Traits>&
-    operator>>(basic_istream<charT, Traits>& is,
-               time_point<high_resolution_clock, Duration>& tp);
-
-}  // chrono
-}  // std
-
-*/
-
-#include <chrono>
-#include <beast/chrono/ratio_io.h>
-
-//_LIBCPP_BEGIN_NAMESPACE_STD
-namespace std {
-
-namespace chrono
-{
-
-template <class To, class Rep, class Period>
-To
-round(const duration<Rep, Period>& d)
-{
-    To t0 = duration_cast<To>(d);
-    To t1 = t0;
-    ++t1;
-    typedef typename common_type<To, duration<Rep, Period> >::type _D;
-    _D diff0 = d - t0;
-    _D diff1 = t1 - d;
-    if (diff0 == diff1)
-    {
-        if (t0.count() & 1)
-            return t1;
-        return t0;
-    }
-    else if (diff0 < diff1)
-        return t0;
-    return t1;
-}
-
-enum duration_style {prefix, symbol};
-enum timezone {utc, local};
-
-class durationpunct
-    : public locale::facet
-{
-private:
-    duration_style __style_;
-public:
-    static locale::id id;
-
-    explicit durationpunct(size_t refs = 0)
-        : locale::facet(refs), __style_(prefix) {}
-
-    explicit durationpunct(duration_style fmt, size_t refs = 0)
-        : locale::facet(refs), __style_(fmt) {}
-
-    bool is_symbol_name() const noexcept {return __style_ == symbol;}
-    bool is_prefix_name() const noexcept {return __style_ == prefix;}
-};
-
-class duration_fmt
-{
-    duration_style form_;
-public:
-    explicit duration_fmt(duration_style f) noexcept : form_(f) {}
-    // VFALCO NOTE disabled this for MSVC
-    /*explicit*/
-        operator duration_style() const noexcept {return form_;}
-};
-
-template<class charT, class traits>
-basic_ostream<charT, traits>&
-operator <<(basic_ostream<charT, traits>& os, duration_fmt d)
-{
-    os.imbue(locale(os.getloc(), new durationpunct(static_cast<duration_style>(d))));
-    return os;
-}
-
-template<class charT, class traits>
-basic_istream<charT, traits>&
-operator >>(basic_istream<charT, traits>& is, duration_fmt d)
-{
-    is.imbue(locale(is.getloc(), new durationpunct(static_cast<duration_style>(d))));
-    return is;
-}
-
-template <class _CharT, class _Rep, class _Period>
-basic_string<_CharT>
-__get_unit(bool __is_long, const duration<_Rep, _Period>& d)
-{
-    if (__is_long)
-    {
-        _CharT __p[] = {'s', 'e', 'c', 'o', 'n', 'd', 's', 0};
-        basic_string<_CharT> s = ratio_string<_Period, _CharT>::prefix() + __p;
-        if (d.count() == 1 || d.count() == -1)
-            s.pop_back();
-        return s;
-    }
-    return ratio_string<_Period, _CharT>::symbol() + 's';
-}
-
-template <class _CharT, class _Rep>
-basic_string<_CharT>
-__get_unit(bool __is_long, const duration<_Rep, ratio<1> >& d)
-{
-    if (__is_long)
-    {
-        _CharT __p[] = {'s', 'e', 'c', 'o', 'n', 'd', 's'};
-        basic_string<_CharT> s = basic_string<_CharT>(__p, __p + sizeof(__p) / sizeof(_CharT));
-        if (d.count() == 1 || d.count() == -1)
-            s.pop_back();
-        return s;
-    }
-    return basic_string<_CharT>(1, 's');
-}
-
-template <class _CharT, class _Rep>
-basic_string<_CharT>
-__get_unit(bool __is_long, const duration<_Rep, ratio<60> >& d)
-{
-    if (__is_long)
-    {
-        _CharT __p[] = {'m', 'i', 'n', 'u', 't', 'e', 's'};
-        basic_string<_CharT> s = basic_string<_CharT>(__p, __p + sizeof(__p) / sizeof(_CharT));
-        if (d.count() == 1 || d.count() == -1)
-            s.pop_back();
-        return s;
-    }
-    _CharT __p[] = {'m', 'i', 'n'};
-    return basic_string<_CharT>(__p, __p + sizeof(__p) / sizeof(_CharT));
-}
-
-template <class _CharT, class _Rep>
-basic_string<_CharT>
-__get_unit(bool __is_long, const duration<_Rep, ratio<3600> >& d)
-{
-    if (__is_long)
-    {
-        _CharT __p[] = {'h', 'o', 'u', 'r', 's'};
-        basic_string<_CharT> s = basic_string<_CharT>(__p, __p + sizeof(__p) / sizeof(_CharT));
-        if (d.count() == 1 || d.count() == -1)
-            s.pop_back();
-        return s;
-    }
-    return basic_string<_CharT>(1, 'h');
-}
-
-template <class _CharT, class _Traits, class _Rep, class _Period>
-basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os, const duration<_Rep, _Period>& __d)
-{
-    typename basic_ostream<_CharT, _Traits>::sentry ok(__os);
-    if (ok)
-    {
-        typedef durationpunct _F;
-        typedef basic_string<_CharT> string_type;
-        bool failed = false;
-        try
-        {
-            bool __is_long = true;
-            locale __loc = __os.getloc();
-            if (has_facet<_F>(__loc))
-            {
-                const _F& f = use_facet<_F>(__loc);
-                __is_long = f.is_prefix_name();
-            }
-            string_type __unit = __get_unit<_CharT>(__is_long, __d);
-            __os << __d.count() << ' ' << __unit;
-        }
-        catch (...)
-        {
-            failed = true;
-        }
-        if (failed)
-            __os.setstate(ios_base::failbit | ios_base::badbit);
-    }
-    return __os;
-}
-
-template <class _Rep, bool = is_scalar<_Rep>::value>
-struct __duration_io_intermediate
-{
-    typedef _Rep type;
-};
-
-template <class _Rep>
-struct __duration_io_intermediate<_Rep, true>
-{
-    typedef typename conditional
-    <
-        is_floating_point<_Rep>::value,
-            long double,
-            typename conditional
-            <
-                is_signed<_Rep>::value,
-                    long long,
-                    unsigned long long
-            >::type
-    >::type type;
-};
-
-template <class T>
-T
-__gcd(T x, T y)
-{
-    while (y != 0)
-    {
-        T old_x = x;
-        x = y;
-        y = old_x % y;
-    }
-    return x;
-}
-
-template <>
-long double
-inline
-__gcd(long double, long double)
-{
-    return 1;
-}
-
-template <class _CharT, class _Traits, class _Rep, class _Period>
-basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>& __is, duration<_Rep, _Period>& __d)
-{
-    // These are unused and generate warnings
-    //typedef basic_string<_CharT> string_type;
-    //typedef durationpunct _F;
-
-    typedef typename __duration_io_intermediate<_Rep>::type _IR;
-    _IR __r;
-    // read value into __r
-    __is >> __r;
-    if (__is.good())
-    {
-        // now determine unit
-        typedef istreambuf_iterator<_CharT, _Traits> _I;
-        _I __i(__is);
-        _I __e;
-        if (__i != __e && *__i == ' ')  // mandatory ' ' after value
-        {
-            ++__i;
-            if (__i != __e)
-            {
-                locale __loc = __is.getloc();
-                // unit is num / den (yet to be determined)
-                unsigned long long num = 0;
-                unsigned long long den = 0;
-                ios_base::iostate __err = ios_base::goodbit;
-                if (*__i == '[')
-                {
-                    // parse [N/D]s or [N/D]seconds format
-                    ++__i;
-                    _CharT __x;
-                    __is >> num >> __x >> den;
-                    if (!__is.good() || __x != '/')
-                    {
-                        __is.setstate(__is.failbit);
-                        return __is;
-                    }
-                    __i = _I(__is);
-                    if (*__i != ']')
-                    {
-                        __is.setstate(__is.failbit);
-                        return __is;
-                    }
-                    ++__i;
-                    const basic_string<_CharT> __units[] =
-                    {
-                        __get_unit<_CharT>(true, seconds(2)),
-                        __get_unit<_CharT>(true, seconds(1)),
-                        __get_unit<_CharT>(false, seconds(1))
-                    };
-                    const basic_string<_CharT>* __k = __scan_keyword(__i, __e,
-                                  __units, __units + sizeof(__units)/sizeof(__units[0]),
-                                  use_facet<ctype<_CharT> >(__loc),
-                                  __err);
-                    switch ((__k - __units) / 3)
-                    {
-                    case 0:
-                        break;
-                    default:
-                        __is.setstate(__err);
-                        return __is;
-                    }
-                }
-                else
-                {
-                    // parse SI name, short or long
-                    const basic_string<_CharT> __units[] =
-                    {
-                        __get_unit<_CharT>(true, duration<_Rep, atto>(2)),
-                        __get_unit<_CharT>(true, duration<_Rep, atto>(1)),
-                        __get_unit<_CharT>(false, duration<_Rep, atto>(1)),
-                        __get_unit<_CharT>(true, duration<_Rep, femto>(2)),
-                        __get_unit<_CharT>(true, duration<_Rep, femto>(1)),
-                        __get_unit<_CharT>(false, duration<_Rep, femto>(1)),
-                        __get_unit<_CharT>(true, duration<_Rep, pico>(2)),
-                        __get_unit<_CharT>(true, duration<_Rep, pico>(1)),
-                        __get_unit<_CharT>(false, duration<_Rep, pico>(1)),
-                        __get_unit<_CharT>(true, duration<_Rep, nano>(2)),
-                        __get_unit<_CharT>(true, duration<_Rep, nano>(1)),
-                        __get_unit<_CharT>(false, duration<_Rep, nano>(1)),
-                        __get_unit<_CharT>(true, duration<_Rep, micro>(2)),
-                        __get_unit<_CharT>(true, duration<_Rep, micro>(1)),
-                        __get_unit<_CharT>(false, duration<_Rep, micro>(1)),
-                        __get_unit<_CharT>(true, duration<_Rep, milli>(2)),
-                        __get_unit<_CharT>(true, duration<_Rep, milli>(1)),
-                        __get_unit<_CharT>(false, duration<_Rep, milli>(1)),
-                        __get_unit<_CharT>(true, duration<_Rep, centi>(2)),
-                        __get_unit<_CharT>(true, duration<_Rep, centi>(1)),
-                        __get_unit<_CharT>(false, duration<_Rep, centi>(1)),
-                        __get_unit<_CharT>(true, duration<_Rep, deci>(2)),
-                        __get_unit<_CharT>(true, duration<_Rep, deci>(1)),
-                        __get_unit<_CharT>(false, duration<_Rep, deci>(1)),
-                        __get_unit<_CharT>(true, duration<_Rep, deca>(2)),
-                        __get_unit<_CharT>(true, duration<_Rep, deca>(1)),
-                        __get_unit<_CharT>(false, duration<_Rep, deca>(1)),
-                        __get_unit<_CharT>(true, duration<_Rep, hecto>(2)),
-                        __get_unit<_CharT>(true, duration<_Rep, hecto>(1)),
-                        __get_unit<_CharT>(false, duration<_Rep, hecto>(1)),
-                        __get_unit<_CharT>(true, duration<_Rep, kilo>(2)),
-                        __get_unit<_CharT>(true, duration<_Rep, kilo>(1)),
-                        __get_unit<_CharT>(false, duration<_Rep, kilo>(1)),
-                        __get_unit<_CharT>(true, duration<_Rep, mega>(2)),
-                        __get_unit<_CharT>(true, duration<_Rep, mega>(1)),
-                        __get_unit<_CharT>(false, duration<_Rep, mega>(1)),
-                        __get_unit<_CharT>(true, duration<_Rep, giga>(2)),
-                        __get_unit<_CharT>(true, duration<_Rep, giga>(1)),
-                        __get_unit<_CharT>(false, duration<_Rep, giga>(1)),
-                        __get_unit<_CharT>(true, duration<_Rep, tera>(2)),
-                        __get_unit<_CharT>(true, duration<_Rep, tera>(1)),
-                        __get_unit<_CharT>(false, duration<_Rep, tera>(1)),
-                        __get_unit<_CharT>(true, duration<_Rep, peta>(2)),
-                        __get_unit<_CharT>(true, duration<_Rep, peta>(1)),
-                        __get_unit<_CharT>(false, duration<_Rep, peta>(1)),
-                        __get_unit<_CharT>(true, duration<_Rep, exa>(2)),
-                        __get_unit<_CharT>(true, duration<_Rep, exa>(1)),
-                        __get_unit<_CharT>(false, duration<_Rep, exa>(1)),
-                        __get_unit<_CharT>(true, duration<_Rep, ratio<1> >(2)),
-                        __get_unit<_CharT>(true, duration<_Rep, ratio<1> >(1)),
-                        __get_unit<_CharT>(false, duration<_Rep, ratio<1> >(1)),
-                        __get_unit<_CharT>(true, duration<_Rep, ratio<60> >(2)),
-                        __get_unit<_CharT>(true, duration<_Rep, ratio<60> >(1)),
-                        __get_unit<_CharT>(false, duration<_Rep, ratio<60> >(1)),
-                        __get_unit<_CharT>(true, duration<_Rep, ratio<3600> >(2)),
-                        __get_unit<_CharT>(true, duration<_Rep, ratio<3600> >(1)),
-                        __get_unit<_CharT>(false, duration<_Rep, ratio<3600> >(1))
-                    };
-                    const basic_string<_CharT>* __k = __scan_keyword(__i, __e,
-                                  __units, __units + sizeof(__units)/sizeof(__units[0]),
-                                  use_facet<ctype<_CharT> >(__loc),
-                                  __err);
-                    switch (__k - __units)
-                    {
-                    case 0:
-                    case 1:
-                    case 2:
-                        num = 1ULL;
-                        den = 1000000000000000000ULL;
-                        break;
-                    case 3:
-                    case 4:
-                    case 5:
-                        num = 1ULL;
-                        den = 1000000000000000ULL;
-                        break;
-                    case 6:
-                    case 7:
-                    case 8:
-                        num = 1ULL;
-                        den = 1000000000000ULL;
-                        break;
-                    case 9:
-                    case 10:
-                    case 11:
-                        num = 1ULL;
-                        den = 1000000000ULL;
-                        break;
-                    case 12:
-                    case 13:
-                    case 14:
-                        num = 1ULL;
-                        den = 1000000ULL;
-                        break;
-                    case 15:
-                    case 16:
-                    case 17:
-                        num = 1ULL;
-                        den = 1000ULL;
-                        break;
-                    case 18:
-                    case 19:
-                    case 20:
-                        num = 1ULL;
-                        den = 100ULL;
-                        break;
-                    case 21:
-                    case 22:
-                    case 23:
-                        num = 1ULL;
-                        den = 10ULL;
-                        break;
-                    case 24:
-                    case 25:
-                    case 26:
-                        num = 10ULL;
-                        den = 1ULL;
-                        break;
-                    case 27:
-                    case 28:
-                    case 29:
-                        num = 100ULL;
-                        den = 1ULL;
-                        break;
-                    case 30:
-                    case 31:
-                    case 32:
-                        num = 1000ULL;
-                        den = 1ULL;
-                        break;
-                    case 33:
-                    case 34:
-                    case 35:
-                        num = 1000000ULL;
-                        den = 1ULL;
-                        break;
-                    case 36:
-                    case 37:
-                    case 38:
-                        num = 1000000000ULL;
-                        den = 1ULL;
-                        break;
-                    case 39:
-                    case 40:
-                    case 41:
-                        num = 1000000000000ULL;
-                        den = 1ULL;
-                        break;
-                    case 42:
-                    case 43:
-                    case 44:
-                        num = 1000000000000000ULL;
-                        den = 1ULL;
-                        break;
-                    case 45:
-                    case 46:
-                    case 47:
-                        num = 1000000000000000000ULL;
-                        den = 1ULL;
-                        break;
-                    case 48:
-                    case 49:
-                    case 50:
-                        num = 1;
-                        den = 1;
-                        break;
-                    case 51:
-                    case 52:
-                    case 53:
-                        num = 60;
-                        den = 1;
-                        break;
-                    case 54:
-                    case 55:
-                    case 56:
-                        num = 3600;
-                        den = 1;
-                        break;
-                    default:
-                        __is.setstate(__err);
-                        return __is;
-                    }
-                }
-                // unit is num/den
-                // __r should be multiplied by (num/den) / _Period
-                // Reduce (num/den) / _Period to lowest terms
-                unsigned long long __gcd_n1_n2 = __gcd<unsigned long long>(num, _Period::num);
-                unsigned long long __gcd_d1_d2 = __gcd<unsigned long long>(den, _Period::den);
-                num /= __gcd_n1_n2;
-                den /= __gcd_d1_d2;
-                unsigned long long __n2 = _Period::num / __gcd_n1_n2;
-                unsigned long long __d2 = _Period::den / __gcd_d1_d2;
-                if (num > numeric_limits<unsigned long long>::max() / __d2 ||
-                    den > numeric_limits<unsigned long long>::max() / __n2)
-                {
-                    // (num/den) / _Period overflows
-                    __is.setstate(__is.failbit);
-                    return __is;
-                }
-                num *= __d2;
-                den *= __n2;
-                // num / den is now factor to multiply by __r
-                typedef typename common_type<_IR, unsigned long long>::type _CT;
-                if (is_integral<_IR>::value)
-                {
-                    // Reduce __r * num / den
-                    _CT __t = __gcd<_CT>(__r, den);
-                    __r /= __t;
-                    den /= __t;
-                    if (den != 1)
-                    {
-                        // Conversion to _Period is integral and not exact
-                        __is.setstate(__is.failbit);
-                        return __is;
-                    }
-                }
-                if (__r > duration_values<_CT>::max() / num)
-                {
-                    // Conversion to _Period overflowed
-                    __is.setstate(__is.failbit);
-                    return __is;
-                }
-                _CT __t = __r * num;
-                __t /= den;
-                if (duration_values<_Rep>::max() < __t)
-                {
-                    // Conversion to _Period overflowed
-                    __is.setstate(__is.failbit);
-                    return __is;
-                }
-                // Success!  Store it.
-                __r = _Rep(__t);
-                __d = duration<_Rep, _Period>(__r);
-                __is.setstate(__err);
-            }
-            else
-                __is.setstate(__is.failbit | __is.eofbit);
-        }
-        else
-        {
-            if (__i == __e)
-                __is.setstate(__is.eofbit);
-            __is.setstate(__is.failbit);
-        }
-    }
-    else
-        __is.setstate(__is.failbit);
-    return __is;
-}
-
-template <class charT>
-class timepunct
-    : public locale::facet
-{
-public:
-    typedef basic_string<charT> string_type;
-
-private:
-    string_type           fmt_;
-    chrono::timezone tz_;
-
-public:
-    static locale::id id;
-
-    explicit timepunct(size_t refs = 0)
-        : locale::facet(refs), tz_(utc) {}
-    timepunct(timezone tz, string_type fmt, size_t refs = 0)
-        : locale::facet(refs), fmt_(std::move(fmt)), tz_(tz) {}
-
-    const string_type& fmt() const noexcept {return fmt_;}
-    chrono::timezone get_timezone() const noexcept {return tz_;}
-};
-
-template <class CharT>
-locale::id
-timepunct<CharT>::id;
-
-template <class _CharT, class _Traits, class _Duration>
-basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os,
-           const time_point<steady_clock, _Duration>& __tp)
-{
-    return __os << __tp.time_since_epoch() << " since boot";
-}
-
-template<class charT>
-struct __time_manip
-{
-    basic_string<charT> fmt_;
-    timezone tz_;
-
-    __time_manip(timezone tz, basic_string<charT> fmt)
-        : fmt_(std::move(fmt)),
-          tz_(tz) {}
-};
-
-template<class charT, class traits>
-basic_ostream<charT, traits>&
-operator <<(basic_ostream<charT, traits>& os, __time_manip<charT> m)
-{
-    os.imbue(locale(os.getloc(), new timepunct<charT>(m.tz_, std::move(m.fmt_))));
-    return os;
-}
-
-template<class charT, class traits>
-basic_istream<charT, traits>&
-operator >>(basic_istream<charT, traits>& is, __time_manip<charT> m)
-{
-    is.imbue(locale(is.getloc(), new timepunct<charT>(m.tz_, std::move(m.fmt_))));
-    return is;
-}
-
-template<class charT>
-inline
-__time_manip<charT>
-time_fmt(timezone tz, const charT* fmt)
-{
-    return __time_manip<charT>(tz, fmt);
-}
-
-template<class charT>
-inline
-__time_manip<charT>
-time_fmt(timezone tz, basic_string<charT> fmt)
-{
-    return __time_manip<charT>(tz, std::move(fmt));
-}
-
-class __time_man
-{
-    timezone form_;
-public:
-    explicit __time_man(timezone f) : form_(f) {}
-    // explicit
-        operator timezone() const {return form_;}
-};
-
-template<class charT, class traits>
-basic_ostream<charT, traits>&
-operator <<(basic_ostream<charT, traits>& os, __time_man m)
-{
-    os.imbue(locale(os.getloc(), new timepunct<charT>(static_cast<timezone>(m), basic_string<charT>())));
-    return os;
-}
-
-template<class charT, class traits>
-basic_istream<charT, traits>&
-operator >>(basic_istream<charT, traits>& is, __time_man m)
-{
-    is.imbue(locale(is.getloc(), new timepunct<charT>(static_cast<timezone>(m), basic_string<charT>())));
-    return is;
-}
-
-inline
-__time_man
-time_fmt(timezone f)
-{
-    return __time_man(f);
-}
-
-} // chrono
-
-}
-
-#endif
-

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

@@ -1,41 +0,0 @@
-//------------------------------------------------------------------------------
-/*
-    This file is part of Beast: https://github.com/vinniefalco/Beast
-    Copyright 2013, Vinnie Falco <vinnie.falco@gmail.com>
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose  with  or without fee is hereby granted, provided that the above
-    copyright notice and this permission notice appear in all copies.
-
-    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
-    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
-    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-*/
-//==============================================================================
-
-//  chrono_io
-//
-//  (C) Copyright Howard Hinnant
-//  Use, modification and distribution are subject to the Boost Software License,
-//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//  http://www.boost.org/LICENSE_1_0.txt).
-
-#include <beast/chrono/chrono_io.h>
-
-//_LIBCPP_BEGIN_NAMESPACE_STD
-namespace std {
-
-namespace chrono
-{
-
-locale::id
-durationpunct::id;
-
-}  // chrono
-
-//_LIBCPP_END_NAMESPACE_STD
-}

src/beast/beast/chrono/ratio_io.h

@@ -1,622 +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.
-*/
-//==============================================================================
-
-//  ratio_io
-//
-//  (C) Copyright Howard Hinnant
-//  Use, modification and distribution are subject to the Boost Software License,
-//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//  http://www.boost.org/LICENSE_1_0.txt).
-
-#ifndef BEAST_CHRONO_RATIO_IO_H_INCLUDED
-#define BEAST_CHRONO_RATIO_IO_H_INCLUDED
-
-/*
-
-    ratio_io synopsis
-
-#include <ratio>
-#include <string>
-
-namespace std
-{
-
-template <class Ratio, class charT>
-struct ratio_string
-{
-    static basic_string<charT> symbol();
-    static basic_string<charT> prefix();
-};
-
-}  // std
-
-*/
-
-#include <ratio>
-#include <string>
-#include <sstream>
-
-//_LIBCPP_BEGIN_NAMESPACE_STD
-namespace std {
-
-template <class _Ratio, class _CharT>
-struct ratio_string
-{
-    static basic_string<_CharT> symbol() {return prefix();}
-    static basic_string<_CharT> prefix();
-};
-
-template <class _Ratio, class _CharT>
-basic_string<_CharT>
-ratio_string<_Ratio, _CharT>::prefix()
-{
-    basic_ostringstream<_CharT> __os;
-    __os << _CharT('[') << _Ratio::num << _CharT('/')
-                        << _Ratio::den << _CharT(']');
-    return __os.str();
-}
-
-// atto
-
-template <>
-struct ratio_string<atto, char>
-{
-    static string symbol() {return string(1, 'a');}
-    static string prefix()  {return string("atto");}
-};
-
-#if HAS_UNICODE_SUPPORT
-
-template <>
-struct ratio_string<atto, char16_t>
-{
-    static u16string symbol() {return u16string(1, u'a');}
-    static u16string prefix()  {return u16string(u"atto");}
-};
-
-template <>
-struct ratio_string<atto, char32_t>
-{
-    static u32string symbol() {return u32string(1, U'a');}
-    static u32string prefix()  {return u32string(U"atto");}
-};
-
-#endif
-
-template <>
-struct ratio_string<atto, wchar_t>
-{
-    static wstring symbol() {return wstring(1, L'a');}
-    static wstring prefix()  {return wstring(L"atto");}
-};
-
-// femto
-
-template <>
-struct ratio_string<femto, char>
-{
-    static string symbol() {return string(1, 'f');}
-    static string prefix()  {return string("femto");}
-};
-
-#if HAS_UNICODE_SUPPORT
-
-template <>
-struct ratio_string<femto, char16_t>
-{
-    static u16string symbol() {return u16string(1, u'f');}
-    static u16string prefix()  {return u16string(u"femto");}
-};
-
-template <>
-struct ratio_string<femto, char32_t>
-{
-    static u32string symbol() {return u32string(1, U'f');}
-    static u32string prefix()  {return u32string(U"femto");}
-};
-
-#endif
-
-template <>
-struct ratio_string<femto, wchar_t>
-{
-    static wstring symbol() {return wstring(1, L'f');}
-    static wstring prefix()  {return wstring(L"femto");}
-};
-
-// pico
-
-template <>
-struct ratio_string<pico, char>
-{
-    static string symbol() {return string(1, 'p');}
-    static string prefix()  {return string("pico");}
-};
-
-#if HAS_UNICODE_SUPPORT
-
-template <>
-struct ratio_string<pico, char16_t>
-{
-    static u16string symbol() {return u16string(1, u'p');}
-    static u16string prefix()  {return u16string(u"pico");}
-};
-
-template <>
-struct ratio_string<pico, char32_t>
-{
-    static u32string symbol() {return u32string(1, U'p');}
-    static u32string prefix()  {return u32string(U"pico");}
-};
-
-#endif
-
-template <>
-struct ratio_string<pico, wchar_t>
-{
-    static wstring symbol() {return wstring(1, L'p');}
-    static wstring prefix()  {return wstring(L"pico");}
-};
-
-// nano
-
-template <>
-struct ratio_string<nano, char>
-{
-    static string symbol() {return string(1, 'n');}
-    static string prefix()  {return string("nano");}
-};
-
-#if HAS_UNICODE_SUPPORT
-
-template <>
-struct ratio_string<nano, char16_t>
-{
-    static u16string symbol() {return u16string(1, u'n');}
-    static u16string prefix()  {return u16string(u"nano");}
-};
-
-template <>
-struct ratio_string<nano, char32_t>
-{
-    static u32string symbol() {return u32string(1, U'n');}
-    static u32string prefix()  {return u32string(U"nano");}
-};
-
-#endif
-
-template <>
-struct ratio_string<nano, wchar_t>
-{
-    static wstring symbol() {return wstring(1, L'n');}
-    static wstring prefix()  {return wstring(L"nano");}
-};
-
-// micro
-
-template <>
-struct ratio_string<micro, char>
-{
-    static string symbol() {return string("\xC2\xB5");}
-    static string prefix()  {return string("micro");}
-};
-
-#if HAS_UNICODE_SUPPORT
-
-template <>
-struct ratio_string<micro, char16_t>
-{
-    static u16string symbol() {return u16string(1, u'\xB5');}
-    static u16string prefix()  {return u16string(u"micro");}
-};
-
-template <>
-struct ratio_string<micro, char32_t>
-{
-    static u32string symbol() {return u32string(1, U'\xB5');}
-    static u32string prefix()  {return u32string(U"micro");}
-};
-
-#endif
-
-template <>
-struct ratio_string<micro, wchar_t>
-{
-    static wstring symbol() {return wstring(1, L'\xB5');}
-    static wstring prefix()  {return wstring(L"micro");}
-};
-
-// milli
-
-template <>
-struct ratio_string<milli, char>
-{
-    static string symbol() {return string(1, 'm');}
-    static string prefix()  {return string("milli");}
-};
-
-#if HAS_UNICODE_SUPPORT
-
-template <>
-struct ratio_string<milli, char16_t>
-{
-    static u16string symbol() {return u16string(1, u'm');}
-    static u16string prefix()  {return u16string(u"milli");}
-};
-
-template <>
-struct ratio_string<milli, char32_t>
-{
-    static u32string symbol() {return u32string(1, U'm');}
-    static u32string prefix()  {return u32string(U"milli");}
-};
-
-#endif
-
-template <>
-struct ratio_string<milli, wchar_t>
-{
-    static wstring symbol() {return wstring(1, L'm');}
-    static wstring prefix()  {return wstring(L"milli");}
-};
-
-// centi
-
-template <>
-struct ratio_string<centi, char>
-{
-    static string symbol() {return string(1, 'c');}
-    static string prefix()  {return string("centi");}
-};
-
-#if HAS_UNICODE_SUPPORT
-
-template <>
-struct ratio_string<centi, char16_t>
-{
-    static u16string symbol() {return u16string(1, u'c');}
-    static u16string prefix()  {return u16string(u"centi");}
-};
-
-template <>
-struct ratio_string<centi, char32_t>
-{
-    static u32string symbol() {return u32string(1, U'c');}
-    static u32string prefix()  {return u32string(U"centi");}
-};
-
-#endif
-
-template <>
-struct ratio_string<centi, wchar_t>
-{
-    static wstring symbol() {return wstring(1, L'c');}
-    static wstring prefix()  {return wstring(L"centi");}
-};
-
-// deci
-
-template <>
-struct ratio_string<deci, char>
-{
-    static string symbol() {return string(1, 'd');}
-    static string prefix()  {return string("deci");}
-};
-
-#if HAS_UNICODE_SUPPORT
-
-template <>
-struct ratio_string<deci, char16_t>
-{
-    static u16string symbol() {return u16string(1, u'd');}
-    static u16string prefix()  {return u16string(u"deci");}
-};
-
-template <>
-struct ratio_string<deci, char32_t>
-{
-    static u32string symbol() {return u32string(1, U'd');}
-    static u32string prefix()  {return u32string(U"deci");}
-};
-
-#endif
-
-template <>
-struct ratio_string<deci, wchar_t>
-{
-    static wstring symbol() {return wstring(1, L'd');}
-    static wstring prefix()  {return wstring(L"deci");}
-};
-
-// deca
-
-template <>
-struct ratio_string<deca, char>
-{
-    static string symbol() {return string("da");}
-    static string prefix()  {return string("deca");}
-};
-
-#if HAS_UNICODE_SUPPORT
-
-template <>
-struct ratio_string<deca, char16_t>
-{
-    static u16string symbol() {return u16string(u"da");}
-    static u16string prefix()  {return u16string(u"deca");}
-};
-
-template <>
-struct ratio_string<deca, char32_t>
-{
-    static u32string symbol() {return u32string(U"da");}
-    static u32string prefix()  {return u32string(U"deca");}
-};
-
-#endif
-
-template <>
-struct ratio_string<deca, wchar_t>
-{
-    static wstring symbol() {return wstring(L"da");}
-    static wstring prefix()  {return wstring(L"deca");}
-};
-
-// hecto
-
-template <>
-struct ratio_string<hecto, char>
-{
-    static string symbol() {return string(1, 'h');}
-    static string prefix()  {return string("hecto");}
-};
-
-#if HAS_UNICODE_SUPPORT
-
-template <>
-struct ratio_string<hecto, char16_t>
-{
-    static u16string symbol() {return u16string(1, u'h');}
-    static u16string prefix()  {return u16string(u"hecto");}
-};
-
-template <>
-struct ratio_string<hecto, char32_t>
-{
-    static u32string symbol() {return u32string(1, U'h');}
-    static u32string prefix()  {return u32string(U"hecto");}
-};
-
-#endif
-
-template <>
-struct ratio_string<hecto, wchar_t>
-{
-    static wstring symbol() {return wstring(1, L'h');}
-    static wstring prefix()  {return wstring(L"hecto");}
-};
-
-// kilo
-
-template <>
-struct ratio_string<kilo, char>
-{
-    static string symbol() {return string(1, 'k');}
-    static string prefix()  {return string("kilo");}
-};
-
-#if HAS_UNICODE_SUPPORT
-
-template <>
-struct ratio_string<kilo, char16_t>
-{
-    static u16string symbol() {return u16string(1, u'k');}
-    static u16string prefix()  {return u16string(u"kilo");}
-};
-
-template <>
-struct ratio_string<kilo, char32_t>
-{
-    static u32string symbol() {return u32string(1, U'k');}
-    static u32string prefix()  {return u32string(U"kilo");}
-};
-
-#endif
-
-template <>
-struct ratio_string<kilo, wchar_t>
-{
-    static wstring symbol() {return wstring(1, L'k');}
-    static wstring prefix()  {return wstring(L"kilo");}
-};
-
-// mega
-
-template <>
-struct ratio_string<mega, char>
-{
-    static string symbol() {return string(1, 'M');}
-    static string prefix()  {return string("mega");}
-};
-
-#if HAS_UNICODE_SUPPORT
-
-template <>
-struct ratio_string<mega, char16_t>
-{
-    static u16string symbol() {return u16string(1, u'M');}
-    static u16string prefix()  {return u16string(u"mega");}
-};
-
-template <>
-struct ratio_string<mega, char32_t>
-{
-    static u32string symbol() {return u32string(1, U'M');}
-    static u32string prefix()  {return u32string(U"mega");}
-};
-
-#endif
-
-template <>
-struct ratio_string<mega, wchar_t>
-{
-    static wstring symbol() {return wstring(1, L'M');}
-    static wstring prefix()  {return wstring(L"mega");}
-};
-
-// giga
-
-template <>
-struct ratio_string<giga, char>
-{
-    static string symbol() {return string(1, 'G');}
-    static string prefix()  {return string("giga");}
-};
-
-#if HAS_UNICODE_SUPPORT
-
-template <>
-struct ratio_string<giga, char16_t>
-{
-    static u16string symbol() {return u16string(1, u'G');}
-    static u16string prefix()  {return u16string(u"giga");}
-};
-
-template <>
-struct ratio_string<giga, char32_t>
-{
-    static u32string symbol() {return u32string(1, U'G');}
-    static u32string prefix()  {return u32string(U"giga");}
-};
-
-#endif
-
-template <>
-struct ratio_string<giga, wchar_t>
-{
-    static wstring symbol() {return wstring(1, L'G');}
-    static wstring prefix()  {return wstring(L"giga");}
-};
-
-// tera
-
-template <>
-struct ratio_string<tera, char>
-{
-    static string symbol() {return string(1, 'T');}
-    static string prefix()  {return string("tera");}
-};
-
-#if HAS_UNICODE_SUPPORT
-
-template <>
-struct ratio_string<tera, char16_t>
-{
-    static u16string symbol() {return u16string(1, u'T');}
-    static u16string prefix()  {return u16string(u"tera");}
-};
-
-template <>
-struct ratio_string<tera, char32_t>
-{
-    static u32string symbol() {return u32string(1, U'T');}
-    static u32string prefix()  {return u32string(U"tera");}
-};
-
-#endif
-
-template <>
-struct ratio_string<tera, wchar_t>
-{
-    static wstring symbol() {return wstring(1, L'T');}
-    static wstring prefix()  {return wstring(L"tera");}
-};
-
-// peta
-
-template <>
-struct ratio_string<peta, char>
-{
-    static string symbol() {return string(1, 'P');}
-    static string prefix()  {return string("peta");}
-};
-
-#if HAS_UNICODE_SUPPORT
-
-template <>
-struct ratio_string<peta, char16_t>
-{
-    static u16string symbol() {return u16string(1, u'P');}
-    static u16string prefix()  {return u16string(u"peta");}
-};
-
-template <>
-struct ratio_string<peta, char32_t>
-{
-    static u32string symbol() {return u32string(1, U'P');}
-    static u32string prefix()  {return u32string(U"peta");}
-};
-
-#endif
-
-template <>
-struct ratio_string<peta, wchar_t>
-{
-    static wstring symbol() {return wstring(1, L'P');}
-    static wstring prefix()  {return wstring(L"peta");}
-};
-
-// exa
-
-template <>
-struct ratio_string<exa, char>
-{
-    static string symbol() {return string(1, 'E');}
-    static string prefix()  {return string("exa");}
-};
-
-#if HAS_UNICODE_SUPPORT
-
-template <>
-struct ratio_string<exa, char16_t>
-{
-    static u16string symbol() {return u16string(1, u'E');}
-    static u16string prefix()  {return u16string(u"exa");}
-};
-
-template <>
-struct ratio_string<exa, char32_t>
-{
-    static u32string symbol() {return u32string(1, U'E');}
-    static u32string prefix()  {return u32string(U"exa");}
-};
-
-#endif
-
-template <>
-struct ratio_string<exa, wchar_t>
-{
-    static wstring symbol() {return wstring(1, L'E');}
-    static wstring prefix()  {return wstring(L"exa");}
-};
-
-//_LIBCPP_END_NAMESPACE_STD
-}
-
-#endif  // _RATIO_IO

src/beast/beast/config/ContractChecks.h

@@ -1,86 +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_CONFIG_CONTRACTCHECKS_H_INCLUDED
-#define BEAST_CONFIG_CONTRACTCHECKS_H_INCLUDED
-
-// This file has to work when included in a C source file.
-
-#if defined (fatal_error) || \
-    defined (fatal_condition) || \
-    defined (meets_condition) || \
-    defined (meets_precondition) || \
-    defined (meets_postcondition) || \
-    defined (meets_invariant) || \
-    defined (check_invariant)
-#error "Programming by contract macros cannot be overriden!"
-#endif
-
-/** Report a fatal error message and terminate the application.
-    This macro automatically fills in the file and line number
-    Meets this declaration syntax:
-    @code inline void fatal_error (char const* message); @endif
-    @see FatalError
-*/
-#define fatal_error(message) beast_reportFatalError (message, __FILE__, __LINE__)
-
-/** Reports a fatal error message type if the condition is false
-    The condition is always evaluated regardless of settings.
-    Meets this declaration syntax:
-    @code inline void fatal_condition (bool condition, char const* category); @endcode
-*/
-#define fatal_condition(condition,category) static_cast <void> \
-    (((!!(condition)) || (beast_reportFatalError ( \
-        category " '" BEAST_STRINGIFY(condition) "' failed.", __FILE__, __LINE__), 0)))
-
-/** Reports a fatal error message type if the condition is false
-    The condition is always evaluated regardless of settings.
-    Meets this declaration syntax:
-    @code inline void fatal_condition (bool condition, char const* category); @endcode
-*/
-#define meets_condition(condition,category) static_cast <bool> \
-    (((!!(condition)) || (beast_reportFatalError ( \
-        category " '" BEAST_STRINGIFY(condition) "' failed.", __FILE__, __LINE__), false)))
-
-/** Condition tests for programming by contract.
-    The condition is always evaluated regardless of settings, and gets returned.
-    Meets this declaration syntax:
-    @code inline bool meets_condition (bool); @endcode
-*/
-/** @{ */
-#define meets_precondition(condition)  meets_condition(condition,"Pre-condition")
-#define meets_postcondition(condition) meets_condition(condition,"Post-condition")
-#define meets_invariant(condition)     meets_condition(condition,"Invariant")
-/** @} */
-
-/** Condition tests for programming by contract.
-    The condition is evaluated only if BEAST_DISABLE_CONTRACT_CHECKS is 0.
-    Meets this declaration syntax:
-    @code inline void check_condition (bool); @endcode
-    @see BEAST_DISABLE_CONTRACT_CHECKS
-*/
-/** @{ */
-#if ! BEAST_DISABLE_CONTRACT_CHECKS
-# define check_invariant(condition)     meets_invariant(condition)
-#else
-# define check_invariant(condition)     ((void)0)
-#endif
-/** @} */
-
-#endif

src/beast/beast/config/SelectCompilerConfig.h

@@ -1,48 +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.
-*/
-//==============================================================================
-
-// Ideas from boost
-
-// Intel
-#ifndef BEAST_CONFIG_SELECTCOMPILERCONFIG_H_INCLUDED
-#define BEAST_CONFIG_SELECTCOMPILERCONFIG_H_INCLUDED
-
-#if defined(__INTEL_COMPILER) || defined(__ICL) || defined(__ICC) || defined(__ECC)
-#define BEAST_COMPILER_CONFIG "config/compiler/Intel.h"
-
-// Clang C++ emulates GCC, so it has to appear early.
-#elif defined __clang__
-#define BEAST_COMPILER_CONFIG "config/compiler/Clang.h"
-
-//  GNU C++:
-#elif defined __GNUC__
-#define BEAST_COMPILER_CONFIG "config/compiler/Gcc.h"
-
-//  Microsoft Visual C++
-//
-//  Must remain the last #elif since some other vendors (Metrowerks, for
-//  example) also #define _MSC_VER
-#elif defined _MSC_VER
-#define BEAST_COMPILER_CONFIG "config/compiler/VisualC.h"
-
-#else
-#error "Unsupported compiler."
-#endif
-
-#endif

src/beast/beast/config/SelectPlatformConfig.h

@@ -1,48 +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.
-*/
-//==============================================================================
-
-// Ideas from boost
-
-// Android, which must be manually set by defining BEAST_ANDROID
-#ifndef BEAST_CONFIG_SELECTPLATFORMCONFIG_H_INCLUDED
-#define BEAST_CONFIG_SELECTPLATFORMCONFIG_H_INCLUDED
-
-#if defined(BEAST_ANDROID)
-#define BEAST_PLATFORM_CONFIG "config/platform/Android.h"
-
-// linux, also other platforms (Hurd etc) that use GLIBC
-#elif (defined(linux) || defined(__linux) || defined(__linux__) || defined(__GNU__) || defined(__GLIBC__)) && !defined(_CRAYC)
-#define BEAST_PLATFORM_CONFIG "config/platform/Linux.h"
-
-// BSD
-#elif defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__)
-#define BEAST_PLATFORM_CONFIG "config/platform/Bsd.h"
-
-// win32
-#elif defined(_WIN32) || defined(__WIN32__) || defined(WIN32) || defined(_WIN64)
-#define BEAST_PLATFORM_CONFIG "config/platform/Win32.h"
-
-// MacOS
-#elif defined(macintosh) || defined(__APPLE__) || defined(__APPLE_CC__) || defined(__APPLE_CPP__)
-#define BEAST_PLATFORM_CONFIG "config/platform/MacOS.h"
-
-#else
-#error "Unsupported platform."
-#endif
-#endif

src/beast/beast/config/SelectStdlibConfig.h

@@ -1,21 +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.
-*/
-//==============================================================================
-
-// Ideas from boost
-

src/beast/beast/config/Suffix.h

@@ -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.
-*/
-//==============================================================================
-
-#ifndef BEAST_CONFIG_SUFFIX_H_INCLUDED
-#define BEAST_CONFIG_SUFFIX_H_INCLUDED
-
-// Included at the end of Config.h
-
-#endif

src/beast/beast/config/compiler/Clang.h

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

src/beast/beast/config/compiler/Gcc.h

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

src/beast/beast/config/compiler/Intel.h

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