微软开源网络库：c++REST SDK 编译包

/*** * Copyright (C) Microsoft. All rights reserved. * Licensed under the MIT license. See LICENSE.txt file in the project root for full license information. * * =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+ * * Parallel Patterns Library - PPLx Tasks * * For the latest on this and related APIs, please see: https://github.com/Microsoft/cpprestsdk * * =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- ****/ #pragma once #ifndef PPLXTASKS_H #define PPLXTASKS_H #include "cpprest/details/cpprest_compat.h" #if (defined(_MSC_VER) && (_MSC_VER >= 1800)) && !CPPREST_FORCE_PPLX #include <ppltasks.h> namespace pplx = Concurrency; namespace Concurrency { /// <summary> /// Sets the ambient scheduler to be used by the PPL constructs. /// </summary> _ASYNCRTIMP void __cdecl set_cpprestsdk_ambient_scheduler(const std::shared_ptr<scheduler_interface>& _Scheduler); /// <summary> /// Gets the ambient scheduler to be used by the PPL constructs /// </summary> _ASYNCRTIMP const std::shared_ptr<scheduler_interface>& __cdecl get_cpprestsdk_ambient_scheduler(); } // namespace Concurrency #if (_MSC_VER >= 1900) #include <concrt.h> namespace Concurrency { namespace extensibility { typedef ::std::condition_variable condition_variable_t; typedef ::std::mutex critical_section_t; typedef ::std::unique_lock< ::std::mutex> scoped_critical_section_t; typedef ::Concurrency::event event_t; typedef ::Concurrency::reader_writer_lock reader_writer_lock_t; typedef ::Concurrency::reader_writer_lock::scoped_lock scoped_rw_lock_t; typedef ::Concurrency::reader_writer_lock::scoped_lock_read scoped_read_lock_t; typedef ::Concurrency::details::_ReentrantBlockingLock recursive_lock_t; typedef recursive_lock_t::_Scoped_lock scoped_recursive_lock_t; } } #endif // _MSC_VER >= 1900 #else #include "pplx/pplx.h" #if defined(__ANDROID__) #include <jni.h> void cpprest_init(JavaVM*); #endif // Cannot build using a compiler that is older than dev10 SP1 #if defined(_MSC_VER) #if _MSC_FULL_VER < 160040219 /*IFSTRIP=IGN*/ #error ERROR: Visual Studio 2010 SP1 or later is required to build ppltasks #endif /*IFSTRIP=IGN*/ #endif /* defined(_MSC_VER) */ #include <functional> #include <vector> #include <utility> #include <exception> #include <algorithm> #include <atomic> #if defined(_MSC_VER) #include <intrin.h> #if defined(__cplusplus_winrt) #include <windows.h> #include <ctxtcall.h> #include <agile.h> #include <winapifamily.h> #ifndef _UITHREADCTXT_SUPPORT #ifdef WINAPI_FAMILY /*IFSTRIP=IGN*/ // It is safe to include winapifamily as WINAPI_FAMILY was defined by the user #include <winapifamily.h> #if WINAPI_FAMILY == WINAPI_FAMILY_APP // UI thread context support is not required for desktop and Windows Store apps #define _UITHREADCTXT_SUPPORT 0 #elif WINAPI_FAMILY == WINAPI_FAMILY_DESKTOP_APP // UI thread context support is not required for desktop and Windows Store apps #define _UITHREADCTXT_SUPPORT 0 #else /* WINAPI_FAMILY == WINAPI_FAMILY_DESKTOP_APP */ #define _UITHREADCTXT_SUPPORT 1 #endif /* WINAPI_FAMILY == WINAPI_FAMILY_DESKTOP_APP */ #else /* WINAPI_FAMILY */ // Not supported without a WINAPI_FAMILY setting. #define _UITHREADCTXT_SUPPORT 0 #endif /* WINAPI_FAMILY */ #endif /* _UITHREADCTXT_SUPPORT */ #if _UITHREADCTXT_SUPPORT #include <uithreadctxt.h> #endif /* _UITHREADCTXT_SUPPORT */ #pragma detect_mismatch("PPLXTASKS_WITH_WINRT", "1") #else /* defined(__cplusplus_winrt) */ #pragma detect_mismatch("PPLXTASKS_WITH_WINRT", "0") #endif /* defined(__cplusplus_winrt) */ #endif /* defined(_MSC_VER) */ #ifdef _DEBUG #define _DBG_ONLY(X) X #else #define _DBG_ONLY(X) #endif // #ifdef _DEBUG // std::copy_exception changed to std::make_exception_ptr from VS 2010 to VS 11. #ifdef _MSC_VER #if _MSC_VER < 1700 /*IFSTRIP=IGN*/ namespace std { template<class _E> exception_ptr make_exception_ptr(_E _Except) { return copy_exception(_Except); } } #endif /* _MSC_VER < 1700 */ #ifndef PPLX_TASK_ASYNC_LOGGING #if _MSC_VER >= 1800 && defined(__cplusplus_winrt) #define PPLX_TASK_ASYNC_LOGGING 1 // Only enable async logging under dev12 winrt #else #define PPLX_TASK_ASYNC_LOGGING 0 #endif #endif /* !PPLX_TASK_ASYNC_LOGGING */ #endif /* _MSC_VER */ #pragma pack(push,_CRT_PACKING) #if defined(_MSC_VER) #pragma warning(push) #pragma warning(disable: 28197) #pragma warning(disable: 4100) // Unreferenced formal parameter - needed for document generation #pragma warning(disable: 4127) // constant express in if condition - we use it for meta programming #endif /* defined(_MSC_VER) */ // All CRT public header files are required to be protected from the macro new #pragma push_macro("new") #undef new // stuff ported from Dev11 CRT // NOTE: this doesn't actually match std::declval. it behaves differently for void! // so don't blindly change it to std::declval. namespace stdx { template<class _T> _T&& declval(); } /// <summary> /// The <c>pplx</c> namespace provides classes and functions that give you access to the Concurrency Runtime, /// a concurrent programming framework for C++. For more information, see <see cref="Concurrency Runtime"/>. /// </summary> /**/ namespace pplx { /// <summary> /// A type that represents the terminal state of a task. Valid values are <c>completed</c> and <c>canceled</c>. /// </summary> /// <seealso cref="task Class"/> /**/ typedef task_group_status task_status; template <typename _Type> class task; template <> class task<void>; // In debug builds, default to 10 frames, unless this is overridden prior to #includ'ing ppltasks.h. In retail builds, default to only one frame. #ifndef PPLX_TASK_SAVE_FRAME_COUNT #ifdef _DEBUG #define PPLX_TASK_SAVE_FRAME_COUNT 10 #else #define PPLX_TASK_SAVE_FRAME_COUNT 1 #endif #endif /// <summary> /// Helper macro to determine how many stack frames need to be saved. When any number less or equal to 1 is specified, /// only one frame is captured and no stackwalk will be involved. Otherwise, the number of callstack frames will be captured. /// </summary> /// <ramarks> /// This needs to be defined as a macro rather than a function so that if we're only gathering one frame, _ReturnAddress() /// will evaluate to client code, rather than a helper function inside of _TaskCreationCallstack, itself. /// </remarks> #if PPLX_TASK_SAVE_FRAME_COUNT > 1 #if defined(__cplusplus_winrt) && !defined(_DEBUG) #pragma message ("WARNING: Redefining PPLX_TASK_SAVE_FRAME_COUNT under Release build for non-desktop applications is not supported; only one frame will be captured!") #define PPLX_CAPTURE_CALLSTACK() ::pplx::details::_TaskCreationCallstack::_CaptureSingleFrameCallstack(_ReturnAddress()) #else #define PPLX_CAPTURE_CALLSTACK() ::pplx::details::_TaskCreationCallstack::_CaptureMultiFramesCallstack(PPLX_TASK_SAVE_FRAME_COUNT) #endif #else #define PPLX_CAPTURE_CALLSTACK() ::pplx::details::_TaskCreationCallstack::_CaptureSingleFrameCallstack(_ReturnAddress()) #endif /// <summary> /// Returns an indication of whether the task that is currently executing has received a request to cancel its /// execution. Cancellation is requested on a task if the task was created with a cancellation token, and /// the token source associated with that token is canceled. /// </summary> /// <returns> /// <c>true</c> if the currently executing task has received a request for cancellation, <c>false</c> otherwise. /// </returns> /// <remarks> /// If you call this method in the body of a task and it returns <c>true</c>, you