prettywriter.h
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 RAPIDJSON_NAMESPACE_BEGIN
26
27 //! Combination of PrettyWriter format flags.
28 /*! \see PrettyWriter::SetFormatOptions
29 */
30 enum PrettyFormatOptions {
31 kFormatDefault = 0, //!< Default pretty formatting.
32 kFormatSingleLineArray = 1 //!< Format arrays on a single line.
33 };
34
35 //! Writer with indentation and spacing.
36 /*!
37 \tparam OutputStream Type of ouptut os.
38 \tparam SourceEncoding Encoding of source string.
39 \tparam TargetEncoding Encoding of output stream.
40 \tparam StackAllocator Type of allocator for allocating memory of stack.
41 */
42 template<typename OutputStream, typename SourceEncoding = UTF8<>, typename TargetEncoding = UTF8<>, typename StackAllocator = CrtAllocator, unsigned writeFlags = kWriteDefaultFlags>
43 class PrettyWriter : public Writer<OutputStream, SourceEncoding, TargetEncoding, StackAllocator, writeFlags> {
44 public:
45 typedef Writer<OutputStream, SourceEncoding, TargetEncoding, StackAllocator> Base;
46 typedef typename Base::Ch Ch;
47
48 //! Constructor
49 /*! \param os Output stream.
50 \param allocator User supplied allocator. If it is null, it will create a private one.
51 \param levelDepth Initial capacity of stack.
52 */
53 explicit PrettyWriter(OutputStream& os, StackAllocator* allocator = 0, size_t levelDepth = Base::kDefaultLevelDepth) :
54 Base(os, allocator, levelDepth), indentChar_(' '), indentCharCount_(4), formatOptions_(kFormatDefault) {}
55
56
57 explicit PrettyWriter(StackAllocator* allocator = 0, size_t levelDepth = Base::kDefaultLevelDepth) :
58 Base(allocator, levelDepth), indentChar_(' '), indentCharCount_(4) {}
59
60 //! Set custom indentation.
61 /*! \param indentChar Character for indentation. Must be whitespace character (' ', '\\t', '\\n', '\\r').
62 \param indentCharCount Number of indent characters for each indentation level.
63 \note The default indentation is 4 spaces.
64 */
65 PrettyWriter& SetIndent(Ch indentChar, unsigned indentCharCount) {
66 RAPIDJSON_ASSERT(indentChar == ' ' || indentChar == '\t' || indentChar == '\n' || indentChar == '\r');
67 indentChar_ = indentChar;
68 indentCharCount_ = indentCharCount;
69 return *this;
70 }
71
72 //! Set pretty writer formatting options.
73 /*! \param options Formatting options.
74 */
75 PrettyWriter& SetFormatOptions(PrettyFormatOptions options) {
76 formatOptions_ = options;
77 return *this;
78 }
79
80 /*! @name Implementation of Handler
81 \see Handler
82 */
83 //@{
84
85 bool Null() { PrettyPrefix(kNullType); return Base::WriteNull(); }
86 bool Bool(bool b) { PrettyPrefix(b ? kTrueType : kFalseType); return Base::WriteBool(b); }
87 bool Int(int i) { PrettyPrefix(kNumberType); return Base::WriteInt(i); }
88 bool Uint(unsigned u) { PrettyPrefix(kNumberType); return Base::WriteUint(u); }
89 bool Int64(int64_t i64) { PrettyPrefix(kNumberType); return Base::WriteInt64(i64); }
90 bool Uint64(uint64_t u64) { PrettyPrefix(kNumberType); return Base::WriteUint64(u64); }
91 bool Double(double d) { PrettyPrefix(kNumberType); return Base::WriteDouble(d); }
92
93 bool RawNumber(const Ch* str, SizeType length, bool copy = false) {
94 (void)copy;
95 PrettyPrefix(kNumberType);
96 return Base::WriteString(str, length);
97 }
98
99 bool String(const Ch* str, SizeType length, bool copy = false) {
100 (void)copy;
101 PrettyPrefix(kStringType);
102 return Base::WriteString(str, length);
103 }
104
105 #if RAPIDJSON_HAS_STDSTRING
106 bool String(const std::basic_string<Ch>& str) {
107 return String(str.data(), SizeType(str.size()));
108 }
109 #endif
110
111 bool StartObject() {
112 PrettyPrefix(kObjectType);
113 new (Base::level_stack_.template Push<typename Base::Level>()) typename Base::Level(false);
114 return Base::WriteStartObject();
115 }
116
117 bool Key(const Ch* str, SizeType length, bool copy = false) { return String(str, length, copy); }
118
119 #if RAPIDJSON_HAS_STDSTRING
120 bool Key(const std::basic_string<Ch>& str) {
121 return Key(str.data(), SizeType(str.size()));
122 }
123 #endif
124
125 bool EndObject(SizeType memberCount = 0) {
126 (void)memberCount;
127 RAPIDJSON_ASSERT(Base::level_stack_.GetSize() >= sizeof(typename Base::Level));
128 RAPIDJSON_ASSERT(!Base::level_stack_.template Top<typename Base::Level>()->inArray);
129 bool empty = Base::level_stack_.template Pop<typename Base::Level>(1)->valueCount == 0;
130
131 if (!empty) {
132 Base::os_->Put('\n');
133 WriteIndent();
134 }
135 bool ret = Base::WriteEndObject();
136 (void)ret;
137 RAPIDJSON_ASSERT(ret == true);
138 if (Base::level_stack_.Empty()) // end of json text
139 Base::os_->Flush();
140 return true;
141 }
142
143 bool StartArray() {
144 PrettyPrefix(kArrayType);
145 new (Base::level_stack_.template Push<typename Base::Level>()) typename Base::Level(true);
146 return Base::WriteStartArray();
147 }
148
149 bool EndArray(SizeType memberCount = 0) {
150 (void)memberCount;
151 RAPIDJSON_ASSERT(Base::level_stack_.GetSize() >= sizeof(typename Base::Level));
152 RAPIDJSON_ASSERT(Base::level_stack_.template Top<typename Base::Level>()->inArray);
153 bool empty = Base::level_stack_.template Pop<typename Base::Level>(1)->valueCount == 0;
154
155 if (!empty && !(formatOptions_ & kFormatSingleLineArray)) {
156 Base::os_->Put('\n');
157 WriteIndent();
158 }
159 bool ret = Base::WriteEndArray();
160 (void)ret;
161 RAPIDJSON_ASSERT(ret == true);
162 if (Base::level_stack_.Empty()) // end of json text
163 Base::os_->Flush();
164 return true;
165 }
166
167 //@}
168
169 /*! @name Convenience extensions */
170 //@{
171
172 //! Simpler but slower overload.
173 bool String(const Ch* str) { return String(str, internal::StrLen(str)); }
174 bool Key(const Ch* str) { return Key(str, internal::StrLen(str)); }
175
176 //@}
177
178 //! Write a raw JSON value.
179 /*!
180 For user to write a stringified JSON as a value.
181
182 \param json A well-formed JSON value. It should not contain null character within [0, length - 1] range.
183 \param length Length of the json.
184 \param type Type of the root of json.
185 \note When using PrettyWriter::RawValue(), the result json may not be indented correctly.
186 */
187 bool RawValue(const Ch* json, size_t length, Type type) { PrettyPrefix(type); return Base::WriteRawValue(json, length); }
188
189 protected:
190 void PrettyPrefix(Type type) {
191 (void)type;
192 if (Base::level_stack_.GetSize() != 0) { // this value is not at root
193 typename Base::Level* level = Base::level_stack_.template Top<typename Base::Level>();
194
195 if (level->inArray) {
196 if (level->valueCount > 0) {
197 Base::os_->Put(','); // add comma if it is not the first element in array
198 if (formatOptions_ & kFormatSingleLineArray)
199 Base::os_->Put(' ');
200 }
201
202 if (!(formatOptions_ & kFormatSingleLineArray)) {
203 Base::os_->Put('\n');
204 WriteIndent();
205 }
206 }
207 else { // in object
208 if (level->valueCount > 0) {
209 if (level->valueCount % 2 == 0) {
210 Base::os_->Put(',');
211 Base::os_->Put('\n');
212 }
213 else {
214 Base::os_->Put(':');
215 Base::os_->Put(' ');
216 }
217 }
218 else
219 Base::os_->Put('\n');
220
221 if (level->valueCount % 2 == 0)
222 WriteIndent();
223 }
224 if (!level->inArray && level->valueCount % 2 == 0)
225 RAPIDJSON_ASSERT(type == kStringType); // if it's in object, then even number should be a name
226 level->valueCount++;
227 }
228 else {
229 RAPIDJSON_ASSERT(!Base::hasRoot_); // Should only has one and only one root.
230 Base::hasRoot_ = true;
231 }
232 }
233
234 void WriteIndent() {
235 size_t count = (Base::level_stack_.GetSize() / sizeof(typename Base::Level)) * indentCharCount_;
236 PutN(*Base::os_, static_cast<typename TargetEncoding::Ch>(indentChar_), count);
237 }
238
239 Ch indentChar_;
240 unsigned indentCharCount_;
241 PrettyFormatOptions formatOptions_;
242
243 private:
244 // Prohibit copy constructor & assignment operator.
245 PrettyWriter(const PrettyWriter&);
246 PrettyWriter& operator=(const PrettyWriter&);
247 };
248
249 RAPIDJSON_NAMESPACE_END
250
251 #ifdef __GNUC__
252 RAPIDJSON_DIAG_POP
253 #endif
254
255 #endif // RAPIDJSON_RAPIDJSON_H_
rapidjson::kTrueType
true
Definition: rapidjson.h:606
rapidjson::Writer::Level::inArray
bool inArray
true if in array, otherwise in object
Definition: writer.h:259
rapidjson::PrettyWriter::String
bool String(const Ch *str)
Simpler but slower overload.
Definition: prettywriter.h:173
rapidjson::PrettyFormatOptions
PrettyFormatOptions
Combination of PrettyWriter format flags.
Definition: prettywriter.h:30
rapidjson::kFormatSingleLineArray
Format arrays on a single line.
Definition: prettywriter.h:32
rapidjson::SizeType
unsigned SizeType
Size type (for string lengths, array sizes, etc.)
Definition: rapidjson.h:380
rapidjson::kFalseType
false
Definition: rapidjson.h:605
rapidjson::PrettyWriter
Writer with indentation and spacing.
Definition: fwd.h:100
rapidjson::Writer::Level
Information for each nested level
Definition: writer.h:256
rapidjson::Writer::Level::valueCount
size_t valueCount
number of values in this level
Definition: writer.h:258
rapidjson::PrettyWriter::RawValue
bool RawValue(const Ch *json, size_t length, Type type)
Write a raw JSON value.
Definition: prettywriter.h:187
rapidjson::Type
Type
Type of JSON value
Definition: rapidjson.h:603
rapidjson::kObjectType
object
Definition: rapidjson.h:607
rapidjson::kArrayType
array
Definition: rapidjson.h:608
rapidjson::PutN
void PutN(FileWriteStream &stream, char c, size_t n)
Implement specialized version of PutN() with memset() for better performance.
Definition: filewritestream.h:94
rapidjson::Writer
JSON writer
Definition: fwd.h:95
rapidjson::kNullType
null
Definition: rapidjson.h:604
rapidjson::kFormatDefault
Default pretty formatting.
Definition: prettywriter.h:31
rapidjson::kStringType
string
Definition: rapidjson.h:609
rapidjson::PrettyWriter::SetIndent
PrettyWriter & SetIndent(Ch indentChar, unsigned indentCharCount)
Set custom indentation.
Definition: prettywriter.h:65
rapidjson::PrettyWriter::PrettyWriter
PrettyWriter(OutputStream &os, StackAllocator *allocator=0, size_t levelDepth=Base::kDefaultLevelDepth)
Constructor
Definition: prettywriter.h:53
rapidjson::PrettyWriter::SetFormatOptions
PrettyWriter & SetFormatOptions(PrettyFormatOptions options)
Set pretty writer formatting options.
Definition: prettywriter.h:75
RAPIDJSON_ASSERT
#define RAPIDJSON_ASSERT(x)
Assertion.
Definition: rapidjson.h:402
rapidjson::kNumberType
number
Definition: rapidjson.h:610