Initial commit

externals/vcpkg/buildtrees/boost-io/src/ost-1.79.0-aff9d6facf.clean/.appveyor.yml

@@ -0,0 +1,61 @@
+# Copyright 2019 Glen Fernandes
+# Distributed under the Boost Software License, Version 1.0.
+
+version: 1.0.{build}-{branch}
+
+shallow_clone: true
+
+branches:
+  only:
+    - master
+    - develop
+
+environment:
+  matrix:
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+      TOOLSET: msvc-9.0
+      ADDRMD: 32
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+      TOOLSET: msvc-10.0
+      ADDRMD: 32
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+      TOOLSET: msvc-11.0
+      ADDRMD: 32
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+      TOOLSET: msvc-12.0
+      ADDRMD: 32,64
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+      TOOLSET: msvc-14.0
+      ADDRMD: 32,64
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+      TOOLSET: msvc-14.1
+      ADDRMD: 32,64
+      CXXSTD: 14,17
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+      TOOLSET: clang-win
+      ADDRMD: 32,64
+      CXXSTD: 14,17
+
+install:
+  - set BOOST_BRANCH=develop
+  - if "%APPVEYOR_REPO_BRANCH%" == "master" set BOOST_BRANCH=master
+  - cd ..
+  - git clone -b %BOOST_BRANCH% https://github.com/boostorg/boost.git boost
+  - cd boost
+  - git submodule init libs/assert
+  - git submodule init libs/config
+  - git submodule init libs/core
+  - git submodule init libs/headers
+  - git submodule init tools/build
+  - git submodule init tools/boost_install
+  - git submodule update
+  - xcopy /s /e /q %APPVEYOR_BUILD_FOLDER% libs\io\
+  - cmd /c bootstrap
+  - b2 headers
+
+build: off
+
+test_script:
+  - if not "%CXXSTD%" == "" set CXXSTD=cxxstd=%CXXSTD%
+  - if not "%ADDRMD%" == "" set ADDRMD=address-model=%ADDRMD%
+  - b2 libs/io/test toolset=%TOOLSET% %CXXSTD% %ADDRMD%

externals/vcpkg/buildtrees/boost-io/src/ost-1.79.0-aff9d6facf.clean/.github/workflows/ci.yml

