]> git.proxmox.com Git - ceph.git/blame - ceph/src/common/Formatter.cc
update sources to v12.2.1
[ceph.git] / ceph / src / common / Formatter.cc
CommitLineData
7c673cae
FG
1// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
2// vim: ts=8 sw=2 smarttab
3/*
4 * Ceph - scalable distributed file system
5 *
6 * Copyright (C) 2011 New Dream Network
7 *
8 * This is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License version 2.1, as published by the Free Software
11 * Foundation. See file COPYING.
12 *
13 */
14
15#define LARGE_SIZE 1024
16
7c673cae
FG
17#include "HTMLFormatter.h"
18#include "common/escape.h"
19#include "include/buffer.h"
20
7c673cae
FG
21#include <set>
22#include <boost/format.hpp>
23
7c673cae
FG
24// -----------------------
25namespace ceph {
26
27/*
28 * FormatterAttrs(const char *attr, ...)
29 *
30 * Requires a list of attrs followed by NULL. The attrs should be char *
31 * pairs, first one is the name, second one is the value. E.g.,
32 *
33 * FormatterAttrs("name1", "value1", "name2", "value2", NULL);
34 */
35FormatterAttrs::FormatterAttrs(const char *attr, ...)
36{
37 const char *s = attr;
38 va_list ap;
39 va_start(ap, attr);
40 do {
41 const char *val = va_arg(ap, char *);
42 if (!val)
43 break;
44
45 attrs.push_back(make_pair(std::string(s), std::string(val)));
46 s = va_arg(ap, char *);
47 } while (s);
48 va_end(ap);
49}
50
51Formatter::Formatter() { }
52
53Formatter::~Formatter() { }
54
55Formatter *Formatter::create(const std::string &type,
56 const std::string& default_type,
57 const std::string& fallback)
58{
59 std::string mytype = type;
60 if (mytype == "")
61 mytype = default_type;
62
63 if (mytype == "json")
64 return new JSONFormatter(false);
65 else if (mytype == "json-pretty")
66 return new JSONFormatter(true);
67 else if (mytype == "xml")
68 return new XMLFormatter(false);
69 else if (mytype == "xml-pretty")
70 return new XMLFormatter(true);
71 else if (mytype == "table")
72 return new TableFormatter();
73 else if (mytype == "table-kv")
74 return new TableFormatter(true);
75 else if (mytype == "html")
76 return new HTMLFormatter(false);
77 else if (mytype == "html-pretty")
78 return new HTMLFormatter(true);
79 else if (fallback != "")
80 return create(fallback, "", "");
81 else
82 return (Formatter *) NULL;
83}
84
85
86void Formatter::flush(bufferlist &bl)
87{
88 std::stringstream os;
89 flush(os);
90 bl.append(os.str());
91}
92
93void Formatter::dump_format(const char *name, const char *fmt, ...)
94{
95 va_list ap;
96 va_start(ap, fmt);
97 dump_format_va(name, NULL, true, fmt, ap);
98 va_end(ap);
99}
100
101void Formatter::dump_format_ns(const char *name, const char *ns, const char *fmt, ...)
102{
103 va_list ap;
104 va_start(ap, fmt);
105 dump_format_va(name, ns, true, fmt, ap);
106 va_end(ap);
107
108}
109
110void Formatter::dump_format_unquoted(const char *name, const char *fmt, ...)
111{
112 va_list ap;
113 va_start(ap, fmt);
114 dump_format_va(name, NULL, false, fmt, ap);
115 va_end(ap);
116}
117
118// -----------------------
119
120JSONFormatter::JSONFormatter(bool p)
121: m_pretty(p), m_is_pending_string(false)
122{
123 reset();
124}
125
126void JSONFormatter::flush(std::ostream& os)
127{
128 finish_pending_string();
129 os << m_ss.str();
181888fb
FG
130 if (m_line_break_enabled)
131 os << "\n";
7c673cae
FG
132 m_ss.clear();
133 m_ss.str("");
134}
135
136void JSONFormatter::reset()
137{
138 m_stack.clear();
139 m_ss.clear();
140 m_ss.str("");
141 m_pending_string.clear();
142 m_pending_string.str("");
143}
144
145void JSONFormatter::print_comma(json_formatter_stack_entry_d& entry)
146{
147 if (entry.size) {
148 if (m_pretty) {
149 m_ss << ",\n";
150 for (unsigned i = 1; i < m_stack.size(); i++)
151 m_ss << " ";
152 } else {
153 m_ss << ",";
154 }
155 } else if (m_pretty) {
156 m_ss << "\n";
157 for (unsigned i = 1; i < m_stack.size(); i++)
158 m_ss << " ";
159 }
160 if (m_pretty && entry.is_array)
161 m_ss << " ";
162}
163
164void JSONFormatter::print_quoted_string(const std::string& s)
165{
166 int len = escape_json_attr_len(s.c_str(), s.size());
167 char escaped[len];
168 escape_json_attr(s.c_str(), s.size(), escaped);
169 m_ss << '\"' << escaped << '\"';
170}
171
172void JSONFormatter::print_name(const char *name)
173{
174 finish_pending_string();
175 if (m_stack.empty())
176 return;
177 struct json_formatter_stack_entry_d& entry = m_stack.back();
178 print_comma(entry);
179 if (!entry.is_array) {
180 if (m_pretty) {
181 m_ss << " ";
182 }
183 m_ss << "\"" << name << "\"";
184 if (m_pretty)
185 m_ss << ": ";
186 else
187 m_ss << ':';
188 }
189 ++entry.size;
190}
191
192void JSONFormatter::open_section(const char *name, bool is_array)
193{
194 print_name(name);
195 if (is_array)
196 m_ss << '[';
197 else
198 m_ss << '{';
199
200 json_formatter_stack_entry_d n;
201 n.is_array = is_array;
202 m_stack.push_back(n);
203}
204
205void JSONFormatter::open_array_section(const char *name)
206{
207 open_section(name, true);
208}
209
210void JSONFormatter::open_array_section_in_ns(const char *name, const char *ns)
211{
212 std::ostringstream oss;
213 oss << name << " " << ns;
214 open_section(oss.str().c_str(), true);
215}
216
217void JSONFormatter::open_object_section(const char *name)
218{
219 open_section(name, false);
220}
221
222void JSONFormatter::open_object_section_in_ns(const char *name, const char *ns)
223{
224 std::ostringstream oss;
225 oss << name << " " << ns;
226 open_section(oss.str().c_str(), false);
227}
228
229void JSONFormatter::close_section()
230{
231 assert(!m_stack.empty());
232 finish_pending_string();
233
234 struct json_formatter_stack_entry_d& entry = m_stack.back();
235 if (m_pretty && entry.size) {
236 m_ss << "\n";
237 for (unsigned i = 1; i < m_stack.size(); i++)
238 m_ss << " ";
239 }
240 m_ss << (entry.is_array ? ']' : '}');
241 m_stack.pop_back();
242 if (m_pretty && m_stack.empty())
243 m_ss << "\n";
244}
245
246void JSONFormatter::finish_pending_string()
247{
248 if (m_is_pending_string) {
249 print_quoted_string(m_pending_string.str());
250 m_pending_string.str(std::string());
251 m_is_pending_string = false;
252 }
253}
254
255void JSONFormatter::dump_unsigned(const char *name, uint64_t u)
256{
257 print_name(name);
258 m_ss << u;
259}
260
261void JSONFormatter::dump_int(const char *name, int64_t s)
262{
263 print_name(name);
264 m_ss << s;
265}
266
267void JSONFormatter::dump_float(const char *name, double d)
268{
269 print_name(name);
270 char foo[30];
271 snprintf(foo, sizeof(foo), "%lf", d);
272 m_ss << foo;
273}
274
275void JSONFormatter::dump_string(const char *name, const std::string& s)
276{
277 print_name(name);
278 print_quoted_string(s);
279}
280
281std::ostream& JSONFormatter::dump_stream(const char *name)
282{
283 print_name(name);
284 m_is_pending_string = true;
285 return m_pending_string;
286}
287
288void JSONFormatter::dump_format_va(const char *name, const char *ns, bool quoted, const char *fmt, va_list ap)
289{
290 char buf[LARGE_SIZE];
291 vsnprintf(buf, LARGE_SIZE, fmt, ap);
292
293 print_name(name);
294 if (quoted) {
295 print_quoted_string(std::string(buf));
296 } else {
297 m_ss << std::string(buf);
298 }
299}
300
301int JSONFormatter::get_len() const
302{
303 return m_ss.str().size();
304}
305
306void JSONFormatter::write_raw_data(const char *data)
307{
308 m_ss << data;
309}
310
311const char *XMLFormatter::XML_1_DTD =
312 "<?xml version=\"1.0\" encoding=\"UTF-8\"?>";
313
314XMLFormatter::XMLFormatter(bool pretty, bool lowercased, bool underscored)
315: m_pretty(pretty),
316 m_lowercased(lowercased),
317 m_underscored(underscored)
318{
319 reset();
320}
321
322void XMLFormatter::flush(std::ostream& os)
323{
324 finish_pending_string();
325 std::string m_ss_str = m_ss.str();
326 os << m_ss_str;
327 /* There is a small catch here. If the rest of the formatter had NO output,
328 * we should NOT output a newline. This primarily triggers on HTTP redirects */
329 if (m_pretty && !m_ss_str.empty())
330 os << "\n";
181888fb
FG
331 else if (m_line_break_enabled)
332 os << "\n";
7c673cae
FG
333 m_ss.clear();
334 m_ss.str("");
335}
336
337void XMLFormatter::reset()
338{
339 m_ss.clear();
340 m_ss.str("");
341 m_pending_string.clear();
342 m_pending_string.str("");
343 m_sections.clear();
344 m_pending_string_name.clear();
345 m_header_done = false;
346}
347
348void XMLFormatter::output_header()
349{
350 if(!m_header_done) {
351 m_header_done = true;
352 write_raw_data(XMLFormatter::XML_1_DTD);;
353 if (m_pretty)
354 m_ss << "\n";
355 }
356}
357
358void XMLFormatter::output_footer()
359{
360 while(!m_sections.empty()) {
361 close_section();
362 }
363}
364
365void XMLFormatter::open_object_section(const char *name)
366{
367 open_section_in_ns(name, NULL, NULL);
368}
369
370void XMLFormatter::open_object_section_with_attrs(const char *name, const FormatterAttrs& attrs)
371{
372 open_section_in_ns(name, NULL, &attrs);
373}
374
375void XMLFormatter::open_object_section_in_ns(const char *name, const char *ns)
376{
377 open_section_in_ns(name, ns, NULL);
378}
379
380void XMLFormatter::open_array_section(const char *name)
381{
382 open_section_in_ns(name, NULL, NULL);
383}
384
385void XMLFormatter::open_array_section_with_attrs(const char *name, const FormatterAttrs& attrs)
386{
387 open_section_in_ns(name, NULL, &attrs);
388}
389
390void XMLFormatter::open_array_section_in_ns(const char *name, const char *ns)
391{
392 open_section_in_ns(name, ns, NULL);
393}
394
395void XMLFormatter::close_section()
396{
397 assert(!m_sections.empty());
398 finish_pending_string();
399
400 std::string section = m_sections.back();
401 std::transform(section.begin(), section.end(), section.begin(),
402 [this](char c) { return this->to_lower_underscore(c); });
403 m_sections.pop_back();
404 print_spaces();
405 m_ss << "</" << section << ">";
406 if (m_pretty)
407 m_ss << "\n";
408}
409
410void XMLFormatter::dump_unsigned(const char *name, uint64_t u)
411{
412 std::string e(name);
413 std::transform(e.begin(), e.end(), e.begin(),
414 [this](char c) { return this->to_lower_underscore(c); });
415
416 print_spaces();
417 m_ss << "<" << e << ">" << u << "</" << e << ">";
418 if (m_pretty)
419 m_ss << "\n";
420}
421
422void XMLFormatter::dump_int(const char *name, int64_t u)
423{
424 std::string e(name);
425 std::transform(e.begin(), e.end(), e.begin(),
426 [this](char c) { return this->to_lower_underscore(c); });
427
428 print_spaces();
429 m_ss << "<" << e << ">" << u << "</" << e << ">";
430 if (m_pretty)
431 m_ss << "\n";
432}
433
434void XMLFormatter::dump_float(const char *name, double d)
435{
436 std::string e(name);
437 std::transform(e.begin(), e.end(), e.begin(),
438 [this](char c) { return this->to_lower_underscore(c); });
439
440 print_spaces();
441 m_ss << "<" << e << ">" << d << "</" << e << ">";
442 if (m_pretty)
443 m_ss << "\n";
444}
445
446void XMLFormatter::dump_string(const char *name, const std::string& s)
447{
448 std::string e(name);
449 std::transform(e.begin(), e.end(), e.begin(),
450 [this](char c) { return this->to_lower_underscore(c); });
451
452 print_spaces();
453 m_ss << "<" << e << ">" << escape_xml_str(s.c_str()) << "</" << e << ">";
454 if (m_pretty)
455 m_ss << "\n";
456}
457
458void XMLFormatter::dump_string_with_attrs(const char *name, const std::string& s, const FormatterAttrs& attrs)
459{
460 std::string e(name);
461 std::transform(e.begin(), e.end(), e.begin(),
462 [this](char c) { return this->to_lower_underscore(c); });
463
464 std::string attrs_str;
465 get_attrs_str(&attrs, attrs_str);
466 print_spaces();
467 m_ss << "<" << e << attrs_str << ">" << escape_xml_str(s.c_str()) << "</" << e << ">";
468 if (m_pretty)
469 m_ss << "\n";
470}
471
472std::ostream& XMLFormatter::dump_stream(const char *name)
473{
474 print_spaces();
475 m_pending_string_name = name;
476 m_ss << "<" << m_pending_string_name << ">";
477 return m_pending_string;
478}
479
480void XMLFormatter::dump_format_va(const char* name, const char *ns, bool quoted, const char *fmt, va_list ap)
481{
482 char buf[LARGE_SIZE];
483 vsnprintf(buf, LARGE_SIZE, fmt, ap);
484 std::string e(name);
485 std::transform(e.begin(), e.end(), e.begin(),
486 [this](char c) { return this->to_lower_underscore(c); });
487
488 print_spaces();
489 if (ns) {
490 m_ss << "<" << e << " xmlns=\"" << ns << "\">" << buf << "</" << e << ">";
491 } else {
492 m_ss << "<" << e << ">" << escape_xml_str(buf) << "</" << e << ">";
493 }
494
495 if (m_pretty)
496 m_ss << "\n";
497}
498
499int XMLFormatter::get_len() const
500{
501 return m_ss.str().size();
502}
503
504void XMLFormatter::write_raw_data(const char *data)
505{
506 m_ss << data;
507}
508
509void XMLFormatter::get_attrs_str(const FormatterAttrs *attrs, std::string& attrs_str)
510{
511 std::stringstream attrs_ss;
512
513 for (std::list<std::pair<std::string, std::string> >::const_iterator iter = attrs->attrs.begin();
514 iter != attrs->attrs.end(); ++iter) {
515 std::pair<std::string, std::string> p = *iter;
516 attrs_ss << " " << p.first << "=" << "\"" << p.second << "\"";
517 }
518
519 attrs_str = attrs_ss.str();
520}
521
522void XMLFormatter::open_section_in_ns(const char *name, const char *ns, const FormatterAttrs *attrs)
523{
524 print_spaces();
525 std::string attrs_str;
526
527 if (attrs) {
528 get_attrs_str(attrs, attrs_str);
529 }
530
531 std::string e(name);
532 std::transform(e.begin(), e.end(), e.begin(),
533 [this](char c) { return this->to_lower_underscore(c); });
534
535 if (ns) {
536 m_ss << "<" << e << attrs_str << " xmlns=\"" << ns << "\">";
537 } else {
538 m_ss << "<" << e << attrs_str << ">";
539 }
540 if (m_pretty)
541 m_ss << "\n";
542 m_sections.push_back(name);
543}
544
545void XMLFormatter::finish_pending_string()
546{
547 if (!m_pending_string_name.empty()) {
548 m_ss << escape_xml_str(m_pending_string.str().c_str())
549 << "</" << m_pending_string_name << ">";
550 m_pending_string_name.clear();
551 m_pending_string.str(std::string());
552 if (m_pretty) {
553 m_ss << "\n";
554 }
555 }
556}
557
558void XMLFormatter::print_spaces()
559{
560 finish_pending_string();
561 if (m_pretty) {
562 std::string spaces(m_sections.size(), ' ');
563 m_ss << spaces;
564 }
565}
566
567std::string XMLFormatter::escape_xml_str(const char *str)
568{
569 int len = escape_xml_attr_len(str);
570 std::vector<char> escaped(len, '\0');
571 escape_xml_attr(str, &escaped[0]);
572 return std::string(&escaped[0]);
573}
574
575char XMLFormatter::to_lower_underscore(char c) const
576{
577 if (m_underscored && c == ' ') {
578 return '_';
579 } else if (m_lowercased) {
580 return std::tolower(c);
581 }
582 return c;
583}
584
585TableFormatter::TableFormatter(bool keyval) : m_keyval(keyval)
586{
587 reset();
588}
589
590void TableFormatter::flush(std::ostream& os)
591{
592 finish_pending_string();
593 std::vector<size_t> column_size = m_column_size;
594 std::vector<std::string> column_name = m_column_name;
595
596 std::set<int> need_header_set;
597
598 // auto-sizing columns
599 for (size_t i = 0; i < m_vec.size(); i++) {
600 for (size_t j = 0; j < m_vec[i].size(); j++) {
601 column_size.resize(m_vec[i].size());
602 column_name.resize(m_vec[i].size());
603 if (i > 0) {
604 if (m_vec[i - 1][j] != m_vec[i][j]) {
605 // changing row labels require to show the header
606 need_header_set.insert(i);
607 column_name[i] = m_vec[i][j].first;
608 }
609 } else {
610 column_name[i] = m_vec[i][j].first;
611 }
612
613 if (m_vec[i][j].second.length() > column_size[j])
614 column_size[j] = m_vec[i][j].second.length();
615 if (m_vec[i][j].first.length() > column_size[j])
616 column_size[j] = m_vec[i][j].first.length();
617 }
618 }
619
620 bool need_header = false;
621 if ((column_size.size() == m_column_size.size())) {
622 for (size_t i = 0; i < column_size.size(); i++) {
623 if (column_size[i] != m_column_size[i]) {
624 need_header = true;
625 break;
626 }
627 }
628 } else {
629 need_header = true;
630 }
631
632 if (need_header) {
633 // first row always needs a header if there wasn't one before
634 need_header_set.insert(0);
635 }
636
637 m_column_size = column_size;
638 for (size_t i = 0; i < m_vec.size(); i++) {
639 if (i == 0) {
640 if (need_header_set.count(i)) {
641 // print the header
642 if (!m_keyval) {
643 os << "+";
644 for (size_t j = 0; j < m_vec[i].size(); j++) {
645 for (size_t v = 0; v < m_column_size[j] + 3; v++)
646 os << "-";
647 os << "+";
648 }
649 os << "\n";
650 os << "|";
651
652 for (size_t j = 0; j < m_vec[i].size(); j++) {
653 os << " ";
654 std::stringstream fs;
655 fs << boost::format("%%-%is") % (m_column_size[j] + 2);
656 os << boost::format(fs.str()) % m_vec[i][j].first;
657 os << "|";
658 }
659 os << "\n";
660 os << "+";
661 for (size_t j = 0; j < m_vec[i].size(); j++) {
662 for (size_t v = 0; v < m_column_size[j] + 3; v++)
663 os << "-";
664 os << "+";
665 }
666 os << "\n";
667 }
668 }
669 }
670 // print body
671 if (!m_keyval)
672 os << "|";
673 for (size_t j = 0; j < m_vec[i].size(); j++) {
674 if (!m_keyval)
675 os << " ";
676 std::stringstream fs;
677
678 if (m_keyval) {
679 os << "key::";
680 os << m_vec[i][j].first;
681 os << "=";
682 os << "\"";
683 os << m_vec[i][j].second;
684 os << "\" ";
685 } else {
686 fs << boost::format("%%-%is") % (m_column_size[j] + 2);
687 os << boost::format(fs.str()) % m_vec[i][j].second;
688 os << "|";
689 }
690 }
691
692 os << "\n";
693 if (!m_keyval) {
694 if (i == (m_vec.size() - 1)) {
695 // print trailer
696 os << "+";
697 for (size_t j = 0; j < m_vec[i].size(); j++) {
698 for (size_t v = 0; v < m_column_size[j] + 3; v++)
699 os << "-";
700 os << "+";
701 }
702 os << "\n";
703 }
704 }
705 m_vec[i].clear();
706 }
707 m_vec.clear();
708}
709
710void TableFormatter::reset()
711{
712 m_ss.clear();
713 m_ss.str("");
714 m_section_cnt.clear();
715 m_column_size.clear();
716 m_section_open = 0;
717}
718
719void TableFormatter::open_object_section(const char *name)
720{
721 open_section_in_ns(name, NULL, NULL);
722}
723
724void TableFormatter::open_object_section_with_attrs(const char *name, const FormatterAttrs& attrs)
725{
726 open_section_in_ns(name, NULL, NULL);
727}
728
729void TableFormatter::open_object_section_in_ns(const char *name, const char *ns)
730{
731 open_section_in_ns(name, NULL, NULL);
732}
733
734void TableFormatter::open_array_section(const char *name)
735{
736 open_section_in_ns(name, NULL, NULL);
737}
738
739void TableFormatter::open_array_section_with_attrs(const char *name, const FormatterAttrs& attrs)
740{
741 open_section_in_ns(name, NULL, NULL);
742}
743
744void TableFormatter::open_array_section_in_ns(const char *name, const char *ns)
745{
746 open_section_in_ns(name, NULL, NULL);
747}
748
749void TableFormatter::open_section_in_ns(const char *name, const char *ns, const FormatterAttrs *attrs)
750{
751 m_section.push_back(name);
752 m_section_open++;
753}
754
755void TableFormatter::close_section()
756{
757 //
758 m_section_open--;
759 if (m_section.size()) {
760 m_section_cnt[m_section.back()] = 0;
761 m_section.pop_back();
762 }
763}
764
765size_t TableFormatter::m_vec_index(const char *name)
766{
767 std::string key(name);
768
769 size_t i = m_vec.size();
770 if (i)
771 i--;
772
773 // make sure there are vectors to push back key/val pairs
774 if (!m_vec.size())
775 m_vec.resize(1);
776
777 if (m_vec.size()) {
778 if (m_vec[i].size()) {
779 if (m_vec[i][0].first == key) {
780 // start a new column if a key is repeated
781 m_vec.resize(m_vec.size() + 1);
782 i++;
783 }
784 }
785 }
786
787 return i;
788}
789
790std::string TableFormatter::get_section_name(const char* name)
791{
792 std::string t_name = name;
793 for (size_t i = 0; i < m_section.size(); i++) {
794 t_name.insert(0, ":");
795 t_name.insert(0, m_section[i]);
796 }
797 if (m_section_open) {
798 std::stringstream lss;
799 lss << t_name;
800 lss << "[";
801 lss << m_section_cnt[t_name]++;
802 lss << "]";
803 return lss.str();
804 } else {
805 return t_name;
806 }
807}
808
809void TableFormatter::dump_unsigned(const char *name, uint64_t u)
810{
811 finish_pending_string();
812 size_t i = m_vec_index(name);
813 m_ss << u;
814 m_vec[i].push_back(std::make_pair(get_section_name(name), m_ss.str()));
815 m_ss.clear();
816 m_ss.str("");
817}
818
819void TableFormatter::dump_int(const char *name, int64_t u)
820{
821 finish_pending_string();
822 size_t i = m_vec_index(name);
823 m_ss << u;
824 m_vec[i].push_back(std::make_pair(get_section_name(name), m_ss.str()));
825 m_ss.clear();
826 m_ss.str("");
827}
828
829void TableFormatter::dump_float(const char *name, double d)
830{
831 finish_pending_string();
832 size_t i = m_vec_index(name);
833 m_ss << d;
834
835 m_vec[i].push_back(std::make_pair(get_section_name(name), m_ss.str()));
836 m_ss.clear();
837 m_ss.str("");
838}
839
840void TableFormatter::dump_string(const char *name, const std::string& s)
841{
842 finish_pending_string();
843 size_t i = m_vec_index(name);
844 m_ss << s;
845
846 m_vec[i].push_back(std::make_pair(get_section_name(name), m_ss.str()));
847 m_ss.clear();
848 m_ss.str("");
849}
850
851void TableFormatter::dump_string_with_attrs(const char *name, const std::string& s, const FormatterAttrs& attrs)
852{
853 finish_pending_string();
854 size_t i = m_vec_index(name);
855
856 std::string attrs_str;
857 get_attrs_str(&attrs, attrs_str);
858 m_ss << attrs_str << s;
859
860 m_vec[i].push_back(std::make_pair(get_section_name(name), m_ss.str()));
861 m_ss.clear();
862 m_ss.str("");
863}
864
865void TableFormatter::dump_format_va(const char* name, const char *ns, bool quoted, const char *fmt, va_list ap)
866{
867 finish_pending_string();
868 char buf[LARGE_SIZE];
869 vsnprintf(buf, LARGE_SIZE, fmt, ap);
870
871 size_t i = m_vec_index(name);
872 if (ns) {
873 m_ss << ns << "." << buf;
874 } else
875 m_ss << buf;
876
877 m_vec[i].push_back(std::make_pair(get_section_name(name), m_ss.str()));
878 m_ss.clear();
879 m_ss.str("");
880}
881
882std::ostream& TableFormatter::dump_stream(const char *name)
883{
884 finish_pending_string();
885 // we don't support this
886 m_pending_name = name;
887 return m_ss;
888}
889
890int TableFormatter::get_len() const
891{
892 // we don't know the size until flush is called
893 return 0;
894}
895
896void TableFormatter::write_raw_data(const char *data) {
897 // not supported
898}
899
900void TableFormatter::get_attrs_str(const FormatterAttrs *attrs, std::string& attrs_str)
901{
902 std::stringstream attrs_ss;
903
904 for (std::list<std::pair<std::string, std::string> >::const_iterator iter = attrs->attrs.begin();
905 iter != attrs->attrs.end(); ++iter) {
906 std::pair<std::string, std::string> p = *iter;
907 attrs_ss << " " << p.first << "=" << "\"" << p.second << "\"";
908 }
909
910 attrs_str = attrs_ss.str();
911}
912
913void TableFormatter::finish_pending_string()
914{
915 if (m_pending_name.length()) {
916 std::string ss = m_ss.str();
917 m_ss.clear();
918 m_ss.str("");
919 std::string pending_name = m_pending_name;
920 m_pending_name = "";
921 dump_string(pending_name.c_str(), ss);
922 }
923}
924}
925