diff --git a/3rdparty/CMakeLists.txt b/3rdparty/CMakeLists.txt
index 40cefc55aafc9be07149e486841f61fe7a71cfe0..b9c185966fe191b9a7468604688853e942de1a58 100644
--- a/3rdparty/CMakeLists.txt
+++ b/3rdparty/CMakeLists.txt
@@ -1 +1 @@
-ADD_SUBDIRECTORY(o2)
+ADD_SUBDIRECTORY(cpprestsdk)
diff --git a/3rdparty/cpprestsdk/CMakeLists.txt b/3rdparty/cpprestsdk/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..d66371049bb2975123e447101075a792cb401d75
--- /dev/null
+++ b/3rdparty/cpprestsdk/CMakeLists.txt
@@ -0,0 +1,204 @@
+set(CMAKE_LEGACY_CYGWIN_WIN32 0)
+cmake_minimum_required(VERSION 2.6)
+
+enable_testing()
+
+set(WARNINGS)
+set(ANDROID_STL_FLAGS)
+
+# Platform (not compiler) specific settings
+if(IOS)
+ set(IOS_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../Build_iOS")
+ set(Boost_FRAMEWORK "-F ${IOS_SOURCE_DIR} -framework boost")
+ set(Boost_INCLUDE_DIR "${IOS_SOURCE_DIR}/boost.framework/Headers")
+
+ set(OPENSSL_FOUND 1)
+ set(OPENSSL_INCLUDE_DIR "${IOS_SOURCE_DIR}/openssl/include")
+ set(OPENSSL_LIBRARIES
+ "${IOS_SOURCE_DIR}/openssl/lib/libcrypto.a"
+ "${IOS_SOURCE_DIR}/openssl/lib/libssl.a"
+ )
+
+ # The cxx_flags must be reset here, because the ios-cmake toolchain file unfortunately sets "-headerpad_max_install_names" which is not a valid clang flag.
+ set(CMAKE_CXX_FLAGS "-fvisibility=hidden -fvisibility-inlines-hidden")
+
+ set(BUILD_SHARED_LIBS OFF)
+ set(BUILD_SAMPLES OFF)
+ option(BUILD_TESTS "Build tests." ON)
+elseif(ANDROID)
+ set(Boost_COMPILER "-clang")
+ set(Boost_USE_STATIC_LIBS ON)
+ if(ARM)
+ set(BOOST_ROOT "${CMAKE_BINARY_DIR}/../Boost-for-Android/build")
+ set(BOOST_LIBRARYDIR "${CMAKE_BINARY_DIR}/../Boost-for-Android/build/lib")
+ else()
+ set(BOOST_ROOT "${CMAKE_BINARY_DIR}/../Boost-for-Android-x86/build")
+ set(BOOST_LIBRARYDIR "${CMAKE_BINARY_DIR}/../Boost-for-Android-x86/build/lib")
+ endif()
+ find_host_package(Boost 1.55 EXACT REQUIRED COMPONENTS random system thread filesystem chrono atomic)
+
+ set(OPENSSL_FOUND 1)
+ if(ARM)
+ set(OPENSSL_INCLUDE_DIR "${CMAKE_BINARY_DIR}/../openssl/armeabi-v7a/include")
+ set(OPENSSL_LIBRARIES
+ "${CMAKE_BINARY_DIR}/../openssl/armeabi-v7a/lib/libssl.a"
+ "${CMAKE_BINARY_DIR}/../openssl/armeabi-v7a/lib/libcrypto.a"
+ )
+ else()
+ set(OPENSSL_INCLUDE_DIR "${CMAKE_BINARY_DIR}/../openssl/x86/include")
+ set(OPENSSL_LIBRARIES
+ "${CMAKE_BINARY_DIR}/../openssl/x86/lib/libssl.a"
+ "${CMAKE_BINARY_DIR}/../openssl/x86/lib/libcrypto.a"
+ )
+ endif()
+
+ if(ARM)
+ set(LIBCXX_STL "${ANDROID_NDK}/sources/cxx-stl/gnu-libstdc++/4.8/libs/armeabi-v7a/thumb/libgnustl_static.a")
+ else()
+ set(LIBCXX_STL "${ANDROID_NDK}/sources/cxx-stl/gnu-libstdc++/4.8/libs/x86/libgnustl_static.a")
+ endif()
+ # These are used in the shared library case
+ set(ANDROID_STL_FLAGS
+ ${LIBCXX_STL}
+ atomic
+ dl
+ gcc
+ c
+ m
+ -nodefaultlibs
+ )
+
+ option(BUILD_SHARED_LIBS "Build shared Libraries." OFF)
+ set(BUILD_SAMPLES OFF)
+ option(BUILD_TESTS "Build tests." ON)
+elseif(UNIX) # This includes OSX
+ find_package(Boost REQUIRED COMPONENTS random chrono system thread regex filesystem)
+ find_package(Threads REQUIRED)
+ if(APPLE AND NOT OPENSSL_ROOT_DIR)
+ # Prefer a homebrew version of OpenSSL over the one in /usr/lib
+ file(GLOB OPENSSL_ROOT_DIR /usr/local/Cellar/openssl/*)
+ # Prefer the latest (make the latest one first)
+ list(REVERSE OPENSSL_ROOT_DIR)
+ endif()
+ # This should prevent linking against the system provided 0.9.8y
+ set(_OPENSSL_VERSION "")
+ find_package(OpenSSL 1.0.0 REQUIRED)
+
+ option(BUILD_SHARED_LIBS "Build shared Libraries." ON)
+ option(BUILD_TESTS "Build tests." OFF)
+ option(BUILD_SAMPLES "Build samples." OFF)
+ option(CASA_INSTALL_HEADERS "Install header files." ON)
+ if(CASA_INSTALL_HEADERS)
+ file(GLOB CASA_HEADERS_CPPREST include/cpprest/*.hpp include/cpprest/*.h include/cpprest/*.dat)
+ install(FILES ${CASA_HEADERS_CPPREST} DESTINATION include/cpprest)
+ file(GLOB CASA_HEADERS_PPLX include/pplx/*.hpp include/pplx/*.h)
+ install(FILES ${CASA_HEADERS_PPLX} DESTINATION include/pplx)
+ file(GLOB CASA_HEADERS_DETAILS include/cpprest/details/*.hpp include/cpprest/details/*.h include/cpprest/details/*.dat)
+ install(FILES ${CASA_HEADERS_DETAILS} DESTINATION include/cpprest/details)
+ endif()
+elseif(WIN32)
+ option(BUILD_SHARED_LIBS "Build shared Libraries." ON)
+ option(BUILD_TESTS "Build tests." ON)
+ option(BUILD_SAMPLES "Build samples." ON)
+ option(Boost_USE_STATIC_LIBS ON)
+
+ add_definitions(-DUNICODE -D_UNICODE)
+
+ if(NOT BUILD_SHARED_LIBS)
+ # This causes cmake to not link the test libraries separately, but instead hold onto their object files.
+ set(TEST_LIBRARY_TARGET_TYPE OBJECT)
+ set(Casablanca_DEFINITIONS -D_NO_ASYNCRTIMP -D_NO_PPLXIMP CACHE INTERNAL "Definitions for consume casablanca library")
+ else()
+ set(Casablanca_DEFINITIONS "" CACHE INTERNAL "Definitions for consume casablanca library")
+ endif()
+ add_definitions(${Casablanca_DEFINITIONS} -D_WINSOCK_DEPRECATED_NO_WARNINGS -DWIN32)
+
+ find_package(Boost 1.55 REQUIRED COMPONENTS random system thread filesystem chrono atomic)
+ find_package(OpenSSL 1.0 REQUIRED)
+else()
+ message(FATAL_ERROR "-- Unsupported Build Platform.")
+endif()
+
+# Compiler (not platform) specific settings
+if(ANDROID)
+ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -fno-strict-aliasing")
+ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-pedantic")
+ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-attributes -Wno-pointer-arith")
+ include_directories(
+ "${ANDROID_NDK}/sources/cxx-stl/gnu-libstdc++/4.8/include"
+ "${ANDROID_NDK}/sources/cxx-stl/gnu-libstdc++/4.8/libs/armeabi-v7a/include"
+ "${ANDROID_NDK}/sources/cxx-stl/gnu-libstdc++/4.8/include/backward"
+ )
+elseif((CMAKE_CXX_COMPILER_ID MATCHES "Clang") OR IOS)
+ message("-- Setting clang options")
+
+ set(WARNINGS "-Wall -Wextra -Wcast-qual -Wconversion -Wformat=2 -Winit-self -Winvalid-pch -Wmissing-format-attribute -Wmissing-include-dirs -Wpacked -Wredundant-decls")
+ set(OSX_SUPPRESSIONS "-Wno-overloaded-virtual -Wno-sign-conversion -Wno-deprecated -Wno-unknown-pragmas -Wno-reorder -Wno-char-subscripts -Wno-switch -Wno-unused-parameter -Wno-unused-variable -Wno-deprecated -Wno-unused-value -Wno-unknown-warning-option -Wno-return-type-c-linkage -Wno-unused-function -Wno-sign-compare -Wno-shorten-64-to-32 -Wno-reorder")
+ set(WARNINGS "${WARNINGS} ${OSX_SUPPRESSIONS}")
+
+ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -stdlib=libc++ -Wno-return-type-c-linkage -Wno-unneeded-internal-declaration")
+ set(CMAKE_XCODE_ATTRIBUTE_CLANG_CXX_LIBRARY "libc++")
+ set(CMAKE_XCODE_ATTRIBUTE_CLANG_CXX_LANGUAGE_STANDARD "c++11")
+
+ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -fno-strict-aliasing")
+elseif(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
+ message("-- Setting gcc options")
+
+ set(WARNINGS "-Wall -Wextra -Wunused-parameter -Wcast-align -Wcast-qual -Wconversion -Wformat=2 -Winit-self -Winvalid-pch -Wmissing-format-attribute -Wmissing-include-dirs -Wpacked -Wredundant-decls -Wunreachable-code")
+
+ set(LD_FLAGS "${LD_FLAGS} -Wl,-z,defs")
+
+ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -fno-strict-aliasing")
+elseif(CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
+ message("-- Setting msvc options")
+ set(WARNINGS)
+else()
+ message("-- Unknown compiler, success is doubtful.")
+ message("CMAKE_CXX_COMPILER_ID=${CMAKE_CXX_COMPILER_ID}")
+endif()
+
+# Reconfigure final output directory
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/Binaries)
+set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/Binaries)
+set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/Binaries)
+
+# These settings can be used by the test targets
+set(Casablanca_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/include)
+set(Casablanca_INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/include ${Boost_INCLUDE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/libs/websocketpp)
+
+set(Casablanca_LIBRARY ${LIB}cpprest)
+set(Casablanca_LIBRARIES ${Casablanca_LIBRARY} ${Boost_LIBRARIES} ${Boost_FRAMEWORK})
+
+# Everything in the project needs access to the casablanca include directories
+include_directories(${Casablanca_INCLUDE_DIRS})
+
+# Finally, the tests all use the same style declaration to build themselves, so we use a function
+function(add_casablanca_test NAME SOURCES_VAR)
+ add_library(${NAME} ${TEST_LIBRARY_TARGET_TYPE} ${${SOURCES_VAR}})
+ message("-- Added test library ${NAME}")
+ if (NOT TEST_LIBRARY_TARGET_TYPE STREQUAL "OBJECT")
+ target_link_libraries(${NAME}
+ ${LIB}httptest_utilities
+ ${LIB}common_utilities
+ ${LIB}unittestpp
+ ${Casablanca_LIBRARIES}
+ ${ANDROID_STL_FLAGS}
+ )
+ if (BUILD_SHARED_LIBS)
+ add_test(NAME ${NAME}
+ WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}
+ COMMAND test_runner lib${NAME}${CMAKE_SHARED_LIBRARY_SUFFIX}
+ )
+ endif()
+ endif()
+endfunction()
+
+add_subdirectory(src)
+
+if(BUILD_TESTS)
+ add_subdirectory(tests)
+endif()
+
+if(BUILD_SAMPLES)
+ add_subdirectory(samples)
+endif()
diff --git a/3rdparty/cpprestsdk/dirs.proj b/3rdparty/cpprestsdk/dirs.proj
new file mode 100644
index 0000000000000000000000000000000000000000..bdbd321a8d381b7d9bf85c31dc3e8de9fc83e008
--- /dev/null
+++ b/3rdparty/cpprestsdk/dirs.proj
@@ -0,0 +1,16 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/3rdparty/cpprestsdk/include/cpprest/astreambuf.h b/3rdparty/cpprestsdk/include/cpprest/astreambuf.h
new file mode 100644
index 0000000000000000000000000000000000000000..a12605d9add647321d6b9ae030eb62f54cf17d1c
--- /dev/null
+++ b/3rdparty/cpprestsdk/include/cpprest/astreambuf.h
@@ -0,0 +1,1199 @@
+/***
+* ==++==
+*
+* Copyright (c) Microsoft Corporation. All rights reserved.
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*
+* ==--==
+* =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+*
+* Asynchronous I/O: stream buffer. This is an extension to the PPL concurrency features and therefore
+* lives in the Concurrency namespace.
+*
+* For the latest on this and related APIs, please see http://casablanca.codeplex.com.
+*
+* =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+****/
+#pragma once
+
+#include
+#include
+#include
+#include
+
+#include "pplx/pplxtasks.h"
+#include "cpprest/details/basic_types.h"
+#include "cpprest/asyncrt_utils.h"
+
+namespace Concurrency
+{
+/// Library for asynchronous streams.
+namespace streams
+{
+ ///
+ /// Extending the standard char_traits type with one that adds values and types
+ /// that are unique to "C++ REST SDK" streams.
+ ///
+ ///
+ /// The data type of the basic element of the stream.
+ ///
+ template
+ struct char_traits : std::char_traits<_CharType>
+ {
+ ///
+ /// Some synchronous functions will return this value if the operation
+ /// requires an asynchronous call in a given situation.
+ ///
+ /// An int_type value which implies that an asynchronous call is required.
+ static typename std::char_traits<_CharType>::int_type requires_async() { return std::char_traits<_CharType>::eof()-1; }
+ };
+#if !defined(_WIN32)
+ template<>
+ struct char_traits : private std::char_traits
+ {
+ public:
+ typedef unsigned char char_type;
+
+ using std::char_traits::eof;
+ using std::char_traits::int_type;
+ using std::char_traits::off_type;
+ using std::char_traits::pos_type;
+
+ static size_t length(const unsigned char* str)
+ {
+ return std::char_traits::length(reinterpret_cast(str));
+ }
+
+ static void assign(unsigned char& left, const unsigned char& right) { left = right; }
+ static unsigned char* assign(unsigned char* left, size_t n, unsigned char value)
+ {
+ return reinterpret_cast(std::char_traits::assign(reinterpret_cast(left), n, static_cast(value)));
+ }
+
+ static unsigned char* copy(unsigned char* left, const unsigned char* right, size_t n)
+ {
+ return reinterpret_cast(std::char_traits::copy(reinterpret_cast(left), reinterpret_cast(right), n));
+ }
+
+ static unsigned char* move(unsigned char* left, const unsigned char* right, size_t n)
+ {
+ return reinterpret_cast(std::char_traits::move(reinterpret_cast(left), reinterpret_cast(right), n));
+ }
+
+ static int_type requires_async() { return eof() - 1; }
+ };
+#endif
+
+ namespace details {
+
+ ///
+ /// Stream buffer base class.
+ ///
+ template
+ class basic_streambuf
+ {
+ public:
+ typedef _CharType char_type;
+ typedef ::concurrency::streams::char_traits<_CharType> traits;
+
+ typedef typename traits::int_type int_type;
+ typedef typename traits::pos_type pos_type;
+ typedef typename traits::off_type off_type;
+
+
+ ///
+ /// Virtual constructor for stream buffers.
+ ///
+ virtual ~basic_streambuf() { }
+
+ ///
+ /// can_read is used to determine whether a stream buffer will support read operations (get).
+ ///
+ virtual bool can_read() const = 0;
+
+ ///
+ /// can_write is used to determine whether a stream buffer will support write operations (put).
+ ///
+ virtual bool can_write() const = 0;
+
+ ///
+ /// can_seek is used to determine whether a stream buffer supports seeking.
+ ///
+ virtual bool can_seek() const = 0;
+
+ ///
+ /// has_size is used to determine whether a stream buffer supports size().
+ ///
+ virtual bool has_size() const = 0;
+
+ ///
+ /// is_eof is used to determine whether a read head has reached the end of the buffer.
+ ///
+ virtual bool is_eof() const = 0;
+
+ ///
+ /// Gets the stream buffer size, if one has been set.
+ ///
+ /// The direction of buffering (in or out)
+ /// The size of the internal buffer (for the given direction).
+ /// An implementation that does not support buffering will always return 0.
+ virtual size_t buffer_size(std::ios_base::openmode direction = std::ios_base::in) const = 0;
+
+ ///
+ /// Sets the stream buffer implementation to buffer or not buffer.
+ ///
+ /// The size to use for internal buffering, 0 if no buffering should be done.
+ /// The direction of buffering (in or out)
+ /// An implementation that does not support buffering will silently ignore calls to this function and it will not have any effect on what is returned by subsequent calls to .
+ virtual void set_buffer_size(size_t size, std::ios_base::openmode direction = std::ios_base::in) = 0;
+
+ ///
+ /// For any input stream, in_avail returns the number of characters that are immediately available
+ /// to be consumed without blocking. May be used in conjunction with to read data without
+ /// incurring the overhead of using tasks.
+ ///
+ virtual size_t in_avail() const = 0;
+
+ ///
+ /// Checks if the stream buffer is open.
+ ///
+ /// No separation is made between open for reading and open for writing.
+ virtual bool is_open() const = 0;
+
+ ///
+ /// Closes the stream buffer, preventing further read or write operations.
+ ///
+ /// The I/O mode (in or out) to close for.
+ virtual pplx::task close(std::ios_base::openmode mode = (std::ios_base::in | std::ios_base::out)) = 0;
+
+ ///
+ /// Closes the stream buffer with an exception.
+ ///
+ /// The I/O mode (in or out) to close for.
+ /// Pointer to the exception.
+ virtual pplx::task close(std::ios_base::openmode mode, std::exception_ptr eptr) = 0;
+
+ ///
+ /// Writes a single character to the stream.
+ ///
+ /// The character to write
+ /// A task that holds the value of the character. This value is EOF if the write operation fails.
+ virtual pplx::task putc(_CharType ch) = 0;
+
+ ///
+ /// Writes a number of characters to the stream.
+ ///
+ /// A pointer to the block of data to be written.
+ /// The number of characters to write.
+ /// A task that holds the number of characters actually written, either 'count' or 0.
+ virtual pplx::task putn(const _CharType *ptr, size_t count) = 0;
+
+ ///
+ /// Writes a number of characters to the stream. Note: callers must make sure the data to be written is valid until
+ /// the returned task completes.
+ ///
+ /// A pointer to the block of data to be written.
+ /// The number of characters to write.
+ /// A task that holds the number of characters actually written, either 'count' or 0.
+ virtual pplx::task putn_nocopy(const _CharType *ptr, size_t count) = 0;
+
+ ///
+ /// Reads a single character from the stream and advances the read position.
+ ///
+ /// A task that holds the value of the character. This value is EOF if the read fails.
+ virtual pplx::task bumpc() = 0;
+
+ ///
+ /// Reads a single character from the stream and advances the read position.
+ ///
+ /// The value of the character. -1 if the read fails. -2 if an asynchronous read is required
+ /// This is a synchronous operation, but is guaranteed to never block.
+ virtual int_type sbumpc() = 0;
+
+ ///
+ /// Reads a single character from the stream without advancing the read position.
+ ///
+ /// A task that holds the value of the byte. This value is EOF if the read fails.
+ virtual pplx::task getc() = 0;
+
+ ///
+ /// Reads a single character from the stream without advancing the read position.
+ ///
+ /// The value of the character. EOF if the read fails. if an asynchronous read is required
+ /// This is a synchronous operation, but is guaranteed to never block.
+ virtual int_type sgetc() = 0;
+
+ ///
+ /// Advances the read position, then returns the next character without advancing again.
+ ///
+ /// A task that holds the value of the character. This value is EOF if the read fails.
+ virtual pplx::task nextc() = 0;
+
+ ///
+ /// Retreats the read position, then returns the current character without advancing.
+ ///
+ /// A task that holds the value of the character. This value is EOF if the read fails, requires_async if an asynchronous read is required
+ virtual pplx::task ungetc() = 0;
+
+ ///
+ /// Reads up to a given number of characters from the stream.
+ ///
+ /// The address of the target memory area.
+ /// The maximum number of characters to read.
+ /// A task that holds the number of characters read. This value is O if the end of the stream is reached.
+ virtual pplx::task getn(_Out_writes_(count) _CharType *ptr, _In_ size_t count) = 0;
+
+ ///
+ /// Copies up to a given number of characters from the stream, synchronously.
+ ///
+ /// The address of the target memory area.
+ /// The maximum number of characters to read.
+ /// The number of characters copied. O if the end of the stream is reached or an asynchronous read is required.
+ /// This is a synchronous operation, but is guaranteed to never block.
+ virtual size_t scopy(_Out_writes_(count) _CharType *ptr, _In_ size_t count) = 0;
+
+ ///
+ /// Gets the current read or write position in the stream.
+ ///
+ /// The I/O direction to seek (see remarks)
+ /// The current position. EOF if the operation fails.
+ /// Some streams may have separate write and read cursors.
+ /// For such streams, the direction parameter defines whether to move the read or the write cursor.
+ virtual pos_type getpos(std::ios_base::openmode direction) const = 0;
+
+ ///
+ /// Gets the size of the stream, if known. Calls to has_size will determine whether
+ /// the result of size can be relied on.
+ ///
+ virtual utility::size64_t size() const = 0;
+
+ ///
+ /// Seeks to the given position.
+ ///
+ /// The offset from the beginning of the stream.
+ /// The I/O direction to seek (see remarks).
+ /// The position. EOF if the operation fails.
+ /// Some streams may have separate write and read cursors. For such streams, the direction parameter defines whether to move the read or the write cursor.
+ virtual pos_type seekpos(pos_type pos, std::ios_base::openmode direction) = 0;
+
+ ///
+ /// Seeks to a position given by a relative offset.
+ ///
+ /// The relative position to seek to
+ /// The starting point (beginning, end, current) for the seek.
+ /// The I/O direction to seek (see remarks)
+ /// The position. EOF if the operation fails.
+ /// Some streams may have separate write and read cursors.
+ /// For such streams, the mode parameter defines whether to move the read or the write cursor.
+ virtual pos_type seekoff(off_type offset, std::ios_base::seekdir way, std::ios_base::openmode mode) = 0;
+
+ ///
+ /// For output streams, flush any internally buffered data to the underlying medium.
+ ///
+ /// A task that returns true if the sync succeeds, false if not.
+ virtual pplx::task sync() = 0;
+
+ //
+ // Efficient read and write.
+ //
+ // The following routines are intended to be used for more efficient, copy-free, reading and
+ // writing of data from/to the stream. Rather than having the caller provide a buffer into which
+ // data is written or from which it is read, the stream buffer provides a pointer directly to the
+ // internal data blocks that it is using. Since not all stream buffers use internal data structures
+ // to copy data, the functions may not be supported by all. An application that wishes to use this
+ // functionality should therefore first try them and check for failure to support. If there is
+ // such failure, the application should fall back on the copying interfaces (putn / getn)
+ //
+
+ ///
+ /// Allocates a contiguous memory block and returns it.
+ ///
+ /// The number of characters to allocate.
+ /// A pointer to a block to write to, null if the stream buffer implementation does not support alloc/commit.
+ virtual _CharType* alloc(_In_ size_t count) = 0;
+
+ ///
+ /// Submits a block already allocated by the stream buffer.
+ ///
+ /// The number of characters to be committed.
+ virtual void commit(_In_ size_t count) = 0;
+
+ ///
+ /// Gets a pointer to the next already allocated contiguous block of data.
+ ///
+ /// A reference to a pointer variable that will hold the address of the block on success.
+ /// The number of contiguous characters available at the address in 'ptr.'
+ /// true if the operation succeeded, false otherwise.
+ ///
+ /// A return of false does not necessarily indicate that a subsequent read operation would fail, only that
+ /// there is no block to return immediately or that the stream buffer does not support the operation.
+ /// The stream buffer may not de-allocate the block until is called.
+ /// If the end of the stream is reached, the function will return true, a null pointer, and a count of zero;
+ /// a subsequent read will not succeed.
+ ///
+ virtual bool acquire(_Out_ _CharType*& ptr, _Out_ size_t& count) = 0;
+
+ ///
+ /// Releases a block of data acquired using . This frees the stream buffer to de-allocate the
+ /// memory, if it so desires. Move the read position ahead by the count.
+ ///
+ /// A pointer to the block of data to be released.
+ /// The number of characters that were read.
+ virtual void release(_Out_writes_(count) _CharType *ptr, _In_ size_t count) = 0;
+
+ ///
+ /// Retrieves the stream buffer exception_ptr if it has been set.
+ ///
+ /// Pointer to the exception, if it has been set; otherwise, nullptr will be returned
+ virtual std::exception_ptr exception() const = 0;
+ };
+
+
+ template
+ class streambuf_state_manager : public basic_streambuf<_CharType>, public std::enable_shared_from_this>
+ {
+ public:
+ typedef typename details::basic_streambuf<_CharType>::traits traits;
+ typedef typename details::basic_streambuf<_CharType>::int_type int_type;
+ typedef typename details::basic_streambuf<_CharType>::pos_type pos_type;
+ typedef typename details::basic_streambuf<_CharType>::off_type off_type;
+
+ ///
+ /// can_read is used to determine whether a stream buffer will support read operations (get).
+ ///
+ virtual bool can_read() const
+ {
+ return m_stream_can_read;
+ }
+
+ ///
+ /// can_write is used to determine whether a stream buffer will support write operations (put).
+ ///
+ virtual bool can_write() const
+ {
+ return m_stream_can_write;
+ }
+
+ ///
+ /// Checks if the stream buffer is open.
+ ///
+ /// No separation is made between open for reading and open for writing.
+ virtual bool is_open() const
+ {
+ return can_read() || can_write();
+ }
+
+ ///
+ /// Closes the stream buffer, preventing further read or write operations.
+ ///
+ /// The I/O mode (in or out) to close for.
+ virtual pplx::task close(std::ios_base::openmode mode = std::ios_base::in | std::ios_base::out)
+ {
+ pplx::task closeOp = pplx::task_from_result();
+
+ if (mode & std::ios_base::in && can_read()) {
+ closeOp = _close_read();
+ }
+
+ // After the flush_internal task completed, "this" object may have been destroyed,
+ // accessing the members is invalid, use shared_from_this to avoid access violation exception.
+ auto this_ptr = std::static_pointer_cast(this->shared_from_this());
+
+ if (mode & std::ios_base::out && can_write()) {
+ if (closeOp.is_done())
+ closeOp = closeOp && _close_write().then([this_ptr]{}); // passing down exceptions from closeOp
+ else
+ closeOp = closeOp.then([this_ptr] { return this_ptr->_close_write().then([this_ptr]{}); });
+ }
+
+ return closeOp;
+ }
+
+ ///
+ /// Closes the stream buffer with an exception.
+ ///
+ /// The I/O mode (in or out) to close for.
+ /// Pointer to the exception.
+ virtual pplx::task close(std::ios_base::openmode mode, std::exception_ptr eptr)
+ {
+ if (m_currentException == nullptr)
+ m_currentException = eptr;
+ return close(mode);
+ }
+
+ ///
+ /// is_eof is used to determine whether a read head has reached the end of the buffer.
+ ///
+ virtual bool is_eof() const
+ {
+ return m_stream_read_eof;
+ }
+
+ ///
+ /// Writes a single character to the stream.
+ ///
+ /// The character to write
+ /// The value of the character. EOF if the write operation fails
+ virtual pplx::task putc(_CharType ch)
+ {
+ if (!can_write())
+ return create_exception_checked_value_task(traits::eof());
+
+ return create_exception_checked_task(_putc(ch), [](int_type) {
+ return false; // no EOF for write
+ });
+ }
+
+ ///
+ /// Writes a number of characters to the stream.
+ ///
+ /// A pointer to the block of data to be written.
+ /// The number of characters to write.
+ /// The number of characters actually written, either 'count' or 0.
+// CASABLANCA_DEPRECATED("This API in some cases performs a copy. It is deprecated and will be removed in a future release. Use putn_nocopy instead.")
+ virtual pplx::task putn(const _CharType *ptr, size_t count)
+ {
+ if (!can_write())
+ return create_exception_checked_value_task(0);
+ if (count == 0)
+ return pplx::task_from_result(0);
+
+ return create_exception_checked_task(_putn(ptr, count, true), [](size_t) {
+ return false; // no EOF for write
+ });
+ }
+
+ ///
+ /// Writes a number of characters to the stream. Note: callers must make sure the data to be written is valid until
+ /// the returned task completes.
+ ///
+ /// A pointer to the block of data to be written.
+ /// The number of characters to write.
+ /// A task that holds the number of characters actually written, either 'count' or 0.
+ virtual pplx::task putn_nocopy(const _CharType *ptr, size_t count)
+ {
+ if (!can_write())
+ return create_exception_checked_value_task(0);
+ if (count == 0)
+ return pplx::task_from_result(0);
+
+ return create_exception_checked_task(_putn(ptr, count), [](size_t) {
+ return false; // no EOF for write
+ });
+ }
+
+ ///
+ /// Reads a single character from the stream and advances the read position.
+ ///
+ /// The value of the character. EOF if the read fails.
+ virtual pplx::task bumpc()
+ {
+ if (!can_read())
+ return create_exception_checked_value_task(streambuf_state_manager<_CharType>::traits::eof());
+
+ return create_exception_checked_task(_bumpc(), [](int_type val) {
+ return val == streambuf_state_manager<_CharType>::traits::eof();
+ });
+ }
+
+ ///
+ /// Reads a single character from the stream and advances the read position.
+ ///
+ /// The value of the character. -1 if the read fails. -2 if an asynchronous read is required
+ /// This is a synchronous operation, but is guaranteed to never block.
+ virtual int_type sbumpc()
+ {
+ if ( !(m_currentException == nullptr) )
+ std::rethrow_exception(m_currentException);
+ if (!can_read())
+ return traits::eof();
+ return check_sync_read_eof(_sbumpc());
+ }
+
+ ///
+ /// Reads a single character from the stream without advancing the read position.
+ ///
+ /// The value of the byte. EOF if the read fails.
+ virtual pplx::task getc()
+ {
+ if (!can_read())
+ return create_exception_checked_value_task(traits::eof());
+
+ return create_exception_checked_task(_getc(), [](int_type val) {
+ return val == streambuf_state_manager<_CharType>::traits::eof();
+ });
+ }
+
+ ///
+ /// Reads a single character from the stream without advancing the read position.
+ ///
+ /// The value of the character. EOF if the read fails. if an asynchronous read is required
+ /// This is a synchronous operation, but is guaranteed to never block.
+ virtual int_type sgetc()
+ {
+ if ( !(m_currentException == nullptr) )
+ std::rethrow_exception(m_currentException);
+ if (!can_read())
+ return traits::eof();
+ return check_sync_read_eof(_sgetc());
+ }
+
+ ///
+ /// Advances the read position, then returns the next character without advancing again.
+ ///
+ /// The value of the character. EOF if the read fails.
+ virtual pplx::task nextc()
+ {
+ if (!can_read())
+ return create_exception_checked_value_task(traits::eof());
+
+ return create_exception_checked_task(_nextc(), [](int_type val) {
+ return val == streambuf_state_manager<_CharType>::traits::eof();
+ });
+ }
+
+ ///
+ /// Retreats the read position, then returns the current character without advancing.
+ ///
+ /// The value of the character. EOF if the read fails. if an asynchronous read is required
+ virtual pplx::task ungetc()
+ {
+ if (!can_read())
+ return create_exception_checked_value_task(traits::eof());
+
+ return create_exception_checked_task(_ungetc(), [](int_type) {
+ return false;
+ });
+ }
+
+ ///
+ /// Reads up to a given number of characters from the stream.
+ ///
+ /// The address of the target memory area.
+ /// The maximum number of characters to read.
+ /// The number of characters read. O if the end of the stream is reached.
+ virtual pplx::task getn(_Out_writes_(count) _CharType *ptr, _In_ size_t count)
+ {
+ if (!can_read())
+ return create_exception_checked_value_task(0);
+ if (count == 0)
+ return pplx::task_from_result(0);
+
+ return create_exception_checked_task(_getn(ptr, count), [](size_t val) {
+ return val == 0;
+ });
+ }
+
+ ///
+ /// Copies up to a given number of characters from the stream, synchronously.
+ ///
+ /// The address of the target memory area.
+ /// The maximum number of characters to read.
+ /// The number of characters copied. O if the end of the stream is reached or an asynchronous read is required.
+ /// This is a synchronous operation, but is guaranteed to never block.
+ virtual size_t scopy(_Out_writes_(count) _CharType *ptr, _In_ size_t count)
+ {
+ if ( !(m_currentException == nullptr) )
+ std::rethrow_exception(m_currentException);
+ if (!can_read())
+ return 0;
+
+ return _scopy(ptr, count);
+ }
+
+ ///
+ /// For output streams, flush any internally buffered data to the underlying medium.
+ ///
+ /// true if the flush succeeds, false if not
+ virtual pplx::task sync()
+ {
+ if (!can_write())
+ {
+ if (m_currentException == nullptr)
+ return pplx::task_from_result();
+ else
+ return pplx::task_from_exception(m_currentException);
+ }
+ return create_exception_checked_task(_sync(), [](bool) {
+ return false;
+ }).then([](bool){});
+ }
+
+ ///
+ /// Retrieves the stream buffer exception_ptr if it has been set.
+ ///
+ /// Pointer to the exception, if it has been set; otherwise, nullptr will be returned.
+ virtual std::exception_ptr exception() const
+ {
+ return m_currentException;
+ }
+
+ ///
+ /// Allocates a contiguous memory block and returns it.
+ ///
+ /// The number of characters to allocate.
+ /// A pointer to a block to write to, null if the stream buffer implementation does not support alloc/commit.
+ /// This is intended as an advanced API to be used only when it is important to avoid extra copies.
+ _CharType* alloc(size_t count)
+ {
+ if (m_alloced)
+ throw std::logic_error("The buffer is already allocated, this maybe caused by overlap of stream read or write");
+
+ _CharType* alloc_result = _alloc(count);
+
+ if (alloc_result)
+ m_alloced = true;
+
+ return alloc_result;
+ }
+
+ ///
+ /// Submits a block already allocated by the stream buffer.
+ ///
+ /// The number of characters to be committed.
+ /// This is intended as an advanced API to be used only when it is important to avoid extra copies.
+ void commit(size_t count)
+ {
+ if (!m_alloced)
+ throw std::logic_error("The buffer needs to allocate first");
+
+ _commit(count);
+ m_alloced = false;
+ }
+
+ public:
+ virtual bool can_seek() const = 0;
+ virtual bool has_size() const = 0;
+ virtual utility::size64_t size() const { return 0; }
+ virtual size_t buffer_size(std::ios_base::openmode direction = std::ios_base::in) const = 0;
+ virtual void set_buffer_size(size_t size, std::ios_base::openmode direction = std::ios_base::in) = 0;
+ virtual size_t in_avail() const = 0;
+ virtual pos_type getpos(std::ios_base::openmode direction) const = 0;
+ virtual pos_type seekpos(pos_type pos, std::ios_base::openmode direction) = 0;
+ virtual pos_type seekoff(off_type offset, std::ios_base::seekdir way, std::ios_base::openmode mode) = 0;
+ virtual bool acquire(_Out_writes_(count) _CharType*& ptr, _In_ size_t& count) = 0;
+ virtual void release(_Out_writes_(count) _CharType *ptr, _In_ size_t count) = 0;
+ protected:
+ virtual pplx::task _putc(_CharType ch) = 0;
+
+ // This API is only needed for file streams and until we remove the deprecated stream buffer putn overload.
+ virtual pplx::task _putn(const _CharType *ptr, size_t count, bool)
+ {
+ // Default to no copy, only the file streams API overloads and performs a copy.
+ return _putn(ptr, count);
+ }
+ virtual pplx::task _putn(const _CharType *ptr, size_t count) = 0;
+
+ virtual pplx::task _bumpc() = 0;
+ virtual int_type _sbumpc() = 0;
+ virtual pplx::task _getc() = 0;
+ virtual int_type _sgetc() = 0;
+ virtual pplx::task _nextc() = 0;
+ virtual pplx::task _ungetc() = 0;
+ virtual pplx::task _getn(_Out_writes_(count) _CharType *ptr, _In_ size_t count) = 0;
+ virtual size_t _scopy(_Out_writes_(count) _CharType *ptr, _In_ size_t count) = 0;
+ virtual pplx::task _sync() = 0;
+ virtual _CharType* _alloc(size_t count) = 0;
+ virtual void _commit(size_t count) = 0;
+
+ ///
+ /// The real read head close operation, implementation should override it if there is any resource to be released.
+ ///
+ virtual pplx::task _close_read()
+ {
+ m_stream_can_read = false;
+ return pplx::task_from_result();
+ }
+
+ ///
+ /// The real write head close operation, implementation should override it if there is any resource to be released.
+ ///
+ virtual pplx::task _close_write()
+ {
+ m_stream_can_write = false;
+ return pplx::task_from_result();
+ }
+
+ protected:
+ streambuf_state_manager(std::ios_base::openmode mode)
+ {
+ m_stream_can_read = (mode & std::ios_base::in) != 0;
+ m_stream_can_write = (mode & std::ios_base::out) != 0;
+ m_stream_read_eof = false;
+ m_alloced = false;
+ }
+
+ std::exception_ptr m_currentException;
+ // The in/out mode for the buffer
+ bool m_stream_can_read, m_stream_can_write, m_stream_read_eof, m_alloced;
+
+
+ private:
+ template
+ pplx::task<_CharType1> create_exception_checked_value_task(const _CharType1 &val) const
+ {
+ if (this->exception() == nullptr)
+ return pplx::task_from_result<_CharType1>(static_cast<_CharType1>(val));
+ else
+ return pplx::task_from_exception<_CharType1>(this->exception());
+ }
+
+ // Set exception and eof states for async read
+ template
+ pplx::task<_CharType1> create_exception_checked_task(pplx::task<_CharType1> result, std::function eof_test, std::ios_base::openmode mode = std::ios_base::in | std::ios_base::out)
+ {
+ auto thisPointer = this->shared_from_this();
+
+ auto func1 = [=](pplx::task<_CharType1> t1) -> pplx::task<_CharType1> {
+ try {
+ thisPointer->m_stream_read_eof = eof_test(t1.get());
+ } catch (...) {
+ thisPointer->close(mode, std::current_exception()).get();
+ return pplx::task_from_exception<_CharType1>(thisPointer->exception(), pplx::task_options());
+ }
+ if (thisPointer->m_stream_read_eof && !(thisPointer->exception() == nullptr))
+ return pplx::task_from_exception<_CharType1>(thisPointer->exception(), pplx::task_options());
+ return t1;
+ };
+
+ if ( result.is_done() )
+ {
+ // If the data is already available, we should avoid scheduling a continuation, so we do it inline.
+ return func1(result);
+ }
+ else
+ {
+ return result.then(func1);
+ }
+ }
+
+ // Set eof states for sync read
+ int_type check_sync_read_eof(int_type ch)
+ {
+ m_stream_read_eof = ch == traits::eof();
+ return ch;
+ }
+
+ };
+
+ } // namespace details
+
+ // Forward declarations
+ template class basic_istream;
+ template class basic_ostream;
+
+ ///
+ /// Reference-counted stream buffer.
+ ///
+ ///
+ /// The data type of the basic element of the streambuf.
+ ///
+ ///
+ /// The data type of the basic element of the streambuf.
+ ///
+ template
+ class streambuf : public details::basic_streambuf<_CharType>
+ {
+ public:
+ typedef typename details::basic_streambuf<_CharType>::traits traits;
+ typedef typename details::basic_streambuf<_CharType>::int_type int_type;
+ typedef typename details::basic_streambuf<_CharType>::pos_type pos_type;
+ typedef typename details::basic_streambuf<_CharType>::off_type off_type;
+ typedef typename details::basic_streambuf<_CharType>::char_type char_type;
+
+ template friend class streambuf;
+
+ ///
+ /// Constructor.
+ ///
+ /// A pointer to the concrete stream buffer implementation.
+ streambuf(_In_ const std::shared_ptr> &ptr) : m_buffer(ptr) {}
+
+ ///
+ /// Default constructor.
+ ///
+ streambuf() { }
+
+ ///
+ /// Converter Constructor.
+ ///
+ ///
+ /// The data type of the basic element of the source streambuf.
+ ///
+ /// The source buffer to be converted.
+ template
+ streambuf(const streambuf &other) :
+ m_buffer(std::static_pointer_cast>(std::static_pointer_cast(other.m_buffer)))
+ {
+ static_assert(std::is_same::pos_type>::value
+ && std::is_same::off_type>::value
+ && std::is_integral<_CharType>::value && std::is_integral::value
+ && std::is_integral::value && std::is_integral::int_type>::value
+ && sizeof(_CharType) == sizeof(AlterCharType)
+ && sizeof(int_type) == sizeof(typename details::basic_streambuf::int_type),
+ "incompatible stream character types");
+ }
+
+ ///
+ /// Constructs an input stream head for this stream buffer.
+ ///
+ /// basic_istream.
+ concurrency::streams::basic_istream<_CharType> create_istream() const
+ {
+ if (!can_read()) throw std::runtime_error("stream buffer not set up for input of data");
+ return concurrency::streams::basic_istream<_CharType>(*this);
+ }
+
+ ///
+ /// Constructs an output stream for this stream buffer.
+ ///
+ /// basic_ostream
+ concurrency::streams::basic_ostream<_CharType> create_ostream() const
+ {
+ if (!can_write()) throw std::runtime_error("stream buffer not set up for output of data");
+ return concurrency::streams::basic_ostream<_CharType>(*this);
+ }
+
+ ///
+ /// Checks if the stream buffer has been initialized or not.
+ ///
+ operator bool() const { return (bool)m_buffer; }
+
+ ///
+ /// Destructor
+ ///
+ virtual ~streambuf() { }
+
+ const std::shared_ptr> & get_base() const
+ {
+ if (!m_buffer)
+ {
+ throw std::invalid_argument("Invalid streambuf object");
+ }
+
+ return m_buffer;
+ }
+
+ ///
+ /// can_read is used to determine whether a stream buffer will support read operations (get).
+ ///
+ virtual bool can_read() const { return get_base()->can_read(); }
+
+ ///
+ /// can_write is used to determine whether a stream buffer will support write operations (put).
+ ///
+ virtual bool can_write() const { return get_base()->can_write(); }
+
+ ///
+ /// can_seek is used to determine whether a stream buffer supports seeking.
+ ///
+ /// True if seeking is supported, false otherwise.
+ virtual bool can_seek() const { return get_base()->can_seek(); }
+
+ ///
+ /// has_size is used to determine whether a stream buffer supports size().
+ ///
+ /// True if the size API is supported, false otherwise.
+ virtual bool has_size() const { return get_base()->has_size(); }
+
+ ///
+ /// Gets the total number of characters in the stream buffer, if known. Calls to has_size will determine whether
+ /// the result of size can be relied on.
+ ///
+ /// The total number of characters in the stream buffer.
+ virtual utility::size64_t size() const { return get_base()->size(); }
+
+ ///
+ /// Gets the stream buffer size, if one has been set.
+ ///
+ /// The direction of buffering (in or out)
+ /// The size of the internal buffer (for the given direction).
+ /// An implementation that does not support buffering will always return 0.
+ virtual size_t buffer_size(std::ios_base::openmode direction = std::ios_base::in) const { return get_base()->buffer_size(direction); }
+
+ ///
+ /// Sets the stream buffer implementation to buffer or not buffer.
+ ///
+ /// The size to use for internal buffering, 0 if no buffering should be done.
+ /// The direction of buffering (in or out)
+ /// An implementation that does not support buffering will silently ignore calls to this function and it will not have any effect on what is returned by subsequent calls to .
+ virtual void set_buffer_size(size_t size, std::ios_base::openmode direction = std::ios_base::in) { get_base()->set_buffer_size(size,direction); }
+
+ ///
+ /// For any input stream, in_avail returns the number of characters that are immediately available
+ /// to be consumed without blocking. May be used in conjunction with to read data without
+ /// incurring the overhead of using tasks.
+ ///
+ /// Number of characters that are ready to read.
+ virtual size_t in_avail() const { return get_base()->in_avail(); }
+
+ ///
+ /// Checks if the stream buffer is open.
+ ///
+ /// No separation is made between open for reading and open for writing.
+ /// True if the stream buffer is open for reading or writing, false otherwise.
+ virtual bool is_open() const { return get_base()->is_open(); }
+
+ ///
+ /// is_eof is used to determine whether a read head has reached the end of the buffer.
+ ///
+ /// True if at the end of the buffer, false otherwise.
+ virtual bool is_eof() const { return get_base()->is_eof(); }
+
+ ///
+ /// Closes the stream buffer, preventing further read or write operations.
+ ///
+ /// The I/O mode (in or out) to close for.
+ virtual pplx::task close(std::ios_base::openmode mode = (std::ios_base::in | std::ios_base::out))
+ {
+ // We preserve the check here to workaround a Dev10 compiler crash
+ auto buffer = get_base();
+ return buffer ? buffer->close(mode) : pplx::task_from_result();
+ }
+
+ ///
+ /// Closes the stream buffer with an exception.
+ ///
+ /// The I/O mode (in or out) to close for.
+ /// Pointer to the exception.
+ virtual pplx::task close(std::ios_base::openmode mode, std::exception_ptr eptr)
+ {
+ // We preserve the check here to workaround a Dev10 compiler crash
+ auto buffer = get_base();
+ return buffer ? buffer->close(mode, eptr) : pplx::task_from_result();
+ }
+
+ ///
+ /// Writes a single character to the stream.
+ ///
+ /// The character to write
+ /// The value of the character. EOF if the write operation fails
+ virtual pplx::task putc(_CharType ch)
+ {
+ return get_base()->putc(ch);
+ }
+
+ ///
+ /// Allocates a contiguous memory block and returns it.
+ ///
+ /// The number of characters to allocate.
+ /// A pointer to a block to write to, null if the stream buffer implementation does not support alloc/commit.
+ virtual _CharType* alloc(size_t count)
+ {
+ return get_base()->alloc(count);
+ }
+
+ ///
+ /// Submits a block already allocated by the stream buffer.
+ ///
+ /// The number of characters to be committed.
+ virtual void commit(size_t count)
+ {
+ get_base()->commit(count);
+ }
+
+ ///
+ /// Gets a pointer to the next already allocated contiguous block of data.
+ ///
+ /// A reference to a pointer variable that will hold the address of the block on success.
+ /// The number of contiguous characters available at the address in 'ptr.'
+ /// true if the operation succeeded, false otherwise.
+ ///
+ /// A return of false does not necessarily indicate that a subsequent read operation would fail, only that
+ /// there is no block to return immediately or that the stream buffer does not support the operation.
+ /// The stream buffer may not de-allocate the block until is called.
+ /// If the end of the stream is reached, the function will return true, a null pointer, and a count of zero;
+ /// a subsequent read will not succeed.
+ ///
+ virtual bool acquire(_Out_ _CharType*& ptr, _Out_ size_t& count)
+ {
+ ptr = nullptr;
+ count = 0;
+ return get_base()->acquire(ptr, count);
+ }
+
+ ///
+ /// Releases a block of data acquired using . This frees the stream buffer to de-allocate the
+ /// memory, if it so desires. Move the read position ahead by the count.
+ ///
+ /// A pointer to the block of data to be released.
+ /// The number of characters that were read.
+ virtual void release(_Out_writes_(count) _CharType *ptr, _In_ size_t count)
+ {
+ get_base()->release(ptr, count);
+ }
+
+ ///
+ /// Writes a number of characters to the stream.
+ ///
+ /// A pointer to the block of data to be written.
+ /// The number of characters to write.
+ /// The number of characters actually written, either 'count' or 0.
+// CASABLANCA_DEPRECATED("This API in some cases performs a copy. It is deprecated and will be removed in a future release. Use putn_nocopy instead.")
+ virtual pplx::task putn(const _CharType *ptr, size_t count)
+ {
+ return get_base()->putn(ptr, count);
+ }
+
+ ///
+ /// Writes a number of characters to the stream. Note: callers must make sure the data to be written is valid until
+ /// the returned task completes.
+ ///
+ /// A pointer to the block of data to be written.
+ /// The number of characters to write.
+ /// The number of characters actually written, either 'count' or 0.
+ virtual pplx::task putn_nocopy(const _CharType *ptr, size_t count)
+ {
+ return get_base()->putn_nocopy(ptr, count);
+ }
+
+ ///
+ /// Reads a single character from the stream and advances the read position.
+ ///
+ /// The value of the character. EOF if the read fails.
+ virtual pplx::task bumpc()
+ {
+ return get_base()->bumpc();
+ }
+
+ ///
+ /// Reads a single character from the stream and advances the read position.
+ ///
+ /// The value of the character. -1 if the read fails. -2 if an asynchronous read is required
+ /// This is a synchronous operation, but is guaranteed to never block.
+ virtual typename details::basic_streambuf<_CharType>::int_type sbumpc()
+ {
+ return get_base()->sbumpc();
+ }
+
+ ///
+ /// Reads a single character from the stream without advancing the read position.
+ ///
+ /// The value of the byte. EOF if the read fails.
+ virtual pplx::task getc()
+ {
+ return get_base()->getc();
+ }
+
+ ///
+ /// Reads a single character from the stream without advancing the read position.
+ ///
+ /// The value of the character. EOF if the read fails. if an asynchronous read is required
+ /// This is a synchronous operation, but is guaranteed to never block.
+ virtual typename details::basic_streambuf<_CharType>::int_type sgetc()
+ {
+ return get_base()->sgetc();
+ }
+
+ ///
+ /// Advances the read position, then returns the next character without advancing again.
+ ///
+ /// The value of the character. EOF if the read fails.
+ pplx::task nextc()
+ {
+ return get_base()->nextc();
+ }
+
+ ///
+ /// Retreats the read position, then returns the current character without advancing.
+ ///
+ /// The value of the character. EOF if the read fails. if an asynchronous read is required
+ pplx::task ungetc()
+ {
+ return get_base()->ungetc();
+ }
+
+ ///
+ /// Reads up to a given number of characters from the stream.
+ ///
+ /// The address of the target memory area.
+ /// The maximum number of characters to read.
+ /// The number of characters read. O if the end of the stream is reached.
+ virtual pplx::task getn(_Out_writes_(count) _CharType *ptr, _In_ size_t count)
+ {
+ return get_base()->getn(ptr, count);
+ }
+
+ ///
+ /// Copies up to a given number of characters from the stream, synchronously.
+ ///
+ /// The address of the target memory area.
+ /// The maximum number of characters to read.
+ /// The number of characters copied. O if the end of the stream is reached or an asynchronous read is required.
+ /// This is a synchronous operation, but is guaranteed to never block.
+ virtual size_t scopy(_Out_writes_(count) _CharType *ptr, _In_ size_t count)
+ {
+ return get_base()->scopy(ptr, count);
+ }
+
+ ///
+ /// Gets the current read or write position in the stream.
+ ///
+ /// The I/O direction to seek (see remarks)
+ /// The current position. EOF if the operation fails.
+ /// Some streams may have separate write and read cursors.
+ /// For such streams, the direction parameter defines whether to move the read or the write cursor.
+ virtual typename details::basic_streambuf<_CharType>::pos_type getpos(std::ios_base::openmode direction) const
+ {
+ return get_base()->getpos(direction);
+ }
+
+ ///
+ /// Seeks to the given position.
+ ///
+ /// The offset from the beginning of the stream.
+ /// The I/O direction to seek (see remarks).
+ /// The position. EOF if the operation fails.
+ /// Some streams may have separate write and read cursors. For such streams, the direction parameter defines whether to move the read or the write cursor.
+ virtual typename details::basic_streambuf<_CharType>::pos_type seekpos(typename details::basic_streambuf<_CharType>::pos_type pos, std::ios_base::openmode direction)
+ {
+ return get_base()->seekpos(pos, direction);
+ }
+
+ ///
+ /// Seeks to a position given by a relative offset.
+ ///
+ /// The relative position to seek to
+ /// The starting point (beginning, end, current) for the seek.
+ /// The I/O direction to seek (see remarks)
+ /// The position. EOF if the operation fails.
+ /// Some streams may have separate write and read cursors.
+ /// For such streams, the mode parameter defines whether to move the read or the write cursor.
+ virtual typename details::basic_streambuf<_CharType>::pos_type seekoff(typename details::basic_streambuf<_CharType>::off_type offset, std::ios_base::seekdir way, std::ios_base::openmode mode)
+ {
+ return get_base()->seekoff(offset, way, mode);
+ }
+
+ ///
+ /// For output streams, flush any internally buffered data to the underlying medium.
+ ///
+ /// true if the flush succeeds, false if not
+ virtual pplx::task sync()
+ {
+ return get_base()->sync();
+ }
+
+ ///
+ /// Retrieves the stream buffer exception_ptr if it has been set.
+ ///
+ /// Pointer to the exception, if it has been set; otherwise, nullptr will be returned
+ virtual std::exception_ptr exception() const
+ {
+ return get_base()->exception();
+ }
+
+ private:
+ std::shared_ptr> m_buffer;
+
+ };
+
+}}
diff --git a/3rdparty/cpprestsdk/include/cpprest/asyncrt_utils.h b/3rdparty/cpprestsdk/include/cpprest/asyncrt_utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..eb162451276397e0180c524a2c292cfb53f65aa5
--- /dev/null
+++ b/3rdparty/cpprestsdk/include/cpprest/asyncrt_utils.h
@@ -0,0 +1,593 @@
+/***
+* ==++==
+*
+* Copyright (c) Microsoft Corporation. All rights reserved.
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*
+* ==--==
+* =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+*
+* Various common utilities.
+*
+* For the latest on this and related APIs, please see http://casablanca.codeplex.com.
+*
+* =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+****/
+
+#pragma once
+
+#include
+#include
+#include
+#include
+#include
+#include
+
+#include "pplx/pplxtasks.h"
+#include "cpprest/details/basic_types.h"
+
+#if !defined(_WIN32) || (_MSC_VER >= 1700)
+#include
+#endif
+
+#ifndef _WIN32
+#include
+#if !defined(ANDROID) && !defined(__ANDROID__) // CodePlex 269
+#include
+#endif
+#endif
+
+/// Various utilities for string conversions and date and time manipulation.
+namespace utility
+{
+
+// Left over from VS2010 support, remains to avoid breaking.
+typedef std::chrono::seconds seconds;
+
+/// Functions for converting to/from std::chrono::seconds to xml string.
+namespace timespan
+{
+ ///
+ /// Converts a timespan/interval in seconds to xml duration string as specified by
+ /// http://www.w3.org/TR/xmlschema-2/#duration
+ ///
+ _ASYNCRTIMP utility::string_t __cdecl seconds_to_xml_duration(utility::seconds numSecs);
+
+ ///
+ /// Converts an xml duration to timespan/interval in seconds
+ /// http://www.w3.org/TR/xmlschema-2/#duration
+ ///
+ _ASYNCRTIMP utility::seconds __cdecl xml_duration_to_seconds(const utility::string_t ×panString);
+}
+
+/// Functions for Unicode string conversions.
+namespace conversions
+{
+ ///
+ /// Converts a UTF-16 string to a UTF-8 string.
+ ///
+ /// A two byte character UTF-16 string.
+ /// A single byte character UTF-8 string.
+ _ASYNCRTIMP std::string __cdecl utf16_to_utf8(const utf16string &w);
+
+ ///
+ /// Converts a UTF-8 string to a UTF-16
+ ///
+ /// A single byte character UTF-8 string.
+ /// A two byte character UTF-16 string.
+ _ASYNCRTIMP utf16string __cdecl utf8_to_utf16(const std::string &s);
+
+ ///
+ /// Converts a ASCII (us-ascii) string to a UTF-16 string.
+ ///
+ /// A single byte character us-ascii string.
+ /// A two byte character UTF-16 string.
+ _ASYNCRTIMP utf16string __cdecl usascii_to_utf16(const std::string &s);
+
+ ///
+ /// Converts a Latin1 (iso-8859-1) string to a UTF-16 string.
+ ///
+ /// A single byte character UTF-8 string.
+ /// A two byte character UTF-16 string.
+ _ASYNCRTIMP utf16string __cdecl latin1_to_utf16(const std::string &s);
+
+ ///
+ /// Converts a Latin1 (iso-8859-1) string to a UTF-8 string.
+ ///
+ /// A single byte character UTF-8 string.
+ /// A single byte character UTF-8 string.
+ _ASYNCRTIMP utf8string __cdecl latin1_to_utf8(const std::string &s);
+
+ ///
+ /// Converts to a platform dependent Unicode string type.
+ ///
+ /// A single byte character UTF-8 string.
+ /// A platform dependent string type.
+ _ASYNCRTIMP utility::string_t __cdecl to_string_t(std::string &&s);
+
+ ///
+ /// Converts to a platform dependent Unicode string type.
+ ///
+ /// A two byte character UTF-16 string.
+ /// A platform dependent string type.
+ _ASYNCRTIMP utility::string_t __cdecl to_string_t(utf16string &&s);
+
+ ///
+ /// Converts to a platform dependent Unicode string type.
+ ///
+ /// A single byte character UTF-8 string.
+ /// A platform dependent string type.
+ _ASYNCRTIMP utility::string_t __cdecl to_string_t(const std::string &s);
+
+ ///
+ /// Converts to a platform dependent Unicode string type.
+ ///
+ /// A two byte character UTF-16 string.
+ /// A platform dependent string type.
+ _ASYNCRTIMP utility::string_t __cdecl to_string_t(const utf16string &s);
+
+ ///
+ /// Converts to a UTF-16 from string.
+ ///
+ /// A single byte character UTF-8 string.
+ /// A two byte character UTF-16 string.
+ _ASYNCRTIMP utf16string __cdecl to_utf16string(const std::string &value);
+
+ ///
+ /// Converts to a UTF-16 from string.
+ ///
+ /// A two byte character UTF-16 string.
+ /// A two byte character UTF-16 string.
+ _ASYNCRTIMP utf16string __cdecl to_utf16string(utf16string value);
+
+ ///
+ /// Converts to a UTF-8 string.
+ ///
+ /// A single byte character UTF-8 string.
+ /// A single byte character UTF-8 string.
+ _ASYNCRTIMP std::string __cdecl to_utf8string(std::string value);
+
+ ///
+ /// Converts to a UTF-8 string.
+ ///
+ /// A two byte character UTF-16 string.
+ /// A single byte character UTF-8 string.
+ _ASYNCRTIMP std::string __cdecl to_utf8string(const utf16string &value);
+
+ ///
+ /// Encode the given byte array into a base64 string
+ ///
+ _ASYNCRTIMP utility::string_t __cdecl to_base64(const std::vector& data);
+
+ ///
+ /// Encode the given 8-byte integer into a base64 string
+ ///
+ _ASYNCRTIMP utility::string_t __cdecl to_base64(uint64_t data);
+
+ ///
+ /// Decode the given base64 string to a byte array
+ ///
+ _ASYNCRTIMP std::vector __cdecl from_base64(const utility::string_t& str);
+
+ template
+ utility::string_t print_string(const Source &val, const std::locale &loc)
+ {
+ utility::ostringstream_t oss;
+ oss.imbue(loc);
+ oss << val;
+ if (oss.bad())
+ {
+ throw std::bad_cast();
+ }
+ return oss.str();
+ }
+
+ template
+ utility::string_t print_string(const Source &val)
+ {
+ return print_string(val, std::locale());
+ }
+
+ template
+ Target scan_string(const utility::string_t &str, const std::locale &loc)
+ {
+ Target t;
+ utility::istringstream_t iss(str);
+ iss.imbue(loc);
+ iss >> t;
+ if (iss.bad())
+ {
+ throw std::bad_cast();
+ }
+ return t;
+ }
+
+ template
+ Target scan_string(const utility::string_t &str)
+ {
+ return scan_string(str, std::locale());
+ }
+}
+
+namespace details
+{
+ ///
+ /// Cross platform RAII container for setting thread local locale.
+ ///
+ class scoped_c_thread_locale
+ {
+ public:
+ _ASYNCRTIMP scoped_c_thread_locale();
+ _ASYNCRTIMP ~scoped_c_thread_locale();
+
+#if !defined(ANDROID) && !defined(__ANDROID__) // CodePlex 269
+#ifdef _WIN32
+ typedef _locale_t xplat_locale;
+#else
+ typedef locale_t xplat_locale;
+#endif
+
+ static _ASYNCRTIMP xplat_locale __cdecl c_locale();
+#endif
+ private:
+#ifdef _WIN32
+ std::string m_prevLocale;
+ int m_prevThreadSetting;
+#elif !(defined(ANDROID) || defined(__ANDROID__))
+ locale_t m_prevLocale;
+#endif
+ scoped_c_thread_locale(const scoped_c_thread_locale &);
+ scoped_c_thread_locale & operator=(const scoped_c_thread_locale &);
+ };
+
+ ///
+ /// Our own implementation of alpha numeric instead of std::isalnum to avoid
+ /// taking global lock for performance reasons.
+ ///
+ inline bool __cdecl is_alnum(char ch)
+ {
+ return (ch >= '0' && ch <= '9')
+ || (ch >= 'A' && ch <= 'Z')
+ || (ch >= 'a' && ch <= 'z');
+ }
+
+ ///
+ /// Simplistic implementation of make_unique. A better implementation would be based on variadic templates
+ /// and therefore not be compatible with Dev10.
+ ///
+ template
+ std::unique_ptr<_Type> make_unique() {
+ return std::unique_ptr<_Type>(new _Type());
+ }
+
+ template
+ std::unique_ptr<_Type> make_unique(_Arg1&& arg1) {
+ return std::unique_ptr<_Type>(new _Type(std::forward<_Arg1>(arg1)));
+ }
+
+ template
+ std::unique_ptr<_Type> make_unique(_Arg1&& arg1, _Arg2&& arg2) {
+ return std::unique_ptr<_Type>(new _Type(std::forward<_Arg1>(arg1), std::forward<_Arg2>(arg2)));
+ }
+
+ template
+ std::unique_ptr<_Type> make_unique(_Arg1&& arg1, _Arg2&& arg2, _Arg3&& arg3) {
+ return std::unique_ptr<_Type>(new _Type(std::forward<_Arg1>(arg1), std::forward<_Arg2>(arg2), std::forward<_Arg3>(arg3)));
+ }
+
+ ///
+ /// Cross platform utility function for performing case insensitive string comparision.
+ ///
+ /// First string to compare.
+ /// Second strong to compare.
+ /// true if the strings are equivalent, false otherwise
+ inline bool str_icmp(const utility::string_t &left, const utility::string_t &right)
+ {
+#ifdef _WIN32
+ return _wcsicmp(left.c_str(), right.c_str()) == 0;
+#else
+ return boost::iequals(left, right);
+#endif
+ }
+
+#ifdef _WIN32
+
+///
+/// Category error type for Windows OS errors.
+///
+class windows_category_impl : public std::error_category
+{
+public:
+ virtual const char *name() const CPPREST_NOEXCEPT { return "windows"; }
+
+ _ASYNCRTIMP virtual std::string message(int errorCode) const CPPREST_NOEXCEPT;
+
+ _ASYNCRTIMP virtual std::error_condition default_error_condition(int errorCode) const CPPREST_NOEXCEPT;
+};
+
+///
+/// Gets the one global instance of the windows error category.
+///
+/// An error category instance.
+_ASYNCRTIMP const std::error_category & __cdecl windows_category();
+
+#else
+
+///
+/// Gets the one global instance of the linux error category.
+///
+/// An error category instance.
+_ASYNCRTIMP const std::error_category & __cdecl linux_category();
+
+#endif
+
+///
+/// Gets the one global instance of the current platform's error category.
+///
+_ASYNCRTIMP const std::error_category & __cdecl platform_category();
+
+///
+/// Creates an instance of std::system_error from a OS error code.
+///
+inline std::system_error __cdecl create_system_error(unsigned long errorCode)
+{
+ std::error_code code((int)errorCode, platform_category());
+ return std::system_error(code, code.message());
+}
+
+///
+/// Creates a std::error_code from a OS error code.
+///
+inline std::error_code __cdecl create_error_code(unsigned long errorCode)
+{
+ return std::error_code((int)errorCode, platform_category());
+}
+
+///
+/// Creates the corresponding error message from a OS error code.
+///
+inline utility::string_t __cdecl create_error_message(unsigned long errorCode)
+{
+ return utility::conversions::to_string_t(create_error_code(errorCode).message());
+}
+
+}
+
+class datetime
+{
+public:
+ typedef uint64_t interval_type;
+
+ ///
+ /// Defines the supported date and time string formats.
+ ///
+ enum date_format { RFC_1123, ISO_8601 };
+
+ ///
+ /// Returns the current UTC time.
+ ///
+ static _ASYNCRTIMP datetime __cdecl utc_now();
+
+ ///
+ /// An invalid UTC timestamp value.
+ ///
+ enum:interval_type { utc_timestamp_invalid = static_cast(-1) };
+
+ ///
+ /// Returns seconds since Unix/POSIX time epoch at 01-01-1970 00:00:00.
+ /// If time is before epoch, utc_timestamp_invalid is returned.
+ ///
+ static interval_type utc_timestamp()
+ {
+ const auto seconds = utc_now().to_interval() / _secondTicks;
+ if (seconds >= 11644473600LL)
+ {
+ return seconds - 11644473600LL;
+ }
+ else
+ {
+ return utc_timestamp_invalid;
+ }
+ }
+
+ datetime() : m_interval(0)
+ {
+ }
+
+ ///
+ /// Creates datetime from a string representing time in UTC in RFC 1123 format.
+ ///
+ /// Returns a datetime of zero if not successful.
+ static _ASYNCRTIMP datetime __cdecl from_string(const utility::string_t& timestring, date_format format = RFC_1123);
+
+ ///
+ /// Returns a string representation of the datetime.
+ ///
+ _ASYNCRTIMP utility::string_t to_string(date_format format = RFC_1123) const;
+
+ ///
+ /// Returns the integral time value.
+ ///
+ interval_type to_interval() const
+ {
+ return m_interval;
+ }
+
+ datetime operator- (interval_type value) const
+ {
+ return datetime(m_interval - value);
+ }
+
+ datetime operator+ (interval_type value) const
+ {
+ return datetime(m_interval + value);
+ }
+
+ bool operator== (datetime dt) const
+ {
+ return m_interval == dt.m_interval;
+ }
+
+ bool operator!= (const datetime& dt) const
+ {
+ return !(*this == dt);
+ }
+
+ static interval_type from_milliseconds(unsigned int milliseconds)
+ {
+ return milliseconds*_msTicks;
+ }
+
+ static interval_type from_seconds(unsigned int seconds)
+ {
+ return seconds*_secondTicks;
+ }
+
+ static interval_type from_minutes(unsigned int minutes)
+ {
+ return minutes*_minuteTicks;
+ }
+
+ static interval_type from_hours(unsigned int hours)
+ {
+ return hours*_hourTicks;
+ }
+
+ static interval_type from_days(unsigned int days)
+ {
+ return days*_dayTicks;
+ }
+
+ bool is_initialized() const
+ {
+ return m_interval != 0;
+ }
+
+private:
+
+ friend int operator- (datetime t1, datetime t2);
+
+ static const interval_type _msTicks = static_cast(10000);
+ static const interval_type _secondTicks = 1000*_msTicks;
+ static const interval_type _minuteTicks = 60*_secondTicks;
+ static const interval_type _hourTicks = 60*60*_secondTicks;
+ static const interval_type _dayTicks = 24*60*60*_secondTicks;
+
+
+#ifdef _WIN32
+ // void* to avoid pulling in windows.h
+ static _ASYNCRTIMP bool __cdecl datetime::system_type_to_datetime(/*SYSTEMTIME*/ void* psysTime, uint64_t seconds, datetime * pdt);
+#else
+ static datetime timeval_to_datetime(const timeval &time);
+#endif
+
+ // Private constructor. Use static methods to create an instance.
+ datetime(interval_type interval) : m_interval(interval)
+ {
+ }
+
+ // Storing as hundreds of nanoseconds 10e-7, i.e. 1 here equals 100ns.
+ interval_type m_interval;
+};
+
+#ifndef _WIN32
+
+// temporary workaround for the fact that
+// utf16char is not fully supported in GCC
+class cmp
+{
+public:
+
+ static int icmp(std::string left, std::string right)
+ {
+ size_t i;
+ for (i = 0; i < left.size(); ++i)
+ {
+ if (i == right.size()) return 1;
+
+ auto l = cmp::tolower(left[i]);
+ auto r = cmp::tolower(right[i]);
+ if (l > r) return 1;
+ if (l < r) return -1;
+ }
+ if (i < right.size()) return -1;
+ return 0;
+ }
+
+private:
+ static char tolower(char c)
+ {
+ if (c >= 'A' && c <= 'Z')
+ return static_cast(c - 'A' + 'a');
+ return c;
+ }
+};
+
+#endif
+
+inline int operator- (datetime t1, datetime t2)
+{
+ auto diff = (t1.m_interval - t2.m_interval);
+
+ // Round it down to seconds
+ diff /= 10 * 1000 * 1000;
+
+ return static_cast(diff);
+}
+
+///
+/// Nonce string generator class.
+///
+class nonce_generator
+{
+public:
+
+ ///
+ /// Define default nonce length.
+ ///
+ enum { default_length = 32 };
+
+ ///
+ /// Nonce generator constructor.
+ ///
+ /// Length of the generated nonce string.
+ nonce_generator(int length=default_length) :
+ m_random(static_cast(utility::datetime::utc_timestamp())),
+ m_length(length)
+ {}
+
+ ///
+ /// Generate a nonce string containing random alphanumeric characters (A-Za-z0-9).
+ /// Length of the generated string is set by length().
+ ///
+ /// The generated nonce string.
+ _ASYNCRTIMP utility::string_t generate();
+
+ ///
+ /// Get length of generated nonce string.
+ ///
+ /// Nonce string length.
+ int length() const { return m_length; }
+
+ ///
+ /// Set length of the generated nonce string.
+ ///
+ /// Lenght of nonce string.
+ void set_length(int length) { m_length = length; }
+
+private:
+ static const utility::string_t c_allowed_chars;
+ std::mt19937 m_random;
+ int m_length;
+};
+
+} // namespace utility;
diff --git a/3rdparty/cpprestsdk/include/cpprest/base_uri.h b/3rdparty/cpprestsdk/include/cpprest/base_uri.h
new file mode 100644
index 0000000000000000000000000000000000000000..f33277965a7179b9227482909a01f6ada356458a
--- /dev/null
+++ b/3rdparty/cpprestsdk/include/cpprest/base_uri.h
@@ -0,0 +1,450 @@
+/***
+* ==++==
+*
+* Copyright (c) Microsoft Corporation. All rights reserved.
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*
+* ==--==
+* =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+*
+* Protocol independent support for URIs.
+*
+* For the latest on this and related APIs, please see http://casablanca.codeplex.com.
+*
+* =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+****/
+
+#pragma once
+
+#include