[ceph.git] / ceph / src / boost / libs / type_erasure / example / printf.cpp

// Boost.TypeErasure library
//
// Copyright 2012 Steven Watanabe
//
// Distributed under the Boost Software License Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// $Id$

//[printf
/*`
    (For the source of this example see
    [@boost:/libs/type_erasure/example/printf.cpp printf.cpp])

    This example uses the library to implement a type safe printf.

    [note This example uses C++11 features.  You'll need a
    recent compiler for it to work.]
 */

#include <boost/type_erasure/builtin.hpp>
#include <boost/type_erasure/operators.hpp>
#include <boost/type_erasure/any_cast.hpp>
#include <boost/type_erasure/any.hpp>
#include <boost/mpl/vector.hpp>
#include <boost/io/ios_state.hpp>
#include <iostream>
#include <sstream>
#include <iomanip>
#include <vector>
#include <string>

namespace mpl = boost::mpl;
using namespace boost::type_erasure;
using namespace boost::io;

// We capture the arguments by reference and require nothing
// except that each one must provide a stream insertion operator.
typedef any<
    mpl::vector<
        typeid_<>,
        ostreamable<>
    >,
    const _self&
> any_printable;
typedef std::vector<any_printable> print_storage;

// Forward declaration of the implementation function
void print_impl(std::ostream& os, const char * format, const print_storage& args);

// print
//
// Writes values to a stream like the classic C printf function.  The
// arguments are formatted based on specifiers in the format string,
// which match the pattern:
//
// '%' [ argument-number '$' ] flags * [ width ] [ '.' precision ] [ type-code ] format-specifier
//
// Other characters in the format string are written to the stream unchanged.
// In addition the sequence, "%%" can be used to print a literal '%' character.
// Each component is explained in detail below
//
// argument-number:
//   The value must be between 1 and sizeof... T.  It indicates the
//   index of the argument to be formatted.  If no index is specified
//   the arguments will be processed sequentially.  If an index is
//   specified for one argument, then it must be specified for every argument.
//
// flags:
//   Consists of zero or more of the following:
//   '-': Left justify the argument
//   '+': Print a plus sign for positive integers
//   '0': Use leading 0's to pad instead of filling with spaces.
//   ' ': If the value doesn't begin with a sign, prepend a space
//   '#': Print 0x or 0 for hexadecimal and octal numbers.
//
// width:
//   Indicates the minimum width to print.  This can be either
//   an integer or a '*'.  an asterisk means to read the next
//   argument (which must have type int) as the width.
//
// precision:
//   For numeric arguments, indicates the number of digits to print.  For
//   strings (%s) the precision indicates the maximum number of characters
//   to print.  Longer strings will be truncated.  As with width
//   this can be either an integer or a '*'.  an asterisk means
//   to read the next argument (which must have type int) as
//   the width.  If both the width and the precision are specified
//   as '*', the width is read first.
//
// type-code:
//   This is ignored, but provided for compatibility with C printf.
//
// format-specifier:
//   Must be one of the following characters:
//   d, i, u: The argument is formatted as a decimal integer
//   o:       The argument is formatted as an octal integer
//   x, X:    The argument is formatted as a hexadecimal integer
//   p:       The argument is formatted as a pointer
//   f:       The argument is formatted as a fixed point decimal
//   e, E:    The argument is formatted in exponential notation
//   g, G:    The argument is formatted as either fixed point or using
//            scientific notation depending on its magnitude
//   c:       The argument is formatted as a character
//   s:       The argument is formatted as a string
//
template<class... T>
void print(std::ostream& os, const char * format, const T&... t)
{
    // capture the arguments
    print_storage args = { any_printable(t)... };
    // and forward to the real implementation
    print_impl(os, format, args);
}

// This overload of print with no explicit stream writes to std::cout.
template<class... T>
void print(const char * format, const T&... t)
{
    print(std::cout, format, t...);
}

// The implementation from here on can be separately compiled.

// utility function to parse an integer
int parse_int(const char *& format) {
    int result = 0;
    while(char ch = *format) {
        switch(ch) {
        case '0': case '1': case '2': case '3': case '4':
        case '5': case '6': case '7': case '8': case '9':
            result = result * 10 + (ch - '0');
            break;
        default: return result;
        }
        ++format;
    }
    return result;
}

