Merge branch 'development' of https://git01.codeplex.com/casablanca into default_workarounds

Author: stgates

CONTRIBUTORS.txt

@@ -9,5 +9,6 @@ Brian Wengert (bwengert79)
 Leslie Brody (Les1966)
 Michael M (M1xa)
 Matt Peterson (MattPeterson1)
+Dmitry Kolomiets (kolomiets)
 
 

Release/include/cpprest/asyncrt_utils.h

@@ -49,8 +49,10 @@ namespace pplx = Concurrency;
 
 #ifndef _MS_WINDOWS
 #include <boost/algorithm/string.hpp>
+#ifndef ANDROID // CodePlex 269
 #include <xlocale.h>
 #endif
+#endif
 
 /// Various utilities for string conversions and date and time manipulation.
 namespace utility
@@ -170,18 +172,20 @@ namespace details
         _ASYNCRTIMP scoped_c_thread_locale();
         _ASYNCRTIMP ~scoped_c_thread_locale();
 
+#ifndef ANDROID // CodePlex 269
 #ifdef _MS_WINDOWS
         typedef _locale_t xplat_locale;
 #else
         typedef locale_t xplat_locale;
 #endif
 
         static _ASYNCRTIMP xplat_locale __cdecl c_locale();
+#endif
     private:
 #ifdef _MS_WINDOWS
         std::string m_prevLocale;
         int m_prevThreadSetting;
-#else
+#elif !defined(ANDROID)
         locale_t m_prevLocale;        
 #endif
         scoped_c_thread_locale(const scoped_c_thread_locale &);

Release/include/cpprest/filestream.h

@@ -737,7 +737,6 @@ namespace details {
         }
 #endif
 
-#pragma region Completion callback interface implementations
         class _filestream_callback_open : public details::_filestream_callback
         {
         public:
@@ -942,7 +941,6 @@ namespace details {
             _file_info *m_info;
             pplx::task_completion_event<int_type> m_op;
         };
-#pragma endregion
 
         _file_info *m_info;
         async_operation_queue m_readOps;

Release/include/cpprest/http_listener.h

@@ -139,6 +139,7 @@ class http_listener_impl
 
     http_listener_impl()
         : m_closed(true)
+        , m_close_task(pplx::task_from_result())
     {
     }
 
@@ -176,6 +177,7 @@ class http_listener_impl
 
     // Used to record that the listener is closed.
     bool m_closed;
+    pplx::task<void> m_close_task;
 };
 
 } // namespace details
@@ -315,4 +317,4 @@ class http_listener
 } // namespace http
 } // namespace web
 
-#endif  /* _CASA_HTTP_LISTENER_H */
+#endif  /* _CASA_HTTP_LISTENER_H */

Release/include/cpprest/interopstream.h

