prettywriter.h
Go to the documentation of this file.
1 // Tencent is pleased to support the open source community by making RapidJSON available.
2 //
3 // Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
4 //
5 // Licensed under the MIT License (the "License"); you may not use this file except
6 // in compliance with the License. You may obtain a copy of the License at
7 //
8 // http://opensource.org/licenses/MIT
9 //
10 // Unless required by applicable law or agreed to in writing, software distributed
11 // under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
12 // CONDITIONS OF ANY KIND, either express or implied. See the License for the
13 // specific language governing permissions and limitations under the License.
14 
15 #ifndef RAPIDJSON_PRETTYWRITER_H_
16 #define RAPIDJSON_PRETTYWRITER_H_
17 
18 #include "writer.h"
19 
20 #ifdef __GNUC__
21 RAPIDJSON_DIAG_PUSH
22 RAPIDJSON_DIAG_OFF(effc++)
23 #endif
24 
25 #if defined(__clang__)
26 RAPIDJSON_DIAG_PUSH
27 RAPIDJSON_DIAG_OFF(c++98-compat)
28 #endif
29 
31 
32 //! Combination of PrettyWriter format flags.
33 /*! \see PrettyWriter::SetFormatOptions
34  */
36  kFormatDefault = 0, //!< Default pretty formatting.
37  kFormatSingleLineArray = 1 //!< Format arrays on a single line.
38 };
39 
40 //! Writer with indentation and spacing.
41 /*!
42  \tparam OutputStream Type of output os.
43  \tparam SourceEncoding Encoding of source string.
44  \tparam TargetEncoding Encoding of output stream.
45  \tparam StackAllocator Type of allocator for allocating memory of stack.
46 */
47 template<typename OutputStream, typename SourceEncoding = UTF8<>, typename TargetEncoding = UTF8<>, typename StackAllocator = CrtAllocator, unsigned writeFlags = kWriteDefaultFlags>
48 class PrettyWriter : public Writer<OutputStream, SourceEncoding, TargetEncoding, StackAllocator, writeFlags> {
49 public:
51  typedef typename Base::Ch Ch;
52 
53  //! Constructor
54  /*! \param os Output stream.
55  \param allocator User supplied allocator. If it is null, it will create a private one.
56  \param levelDepth Initial capacity of stack.
57  */
58  explicit PrettyWriter(OutputStream& os, StackAllocator* allocator = 0, size_t levelDepth = Base::kDefaultLevelDepth) :
59  Base(os, allocator, levelDepth), indentChar_(' '), indentCharCount_(4), formatOptions_(kFormatDefault) {}
60 
61 
62  explicit PrettyWriter(StackAllocator* allocator = 0, size_t levelDepth = Base::kDefaultLevelDepth) :
63  Base(allocator, levelDepth), indentChar_(' '), indentCharCount_(4) {}
64 
65 #if RAPIDJSON_HAS_CXX11_RVALUE_REFS
66  PrettyWriter(PrettyWriter&& rhs) :
67  Base(std::forward<PrettyWriter>(rhs)), indentChar_(rhs.indentChar_), indentCharCount_(rhs.indentCharCount_), formatOptions_(rhs.formatOptions_) {}
68 #endif
69 
70  //! Set custom indentation.
71  /*! \param indentChar Character for indentation. Must be whitespace character (' ', '\\t', '\\n', '\\r').
72  \param indentCharCount Number of indent characters for each indentation level.
73  \note The default indentation is 4 spaces.
74  */
75  PrettyWriter& SetIndent(Ch indentChar, unsigned indentCharCount) {
76  RAPIDJSON_ASSERT(indentChar == ' ' || indentChar == '\t' || indentChar == '\n' || indentChar == '\r');
77  indentChar_ = indentChar;
78  indentCharCount_ = indentCharCount;
79  return *this;
80  }
81 
82  //! Set pretty writer formatting options.
83  /*! \param options Formatting options.
84  */
87  return *this;
88  }
89 
90  /*! @name Implementation of Handler
91  \see Handler
92  */
93  //@{
94 
98  bool Uint(unsigned u) { PrettyPrefix(kNumberType); return Base::EndValue(Base::WriteUint(u)); }
102 
103  bool RawNumber(const Ch* str, SizeType length, bool copy = false) {
104  RAPIDJSON_ASSERT(str != 0);
105  (void)copy;
107  return Base::EndValue(Base::WriteString(str, length));
108  }
109 
110  bool String(const Ch* str, SizeType length, bool copy = false) {
111  RAPIDJSON_ASSERT(str != 0);
112  (void)copy;
114  return Base::EndValue(Base::WriteString(str, length));
115  }
116 
117 #if RAPIDJSON_HAS_STDSTRING
118  bool String(const std::basic_string<Ch>& str) {
119  return String(str.data(), SizeType(str.size()));
120  }
121 #endif
122 
123  bool StartObject() {
125  new (Base::level_stack_.template Push<typename Base::Level>()) typename Base::Level(false);
126  return Base::WriteStartObject();
127  }
128 
129  bool Key(const Ch* str, SizeType length, bool copy = false) { return String(str, length, copy); }
130 
131 #if RAPIDJSON_HAS_STDSTRING
132  bool Key(const std::basic_string<Ch>& str) {
133  return Key(str.data(), SizeType(str.size()));
134  }
135 #endif
136 
137  bool EndObject(SizeType memberCount = 0) {
138  (void)memberCount;
139  RAPIDJSON_ASSERT(Base::level_stack_.GetSize() >= sizeof(typename Base::Level)); // not inside an Object
140  RAPIDJSON_ASSERT(!Base::level_stack_.template Top<typename Base::Level>()->inArray); // currently inside an Array, not Object
141  RAPIDJSON_ASSERT(0 == Base::level_stack_.template Top<typename Base::Level>()->valueCount % 2); // Object has a Key without a Value
142 
143  bool empty = Base::level_stack_.template Pop<typename Base::Level>(1)->valueCount == 0;
144 
145  if (!empty) {
146  Base::os_->Put('\n');
147  WriteIndent();
148  }
149  bool ret = Base::EndValue(Base::WriteEndObject());
150  (void)ret;
151  RAPIDJSON_ASSERT(ret == true);
152  if (Base::level_stack_.Empty()) // end of json text
153  Base::Flush();
154  return true;
155  }
156 
157  bool StartArray() {
159  new (Base::level_stack_.template Push<typename Base::Level>()) typename Base::Level(true);
160  return Base::WriteStartArray();
161  }
162 
163  bool EndArray(SizeType memberCount = 0) {
164  (void)memberCount;
165  RAPIDJSON_ASSERT(Base::level_stack_.GetSize() >= sizeof(typename Base::Level));
166  RAPIDJSON_ASSERT(Base::level_stack_.template Top<typename Base::Level>()->inArray);
167  bool empty = Base::level_stack_.template Pop<typename Base::Level>(1)->valueCount == 0;
168 
169  if (!empty && !(formatOptions_ & kFormatSingleLineArray)) {
170  Base::os_->Put('\n');
171  WriteIndent();
172  }
173  bool ret = Base::EndValue(Base::WriteEndArray());
174  (void)ret;
175  RAPIDJSON_ASSERT(ret == true);
176  if (Base::level_stack_.Empty()) // end of json text
177  Base::Flush();
178  return true;
179  }
180 
181  //@}
182 
183  /*! @name Convenience extensions */
184  //@{
185 
186  //! Simpler but slower overload.
187  bool String(const Ch* str) { return String(str, internal::StrLen(str)); }
188  bool Key(const Ch* str) { return Key(str, internal::StrLen(str)); }
189 
190  //@}
191 
192  //! Write a raw JSON value.
193  /*!
194  For user to write a stringified JSON as a value.
195 
196  \param json A well-formed JSON value. It should not contain null character within [0, length - 1] range.
197  \param length Length of the json.
198  \param type Type of the root of json.
199  \note When using PrettyWriter::RawValue(), the result json may not be indented correctly.
200  */
201  bool RawValue(const Ch* json, size_t length, Type type) {
202  RAPIDJSON_ASSERT(json != 0);
203  PrettyPrefix(type);
204  return Base::EndValue(Base::WriteRawValue(json, length));
205  }
206 
207 protected:
209  (void)type;
210  if (Base::level_stack_.GetSize() != 0) { // this value is not at root
211  typename Base::Level* level = Base::level_stack_.template Top<typename Base::Level>();
212 
213  if (level->inArray) {
214  if (level->valueCount > 0) {
215  Base::os_->Put(','); // add comma if it is not the first element in array
217  Base::os_->Put(' ');
218  }
219 
221  Base::os_->Put('\n');
222  WriteIndent();
223  }
224  }
225  else { // in object
226  if (level->valueCount > 0) {
227  if (level->valueCount % 2 == 0) {
228  Base::os_->Put(',');
229  Base::os_->Put('\n');
230  }
231  else {
232  Base::os_->Put(':');
233  Base::os_->Put(' ');
234  }
235  }
236  else
237  Base::os_->Put('\n');
238 
239  if (level->valueCount % 2 == 0)
240  WriteIndent();
241  }
242  if (!level->inArray && level->valueCount % 2 == 0)
243  RAPIDJSON_ASSERT(type == kStringType); // if it's in object, then even number should be a name
244  level->valueCount++;
245  }
246  else {
247  RAPIDJSON_ASSERT(!Base::hasRoot_); // Should only has one and only one root.
248  Base::hasRoot_ = true;
249  }
250  }
251 
252  void WriteIndent() {
253  size_t count = (Base::level_stack_.GetSize() / sizeof(typename Base::Level)) * indentCharCount_;
254  PutN(*Base::os_, static_cast<typename OutputStream::Ch>(indentChar_), count);
255  }
256 
260 
261 private:
262  // Prohibit copy constructor & assignment operator.
263  PrettyWriter(const PrettyWriter&);
265 };
266 
268 
269 #if defined(__clang__)
270 RAPIDJSON_DIAG_POP
271 #endif
272 
273 #ifdef __GNUC__
274 RAPIDJSON_DIAG_POP
275 #endif
276 
277 #endif // RAPIDJSON_RAPIDJSON_H_
PrettyFormatOptions
Combination of PrettyWriter format flags.
Definition: prettywriter.h:35
bool EndValue(bool ret)
Definition: writer.h:494
unsigned indentCharCount_
Definition: prettywriter.h:258
bool RawValue(const Ch *json, size_t length, Type type)
Write a raw JSON value.
Definition: prettywriter.h:201
void WriteIndent()
Definition: prettywriter.h:252
size_t valueCount
number of values in this level
Definition: writer.h:289
void Flush()
Flush the output stream.
Definition: writer.h:281
RAPIDJSON_NAMESPACE_BEGIN typedef unsigned SizeType
Size type (for string lengths, array sizes, etc.)
Definition: rapidjson.h:384
bool inArray
true if in array, otherwise in object
Definition: writer.h:290
#define RAPIDJSON_ASSERT(x)
Assertion.
Definition: rapidjson.h:406
PrettyFormatOptions formatOptions_
Definition: prettywriter.h:259
bool WriteInt64(int64_t i64)
Definition: writer.h:330
JSON writer.
Definition: fwd.h:95
object
Definition: rapidjson.h:622
void PrettyPrefix(Type type)
Definition: prettywriter.h:208
PrettyWriter & SetIndent(Ch indentChar, unsigned indentCharCount)
Set custom indentation.
Definition: prettywriter.h:75
bool String(const Ch *str)
Simpler but slower overload.
Definition: prettywriter.h:187
bool WriteUint64(uint64_t u64)
Definition: writer.h:339
#define RAPIDJSON_NAMESPACE_END
provide custom rapidjson namespace (closing expression)
Definition: rapidjson.h:124
static const size_t kDefaultLevelDepth
Definition: writer.h:293
void PutN(FileWriteStream &stream, char c, size_t n)
Implement specialized version of PutN() with memset() for better performance.
array
Definition: rapidjson.h:623
bool Key(const Ch *str, SizeType length, bool copy=false)
Definition: prettywriter.h:129
bool WriteRawValue(const Ch *json, size_t length)
Definition: writer.h:459
Level
Definition: Level.h:13
bool StartObject()
Definition: prettywriter.h:123
bool hasRoot_
Definition: writer.h:503
false
Definition: rapidjson.h:620
bool WriteStartObject()
Definition: writer.h:454
PrettyWriter & operator=(const PrettyWriter &)
bool Int(int i)
Definition: prettywriter.h:97
PrettyWriter(StackAllocator *allocator=0, size_t levelDepth=Base::kDefaultLevelDepth)
Definition: prettywriter.h:62
bool Bool(bool b)
Definition: prettywriter.h:96
#define RAPIDJSON_NAMESPACE_BEGIN
provide custom rapidjson namespace (opening expression)
Definition: rapidjson.h:121
Default pretty formatting.
Definition: prettywriter.h:36
Base::Ch Ch
Definition: prettywriter.h:51
bool RawNumber(const Ch *str, SizeType length, bool copy=false)
Definition: prettywriter.h:103
bool WriteUint(unsigned u)
Definition: writer.h:321
OutputStream * os_
Definition: writer.h:500
SourceEncoding::Ch Ch
Definition: writer.h:91
Information for each nested level.
Definition: writer.h:287
string
Definition: rapidjson.h:624
bool EndObject(SizeType memberCount=0)
Definition: prettywriter.h:137
bool WriteNull()
Definition: writer.h:295
unsigned __int64 uint64_t
Definition: stdint.h:136
number
Definition: rapidjson.h:625
size_t GetSize() const
Definition: stack.h:177
bool WriteEndObject()
Definition: writer.h:455
bool Int64(int64_t i64)
Definition: prettywriter.h:99
bool Key(const Ch *str)
Definition: prettywriter.h:188
bool WriteString(const Ch *str, SizeType length)
Definition: writer.h:376
bool EndArray(SizeType memberCount=0)
Definition: prettywriter.h:163
signed __int64 int64_t
Definition: stdint.h:135
bool WriteEndArray()
Definition: writer.h:457
PrettyWriter(OutputStream &os, StackAllocator *allocator=0, size_t levelDepth=Base::kDefaultLevelDepth)
Constructor.
Definition: prettywriter.h:58
T copy(T const &v)
static bool * b
Definition: config.cpp:1043
true
Definition: rapidjson.h:621
bool WriteStartArray()
Definition: writer.h:456
SizeType StrLen(const Ch *s)
Custom strlen() which works on different character types.
Definition: strfunc.h:31
bool String(const Ch *str, SizeType length, bool copy=false)
Definition: prettywriter.h:110
internal::Stack< StackAllocator > level_stack_
Definition: writer.h:501
bool WriteDouble(double d)
Definition: writer.h:348
Format arrays on a single line.
Definition: prettywriter.h:37
Type
Type of JSON value.
Definition: rapidjson.h:618
Writer< OutputStream, SourceEncoding, TargetEncoding, StackAllocator, writeFlags > Base
Definition: prettywriter.h:50
bool StartArray()
Definition: prettywriter.h:157
PrettyWriter & SetFormatOptions(PrettyFormatOptions options)
Set pretty writer formatting options.
Definition: prettywriter.h:85
bool Uint64(uint64_t u64)
Definition: prettywriter.h:100
bool WriteInt(int i)
Definition: writer.h:312
static QCString str
decltype(auto) constexpr empty(T &&obj)
ADL-aware version of std::empty.
Definition: StdUtils.h:97
Writer with indentation and spacing.
Definition: fwd.h:100
bool Uint(unsigned u)
Definition: prettywriter.h:98
null
Definition: rapidjson.h:619
bool WriteBool(bool b)
Definition: writer.h:300
bool Double(double d)
Definition: prettywriter.h:101