merge from tfs to codeplex

Author: hohong

Release/include/astreambuf.h

@@ -152,7 +152,7 @@ namespace Concurrency { namespace streams
         virtual bool can_seek() const = 0;
 
         /// <summary>
-        /// <c>is_eof</c> is used to determine whether a read head has reached the buffer.
+        /// <c>is_eof</c> is used to determine whether a read head has reached the end of the buffer.
         /// </summary>
         virtual bool is_eof() const = 0;
 
@@ -443,7 +443,7 @@ namespace Concurrency { namespace streams
         }
 
         /// <summary>
-        /// <c>is_eof</c> is used to determine whether a read head has reached the buffer.
+        /// <c>is_eof</c> is used to determine whether a read head has reached the end of the buffer.
         /// </summary>
         virtual bool is_eof() const
         {
@@ -911,7 +911,7 @@ namespace Concurrency { namespace streams
         virtual bool is_open() const { return get_base()->is_open(); }
 
 		/// <summary>
-        /// <c>is_eof</c> is used to determine whether a read head has reached the buffer.
+        /// <c>is_eof</c> is used to determine whether a read head has reached the end of the buffer.
         /// </summary>
         virtual bool is_eof() const { return get_base()->is_eof(); }
 

Release/include/http_client.h

@@ -253,16 +253,27 @@ class http_client
     ~http_client() {}
 
     /// <summary>
-    /// Add an HTTP pipeline stage to the client.
+    /// Gets the base uri
+    /// </summary>
+    /// <returns>
+    ///	A base uri initialized in constructor
+    ///	</return>
+    const uri& base_uri() const
+    {
+        return _base_uri;
+    }
+
+    /// <summary>
+    /// Adds an HTTP pipeline stage to the client.
     /// </summary>
     /// <param name="handler">A function object representing the pipeline stage.</param>
     void add_handler(std::function<pplx::task<http_response>(http_request, std::shared_ptr<http::http_pipeline_stage>)> handler)
     {
-        m_pipeline->append(std::make_shared< ::web::http::details::function_pipeline_wrapper>(handler));
+        m_pipeline->append(std::make_shared<::web::http::details::function_pipeline_wrapper>(handler));
     }
 
 	/// <summary>
-	/// Add an HTTP pipeline stage to the client.
+	/// Adds an HTTP pipeline stage to the client.
 	/// </summary>
 	/// <param name="stage">A shared pointer to a pipeline stage.</param>
 	void add_handler(std::shared_ptr<http::http_pipeline_stage> stage)
@@ -387,8 +398,10 @@ class http_client
 private:
 
     void build_pipeline(const uri &base_uri, const http_client_config& client_config);
+	
+    std::shared_ptr<::web::http::http_pipeline> m_pipeline;
 
-    std::shared_ptr< ::web::http::http_pipeline> m_pipeline;
+	uri _base_uri;
 };
 
 } // namespace client

Release/include/http_helpers.h

@@ -40,12 +40,21 @@ namespace details
 {
     // Constants for MIME types.
     const utility::string_t content_type_application_json = U("application/json");
+
     const utility::string_t content_type_application_octetstream = U("application/octet-stream");
     const utility::string_t content_type_text_plain = U("text/plain");
     const utility::string_t content_type_text_plain_utf8 = U("text/plain; charset=utf-8");
     const utility::string_t content_type_text_plain_utf16 = U("text/plain; charset=utf-16");
     const utility::string_t content_type_text_plain_utf16le = U("text/plain; charset=utf-16le");
 
+    // Unofficial JSON MIME types...
+    const utility::string_t content_type_text_json = U("text/json");
+    const utility::string_t content_type_text_xjson = U("text/x-json");
+    const utility::string_t content_type_text_javascript = U("text/javascript");
+    const utility::string_t content_type_text_xjavascript = U("text/x-javascript");
+    const utility::string_t content_type_application_javascript = U("application/javascript");
+    const utility::string_t content_type_application_xjavascript = U("application/x-javascript");
+
     // Constants for differnet charsets.
     const utility::string_t charset_usascii = U("us-ascii");
     const utility::string_t charset_latin1 = U("iso-8859-1");
@@ -55,10 +64,15 @@ namespace details
     const utility::string_t charset_utf16be = U("utf-16be");
 
     /// <summary>
-    /// Determines which or not the given content type is 'textual' according the feature specifications.
+    /// Determines whether or not the given content type is 'textual' according the feature specifications.
     /// </summary>
     bool is_content_type_textual(const utility::string_t &content_type);
 
+    /// <summary>
+    /// Determines whether or not the given content type is JSON according the feature specifications.
+    /// </summary>
+    bool is_content_type_json(const utility::string_t &content_type);
+
     /// <summary>
     /// Parses the given Content-Type header value to get out actual content type and charset.
     /// If the charset isn't specified the default charset for the content type will be set.

Release/include/json.h

@@ -171,21 +171,6 @@ namespace web { namespace json
         /// <returns>The JSON value object that contains the result of the assignment.</returns>
         _ASYNCRTIMP value &operator=(value &&);
 
-        /// <summary>
-        /// Constructor creating a JSON value from an input stream, by parsing its contents.
-        /// </summary>
-        /// <param name="input">The stream to read the JSON value from</param>
-        /// <returns>The JSON value object created from the input stream.</returns>
-        _ASYNCRTIMP static value parse(utility::istream_t &input);
-
-#ifdef _MS_WINDOWS
-        /// <summary>
-        /// Constructor creating a JSON value from a byte buffer stream, by parsing its contents.
-        /// </summary>
-        /// <param name="stream">The stream to read the JSON value from</param>
-        _ASYNCRTIMP static value parse(std::istream& stream);
-#endif
-
         // Static factories
 
         /// <summary>
@@ -312,31 +297,44 @@ namespace web { namespace json
         /// <returns>The number of children. 0 for all non-composites.</returns>
         size_t size() const;
 
+        /// <summary>
+        /// Parse a string and construct a JSON value.
+        /// </summary>
+        /// <param name="value">The C++ value to create a JSON value from, a C++ STL double-byte string</param>
+        _ASYNCRTIMP static value parse(utility::string_t);
+
         /// <summary>
         /// Serialize the current JSON value to a C++ string.
         /// </summary>
         /// <returns>A string representation of the value</returns>
         _ASYNCRTIMP utility::string_t to_string() const;
 
         /// <summary>
-        /// Parse a string and construct a JSON value.
+        /// Parse a JSON value from the contents of an input stream using the native platform character width.
         /// </summary>
-        /// <param name="value">The C++ value to create a JSON value from, a C++ STL double-byte string</param>
-        _ASYNCRTIMP static value parse(utility::string_t);
+        /// <param name="input">The stream to read the JSON value from</param>
+        /// <returns>The JSON value object created from the input stream.</returns>
+        _ASYNCRTIMP static value parse(utility::istream_t &input);
 
-#ifdef _MS_WINDOWS
         /// <summary>
-        /// Write the current JSON value as a double-byte string to a stream instance.
+        /// Write the current JSON value to a stream with the native platform character width.
         /// </summary>
         /// <param name="stream">The stream that the JSON string representation should be written to.</param>
-        _ASYNCRTIMP void serialize(std::basic_ostream<utf16char> &stream) const;
-#endif
+        _ASYNCRTIMP void serialize(utility::ostream_t &stream) const;
 
+#ifdef _MS_WINDOWS
         /// <summary>
-        /// Serialize the content of the value into a stream in UTF8 format
+        /// Parse a JSON value from the contents of a single-byte (UTF8) stream.
+        /// </summary>
+        /// <param name="stream">The stream to read the JSON value from</param>
+        _ASYNCRTIMP static value parse(std::istream& stream);
+
+		/// <summary>
+        /// Serialize the content of the value into a single-byte (UTF8) stream.
         /// </summary>
         /// <param name="stream">The stream that the JSON string representation should be written to.</param>
-        _ASYNCRTIMP void serialize(std::basic_ostream<char>& stream) const;
+        _ASYNCRTIMP void serialize(std::ostream& stream) const;
+#endif
 
 		/// <summary>
         /// Convert the JSON value to a C++ double, if and only if it is a number value.
@@ -381,6 +379,13 @@ namespace web { namespace json
             return !((*this) == other);
         }
 
+        /// <summary>
+        /// Access a field of a JSON object.
+        /// </summary>
+        /// <param name="key">The name of the field</param>
+        /// <returns>The value kept in the field; null if the field does not exist</returns>
+        value get(const utility::string_t &key) const;
+
         /// <summary>
         /// Access a field of a JSON object.
         /// </summary>
@@ -406,6 +411,13 @@ namespace web { namespace json
 public:
 #endif
 
+        /// <summary>
+        /// Access an element of a JSON array.
+        /// </summary>
+        /// <param name="key">The index of an element in the JSON array</param>
+        /// <returns>The value kept at the array index; null if outside the boundaries of the array</returns>
+        value get(size_t index) const;
+
         /// <summary>
         /// Accesses an element of a JSON array.
         /// </summary>
@@ -530,6 +542,9 @@ namespace web { namespace json
             virtual const json::value::element_vector &elements() const { throw json_exception(U("not an array")); }
             virtual const json::value::field_map &fields() const { throw json_exception(U("not an object")); }
 
+            virtual value get_field(const utility::string_t &) const { throw json_exception(U("not an object")); }
+            virtual value get_element(std::vector<value>::size_type) const { throw json_exception(U("not an array")); }
+
             virtual value &index(const utility::string_t &) { throw json_exception(U("not an object")); }
             virtual value &index(std::vector<value>::size_type) { throw json_exception(U("not an array")); }
 
@@ -775,6 +790,7 @@ namespace web { namespace json
 
             virtual json::value::value_type type() const { return json::value::Object; }
 
+            _ASYNCRTIMP virtual value get_field(const utility::string_t &) const;
             _ASYNCRTIMP virtual json::value &index(const utility::string_t &key);
             _ASYNCRTIMP virtual const json::value &cnst_index(const utility::string_t &key) const;
 
@@ -843,6 +859,18 @@ namespace web { namespace json
 
             virtual json::value::value_type type() const { return json::value::Array; }
 
+            virtual value get_element(std::vector<value>::size_type index) const
+            {
+#ifdef _MS_WINDOWS
+               msl::utilities::SafeInt<std::vector<json::value>::size_type> idx(index);
+               msl::utilities::SafeInt<std::vector<json::value>::size_type> size(m_elements.size());
+#else
+               size_t idx = index;
+               size_t size = m_elements.size();
+#endif
+                return (idx >= size) ? value() : m_elements[index].second; 
+            }
+
             virtual json::value &index(std::vector<json::value>::size_type index)
             {
 #ifdef _MS_WINDOWS
@@ -925,6 +953,17 @@ namespace web { namespace json
         return m_value->size();
     }
 
+    inline json::value json::value::get(const utility::string_t& key) const
+    {
+        return m_value->get_field(key);
+    }
+
+    inline json::value json::value::get(size_t index) const
+    {
+        return m_value->get_element(index);
+    }
+
+
     inline json::value::iterator json::value::begin()
     {
         return m_value->elements().begin();

Release/include/pplxtasks.h

@@ -847,7 +847,7 @@ namespace details
 
     // Specializations to avoid marshaling for strings and arrays.
     template<typename _Type>
-    struct _MarshalHelper< ::Platform::Array<_Type^>>
+    struct _MarshalHelper<::Platform::Array<_Type^>>
     {
         static ::Platform::Array<_Type^>^ _Perform(::Platform::Array<_Type^>^& _ObjInCtx, const _ContextCallback& _Ctx)
         {
@@ -856,7 +856,7 @@ namespace details
     };
 
     template<>
-    struct _MarshalHelper< ::Platform::String>
+    struct _MarshalHelper<::Platform::String>
     {
         static ::Platform::String^ _Perform(::Platform::String^& _ObjInCtx, const _ContextCallback& _Ctx)
         {
@@ -7320,15 +7320,19 @@ namespace details
     inline
     task<bool> do_while(std::function<task<bool>(void)> func)
     {
-        task<bool> first = func();
-        return first.then([=](bool guard) -> task<bool> {
-            if (guard)
-                return do_while(func);
-            else
-                return first;
-            });
-    }
+        task<bool> cond = func();
 
+        while ( cond.is_done() )
+        {
+            if ( !cond.get() )
+                return task_from_result(true);
+            cond = func();
+        }
+
+        return cond.then([=](task<bool> guard) {
+            return (guard.get()) ? do_while(func) : task_from_result(true);
+        });
+    }
 } // namespace details
 
 } // namespace pplx