mirror/fmt
1
0
Fork 0
mirror of https://github.com/fmtlib/fmt.git synced 2025-03-15 16:20:59 +00:00
Code Issues Packages Projects Releases Wiki Activity

BasicFormatter -> basic_formatter

Browse Source
This commit is contained in:
Victor Zverovich 2016-10-22 08:04:20 -07:00
parent 18dfa257d0
commit f85d5f4dac
10 changed files with 53 additions and 51 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
fmt/format.cc
View File

@ -362,9 +362,10 @@ FMT_FUNC void internal::format_windows_error(
buffer.resize(INLINE_BUFFER_SIZE);
for (;;) {
wchar_t *system_message = &buffer[0];
int result = FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
0, error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
system_message, static_cast<uint32_t>(buffer.size()), 0);
int result = FormatMessageW(
FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
0, error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
system_message, static_cast<uint32_t>(buffer.size()), 0);
if (result != 0) {
UTF16ToUTF8 utf8_message;
if (utf8_message.convert(system_message) == ERROR_SUCCESS) {

59
fmt/format.h
View File

@ -379,7 +379,7 @@ class BasicPrintfArgFormatter;
template <typename CharType,
typename ArgFormatter = fmt::ArgFormatter<CharType> >
class BasicFormatter;
class basic_formatter;
/**
\rst
@ -1405,7 +1405,7 @@ struct NamedArg : Arg {
template <typename T>
NamedArg(BasicStringRef<Char> argname, const T &value)
: Arg(MakeArg< BasicFormatter<Char> >(value)), name(argname) {}
: Arg(MakeArg< basic_formatter<Char> >(value)), name(argname) {}
};
class RuntimeError : public std::runtime_error {
@ -1526,8 +1526,8 @@ class basic_format_args {
}
};
typedef basic_format_args<BasicFormatter<char>> format_args;
typedef basic_format_args<BasicFormatter<wchar_t>> wformat_args;
typedef basic_format_args<basic_formatter<char>> format_args;
typedef basic_format_args<basic_formatter<wchar_t>> wformat_args;
#define FMT_DISPATCH(call) static_cast<Impl*>(this)->call
@ -2160,7 +2160,7 @@ private:
template <typename Impl, typename Char>
class BasicArgFormatter : public internal::ArgFormatterBase<Impl, Char> {
private:
BasicFormatter<Char, Impl> &formatter_;
basic_formatter<Char, Impl> &formatter_;
const Char *format_;
public:
@ -2172,7 +2172,7 @@ class BasicArgFormatter : public internal::ArgFormatterBase<Impl, Char> {
to the part of the format string being parsed for custom argument types.
\endrst
*/
BasicArgFormatter(BasicFormatter<Char, Impl> &formatter,
BasicArgFormatter(basic_formatter<Char, Impl> &formatter,
FormatSpec &spec, const Char *fmt)
: internal::ArgFormatterBase<Impl, Char>(formatter.writer(), spec),
formatter_(formatter), format_(fmt) {}
@ -2188,15 +2188,15 @@ template <typename Char>
class ArgFormatter : public BasicArgFormatter<ArgFormatter<Char>, Char> {
public:
/** Constructs an argument formatter object. */
ArgFormatter(BasicFormatter<Char> &formatter,
ArgFormatter(basic_formatter<Char> &formatter,
FormatSpec &spec, const Char *fmt)
: BasicArgFormatter<ArgFormatter<Char>, Char>(formatter, spec, fmt) {}
};
/** This template formats data and writes the output to a writer. */
template <typename CharType, typename ArgFormatter>
class BasicFormatter :
private internal::FormatterBase<BasicFormatter<CharType, ArgFormatter>> {
class basic_formatter :
private internal::FormatterBase<basic_formatter<CharType, ArgFormatter>> {
public:
/** The character type for the output. */
typedef CharType Char;
@ -2205,9 +2205,9 @@ class BasicFormatter :
BasicWriter<Char> &writer_;
internal::ArgMap<Char> map_;
FMT_DISALLOW_COPY_AND_ASSIGN(BasicFormatter);
FMT_DISALLOW_COPY_AND_ASSIGN(basic_formatter);
typedef internal::FormatterBase<BasicFormatter> Base;
typedef internal::FormatterBase<basic_formatter> Base;
using Base::get_arg;
// Checks if manual indexing is used and returns the argument with
@ -2223,12 +2223,12 @@ class BasicFormatter :
public:
/**
\rst
Constructs a ``BasicFormatter`` object. References to the arguments and
Constructs a ``basic_formatter`` object. References to the arguments and
the writer are stored in the formatter object so make sure they have
appropriate lifetimes.
\endrst
*/
BasicFormatter(basic_format_args<BasicFormatter> args, BasicWriter<Char> &w)
basic_formatter(basic_format_args<basic_formatter> args, BasicWriter<Char> &w)
: Base(args), writer_(w) {}
/** Returns a reference to the writer associated with this formatter. */
@ -2275,7 +2275,7 @@ class SystemError : public internal::RuntimeError {
*/
template <typename... Args>
SystemError(int error_code, CStringRef message, const Args & ... args) {
init(error_code, message, make_format_args<BasicFormatter<char>>(args...));
init(error_code, message, make_format_args<basic_formatter<char>>(args...));
}
~SystemError() throw();
@ -2470,8 +2470,8 @@ class BasicWriter {
}
void vwrite(BasicCStringRef<Char> format,
basic_format_args<BasicFormatter<Char>> args) {
BasicFormatter<Char>(args, *this).format(format);
basic_format_args<basic_formatter<Char>> args) {
basic_formatter<Char>(args, *this).format(format);
}
/**
@ -2501,7 +2501,7 @@ class BasicWriter {
*/
template <typename... Args>
void write(BasicCStringRef<Char> format, const Args & ... args) {
vwrite(format, make_format_args<fmt::BasicFormatter<Char>>(args...));
vwrite(format, make_format_args<fmt::basic_formatter<Char>>(args...));
}
BasicWriter &operator<<(int value) {
@ -3129,7 +3129,7 @@ class WindowsError : public SystemError {
*/
template <typename... Args>
WindowsError(int error_code, CStringRef message, const Args & ... args) {
init(error_code, message, make_format_args<BasicFormatter<char>>(args...));
init(error_code, message, make_format_args<basic_formatter<char>>(args...));
}
};
@ -3154,7 +3154,7 @@ template <typename... Args>
inline void print_colored(Color c, CStringRef format_str,
const Args & ... args) {
vprint_colored(c, format_str,
make_format_args<BasicFormatter<char>>(args...));
make_format_args<basic_formatter<char>>(args...));
}
inline std::string vformat(CStringRef format_str, format_args args) {
@ -3174,7 +3174,7 @@ inline std::string vformat(CStringRef format_str, format_args args) {
*/
template <typename... Args>
inline std::string format(CStringRef format_str, const Args & ... args) {
return vformat(format_str, make_format_args<BasicFormatter<char>>(args...));
return vformat(format_str, make_format_args<basic_formatter<char>>(args...));
}
inline std::wstring vformat(WCStringRef format_str, wformat_args args) {
@ -3185,7 +3185,7 @@ inline std::wstring vformat(WCStringRef format_str, wformat_args args) {
template <typename... Args>
inline std::wstring format(WCStringRef format_str, const Args & ... args) {
auto vargs = make_format_args<BasicFormatter<wchar_t>>(args...);
auto vargs = make_format_args<basic_formatter<wchar_t>>(args...);
return vformat(format_str, vargs);
}
@ -3202,7 +3202,7 @@ FMT_API void vprint(std::FILE *f, CStringRef format_str, format_args args);
*/
template <typename... Args>
inline void print(std::FILE *f, CStringRef format_str, const Args & ... args) {
vprint(f, format_str, make_format_args<BasicFormatter<char>>(args...));
vprint(f, format_str, make_format_args<basic_formatter<char>>(args...));
}
FMT_API void vprint(CStringRef format_str, format_args args);
@ -3218,7 +3218,7 @@ FMT_API void vprint(CStringRef format_str, format_args args);
*/
template <typename... Args>
inline void print(CStringRef format_str, const Args & ... args) {
vprint(format_str, make_format_args<BasicFormatter<char>>(args...));
vprint(format_str, make_format_args<basic_formatter<char>>(args...));
}
/**
@ -3412,7 +3412,7 @@ void check_sign(const Char *&s, const Arg &arg) {
} // namespace internal
template <typename Char, typename AF>
inline internal::Arg BasicFormatter<Char, AF>::get_arg(
inline internal::Arg basic_formatter<Char, AF>::get_arg(
BasicStringRef<Char> arg_name, const char *&error) {
if (this->check_no_auto_index(error)) {
map_.init(this->args());
@ -3425,10 +3425,11 @@ inline internal::Arg BasicFormatter<Char, AF>::get_arg(
}
template <typename Char, typename AF>
inline internal::Arg BasicFormatter<Char, AF>::parse_arg_index(const Char *&s) {
inline internal::Arg basic_formatter<Char, AF>::parse_arg_index(
const Char *&s) {
const char *error = 0;
internal::Arg arg = *s < '0' || *s > '9' ?
this->next_arg(error) : get_arg(internal::parse_nonnegative_int(s), error);
this->next_arg(error) : get_arg(internal::parse_nonnegative_int(s), error);
if (error) {
FMT_THROW(format_error(
*s != '}' && *s != ':' ? "invalid format string" : error));
@ -3437,7 +3438,7 @@ inline internal::Arg BasicFormatter<Char, AF>::parse_arg_index(const Char *&s) {
}
template <typename Char, typename AF>
inline internal::Arg BasicFormatter<Char, AF>::parse_arg_name(const Char *&s) {
inline internal::Arg basic_formatter<Char, AF>::parse_arg_name(const Char *&s) {
assert(internal::is_name_start(*s));
const Char *start = s;
Char c;
@ -3452,7 +3453,7 @@ inline internal::Arg BasicFormatter<Char, AF>::parse_arg_name(const Char *&s) {
}
template <typename Char, typename ArgFormatter>
const Char *BasicFormatter<Char, ArgFormatter>::format(
const Char *basic_formatter<Char, ArgFormatter>::format(
const Char *&format_str, const internal::Arg &arg) {
using internal::Arg;
const Char *s = format_str;
@ -3622,7 +3623,7 @@ const Char *BasicFormatter<Char, ArgFormatter>::format(
}
template <typename Char, typename AF>
void BasicFormatter<Char, AF>::format(BasicCStringRef<Char> format_str) {
void basic_formatter<Char, AF>::format(BasicCStringRef<Char> format_str) {
const Char *s = format_str.c_str();
const Char *start = s;
while (*s) {

6
fmt/ostream.h
View File

@ -83,11 +83,11 @@ BasicStringRef<Char> format_value(
// Formats a value.
template <typename Char, typename ArgFormatter, typename T>
void format_value(BasicFormatter<Char, ArgFormatter> &f,
void format_value(basic_formatter<Char, ArgFormatter> &f,
const Char *&format_str, const T &value) {
internal::MemoryBuffer<Char, internal::INLINE_BUFFER_SIZE> buffer;
auto str = internal::format_value(buffer, value);
typedef internal::MakeArg< BasicFormatter<Char> > MakeArg;
typedef internal::MakeArg< basic_formatter<Char> > MakeArg;
format_str = f.format(format_str, MakeArg(str));
}
@ -105,7 +105,7 @@ FMT_API void vprint(std::ostream &os, CStringRef format_str, format_args args);
template <typename... Args>
inline void print(std::ostream &os, CStringRef format_str,
const Args & ... args) {
vprint(os, format_str, make_format_args<BasicFormatter<char>>(args...));
vprint(os, format_str, make_format_args<basic_formatter<char>>(args...));
}
} // namespace fmt

2
fmt/posix.h
View File

@ -172,7 +172,7 @@ public:
template <typename... Args>
inline void print(CStringRef format_str, const Args & ... args) {
vprint(format_str, make_format_args<BasicFormatter<char>>(args...));
vprint(format_str, make_format_args<basic_formatter<char>>(args...));
}
};

2
fmt/printf.h
View File

@ -262,7 +262,7 @@ class BasicPrintfArgFormatter : public internal::ArgFormatterBase<Impl, Char> {
/** Formats an argument of a custom (user-defined) type. */
void visit_custom(internal::Arg::CustomValue c) {
BasicFormatter<Char> formatter(basic_format_args<BasicFormatter<Char>>(),
basic_formatter<Char> formatter(basic_format_args<basic_formatter<Char>>(),
this->writer());
const Char format_str[] = {'}', 0};
const Char *format = format_str;

2
fmt/time.h
View File

@ -15,7 +15,7 @@
namespace fmt {
template <typename ArgFormatter>
void format_value(BasicFormatter<char, ArgFormatter> &f,
void format_value(basic_formatter<char, ArgFormatter> &f,
const char *&format_str, const std::tm &tm) {
if (*format_str == ':')
++format_str;

6
test/custom-formatter-test.cc
View File

@ -17,7 +17,7 @@ using fmt::BasicPrintfArgFormatter;
class CustomArgFormatter
: public fmt::BasicArgFormatter<CustomArgFormatter, char> {
public:
CustomArgFormatter(fmt::BasicFormatter<char, CustomArgFormatter> &f,
CustomArgFormatter(fmt::basic_formatter<char, CustomArgFormatter> &f,
fmt::FormatSpec &s, const char *fmt)
: fmt::BasicArgFormatter<CustomArgFormatter, char>(f, s, fmt) {}
@ -45,12 +45,12 @@ class CustomPrintfArgFormatter :
}
};
typedef fmt::BasicFormatter<char, CustomArgFormatter> CustomFormatter;
typedef fmt::basic_formatter<char, CustomArgFormatter> CustomFormatter;
std::string custom_vformat(const char *format_str,
fmt::basic_format_args<CustomFormatter> args) {
fmt::MemoryWriter writer;
// Pass custom argument formatter as a template arg to BasicFormatter.
// Pass custom argument formatter as a template arg to basic_formatter.
CustomFormatter formatter(args, writer);
formatter.format(format_str);
return writer.str();

10
test/format-test.cc
View File

@ -1355,7 +1355,7 @@ TEST(FormatterTest, FormatCStringRef) {
EXPECT_EQ("test", format("{0}", CStringRef("test")));
}
void format_value(fmt::BasicFormatter<char> &f, const char *, const Date &d) {
void format_value(fmt::basic_formatter<char> &f, const char *, const Date &d) {
f.writer() << d.year() << '-' << d.month() << '-' << d.day();
}
@ -1368,7 +1368,7 @@ TEST(FormatterTest, FormatCustom) {
class Answer {};
template <typename Char>
void format_value(fmt::BasicFormatter<Char> &f, const Char *, Answer) {
void format_value(fmt::basic_formatter<Char> &f, const Char *, Answer) {
f.writer() << "42";
}
@ -1559,7 +1559,7 @@ std::string vformat_message(int id, const char *format, fmt::format_args args) {
template <typename... Args>
std::string format_message(int id, const char *format, const Args & ... args) {
auto va = fmt::make_format_args<fmt::BasicFormatter<char>>(args...);
auto va = fmt::make_format_args<fmt::basic_formatter<char>>(args...);
return vformat_message(id, format, va);
}
@ -1624,7 +1624,7 @@ class MockArgFormatter :
public:
typedef fmt::internal::ArgFormatterBase<MockArgFormatter, char> Base;
MockArgFormatter(fmt::BasicFormatter<char, MockArgFormatter> &f,
MockArgFormatter(fmt::basic_formatter<char, MockArgFormatter> &f,
fmt::FormatSpec &s, const char *)
: fmt::internal::ArgFormatterBase<MockArgFormatter, char>(f.writer(), s) {
EXPECT_CALL(*this, visit_int(42));
@ -1633,7 +1633,7 @@ class MockArgFormatter :
MOCK_METHOD1(visit_int, void (int value));
};
typedef fmt::BasicFormatter<char, MockArgFormatter> CustomFormatter;
typedef fmt::basic_formatter<char, MockArgFormatter> CustomFormatter;
void custom_vformat(const char *format_str,
fmt::basic_format_args<CustomFormatter> args) {

4
test/ostream-test.cc
View File

@ -59,14 +59,14 @@ TEST(OStreamTest, Enum) {
}
struct TestArgFormatter : fmt::BasicArgFormatter<TestArgFormatter, char> {
TestArgFormatter(fmt::BasicFormatter<char, TestArgFormatter> &f,
TestArgFormatter(fmt::basic_formatter<char, TestArgFormatter> &f,
fmt::FormatSpec &s, const char *fmt)
: fmt::BasicArgFormatter<TestArgFormatter, char>(f, s, fmt) {}
};
TEST(OStreamTest, CustomArg) {
fmt::MemoryWriter writer;
typedef fmt::BasicFormatter<char, TestArgFormatter> Formatter;
typedef fmt::basic_formatter<char, TestArgFormatter> Formatter;
Formatter formatter(fmt::basic_format_args<Formatter>(), writer);
fmt::FormatSpec spec;
TestArgFormatter af(formatter, spec, "}");

6
test/util-test.cc
View File

@ -64,13 +64,13 @@ namespace {
struct Test {};
template <typename Char>
void format_value(fmt::BasicFormatter<Char> &f, const Char *, Test) {
void format_value(fmt::basic_formatter<Char> &f, const Char *, Test) {
f.writer() << "test";
}
template <typename Char, typename T>
Arg make_arg(const T &value) {
typedef fmt::internal::MakeValue< fmt::BasicFormatter<Char> > MakeValue;
typedef fmt::internal::MakeValue< fmt::basic_formatter<Char> > MakeValue;
Arg arg = MakeValue(value);
arg.type = fmt::internal::type<T>();
return arg;
@ -566,7 +566,7 @@ TEST(ArgTest, MakeArg) {
EXPECT_EQ(fmt::internal::Arg::CUSTOM, arg.type);
EXPECT_EQ(&t, arg.custom.value);
fmt::MemoryWriter w;
fmt::BasicFormatter<char> formatter(fmt::format_args(), w);
fmt::basic_formatter<char> formatter(fmt::format_args(), w);
const char *s = "}";
arg.custom.format(&formatter, &t, &s);
EXPECT_EQ("test", w.str());