// printf implementation
void print_impl(std::ostream& os, const char * format, const print_storage& args) {
    int idx = 0;
    ios_flags_saver savef_outer(os, std::ios_base::dec);
    bool has_positional = false;
    bool has_indexed = false;
    while(char ch = *format++) {
        if (ch == '%') {
            if (*format == '%') { os << '%'; continue; }

            ios_flags_saver savef(os);
            ios_precision_saver savep(os);
            ios_fill_saver savefill(os);
            
            int precision = 0;
            bool pad_space = false;
            bool pad_zero = false;

            // parse argument index
            if (*format != '0') {
                int i = parse_int(format);
                if (i != 0) {
                    if(*format == '$') {
                        idx = i - 1;
                        has_indexed = true;
                        ++format;
                    } else {
                        os << std::setw(i);
                        has_positional = true;
                        goto parse_precision;
                    }
                } else {
                    has_positional = true;
                }
            } else {
                has_positional = true;
            }

            // Parse format modifiers
            while((ch = *format)) {
                switch(ch) {
                case '-': os << std::left; break;
                case '+': os << std::showpos; break;
                case '0': pad_zero = true; break;
                case ' ': pad_space = true; break;
                case '#': os << std::showpoint << std::showbase; break;
                default: goto parse_width;
                }
                ++format;
            }

        parse_width:
            int width;
            if (*format == '*') {
                ++format;
                width = any_cast<int>(args.at(idx++));
            } else {
                width = parse_int(format);
            }
            os << std::setw(width);

        parse_precision:
            if (*format == '.') {
                ++format;
                if (*format == '*') {
                    ++format;
                    precision = any_cast<int>(args.at(idx++));
                } else {
                    precision = parse_int(format);
                }
                os << std::setprecision(precision);
            }

            // parse (and ignore) the type modifier
            switch(*format) {
            case 'h': ++format; if(*format == 'h') ++format; break;
            case 'l': ++format; if(*format == 'l') ++format; break;
            case 'j':
            case 'L':
            case 'q':
            case 't':
            case 'z':
                ++format; break;
            }

            std::size_t truncate = 0;

            // parse the format code
            switch(*format++) {
            case 'd': case 'i': case 'u': os << std::dec; break;
            case 'o': os << std::oct; break;
            case 'p': case 'x': os << std::hex; break;
            case 'X': os << std::uppercase << std::hex; break;
            case 'f': os << std::fixed; break;
            case 'e': os << std::scientific; break;
            case 'E': os << std::uppercase << std::scientific; break;
            case 'g': break;
            case 'G': os << std::uppercase; break;
            case 'c': case 'C': break;
            case 's': case 'S': truncate = precision; os << std::setprecision(6); break;
            default: assert(!"Bad format string");
            }

            if (pad_zero && !(os.flags() & std::ios_base::left)) {
                os << std::setfill('0') << std::internal;
                pad_space = false;
            }

            if (truncate != 0 || pad_space) {
                // These can't be handled by std::setw.  Write to a stringstream and
                // pad/truncate manually.
                std::ostringstream oss;
                oss.copyfmt(os);
                oss << args.at(idx++);
                std::string data = oss.str();

                if (pad_space) {
                    if (data.empty() || (data[0] != '+' && data[0] != '-' && data[0] != ' ')) {
                        os << ' ';
                    }
                }
                if (truncate != 0 && data.size() > truncate) {
                    data.resize(truncate);
                }
                os << data;
            } else {
                os << args.at(idx++);
            }

            // we can't have both positional and indexed arguments in
            // the format string.
            assert(has_positional ^ has_indexed);

        } else {
            std::cout << ch;
        }
    }
}

int main() {
    print("int: %d\n", 10);
    print("int: %0#8X\n", 0xA56E);
    print("double: %g\n", 3.14159265358979323846);
    print("double: %f\n", 3.14159265358979323846);
    print("double: %+20.9e\n", 3.14159265358979323846);
    print("double: %0+20.9g\n", 3.14159265358979323846);
    print("double: %*.*g\n", 20, 5, 3.14159265358979323846);
    print("string: %.10s\n", "Hello World!");
    print("double: %2$*.*g int: %1$d\n", 10, 20, 5, 3.14159265358979323846);
}

