Add full implementation for JsonWriter and tests for it

catchorg · Jun 25, 2023 · 12bc1cf · 12bc1cf
1 parent 95eff52
commit 12bc1cf
Show file tree

Hide file tree

Showing 22 changed files with 106,185 additions and 64 deletions.
diff --git a/extras/catch_amalgamated.cpp b/extras/catch_amalgamated.cpp
@@ -6,7 +6,7 @@
 // SPDX-License-Identifier: BSL-1.0
 
 //  Catch v3.3.2
-//  Generated: 2023-06-18 17:50:33.082789
+//  Generated: 2023-06-25 03:34:19.311663
 //  ----------------------------------------------------------
 //  This file is an amalgamation of multiple different files.
 //  You probably shouldn't edit it directly.
@@ -4270,41 +4270,128 @@ namespace Detail {
 //       while in /permissive- mode. No, I don't know why.
 //       Tested on VS 2019, 18.{3, 4}.x
 
-#include <cstdint>
-#include <iomanip>
-#include <type_traits>
-
-namespace Catch {
-    JsonWriter::JsonWriter( std::ostream& os ): m_os{ os } {}
-    JsonWriter::~JsonWriter() {
-        while ( m_object_level-- > 0 ) {
-            endObject();
+namespace {
+    void indent( std::ostream& os, std::uint64_t level ) {
+        for ( std::uint64_t i = 0; i < level; ++i ) {
+            os << "  ";
         }
     }
+    void appendCommaNewline( std::ostream& os,
+                             bool& should_comma,
+                             std::uint64_t level ) {
+        if ( should_comma ) { os << ','; }
+        should_comma = true;
+        os << '\n';
+        indent( os, level );
+    }
+} // namespace
 
-    JsonWriter& JsonWriter::startObject() {
-        for ( auto i = m_object_level; i > 0; --i ) {
-            m_os << "  ";
-        }
+namespace Catch {
+    JsonObjectWriter::JsonObjectWriter( std::ostream& os ):
+        JsonObjectWriter{ os, 0 } {}
+
+    JsonObjectWriter::JsonObjectWriter( std::ostream& os,
+                                        std::uint64_t indent_level ):
+        m_os{ os }, m_indent_level{ indent_level } {
         m_os << "{";
+    }
 
-        ++m_object_level;
+    JsonObjectWriter::~JsonObjectWriter() {
+        m_os << '\n';
+        indent( m_os, m_indent_level );
+        m_os << '}';
+    }
 
-        return *this;
+    JsonValueWriter JsonObjectWriter::write( std::string const& key ) {
+        appendCommaNewline( m_os, m_should_comma, m_indent_level + 1 );
+
+        m_os << '"' << key << '"' << ": ";
+        return JsonValueWriter{ m_os, m_indent_level + 1 };
+    }
+
+    JsonArrayWriter::JsonArrayWriter( std::ostream& os ):
+        JsonArrayWriter{ os, 0 } {}
+    JsonArrayWriter::JsonArrayWriter( std::ostream& os,
+                                      std::uint64_t indent_level ):
+        m_os{ os }, m_indent_level{ indent_level } {
+        m_os << "[";
+    }
+    JsonArrayWriter::~JsonArrayWriter() {
+        m_os << '\n';
+        indent( m_os, m_indent_level );
+        m_os << ']';
     }
 
-    JsonWriter& JsonWriter::endObject() {
-        if ( m_object_level == 0 ) { return *this; }
+    JsonObjectWriter JsonArrayWriter::writeObject() {
+        appendCommaNewline( m_os, m_should_comma, m_indent_level + 1 );
+        return JsonObjectWriter{ m_os, m_indent_level + 1 };
+    }
 
-        for ( auto i = m_object_level; i > 0; --i ) {
-            m_os << "  ";
-        }
-        m_os << "}";
+    JsonArrayWriter JsonArrayWriter::writeArray() {
+        appendCommaNewline( m_os, m_should_comma, m_indent_level + 1 );
+        return JsonArrayWriter{ m_os, m_indent_level + 1 };
+    }
 
-        --m_object_level;
+    template <typename T>
+    JsonArrayWriter& JsonArrayWriter::writeImpl( T const& value ) {
+        appendCommaNewline( m_os, m_should_comma, m_indent_level + 1 );
+        JsonValueWriter{ m_os }.write( value );
 
         return *this;
     }
+
+    JsonArrayWriter& JsonArrayWriter::write( int value ) {
+        return writeImpl( value );
+    }
+    JsonArrayWriter& JsonArrayWriter::write( double value ) {
+        return writeImpl( value );
+    }
+    JsonArrayWriter& JsonArrayWriter::write( bool value ) {
+        return writeImpl( value );
+    }
+    JsonArrayWriter& JsonArrayWriter::write( StringRef value ) {
+        return writeImpl( value );
+    }
+    JsonArrayWriter& JsonArrayWriter::write( char const* value ) {
+        return writeImpl( value );
+    }
+
+    JsonValueWriter::JsonValueWriter( std::ostream& os ):
+        JsonValueWriter{ os, 0 } {}
+
+    JsonValueWriter::JsonValueWriter( std::ostream& os,
+                                      std::uint64_t indent_level ):
+        m_os{ os }, m_indent_level{ indent_level } {}
+
+    template <typename T>
+    void JsonValueWriter::writeImpl( T const& value, bool quote_value ) {
+        if ( quote_value ) { m_os << '"'; }
+        m_os << value;
+        if ( quote_value ) { m_os << '"'; }
+    }
+
+    JsonObjectWriter JsonValueWriter::writeObject() && {
+        return JsonObjectWriter{ m_os, m_indent_level };
+    }
+
+    JsonArrayWriter JsonValueWriter::writeArray() && {
+        return JsonArrayWriter{ m_os, m_indent_level };
+    }
+
+    void JsonValueWriter::write( int value ) && { writeImpl( value, false ); }
+    void JsonValueWriter::write( double value ) && {
+        writeImpl( value, false );
+    }
+    void JsonValueWriter::write( bool value ) && {
+        writeImpl( value ? "true" : "false", false );
+    }
+    void JsonValueWriter::write( StringRef value ) && {
+        writeImpl( value, true );
+    }
+    void JsonValueWriter::write( char const* value ) && {
+        writeImpl( value, true );
+    }
+
 } // namespace Catch
 
 

diff --git a/extras/catch_amalgamated.hpp b/extras/catch_amalgamated.hpp
@@ -6,7 +6,7 @@
 // SPDX-License-Identifier: BSL-1.0
 
 //  Catch v3.3.2
-//  Generated: 2023-06-18 17:50:33.071281
+//  Generated: 2023-06-25 03:34:19.300670
 //  ----------------------------------------------------------
 //  This file is an amalgamation of multiple different files.
 //  You probably shouldn't edit it directly.
@@ -16,8 +16,7 @@
 
 
 /** \file
- * This is a convenience header for Catch2. It includes **all** of Catch2
- * headers.
+ * This is a convenience header for Catch2. It includes **all** of Catch2 headers.
  *
  * Generally the Catch2 users should use specific includes they need,
  * but this header can be used instead for ease-of-experimentation, or
@@ -9300,21 +9299,85 @@ namespace Catch {
 #include <vector>
 
 namespace Catch {
-    class JsonWriter {
+    class JsonObjectWriter;
+    class JsonArrayWriter;
+
+    class JsonValueWriter {
     public:
-        JsonWriter( std::ostream& os );
-        ~JsonWriter();
+        friend JsonObjectWriter;
+        friend JsonArrayWriter;
+
+        JsonValueWriter( std::ostream& os );
 
-        JsonWriter( JsonWriter const& ) = delete;
-        JsonWriter& operator=( JsonWriter const& ) = delete;
+        JsonObjectWriter writeObject() &&;
+        JsonArrayWriter writeArray() &&;
 
-        JsonWriter& startObject();
-        JsonWriter& endObject();
+        void write( int value ) &&;
+        void write( double value ) &&;
+        void write( bool value ) &&;
+        void write( StringRef value ) &&;
+        void write( char const* value ) &&;
 
     private:
-        std::uint64_t m_object_level = 0;
+        JsonValueWriter( std::ostream& os, std::uint64_t indent_level );
+
+        template <typename T>
+        void writeImpl( T const& value, bool quote_value );
 
         std::ostream& m_os;
+        std::uint64_t m_indent_level;
+    };
+
+    class JsonObjectWriter {
+    public:
+        friend JsonValueWriter;
+        friend JsonArrayWriter;
+
+        JsonObjectWriter( std::ostream& os );
+
+        ~JsonObjectWriter();
+
+        JsonValueWriter write( std::string const& key );
+
+    private:
+        JsonObjectWriter( std::ostream& os, std::uint64_t indent_level );
+
+        std::ostream& m_os;
+        std::uint64_t m_indent_level;
+        bool m_should_comma = false;
+    };
+
+    class JsonArrayWriter {
+    public:
+        friend JsonValueWriter;
+        friend JsonObjectWriter;
+
+        JsonArrayWriter( std::ostream& os );
+
+        JsonObjectWriter writeObject();
+        JsonArrayWriter writeArray();
+
+        JsonArrayWriter& write( int value );
+        JsonArrayWriter& write( double value );
+        JsonArrayWriter& write( bool value );
+        JsonArrayWriter& write( StringRef value );
+        JsonArrayWriter& write( char const* value );
+
+        ~JsonArrayWriter();
+
+    private:
+        JsonArrayWriter( std::ostream& os, std::uint64_t indent_level );
+
+        template <typename T>
+        JsonArrayWriter& writeImpl( T const& value );
+
+        std::ostream& m_os;
+        std::uint64_t m_indent_level;
+        bool m_should_comma = false;
+    };
+
+    struct JsonWriter : JsonValueWriter {
+        using JsonValueWriter::JsonValueWriter;
     };
 } // namespace Catch