1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_FORMATTER_H
#define CEPH_FORMATTER_H
#include "include/int_types.h"
#include "include/buffer_fwd.h"
#include <deque>
#include <list>
#include <vector>
#include <stdarg.h>
#include <sstream>
#include <map>
namespace ceph {
struct FormatterAttrs {
std::list< std::pair<std::string, std::string> > attrs;
FormatterAttrs(const char *attr, ...);
};
class Formatter {
public:
class ObjectSection {
Formatter& formatter;
public:
ObjectSection(Formatter& f, const char *name) : formatter(f) {
formatter.open_object_section(name);
}
ObjectSection(Formatter& f, const char *name, const char *ns) : formatter(f) {
formatter.open_object_section_in_ns(name, ns);
}
~ObjectSection() {
formatter.close_section();
}
};
class ArraySection {
Formatter& formatter;
public:
ArraySection(Formatter& f, const char *name) : formatter(f) {
formatter.open_array_section(name);
}
ArraySection(Formatter& f, const char *name, const char *ns) : formatter(f) {
formatter.open_array_section_in_ns(name, ns);
}
~ArraySection() {
formatter.close_section();
}
};
static Formatter *create(std::string_view type,
std::string_view default_type,
std::string_view fallback);
static Formatter *create(std::string_view type,
std::string_view default_type) {
return create(type, default_type, "");
}
static Formatter *create(std::string_view type) {
return create(type, "json-pretty", "");
}
Formatter();
virtual ~Formatter();
virtual void enable_line_break() = 0;
virtual void flush(std::ostream& os) = 0;
void flush(bufferlist &bl);
virtual void reset() = 0;
virtual void set_status(int status, const char* status_name) = 0;
virtual void output_header() = 0;
virtual void output_footer() = 0;
virtual void open_array_section(const char *name) = 0;
virtual void open_array_section_in_ns(const char *name, const char *ns) = 0;
virtual void open_object_section(const char *name) = 0;
virtual void open_object_section_in_ns(const char *name, const char *ns) = 0;
virtual void close_section() = 0;
virtual void dump_unsigned(const char *name, uint64_t u) = 0;
virtual void dump_int(const char *name, int64_t s) = 0;
virtual void dump_float(const char *name, double d) = 0;
virtual void dump_string(const char *name, std::string_view s) = 0;
virtual void dump_bool(const char *name, bool b)
{
dump_format_unquoted(name, "%s", (b ? "true" : "false"));
}
template<typename T>
void dump_object(const char *name, const T& foo) {
open_object_section(name);
foo.dump(this);
close_section();
}
virtual std::ostream& dump_stream(const char *name) = 0;
virtual void dump_format_va(const char *name, const char *ns, bool quoted, const char *fmt, va_list ap) = 0;
virtual void dump_format(const char *name, const char *fmt, ...);
virtual void dump_format_ns(const char *name, const char *ns, const char *fmt, ...);
virtual void dump_format_unquoted(const char *name, const char *fmt, ...);
virtual int get_len() const = 0;
virtual void write_raw_data(const char *data) = 0;
/* with attrs */
virtual void open_array_section_with_attrs(const char *name, const FormatterAttrs& attrs)
{
open_array_section(name);
}
virtual void open_object_section_with_attrs(const char *name, const FormatterAttrs& attrs)
{
open_object_section(name);
}
virtual void dump_string_with_attrs(const char *name, std::string_view s, const FormatterAttrs& attrs)
{
dump_string(name, s);
}
};
class copyable_sstream : public std::stringstream {
public:
copyable_sstream() {}
copyable_sstream(const copyable_sstream& rhs) {
str(rhs.str());
}
copyable_sstream& operator=(const copyable_sstream& rhs) {
str(rhs.str());
return *this;
}
};
class JSONFormatter : public Formatter {
public:
explicit JSONFormatter(bool p = false);
void set_status(int status, const char* status_name) override {};
void output_header() override {};
void output_footer() override {};
void enable_line_break() override { m_line_break_enabled = true; }
void flush(std::ostream& os) override;
using Formatter::flush; // don't hide Formatter::flush(bufferlist &bl)
void reset() override;
void open_array_section(const char *name) override;
void open_array_section_in_ns(const char *name, const char *ns) override;
void open_object_section(const char *name) override;
void open_object_section_in_ns(const char *name, const char *ns) override;
void close_section() override;
void dump_unsigned(const char *name, uint64_t u) override;
void dump_int(const char *name, int64_t s) override;
void dump_float(const char *name, double d) override;
void dump_string(const char *name, std::string_view s) override;
std::ostream& dump_stream(const char *name) override;
void dump_format_va(const char *name, const char *ns, bool quoted, const char *fmt, va_list ap) override;
int get_len() const override;
void write_raw_data(const char *data) override;
protected:
virtual bool handle_value(const char *name, std::string_view s, bool quoted) {
return false; /* is handling done? */
}
virtual bool handle_open_section(const char *name, const char *ns, bool is_array) {
return false; /* is handling done? */
}
virtual bool handle_close_section() {
return false; /* is handling done? */
}
private:
struct json_formatter_stack_entry_d {
int size;
bool is_array;
json_formatter_stack_entry_d() : size(0), is_array(false) { }
};
bool m_pretty;
void open_section(const char *name, const char *ns, bool is_array);
void print_quoted_string(std::string_view s);
void print_name(const char *name);
void print_comma(json_formatter_stack_entry_d& entry);
void finish_pending_string();
template <class T>
void add_value(const char *name, T val);
void add_value(const char *name, std::string_view val, bool quoted);
copyable_sstream m_ss;
copyable_sstream m_pending_string;
std::string m_pending_name;
std::list<json_formatter_stack_entry_d> m_stack;
bool m_is_pending_string;
bool m_line_break_enabled = false;
};
template <class T>
void add_value(const char *name, T val);
class XMLFormatter : public Formatter {
public:
static const char *XML_1_DTD;
XMLFormatter(bool pretty = false, bool lowercased = false, bool underscored = true);
void set_status(int status, const char* status_name) override {}
void output_header() override;
void output_footer() override;
void enable_line_break() override { m_line_break_enabled = true; }
void flush(std::ostream& os) override;
using Formatter::flush; // don't hide Formatter::flush(bufferlist &bl)
void reset() override;
void open_array_section(const char *name) override;
void open_array_section_in_ns(const char *name, const char *ns) override;
void open_object_section(const char *name) override;
void open_object_section_in_ns(const char *name, const char *ns) override;
void close_section() override;
void dump_unsigned(const char *name, uint64_t u) override;
void dump_int(const char *name, int64_t s) override;
void dump_float(const char *name, double d) override;
void dump_string(const char *name, std::string_view s) override;
std::ostream& dump_stream(const char *name) override;
void dump_format_va(const char *name, const char *ns, bool quoted, const char *fmt, va_list ap) override;
int get_len() const override;
void write_raw_data(const char *data) override;
/* with attrs */
void open_array_section_with_attrs(const char *name, const FormatterAttrs& attrs) override;
void open_object_section_with_attrs(const char *name, const FormatterAttrs& attrs) override;
void dump_string_with_attrs(const char *name, std::string_view s, const FormatterAttrs& attrs) override;
protected:
void open_section_in_ns(const char *name, const char *ns, const FormatterAttrs *attrs);
void finish_pending_string();
void print_spaces();
void get_attrs_str(const FormatterAttrs *attrs, std::string& attrs_str);
char to_lower_underscore(char c) const;
std::stringstream m_ss, m_pending_string;
std::deque<std::string> m_sections;
const bool m_pretty;
const bool m_lowercased;
const bool m_underscored;
std::string m_pending_string_name;
bool m_header_done;
bool m_line_break_enabled = false;
private:
template <class T>
void add_value(const char *name, T val);
};
class TableFormatter : public Formatter {
public:
explicit TableFormatter(bool keyval = false);
void set_status(int status, const char* status_name) override {};
void output_header() override {};
void output_footer() override {};
void enable_line_break() override {};
void flush(std::ostream& os) override;
using Formatter::flush; // don't hide Formatter::flush(bufferlist &bl)
void reset() override;
void open_array_section(const char *name) override;
void open_array_section_in_ns(const char *name, const char *ns) override;
void open_object_section(const char *name) override;
void open_object_section_in_ns(const char *name, const char *ns) override;
void open_array_section_with_attrs(const char *name, const FormatterAttrs& attrs) override;
void open_object_section_with_attrs(const char *name, const FormatterAttrs& attrs) override;
void close_section() override;
void dump_unsigned(const char *name, uint64_t u) override;
void dump_int(const char *name, int64_t s) override;
void dump_float(const char *name, double d) override;
void dump_string(const char *name, std::string_view s) override;
void dump_format_va(const char *name, const char *ns, bool quoted, const char *fmt, va_list ap) override;
void dump_string_with_attrs(const char *name, std::string_view s, const FormatterAttrs& attrs) override;
std::ostream& dump_stream(const char *name) override;
int get_len() const override;
void write_raw_data(const char *data) override;
void get_attrs_str(const FormatterAttrs *attrs, std::string& attrs_str);
private:
template <class T>
void add_value(const char *name, T val);
void open_section_in_ns(const char *name, const char *ns, const FormatterAttrs *attrs);
std::vector< std::vector<std::pair<std::string, std::string> > > m_vec;
std::stringstream m_ss;
size_t m_vec_index(const char* name);
std::string get_section_name(const char* name);
void finish_pending_string();
std::string m_pending_name;
bool m_keyval;
int m_section_open;
std::vector< std::string > m_section;
std::map<std::string, int> m_section_cnt;
std::vector<size_t> m_column_size;
std::vector< std::string > m_column_name;
};
std::string fixed_to_string(int64_t num, int scale);
std::string fixed_u_to_string(uint64_t num, int scale);
}
#endif
|