@@ -0,0 +1,184 @@
+name: CI
+
+on:
+  pull_request:
+  push:
+    branches:
+      - master
+      - develop
+
+jobs:
+  posix:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - toolset: gcc-4.8
+            standard: "03,11"
+            os: ubuntu-18.04
+            install: g++-4.8
+          - toolset: gcc-5
+            standard: "03,11,14,1z"
+            os: ubuntu-18.04
+            install: g++-5
+          - toolset: gcc-6
+            standard: "03,11,14,1z"
+            os: ubuntu-18.04
+            install: g++-6
+          - toolset: gcc-7
+            standard: "03,11,14,17"
+            os: ubuntu-18.04
+          - toolset: gcc-8
+            standard: "03,11,14,17,2a"
+            os: ubuntu-18.04
+            install: g++-8
+          - toolset: gcc-9
+            standard: "03,11,14,17,2a"
+            os: ubuntu-18.04
+          - toolset: gcc-10
+            standard: "03,11,14,17,2a"
+            os: ubuntu-20.04
+            install: g++-10
+          - toolset: gcc-11
+            standard: "03,11,14,17,2a"
+            os: ubuntu-20.04
+            install: g++-11
+          - toolset: clang
+            compiler: clang++-3.9
+            standard: "03,11,14"
+            os: ubuntu-18.04
+            install: clang-3.9
+          - toolset: clang
+            compiler: clang++-4.0
+            standard: "03,11,14"
+            os: ubuntu-18.04
+            install: clang-4.0
+          - toolset: clang
+            compiler: clang++-5.0
+            standard: "03,11,14,1z"
+            os: ubuntu-18.04
+            install: clang-5.0
+          - toolset: clang
+            compiler: clang++-6.0
+            standard: "03,11,14,17"
+            os: ubuntu-18.04
+            install: clang-6.0
+          - toolset: clang
+            compiler: clang++-7
+            standard: "03,11,14,17"
+            os: ubuntu-18.04
+            install: clang-7
+          - toolset: clang
+            compiler: clang++-8
+            standard: "03,11,14,17"
+            os: ubuntu-20.04
+            install: clang-8
+          - toolset: clang
+            compiler: clang++-9
+            standard: "03,11,14,17,2a"
+            os: ubuntu-20.04
+            install: clang-9
+          - toolset: clang
+            compiler: clang++-10
+            standard: "03,11,14,17,2a"
+            os: ubuntu-20.04
+            install: clang-10
+          - toolset: clang
+            compiler: clang++-11
+            cxxstd: "03,11,14,17,2a"
+            os: ubuntu-20.04
+            install: clang-11
+          - toolset: clang
+            compiler: clang++-12
+            cxxstd: "03,11,14,17,2a"
+            os: ubuntu-20.04
+            install: clang-12
+          - toolset: clang
+            standard: "03,11,14,17,2a"
+            os: macos-10.15
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Install packages
+        if: matrix.install
+        run: sudo apt install ${{matrix.install}}
+
+      - name: Setup Boost
+        run: |
+          cd ..
+          git clone --depth 1 https://github.com/boostorg/boost
+          cd boost
+          cp -r $GITHUB_WORKSPACE/* libs/io
+          git submodule init libs/assert
+          git submodule init libs/config
+          git submodule init libs/core
+          git submodule init libs/headers
+          git submodule init tools/build
+          git submodule init tools/boost_install
+          git submodule update
+          ./bootstrap.sh
+          ./b2 -d0 headers
+
+      - name: Create user-config.jam
+        if: matrix.compiler
+        run: |
+          echo "using ${{matrix.toolset}} : : ${{matrix.compiler}} ;" > ~/user-config.jam
+
+      - name: Run tests
+        run: |
+          cd ../boost
+          ./b2 -j3 libs/io/test toolset=${{matrix.toolset}} cxxstd=${{matrix.standard}} variant=debug,release
+
+  windows:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - toolset: msvc-14.1
+            standard: "14,17,latest"
+            target: 32,64
+            os: windows-2016
+          - toolset: msvc-14.2
+            standard: "14,17,latest"
+            target: 32,64
+            os: windows-2019
+          - toolset: msvc-14.3
+            cxxstd: "14,17,latest"
+            addrmd: 32,64
+            os: windows-2022
+          - toolset: gcc
+            standard: "03,11,14,17,2a"
+            target: 64
+            os: windows-2019
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Setup Boost
+        shell: cmd
+        run: |
+          cd ..
+          git clone --depth 1 https://github.com/boostorg/boost boost
+          cd boost
+          xcopy /s /e /q %GITHUB_WORKSPACE% libs\io\
+          git submodule init libs/assert
+          git submodule init libs/config
+          git submodule init libs/core
+          git submodule init libs/static_assert
+          git submodule init libs/headers
+          git submodule init tools/build
+          git submodule init tools/boost_install
+          git submodule update
+          cmd /c bootstrap
+          b2 -d0 headers
+
+      - name: Run tests
+        shell: cmd
+        run: |
+          cd ../boost
+          b2 -j3 libs/io/test toolset=${{matrix.toolset}} cxxstd=${{matrix.standard}} address-model=${{matrix.target}} variant=debug,release

externals/vcpkg/buildtrees/boost-io/src/ost-1.79.0-aff9d6facf.clean/.travis.yml

@@ -0,0 +1,301 @@
+# Copyright 2017 Edward Diener
+# Copyright 2019 Glen Fernandes
+# Distributed under the Boost Software License, Version 1.0.
+
+language: cpp
+
+sudo: false
+
+dist: trusty
+
+python: "2.7"
+
+branches:
+  only:
+    - master
+    - develop
+
+env:
+  matrix:
+    - BOGUS_JOB=true
+
+matrix:
+
+  exclude:
+    - env: BOGUS_JOB=true
+
+  include:
+    - os: linux
+      compiler: g++
+      env: TOOLSET=gcc COMPILER=g++ CXXSTD=03,11
+
+    - os: linux
+      compiler: g++-4.4
+      env: TOOLSET=gcc COMPILER=g++-4.4 CXXSTD=98,0x
+      addons:
+        apt:
+          packages:
+            - g++-4.4
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-4.6
+      env: TOOLSET=gcc COMPILER=g++-4.6 CXXSTD=03,0x
+      addons:
+        apt:
+          packages:
+            - g++-4.6
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-4.7
+      env: TOOLSET=gcc COMPILER=g++-4.7 CXXSTD=03,11
+      addons:
+        apt:
+          packages:
+            - g++-4.7
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-4.8
+      env: TOOLSET=gcc COMPILER=g++-4.8 CXXSTD=03,11
+      addons:
+        apt:
+          packages:
+            - g++-4.8
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-4.9
+      env: TOOLSET=gcc COMPILER=g++-4.9 CXXSTD=03,11
+      addons:
+        apt:
+          packages:
+            - g++-4.9
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-5
+      env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - g++-5
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-6
+      env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - g++-6
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-7
+      env: TOOLSET=gcc COMPILER=g++-7 CXXSTD=03,11,14,17
+      addons:
+        apt:
+          packages:
+            - g++-7
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-8
+      env: TOOLSET=gcc COMPILER=g++-8 CXXSTD=03,11,14,17,2a
+      addons:
+        apt:
+          packages:
+            - g++-8
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-9
+      env: TOOLSET=gcc COMPILER=g++-9 CXXSTD=03,11,14,17,2a
+      addons:
+        apt:
+          packages:
+            - g++-9
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: clang++
+      env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11
+
+    - os: linux
+      compiler: /usr/bin/clang++
+      env: TOOLSET=clang COMPILER=/usr/bin/clang++ CXXSTD=03,11
+      addons:
+        apt:
+          packages:
+            - clang-3.3
+
+    - os: linux
+      compiler: /usr/bin/clang++
+      env: TOOLSET=clang COMPILER=/usr/bin/clang++ CXXSTD=03,11
+      addons:
+        apt:
+          packages:
+            - clang-3.4
+
+    - os: linux
+      compiler: clang++-3.5
+      env: TOOLSET=clang COMPILER=clang++-3.5 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-3.5
+            - libstdc++-4.9-dev
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.5
+
+    - os: linux
+      compiler: clang++-3.6
+      env: TOOLSET=clang COMPILER=clang++-3.6 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-3.6
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.6
+
+    - os: linux
+      compiler: clang++-3.7
+      env: TOOLSET=clang COMPILER=clang++-3.7 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-3.7
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.7
+
+    - os: linux
+      compiler: clang++-3.8
+      env: TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-3.8
+            - libstdc++-4.9-dev
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.8
+
+    - os: linux
+      compiler: clang++-3.9
+      env: TOOLSET=clang COMPILER=clang++-3.9 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-3.9
+            - libstdc++-4.9-dev
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.9
+
+    - os: linux
+      compiler: clang++-4.0
+      env: TOOLSET=clang COMPILER=clang++-4.0 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-4.0
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-trusty-4.0
+
+    - os: linux
+      compiler: clang++-5.0
+      env: TOOLSET=clang COMPILER=clang++-5.0 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-5.0
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-trusty-5.0
+
+    - os: linux
+      compiler: clang++-6.0
+      env: TOOLSET=clang COMPILER=clang++-6.0 CXXSTD=03,11,14,17,2a
+      addons:
+        apt:
+          packages:
+            - clang-6.0
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-trusty-6.0
+
+    - os: linux
+      compiler: clang++-7
+      env: TOOLSET=clang COMPILER=clang++-7 CXXSTD=03,11,14,17,2a
+      addons:
+        apt:
+          packages:
+            - clang-7
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-trusty-7
+
+    - os: linux
+      compiler: clang++-8
+      env: TOOLSET=clang COMPILER=clang++-8 CXXSTD=03,11,14,17,2a
+      addons:
+        apt:
+          packages:
+            - clang-8
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-trusty-8
+
+    - os: linux
+      compiler: clang++-libc++
+      env: TOOLSET=clang COMPILER=clang++-libc++ CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - libc++-dev
+
+    - os: osx
+      compiler: clang++
+      env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11,14,1z
+
+install:
+  - BOOST_BRANCH=develop && [ "$TRAVIS_BRANCH" == "master" ] && BOOST_BRANCH=master || true
+  - cd ..
+  - git clone -b $BOOST_BRANCH https://github.com/boostorg/boost.git boost
+  - cd boost
+  - git submodule init libs/assert
+  - git submodule init libs/config
+  - git submodule init libs/core
+  - git submodule init libs/headers
+  - git submodule init tools/build
+  - git submodule init tools/boost_install
+  - git submodule update
+  - mkdir -p libs/io
+  - cp -r $TRAVIS_BUILD_DIR/* libs/io
+  - ./bootstrap.sh
+  - ./b2 headers
+
+script:
+  - |-
+    echo "using $TOOLSET : : $COMPILER ;" > ~/user-config.jam
+  - ./b2 libs/io/test toolset=$TOOLSET cxxstd=$CXXSTD
+
+notifications:
+  email:
+    on_success: always

externals/vcpkg/buildtrees/boost-io/src/ost-1.79.0-aff9d6facf.clean/CMakeLists.txt

@@ -0,0 +1,17 @@
+# Copyright 2018 Mike Dev
+# Distributed under the Boost Software License, Version 1.0.
+# (http://www.boost.org/LICENSE_1_0.txt)
+
+cmake_minimum_required(VERSION 3.5...3.20)
+
+project(boost_io VERSION "${BOOST_SUPERPROJECT_VERSION}" LANGUAGES CXX)
+
+add_library(boost_io INTERFACE)
+add_library(Boost::io ALIAS boost_io)
+
+target_include_directories(boost_io INTERFACE include)
+
+target_link_libraries(boost_io
+  INTERFACE
+    Boost::config
+)

externals/vcpkg/buildtrees/boost-io/src/ost-1.79.0-aff9d6facf.clean/README.md

@@ -0,0 +1,9 @@
+# Boost.IO
+
+The Boost IO C++ library provides utilities for dealing with the C++ standard
+library IO streams.
+
+### License
+
+Distributed under the
+[Boost Software License, Version 1.0](http://www.boost.org/LICENSE_1_0.txt).

externals/vcpkg/buildtrees/boost-io/src/ost-1.79.0-aff9d6facf.clean/doc/Jamfile

@@ -0,0 +1,23 @@
+# Copyright 2019 Glen Joseph Fernandes
+# (glenjofe@gmail.com)
+#
+# Distributed under the Boost Software License, Version 1.0.
+# (http://www.boost.org/LICENSE_1_0.txt)
+
+import asciidoctor ;
+
+html io.html : io.adoc ;
+
+install html_ : io.html : <location>html ;
+
+pdf io.pdf : io.adoc ;
+explicit io.pdf ;
+
+install pdf_ : io.pdf : <location>pdf ;
+explicit pdf_ ;
+
+alias boostdoc ;
+explicit boostdoc ;
+
+alias boostrelease : html_ ;
+explicit boostrelease ;

externals/vcpkg/buildtrees/boost-io/src/ost-1.79.0-aff9d6facf.clean/doc/io-docinfo-footer.html

@@ -0,0 +1,5 @@
+<style>
+.specification {
+margin-left: 2em;
+}
+</style>

externals/vcpkg/buildtrees/boost-io/src/ost-1.79.0-aff9d6facf.clean/doc/io.adoc

@@ -0,0 +1,39 @@
+////
+Copyright 2019 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+////
+
+# Boost.IO
+Daryle Walker, Beman Dawes, Glen Joseph Fernandes <glenjofe@gmail.com>
+:docinfo: private-footer
+:idprefix:
+:source-language: cpp
+:toc: left
+
+This library contains various utilities for the standard I/O library.
+
+:leveloffset: +1
+
+include::ios_state.adoc[]
+
+include::quoted.adoc[]
+
+include::ostream_joiner.adoc[]
+
+include::ostream_put.adoc[]
+
+include::nullstream.adoc[]
+
+:leveloffset: -1
+
+## Copyright and License
+
+* Copyright 2002 Daryle Walker
+* Copyright 2002, 2006, 2007, 2009, 2010 Beman Dawes
+* Copyright 2019 Glen Joseph Fernandes
+
+Distributed under the
+http://www.boost.org/LICENSE_1_0.txt[Boost Software License, Version 1.0].

externals/vcpkg/buildtrees/boost-io/src/ost-1.79.0-aff9d6facf.clean/doc/ios_state.adoc

@@ -0,0 +1,322 @@
+////
+Copyright 2019 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+////
+
+# IO State Savers, <boost/io/ios_state.hpp>
+:toc:
+:toc-title:
+:idprefix:
+
+## Description
+
+The header `<boost/io/ios_state.hpp>` covers saving the stream state of objects
+in the {cpp} IOStreams system.
+
+## Rationale
+
+Sometimes a certain value has to change only for a limited scope. Saver classes
+save a copy of the current state of some object (or an aspect of an object),
+and reset the object's state at destruction time, undoing any change the object
+may have gone through.
+
+The saver class strategy is helpful when using I/O stream objects. Manipulator
+objects can change some aspect of a stream during input or output. The state
+changed by the manipulator usually sticks to its new value after the I/O
+transaction. This can be a problem if manipulators are used in a function that
+is not supposed to externally change a stream's state.
+
+```
+#include <ostream>
+#include <ios>
+
+void hex_my_byte(std::ostream& os, char byte)
+{
+    os << std::hex << static_cast<unsigned>(byte);
+}
+```
+
+The `os` stream will retain its new hexadecimal printing mode after the call to
+`hex_my_byte`. The stream's printing mode can be saved and restored with manual
+calls to the stream's state inspecting and mutating member functions. The
+manual method becomes unwieldy if the main functionality is complex and/or
+needs to be exception safe. A saver class can implement the better
+"resource acquisition is initialization" strategy.
+
+See the example below for better code, using saver classes.
+
+## Header Synopsis
+
+```
+namespace boost {
+namespace io {
+
+class ios_flags_saver;
+class ios_precision_saver;
+class ios_width_saver;
+class ios_base_all_saver;
+
+template<class Ch, class Tr = std::char_traits<Ch> >
+class basic_ios_iostate_saver;
+
+template<class Ch, class Tr = std::char_traits<Ch> >
+class basic_ios_exception_saver;
+
+template<class Ch, class Tr = std::char_traits<Ch> >
+class basic_ios_tie_saver;
+
+template<class Ch, class Tr = std::char_traits<Ch> >
+class basic_ios_rdbuf_saver;
+
+template<class Ch, class Tr = std::char_traits<Ch> >
+class basic_ios_fill_saver;
+
+template<class Ch, class Tr = std::char_traits<Ch> >
+class basic_ios_locale_saver;
+
+template<class Ch, class Tr = std::char_traits<Ch> >
+class basic_ios_all_saver;
+
+typedef basic_ios_iostate_saver<char>      ios_iostate_saver;
+typedef basic_ios_iostate_saver<wchar_t>   wios_iostate_saver;
+typedef basic_ios_exception_saver<char>    ios_exception_saver;
+typedef basic_ios_exception_saver<wchar_t> wios_exception_saver;
+typedef basic_ios_tie_saver<char>          ios_tie_saver;
+typedef basic_ios_tie_saver<wchar_t>       wios_tie_saver;
+typedef basic_ios_rdbuf_saver<char>        ios_rdbuf_saver;
+typedef basic_ios_rdbuf_saver<wchar_t>     wios_rdbuf_saver;
+typedef basic_ios_fill_saver<char>         ios_fill_saver;
+typedef basic_ios_fill_saver<wchar_t>      wios_fill_saver;
+typedef basic_ios_locale_saver<char>       ios_locale_saver;
+typedef basic_ios_locale_saver<wchar_t>    wios_locale_saver;
+typedef basic_ios_all_saver<char>          ios_all_saver;
+typedef basic_ios_all_saver<wchar_t>       wios_all_saver;
+
+class ios_iword_saver;
+class ios_pword_saver;
+class ios_all_word_saver;
+
+} // io
+} // boost
+```
+
+## Savers for Basic Standard Attributes
+
+The basic saver classes have this format:
+
+[subs=+quotes]
+```
+class saver {
+public:
+    typedef std::ios_base state_type;
+    typedef `implementation_defined` aspect_type;
+
+    explicit saver(state_type& s);
+    saver(state_type& s, const aspect_type& new_value);
+    ~saver();
+
+    void restore();
+};
+```
+
+The `state_type` is the IOStreams base class `std::ios_base`. The user would
+usually place an actual input, output, or combined stream object for the
+state-type parameter, and not a base class object. The first constructor takes
+a stream object and saves a reference to the stream and the current value of a
+particular stream attribute. The second constructor works like the first, and
+uses its second argument to change the stream's attribute to the new
+`aspect_type` value given. The destructor restores the stream's attribute to
+the saved value. The restoration can be activated early (and often) with the
+`restore` member function.
+
+.Basic IOStreams State Saver Classes
+[%header,cols=5*]
+|===
+|Class |Saved Attribute |Attribute Type |Reading Method |Writing Method
+|`ios_flags_saver`
+|Format control flags
+|`std::ios_base::fmtflags`
+|`flags`
+|`flags`
+|`ios_precision_saver`
+|Number of digits to print after decimal point
+|`std::streamsize`
+|`precision`
+|`precision`
+|`ios_width_saver`
+|Minimum field width for printing objects
+|`std::streamsize`
+|`width`
+|`width`
+|===
+
+## Savers for Advanced Standard Attributes
+
+The saver class templates have this format:
+
+[subs=+quotes]
+```
+template<class Ch, class Tr>
+class saver {
+public:
+    typedef std::basic_ios<Ch, Tr> state_type;
+    typedef `implementation-defined` aspect_type;
+
+    explicit saver(state_type& s);
+    saver(state_type& s, const aspect_type& new_value);
+    ~saver();
+
+    void restore();
+};
+```
+
+The `state_type` is a version of the IOStreams base class template
+`std::basic_ios<Ch, Tr>`, where `Ch` is a character type and `Tr` is a
+character traits class. The user would usually place an actual input,
+output, or combined stream object for the state-type parameter, and not a base
+class object. The first constructor takes a stream object and saves a reference
+to the stream and the current value of a particular stream attribute. The
+second constructor works like the first, and uses its second argument to change
+the stream's attribute to the new `aspect_type` value given. The destructor
+restores the stream's attribute to the saved value. The restoration can be
+activated early (and often) with the `restore` member function.
+
+.Advanced IOStreams State Saver Class Templates
+[%header,cols=5*]
+|===
+|Class |Saved Attribute |Attribute Type |Reading Method |Writing Method
+|`basic_ios_iostate_saver<Ch, Tr>`
+|Failure state of the stream [1], [2]
+|`std::ios_base::iostate`
+|`rdstate`
+|`clear`
+|`basic_ios_exception_saver<Ch, Tr>`
+|Which failure states trigger an exception [1]
+|`std::ios_base::iostate`
+|`exceptions`
+|`exceptions`
+|`basic_ios_tie_saver<Ch, Tr>`
+|Output stream synchronized with the stream
+|`std::basic_ostream<Ch, Tr>*`
+|`tie`
+|`tie`
+|`basic_ios_rdbuf_saver<Ch, Tr>`
+|Stream buffer associated with the stream [2]
+|`std::basic_streambuf<Ch, Tr>*`
+|`rdbuf`
+|`rdbuf`
+|`basic_ios_fill_saver<Ch, Tr>`
+|Character used to pad oversized field widths
+|`Ch`
+|`fill`
+|`fill`
+|`basic_ios_locale_saver<Ch, Tr>`
+|Locale information associated with the stream [3]
+|`std::locale`
+|`getloc` (from `std::ios_base`)
+|`imbue` (from `std::basic_ios<Ch, Tr>`)
+|===
+
+### Notes
+
+1. When the failure state flags and/or the failure state exception watching
+flags are changed, an exception is thrown if a match occurs among the two sets
+of flags. This could mean that the constructor or destructor of these class
+templates may throw.
+2. When the associated stream buffer is changed, the stream's failure state set
+is reset to "good" if the given stream buffer's address is non-NULL, but the
+"bad" failure state is set if that address is NULL. This means that a saved
+failure state of "good" may be restored as "bad" if the stream is stripped of
+an associated stream buffer. Worse, given a NULL stream buffer address, an
+exception is thrown if the "bad" failure state is being watched. This could
+mean that the constructor or destructor of these class templates may throw.
+3. The saver for the locale uses the `std::basic_ios<Ch, Tr>` class to extract
+their information, although it could have used the functionality in
+`std::ios_base`. The problem is that the versions of the needed member
+functions in `ios_base` are not polymorphically related to the ones in
+`basic_ios`. The stream classes that will be used with the saver classes should
+use the versions of the member functions closest to them by inheritance, which
+means the ones in `basic_ios`.
+
+## Savers for User-Defined Attributes
+
+There are three class (templates) for combined attribute savers. The
+`ios_base_all_saver` saver class combines the functionality of all the basic
+attribute saver classes. It has a constructor that takes the stream to have its
+state preserved. The `basic_ios_all_saver` combines the functionality of all
+the advanced attribute saver class templates and the combined basic attribute
+saver class. It has a constructor that takes the stream to have its state
+preserved. The `ios_all_word_saver` saver class combines the saver classes that
+preserve user-defined formatting information. Its constructor takes the stream
+to have its attributes saved and the index of the user-defined attributes. The
+destructor for each class restores the saved state. Restoration can be
+activated early (and often) for a class with the restore member function.
+
+## Example
+
+The code used in the rationale can be improved at two places. The printing
+function could use a saver around the code that changes the formatting state.
+Or the calling function can surround the call with a saver. Or both can be
+done, especially if the user does not know if the printing function uses a
+state saver. If the user wants a series of changes back and forth, without
+surrounding each change within a separate block, the restore member function
+can be called between each trial.
+
+```
+#include <boost/io/ios_state.hpp>
+#include <ios>
+#include <iostream>
+#include <ostream>
+
+void new_hex_my_byte(std::ostream& os, char byte)
+{
+    boost::io::ios_flags_saver ifs(os);
+    os << std::hex << static_cast<unsigned>(byte);
+}
+
+int main()
+{
+    // ...
+    {
+        boost::io::ios_all_saver ias(std::cout);
+        new_hex_my_byte(std::cout, 'A');
+    }
+    // ...
+    {
+        boost::io::ios_all_saver ias(std::cerr);
+        new_hex_my_byte(std::cerr, 'b');
+        ias.restore();
+        new_hex_my_byte(std::cerr, 'C');
+    }
+    // ...
+}
+```
+
+## Credits
+
+### Daryle Walker
+
+Started the library. Contributed the initial versions of the format flags,
+precision, width, and user-defined format flags saver classes. Contributed the
+initial versions of the success state, success state exception flags, output
+stream tie, stream buffer, character fill, and locale saver class templates.
+Contributed the combined attribute classes and class template. Contributed the
+test file `ios_state_test.cpp`.
+
+## History
+
+### 20 Dec 2019
+
+Glen Fernandes made all the saver classes non-copyable.
+
+### 28 Feb 2005
+
+Daryle Walker added the restore member functions, based on suggestions by
+Gennadiy Rozental and Rob Stewart.
+
+### 13 Mar 2002
+
+Daryle Walker implemented the initial version.

externals/vcpkg/buildtrees/boost-io/src/ost-1.79.0-aff9d6facf.clean/doc/nullstream.adoc

@@ -0,0 +1,75 @@
+////
+Copyright 2021 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+////
+
+# Null Streams, <boost/io/nullstream.hpp>
+:toc:
+:toc-title:
+:idprefix:
+
+## Description
+
+The header `<boost/io/nullstream.hpp>` provides the class template
+`boost::io::basic_nullbuf` which is a null stream buffer and class template
+`boost::io::basic_onullstream` which is a null stream.
+
+## Example
+
+The following program passes a null stream to a function.
+
+```
+#include <boost/io/ostream_joiner.hpp>
+#include <fstream>
+
+void setup(std::ostream& log);
+
+int main(int argc, char* argv[])
+{
+    if (argc == 2) {
+        std::ofstream file(argv[1]);
+        setup(file);
+    } else {
+        boost::io::onullstream none;
+        setup(none);
+    }
+}
+```
+
+## Reference
+
+### Header Synopsis
+
+```
+namespace boost {
+namespace io {
+
+template<class CharT, class Traits = std::char_traits<Char> >
+class basic_nullbuf
+    : public std::basic_streambuf<CharT, Traits> {
+protected:
+    typename Traits::int_type overflow(typename Traits::int_type c) override;
+
+    std::streamsize xsputn(const CharT*, std::streamsize n) override;
+};
+
+template<class CharT, class Traits = std::char_traits<CharT> >
+class basic_onullstream
+    : public std::basic_ostream<CharT, Traits> {
+public:
+    basic_onullstream();
+};
+
+typedef basic_onullstream<char> onullstream;
+typedef basic_onullstream<wchar_t> wonullstream;
+
+} // io
+} // boost
+```
+
+## Acknowledgments
+
+Glen Fernandes implemented `basic_nullbuf` and `basic_onullstream`.

externals/vcpkg/buildtrees/boost-io/src/ost-1.79.0-aff9d6facf.clean/doc/ostream_joiner.adoc

@@ -0,0 +1,142 @@
+////
+Copyright 2019 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+////
+
+# Delimited Iterators, <boost/io/ostream_joiner.hpp>
+:toc:
+:toc-title:
+:idprefix:
+
+## Description
+
+The header `<boost/io/ostream_joiner.hpp>` provides the class template
+`boost::io::ostream_joiner` which is an output iterator that writes objects to
+a `std::basic_ostream` separated by a delimiter. It is an implementation of
+the Library Fundamentals TS `std::ostream_joiner` which supports {cpp}03 and
+higher.
+
+## Example
+
+The following program writes the contents of a vector to standard output, with
+each element separated by a comma.
+
+```
+#include <boost/io/ostream_joiner.hpp>
+#include <algorithm>
+#include <iostream>
+#include <vector>
+
+int main()
+{
+    std::vector<int> v;
+    v.push_back(2);
+    v.push_back(4);
+    v.push_back(6);
+    v.push_back(8);
+    std::copy(v.begin(), v.end(), boost::make_ostream_joiner(std::cout, ','));
+}
+```
+
+## Reference
+
+### Header Synopsis
+
+```
+namespace boost {
+namespace io {
+
+template<class Delim, class Char = char,
+    class Traits = std::char_traits<Char> >
+class ostream_joiner {
+public:
+    typedef Char char_type;
+    typedef Traits traits_type;
+    typedef std::basic_ostream<Char, Traits> ostream_type;
+    typedef std::output_iterator_tag iterator_category;
+    typedef void value_type;
+    typedef void difference_type;
+    typedef void pointer;
+    typedef void reference;
+
+    ostream_joiner(ostream_type& output, const Delim& delim);
+    ostream_joiner(ostream_type& output, Delim&& delim);
+
+    template<class T>
+    ostream_joiner& operator=(const T& value);
+
+    ostream_joiner& operator*() noexcept;
+    ostream_joiner& operator++() noexcept;
+    ostream_joiner& operator++(int) noexcept;
+};
+
+template<class Char, class Traits, class Delim>
+ostream_joiner<std::decay_t<Delim>, Char, Traits>
+make_ostream_joiner(std::basic_ostream<Char, Traits>& output, Delim&& delim);
+
+} // io
+} // boost
+```
+
+### Constructors
+
+```
+ostream_joiner(ostream_type& output, const Delim& delim);
+```
+
+[.specification]
+EFfects:: Initializes the stored reference to the stream with
+`std::addressof(output)` and the stored delimiter with `delim`.
+
+```
+ostream_joiner(ostream_type& output, Delim&& delim);
+```
+
+[.specification]
+EFfects:: Initializes the stored reference to the stream with
+`std::addressof(output)` and the stored delimiter with `std::move(delim)`.
+
+### Member functions
+
+```
+template<class T>
+ostream_joiner& operator=(const T& value);
+```
+
+[.specification]
+Effects:: If the is the first call to this member function, write the stored
+delimiter to the stored stream reference. Writes `value` to the stored stream
+reference.
+Returns:: `*this`.
+
+```
+ostream_joiner& operator*() noexcept;
+```
+```
+ostream_joiner& operator++() noexcept;
+```
+```
+ostream_joiner& operator++(int) noexcept;
+```
+
+[.specification]
+Returns:: `*this`.
+
+### Free functions
+
+```
+template<class Char, class Traits, class Delim>
+ostream_joiner<decay_t<Delim>, Char, Traits>
+make_ostream_joiner(std::basic_ostream<Char, Traits>& output, Delim&& delim);
+```
+
+[.specification]
+Returns:: `ostream_joiner<std::decay_t<Delim>, Char, Traits>(output,
+std::forward<Delim>(delim))`.
+
+## Acknowledgments
+
+Glen Fernandes implemented `ostream_joiner` and `make_ostream_joiner`.

externals/vcpkg/buildtrees/boost-io/src/ost-1.79.0-aff9d6facf.clean/doc/ostream_put.adoc

@@ -0,0 +1,73 @@
+////
+Copyright 2019 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+////
+
+# Insert Formatted Output, <boost/io/ostream_put.hpp>
+:toc:
+:toc-title:
+:idprefix:
+
+## Description
+
+The header `<boost/io/ostream_put.hpp>` provides the function template
+`boost::io::ostream_put` for formatted output that satisfies the requirements
+of [ostream.formatted.reqmts].
+
+## Example
+
+The inserter for class template `basic_string_view` could be implemented as
+follows:
+
+```
+template<class charT, class traits>
+std::basic_ostream<charT, traits>&
+operator<<(std::basic_ostream<charT, traits>& os,
+    const basic_string_view<charT, traits>& str)
+{
+    return boost::io::ostream_put(os, str.data(), str.size());
+}
+```
+
+## Reference
+
+### Header Synopsis
+
+```
+namespace boost {
+namespace io {
+
+template<class charT, class traits>
+std::basic_ostream<charT, traits>&
+ostream_put(std::basic_ostream<charT, traits>& os,
+    const charT* data, std::size_t size);
+
+} // io
+} // boost
+```
+
+### Free functions
+
+```
+template<class charT, class traits>
+std::basic_ostream<charT, traits>&
+ostream_put(std::basic_ostream<charT, traits>& os,
+    const charT* data, std::size_t size);
+```
+
+[.specification]
+Effects:: Behaves like a formatted inserter (as described in
+[ostream.formatted.reqmts]) of `os`. Creates a character sequence `seq` of size
+characters starting at `data`, each widened using `os.widen()`
+([basic.ios.members]). Determines padding for `seq` as described in
+[ostream.formatted.reqmts]. Inserts `seq` into `os`. Calls `width(0)`.
+Returns:: `os`.
+
+## Acknowledgments
+
+Glen Fernandes updated the implementation of the `basic_string_ref` and
+`basic_string_view` stream insertion operators to write directly to the
+`basic_streambuf` and refactored that functionality into this common utility.

externals/vcpkg/buildtrees/boost-io/src/ost-1.79.0-aff9d6facf.clean/doc/quoted.adoc

@@ -0,0 +1,145 @@
+////
+Copyright 2019 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+////
+
+# Quoted Manipulators, <boost/io/quoted.hpp>
+:toc:
+:toc-title:
+:idprefix:
+
+## Introduction
+
+C++ Standard library stream I/O for strings that contain embedded spaces can
+produce unexpected results. For example,
+
+```
+std::stringstream ss;
+std::string original = "fooled you";
+std::string roundtrip;
+
+ss << original;
+ss >> roundtrip;
+
+std::cout << original;   // outputs: fooled you
+std::cout << roundtrip; // outputs: fooled
+
+assert(original == roundtrip); // assert will fire
+```
+
+The Boost quoted stream I/O manipulator places delimiters, defaulted to the
+double-quote ("), around strings on output, and strips off the delimiters on
+input. This ensures strings with embedded spaces round-trip as desired. For
+example,
+
+```
+std::stringstream ss;
+std::string original = "fooled you";
+std::string roundtrip;
+
+ss << quoted(original);
+ss >> quoted(roundtrip);
+
+std::cout << quoted(original); // outputs: "fooled you"
+std::cout << roundtrip;       // outputs: fooled you
+
+assert(original == roundtrip); // assert will not fire
+```
+
+If the string contains the delimiter character, on output that character will
+be preceded by an escape character, as will the escape character itself:
+
+```
+std::cout << quoted("'Jack & Jill'", '&', '\''); // outputs: '&'Jack && Jill&''
+```
+
+## Header synopsis
+
+[subs=+quotes]
+```
+namespace boost {
+namespace io {
+
+template<class Char, class Traits, class Alloc>
+`unspecified-type1`
+quoted(const std::basic_string<Char, Traits, Alloc>& string,
+       Char escape='\\', Char delim='\"');
+
+template<class Char>
+`unspecified-type2`
+quoted(const Char* string, Char escape='\\', Char delim='\"');
+
+template<class Char, class Traits, class Alloc>
+`unspecified-type3`
+quoted(std::basic_string<Char, Traits, Alloc>& string,
+       Char escape='\\', Char delim='\"');
+
+} // io
+} // boost
+```
+
+*unspecified-type1*, *unspecified-type2*, and *unspecified-type3* are
+implementation supplied types with implementation supplied `operator<<`:
+
+[subs=+quotes]
+```
+template<class Char, class Traits>
+std::basic_ostream<Char, Traits>&
+operator<<(std::basic_ostream<Char, Traits>& os,
+           const `unspecified-typeN`& proxy);
+```
+
+Effects:: Inserts characters into `os`:
+* `delim`
+* Each character in `string`. If the character to be output is equal to
+`escape` or `delim`, as determined by `operator==`, first output `escape`.
+* `delim`
+Remarks:: `string`, `escape`, and `delim` have the type and value of the
+corresponding arguments of the call to the `quoted` function that constructed
+`proxy`.
+Returns:: `os`.
+
+*unspecified-type3* is an implementation supplied type with an implementation
+supplied `operator>>`:
+
+[subs=+quotes]
+```
+template<class Char, class Traits>
+std::basic_istream<Char, Traits>&
+operator>>(std::basic_istream<Char, Traits>& is,
+           const `unspecified-type3`& proxy);
+```
+
+Effects:: Extracts characters from `os`:
+* If the first character extracted is equal to `delim`, as determined by
+`operator==`, then:
+** Turn off the `skipws` flag.
+** `string.clear()`
+** Until an unescaped `delim` character is reached or `is.not_good()`, extract
+characters from `os` and append them to string, except that if an escape is
+reached, ignore it and append the next character to string.
+** Discard the final `delim` character.
+** Restore the `skipws` flag to its original value.
+* Otherwise, `os >> string`.
+
+Remarks:: `string`, `escape`, and `delim` have the type and value of the
+corresponding arguments of the call to the `quoted` function that constructed
+`proxy`.
+Returns:: `is`.
+
+## Acknowledgements
+
+The `quoted()` stream manipulator emerged from discussions on the Boost
+developers mailing list. Participants included Beman Dawes, Rob Stewart,
+Alexander Lamaison, Eric Niebler, Vicente Botet, Andrey Semashev,
+Phil Richards, and Rob Murray. Eric Niebler's suggestions provided the basis
+for the name and form of the templates.
+
+Beman Dawes started the implementation of `quoted()` as a private detail
+header. Glen Fernandes updated the implementation and also made it public.
+
+Glen Fernandes corrected the implementation to properly account for stream
+width and fill, and optimized it to write directly to the stream buffer.

externals/vcpkg/buildtrees/boost-io/src/ost-1.79.0-aff9d6facf.clean/include/boost/io/detail/buffer_fill.hpp

@@ -0,0 +1,39 @@
+/*
+Copyright 2019-2020 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#ifndef BOOST_IO_DETAIL_BUFFER_FILL_HPP
+#define BOOST_IO_DETAIL_BUFFER_FILL_HPP
+
+#include <iosfwd>
+#include <cstddef>
+
+namespace boost {
+namespace io {
+namespace detail {
+
+template<class charT, class traits>
+inline bool
+buffer_fill(std::basic_streambuf<charT, traits>& buf, charT ch,
+    std::size_t size)
+{
+    charT fill[] = { ch, ch, ch, ch, ch, ch, ch, ch };
+    enum {
+        chunk = sizeof fill / sizeof(charT)
+    };
+    for (; size > chunk; size -= chunk) {
+        if (static_cast<std::size_t>(buf.sputn(fill, chunk)) != chunk) {
+            return false;
+        }
+    }
+    return static_cast<std::size_t>(buf.sputn(fill, size)) == size;
+}
+
+} /* detail */
+} /* io */
+} /* boost */
+
+#endif

externals/vcpkg/buildtrees/boost-io/src/ost-1.79.0-aff9d6facf.clean/include/boost/io/detail/ostream_guard.hpp

@@ -0,0 +1,45 @@
+/*
+Copyright 2019-2020 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#ifndef BOOST_IO_DETAIL_OSTREAM_GUARD_HPP
+#define BOOST_IO_DETAIL_OSTREAM_GUARD_HPP
+
+#include <boost/config.hpp>
+#include <iosfwd>
+
+namespace boost {
+namespace io {
+namespace detail {
+
+template<class Char, class Traits>
+class ostream_guard {
+public:
+    explicit ostream_guard(std::basic_ostream<Char, Traits>& os) BOOST_NOEXCEPT
+        : os_(&os) { }
+
+    ~ostream_guard() BOOST_NOEXCEPT_IF(false) {
+        if (os_) {
+            os_->setstate(std::basic_ostream<Char, Traits>::badbit);
+        }
+    }
+
+    void release() BOOST_NOEXCEPT {
+        os_ = 0;
+    }
+
+private:
+    ostream_guard(const ostream_guard&);
+    ostream_guard& operator=(const ostream_guard&);
+
+    std::basic_ostream<Char, Traits>* os_;
+};
+
+} /* detail */
+} /* io */
+} /* boost */
+
+#endif

externals/vcpkg/buildtrees/boost-io/src/ost-1.79.0-aff9d6facf.clean/include/boost/io/ios_state.hpp

@@ -0,0 +1,485 @@
+/*
+Copyright 2002, 2005 Daryle Walker
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#ifndef BOOST_IO_IOS_STATE_HPP
+#define BOOST_IO_IOS_STATE_HPP
+
+#include <boost/config.hpp>
+#include <boost/io_fwd.hpp>
+#include <ios>
+#ifndef BOOST_NO_STD_LOCALE
+#include <locale>
+#endif
+#include <ostream>
+#include <streambuf>
+#include <string>
+
+namespace boost {
+namespace io {
+
+class ios_flags_saver {
+public:
+    typedef std::ios_base state_type;
+    typedef std::ios_base::fmtflags aspect_type;
+
+    explicit ios_flags_saver(state_type& s)
+        : s_save_(s)
+        , a_save_(s.flags()) { }
+
+    ios_flags_saver(state_type& s, aspect_type a)
+        : s_save_(s)
+        , a_save_(s.flags(a)) { }
+
+    ~ios_flags_saver() {
+        this->restore();
+    }
+
+    void restore() {
+        s_save_.flags(a_save_);
+    }
+
+private:
+    ios_flags_saver(const ios_flags_saver&);
+    ios_flags_saver& operator=(const ios_flags_saver&);
+
+    state_type& s_save_;
+    aspect_type a_save_;
+};
+
+class ios_precision_saver {
+public:
+    typedef std::ios_base state_type;
+    typedef std::streamsize aspect_type;
+
+    explicit ios_precision_saver(state_type& s)
+        : s_save_(s)
+        , a_save_(s.precision()) { }
+
+    ios_precision_saver(state_type& s, aspect_type a)
+        : s_save_(s)
+        , a_save_(s.precision(a)) { }
+
+    ~ios_precision_saver() {
+        this->restore();
+    }
+
+    void restore() {
+        s_save_.precision(a_save_);
+    }
+
+private:
+    ios_precision_saver(const ios_precision_saver&);
+    ios_precision_saver& operator=(const ios_precision_saver&);
+
+    state_type& s_save_;
+    aspect_type a_save_;
+};
+
+class ios_width_saver {
+public:
+    typedef std::ios_base state_type;
+    typedef std::streamsize aspect_type;
+
+    explicit ios_width_saver(state_type& s)
+        : s_save_(s)
+        , a_save_(s.width()) { }
+
+    ios_width_saver(state_type& s, aspect_type a)
+        : s_save_(s)
+        , a_save_(s.width(a)) { }
+
+    ~ios_width_saver() {
+        this->restore();
+    }
+
+    void restore() {
+        s_save_.width(a_save_);
+    }
+
+private:
+    ios_width_saver(const ios_width_saver&);
+    ios_width_saver& operator=(const ios_width_saver&);
+
+    state_type& s_save_;
+    aspect_type a_save_;
+};
+
+template<class Ch, class Tr>
+class basic_ios_iostate_saver {
+public:
+    typedef std::basic_ios<Ch, Tr> state_type;
+    typedef std::ios_base::iostate aspect_type;
+
+    explicit basic_ios_iostate_saver(state_type& s)
+        : s_save_(s)
+        , a_save_(s.rdstate()) { }
+
+    basic_ios_iostate_saver(state_type& s, aspect_type a)
+        : s_save_(s)
+        , a_save_(s.rdstate()) {
+            s.clear(a);
+        }
+
+    ~basic_ios_iostate_saver() {
+        this->restore();
+    }
+
+    void restore() {
+        s_save_.clear(a_save_);
+    }
+
+private:
+    basic_ios_iostate_saver(const basic_ios_iostate_saver&);
+    basic_ios_iostate_saver& operator=(const basic_ios_iostate_saver&);
+
+    state_type& s_save_;
+    aspect_type a_save_;
+};
+
+template<class Ch, class Tr>
+class basic_ios_exception_saver {
+public:
+    typedef std::basic_ios<Ch, Tr> state_type;
+    typedef std::ios_base::iostate aspect_type;
+
+    explicit basic_ios_exception_saver(state_type& s)
+        : s_save_(s)
+        , a_save_(s.exceptions()) { }
+
+    basic_ios_exception_saver(state_type& s, aspect_type a)
+        : s_save_(s)
+        , a_save_(s.exceptions()) {
+        s.exceptions(a);
+    }
+
+    ~basic_ios_exception_saver() {
+        this->restore();
+    }
+
+    void restore() {
+        s_save_.exceptions(a_save_);
+    }
+
+private:
+    basic_ios_exception_saver(const basic_ios_exception_saver&);
+    basic_ios_exception_saver& operator=(const basic_ios_exception_saver&);
+
+    state_type& s_save_;
+    aspect_type a_save_;
+};
+
+template<class Ch, class Tr>
+class basic_ios_tie_saver {
+public:
+    typedef std::basic_ios<Ch, Tr> state_type;
+    typedef std::basic_ostream<Ch, Tr>* aspect_type;
+
+    explicit basic_ios_tie_saver(state_type& s)
+        : s_save_(s)
+        , a_save_(s.tie()) { }
+
+    basic_ios_tie_saver(state_type& s, aspect_type a)
+        : s_save_(s)
+        , a_save_(s.tie(a)) { }
+
+    ~basic_ios_tie_saver() {
+        this->restore();
+    }
+
+    void restore() {
+        s_save_.tie(a_save_);
+    }
+
+private:
+    basic_ios_tie_saver(const basic_ios_tie_saver&);
+    basic_ios_tie_saver& operator=(const basic_ios_tie_saver&);
+
+    state_type& s_save_;
+    aspect_type a_save_;
+};
+
+template<class Ch, class Tr>
+class basic_ios_rdbuf_saver {
+public:
+    typedef std::basic_ios<Ch, Tr> state_type;
+    typedef std::basic_streambuf<Ch, Tr>* aspect_type;
+
+    explicit basic_ios_rdbuf_saver(state_type& s)
+        : s_save_(s)
+        , a_save_(s.rdbuf()) { }
+
+    basic_ios_rdbuf_saver(state_type& s, aspect_type a)
+        : s_save_(s)
+        , a_save_(s.rdbuf(a)) { }
+
+    ~basic_ios_rdbuf_saver() {
+        this->restore();
+    }
+
+    void restore() {
+        s_save_.rdbuf(a_save_);
+    }
+
+private:
+    basic_ios_rdbuf_saver(const basic_ios_rdbuf_saver&);
+    basic_ios_rdbuf_saver& operator=(const basic_ios_rdbuf_saver&);
+
+    state_type& s_save_;
+    aspect_type a_save_;
+};
+
+template<class Ch, class Tr>
+class basic_ios_fill_saver {
+public:
+    typedef std::basic_ios<Ch, Tr> state_type;
+    typedef typename state_type::char_type aspect_type;
+
+    explicit basic_ios_fill_saver(state_type& s)
+        : s_save_(s)
+        , a_save_(s.fill()) { }
+
+    basic_ios_fill_saver(state_type& s, aspect_type a)
+        : s_save_(s)
+        , a_save_(s.fill(a)) { }
+
+    ~basic_ios_fill_saver() {
+        this->restore();
+    }
+
+    void restore() {
+        s_save_.fill(a_save_);
+    }
+
+private:
+    basic_ios_fill_saver(const basic_ios_fill_saver&);
+    basic_ios_fill_saver& operator=(const basic_ios_fill_saver&);
+
+    state_type& s_save_;
+    aspect_type a_save_;
+};
+
+#ifndef BOOST_NO_STD_LOCALE
+template<class Ch, class Tr>
+class basic_ios_locale_saver {
+public:
+    typedef std::basic_ios<Ch, Tr> state_type;
+    typedef std::locale aspect_type;
+
+    explicit basic_ios_locale_saver(state_type& s)
+        : s_save_(s)
+        , a_save_(s.getloc()) { }
+
+    basic_ios_locale_saver(state_type& s, const aspect_type& a)
+        : s_save_(s)
+        , a_save_(s.imbue(a)) { }
+
+    ~basic_ios_locale_saver() {
+        this->restore();
+    }
+
+    void restore() {
+        s_save_.imbue(a_save_);
+    }
+
+private:
+    basic_ios_locale_saver(const basic_ios_locale_saver&);
+    basic_ios_locale_saver& operator=(const basic_ios_locale_saver&);
+
+    state_type& s_save_;
+    aspect_type a_save_;
+};
+#endif
+
+class ios_iword_saver {
+public:
+    typedef std::ios_base state_type;
+    typedef int index_type;
+    typedef long aspect_type;
+
+    explicit ios_iword_saver(state_type& s, index_type i)
+        : s_save_(s)
+        , a_save_(s.iword(i))
+        , i_save_(i) { }
+
+    ios_iword_saver(state_type& s, index_type i, aspect_type a)
+        : s_save_(s)
+        , a_save_(s.iword(i))
+        , i_save_(i) {
+        s.iword(i) = a;
+    }
+
+    ~ios_iword_saver() {
+        this->restore();
+    }
+
+    void restore() {
+        s_save_.iword(i_save_) = a_save_;
+    }
+
+private:
+    ios_iword_saver(const ios_iword_saver&);
+    ios_iword_saver& operator=(const ios_iword_saver&);
+
+    state_type& s_save_;
+    aspect_type a_save_;
+    index_type i_save_;
+};
+
+class ios_pword_saver {
+public:
+    typedef std::ios_base state_type;
+    typedef int index_type;
+    typedef void* aspect_type;
+
+    explicit ios_pword_saver(state_type& s, index_type i)
+        : s_save_(s)
+        , a_save_(s.pword(i))
+        , i_save_(i) { }
+
+    ios_pword_saver(state_type& s, index_type i, aspect_type a)
+        : s_save_(s)
+        , a_save_(s.pword(i))
+        , i_save_(i) {
+        s.pword(i) = a;
+    }
+
+    ~ios_pword_saver() {
+        this->restore();
+    }
+
+    void restore() {
+        s_save_.pword(i_save_) = a_save_;
+    }
+
+private:
+    ios_pword_saver(const ios_pword_saver&);
+    ios_pword_saver operator=(const ios_pword_saver&);
+
+    state_type& s_save_;
+    aspect_type a_save_;
+    index_type i_save_;
+};
+
+class ios_base_all_saver {
+public:
+    typedef std::ios_base state_type;
+
+    explicit ios_base_all_saver(state_type& s)
+        : s_save_(s)
+        , a1_save_(s.flags())
+        , a2_save_(s.precision())
+        , a3_save_(s.width()) { }
+
+    ~ios_base_all_saver() {
+        this->restore();
+    }
+
+    void restore() {
+        s_save_.width(a3_save_);
+        s_save_.precision(a2_save_);
+        s_save_.flags(a1_save_);
+    }
+
+private:
+    ios_base_all_saver(const ios_base_all_saver&);
+    ios_base_all_saver& operator=(const ios_base_all_saver&);
+
+    state_type& s_save_;
+    state_type::fmtflags a1_save_;
+    std::streamsize a2_save_;
+    std::streamsize a3_save_;
+};
+
+template<class Ch, class Tr>
+class basic_ios_all_saver {
+public:
+    typedef std::basic_ios<Ch, Tr> state_type;
+
+    explicit basic_ios_all_saver(state_type& s)
+        : s_save_(s)
+        , a1_save_(s.flags())
+        , a2_save_(s.precision())
+        , a3_save_(s.width())
+        , a4_save_(s.rdstate())
+        , a5_save_(s.exceptions())
+        , a6_save_(s.tie())
+        , a7_save_(s.rdbuf())
+        , a8_save_(s.fill())
+#ifndef BOOST_NO_STD_LOCALE
+        , a9_save_(s.getloc())
+#endif
+        { }
+
+    ~basic_ios_all_saver() {
+        this->restore();
+    }
+
+    void restore() {
+#ifndef BOOST_NO_STD_LOCALE
+        s_save_.imbue(a9_save_);
+#endif
+        s_save_.fill(a8_save_);
+        s_save_.rdbuf(a7_save_);
+        s_save_.tie(a6_save_);
+        s_save_.exceptions(a5_save_);
+        s_save_.clear(a4_save_);
+        s_save_.width(a3_save_);
+        s_save_.precision(a2_save_);
+        s_save_.flags(a1_save_);
+    }
+
+private:
+    basic_ios_all_saver(const basic_ios_all_saver&);
+    basic_ios_all_saver& operator=(const basic_ios_all_saver&);
+
+    state_type& s_save_;
+    typename state_type::fmtflags a1_save_;
+    std::streamsize a2_save_;
+    std::streamsize a3_save_;
+    typename state_type::iostate a4_save_;
+    typename state_type::iostate a5_save_;
+    std::basic_ostream<Ch, Tr>* a6_save_;
+    std::basic_streambuf<Ch, Tr>* a7_save_;
+    typename state_type::char_type a8_save_;
+#ifndef BOOST_NO_STD_LOCALE
+    std::locale a9_save_;
+#endif
+};
+
+class ios_all_word_saver {
+public:
+    typedef std::ios_base state_type;
+    typedef int index_type;
+
+    ios_all_word_saver(state_type& s, index_type i)
+        : s_save_(s)
+        , i_save_(i)
+        , a1_save_(s.iword(i))
+        , a2_save_(s.pword(i)) { }
+
+    ~ios_all_word_saver() {
+        this->restore();
+    }
+
+    void restore() {
+        s_save_.pword(i_save_) = a2_save_;
+        s_save_.iword(i_save_) = a1_save_;
+    }
+
+private:
+    ios_all_word_saver(const ios_all_word_saver&);
+    ios_all_word_saver& operator=(const ios_all_word_saver&);
+
+    state_type& s_save_;
+    index_type i_save_;
+    long a1_save_;
+    void* a2_save_;
+};
+
+} /* io */
+} /* boost */
+
+#endif

externals/vcpkg/buildtrees/boost-io/src/ost-1.79.0-aff9d6facf.clean/include/boost/io/nullstream.hpp

@@ -0,0 +1,57 @@
+/*
+Copyright 2021 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#ifndef BOOST_IO_NULLSTREAM_HPP
+#define BOOST_IO_NULLSTREAM_HPP
+
+#include <boost/config.hpp>
+#include <ostream>
+#include <streambuf>
+
+namespace boost {
+namespace io {
+
+template<class CharT, class Traits = std::char_traits<CharT> >
+class basic_nullbuf
+    : public std::basic_streambuf<CharT, Traits> {
+protected:
+    typename Traits::int_type overflow(typename Traits::int_type c)
+        BOOST_OVERRIDE {
+        return Traits::not_eof(c);
+    }
+
+    std::streamsize xsputn(const CharT*, std::streamsize n) BOOST_OVERRIDE {
+        return n;
+    }
+};
+
+namespace detail {
+
+template<class CharT, class Traits>
+struct nullbuf {
+    boost::io::basic_nullbuf<CharT, Traits> buf;
+};
+
+} /* detail */
+
+template<class CharT, class Traits = std::char_traits<CharT> >
+class basic_onullstream
+    : detail::nullbuf<CharT, Traits>
+    , public std::basic_ostream<CharT, Traits> {
+public:
+    basic_onullstream()
+        : std::basic_ostream<CharT, Traits>(&(detail::nullbuf<CharT,
+             Traits>::buf)) { }
+};
+
+typedef basic_onullstream<char> onullstream;
+typedef basic_onullstream<wchar_t> wonullstream;
+
+} /* io */
+} /* boost */
+
+#endif

externals/vcpkg/buildtrees/boost-io/src/ost-1.79.0-aff9d6facf.clean/include/boost/io/ostream_joiner.hpp

@@ -0,0 +1,118 @@
+/*
+Copyright 2019 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#ifndef BOOST_IO_OSTREAM_JOINER_HPP
+#define BOOST_IO_OSTREAM_JOINER_HPP
+
+#include <boost/config.hpp>
+#include <ostream>
+#include <string>
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+#if !defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS)
+#include <type_traits>
+#endif
+#include <utility>
+#endif
+
+namespace boost {
+namespace io {
+namespace detail {
+
+#if !defined(BOOST_NO_CXX11_ADDRESSOF)
+template<class T>
+inline T*
+osj_address(T& o)
+{
+    return std::addressof(o);
+}
+#else
+template<class T>
+inline T*
+osj_address(T& obj)
+{
+    return &obj;
+}
+#endif
+
+} /* detail */
+
+template<class Delim, class Char = char,
+    class Traits = std::char_traits<Char> >
+class ostream_joiner {
+public:
+    typedef Char char_type;
+    typedef Traits traits_type;
+    typedef std::basic_ostream<Char, Traits> ostream_type;
+    typedef std::output_iterator_tag iterator_category;
+    typedef void value_type;
+    typedef void difference_type;
+    typedef void pointer;
+    typedef void reference;
+
+    ostream_joiner(ostream_type& output, const Delim& delim)
+        : output_(detail::osj_address(output))
+        , delim_(delim)
+        , first_(true) { }
+
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+    ostream_joiner(ostream_type& output, Delim&& delim)
+        : output_(detail::osj_address(output))
+        , delim_(std::move(delim))
+        , first_(true) { }
+#endif
+
+    template<class T>
+    ostream_joiner& operator=(const T& value) {
+        if (!first_) {
+            *output_ << delim_;
+        }
+        first_ = false;
+        *output_ << value;
+        return *this;
+    }
+
+    ostream_joiner& operator*() BOOST_NOEXCEPT {
+        return *this;
+    }
+
+    ostream_joiner& operator++() BOOST_NOEXCEPT {
+        return *this;
+    }
+
+    ostream_joiner& operator++(int) BOOST_NOEXCEPT {
+        return *this;
+    }
+
+private:
+    ostream_type* output_;
+    Delim delim_;
+    bool first_;
+};
+
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && \
+    !defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS)
+template<class Char, class Traits, class Delim>
+inline ostream_joiner<typename std::decay<Delim>::type, Char, Traits>
+make_ostream_joiner(std::basic_ostream<Char, Traits>& output, Delim&& delim)
+{
+    return ostream_joiner<typename std::decay<Delim>::type, Char,
+        Traits>(output, std::forward<Delim>(delim));
+}
+#else
+template<class Char, class Traits, class Delim>
+inline ostream_joiner<Delim, Char, Traits>
+make_ostream_joiner(std::basic_ostream<Char, Traits>& output,
+    const Delim& delim)
+{
+    return ostream_joiner<Delim, Char, Traits>(output, delim);
+}
+#endif
+
+} /* io */
+} /* boost */
+
+#endif