//]
Commit	Line	Data
7c673cae FG	1	// Boost.TypeErasure library
	2	//
	3	// Copyright 2012 Steven Watanabe
	4	//
	5	// Distributed under the Boost Software License Version 1.0. (See
	6	// accompanying file LICENSE_1_0.txt or copy at
	7	// http://www.boost.org/LICENSE_1_0.txt)
	8	//
	9	// $Id$
	10
	11	//[printf
	12	/*`
	13	(For the source of this example see
	14	[@boost:/libs/type_erasure/example/printf.cpp printf.cpp])
	15
	16	This example uses the library to implement a type safe printf.
	17
	18	[note This example uses C++11 features. You'll need a
	19	recent compiler for it to work.]
	20	*/
	21
	22	#include <boost/type_erasure/builtin.hpp>
	23	#include <boost/type_erasure/operators.hpp>
	24	#include <boost/type_erasure/any_cast.hpp>
	25	#include <boost/type_erasure/any.hpp>
	26	#include <boost/mpl/vector.hpp>
	27	#include <boost/io/ios_state.hpp>
	28	#include <iostream>
	29	#include <sstream>
	30	#include <iomanip>
	31	#include <vector>
	32	#include <string>
	33
	34	namespace mpl = boost::mpl;
	35	using namespace boost::type_erasure;
	36	using namespace boost::io;
	37
	38	// We capture the arguments by reference and require nothing
	39	// except that each one must provide a stream insertion operator.
	40	typedef any<
	41	mpl::vector<
	42	typeid_<>,
	43	ostreamable<>
	44	>,
	45	const _self&
	46	> any_printable;
	47	typedef std::vector<any_printable> print_storage;
	48
	49	// Forward declaration of the implementation function
	50	void print_impl(std::ostream& os, const char * format, const print_storage& args);
	51
	52	// print
	53	//
	54	// Writes values to a stream like the classic C printf function. The
	55	// arguments are formatted based on specifiers in the format string,
	56	// which match the pattern:
	57	//
	58	// '%' [ argument-number '$' ] flags * [ width ] [ '.' precision ] [ type-code ] format-specifier
	59	//
	60	// Other characters in the format string are written to the stream unchanged.
	61	// In addition the sequence, "%%" can be used to print a literal '%' character.
	62	// Each component is explained in detail below
	63	//
	64	// argument-number:
