Libc++ on OSX does not provide std::ctype<char16_t>

We therefore cannot use char16_t based iostreams while under libc++.

Author: ras0219-msft

Release/include/cpprest/asyncrt_utils.h

@@ -210,6 +210,7 @@ namespace conversions
         }
         return t;
     }
+#if !defined(_LIBCPP_VERSION)
     template <typename Target>
     Target scan_string(const utf16string &str, const std::locale &loc = std::locale())
     {
@@ -223,6 +224,7 @@ namespace conversions
         }
         return t;
     }
+#endif
 
 }
 

Release/include/cpprest/details/basic_types.h

@@ -116,12 +116,15 @@ typedef std::wistringstream utf16istringstream;
 #else
 typedef char16_t utf16char;
 typedef std::u16string utf16string;
+// Libc++ does not define std::ctype<char16_t> which prevents the following streams from working.
+#if !defined(_LIBCPP_VERSION)
 typedef std::basic_stringstream<utf16char> utf16stringstream;
 typedef std::basic_ostringstream<utf16char> utf16ostringstream;
 typedef std::basic_ostream<utf16char> utf16ostream;
 typedef std::basic_istream<utf16char> utf16istream;
 typedef std::basic_istringstream<utf16char> utf16istringstream;
 #endif
+#endif
 
 
 #if defined(_WIN32)

Release/include/cpprest/json.h

@@ -527,7 +527,9 @@ namespace json
         /// </summary>
         /// <param name="stream">The stream to read the JSON value from</param>
         _ASYNCRTIMP static value __cdecl parse(std::istream& stream);
+#if !defined(_LIBCPP_VERSION)
         _ASYNCRTIMP static value __cdecl parse(utf16istream& stream);
+#endif
 
         /// <summary>
         /// Parses a JSON value from the contents of a single-byte (UTF8) stream.
@@ -536,7 +538,9 @@ namespace json
         /// <param name="errorCode">If parsing fails, the error code is greater than 0</param>
         /// <returns>The parsed object. Returns web::json::value::null if failed</returns>
         _ASYNCRTIMP static value __cdecl parse(std::istream& stream, std::error_code& error);
+#if !defined(_LIBCPP_VERSION)
         _ASYNCRTIMP static value __cdecl parse(utf16istream& stream, std::error_code& error);
+#endif
 
         /// <summary>
         /// Serializes the current JSON value to a UTF-8 string.
@@ -555,13 +559,12 @@ namespace json
 #endif
             stream << serialize();
         }
+#if !defined(_LIBCPP_VERSION)
         inline void serialize(utf16ostream& stream) const
         {
-#ifndef _WIN32
-            utility::details::scoped_c_thread_locale locale;
-#endif
             stream << utility::conversions::to_utf16string(serialize());
         }
+#endif
 
         /// <summary>
         /// Serializes the content of the value into a UTF-8 string.
@@ -1790,10 +1793,12 @@ namespace json
         val.serialize(os);
         return os;
     }
+#if !defined(_LIBCPP_VERSION)
     inline utf16ostream& operator << (utf16ostream &os, const json::value &val) {
         val.serialize(os);
         return os;
     }
+#endif
 
     /// <summary>
     /// A standard <c>std::istream</c> operator to facilitate reading JSON values from streams.
@@ -1805,10 +1810,12 @@ namespace json
         val = ::web::json::value::parse(is);
         return is;
     }
+#if !defined(_LIBCPP_VERSION)
     inline utf16istream& operator >> (utf16istream &is, json::value &val) {
         val = ::web::json::value::parse(is);
         return is;
     }
+#endif
 }}
 
 #endif

Release/src/json/json_parsing.cpp

@@ -246,6 +246,7 @@ class JSON_StreamParser<char> : public JSON_Parser
     typename std::streambuf* m_streambuf;
 };
 
+#if !defined(_LIBCPP_VERSION)
 template <>
 class JSON_StreamParser<utf16char> : public JSON_Parser
 {
@@ -333,6 +334,7 @@ class JSON_StreamParser<utf16char> : public JSON_Parser
     // The string of utf8 code units are buffered in reverse order
     std::string m_utf8_buffer;
 };
+#endif
 
 class JSON_StringParser : public JSON_Parser
 {
@@ -1234,9 +1236,11 @@ static std::unique_ptr<web::json::details::JSON_Parser> parser_factory(std::istr
 static std::unique_ptr<web::json::details::JSON_Parser> parser_factory(const std::string& str) {
     return utility::details::make_unique<web::json::details::JSON_StringParser>(str);
 }
+#if !defined(_LIBCPP_VERSION)
 static std::unique_ptr<web::json::details::JSON_Parser> parser_factory(utf16istream& stream) {
     return utility::details::make_unique<web::json::details::JSON_StreamParser<utf16char>>(stream);
 }
+#endif
 
 template<class Stream>
 static web::json::value parse_stream(Stream&& stream, std::error_code& error)
@@ -1289,6 +1293,7 @@ web::json::value web::json::value::parse(const std::string& stream, std::error_c
     return parse_stream(stream, error);
 }
 
+#if !defined(_LIBCPP_VERSION)
 web::json::value web::json::value::parse(utf16istream& stream)
 {
     return parse_stream(stream);
@@ -1298,3 +1303,4 @@ web::json::value web::json::value::parse(utf16istream& stream, std::error_code&
 {
     return parse_stream(stream, error);
 }
+#endif

Release/tests/functional/json/negative_parsing_tests.cpp

@@ -156,6 +156,7 @@ TEST(stream_left_over_chars)
     verify_json_throws(stream);
 }
 
+#if !defined(_LIBCPP_VERSION)
 TEST(wstream_left_over_chars)
 {
     std::basic_stringbuf<utf16char> buf;
@@ -167,6 +168,7 @@ TEST(wstream_left_over_chars)
     utf16istream stream(&buf);
     verify_json_throws(stream);
 }
+#endif
 
 void garbage_impl(wchar_t ch)
 {

Release/tests/functional/json/parsing_tests.cpp

@@ -667,11 +667,13 @@ TEST(non_default_locale, "Ignore:Android", "Locale unsupported on Android")
         setlocale(LC_NUMERIC, changedLocale.c_str());
 
         // cpprestsdk stream serialize
+#if !defined(_LIBCPP_VERSION)
         utf16stringstream stream;
         stream << v;
         utf16string serializedStr;
         stream >> serializedStr;
         VERIFY_ARE_EQUAL(utility::conversions::to_utf16string(str), serializedStr);
+#endif
 
         // std stream serialize
         std::stringstream stdStream;