externals/vcpkg/buildtrees/boost-io/src/ost-1.79.0-aff9d6facf.clean/include/boost/io/ostream_put.hpp

@@ -0,0 +1,50 @@
+/*
+Copyright 2019 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#ifndef BOOST_IO_OSTREAM_PUT_HPP
+#define BOOST_IO_OSTREAM_PUT_HPP
+
+#include <boost/io/detail/buffer_fill.hpp>
+#include <boost/io/detail/ostream_guard.hpp>
+
+namespace boost {
+namespace io {
+
+template<class charT, class traits>
+inline std::basic_ostream<charT, traits>&
+ostream_put(std::basic_ostream<charT, traits>& os, const charT* data,
+    std::size_t size)
+{
+    typedef std::basic_ostream<charT, traits> stream;
+    detail::ostream_guard<charT, traits> guard(os);
+    typename stream::sentry entry(os);
+    if (entry) {
+        std::basic_streambuf<charT, traits>& buf = *os.rdbuf();
+        std::size_t width = static_cast<std::size_t>(os.width());
+        if (width <= size) {
+            if (static_cast<std::size_t>(buf.sputn(data, size)) != size) {
+                return os;
+            }
+        } else if ((os.flags() & stream::adjustfield) == stream::left) {
+            if (static_cast<std::size_t>(buf.sputn(data, size)) != size ||
+                !detail::buffer_fill(buf, os.fill(), width - size)) {
+                return os;
+            }
+        } else if (!detail::buffer_fill(buf, os.fill(), width - size) ||
+            static_cast<std::size_t>(buf.sputn(data, size)) != size) {
+            return os;
+        }
+        os.width(0);
+    }
+    guard.release();
+    return os;
+}
+
+} /* io */
+} /* boost */
+
+#endif

externals/vcpkg/buildtrees/boost-io/src/ost-1.79.0-aff9d6facf.clean/include/boost/io/quoted.hpp

@@ -0,0 +1,217 @@
+/*
+Copyright 2010 Beman Dawes
+
+Copyright 2019-2020 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#ifndef BOOST_IO_QUOTED_HPP
+#define BOOST_IO_QUOTED_HPP
+
+#include <boost/io/detail/buffer_fill.hpp>
+#include <boost/io/detail/ostream_guard.hpp>
+#include <boost/io/ios_state.hpp>
+
+namespace boost {
+namespace io {
+namespace detail {
+
+template<class String, class Char>
+struct quoted_proxy {
+    String string;
+    Char escape;
+    Char delim;
+};
+
+template<class Char>
+struct quoted_state {
+    const Char* string;
+    std::size_t size;
+    std::size_t count;
+};
+
+template<class Char>
+inline quoted_state<Char>
+quoted_start(const Char* string, Char escape, Char delim)
+{
+    const Char* end = string;
+    std::size_t count = 2;
+    for (Char ch; (ch = *end) != 0; ++end) {
+        count += 1 + (ch == escape || ch == delim);
+    }
+    quoted_state<Char> state = { string,
+        static_cast<std::size_t>(end - string), count };
+    return state;
+}
+
+template<class Char, class String>
+inline quoted_state<Char>
+quoted_start(const String* string, Char escape, Char delim)
+{
+    const Char* begin = string->data();
+    std::size_t size = string->size();
+    std::size_t count = 2;
+    for (const Char *it = begin, *end = begin + size; it != end; ++it) {
+        Char ch = *it;
+        count += 1 + (ch == escape || ch == delim);
+    }
+    quoted_state<Char> state = { begin, size, count };
+    return state;
+}
+
+template<class Char, class Traits>
+inline bool
+quoted_put(std::basic_streambuf<Char, Traits>& buf, const Char* string,
+    std::size_t size, std::size_t count, Char escape, Char delim)
+{
+    if (buf.sputc(delim) == Traits::eof()) {
+        return false;
+    }
+    if (size == count) {
+        if (static_cast<std::size_t>(buf.sputn(string, size)) != size) {
+            return false;
+        }
+    } else {
+        for (const Char* end = string + size; string != end; ++string) {
+            Char ch = *string;
+            if ((ch == escape || ch == delim) &&
+                buf.sputc(escape) == Traits::eof()) {
+                return false;
+            }
+            if (buf.sputc(ch) == Traits::eof()) {
+                return false;
+            }
+        }
+    }
+    return buf.sputc(delim) != Traits::eof();
+}
+
+template<class Char, class Traits, class String>
+inline std::basic_ostream<Char, Traits>&
+quoted_out(std::basic_ostream<Char, Traits>& os, String* string, Char escape,
+    Char delim)
+{
+    typedef std::basic_ostream<Char, Traits> stream;
+    ostream_guard<Char, Traits> guard(os);
+    typename stream::sentry entry(os);
+    if (entry) {
+        quoted_state<Char> state = boost::io::detail::quoted_start(string,
+            escape, delim);
+        std::basic_streambuf<Char, Traits>& buf = *os.rdbuf();
+        std::size_t width = static_cast<std::size_t>(os.width());
+        if (width <= state.count) {
+            if (!boost::io::detail::quoted_put(buf, state.string, state.size,
+                state.count, escape, delim)) {
+                return os;
+            }
+        } else if ((os.flags() & stream::adjustfield) == stream::left) {
+            if (!boost::io::detail::quoted_put(buf, state.string, state.size,
+                    state.count, escape, delim) ||
+                !boost::io::detail::buffer_fill(buf, os.fill(),
+                    width - state.count)) {
+                return os;
+            }
+        } else if (!boost::io::detail::buffer_fill(buf, os.fill(),
+                width - state.count) ||
+            !boost::io::detail::quoted_put(buf, state.string, state.size,
+                state.count, escape, delim)) {
+            return os;
+        }
+        os.width(0);
+    }
+    guard.release();
+    return os;
+}
+
+template<class Char, class Traits>
+inline std::basic_ostream<Char, Traits>&
+operator<<(std::basic_ostream<Char, Traits>& os,
+    const quoted_proxy<const Char*, Char>& proxy)
+{
+    return boost::io::detail::quoted_out(os, proxy.string, proxy.escape,
+        proxy.delim);
+}
+
+template <class Char, class Traits, class Alloc>
+inline std::basic_ostream<Char, Traits>&
+operator<<(std::basic_ostream<Char, Traits>& os,
+    const quoted_proxy<const std::basic_string<Char, Traits, Alloc>*,
+        Char>& proxy)
+{
+    return boost::io::detail::quoted_out(os, proxy.string, proxy.escape,
+        proxy.delim);
+}
+
+template<class Char, class Traits, class Alloc>
+inline std::basic_ostream<Char, Traits>&
+operator<<(std::basic_ostream<Char, Traits>& os,
+    const quoted_proxy<std::basic_string<Char, Traits, Alloc>*, Char>& proxy)
+{
+    return boost::io::detail::quoted_out(os, proxy.string, proxy.escape,
+        proxy.delim);
+}
+
+template<class Char, class Traits, class Alloc>
+inline std::basic_istream<Char, Traits>&
+operator>>(std::basic_istream<Char, Traits>& is,
+    const quoted_proxy<std::basic_string<Char, Traits, Alloc>*, Char>& proxy)
+{
+    Char ch;
+    if (!(is >> ch)) {
+        return is;
+    }
+    if (ch != proxy.delim) {
+        is.unget();
+        return is >> *proxy.string;
+    }
+    {
+        boost::io::ios_flags_saver ifs(is);
+        std::noskipws(is);
+        proxy.string->clear();
+        while ((is >> ch) && ch != proxy.delim) {
+            if (ch == proxy.escape && !(is >> ch)) {
+                break;
+            }
+            proxy.string->push_back(ch);
+        }
+    }
+    return is;
+}
+
+} /* detail */
+
+template<class Char, class Traits, class Alloc>
+inline detail::quoted_proxy<const std::basic_string<Char, Traits, Alloc>*,
+    Char>
+quoted(const std::basic_string<Char, Traits, Alloc>& s, Char escape='\\',
+    Char delim='\"')
+{
+    detail::quoted_proxy<const std::basic_string<Char, Traits, Alloc>*,
+        Char> proxy = { &s, escape, delim };
+    return proxy;
+}
+
+template<class Char, class Traits, class Alloc>
+inline detail::quoted_proxy<std::basic_string<Char, Traits, Alloc>*, Char>
+quoted(std::basic_string<Char, Traits, Alloc>& s, Char escape='\\',
+    Char delim='\"')
+{
+    detail::quoted_proxy<std::basic_string<Char, Traits, Alloc>*,
+        Char> proxy = { &s, escape, delim };
+    return proxy;
+}
+
+template<class Char>
+inline detail::quoted_proxy<const Char*, Char>
+quoted(const Char* s, Char escape='\\', Char delim='\"')
+{
+    detail::quoted_proxy<const Char*, Char> proxy = { s, escape, delim };
+    return proxy;
+}
+
+} /* io */
+} /* boost */
+
+#endif

externals/vcpkg/buildtrees/boost-io/src/ost-1.79.0-aff9d6facf.clean/include/boost/io_fwd.hpp

@@ -0,0 +1,63 @@
+/*
+Copyright 2002 Daryle Walker
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#ifndef BOOST_IO_FWD_HPP
+#define BOOST_IO_FWD_HPP
+
+#include <iosfwd>
+
+namespace boost {
+namespace io {
+
+class ios_flags_saver;
+class ios_precision_saver;
+class ios_width_saver;
+class ios_base_all_saver;
+
+template<class Ch, class Tr = std::char_traits<Ch> >
+class basic_ios_iostate_saver;
+
+template<class Ch, class Tr = std::char_traits<Ch> >
+class basic_ios_exception_saver;
+
+template<class Ch, class Tr = std::char_traits<Ch> >
+class basic_ios_tie_saver;
+
+template<class Ch, class Tr = std::char_traits<Ch> >
+class basic_ios_rdbuf_saver;
+
+template<class Ch, class Tr = std::char_traits<Ch> >
+class basic_ios_fill_saver;
+
+template<class Ch, class Tr = std::char_traits<Ch> >
+class basic_ios_locale_saver;
+
+template<class Ch, class Tr = std::char_traits<Ch> >
+class basic_ios_all_saver;
+
+typedef basic_ios_iostate_saver<char>      ios_iostate_saver;
+typedef basic_ios_iostate_saver<wchar_t>   wios_iostate_saver;
+typedef basic_ios_exception_saver<char>    ios_exception_saver;
+typedef basic_ios_exception_saver<wchar_t> wios_exception_saver;
+typedef basic_ios_tie_saver<char>          ios_tie_saver;
+typedef basic_ios_tie_saver<wchar_t>       wios_tie_saver;
+typedef basic_ios_rdbuf_saver<char>        ios_rdbuf_saver;
+typedef basic_ios_rdbuf_saver<wchar_t>     wios_rdbuf_saver;
+typedef basic_ios_fill_saver<char>         ios_fill_saver;
+typedef basic_ios_fill_saver<wchar_t>      wios_fill_saver;
+typedef basic_ios_locale_saver<char>       ios_locale_saver;
+typedef basic_ios_locale_saver<wchar_t>    wios_locale_saver;
+typedef basic_ios_all_saver<char>          ios_all_saver;
+typedef basic_ios_all_saver<wchar_t>       wios_all_saver;
+
+class ios_iword_saver;
+class ios_pword_saver;
+class ios_all_word_saver;
+
+} /* io */
+} /* boost */
+
+#endif

externals/vcpkg/buildtrees/boost-io/src/ost-1.79.0-aff9d6facf.clean/index.html

@@ -0,0 +1,17 @@
+<!DOCTYPE html>
+<!--
+Copyright Beman Dawes, 2001
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+-->
+<html>
+<head>
+<meta charset="utf-8">
+<meta http-equiv="refresh" content="0; url=doc/html/io.html">
+<title>IO</title>
+</head>
+<body>
+Redirecting you to <a href="doc/html/io.html">IO</a>.
+</body>
+</html>

externals/vcpkg/buildtrees/boost-io/src/ost-1.79.0-aff9d6facf.clean/meta/libraries.json

@@ -0,0 +1,18 @@
+{
+    "key": "io",
+    "name": "IO",
+    "authors": [
+        "Daryle Walker",
+        "Beman Dawes",
+        "Glen Fernandes"
+    ],
+    "description": "Utilities for the standard I/O library.",
+    "documentation": "doc/html/io.html",
+    "category": [
+        "IO"
+    ],
+    "maintainers": [
+        "Glen Fernandes <glenjofe -at- gmail.com>"
+    ],
+    "cxxstd": "03"
+}

externals/vcpkg/buildtrees/boost-io/src/ost-1.79.0-aff9d6facf.clean/test/Jamfile

@@ -0,0 +1,20 @@
+# Copyright 2003 Daryle Walker
+#
+# Copyright 2019 Glen Joseph Fernandes
+# (glenjofe@gmail.com)
+#
+# Distributed under the Boost Software License, Version 1.0.
+# (http://www.boost.org/LICENSE_1_0.txt)
+
+import testing ;
+
+project : requirements <warnings>pedantic <warnings-as-errors>on ;
+
+run ios_state_unit_test.cpp ;
+run ios_state_test.cpp ;
+run quoted_test.cpp ;
+run quoted_fill_test.cpp ;
+run ostream_joiner_test.cpp ;
+run make_ostream_joiner_test.cpp ;
+run ostream_put_test.cpp ;
+run nullstream_test.cpp ;

externals/vcpkg/buildtrees/boost-io/src/ost-1.79.0-aff9d6facf.clean/test/ios_state_test.cpp