65	// The value must be between 1 and sizeof... T. It indicates the
66	// index of the argument to be formatted. If no index is specified
67	// the arguments will be processed sequentially. If an index is
68	// specified for one argument, then it must be specified for every argument.
69	//
70	// flags:
71	// Consists of zero or more of the following:
72	// '-': Left justify the argument
73	// '+': Print a plus sign for positive integers
74	// '0': Use leading 0's to pad instead of filling with spaces.
75	// ' ': If the value doesn't begin with a sign, prepend a space
76	// '#': Print 0x or 0 for hexadecimal and octal numbers.
77	//
78	// width:
79	// Indicates the minimum width to print. This can be either
80	// an integer or a '*'. an asterisk means to read the next
81	// argument (which must have type int) as the width.
82	//
83	// precision:
84	// For numeric arguments, indicates the number of digits to print. For
85	// strings (%s) the precision indicates the maximum number of characters
86	// to print. Longer strings will be truncated. As with width
87	// this can be either an integer or a '*'. an asterisk means
88	// to read the next argument (which must have type int) as
89	// the width. If both the width and the precision are specified
90	// as '*', the width is read first.
91	//
92	// type-code:
93	// This is ignored, but provided for compatibility with C printf.
94	//
95	// format-specifier:
96	// Must be one of the following characters:
97	// d, i, u: The argument is formatted as a decimal integer
98	// o: The argument is formatted as an octal integer
99	// x, X: The argument is formatted as a hexadecimal integer
100	// p: The argument is formatted as a pointer
101	// f: The argument is formatted as a fixed point decimal
102	// e, E: The argument is formatted in exponential notation
103	// g, G: The argument is formatted as either fixed point or using
104	// scientific notation depending on its magnitude
105	// c: The argument is formatted as a character
106	// s: The argument is formatted as a string
107	//
108	template<class... T>
109	void print(std::ostream& os, const char * format, const T&... t)
110	{
111	// capture the arguments
112	print_storage args = { any_printable(t)... };
113	// and forward to the real implementation
114	print_impl(os, format, args);
115	}
116
117	// This overload of print with no explicit stream writes to std::cout.
118	template<class... T>
119	void print(const char * format, const T&... t)
120	{
121	print(std::cout, format, t...);
122	}
123
124	// The implementation from here on can be separately compiled.
125
126	// utility function to parse an integer
127	int parse_int(const char *& format) {
128	int result = 0;
129	while(char ch = *format) {
130	switch(ch) {
131	case '0': case '1': case '2': case '3': case '4':
132	case '5': case '6': case '7': case '8': case '9':
133	result = result * 10 + (ch - '0');
134	break;
135	default: return result;
136	}
137	++format;
138	}
139	return result;
140	}
141
142	// printf implementation
143	void print_impl(std::ostream& os, const char * format, const print_storage& args) {
144	int idx = 0;
145	ios_flags_saver savef_outer(os, std::ios_base::dec);
146	bool has_positional = false;
147	bool has_indexed = false;
148	while(char ch = *format++) {
149	if (ch == '%') {
150	if (*format == '%') { os << '%'; continue; }
151
152	ios_flags_saver savef(os);
153	ios_precision_saver savep(os);
154	ios_fill_saver savefill(os);
155
156	int precision = 0;
157	bool pad_space = false;
158	bool pad_zero = false;
159
160	// parse argument index
161	if (*format != '0') {
162	int i = parse_int(format);
163	if (i != 0) {
164	if(*format == '$') {
165	idx = i - 1;
166	has_indexed = true;
167	++format;
168	} else {
169	os << std::setw(i);
170	has_positional = true;
171	goto parse_precision;
172	}
173	} else {
174	has_positional = true;
175	}
176	} else {
177	has_positional = true;
178	}
179
180	// Parse format modifiers
181	while((ch = *format)) {
182	switch(ch) {
183	case '-': os << std::left; break;
184	case '+': os << std::showpos; break;
185	case '0': pad_zero = true; break;
186	case ' ': pad_space = true; break;
187	case '#': os << std::showpoint << std::showbase; break;
188	default: goto parse_width;
189	}
190	++format;
191	}
192
193	parse_width:
194	int width;
195	if (format == '') {
196	++format;
197	width = any_cast<int>(args.at(idx++));
198	} else {
199	width = parse_int(format);
200	}
201	os << std::setw(width);
202
203	parse_precision:
204	if (*format == '.') {
205	++format;
206	if (format == '') {
207	++format;
208	precision = any_cast<int>(args.at(idx++));
209	} else {
210	precision = parse_int(format);
211	}
212	os << std::setprecision(precision);
213	}
214
215	// parse (and ignore) the type modifier
216	switch(*format) {
217	case 'h': ++format; if(*format == 'h') ++format; break;
218	case 'l': ++format; if(*format == 'l') ++format; break;
219	case 'j':
220	case 'L':
221	case 'q':
222	case 't':
223	case 'z':
224	++format; break;
225	}
226
227	std::size_t truncate = 0;
228
229	// parse the format code
230	switch(*format++) {
231	case 'd': case 'i': case 'u': os << std::dec; break;
232	case 'o': os << std::oct; break;
233	case 'p': case 'x': os << std::hex; break;
234	case 'X': os << std::uppercase << std::hex; break;
235	case 'f': os << std::fixed; break;
236	case 'e': os << std::scientific; break;
237	case 'E': os << std::uppercase << std::scientific; break;
238	case 'g': break;
239	case 'G': os << std::uppercase; break;
240	case 'c': case 'C': break;
241	case 's': case 'S': truncate = precision; os << std::setprecision(6); break;
242	default: assert(!"Bad format string");
243	}
244
245	if (pad_zero && !(os.flags() & std::ios_base::left)) {
246	os << std::setfill('0') << std::internal;
247	pad_space = false;
248	}
249
250	if (truncate != 0 \|\| pad_space) {
251	// These can't be handled by std::setw. Write to a stringstream and
252	// pad/truncate manually.
253	std::ostringstream oss;
254	oss.copyfmt(os);
255	oss << args.at(idx++);
256	std::string data = oss.str();
257
258	if (pad_space) {
259	if (data.empty() \|\| (data[0] != '+' && data[0] != '-' && data[0] != ' ')) {
260	os << ' ';
261	}
262	}
263	if (truncate != 0 && data.size() > truncate) {
264	data.resize(truncate);
265	}
266	os << data;
267	} else {
268	os << args.at(idx++);
269	}
270
271	// we can't have both positional and indexed arguments in
272	// the format string.
273	assert(has_positional ^ has_indexed);
274
275	} else {
276	std::cout << ch;
277	}
278	}
279	}
280
281	int main() {
282	print("int: %d\n", 10);
283	print("int: %0#8X\n", 0xA56E);
284	print("double: %g\n", 3.14159265358979323846);
285	print("double: %f\n", 3.14159265358979323846);
286	print("double: %+20.9e\n", 3.14159265358979323846);
287	print("double: %0+20.9g\n", 3.14159265358979323846);
288	print("double: %.g\n", 20, 5, 3.14159265358979323846);
289	print("string: %.10s\n", "Hello World!");
290	print("double: %2$.g int: %1$d\n", 10, 20, 5, 3.14159265358979323846);
291	}
292
293	//]