include/tools/json_writer.hxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  */
   9 #pragma once
  10
  11 #include <sal/config.h>
  12
  13 #include <tools/toolsdllapi.h>
  14 #include <rtl/string.hxx>
  15 #include <rtl/ustring.hxx>
  16 #include <sal/types.h>
  17
  18 #include <string>
  19 #include <string_view>
  20 #include <utility>
  21
  22 /** Simple JSON encoder designed specifically for LibreOfficeKit purposes.
  23  *
  24  * (1) Minimal allocations/re-allocations/copying
  25  * (2) Small/simple JSON documents
  26  * (3) ascii property names
  27  */
  28 namespace tools
  29 {
  30 class ScopedJsonWriterNode;
  31 class ScopedJsonWriterArray;
  32 class ScopedJsonWriterStruct;
  33
  34 class TOOLS_DLLPUBLIC JsonWriter
  35 {
  36     friend class ScopedJsonWriterNode;
  37     friend class ScopedJsonWriterArray;
  38     friend class ScopedJsonWriterStruct;
  39
  40     char* mpBuffer;
  41     char* mPos;
  42     int mSpaceAllocated;
  43     int mStartNodeCount;
  44     bool mbFirstFieldInNode;
  45     bool mbClosed; // cannot add to it anymore
  46
  47 public:
  48     JsonWriter();
  49     ~JsonWriter();
  50
  51     [[nodiscard]] ScopedJsonWriterNode startNode(std::string_view);
  52     [[nodiscard]] ScopedJsonWriterArray startArray(std::string_view);
  53     [[nodiscard]] ScopedJsonWriterStruct startStruct();
  54
  55     void put(std::string_view pPropName, const OUString& rPropValue);
  56     // Assumes utf-8 property value encoding
  57     void put(std::string_view pPropName, std::string_view rPropValue);
  58     void put(std::string_view pPropName, const char* pPropVal)
  59     {
  60         put(pPropName, std::string_view(pPropVal));
  61     }
  62     template <size_t N> void put(std::string_view pPropName, const char (&pPropVal)[N])
  63     {
  64         put(pPropName, std::string_view(pPropVal, N));
  65     }
  66
  67     template <typename N, std::enable_if_t<std::is_arithmetic_v<N>, int> = 0>
  68     void put(std::string_view pPropName, N n)
  69     {
  70         putLiteral(pPropName, OString::number(n));
  71     }
  72     void put(std::string_view pPropName, bool);
  73
  74     void putSimpleValue(const OUString& rPropValue);
  75
  76     /// This assumes that this data belongs at this point in the stream, and is valid, and properly encoded
  77     void putRaw(std::string_view);
  78
  79     /** Closes the tags, and returns data.
  80      * After this no more document modifications may be written. */
  81     OString finishAndGetAsOString();
  82
  83     /** returns true if the current JSON data matches the string */
  84     bool isDataEquals(std::string_view) const;
  85
  86 private:
  87     void endNode();
  88     void endArray();
  89     void endStruct();
  90     void addCommaBeforeField();
  91     void writeEscapedOUString(const OUString& rPropVal);
  92     void closeDocument();
  93     void ensureSpace(int noMoreBytesRequired);
  94     void ensureSpaceAndWriteNameColon(std::string_view name, int valSize);
  95     void putLiteral(std::string_view propName, std::string_view propValue);
  96
  97     // overflow validation in debug mode
  98     static constexpr unsigned char JSON_WRITER_DEBUG_MARKER = 0xde;
  99
 100     inline void addValidationMark()
 101     {
 102 #ifndef NDEBUG
 103         *(mpBuffer + mSpaceAllocated - 1) = JSON_WRITER_DEBUG_MARKER;
 104 #endif
 105     }
 106
 107     inline void validate()
 108     {
 109 #ifndef NDEBUG
 110         unsigned char c = *(mpBuffer + mSpaceAllocated - 1);
 111         assert(c == JSON_WRITER_DEBUG_MARKER);
 112 #endif
 113     }
 114 };
 115
 116 /**
 117  * Auto-closes the node.
 118  */
 119 class ScopedJsonWriterNode
 120 {
 121     friend class JsonWriter;
 122
 123     JsonWriter& mrWriter;
 124
 125     ScopedJsonWriterNode(JsonWriter& rWriter)
 126         : mrWriter(rWriter)
 127     {
 128     }
 129
 130 public:
 131     ~ScopedJsonWriterNode() { mrWriter.endNode(); }
 132 };
 133
 134 /**
 135  * Auto-closes the node.
 136  */
 137 class ScopedJsonWriterArray
 138 {
 139     friend class JsonWriter;
 140
 141     JsonWriter& mrWriter;
 142
 143     ScopedJsonWriterArray(JsonWriter& rWriter)
 144         : mrWriter(rWriter)
 145     {
 146     }
 147
 148 public:
 149     ~ScopedJsonWriterArray() { mrWriter.endArray(); }
 150 };
 151
 152 /**
 153  * Auto-closes the node.
 154  */
 155 class ScopedJsonWriterStruct
 156 {
 157     friend class JsonWriter;
 158
 159     JsonWriter& mrWriter;
 160
 161     ScopedJsonWriterStruct(JsonWriter& rWriter)
 162         : mrWriter(rWriter)
 163     {
 164     }
 165
 166 public:
 167     ~ScopedJsonWriterStruct() { mrWriter.endStruct(); }
 168 };
 169 }
 170 /* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */