head 1.2; access; symbols netbsd-11-0-RC4:1.2 netbsd-11-0-RC3:1.2 netbsd-11-0-RC2:1.2 netbsd-11-0-RC1:1.2 perseant-exfatfs-base-20250801:1.2 netbsd-11:1.2.0.10 netbsd-11-base:1.2 netbsd-10-1-RELEASE:1.2 perseant-exfatfs-base-20240630:1.2 perseant-exfatfs:1.2.0.8 perseant-exfatfs-base:1.2 netbsd-8-3-RELEASE:1.1.1.1 netbsd-9-4-RELEASE:1.1.1.1 netbsd-10-0-RELEASE:1.2 netbsd-10-0-RC6:1.2 netbsd-10-0-RC5:1.2 netbsd-10-0-RC4:1.2 netbsd-10-0-RC3:1.2 netbsd-10-0-RC2:1.2 netbsd-10-0-RC1:1.2 netbsd-10:1.2.0.6 netbsd-10-base:1.2 netbsd-9-3-RELEASE:1.1.1.1 cjep_sun2x-base1:1.2 cjep_sun2x:1.2.0.4 cjep_sun2x-base:1.2 cjep_staticlib_x-base1:1.2 netbsd-9-2-RELEASE:1.1.1.1 cjep_staticlib_x:1.2.0.2 cjep_staticlib_x-base:1.2 netbsd-9-1-RELEASE:1.1.1.1 phil-wifi-20200421:1.1.1.1 phil-wifi-20200411:1.1.1.1 is-mlppp:1.1.1.1.0.40 is-mlppp-base:1.1.1.1 phil-wifi-20200406:1.1.1.1 netbsd-8-2-RELEASE:1.1.1.1 netbsd-9-0-RELEASE:1.1.1.1 netbsd-9-0-RC2:1.1.1.1 netbsd-9-0-RC1:1.1.1.1 phil-wifi-20191119:1.1.1.1 netbsd-9:1.1.1.1.0.38 netbsd-9-base:1.1.1.1 phil-wifi-20190609:1.1.1.1 netbsd-8-1-RELEASE:1.1.1.1 netbsd-8-1-RC1:1.1.1.1 pgoyette-compat-merge-20190127:1.1.1.1 pgoyette-compat-20190127:1.1.1.1 pgoyette-compat-20190118:1.1.1.1 pgoyette-compat-1226:1.1.1.1 pgoyette-compat-1126:1.1.1.1 pgoyette-compat-1020:1.1.1.1 pgoyette-compat-0930:1.1.1.1 pgoyette-compat-0906:1.1.1.1 netbsd-7-2-RELEASE:1.1.1.1 pgoyette-compat-0728:1.1.1.1 netbsd-8-0-RELEASE:1.1.1.1 phil-wifi:1.1.1.1.0.36 phil-wifi-base:1.1.1.1 pgoyette-compat-0625:1.1.1.1 netbsd-8-0-RC2:1.1.1.1 pgoyette-compat-0521:1.1.1.1 pgoyette-compat-0502:1.1.1.1 pgoyette-compat-0422:1.1.1.1 netbsd-8-0-RC1:1.1.1.1 pgoyette-compat-0415:1.1.1.1 pgoyette-compat-0407:1.1.1.1 pgoyette-compat-0330:1.1.1.1 pgoyette-compat-0322:1.1.1.1 pgoyette-compat-0315:1.1.1.1 netbsd-7-1-2-RELEASE:1.1.1.1 pgoyette-compat:1.1.1.1.0.34 pgoyette-compat-base:1.1.1.1 netbsd-7-1-1-RELEASE:1.1.1.1 matt-nb8-mediatek:1.1.1.1.0.32 matt-nb8-mediatek-base:1.1.1.1 perseant-stdc-iso10646:1.1.1.1.0.30 perseant-stdc-iso10646-base:1.1.1.1 netbsd-8:1.1.1.1.0.28 netbsd-8-base:1.1.1.1 prg-localcount2-base3:1.1.1.1 prg-localcount2-base2:1.1.1.1 prg-localcount2-base1:1.1.1.1 prg-localcount2:1.1.1.1.0.26 prg-localcount2-base:1.1.1.1 pgoyette-localcount-20170426:1.1.1.1 bouyer-socketcan-base1:1.1.1.1 pgoyette-localcount-20170320:1.1.1.1 netbsd-7-1:1.1.1.1.0.24 netbsd-7-1-RELEASE:1.1.1.1 netbsd-7-1-RC2:1.1.1.1 netbsd-7-nhusb-base-20170116:1.1.1.1 bouyer-socketcan:1.1.1.1.0.22 bouyer-socketcan-base:1.1.1.1 pgoyette-localcount-20170107:1.1.1.1 netbsd-7-1-RC1:1.1.1.1 pgoyette-localcount-20161104:1.1.1.1 netbsd-7-0-2-RELEASE:1.1.1.1 localcount-20160914:1.1.1.1 netbsd-7-nhusb:1.1.1.1.0.20 netbsd-7-nhusb-base:1.1.1.1 pgoyette-localcount-20160806:1.1.1.1 pgoyette-localcount-20160726:1.1.1.1 pgoyette-localcount:1.1.1.1.0.18 pgoyette-localcount-base:1.1.1.1 netbsd-7-0-1-RELEASE:1.1.1.1 netbsd-7-0:1.1.1.1.0.16 netbsd-7-0-RELEASE:1.1.1.1 netbsd-7-0-RC3:1.1.1.1 netbsd-7-0-RC2:1.1.1.1 netbsd-7-0-RC1:1.1.1.1 netbsd-7:1.1.1.1.0.14 netbsd-7-base:1.1.1.1 yamt-pagecache:1.1.1.1.0.12 yamt-pagecache-base9:1.1.1.1 tls-earlyentropy:1.1.1.1.0.10 tls-earlyentropy-base:1.1.1.1 riastradh-xf86-video-intel-2-7-1-pre-2-21-15:1.1.1.1 riastradh-drm2-base3:1.1.1.1 kyua-cli-0-7:1.1.1.1 riastradh-drm2-base2:1.1.1.1 riastradh-drm2-base1:1.1.1.1 riastradh-drm2:1.1.1.1.0.2 riastradh-drm2-base:1.1.1.1 khorben-n900:1.1.1.1.0.8 agc-symver:1.1.1.1.0.6 agc-symver-base:1.1.1.1 tls-maxphys-base:1.1.1.1 tls-maxphys:1.1.1.1.0.4 kyua-cli-0-6:1.1.1.1 GOOGLE-CODE:1.1.1; locks; strict; comment @// @; 1.2 date 2020.07.02.14.04.00; author lukem; state Exp; branches; next 1.1; commitid YUoDcZ95aoStLveC; 1.1 date 2013.02.23.12.34.06; author jmmv; state Exp; branches 1.1.1.1; next ; 1.1.1.1 date 2013.02.23.12.34.06; author jmmv; state Exp; branches 1.1.1.1.4.1 1.1.1.1.12.1; next ; 1.1.1.1.4.1 date 2013.02.23.12.34.06; author tls; state dead; branches; next 1.1.1.1.4.2; 1.1.1.1.4.2 date 2013.02.25.00.26.16; author tls; state Exp; branches; next ; 1.1.1.1.12.1 date 2013.02.23.12.34.06; author yamt; state dead; branches; next 1.1.1.1.12.2; commitid h3iiOYJJCkPr7yBx; 1.1.1.1.12.2 date 2014.05.22.15.45.29; author yamt; state Exp; branches; next ; commitid h3iiOYJJCkPr7yBx; desc @@ 1.2 log @kyua-cli: convert auto_ptr to unique_ptr Update kyua-cli to C++11 and use unique_ptr instead of auto_ptr, (with std::move() where appropriate), to avoid deprecated warning by g++ 8. (I didn't change some of the code that could arguably be refactored to use unique_ptr or shared_ptr instead of raw pointers and therefore remove the special case destructor handling). @ text @// Copyright 2010 Google Inc. // All rights reserved. // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are // met: // // * Redistributions of source code must retain the above copyright // notice, this list of conditions and the following disclaimer. // * Redistributions in binary form must reproduce the above copyright // notice, this list of conditions and the following disclaimer in the // documentation and/or other materials provided with the distribution. // * Neither the name of Google Inc. nor the names of its contributors // may be used to endorse or promote products derived from this software // without specific prior written permission. // // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include "utils/format/formatter.hpp" #include #include #include #include "utils/format/exceptions.hpp" #include "utils/sanity.hpp" #include "utils/text/exceptions.hpp" #include "utils/text/operations.ipp" namespace format = utils::format; namespace text = utils::text; namespace { /// Finds the next placeholder in a string. /// /// \param format The original format string provided by the user; needed for /// error reporting purposes only. /// \param expansion The string containing the placeholder to look for. Any /// '%%' in the string will be skipped, and they must be stripped later by /// strip_double_percent(). /// \param begin The position from which to start looking for the next /// placeholder. /// /// \return The position in the string in which the placeholder is located and /// the placeholder itself. If there are no placeholders left, this returns /// the length of the string and an empty string. /// /// \throw bad_format_error If the input string contains a trailing formatting /// character. We cannot detect any other kind of invalid formatter because /// we do not implement a full parser for them. static std::pair< std::string::size_type, std::string > find_next_placeholder(const std::string& format, const std::string& expansion, std::string::size_type begin) { begin = expansion.find('%', begin); while (begin != std::string::npos && expansion[begin + 1] == '%') begin = expansion.find('%', begin + 2); if (begin == std::string::npos) return std::make_pair(expansion.length(), ""); if (begin == expansion.length() - 1) throw format::bad_format_error(format, "Trailing %"); std::string::size_type end = begin + 1; while (end < expansion.length() && expansion[end] != 's') end++; const std::string placeholder = expansion.substr(begin, end - begin + 1); if (end == expansion.length() || placeholder.find('%', 1) != std::string::npos) throw format::bad_format_error(format, "Unterminated placeholder '" + placeholder + "'"); return std::make_pair(begin, placeholder); } /// Converts a string to an integer. /// /// \param format The format string; for error reporting purposes only. /// \param str The string to conver. /// \param what The name of the field this integer belongs to; for error /// reporting purposes only. /// /// \return An integer representing the input string. inline int to_int(const std::string& format, const std::string& str, const char* what) { try { return text::to_type< int >(str); } catch (const text::value_error& e) { throw format::bad_format_error(format, "Invalid " + std::string(what) + "specifier"); } } /// Constructs an std::ostringstream based on a formatting placeholder. /// /// \param format The format placeholder; may be empty. /// /// \return A new std::ostringstream that is prepared to format a single /// object in the manner specified by the format placeholder. /// /// \throw bad_format_error If the format string is bad. We do minimal /// validation on this string though. static std::ostringstream* new_ostringstream(const std::string& format) { std::unique_ptr< std::ostringstream > output(new std::ostringstream()); if (format.length() <= 2) { // If the format is empty, we create a new stream so that we don't have // to check for NULLs later on. We rarely should hit this condition // (and when we do it's a bug in the caller), so this is not a big deal. // // Otherwise, if the format is a regular '%s', then we don't have to do // any processing for additional formatters. So this is just a "fast // path". } else { std::string partial = format.substr(1, format.length() - 2); if (partial[0] == '0') { output->fill('0'); partial.erase(0, 1); } if (!partial.empty()) { const std::string::size_type dot = partial.find('.'); if (dot != 0) output->width(to_int(format, partial.substr(0, dot), "width")); if (dot != std::string::npos) { output->setf(std::ios::fixed, std::ios::floatfield); output->precision(to_int(format, partial.substr(dot + 1), "precision")); } } } return output.release(); } /// Replaces '%%' by '%' in a given string range. /// /// \param in The input string to be rewritten. /// \param begin The position at which to start the replacement. /// \param end The position at which to end the replacement. /// /// \return The modified string and the amount of characters removed. static std::pair< std::string, int > strip_double_percent(const std::string& in, const std::string::size_type begin, std::string::size_type end) { std::string part = in.substr(begin, end - begin); int removed = 0; std::string::size_type pos = part.find("%%"); while (pos != std::string::npos) { part.erase(pos, 1); ++removed; pos = part.find("%%", pos + 1); } return std::make_pair(in.substr(0, begin) + part + in.substr(end), removed); } } // anonymous namespace /// Performs internal initialization of the formatter. /// /// This is separate from the constructor just because it is shared by different /// overloaded constructors. void format::formatter::init(void) { const std::pair< std::string::size_type, std::string > placeholder = find_next_placeholder(_format, _expansion, _last_pos); const std::pair< std::string, int > no_percents = strip_double_percent(_expansion, _last_pos, placeholder.first); _oss = new_ostringstream(placeholder.second); _expansion = no_percents.first; _placeholder_pos = placeholder.first - no_percents.second; _placeholder = placeholder.second; } /// Constructs a new formatter object (internal). /// /// \param format The format string. /// \param expansion The format string with any replacements performed so far. /// \param last_pos The position from which to start looking for formatting /// placeholders. This must be maintained in case one of the replacements /// introduced a new placeholder, which must be ignored. Think, for /// example, replacing a "%s" string with "foo %s". format::formatter::formatter(const std::string& format, const std::string& expansion, const std::string::size_type last_pos) : _format(format), _expansion(expansion), _last_pos(last_pos), _oss(NULL) { init(); } /// Constructs a new formatter object. /// /// \param format The format string. The formatters in the string are not /// validated during construction, but will cause errors when used later if /// they are invalid. format::formatter::formatter(const std::string& format) : _format(format), _expansion(format), _last_pos(0), _oss(NULL) { init(); } format::formatter::~formatter(void) { delete _oss; } /// Returns the formatted string. const std::string& format::formatter::str(void) const { return _expansion; } /// Automatic conversion of formatter objects to strings. /// /// This is provided to allow painless injection of formatter objects into /// streams, without having to manually call the str() method. format::formatter::operator const std::string&(void) const { return _expansion; } /// Specialization of operator% for booleans. /// /// \param value The boolean to inject into the format string. /// /// \return A new formatter that has one less format placeholder. format::formatter format::formatter::operator%(const bool& value) const { (*_oss) << (value ? "true" : "false"); return replace(_oss->str()); } /// Replaces the first formatting placeholder with a value. /// /// \param arg The replacement string. /// /// \return A new formatter in which the first formatting placeholder has been /// replaced by arg and is ready to replace the next item. /// /// \throw utils::format::extra_args_error If there are no more formatting /// placeholders in the input string, or if the placeholder is invalid. format::formatter format::formatter::replace(const std::string& arg) const { if (_placeholder_pos == _expansion.length()) throw format::extra_args_error(_format, arg); const std::string expansion = _expansion.substr(0, _placeholder_pos) + arg + _expansion.substr(_placeholder_pos + _placeholder.length()); return formatter(_format, expansion, _placeholder_pos + arg.length()); } @ 1.1 log @Initial revision @ text @d121 1 a121 1 std::auto_ptr< std::ostringstream > output(new std::ostringstream()); @ 1.1.1.1 log @Initial import of Kyua CLI, version 0.6: This is the main component of Kyua and its build will be guarded by the MKKYUA knob. core@@ has approved this import. Description: Kyua (pronounced Q.A.) is a testing framework for both developers and users. Kyua is different from most other testing frameworks in that it puts the end user experience before anything else. There are multiple reasons for users to run the tests themselves, and Kyua ensures that they can do so in the most convenient way. This module, kyua-cli, provides the command-line interface to the Kyua runtime system. The major purpose of this tool is to run test cases and generate unified reports for their results. @ text @@ 1.1.1.1.12.1 log @file formatter.cpp was added on branch yamt-pagecache on 2014-05-22 15:45:29 +0000 @ text @d1 291 @ 1.1.1.1.12.2 log @sync with head. for a reference, the tree before this commit was tagged as yamt-pagecache-tag8. this commit was splitted into small chunks to avoid a limitation of cvs. ("Protocol error: too many arguments") @ text @a0 291 // Copyright 2010 Google Inc. // All rights reserved. // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are // met: // // * Redistributions of source code must retain the above copyright // notice, this list of conditions and the following disclaimer. // * Redistributions in binary form must reproduce the above copyright // notice, this list of conditions and the following disclaimer in the // documentation and/or other materials provided with the distribution. // * Neither the name of Google Inc. nor the names of its contributors // may be used to endorse or promote products derived from this software // without specific prior written permission. // // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include "utils/format/formatter.hpp" #include #include #include #include "utils/format/exceptions.hpp" #include "utils/sanity.hpp" #include "utils/text/exceptions.hpp" #include "utils/text/operations.ipp" namespace format = utils::format; namespace text = utils::text; namespace { /// Finds the next placeholder in a string. /// /// \param format The original format string provided by the user; needed for /// error reporting purposes only. /// \param expansion The string containing the placeholder to look for. Any /// '%%' in the string will be skipped, and they must be stripped later by /// strip_double_percent(). /// \param begin The position from which to start looking for the next /// placeholder. /// /// \return The position in the string in which the placeholder is located and /// the placeholder itself. If there are no placeholders left, this returns /// the length of the string and an empty string. /// /// \throw bad_format_error If the input string contains a trailing formatting /// character. We cannot detect any other kind of invalid formatter because /// we do not implement a full parser for them. static std::pair< std::string::size_type, std::string > find_next_placeholder(const std::string& format, const std::string& expansion, std::string::size_type begin) { begin = expansion.find('%', begin); while (begin != std::string::npos && expansion[begin + 1] == '%') begin = expansion.find('%', begin + 2); if (begin == std::string::npos) return std::make_pair(expansion.length(), ""); if (begin == expansion.length() - 1) throw format::bad_format_error(format, "Trailing %"); std::string::size_type end = begin + 1; while (end < expansion.length() && expansion[end] != 's') end++; const std::string placeholder = expansion.substr(begin, end - begin + 1); if (end == expansion.length() || placeholder.find('%', 1) != std::string::npos) throw format::bad_format_error(format, "Unterminated placeholder '" + placeholder + "'"); return std::make_pair(begin, placeholder); } /// Converts a string to an integer. /// /// \param format The format string; for error reporting purposes only. /// \param str The string to conver. /// \param what The name of the field this integer belongs to; for error /// reporting purposes only. /// /// \return An integer representing the input string. inline int to_int(const std::string& format, const std::string& str, const char* what) { try { return text::to_type< int >(str); } catch (const text::value_error& e) { throw format::bad_format_error(format, "Invalid " + std::string(what) + "specifier"); } } /// Constructs an std::ostringstream based on a formatting placeholder. /// /// \param format The format placeholder; may be empty. /// /// \return A new std::ostringstream that is prepared to format a single /// object in the manner specified by the format placeholder. /// /// \throw bad_format_error If the format string is bad. We do minimal /// validation on this string though. static std::ostringstream* new_ostringstream(const std::string& format) { std::auto_ptr< std::ostringstream > output(new std::ostringstream()); if (format.length() <= 2) { // If the format is empty, we create a new stream so that we don't have // to check for NULLs later on. We rarely should hit this condition // (and when we do it's a bug in the caller), so this is not a big deal. // // Otherwise, if the format is a regular '%s', then we don't have to do // any processing for additional formatters. So this is just a "fast // path". } else { std::string partial = format.substr(1, format.length() - 2); if (partial[0] == '0') { output->fill('0'); partial.erase(0, 1); } if (!partial.empty()) { const std::string::size_type dot = partial.find('.'); if (dot != 0) output->width(to_int(format, partial.substr(0, dot), "width")); if (dot != std::string::npos) { output->setf(std::ios::fixed, std::ios::floatfield); output->precision(to_int(format, partial.substr(dot + 1), "precision")); } } } return output.release(); } /// Replaces '%%' by '%' in a given string range. /// /// \param in The input string to be rewritten. /// \param begin The position at which to start the replacement. /// \param end The position at which to end the replacement. /// /// \return The modified string and the amount of characters removed. static std::pair< std::string, int > strip_double_percent(const std::string& in, const std::string::size_type begin, std::string::size_type end) { std::string part = in.substr(begin, end - begin); int removed = 0; std::string::size_type pos = part.find("%%"); while (pos != std::string::npos) { part.erase(pos, 1); ++removed; pos = part.find("%%", pos + 1); } return std::make_pair(in.substr(0, begin) + part + in.substr(end), removed); } } // anonymous namespace /// Performs internal initialization of the formatter. /// /// This is separate from the constructor just because it is shared by different /// overloaded constructors. void format::formatter::init(void) { const std::pair< std::string::size_type, std::string > placeholder = find_next_placeholder(_format, _expansion, _last_pos); const std::pair< std::string, int > no_percents = strip_double_percent(_expansion, _last_pos, placeholder.first); _oss = new_ostringstream(placeholder.second); _expansion = no_percents.first; _placeholder_pos = placeholder.first - no_percents.second; _placeholder = placeholder.second; } /// Constructs a new formatter object (internal). /// /// \param format The format string. /// \param expansion The format string with any replacements performed so far. /// \param last_pos The position from which to start looking for formatting /// placeholders. This must be maintained in case one of the replacements /// introduced a new placeholder, which must be ignored. Think, for /// example, replacing a "%s" string with "foo %s". format::formatter::formatter(const std::string& format, const std::string& expansion, const std::string::size_type last_pos) : _format(format), _expansion(expansion), _last_pos(last_pos), _oss(NULL) { init(); } /// Constructs a new formatter object. /// /// \param format The format string. The formatters in the string are not /// validated during construction, but will cause errors when used later if /// they are invalid. format::formatter::formatter(const std::string& format) : _format(format), _expansion(format), _last_pos(0), _oss(NULL) { init(); } format::formatter::~formatter(void) { delete _oss; } /// Returns the formatted string. const std::string& format::formatter::str(void) const { return _expansion; } /// Automatic conversion of formatter objects to strings. /// /// This is provided to allow painless injection of formatter objects into /// streams, without having to manually call the str() method. format::formatter::operator const std::string&(void) const { return _expansion; } /// Specialization of operator% for booleans. /// /// \param value The boolean to inject into the format string. /// /// \return A new formatter that has one less format placeholder. format::formatter format::formatter::operator%(const bool& value) const { (*_oss) << (value ? "true" : "false"); return replace(_oss->str()); } /// Replaces the first formatting placeholder with a value. /// /// \param arg The replacement string. /// /// \return A new formatter in which the first formatting placeholder has been /// replaced by arg and is ready to replace the next item. /// /// \throw utils::format::extra_args_error If there are no more formatting /// placeholders in the input string, or if the placeholder is invalid. format::formatter format::formatter::replace(const std::string& arg) const { if (_placeholder_pos == _expansion.length()) throw format::extra_args_error(_format, arg); const std::string expansion = _expansion.substr(0, _placeholder_pos) + arg + _expansion.substr(_placeholder_pos + _placeholder.length()); return formatter(_format, expansion, _placeholder_pos + arg.length()); } @ 1.1.1.1.4.1 log @file formatter.cpp was added on branch tls-maxphys on 2013-02-25 00:26:16 +0000 @ text @d1 291 @ 1.1.1.1.4.2 log @resync with head @ text @a0 291 // Copyright 2010 Google Inc. // All rights reserved. // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are // met: // // * Redistributions of source code must retain the above copyright // notice, this list of conditions and the following disclaimer. // * Redistributions in binary form must reproduce the above copyright // notice, this list of conditions and the following disclaimer in the // documentation and/or other materials provided with the distribution. // * Neither the name of Google Inc. nor the names of its contributors // may be used to endorse or promote products derived from this software // without specific prior written permission. // // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include "utils/format/formatter.hpp" #include #include #include #include "utils/format/exceptions.hpp" #include "utils/sanity.hpp" #include "utils/text/exceptions.hpp" #include "utils/text/operations.ipp" namespace format = utils::format; namespace text = utils::text; namespace { /// Finds the next placeholder in a string. /// /// \param format The original format string provided by the user; needed for /// error reporting purposes only. /// \param expansion The string containing the placeholder to look for. Any /// '%%' in the string will be skipped, and they must be stripped later by /// strip_double_percent(). /// \param begin The position from which to start looking for the next /// placeholder. /// /// \return The position in the string in which the placeholder is located and /// the placeholder itself. If there are no placeholders left, this returns /// the length of the string and an empty string. /// /// \throw bad_format_error If the input string contains a trailing formatting /// character. We cannot detect any other kind of invalid formatter because /// we do not implement a full parser for them. static std::pair< std::string::size_type, std::string > find_next_placeholder(const std::string& format, const std::string& expansion, std::string::size_type begin) { begin = expansion.find('%', begin); while (begin != std::string::npos && expansion[begin + 1] == '%') begin = expansion.find('%', begin + 2); if (begin == std::string::npos) return std::make_pair(expansion.length(), ""); if (begin == expansion.length() - 1) throw format::bad_format_error(format, "Trailing %"); std::string::size_type end = begin + 1; while (end < expansion.length() && expansion[end] != 's') end++; const std::string placeholder = expansion.substr(begin, end - begin + 1); if (end == expansion.length() || placeholder.find('%', 1) != std::string::npos) throw format::bad_format_error(format, "Unterminated placeholder '" + placeholder + "'"); return std::make_pair(begin, placeholder); } /// Converts a string to an integer. /// /// \param format The format string; for error reporting purposes only. /// \param str The string to conver. /// \param what The name of the field this integer belongs to; for error /// reporting purposes only. /// /// \return An integer representing the input string. inline int to_int(const std::string& format, const std::string& str, const char* what) { try { return text::to_type< int >(str); } catch (const text::value_error& e) { throw format::bad_format_error(format, "Invalid " + std::string(what) + "specifier"); } } /// Constructs an std::ostringstream based on a formatting placeholder. /// /// \param format The format placeholder; may be empty. /// /// \return A new std::ostringstream that is prepared to format a single /// object in the manner specified by the format placeholder. /// /// \throw bad_format_error If the format string is bad. We do minimal /// validation on this string though. static std::ostringstream* new_ostringstream(const std::string& format) { std::auto_ptr< std::ostringstream > output(new std::ostringstream()); if (format.length() <= 2) { // If the format is empty, we create a new stream so that we don't have // to check for NULLs later on. We rarely should hit this condition // (and when we do it's a bug in the caller), so this is not a big deal. // // Otherwise, if the format is a regular '%s', then we don't have to do // any processing for additional formatters. So this is just a "fast // path". } else { std::string partial = format.substr(1, format.length() - 2); if (partial[0] == '0') { output->fill('0'); partial.erase(0, 1); } if (!partial.empty()) { const std::string::size_type dot = partial.find('.'); if (dot != 0) output->width(to_int(format, partial.substr(0, dot), "width")); if (dot != std::string::npos) { output->setf(std::ios::fixed, std::ios::floatfield); output->precision(to_int(format, partial.substr(dot + 1), "precision")); } } } return output.release(); } /// Replaces '%%' by '%' in a given string range. /// /// \param in The input string to be rewritten. /// \param begin The position at which to start the replacement. /// \param end The position at which to end the replacement. /// /// \return The modified string and the amount of characters removed. static std::pair< std::string, int > strip_double_percent(const std::string& in, const std::string::size_type begin, std::string::size_type end) { std::string part = in.substr(begin, end - begin); int removed = 0; std::string::size_type pos = part.find("%%"); while (pos != std::string::npos) { part.erase(pos, 1); ++removed; pos = part.find("%%", pos + 1); } return std::make_pair(in.substr(0, begin) + part + in.substr(end), removed); } } // anonymous namespace /// Performs internal initialization of the formatter. /// /// This is separate from the constructor just because it is shared by different /// overloaded constructors. void format::formatter::init(void) { const std::pair< std::string::size_type, std::string > placeholder = find_next_placeholder(_format, _expansion, _last_pos); const std::pair< std::string, int > no_percents = strip_double_percent(_expansion, _last_pos, placeholder.first); _oss = new_ostringstream(placeholder.second); _expansion = no_percents.first; _placeholder_pos = placeholder.first - no_percents.second; _placeholder = placeholder.second; } /// Constructs a new formatter object (internal). /// /// \param format The format string. /// \param expansion The format string with any replacements performed so far. /// \param last_pos The position from which to start looking for formatting /// placeholders. This must be maintained in case one of the replacements /// introduced a new placeholder, which must be ignored. Think, for /// example, replacing a "%s" string with "foo %s". format::formatter::formatter(const std::string& format, const std::string& expansion, const std::string::size_type last_pos) : _format(format), _expansion(expansion), _last_pos(last_pos), _oss(NULL) { init(); } /// Constructs a new formatter object. /// /// \param format The format string. The formatters in the string are not /// validated during construction, but will cause errors when used later if /// they are invalid. format::formatter::formatter(const std::string& format) : _format(format), _expansion(format), _last_pos(0), _oss(NULL) { init(); } format::formatter::~formatter(void) { delete _oss; } /// Returns the formatted string. const std::string& format::formatter::str(void) const { return _expansion; } /// Automatic conversion of formatter objects to strings. /// /// This is provided to allow painless injection of formatter objects into /// streams, without having to manually call the str() method. format::formatter::operator const std::string&(void) const { return _expansion; } /// Specialization of operator% for booleans. /// /// \param value The boolean to inject into the format string. /// /// \return A new formatter that has one less format placeholder. format::formatter format::formatter::operator%(const bool& value) const { (*_oss) << (value ? "true" : "false"); return replace(_oss->str()); } /// Replaces the first formatting placeholder with a value. /// /// \param arg The replacement string. /// /// \return A new formatter in which the first formatting placeholder has been /// replaced by arg and is ready to replace the next item. /// /// \throw utils::format::extra_args_error If there are no more formatting /// placeholders in the input string, or if the placeholder is invalid. format::formatter format::formatter::replace(const std::string& arg) const { if (_placeholder_pos == _expansion.length()) throw format::extra_args_error(_format, arg); const std::string expansion = _expansion.substr(0, _placeholder_pos) + arg + _expansion.substr(_placeholder_pos + _placeholder.length()); return formatter(_format, expansion, _placeholder_pos + arg.length()); } @