@@ -57,7 +57,6 @@ namespace Concurrency { namespace streams {
     template<typename CharType> class stdio_ostream;
     template<typename CharType> class stdio_istream;
 
-#pragma region Asynchronous streams on top of synchronous stream buffers.
     namespace details {
 
     /// <summary>
@@ -104,7 +103,7 @@ namespace Concurrency { namespace streams {
         virtual size_t buffer_size(std::ios_base::openmode direction = std::ios_base::in) const { return 0; }
         virtual void set_buffer_size(size_t size, std::ios_base::openmode direction = std::ios_base::in) { return; }
 
-        virtual pplx::task<bool> _sync() { return pplx::task_from_result(m_buffer->pubsync() != std::char_traits<_CharType>::eof()); }
+        virtual pplx::task<bool> _sync() { return pplx::task_from_result(m_buffer->pubsync() == 0); }
 
         virtual pplx::task<int_type> _putc(_CharType ch) { return pplx::task_from_result(m_buffer->sputc(ch)); }
         virtual pplx::task<size_t> _putn(const _CharType *ptr, size_t size) { return pplx::task_from_result((size_t)m_buffer->sputn(ptr, size)); }
@@ -228,10 +227,6 @@ namespace Concurrency { namespace streams {
         stdio_istream & operator =(const stdio_istream &other) { basic_istream<CharType>::operator=(other); return *this; }
     };
 
-#pragma endregion
-
-#pragma region Synchronous streams on top of asynchronous stream buffers.
-
     namespace details {
 
     /// <summary>
@@ -504,10 +499,8 @@ namespace Concurrency { namespace streams {
     private:
         details::basic_async_streambuf<CharType> m_strbuf;
     };
-#pragma endregion
 
 #if defined(__cplusplus_winrt)
-#pragma region WinRT streams interop
 
     /// <summary>
     /// Static class containing factory functions for WinRT streams implemented on top of Casablanca async streams.
@@ -554,7 +547,6 @@ namespace Concurrency { namespace streams {
     };
 
 #endif
-#pragma endregion
 
 }} // namespaces
 #pragma warning(pop) // 4100

Release/include/cpprest/json.h

@@ -150,16 +150,56 @@ namespace json
         /// Constructor creating a JSON string value
         /// </summary>
         /// <param name="value">The C++ value to create a JSON value from, a C++ STL string of the platform-native character width</param>
-        _ASYNCRTIMP explicit value(utility::string_t);
+        /// <remarks>
+        /// This constructor has O(n) performance because it tries to determine if
+        /// specified string has characters that should be properly escaped in JSON. 
+        /// <remarks>
+        _ASYNCRTIMP explicit value(utility::string_t value);
+
+        /// <summary>
+        /// Constructor creating a JSON string value specifying if the string contains characters to escape
+        /// </summary>
+        /// <param name="value">The C++ value to create a JSON value from, a C++ STL string of the platform-native character width</param>
+        /// <param name="has_escape_chars">Whether <paramref name="value" /> contains characters 
+        /// that should be escaped in JSON value</param>
+        /// <remarks>
+        /// This constructor has O(1) performance.
+        /// </remarks>
+        _ASYNCRTIMP explicit value(utility::string_t value, bool has_escape_chars);
 
         /// <summary>
         /// Constructor creating a JSON string value
         /// </summary>
         /// <param name="value">The C++ value to create a JSON value from, a C++ STL string of the platform-native character width</param>
-        /// <remarks>This constructor exists in order to avoid string literals matching another constructor,
+        /// <remarks>
+        /// <para>
+        /// This constructor has O(n) performance because it tries to determine if
+        /// specified string has characters that should be properly escaped in JSON. 
+        /// </para>
+        /// <para>
+        /// This constructor exists in order to avoid string literals matching another constructor,
         /// as is very likely. For example, conversion to bool does not require a user-defined conversion,
-        /// and will therefore match first, which means that the JSON value turns up as a boolean.</remarks>
-        _ASYNCRTIMP explicit value(const utility::char_t *);
+        /// and will therefore match first, which means that the JSON value turns up as a boolean.
+        /// </para>
+        /// </remarks>
+        _ASYNCRTIMP explicit value(const utility::char_t* value);
+
+        /// <summary>
+        /// Constructor creating a JSON string value
+        /// </summary>
+        /// <param name="value">The C++ value to create a JSON value from, a C++ STL string of the platform-native character width</param>
+        /// <param name="has_escape_chars">Whether <paramref name="value" /> contains characters 
+        /// <remarks>
+        /// <para>
+        /// This overload has O(1) performance.
+        /// </para>
+        /// <para>
+        /// This constructor exists in order to avoid string literals matching another constructor,
+        /// as is very likely. For example, conversion to bool does not require a user-defined conversion,
+        /// and will therefore match first, which means that the JSON value turns up as a boolean.
+        /// </para>
+        /// </remarks>
+        _ASYNCRTIMP explicit value(const utility::char_t* value, bool has_escape_chars);
 
         /// <summary>
         /// Copy constructor
@@ -217,8 +257,24 @@ namespace json
         /// </summary>
         /// <param name="value">The C++ value to create a JSON value from</param>
         /// <returns>A JSON string value</returns>
+        /// <remarks>
+        /// This overload has O(n) performance because it tries to determine if
+        /// specified string has characters that should be properly escaped in JSON. 
+        /// <remarks>
         static _ASYNCRTIMP value __cdecl string(utility::string_t value);
 
+        /// <summary>
+        /// Creates a string value specifying if the string contains characters to escape
+        /// </summary>
+        /// <param name="value">The C++ value to create a JSON value from</param>
+        /// <param name="has_escape_chars">Whether <paramref name="value" /> contains characters 
+        /// that should be escaped in JSON value</param>
+        /// <returns>A JSON string value</returns>
+        /// <remarks>
+        /// This overload has O(1) performance.
+        /// </remarks>
+        static _ASYNCRTIMP value __cdecl string(utility::string_t value, bool has_escape_chars);
+
 #ifdef _MS_WINDOWS
 private:
         // Only used internally by JSON parser.

Release/include/cpprest/streams.h

@@ -953,18 +953,41 @@ namespace Concurrency { namespace streams
             if ( !target.can_write() )
                 return pplx::task_from_exception<size_t>(std::make_exception_ptr(std::runtime_error("source buffer not set up for input of data")));
 
-            // Capture 'buffer' rather than 'helper' here due to VC++ 2010 limitations.
-            auto buffer = helper()->m_buffer;
+            auto l_buffer = helper()->m_buffer;
+            auto l_buf_size = this->buf_size;
+            std::shared_ptr<_read_helper> l_locals = std::make_shared<_read_helper>();
 
-            std::shared_ptr<_read_helper> _locals = std::make_shared<_read_helper>();
+            auto copy_to_target = [l_locals, target, l_buffer, l_buf_size]() mutable -> pplx::task<bool>
+            {
+                // We need to capture these, because the object itself may go away
+                // before we're done processing the data.
+                //auto locs = _locals;
+                //auto trg = target;
+
+                return l_buffer.getn(l_locals->outbuf, l_buf_size).then([=](size_t rd) mutable -> pplx::task<bool>
+                {
+                    if (rd == 0)
+                        return pplx::task_from_result(false);
 
-            _dev10_ice_workaround wrkarnd(buffer, target, _locals, buf_size);
+                    // Must be nested to capture rd
+                    return target.putn(l_locals->outbuf, rd).then([target, l_locals, rd](size_t wr) mutable -> pplx::task<bool>
+                    {
+                        l_locals->total += wr;
 
-            auto loop = pplx::details::do_while(wrkarnd);
+                        if (rd != wr)
+                            // Number of bytes written is less than number of bytes received.
+                            throw std::runtime_error("failed to write all bytes");
+
+                        return target.sync().then([]() { return true; });
+                    });
+                });
+            };
+
+            auto loop = pplx::details::do_while(copy_to_target);
 
             return loop.then([=](bool) mutable -> size_t
                 { 
-                    return _locals->total; 
+                    return l_locals->total; 
                 });
         }
 
@@ -1104,48 +1127,6 @@ namespace Concurrency { namespace streams
             }
         };
 
-        // To workaround a VS 2010 internal compiler error, we have to do our own
-        // "lambda" here...
-        class _dev10_ice_workaround
-        {
-        public:
-            _dev10_ice_workaround(streams::streambuf<CharType> buffer,
-                                  concurrency::streams::streambuf<CharType> target,
-                                  std::shared_ptr<typename basic_istream::_read_helper> locals,
-                                  size_t buf_size)
-            : _buffer(buffer), _target(target), _locals(locals), _buf_size(buf_size)
-            {
-            }
-            pplx::task<bool> operator()()
-            {
-                // We need to capture these, because the object itself may go away
-                // before we're done processing the data.
-                auto locs = _locals;
-                auto trg = _target;
-                
-                auto after_putn =
-                [=](size_t wr) mutable -> bool
-                {
-                    locs->total += wr;
-                    trg.sync().wait();
-                    return true;
-                };
-                
-                return _buffer.getn(locs->outbuf, buf_size).then(
-                                                                 [=] (size_t rd) mutable -> pplx::task<bool>
-                                                                 {
-                                                                     if ( rd == 0 )
-                                                                         return pplx::task_from_result(false);
-                                                                     return trg.putn(locs->outbuf, rd).then(after_putn);
-                                                                 });
-            }
-        private:
-            size_t _buf_size;
-            concurrency::streams::streambuf<CharType> _buffer;
-            concurrency::streams::streambuf<CharType> _target;
-            std::shared_ptr<typename basic_istream::_read_helper> _locals;
-        };
-        
         std::shared_ptr<details::basic_istream_helper<CharType>> m_helper;
     };
 

Release/src/build/casablanca110.vcxproj

@@ -43,7 +43,7 @@
       <AdditionalIncludeDirectories>$(CasablancaIncludeDir);$(CasablancaSrcDir)\pch;$(WebsocketppIncludeDir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PrecompiledHeader>Use</PrecompiledHeader>
       <PrecompiledHeaderFile>stdafx.h</PrecompiledHeaderFile>
-      <AdditionalOptions>-Zm160 %(AdditionalOptions)</AdditionalOptions>
+      <AdditionalOptions>-Zm160 /bigobj%(AdditionalOptions)</AdditionalOptions>
     </ClCompile>
     <Link>
       <AdditionalDependencies>Winhttp.lib;httpapi.lib;bcrypt.lib;%(AdditionalDependencies)</AdditionalDependencies>

Release/src/build/casablanca110.winrt.vcxproj

@@ -48,7 +48,7 @@
       <AdditionalIncludeDirectories>$(CasablancaIncludeDir);$(CasablancaSrcDir)\pch;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PrecompiledHeader>Use</PrecompiledHeader>
       <PrecompiledHeaderFile>stdafx.h</PrecompiledHeaderFile>
-      <AdditionalOptions>-Zm250 %(AdditionalOptions)</AdditionalOptions>
+      <AdditionalOptions>-Zm250 /bigobj %(AdditionalOptions)</AdditionalOptions>
     </ClCompile>
     <Link>
       <AdditionalDependencies>msxml6.lib;kernel32.lib;user32.lib;%(AdditionalDependencies)</AdditionalDependencies>

Release/src/build/casablanca110.xp.vcxproj

@@ -43,7 +43,7 @@
       <AdditionalIncludeDirectories>$(CasablancaIncludeDir);$(CasablancaSrcDir)\pch;$(WebsocketppIncludeDir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PrecompiledHeader>Use</PrecompiledHeader>
       <PrecompiledHeaderFile>stdafx.h</PrecompiledHeaderFile>
-      <AdditionalOptions>-Zm160 %(AdditionalOptions)</AdditionalOptions>
+      <AdditionalOptions>-Zm160 /bigobj %(AdditionalOptions)</AdditionalOptions>
     </ClCompile>
     <Link>
       <AdditionalDependencies>Kernel32.lib;Winhttp.lib;httpapi.lib;bcrypt.lib;%(AdditionalDependencies)</AdditionalDependencies>