@@ -0,0 +1,171 @@
+/*
+Copyright 2002, 2003 Daryle Walker
+
+Copyright 2019 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#include <boost/io/ios_state.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/config.hpp>
+#include <iomanip>
+#include <ios>
+#include <istream>
+#include <locale>
+#include <ostream>
+#include <sstream>
+#if defined(BOOST_GCC) || (defined(BOOST_CLANG) && defined(BOOST_GNU_STDLIB))
+#include <stdexcept>
+#endif
+#include <streambuf>
+#include <string>
+#include <cstddef>
+
+class backward_bool_names
+    : public std::numpunct<char> {
+    typedef std::numpunct<char> base_type;
+
+public:
+    explicit backward_bool_names(std::size_t refs = 0)
+        : base_type( refs ) { }
+
+protected:
+    ~backward_bool_names() { }
+
+    base_type::string_type do_truename() const {
+        return "eurt";
+    }
+
+    base_type::string_type do_falsename() const {
+        return "eslaf";
+    }
+};
+
+void saver_tests_1(int index,
+    std::istream& input,
+    std::ostream& output,
+    std::ostream& err)
+{
+    boost::io::ios_flags_saver     ifls(output);
+    boost::io::ios_precision_saver iprs(output);
+    boost::io::ios_width_saver     iws(output);
+    boost::io::ios_tie_saver       its(input);
+    boost::io::ios_rdbuf_saver     irs(output);
+    boost::io::ios_fill_saver      ifis(output);
+    boost::io::ios_locale_saver    ils(output);
+    boost::io::ios_iword_saver     iis(output, index);
+    boost::io::ios_pword_saver     ipws(output, index);
+    std::locale loc(std::locale::classic(), new backward_bool_names);
+    input.tie(&err);
+    output.rdbuf(err.rdbuf());
+    output.iword(index) = 69L;
+    output.pword(index) = &err;
+    output.setf(std::ios_base::showpos | std::ios_base::boolalpha);
+    output.setf(std::ios_base::internal, std::ios_base::adjustfield);
+    output.fill('@');
+    output.precision( 9 );
+    output << "Hello world";
+    output << std::setw(10) << -16;
+    output << std::setw(15) << 34.5678901234;
+    output.imbue(loc);
+    output << true;
+    BOOST_TEST(&err == output.pword(index));
+    BOOST_TEST(69L == output.iword(index));
+    try {
+        boost::io::ios_exception_saver ies(output);
+        boost::io::ios_iostate_saver ias(output);
+        output.exceptions(std::ios_base::eofbit | std::ios_base::badbit);
+        output.setstate(std::ios_base::eofbit);
+        BOOST_ERROR("previous line should have thrown");
+#if defined(BOOST_GCC) || (defined(BOOST_CLANG) && defined(BOOST_GNU_STDLIB))
+    } catch (std::exception&) {
+#else
+    } catch (std::ios_base::failure&) {
+#endif
+        BOOST_TEST(output.exceptions() == std::ios_base::goodbit );
+    }
+}
+
+void saver_tests_2(int index,
+    std::istream& input,
+    std::ostream& output,
+    std::ostream& err)
+{
+    boost::io::ios_tie_saver   its(input, &err);
+    boost::io::ios_rdbuf_saver irs(output, err.rdbuf());
+    boost::io::ios_iword_saver iis(output, index, 69L);
+    boost::io::ios_pword_saver ipws(output, index, &err);
+    boost::io::ios_flags_saver ifls(output,
+        (output.flags() & ~std::ios_base::adjustfield) |
+        std::ios_base::showpos |
+        std::ios_base::boolalpha |
+        (std::ios_base::internal & std::ios_base::adjustfield));
+    boost::io::ios_precision_saver iprs(output, 9);
+    boost::io::ios_fill_saver ifis(output, '@');
+    output << "Hello world";
+    boost::io::ios_width_saver iws(output, 12);
+    output << -16 + 34.5678901234;
+    std::locale loc(std::locale::classic(), new backward_bool_names);
+    boost::io::ios_locale_saver ils(output, loc);
+    output << true;
+    BOOST_TEST(&err == output.pword(index));
+    BOOST_TEST(69L == output.iword(index));
+    try {
+        boost::io::ios_exception_saver ies(output, std::ios_base::eofbit);
+        boost::io::ios_iostate_saver ias(output,
+            output.rdstate() | std::ios_base::eofbit );
+        BOOST_ERROR("previous line should have thrown");
+#if defined(BOOST_GCC) || (defined(BOOST_CLANG) && defined(BOOST_GNU_STDLIB))
+    } catch (std::exception&) {
+#else
+    } catch (std::ios_base::failure&) {
+#endif
+        BOOST_TEST(output.exceptions() == std::ios_base::goodbit);
+    }
+}
+
+int main()
+{
+    int index = std::ios_base::xalloc();
+    std::ostringstream out;
+    std::ostringstream err;
+    std::istringstream in;
+    std::ios_base::fmtflags out_flags = out.flags();
+    std::streamsize         out_precision = out.precision();
+    std::streamsize         out_width = out.width();
+    std::ios_base::iostate  out_iostate = out.rdstate();
+    std::ios_base::iostate  out_exceptions = out.exceptions();
+    std::ostream*           in_tie = in.tie();
+    std::streambuf*         out_sb = out.rdbuf();
+    char                    out_fill = out.fill();
+    std::locale             out_locale = out.getloc();
+    out.iword(index) = 42L;
+    out.pword(index) = &in;
+    saver_tests_1(index, in, out, err);
+    BOOST_TEST(&in == out.pword(index));
+    BOOST_TEST(42L == out.iword(index));
+    BOOST_TEST(out_locale == out.getloc());
+    BOOST_TEST(out_fill == out.fill());
+    BOOST_TEST(out_sb == out.rdbuf());
+    BOOST_TEST(in_tie == in.tie());
+    BOOST_TEST(out_exceptions == out.exceptions());
+    BOOST_TEST(out_iostate == out.rdstate());
+    BOOST_TEST(out_width == out.width());
+    BOOST_TEST(out_precision == out.precision());
+    BOOST_TEST(out_flags == out.flags());
+    saver_tests_2(index, in, out, err);
+    BOOST_TEST(&in == out.pword(index));
+    BOOST_TEST(42L == out.iword(index));
+    BOOST_TEST(out_locale == out.getloc());
+    BOOST_TEST(out_fill == out.fill());
+    BOOST_TEST(out_sb == out.rdbuf());
+    BOOST_TEST(in_tie == in.tie());
+    BOOST_TEST(out_exceptions == out.exceptions());
+    BOOST_TEST(out_iostate == out.rdstate());
+    BOOST_TEST(out_width == out.width());
+    BOOST_TEST(out_precision == out.precision());
+    BOOST_TEST(out_flags == out.flags());
+    return boost::report_errors();
+}

externals/vcpkg/buildtrees/boost-io/src/ost-1.79.0-aff9d6facf.clean/test/ios_state_unit_test.cpp

@@ -0,0 +1,461 @@
+/*
+Copyright 2003 Daryle Walker
+
+Copyright 2019 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#include <boost/io/ios_state.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/config.hpp>
+#include <iomanip>
+#include <ios>
+#include <iostream>
+#include <istream>
+#include <locale>
+#if defined(BOOST_GCC) || (defined(BOOST_CLANG) && defined(BOOST_GNU_STDLIB))
+#include <stdexcept>
+#endif
+#include <sstream>
+#include <cstddef>
+
+class backward_bool_names
+    : public std::numpunct<char> {
+    typedef std::numpunct<char> base_type;
+
+public:
+    explicit backward_bool_names(std::size_t refs = 0)
+        : base_type(refs) { }
+
+protected:
+    ~backward_bool_names() { }
+
+    base_type::string_type do_truename() const {
+        return "eurt";
+    }
+
+    base_type::string_type do_falsename() const {
+        return "eslaf";
+    }
+};
+
+void
+ios_flags_saver_unit_test()
+{
+    std::stringstream ss;
+    BOOST_TEST_EQ(std::ios_base::skipws | std::ios_base::dec, ss.flags());
+    {
+        boost::io::ios_flags_saver ifs(ss);
+        BOOST_TEST_EQ(std::ios_base::skipws | std::ios_base::dec, ss.flags());
+        ss << std::noskipws << std::fixed << std::boolalpha;
+        BOOST_TEST_EQ(std::ios_base::boolalpha |
+            std::ios_base::dec |
+            std::ios_base::fixed, ss.flags());
+    }
+    BOOST_TEST_EQ(std::ios_base::skipws | std::ios_base::dec, ss.flags());
+    {
+        boost::io::ios_flags_saver ifs(ss,
+            std::ios_base::showbase | std::ios_base::internal);
+        BOOST_TEST_EQ(std::ios_base::showbase |
+            std::ios_base::internal, ss.flags());
+        ss << std::setiosflags(std::ios_base::unitbuf);
+        BOOST_TEST_EQ(std::ios_base::showbase |
+            std::ios_base::internal |
+            std::ios_base::unitbuf, ss.flags());
+    }
+    BOOST_TEST_EQ(std::ios_base::skipws | std::ios_base::dec, ss.flags());
+}
+
+void
+ios_precision_saver_unit_test()
+{
+    std::stringstream ss;
+    BOOST_TEST_EQ(6, ss.precision());
+    {
+        boost::io::ios_precision_saver ips(ss);
+        BOOST_TEST_EQ(6, ss.precision());
+        ss << std::setprecision(4);
+        BOOST_TEST_EQ(4, ss.precision());
+    }
+    BOOST_TEST_EQ(6, ss.precision());
+    {
+        boost::io::ios_precision_saver ips(ss, 8);
+        BOOST_TEST_EQ(8, ss.precision());
+        ss << std::setprecision(10);
+        BOOST_TEST_EQ(10, ss.precision());
+    }
+    BOOST_TEST_EQ(6, ss.precision());
+}
+
+void
+ios_width_saver_unit_test()
+{
+    std::stringstream ss;
+    BOOST_TEST_EQ(0, ss.width());
+    {
+        boost::io::ios_width_saver iws(ss);
+        BOOST_TEST_EQ(0, ss.width());
+        ss << std::setw(4);
+        BOOST_TEST_EQ(4, ss.width());
+    }
+    BOOST_TEST_EQ(0, ss.width());
+    {
+        boost::io::ios_width_saver iws(ss, 8);
+        BOOST_TEST_EQ(8, ss.width());
+        ss << std::setw(10);
+        BOOST_TEST_EQ(10, ss.width());
+    }
+    BOOST_TEST_EQ(0, ss.width());
+}
+
+void
+ios_iostate_saver_unit_test()
+{
+    std::stringstream ss;
+    BOOST_TEST_EQ(std::ios_base::goodbit, ss.rdstate());
+    BOOST_TEST(ss.good());
+    {
+        boost::io::ios_iostate_saver iis(ss);
+        char c;
+        BOOST_TEST_EQ(std::ios_base::goodbit, ss.rdstate());
+        BOOST_TEST(ss.good());
+        ss >> c;
+        BOOST_TEST_EQ(std::ios_base::eofbit | std::ios_base::failbit,
+            ss.rdstate());
+        BOOST_TEST(ss.eof());
+        BOOST_TEST(ss.fail());
+        BOOST_TEST(!ss.bad());
+    }
+    BOOST_TEST_EQ(std::ios_base::goodbit, ss.rdstate());
+    BOOST_TEST(ss.good());
+    {
+        boost::io::ios_iostate_saver iis(ss, std::ios_base::eofbit);
+        BOOST_TEST_EQ(std::ios_base::eofbit, ss.rdstate());
+        BOOST_TEST(ss.eof());
+        ss.setstate(std::ios_base::badbit);
+        BOOST_TEST_EQ(std::ios_base::eofbit | std::ios_base::badbit,
+            ss.rdstate());
+        BOOST_TEST(ss.eof());
+        BOOST_TEST(ss.fail());
+        BOOST_TEST(ss.bad());
+    }
+    BOOST_TEST_EQ(std::ios_base::goodbit, ss.rdstate());
+    BOOST_TEST(ss.good());
+}
+
+void
+ios_exception_saver_unit_test()
+{
+    std::stringstream ss;
+    BOOST_TEST_EQ(std::ios_base::goodbit, ss.exceptions());
+    {
+        boost::io::ios_exception_saver ies(ss);
+        BOOST_TEST_EQ(std::ios_base::goodbit, ss.exceptions());
+        ss.exceptions(std::ios_base::failbit);
+        BOOST_TEST_EQ(std::ios_base::failbit, ss.exceptions());
+        {
+            boost::io::ios_iostate_saver iis(ss);
+            ss.exceptions(std::ios_base::failbit | std::ios_base::badbit);
+            char c;
+#if defined(BOOST_GCC) || (defined(BOOST_CLANG) && defined(BOOST_GNU_STDLIB))
+            BOOST_TEST_THROWS(ss >> c, std::exception);
+#else
+            BOOST_TEST_THROWS(ss >> c, std::ios_base::failure);
+#endif
+        }
+    }
+    BOOST_TEST_EQ(std::ios_base::goodbit, ss.exceptions());
+    {
+        boost::io::ios_exception_saver ies(ss, std::ios_base::eofbit);
+        BOOST_TEST_EQ(std::ios_base::eofbit, ss.exceptions());
+        ss.exceptions(std::ios_base::badbit);
+        BOOST_TEST_EQ(std::ios_base::badbit, ss.exceptions());
+        {
+            boost::io::ios_iostate_saver iis(ss);
+            char c;
+            BOOST_TEST_NOT(ss >> c);
+        }
+    }
+    BOOST_TEST_EQ(std::ios_base::goodbit, ss.exceptions());
+}
+
+void
+ios_tie_saver_unit_test()
+{
+    BOOST_TEST(NULL == std::cout.tie());
+    {
+        boost::io::ios_tie_saver its(std::cout);
+        BOOST_TEST(NULL == std::cout.tie());
+        std::cout.tie(&std::clog);
+        BOOST_TEST_EQ(&std::clog, std::cout.tie());
+    }
+    BOOST_TEST(NULL == std::cout.tie());
+    {
+        boost::io::ios_tie_saver its(std::cout, &std::clog);
+        BOOST_TEST_EQ(&std::clog, std::cout.tie());
+        std::cout.tie(&std::cerr);
+        BOOST_TEST_EQ(&std::cerr, std::cout.tie());
+    }
+    BOOST_TEST(NULL == std::cout.tie());
+}
+
+void
+ios_rdbuf_saver_unit_test()
+{
+    std::iostream s(NULL);
+    BOOST_TEST(NULL == s.rdbuf());
+    {
+        std::stringbuf sb;
+        boost::io::ios_rdbuf_saver irs(s);
+        BOOST_TEST(NULL == s.rdbuf());
+        s.rdbuf(&sb);
+        BOOST_TEST_EQ(&sb, s.rdbuf());
+    }
+    BOOST_TEST(NULL == s.rdbuf());
+    {
+        std::stringbuf sb1, sb2("Hi there");
+        boost::io::ios_rdbuf_saver irs(s, &sb1);
+        BOOST_TEST_EQ(&sb1, s.rdbuf());
+        s.rdbuf(&sb2);
+        BOOST_TEST_EQ(&sb2, s.rdbuf());
+    }
+    BOOST_TEST(NULL == s.rdbuf());
+}
+
+void
+ios_fill_saver_unit_test()
+{
+    std::stringstream ss;
+    BOOST_TEST_EQ(' ',  ss.fill());
+    {
+        boost::io::ios_fill_saver ifs(ss);
+        BOOST_TEST_EQ(' ', ss.fill());
+        ss.fill('x');
+        BOOST_TEST_EQ('x', ss.fill());
+    }
+    BOOST_TEST_EQ(' ', ss.fill());
+    {
+        boost::io::ios_fill_saver ifs(ss, '3');
+        BOOST_TEST_EQ('3', ss.fill());
+        ss.fill('+');
+        BOOST_TEST_EQ('+', ss.fill());
+    }
+    BOOST_TEST_EQ(' ', ss.fill());
+}
+
+void
+ios_locale_saver_unit_test()
+{
+    typedef std::numpunct<char> npc_type;
+    std::stringstream ss;
+    BOOST_TEST(std::locale() == ss.getloc());
+    BOOST_TEST(!std::has_facet<npc_type>(ss.getloc()) ||
+        !dynamic_cast<const backward_bool_names*>(&
+        std::use_facet<npc_type>(ss.getloc())));
+    {
+        boost::io::ios_locale_saver ils(ss);
+        BOOST_TEST(std::locale() == ss.getloc());
+        ss.imbue(std::locale::classic());
+        BOOST_TEST(std::locale::classic() == ss.getloc());
+    }
+    BOOST_TEST(std::locale() == ss.getloc());
+    BOOST_TEST(!std::has_facet<npc_type>(ss.getloc()) ||
+        !dynamic_cast<const backward_bool_names*>(&
+        std::use_facet<npc_type>(ss.getloc())));
+    {
+        boost::io::ios_locale_saver ils(ss, std::locale::classic());
+        BOOST_TEST(std::locale::classic() == ss.getloc());
+        BOOST_TEST(!std::has_facet<npc_type>(ss.getloc()) ||
+            !dynamic_cast<const backward_bool_names*>(&
+            std::use_facet<npc_type>(ss.getloc())));
+        ss.imbue(std::locale(std::locale::classic(), new backward_bool_names));
+        BOOST_TEST(std::locale::classic() != ss.getloc());
+        BOOST_TEST(std::has_facet<npc_type>(ss.getloc()) &&
+            dynamic_cast<const backward_bool_names*>(&
+            std::use_facet<npc_type>(ss.getloc())));
+    }
+    BOOST_TEST(std::locale() == ss.getloc());
+    BOOST_TEST(!std::has_facet<npc_type>(ss.getloc()) ||
+        !dynamic_cast<const backward_bool_names*>(&
+        std::use_facet<npc_type>(ss.getloc())));
+}
+
+void
+ios_iword_saver_unit_test(int index)
+{
+    std::stringstream ss;
+    BOOST_TEST_EQ(0, ss.iword(index));
+    {
+        boost::io::ios_iword_saver iis(ss, index);
+        BOOST_TEST_EQ(0, ss.iword(index));
+        ss.iword(index) = 6;
+        BOOST_TEST_EQ(6, ss.iword(index));
+    }
+    BOOST_TEST_EQ(0, ss.iword(index));
+    {
+        boost::io::ios_iword_saver iis(ss, index, 100);
+        BOOST_TEST_EQ(100, ss.iword(index));
+        ss.iword(index) = -2000;
+        BOOST_TEST_EQ(-2000, ss.iword(index));
+    }
+    BOOST_TEST_EQ(0, ss.iword(index));
+}
+
+void
+ios_pword_saver_unit_test(int index)
+{
+    std::stringstream ss;
+    BOOST_TEST(NULL == ss.pword(index));
+    {
+        boost::io::ios_pword_saver ips(ss, index);
+        BOOST_TEST(NULL == ss.pword(index));
+        ss.pword(index) = &ss;
+        BOOST_TEST_EQ(&ss, ss.pword(index));
+    }
+    BOOST_TEST(NULL == ss.pword(index));
+    {
+        boost::io::ios_pword_saver ips(ss, index, ss.rdbuf());
+        BOOST_TEST_EQ(ss.rdbuf(), ss.pword(index));
+        ss.pword(index) = &ss;
+        BOOST_TEST_EQ(&ss, ss.pword(index));
+    }
+    BOOST_TEST(NULL == ss.pword(index));
+}
+
+void
+ios_base_all_saver_unit_test()
+{
+    std::stringstream ss;
+    BOOST_TEST_EQ(std::ios_base::skipws | std::ios_base::dec, ss.flags());
+    BOOST_TEST_EQ(6, ss.precision());
+    BOOST_TEST_EQ(0, ss.width());
+    {
+        boost::io::ios_base_all_saver ibas(ss);
+        BOOST_TEST_EQ(std::ios_base::skipws | std::ios_base::dec, ss.flags());
+        BOOST_TEST_EQ(6, ss.precision());
+        BOOST_TEST_EQ(0, ss.width());
+        ss << std::hex << std::unitbuf << std::setprecision(5) << std::setw(7);
+        BOOST_TEST_EQ(std::ios_base::unitbuf |
+            std::ios_base::hex |
+            std::ios_base::skipws, ss.flags());
+        BOOST_TEST_EQ(5, ss.precision());
+        BOOST_TEST_EQ(7, ss.width());
+    }
+    BOOST_TEST_EQ(std::ios_base::skipws | std::ios_base::dec, ss.flags());
+    BOOST_TEST_EQ(6, ss.precision());
+    BOOST_TEST_EQ(0, ss.width());
+}
+
+void
+ios_all_saver_unit_test()
+{
+    typedef std::numpunct<char> npc_type;
+    std::stringbuf sb;
+    std::iostream ss(&sb);
+    BOOST_TEST_EQ(std::ios_base::skipws | std::ios_base::dec, ss.flags());
+    BOOST_TEST_EQ(6, ss.precision());
+    BOOST_TEST_EQ(0, ss.width());
+    BOOST_TEST_EQ(std::ios_base::goodbit, ss.rdstate());
+    BOOST_TEST(ss.good());
+    BOOST_TEST_EQ(std::ios_base::goodbit, ss.exceptions());
+    BOOST_TEST(NULL == ss.tie());
+    BOOST_TEST(&sb == ss.rdbuf());
+    BOOST_TEST_EQ(' ',  ss.fill());
+    BOOST_TEST(std::locale() == ss.getloc());
+    {
+        boost::io::ios_all_saver ias(ss);
+        BOOST_TEST_EQ(std::ios_base::skipws | std::ios_base::dec, ss.flags());
+        BOOST_TEST_EQ(6, ss.precision());
+        BOOST_TEST_EQ(0, ss.width());
+        BOOST_TEST_EQ(std::ios_base::goodbit, ss.rdstate());
+        BOOST_TEST(ss.good());
+        BOOST_TEST_EQ(std::ios_base::goodbit, ss.exceptions());
+        BOOST_TEST(NULL == ss.tie());
+        BOOST_TEST(&sb == ss.rdbuf());
+        BOOST_TEST_EQ(' ', ss.fill());
+        BOOST_TEST(std::locale() == ss.getloc());
+        ss << std::oct << std::showpos << std::noskipws;
+        BOOST_TEST_EQ(std::ios_base::showpos | std::ios_base::oct, ss.flags());
+        ss << std::setprecision(3);
+        BOOST_TEST_EQ(3, ss.precision());
+        ss << std::setw(9);
+        BOOST_TEST_EQ(9, ss.width());
+        ss.setstate(std::ios_base::eofbit);
+        BOOST_TEST_EQ(std::ios_base::eofbit, ss.rdstate());
+        BOOST_TEST(ss.eof());
+        ss.exceptions(std::ios_base::failbit);
+        BOOST_TEST_EQ(std::ios_base::failbit, ss.exceptions());
+        {
+            boost::io::ios_iostate_saver iis(ss);
+            ss.exceptions(std::ios_base::failbit | std::ios_base::badbit);
+            char c;
+#if defined(BOOST_GCC) || (defined(BOOST_CLANG) && defined(BOOST_GNU_STDLIB))
+            BOOST_TEST_THROWS(ss >> c, std::exception);
+#else
+            BOOST_TEST_THROWS(ss >> c, std::ios_base::failure);
+#endif
+        }
+        ss.tie(&std::clog);
+        BOOST_TEST_EQ(&std::clog, ss.tie());
+        ss.rdbuf(std::cerr.rdbuf());
+        BOOST_TEST_EQ(std::cerr.rdbuf(), ss.rdbuf());
+        ss << std::setfill('x');
+        BOOST_TEST_EQ('x', ss.fill());
+        ss.imbue(std::locale(std::locale::classic(), new backward_bool_names));
+        BOOST_TEST(std::locale() != ss.getloc());
+        BOOST_TEST(std::has_facet<npc_type>(ss.getloc()) &&
+            dynamic_cast<const backward_bool_names*>(&
+            std::use_facet<npc_type>(ss.getloc())));
+    }
+    BOOST_TEST_EQ(std::ios_base::skipws | std::ios_base::dec, ss.flags());
+    BOOST_TEST_EQ(6, ss.precision());
+    BOOST_TEST_EQ(0, ss.width());
+    BOOST_TEST_EQ(std::ios_base::goodbit, ss.rdstate());
+    BOOST_TEST(ss.good());
+    BOOST_TEST_EQ(std::ios_base::goodbit, ss.exceptions());
+    BOOST_TEST(NULL == ss.tie());
+    BOOST_TEST(&sb == ss.rdbuf());
+    BOOST_TEST_EQ(' ', ss.fill());
+    BOOST_TEST(std::locale() == ss.getloc());
+}
+
+void
+ios_word_saver_unit_test(int index)
+{
+    std::stringstream ss;
+    BOOST_TEST_EQ(0, ss.iword(index));
+    BOOST_TEST(NULL == ss.pword(index));
+    {
+        boost::io::ios_all_word_saver iaws(ss, index);
+        BOOST_TEST_EQ(0, ss.iword(index));
+        BOOST_TEST(NULL == ss.pword(index));
+        ss.iword(index) = -11;
+        ss.pword(index) = ss.rdbuf();
+        BOOST_TEST_EQ(-11, ss.iword(index));
+        BOOST_TEST_EQ(ss.rdbuf(), ss.pword(index));
+    }
+    BOOST_TEST_EQ(0, ss.iword(index));
+    BOOST_TEST(NULL == ss.pword(index));
+}
+
+int main()
+{
+    int index = std::ios_base::xalloc();
+    ios_flags_saver_unit_test();
+    ios_precision_saver_unit_test();
+    ios_width_saver_unit_test();
+    ios_iostate_saver_unit_test();
+    ios_exception_saver_unit_test();
+    ios_tie_saver_unit_test();
+    ios_rdbuf_saver_unit_test();
+    ios_fill_saver_unit_test();
+    ios_locale_saver_unit_test();
+    ios_iword_saver_unit_test(index);
+    ios_pword_saver_unit_test(index);
+    ios_base_all_saver_unit_test();
+    ios_all_saver_unit_test();
+    ios_word_saver_unit_test(index);
+    return boost::report_errors();
+}

externals/vcpkg/buildtrees/boost-io/src/ost-1.79.0-aff9d6facf.clean/test/make_ostream_joiner_test.cpp

@@ -0,0 +1,21 @@
+/*
+Copyright 2019 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#include <boost/io/ostream_joiner.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <sstream>
+
+int main()
+{
+    std::ostringstream o;
+    boost::io::ostream_joiner<char> j = boost::io::make_ostream_joiner(o, ',');
+    *j++ = 1;
+    *j++ = '2';
+    *j++ = "3";
+    BOOST_TEST_EQ(o.str(), "1,2,3");
+    return boost::report_errors();
+}

externals/vcpkg/buildtrees/boost-io/src/ost-1.79.0-aff9d6facf.clean/test/nullstream_test.cpp

@@ -0,0 +1,28 @@
+/*
+Copyright 2021 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#include <boost/io/nullstream.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+int main()
+{
+    {
+        boost::io::onullstream s;
+        s << "abc";
+        s << 100;
+        s << std::endl;
+        BOOST_TEST(s);
+    }
+    {
+        boost::io::wonullstream s;
+        s << L"abc";
+        s << 100;
+        s << std::endl;
+        BOOST_TEST(s);
+    }
+    return boost::report_errors();
+}

externals/vcpkg/buildtrees/boost-io/src/ost-1.79.0-aff9d6facf.clean/test/ostream_joiner_test.cpp

@@ -0,0 +1,117 @@
+/*
+Copyright 2019 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#include <boost/io/ostream_joiner.hpp>
+#include <boost/core/is_same.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <sstream>
+
+void test_char_type()
+{
+    BOOST_TEST((boost::core::is_same<char,
+        boost::io::ostream_joiner<const char*>::char_type>::value));
+}
+
+void test_traits_type()
+{
+    BOOST_TEST((boost::core::is_same<std::char_traits<char>,
+        boost::io::ostream_joiner<const char*>::traits_type>::value));
+}
+
+void test_ostream_type()
+{
+    BOOST_TEST((boost::core::is_same<std::ostream,
+        boost::io::ostream_joiner<const char*>::ostream_type>::value));
+}
+
+void test_iterator_category()
+{
+    BOOST_TEST((boost::core::is_same<std::output_iterator_tag,
+        boost::io::ostream_joiner<const char*>::iterator_category>::value));
+}
+
+void test_value_type()
+{
+    BOOST_TEST((boost::core::is_same<void,
+        boost::io::ostream_joiner<const char*>::value_type>::value));
+}
+
+void test_difference_type()
+{
+    BOOST_TEST((boost::core::is_same<void,
+        boost::io::ostream_joiner<const char*>::difference_type>::value));
+}
+
+void test_pointer()
+{
+    BOOST_TEST((boost::core::is_same<void,
+        boost::io::ostream_joiner<const char*>::pointer>::value));
+}
+
+void test_reference()
+{
+    BOOST_TEST((boost::core::is_same<void,
+        boost::io::ostream_joiner<const char*>::reference>::value));
+}
+
+void test_construct()
+{
+    std::ostringstream o;
+    boost::io::ostream_joiner<const char*> j(o, ",");
+    BOOST_TEST(o.str().empty());
+}
+
+void test_assign()
+{
+    std::ostringstream o;
+    boost::io::ostream_joiner<const char*> j(o, ",");
+    j = 1;
+    BOOST_TEST_EQ(o.str(), "1");
+    j = '2';
+    BOOST_TEST_EQ(o.str(), "1,2");
+    j = "3";
+    BOOST_TEST_EQ(o.str(), "1,2,3");
+}
+
+void test_increment()
+{
+    std::ostringstream o;
+    boost::io::ostream_joiner<const char*> j(o, ",");
+    BOOST_TEST_EQ(&++j, &j);
+}
+
+void test_post_increment()
+{
+    std::ostringstream o;
+    boost::io::ostream_joiner<const char*> j(o, ",");
+    BOOST_TEST_EQ(&j++, &j);
+}
+
+void test_value()
+{
+    std::ostringstream o;
+    boost::io::ostream_joiner<const char*> j(o, ",");
+    BOOST_TEST_EQ(&*j, &j);
+}
+
+int main()
+{
+    test_char_type();
+    test_traits_type();
+    test_ostream_type();
+    test_iterator_category();
+    test_value_type();
+    test_difference_type();
+    test_pointer();
+    test_reference();
+    test_construct();
+    test_assign();
+    test_increment();
+    test_post_increment();
+    test_value();
+    return boost::report_errors();
+}

externals/vcpkg/buildtrees/boost-io/src/ost-1.79.0-aff9d6facf.clean/test/ostream_put_test.cpp

@@ -0,0 +1,136 @@
+/*
+Copyright 2019 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#include <boost/io/ostream_put.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <sstream>
+#include <string>
+
+int main()
+{
+    {
+        std::ostringstream os;
+        os.width(1);
+        os.fill('.');
+        os.setf(std::ios_base::left, std::ios_base::adjustfield);
+        boost::io::ostream_put(os, "xy", 2);
+        BOOST_TEST(os.good());
+        BOOST_TEST(os.width() == 0);
+        BOOST_TEST(os.str() == "xy");
+    }
+    {
+        std::wostringstream os;
+        os.width(1);
+        os.fill(L'.');
+        os.setf(std::ios_base::left, std::ios_base::adjustfield);
+        boost::io::ostream_put(os, L"xy", 2);
+        BOOST_TEST(os.good());
+        BOOST_TEST(os.width() == 0);
+        BOOST_TEST(os.str() == L"xy");
+    }
+    {
+        std::ostringstream os;
+        os.width(1);
+        os.fill('.');
+        os.setf(std::ios_base::right, std::ios_base::adjustfield);
+        boost::io::ostream_put(os, "xy", 2);
+        BOOST_TEST(os.good());
+        BOOST_TEST(os.width() == 0);
+        BOOST_TEST(os.str() == "xy");
+    }
+    {
+        std::wostringstream os;
+        os.width(1);
+        os.fill(L'.');
+        os.setf(std::ios_base::right, std::ios_base::adjustfield);
+        boost::io::ostream_put(os, L"xy", 2);
+        BOOST_TEST(os.good());
+        BOOST_TEST(os.width() == 0);
+        BOOST_TEST(os.str() == L"xy");
+    }
+    {
+        std::ostringstream os;
+        os.width(4);
+        os.fill('.');
+        os.setf(std::ios_base::left, std::ios_base::adjustfield);
+        boost::io::ostream_put(os, "xy", 2);
+        BOOST_TEST(os.good());
+        BOOST_TEST(os.width() == 0);
+        BOOST_TEST(os.str() == "xy..");
+    }
+    {
+        std::wostringstream os;
+        os.width(4);
+        os.fill(L'.');
+        os.setf(std::ios_base::left, std::ios_base::adjustfield);
+        boost::io::ostream_put(os, L"xy", 2);
+        BOOST_TEST(os.good());
+        BOOST_TEST(os.width() == 0);
+        BOOST_TEST(os.str() == L"xy..");
+    }
+    {
+        std::ostringstream os;
+        os.width(4);
+        os.fill('.');
+        os.setf(std::ios_base::right, std::ios_base::adjustfield);
+        boost::io::ostream_put(os, "xy", 2);
+        BOOST_TEST(os.good());
+        BOOST_TEST(os.width() == 0);
+        BOOST_TEST(os.str() == "..xy");
+    }
+    {
+        std::wostringstream os;
+        os.width(4);
+        os.fill(L'.');
+        os.setf(std::ios_base::right, std::ios_base::adjustfield);
+        boost::io::ostream_put(os, L"xy", 2);
+        BOOST_TEST(os.good());
+        BOOST_TEST(os.width() == 0);
+        BOOST_TEST(os.str() == L"..xy");
+    }
+    {
+        std::ostringstream os;
+        os.width(12);
+        os.fill('.');
+        os.setf(std::ios_base::left, std::ios_base::adjustfield);
+        boost::io::ostream_put(os, "xy", 2);
+        BOOST_TEST(os.good());
+        BOOST_TEST(os.width() == 0);
+        BOOST_TEST(os.str() == "xy..........");
+    }
+    {
+        std::wostringstream os;
+        os.width(12);
+        os.fill(L'.');
+        os.setf(std::ios_base::left, std::ios_base::adjustfield);
+        boost::io::ostream_put(os, L"xy", 2);
+        BOOST_TEST(os.good());
+        BOOST_TEST(os.width() == 0);
+        BOOST_TEST(os.str() == L"xy..........");
+    }
+    {
+        std::ostringstream os;
+        os.width(12);
+        os.fill('.');
+        os.setf(std::ios_base::right, std::ios_base::adjustfield);
+        boost::io::ostream_put(os, "xy", 2);
+        BOOST_TEST(os.good());
+        BOOST_TEST(os.width() == 0);
+        BOOST_TEST(os.str() == "..........xy");
+    }
+    {
+        std::wostringstream os;
+        os.width(12);
+        os.fill(L'.');
+        os.setf(std::ios_base::right, std::ios_base::adjustfield);
+        boost::io::ostream_put(os, L"xy", 2);
+        BOOST_TEST(os.good());
+        BOOST_TEST(os.width() == 0);
+        BOOST_TEST(os.str() == L"..........xy");
+    }
+    return boost::report_errors();
+}

externals/vcpkg/buildtrees/boost-io/src/ost-1.79.0-aff9d6facf.clean/test/quoted_fill_test.cpp

@@ -0,0 +1,136 @@
+/*
+Copyright 2019-2020 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#include <boost/io/quoted.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <sstream>
+#include <string>
+
+int main()
+{
+    {
+        std::ostringstream os;
+        os.width(2);
+        os.fill('.');
+        os.setf(std::ios_base::left, std::ios_base::adjustfield);
+        os << boost::io::quoted("xy");
+        BOOST_TEST(os.good());
+        BOOST_TEST(os.width() == 0);
+        BOOST_TEST(os.str() == "\"xy\"");
+    }
+    {
+        std::wostringstream os;
+        os.width(2);
+        os.fill(L'.');
+        os.setf(std::ios_base::left, std::ios_base::adjustfield);
+        os << boost::io::quoted(L"xy");
+        BOOST_TEST(os.good());
+        BOOST_TEST(os.width() == 0);
+        BOOST_TEST(os.str() == L"\"xy\"");
+    }
+    {
+        std::ostringstream os;
+        os.width(2);
+        os.fill('.');
+        os.setf(std::ios_base::right, std::ios_base::adjustfield);
+        os << boost::io::quoted("xy");
+        BOOST_TEST(os.good());
+        BOOST_TEST(os.width() == 0);
+        BOOST_TEST(os.str() == "\"xy\"");
+    }
+    {
+        std::wostringstream os;
+        os.width(2);
+        os.fill(L'.');
+        os.setf(std::ios_base::right, std::ios_base::adjustfield);
+        os << boost::io::quoted(L"xy");
+        BOOST_TEST(os.good());
+        BOOST_TEST(os.width() == 0);
+        BOOST_TEST(os.str() == L"\"xy\"");
+    }
+    {
+        std::ostringstream os;
+        os.width(6);
+        os.fill('.');
+        os.setf(std::ios_base::left, std::ios_base::adjustfield);
+        os << boost::io::quoted("xy");
+        BOOST_TEST(os.good());
+        BOOST_TEST(os.width() == 0);
+        BOOST_TEST(os.str() == "\"xy\"..");
+    }
+    {
+        std::wostringstream os;
+        os.width(6);
+        os.fill(L'.');
+        os.setf(std::ios_base::left, std::ios_base::adjustfield);
+        os << boost::io::quoted(L"xy");
+        BOOST_TEST(os.good());
+        BOOST_TEST(os.width() == 0);
+        BOOST_TEST(os.str() == L"\"xy\"..");
+    }
+    {
+        std::ostringstream os;
+        os.width(6);
+        os.fill('.');
+        os.setf(std::ios_base::right, std::ios_base::adjustfield);
+        os << boost::io::quoted("xy");
+        BOOST_TEST(os.good());
+        BOOST_TEST(os.width() == 0);
+        BOOST_TEST(os.str() == "..\"xy\"");
+    }
+    {
+        std::wostringstream os;
+        os.width(6);
+        os.fill(L'.');
+        os.setf(std::ios_base::right, std::ios_base::adjustfield);
+        os << boost::io::quoted(L"xy");
+        BOOST_TEST(os.good());
+        BOOST_TEST(os.width() == 0);
+        BOOST_TEST(os.str() == L"..\"xy\"");
+    }
+    {
+        std::ostringstream os;
+        os.width(14);
+        os.fill('.');
+        os.setf(std::ios_base::left, std::ios_base::adjustfield);
+        os << boost::io::quoted("xy");
+        BOOST_TEST(os.good());
+        BOOST_TEST(os.width() == 0);
+        BOOST_TEST(os.str() == "\"xy\"..........");
+    }
+    {
+        std::wostringstream os;
+        os.width(14);
+        os.fill(L'.');
+        os.setf(std::ios_base::left, std::ios_base::adjustfield);
+        os << boost::io::quoted(L"xy");
+        BOOST_TEST(os.good());
+        BOOST_TEST(os.width() == 0);
+        BOOST_TEST(os.str() == L"\"xy\"..........");
+    }
+    {
+        std::ostringstream os;
+        os.width(14);
+        os.fill('.');
+        os.setf(std::ios_base::right, std::ios_base::adjustfield);
+        os << boost::io::quoted("xy");
+        BOOST_TEST(os.good());
+        BOOST_TEST(os.width() == 0);
+        BOOST_TEST(os.str() == "..........\"xy\"");
+    }
+    {
+        std::wostringstream os;
+        os.width(14);
+        os.fill(L'.');
+        os.setf(std::ios_base::right, std::ios_base::adjustfield);
+        os << boost::io::quoted(L"xy");
+        BOOST_TEST(os.good());
+        BOOST_TEST(os.width() == 0);
+        BOOST_TEST(os.str() == L"..........\"xy\"");
+    }
+    return boost::report_errors();
+}

externals/vcpkg/buildtrees/boost-io/src/ost-1.79.0-aff9d6facf.clean/test/quoted_test.cpp

@@ -0,0 +1,110 @@
+/*
+Copyright 2010 Beman Dawes
+
+Copyright 2019 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#include <boost/io/quoted.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <iostream>
+#include <sstream>
+
+int main()
+{
+    const std::string s0("foo");
+    std::string r;
+    {
+        std::stringstream ss;
+        ss << boost::io::quoted(s0);
+        ss >> r;
+        BOOST_TEST(r == "\"foo\"");
+    }
+    {
+        std::stringstream ss;
+        ss << boost::io::quoted(s0);
+        ss >> boost::io::quoted(r);
+        BOOST_TEST(r == "foo");
+    }
+    const std::string s0s("foo bar");
+    {
+        std::stringstream ss;
+        ss << boost::io::quoted(s0s);
+        ss >> r;
+        BOOST_TEST(r == "\"foo");
+    }
+    {
+        std::stringstream ss;
+        ss << boost::io::quoted(s0s);
+        ss >> boost::io::quoted(r);
+        BOOST_TEST(r == "foo bar");
+    }
+    const std::string s1("foo\\bar, \" *");
+    {
+        std::stringstream ss;
+        ss << boost::io::quoted(s1);
+        ss >> r;
+        BOOST_TEST(r == "\"foo\\\\bar,");
+    }
+    {
+        std::stringstream ss;
+        ss << boost::io::quoted("foo\\bar, \" *");
+        ss >> r;
+        BOOST_TEST(r == "\"foo\\\\bar,");
+    }
+    {
+        std::stringstream ss;
+        ss << boost::io::quoted(s1);
+        ss >> boost::io::quoted(r);
+        BOOST_TEST(r == s1);
+    }
+    {
+        std::stringstream ss;
+        ss << boost::io::quoted(s1.c_str());
+        ss >> boost::io::quoted(r);
+        BOOST_TEST(r == s1);
+    }
+    std::string s2("'Jack & Jill'");
+    {
+        std::stringstream ss;
+        ss << boost::io::quoted(s2, '&', '\'');
+        ss >> boost::io::quoted(r, '&', '\'');
+        BOOST_TEST(r == s2);
+    }
+    const std::wstring ws1(L"foo$bar, \" *");
+    std::wstring wr;
+    {
+        std::wstringstream wss;
+        wss << boost::io::quoted(ws1, L'$');
+        wss >> boost::io::quoted(wr,  L'$');
+        BOOST_TEST(wr == ws1);
+    }
+    const std::string s3("const string");
+    {
+        std::stringstream ss;
+        ss << boost::io::quoted(s3);
+        ss >> boost::io::quoted(r);
+        BOOST_TEST(r == s3);
+    }
+    {
+        std::stringstream ss;
+        ss << "\"abc";
+        ss >> boost::io::quoted(r);
+        BOOST_TEST(r == "abc");
+    }
+    {
+        std::stringstream ss;
+        ss << "abc";
+        ss >> boost::io::quoted(r);
+        BOOST_TEST(r == "abc");
+    }
+    {
+        std::stringstream ss;
+        ss << "abc def";
+        ss >> boost::io::quoted(r);
+        BOOST_TEST(r == "abc");
+    }
+    return boost::report_errors();
+}

externals/vcpkg/buildtrees/boost-io/stdout-x64-windows.log

@@ -0,0 +1,7 @@
+-- Downloading https://github.com/boostorg/io/archive/boost-1.79.0.tar.gz -> boostorg-io-boost-1.79.0.tar.gz...
+-- Extracting source D:/a/1/s/externals/vcpkg/downloads/boostorg-io-boost-1.79.0.tar.gz
+-- Using source at D:/a/1/s/externals/vcpkg/buildtrees/boost-io/src/ost-1.79.0-aff9d6facf.clean
+-- Copying headers
+-- Copying headers done
+-- Installing: D:/a/1/s/externals/vcpkg/packages/boost-io_x64-windows/share/boost-io/usage
+-- Installing: D:/a/1/s/externals/vcpkg/packages/boost-io_x64-windows/share/boost-io/copyright

externals/vcpkg/buildtrees/boost-io/x64-windows.vcpkg_abi_info.txt

@@ -0,0 +1,13 @@
+boost-config 797535e8975ed7cf5bbe11d9f7fe26caa5da8fe819888564758d82a21109fade
+boost-vcpkg-helpers c81c7b003df356a1a120a7c0c2f5a2ac95f3c33b006a2a5b4c02dcf0c9f3deaa
+cmake 3.23.2
+features core
+portfile.cmake 396a8e37384365896c591fc27bc1848b055c778ad98edfb77f5ef712253aa554
+ports.cmake 366c60b768113102408b32ac1d7c7b48ef7d30a477af2a220ecc222d9ffa3166
+post_build_checks 2
+powershell 7.2.5
+triplet x64-windows
+triplet_abi 4556164a2cd3dd6f4742101eabb46def7e71b6e5856faa88e5d005aac12a803c-c0600b35e024ce0485ed253ef5419f3686f7257cfb58cb6a24febcb600fc4b4c-27ebd443f77a6c449168adfa6ce8def60cf46e88
+vcpkg.json e0016e6011cb907a9c1d11654a08ef787cbe9139914e0addf75a10c18a41f5a8
+vcpkg_from_git 0aab20e34e84d52ba4763f009e539bfa8f418c41c918c8cf700156f1a8551a10
+vcpkg_from_github b743742296a114ea1b18ae99672e02f142c4eb2bef7f57d36c038bedbfb0502f