caller provided serializer storage

Author: vinniefalco

include/boost/json/detail/impl/serialize.ipp

@@ -0,0 +1,66 @@
+//
+// Copyright (c) 2019 Vinnie Falco ([email protected])
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Official repository: https://github.com/boostorg/json
+//
+
+#ifndef BOOST_JSON_DETAIL_IMPL_SERIALIZE_IPP
+#define BOOST_JSON_DETAIL_IMPL_SERIALIZE_IPP
+
+#include <boost/json/detail/serialize.hpp>
+
+namespace boost {
+namespace json {
+namespace detail {
+
+void
+serialize_impl(
+    std::string& s,
+    serializer& sr)
+{
+    // serialize to a small buffer to avoid
+    // the first few allocations in std::string
+    char buf[BOOST_JSON_STACK_BUFFER_SIZE];
+    string_view sv;
+    sv = sr.read(buf);
+    if(sr.done())
+    {
+        // fast path
+        s.append(
+            sv.data(), sv.size());
+        return;
+    }
+    std::size_t len = sv.size();
+    s.reserve(len * 2);
+    s.resize(s.capacity());
+    BOOST_ASSERT(
+        s.size() >= len * 2);
+    std::memcpy(&s[0],
+        sv.data(), sv.size());
+    auto const lim =
+        s.max_size() / 2;
+    for(;;)
+    {
+        sv = sr.read(
+            &s[0] + len,
+            s.size() - len);
+        len += sv.size();
+        if(sr.done())
+            break;
+        // growth factor 2x
+        if(s.size() < lim)
+            s.resize(s.size() * 2);
+        else
+            s.resize(2 * lim);
+    }
+    s.resize(len);
+}
+
+} // detail
+} // json
+} // boost
+
+#endif

include/boost/json/detail/impl/writer.ipp

@@ -0,0 +1,27 @@
+//
+// Copyright (c) 2019 Vinnie Falco ([email protected])
+// Copyright (c) 2020 Krystian Stasiowski ([email protected])
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://wwboost.org/LICENSE_1_0.txt)
+//
+// Official repository: https://github.com/boostorg/json
+//
+
+#ifndef BOOST_JSON_DETAIL_IMPL_WRITER_IPP
+#define BOOST_JSON_DETAIL_IMPL_WRITER_IPP
+
+#include <boost/json/detail/writer.hpp>
+#include <boost/json/detail/sse2.hpp>
+#include <boost/json/detail/format.hpp> // for max_number_chars
+#include <boost/static_assert.hpp>
+
+namespace boost {
+namespace json {
+namespace detail {
+
+} // detail
+} // json
+} // boost
+
+#endif

include/boost/json/detail/serialize.hpp

@@ -0,0 +1,30 @@
+//
+// Copyright (c) 2019 Vinnie Falco ([email protected])
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Official repository: https://github.com/boostorg/json
+//
+
+#ifndef BOOST_JSON_DETAIL_SERIALIZE_HPP
+#define BOOST_JSON_DETAIL_SERIALIZE_HPP
+
+#include <boost/json/serializer.hpp>
+#include <string>
+
+namespace boost {
+namespace json {
+namespace detail {
+
+BOOST_JSON_DECL
+void
+serialize_impl(
+    std::string& s,
+    serializer& sr);
+
+} // detail
+} // json
+} // boost
+
+#endif

include/boost/json/detail/stream.hpp

@@ -234,112 +234,6 @@ class clipped_const_stream
     }
 };
 
