diff --git a/.gitignore b/.gitignore
index cfe6466d62acee4c3f0048af5b024fd6e2cb6fb3..b3b39f01d3b5b08e961a675918f9ac183ae84da2 100644
--- a/.gitignore
+++ b/.gitignore
@@ -26,3 +26,8 @@ spectrum2_swiften_backend
spectrum2_template_backend
spectrum2_twitter_backend
install_manifest.txt
+slack.cfg
+*.sqlite
+localhost.port
+*.a
+
diff --git a/3rdparty/CMakeLists.txt b/3rdparty/CMakeLists.txt
deleted file mode 100644
index b9c185966fe191b9a7468604688853e942de1a58..0000000000000000000000000000000000000000
--- a/3rdparty/CMakeLists.txt
+++ /dev/null
@@ -1 +0,0 @@
-ADD_SUBDIRECTORY(cpprestsdk)
diff --git a/3rdparty/cpprestsdk/CMakeLists.txt b/3rdparty/cpprestsdk/CMakeLists.txt
deleted file mode 100644
index 8edeec94763ed97b4d99cbb301e0a2854ebe8eeb..0000000000000000000000000000000000000000
--- a/3rdparty/cpprestsdk/CMakeLists.txt
+++ /dev/null
@@ -1,204 +0,0 @@
-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
deleted file mode 100644
index bdbd321a8d381b7d9bf85c31dc3e8de9fc83e008..0000000000000000000000000000000000000000
--- a/3rdparty/cpprestsdk/dirs.proj
+++ /dev/null
@@ -1,16 +0,0 @@
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
diff --git a/3rdparty/cpprestsdk/include/cpprest/astreambuf.h b/3rdparty/cpprestsdk/include/cpprest/astreambuf.h
deleted file mode 100644
index a12605d9add647321d6b9ae030eb62f54cf17d1c..0000000000000000000000000000000000000000
--- a/3rdparty/cpprestsdk/include/cpprest/astreambuf.h
+++ /dev/null
@@ -1,1199 +0,0 @@
-/***
-* ==++==
-*
-* 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
deleted file mode 100644
index eb162451276397e0180c524a2c292cfb53f65aa5..0000000000000000000000000000000000000000
--- a/3rdparty/cpprestsdk/include/cpprest/asyncrt_utils.h
+++ /dev/null
@@ -1,593 +0,0 @@
-/***
-* ==++==
-*
-* 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
deleted file mode 100644
index f33277965a7179b9227482909a01f6ada356458a..0000000000000000000000000000000000000000
--- a/3rdparty/cpprestsdk/include/cpprest/base_uri.h
+++ /dev/null
@@ -1,450 +0,0 @@
-/***
-* ==++==
-*
-* 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