operator>> for value

Author: grisumbras

include/boost/json/impl/value.ipp

@@ -11,8 +11,10 @@
 #define BOOST_JSON_IMPL_VALUE_IPP
 
 #include <boost/json/value.hpp>
+#include <boost/json/parser.hpp>
 #include <boost/json/detail/hash_combine.hpp>
 #include <cstring>
+#include <istream>
 #include <limits>
 #include <new>
 #include <utility>
@@ -343,6 +345,63 @@ swap(value& other)
     ::new(this) value(pilfer(temp2));
 }
 
+std::istream&
+operator>>(
+    std::istream& is,
+    value& jv)
+{
+    using Traits = std::istream::traits_type;
+
+    std::istream::sentry sentry(is);
+    if( !sentry )
+        return is;
+
+    unsigned char parser_buf[BOOST_JSON_STACK_BUFFER_SIZE];
+    stream_parser p({}, {}, parser_buf);
+    p.reset( jv.storage() );
+
+    std::ios::iostate err = std::ios::goodbit;
+    try
+    {
+        std::istream::int_type c = is.rdbuf()->sgetc();
+        while( true )
+        {
+            error_code ec;
+
+            if( Traits::eq_int_type(c, Traits::eof()) )
+            {
+                err |= std::ios::eofbit;
+                p.finish(ec);
+                if( ec.failed() )
+                    break;
+            }
+
+            if( p.done() )
+            {
+                jv = p.release();
+                return is;
+            }
+
+            char read_buf[1];
+            read_buf[0] = Traits::to_char_type(c);
+            c = is.rdbuf()->snextc();
+
+            p.write_some(read_buf, 1, ec);
+            if( ec.failed() )
+                break;
+        }
+    }
+    catch(...)
+    {
+        is.setstate(std::ios::failbit);
+        throw;
+    }
+
+    err |= std::ios::failbit;
+    is.setstate(err);
+    return is;
+}
+
 //----------------------------------------------------------
 //
 // private

include/boost/json/value.hpp

@@ -3339,6 +3339,34 @@ class value
         std::ostream& os,
         value const& jv);
 
+    /** Parse @ref value from an input stream.
+
+        This function parses JSON from an input stream into a `value`. If
+        parsing fails, `std::ios_base::failbit` will be set for `is` and
+        `jv` will be left unchanged.
+
+        @return Reference to `is`.
+
+        @par Complexity
+        Linear in the size of JSON data.
+
+        @par Exception Safety
+        Basic guarantee.
+        Calls to `memory_resource::allocate` may throw.
+        The stream may throw as described by
+        [`std::ios::exceptions`](https://en.cppreference.com/w/cpp/io/basic_ios/exceptions).
+
+        @param is The input stream to parse from.
+
+        @param jv The value to parse into.
+    */
+    BOOST_JSON_DECL
+    friend
+    std::istream&
+    operator>>(
+        std::istream& is,
+        value& jv);
+
 private:
     static
     void

test/test_suite.hpp

@@ -626,9 +626,13 @@ current_function_helper()
 */
 using log_type = detail::log_ostream<char>;
 
+#define BOOST_JSON_PP_DO_CONCAT(x, y) x ## y
+
+#define BOOST_JSON_PP_CONCAT(x, y) BOOST_JSON_PP_DO_CONCAT(x, y)
+
 #define BOOST_TEST_CHECKPOINT(...) \
     ::test_suite::detail::checkpoint \
-        _BOOST_TEST_CHECKPOINT ## __LINE__ ( \
+        BOOST_JSON_PP_CONCAT(_BOOST_TEST_CHECKPOINT, __LINE__) ( \
             __FILE__, __LINE__, __VA_ARGS__ + 0)
 
 #define BOOST_TEST(expr) \

test/value.cpp

@@ -40,6 +40,27 @@ T min_of()
     return (std::numeric_limits<T>::min)();
 }
 
+class throwing_buffer
+    : public std::streambuf
+{
+protected:
+    int_type
+    underflow() override
+    {
+        // make sure we don't throw before the parser had the chance to start
+        if( !gptr()  )
+        {
+            setg(buf_, buf_, buf_ + 1);
+            return *buf_;
+        }
+
+        throw std::invalid_argument("this buffer throws");
+    }
+
+private:
+    char buf_[1] = {'t'};
+};
+
 } // (anon)
 
 class value_test
@@ -2233,6 +2254,56 @@ class value_test
             value({{"a", "b"}})));
     }
 
+    void
+    testIstream()
+    {
+        std::istringstream ss(
+            R"({ "x": 1
+               , "y": 2
+               , "z": [77, null, true, "qwerty uiop"]
+               } 12)");
+        value jv;
+
+        ss >> jv;
+        BOOST_TEST( !!ss );
+        BOOST_TEST((
+            jv == value{
+                {"x", 1},
+                {"y", 2},
+                {"z", {77, nullptr, true, "qwerty uiop"}}} ));
+
+        // check we didn't consume any extra characters
+        std::string s;
+        std::getline(ss, s);
+        BOOST_TEST( s == " 12" );
+
+        ss.clear();
+        ss.str("23");
+        ss >> jv;
+        BOOST_TEST( jv == 23 );
+
+        ss.clear();
+        ss.str("");
+        ss >> jv;
+        BOOST_TEST( ss.rdstate() == (std::ios::failbit | std::ios::eofbit) );
+
+        ss.clear();
+        ss.str("nu");
+        ss >> jv;
+        BOOST_TEST( ss.rdstate() == (std::ios::failbit | std::ios::eofbit) );
+
+        ss.clear();
+        ss.str("[1,2,3,4,]");
+        ss >> jv;
+        BOOST_TEST( ss.rdstate() == std::ios::failbit );
+
+        {
+            throwing_buffer buf;
+            std::istream is(&buf);
+            BOOST_TEST_THROWS( is >> jv, std::exception );
+        }
+    }
+
     //------------------------------------------------------
 
     void
@@ -2255,6 +2326,7 @@ class value_test
         testInitList();
         testEquality();
         testHash();
+        testIstream();
     }
 };