-//--------------------------------------
-
-class stream
-{
-    friend class local_stream;
-
-    char* p_;
-    char* end_;
-
-public:
-    stream(
-        char* data,
-        std::size_t size) noexcept
-        : p_(data)
-        , end_(data + size)
-    {
-    }
-
-    size_t
-    used(char* begin) const noexcept
-    {
-        return static_cast<
-            size_t>(p_ - begin);
-    }
-
-    size_t
-    remain() const noexcept
-    {
-        return end_ - p_;
-    }
-
-    char*
-    data() noexcept
-    {
-        return p_;
-    }
-
-    operator bool() const noexcept
-    {
-        return p_ < end_;
-    }
-
-    // unchecked
-    char&
-    operator*() noexcept
-    {
-        BOOST_ASSERT(p_ < end_);
-        return *p_;
-    }
-
-    // unchecked
-    stream&
-    operator++() noexcept
-    {
-        BOOST_ASSERT(p_ < end_);
-        ++p_;
-        return *this;
-    }
-
-    // unchecked
-    void
-    append(
-        char const* src,
-        std::size_t n) noexcept
-    {
-        BOOST_ASSERT(remain() >= n);
-        std::memcpy(p_, src, n);
-        p_ += n;
-    }
-
-    // unchecked
-    void
-    append(char c) noexcept
-    {
-        BOOST_ASSERT(p_ < end_);
-        *p_++ = c;
-    }
-
-    void
-    advance(std::size_t n) noexcept
-    {
-        BOOST_ASSERT(remain() >= n);
-        p_ += n;
-    }
-};
-
-class local_stream
-    : public stream
-{
-    stream& src_;
-
-public:
-    explicit
-    local_stream(
-        stream& src)
-        : stream(src)
-        , src_(src)
-    {
-    }
-
-    ~local_stream()
-    {
-        src_.p_ = p_;
-    }
-};
-
 } // detail
 } // namespace json
 } // namespace boost

include/boost/json/detail/writer.hpp

@@ -0,0 +1,135 @@
+//
+// Copyright (c) 2019 Vinnie Falco ([email protected])
+// Copyright (c) 2020 Krystian Stasiowski ([email protected])
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Official repository: https://github.com/boostorg/json
+//
+
+#ifndef BOOST_JSON_DETAIL_WRITER_HPP
+#define BOOST_JSON_DETAIL_WRITER_HPP
+
+#include <boost/json/detail/stack.hpp>
+#include <boost/json/serialize_options.hpp>
+#include <boost/json/string_view.hpp>
+
+namespace boost {
+namespace json {
+namespace detail {
+
+struct writer
+{
+    char* dest_;
+    char const* end_;
+
+public:
+    using resume_fn = bool(*)(writer&, serialize_options const&);
+
+    detail::stack stack;
+    char temp_[29];
+
+    writer() = default;
+
+    writer(
+        storage_ptr sp,
+        unsigned char* buf,
+        std::size_t buf_size) noexcept
+        : stack(
+            std::move(sp),
+            buf,
+            buf_size)
+    {
+    }
+
+    char*
+    data() noexcept
+    {
+        return dest_;
+    }
+
+    // provide an output buffer
+    void
+    prepare(
+        char* dest,
+        std::size_t size)
+    {
+        dest_ = dest;
+        end_ = dest + size;
+    }
+
+    // return true if there is no space
+    bool
+    empty() const noexcept
+    {
+        return dest_ == end_;
+    }
+
+    // return the amount of space available
+    std::size_t
+    available() const noexcept
+    {
+        return static_cast<
+            std::size_t>(end_ - dest_);
+    }
+
+    // return true if there is space
+    bool
+    append(char c) noexcept
+    {
+        if(! empty())
+        {
+            *dest_++ = c;
+            return true;
+        }
+        return false;
+    }
+
+    // append one char
+    void
+    append_unsafe(
+        char c) noexcept
+    {
+        BOOST_ASSERT(! empty());
+        *dest_++ = c;
+    }
+
+    // append chars in s, unchecked
+    void
+    append_unsafe(
+        char const* s,
+        std::size_t n) noexcept
+    {
+        BOOST_ASSERT(available() >= n);
+        std::memcpy(dest_, s, n);
+        dest_ += n;
+    }
+
+    // push a resume function
+    void
+    push_resume(resume_fn fn)
+    {
+        stack.push(fn);
+    }
+
+    // pop and invoke a resume function
+    // or return true if stack is empty
+    bool
+    do_resume(serialize_options const& opts)
+    {
+        if(! stack.empty())
+        {
+            resume_fn fn;
+            stack.pop(fn);
+            return fn(*this, opts);
+        }
+        return true;
+    }
+};
+
+} // detail
+} // json
+} // boost
+
+#endif