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

BasicWriter -> basic_writer

Browse Source
This commit is contained in:
Victor Zverovich 2016-12-30 12:11:27 -08:00
parent 939aff2936
commit 8428621ddc
11 changed files with 101 additions and 103 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
fmt/format.cc
View File

@ -106,7 +106,7 @@ inline int fmt_snprintf(char *buffer, size_t size, const char *format, ...) {
const char RESET_COLOR[] = "\x1b[0m"; const char RESET_COLOR[] = "\x1b[0m";
typedef void (*FormatFunc)(Writer &, int, StringRef); typedef void (*FormatFunc)(writer &, int, StringRef);
// Portable thread-safe version of strerror. // Portable thread-safe version of strerror.
// Sets buffer to point to a string describing the error code. // Sets buffer to point to a string describing the error code.
@ -176,7 +176,7 @@ int safe_strerror(
return StrError(error_code, buffer, buffer_size).run(); return StrError(error_code, buffer, buffer_size).run();
} }
void format_error_code(Writer &out, int error_code, void format_error_code(writer &out, int error_code,
StringRef message) FMT_NOEXCEPT { StringRef message) FMT_NOEXCEPT {
// Report error code making sure that the output fits into // Report error code making sure that the output fits into
// INLINE_BUFFER_SIZE to avoid dynamic memory allocation and potential // INLINE_BUFFER_SIZE to avoid dynamic memory allocation and potential
@ -215,7 +215,7 @@ namespace internal {
// This method is used to preserve binary compatibility with fmt 3.0. // This method is used to preserve binary compatibility with fmt 3.0.
// It can be removed in 4.0. // It can be removed in 4.0.
FMT_FUNC void format_system_error( FMT_FUNC void format_system_error(
Writer &out, int error_code, StringRef message) FMT_NOEXCEPT { writer &out, int error_code, StringRef message) FMT_NOEXCEPT {
fmt::format_system_error(out, error_code, message); fmt::format_system_error(out, error_code, message);
} }
} // namespace internal } // namespace internal
@ -354,7 +354,7 @@ FMT_FUNC void WindowsError::init(
} }
FMT_FUNC void internal::format_windows_error( FMT_FUNC void internal::format_windows_error(
Writer &out, int error_code, StringRef message) FMT_NOEXCEPT { writer &out, int error_code, StringRef message) FMT_NOEXCEPT {
FMT_TRY { FMT_TRY {
MemoryBuffer<wchar_t, INLINE_BUFFER_SIZE> buffer; MemoryBuffer<wchar_t, INLINE_BUFFER_SIZE> buffer;
buffer.resize(INLINE_BUFFER_SIZE); buffer.resize(INLINE_BUFFER_SIZE);
@ -383,7 +383,7 @@ FMT_FUNC void internal::format_windows_error(
#endif // FMT_USE_WINDOWS_H #endif // FMT_USE_WINDOWS_H
FMT_FUNC void format_system_error( FMT_FUNC void format_system_error(
Writer &out, int error_code, StringRef message) FMT_NOEXCEPT { writer &out, int error_code, StringRef message) FMT_NOEXCEPT {
FMT_TRY { FMT_TRY {
internal::MemoryBuffer<char, internal::INLINE_BUFFER_SIZE> buffer; internal::MemoryBuffer<char, internal::INLINE_BUFFER_SIZE> buffer;
buffer.resize(internal::INLINE_BUFFER_SIZE); buffer.resize(internal::INLINE_BUFFER_SIZE);
@ -440,7 +440,7 @@ FMT_FUNC void vprint_colored(Color c, CStringRef format, format_args args) {
} }
template <typename Char> template <typename Char>
void printf(BasicWriter<Char> &w, BasicCStringRef<Char> format, void printf(basic_writer<Char> &w, BasicCStringRef<Char> format,
format_args args); format_args args);
FMT_FUNC int vfprintf(std::FILE *f, CStringRef format, printf_args args) { FMT_FUNC int vfprintf(std::FILE *f, CStringRef format, printf_args args) {
@ -460,7 +460,7 @@ template void internal::FixedBuffer<char>::grow(std::size_t);
template void internal::ArgMap<format_context>::init(const format_args &args); template void internal::ArgMap<format_context>::init(const format_args &args);
template void printf_context<char>::format(Writer &writer); template void printf_context<char>::format(writer &writer);
template int internal::CharTraits<char>::format_float( template int internal::CharTraits<char>::format_float(
char *buffer, std::size_t size, const char *format, char *buffer, std::size_t size, const char *format,
@ -478,7 +478,7 @@ template void internal::FixedBuffer<wchar_t>::grow(std::size_t);
template void internal::ArgMap<wformat_context>::init(const wformat_args &args); template void internal::ArgMap<wformat_context>::init(const wformat_args &args);
template void printf_context<wchar_t>::format(WWriter &writer); template void printf_context<wchar_t>::format(wwriter &writer);
template int internal::CharTraits<wchar_t>::format_float( template int internal::CharTraits<wchar_t>::format_float(
wchar_t *buffer, std::size_t size, const wchar_t *format, wchar_t *buffer, std::size_t size, const wchar_t *format,

128
fmt/format.h
View File

@ -365,10 +365,10 @@ using std::move;
#endif #endif
template <typename Char> template <typename Char>
class BasicWriter; class basic_writer;
typedef BasicWriter<char> Writer; typedef basic_writer<char> writer;
typedef BasicWriter<wchar_t> WWriter; typedef basic_writer<wchar_t> wwriter;
template <typename Context> template <typename Context>
class basic_format_arg; class basic_format_arg;
@ -987,7 +987,7 @@ class UTF16ToUTF8 {
FMT_API int convert(WStringRef s); FMT_API int convert(WStringRef s);
}; };
FMT_API void format_windows_error(fmt::Writer &out, int error_code, FMT_API void format_windows_error(fmt::writer &out, int error_code,
fmt::StringRef message) FMT_NOEXCEPT; fmt::StringRef message) FMT_NOEXCEPT;
#endif #endif
@ -1076,7 +1076,7 @@ enum Type {
}; };
template <typename Char> template <typename Char>
struct StringValue { struct string_value {
const Char *value; const Char *value;
std::size_t size; std::size_t size;
}; };
@ -1084,7 +1084,7 @@ struct StringValue {
template <typename Char> template <typename Char>
struct CustomValue { struct CustomValue {
typedef void (*FormatFunc)( typedef void (*FormatFunc)(
BasicWriter<Char> &writer, const void *arg, void *ctx); basic_writer<Char> &writer, const void *arg, void *ctx);
const void *value; const void *value;
FormatFunc format; FormatFunc format;
@ -1161,10 +1161,10 @@ class value {
double double_value; double double_value;
long double long_double_value; long double long_double_value;
const void *pointer; const void *pointer;
StringValue<char> string; string_value<char> string;
StringValue<signed char> sstring; string_value<signed char> sstring;
StringValue<unsigned char> ustring; string_value<unsigned char> ustring;
StringValue<typename Context::char_type> tstring; string_value<typename Context::char_type> tstring;
CustomValue<typename Context::char_type> custom; CustomValue<typename Context::char_type> custom;
}; };
@ -1206,7 +1206,7 @@ class value {
// Formats an argument of a custom type, such as a user-defined class. // Formats an argument of a custom type, such as a user-defined class.
template <typename T> template <typename T>
static void format_custom_arg( static void format_custom_arg(
BasicWriter<Char> &writer, const void *arg, void *context) { basic_writer<Char> &writer, const void *arg, void *context) {
format_value(writer, *static_cast<const T*>(arg), format_value(writer, *static_cast<const T*>(arg),
*static_cast<Context*>(context)); *static_cast<Context*>(context));
} }
@ -1466,7 +1466,7 @@ inline fmt::StringRef thousands_sep(...) { return ""; }
#endif #endif
template <typename Formatter, typename T, typename Char> template <typename Formatter, typename T, typename Char>
void format_value(BasicWriter<Char> &, const T &, Formatter &, const Char *) { void format_value(basic_writer<Char> &, const T &, Formatter &, const Char *) {
FMT_STATIC_ASSERT(False<T>::value, FMT_STATIC_ASSERT(False<T>::value,
"Cannot format argument. To enable the use of ostream " "Cannot format argument. To enable the use of ostream "
"operator<< include fmt/ostream.h. Otherwise provide " "operator<< include fmt/ostream.h. Otherwise provide "
@ -1925,7 +1925,7 @@ void ArgMap<Context>::init(const basic_format_args<Context> &args) {
template <typename Char> template <typename Char>
class ArgFormatterBase { class ArgFormatterBase {
private: private:
BasicWriter<Char> &writer_; basic_writer<Char> &writer_;
FormatSpec &spec_; FormatSpec &spec_;
FMT_DISALLOW_COPY_AND_ASSIGN(ArgFormatterBase); FMT_DISALLOW_COPY_AND_ASSIGN(ArgFormatterBase);
@ -1953,7 +1953,7 @@ class ArgFormatterBase {
} }
protected: protected:
BasicWriter<Char> &writer() { return writer_; } basic_writer<Char> &writer() { return writer_; }
FormatSpec &spec() { return spec_; } FormatSpec &spec() { return spec_; }
void write(bool value) { void write(bool value) {
@ -1968,7 +1968,7 @@ class ArgFormatterBase {
public: public:
typedef Char char_type; typedef Char char_type;
ArgFormatterBase(BasicWriter<Char> &w, FormatSpec &s) ArgFormatterBase(basic_writer<Char> &w, FormatSpec &s)
: writer_(w), spec_(s) {} : writer_(w), spec_(s) {}
void operator()(monostate) { void operator()(monostate) {
@ -1997,7 +1997,7 @@ class ArgFormatterBase {
} }
if (spec_.align_ == ALIGN_NUMERIC || spec_.flags_ != 0) if (spec_.align_ == ALIGN_NUMERIC || spec_.flags_ != 0)
FMT_THROW(format_error("invalid format specifier for char")); FMT_THROW(format_error("invalid format specifier for char"));
typedef typename BasicWriter<Char>::CharPtr CharPtr; typedef typename basic_writer<Char>::CharPtr CharPtr;
Char fill = internal::CharTraits<Char>::cast(spec_.fill()); Char fill = internal::CharTraits<Char>::cast(spec_.fill());
CharPtr out = CharPtr(); CharPtr out = CharPtr();
const unsigned CHAR_WIDTH = 1; const unsigned CHAR_WIDTH = 1;
@ -2041,7 +2041,7 @@ class ArgFormatterBase {
}; };
template <typename Char> template <typename Char>
inline void write(BasicWriter<Char> &w, const Char *start, const Char *end) { inline void write(basic_writer<Char> &w, const Char *start, const Char *end) {
if (start != end) if (start != end)
w << BasicStringRef<Char>(start, internal::to_unsigned(end - start)); w << BasicStringRef<Char>(start, internal::to_unsigned(end - start));
} }
@ -2115,7 +2115,7 @@ class ArgFormatter : public internal::ArgFormatterBase<Char> {
format specifier information for standard argument types. format specifier information for standard argument types.
\endrst \endrst
*/ */
ArgFormatter(BasicWriter<Char> &writer, basic_format_context<Char> &ctx, ArgFormatter(basic_writer<Char> &writer, basic_format_context<Char> &ctx,
FormatSpec &spec) FormatSpec &spec)
: internal::ArgFormatterBase<Char>(writer, spec), ctx_(ctx) {} : internal::ArgFormatterBase<Char>(writer, spec), ctx_(ctx) {}
@ -2223,7 +2223,7 @@ class SystemError : public internal::RuntimeError {
may look like "Unknown error -1" and is platform-dependent. may look like "Unknown error -1" and is platform-dependent.
\endrst \endrst
*/ */
FMT_API void format_system_error(fmt::Writer &out, int error_code, FMT_API void format_system_error(fmt::writer &out, int error_code,
fmt::StringRef message) FMT_NOEXCEPT; fmt::StringRef message) FMT_NOEXCEPT;
/** /**
@ -2234,23 +2234,23 @@ FMT_API void format_system_error(fmt::Writer &out, int error_code,
You can use one of the following typedefs for common character types: You can use one of the following typedefs for common character types:
+---------+----------------------+ +---------+-----------------------+
| Type | Definition | | Type | Definition |
+=========+======================+ +=========+=======================+
| Writer | BasicWriter<char> | | writer | basic_writer<char> |
+---------+----------------------+ +---------+-----------------------+
| WWriter | BasicWriter<wchar_t> | | wwriter | basic_writer<wchar_t> |
+---------+----------------------+ +---------+-----------------------+
\endrst \endrst
*/ */
template <typename Char> template <typename Char>
class BasicWriter { class basic_writer {
private: private:
// Output buffer. // Output buffer.
Buffer<Char> &buffer_; Buffer<Char> &buffer_;
FMT_DISALLOW_COPY_AND_ASSIGN(BasicWriter); FMT_DISALLOW_COPY_AND_ASSIGN(basic_writer);
typedef typename internal::CharTraits<Char>::CharPtr CharPtr; typedef typename internal::CharTraits<Char>::CharPtr CharPtr;
@ -2349,17 +2349,17 @@ class BasicWriter {
protected: protected:
/** /**
Constructs a ``BasicWriter`` object. Constructs a ``basic_writer`` object.
*/ */
explicit BasicWriter(Buffer<Char> &b) : buffer_(b) {} explicit basic_writer(Buffer<Char> &b) : buffer_(b) {}
public: public:
/** /**
\rst \rst
Destroys a ``BasicWriter`` object. Destroys a ``basic_writer`` object.
\endrst \endrst
*/ */
virtual ~BasicWriter() {} virtual ~basic_writer() {}
/** /**
Returns the total number of characters written. Returns the total number of characters written.
@ -2424,21 +2424,21 @@ class BasicWriter {
vwrite(format, make_xformat_args<basic_format_context<Char>>(args...)); vwrite(format, make_xformat_args<basic_format_context<Char>>(args...));
} }
BasicWriter &operator<<(int value) { basic_writer &operator<<(int value) {
write_decimal(value); write_decimal(value);
return *this; return *this;
} }
BasicWriter &operator<<(unsigned value) { basic_writer &operator<<(unsigned value) {
return *this << IntFormatSpec<unsigned>(value); return *this << IntFormatSpec<unsigned>(value);
} }
BasicWriter &operator<<(long value) { basic_writer &operator<<(long value) {
write_decimal(value); write_decimal(value);
return *this; return *this;
} }
BasicWriter &operator<<(unsigned long value) { basic_writer &operator<<(unsigned long value) {
return *this << IntFormatSpec<unsigned long>(value); return *this << IntFormatSpec<unsigned long>(value);
} }
BasicWriter &operator<<(LongLong value) { basic_writer &operator<<(LongLong value) {
write_decimal(value); write_decimal(value);
return *this; return *this;
} }
@ -2448,11 +2448,11 @@ class BasicWriter {
Formats *value* and writes it to the stream. Formats *value* and writes it to the stream.
\endrst \endrst
*/ */
BasicWriter &operator<<(ULongLong value) { basic_writer &operator<<(ULongLong value) {
return *this << IntFormatSpec<ULongLong>(value); return *this << IntFormatSpec<ULongLong>(value);
} }
BasicWriter &operator<<(double value) { basic_writer &operator<<(double value) {
write_double(value, FormatSpec()); write_double(value, FormatSpec());
return *this; return *this;
} }
@ -2463,7 +2463,7 @@ class BasicWriter {
(``'g'``) and writes it to the stream. (``'g'``) and writes it to the stream.
\endrst \endrst
*/ */
BasicWriter &operator<<(long double value) { basic_writer &operator<<(long double value) {
write_double(value, FormatSpec()); write_double(value, FormatSpec());
return *this; return *this;
} }
@ -2471,12 +2471,12 @@ class BasicWriter {
/** /**
Writes a character to the stream. Writes a character to the stream.
*/ */
BasicWriter &operator<<(char value) { basic_writer &operator<<(char value) {
buffer_.push_back(value); buffer_.push_back(value);
return *this; return *this;
} }
BasicWriter &operator<<( basic_writer &operator<<(
typename internal::WCharHelper<wchar_t, Char>::Supported value) { typename internal::WCharHelper<wchar_t, Char>::Supported value) {
buffer_.push_back(value); buffer_.push_back(value);
return *this; return *this;
@ -2487,13 +2487,13 @@ class BasicWriter {
Writes *value* to the stream. Writes *value* to the stream.
\endrst \endrst
*/ */
BasicWriter &operator<<(fmt::BasicStringRef<Char> value) { basic_writer &operator<<(fmt::BasicStringRef<Char> value) {
const Char *str = value.data(); const Char *str = value.data();
buffer_.append(str, str + value.size()); buffer_.append(str, str + value.size());
return *this; return *this;
} }
BasicWriter &operator<<( basic_writer &operator<<(
typename internal::WCharHelper<StringRef, Char>::Supported value) { typename internal::WCharHelper<StringRef, Char>::Supported value) {
const char *str = value.data(); const char *str = value.data();
buffer_.append(str, str + value.size()); buffer_.append(str, str + value.size());
@ -2501,14 +2501,14 @@ class BasicWriter {
} }
template <typename T, typename Spec, typename FillChar> template <typename T, typename Spec, typename FillChar>
BasicWriter &operator<<(IntFormatSpec<T, Spec, FillChar> spec) { basic_writer &operator<<(IntFormatSpec<T, Spec, FillChar> spec) {
internal::CharTraits<Char>::convert(FillChar()); internal::CharTraits<Char>::convert(FillChar());
write_int(spec.value(), spec); write_int(spec.value(), spec);
return *this; return *this;
} }
template <typename StrChar> template <typename StrChar>
BasicWriter &operator<<(const StrFormatSpec<StrChar> &spec) { basic_writer &operator<<(const StrFormatSpec<StrChar> &spec) {
const StrChar *s = spec.str(); const StrChar *s = spec.str();
write_str(s, std::char_traits<Char>::length(s), spec); write_str(s, std::char_traits<Char>::length(s), spec);
return *this; return *this;
@ -2521,7 +2521,7 @@ class BasicWriter {
template <typename Char> template <typename Char>
template <typename StrChar> template <typename StrChar>
typename BasicWriter<Char>::CharPtr BasicWriter<Char>::write_str( typename basic_writer<Char>::CharPtr basic_writer<Char>::write_str(
const StrChar *s, std::size_t size, const AlignSpec &spec) { const StrChar *s, std::size_t size, const AlignSpec &spec) {
CharPtr out = CharPtr(); CharPtr out = CharPtr();
if (spec.width() > size) { if (spec.width() > size) {
@ -2544,7 +2544,7 @@ typename BasicWriter<Char>::CharPtr BasicWriter<Char>::write_str(
template <typename Char> template <typename Char>
template <typename StrChar> template <typename StrChar>
void BasicWriter<Char>::write_str( void basic_writer<Char>::write_str(
BasicStringRef<StrChar> s, const FormatSpec &spec) { BasicStringRef<StrChar> s, const FormatSpec &spec) {
// Check if StrChar is convertible to Char. // Check if StrChar is convertible to Char.
internal::CharTraits<Char>::convert(StrChar()); internal::CharTraits<Char>::convert(StrChar());
@ -2564,8 +2564,7 @@ void BasicWriter<Char>::write_str(
} }
template <typename Char> template <typename Char>
typename BasicWriter<Char>::CharPtr typename basic_writer<Char>::CharPtr basic_writer<Char>::fill_padding(
BasicWriter<Char>::fill_padding(
CharPtr buffer, unsigned total_size, CharPtr buffer, unsigned total_size,
std::size_t content_size, wchar_t fill) { std::size_t content_size, wchar_t fill) {
std::size_t padding = total_size - content_size; std::size_t padding = total_size - content_size;
@ -2581,8 +2580,7 @@ typename BasicWriter<Char>::CharPtr
template <typename Char> template <typename Char>
template <typename Spec> template <typename Spec>
typename BasicWriter<Char>::CharPtr typename basic_writer<Char>::CharPtr basic_writer<Char>::prepare_int_buffer(
BasicWriter<Char>::prepare_int_buffer(
unsigned num_digits, const Spec &spec, unsigned num_digits, const Spec &spec,
const char *prefix, unsigned prefix_size) { const char *prefix, unsigned prefix_size) {
unsigned width = spec.width(); unsigned width = spec.width();
@ -2645,7 +2643,7 @@ typename BasicWriter<Char>::CharPtr
template <typename Char> template <typename Char>
template <typename T, typename Spec> template <typename T, typename Spec>
void BasicWriter<Char>::write_int(T value, Spec spec) { void basic_writer<Char>::write_int(T value, Spec spec) {
unsigned prefix_size = 0; unsigned prefix_size = 0;
typedef typename internal::IntTraits<T>::MainType UnsignedType; typedef typename internal::IntTraits<T>::MainType UnsignedType;
UnsignedType abs_value = static_cast<UnsignedType>(value); UnsignedType abs_value = static_cast<UnsignedType>(value);
@ -2735,7 +2733,7 @@ void BasicWriter<Char>::write_int(T value, Spec spec) {
template <typename Char> template <typename Char>
template <typename T> template <typename T>
void BasicWriter<Char>::write_double(T value, const FormatSpec &spec) { void basic_writer<Char>::write_double(T value, const FormatSpec &spec) {
// Check type. // Check type.
char type = spec.type(); char type = spec.type();
bool upper = false; bool upper = false;
@ -2923,13 +2921,13 @@ void BasicWriter<Char>::write_double(T value, const FormatSpec &spec) {
\endrst \endrst
*/ */
template <typename Char, typename Allocator = std::allocator<Char> > template <typename Char, typename Allocator = std::allocator<Char> >
class BasicMemoryWriter : public BasicWriter<Char> { class BasicMemoryWriter : public basic_writer<Char> {
private: private:
internal::MemoryBuffer<Char, internal::INLINE_BUFFER_SIZE, Allocator> buffer_; internal::MemoryBuffer<Char, internal::INLINE_BUFFER_SIZE, Allocator> buffer_;
public: public:
explicit BasicMemoryWriter(const Allocator& alloc = Allocator()) explicit BasicMemoryWriter(const Allocator& alloc = Allocator())
: BasicWriter<Char>(buffer_), buffer_(alloc) {} : basic_writer<Char>(buffer_), buffer_(alloc) {}
#if FMT_USE_RVALUE_REFERENCES #if FMT_USE_RVALUE_REFERENCES
/** /**
@ -2939,7 +2937,7 @@ class BasicMemoryWriter : public BasicWriter<Char> {
\endrst \endrst
*/ */
BasicMemoryWriter(BasicMemoryWriter &&other) BasicMemoryWriter(BasicMemoryWriter &&other)
: BasicWriter<Char>(buffer_), buffer_(std::move(other.buffer_)) { : basic_writer<Char>(buffer_), buffer_(std::move(other.buffer_)) {
} }
/** /**
@ -2978,7 +2976,7 @@ typedef BasicMemoryWriter<wchar_t> WMemoryWriter;
\endrst \endrst
*/ */
template <typename Char> template <typename Char>
class BasicArrayWriter : public BasicWriter<Char> { class BasicArrayWriter : public basic_writer<Char> {
private: private:
internal::FixedBuffer<Char> buffer_; internal::FixedBuffer<Char> buffer_;
@ -2990,7 +2988,7 @@ class BasicArrayWriter : public BasicWriter<Char> {
\endrst \endrst
*/ */
BasicArrayWriter(Char *array, std::size_t size) BasicArrayWriter(Char *array, std::size_t size)
: BasicWriter<Char>(buffer_), buffer_(array, size) {} : basic_writer<Char>(buffer_), buffer_(array, size) {}
/** /**
\rst \rst
@ -3000,7 +2998,7 @@ class BasicArrayWriter : public BasicWriter<Char> {
*/ */
template <std::size_t SIZE> template <std::size_t SIZE>
explicit BasicArrayWriter(Char (&array)[SIZE]) explicit BasicArrayWriter(Char (&array)[SIZE])
: BasicWriter<Char>(buffer_), buffer_(array, SIZE) {} : basic_writer<Char>(buffer_), buffer_(array, SIZE) {}
}; };
typedef BasicArrayWriter<char> ArrayWriter; typedef BasicArrayWriter<char> ArrayWriter;
@ -3349,11 +3347,11 @@ void check_sign(const Char *&s, const basic_format_arg<Context> &arg) {
template <typename Char, typename Context> template <typename Char, typename Context>
class CustomFormatter { class CustomFormatter {
private: private:
BasicWriter<Char> &writer_; basic_writer<Char> &writer_;
Context &ctx_; Context &ctx_;
public: public:
CustomFormatter(BasicWriter<Char> &writer, Context &ctx) CustomFormatter(basic_writer<Char> &writer, Context &ctx)
: writer_(writer), ctx_(ctx) {} : writer_(writer), ctx_(ctx) {}
bool operator()(internal::CustomValue<Char> custom) { bool operator()(internal::CustomValue<Char> custom) {
@ -3450,7 +3448,7 @@ inline typename basic_format_context<Char>::format_arg
// Formats a single argument. // Formats a single argument.
template <typename ArgFormatter, typename Char, typename Context> template <typename ArgFormatter, typename Char, typename Context>
void do_format_arg(BasicWriter<Char> &writer, basic_format_arg<Context> arg, void do_format_arg(basic_writer<Char> &writer, basic_format_arg<Context> arg,
Context &ctx) { Context &ctx) {
const Char *&s = ctx.ptr(); const Char *&s = ctx.ptr();
FormatSpec spec; FormatSpec spec;
@ -3576,7 +3574,7 @@ void do_format_arg(BasicWriter<Char> &writer, basic_format_arg<Context> arg,
/** Formats arguments and writes the output to the writer. */ /** Formats arguments and writes the output to the writer. */
template <typename ArgFormatter, typename Char, typename Context> template <typename ArgFormatter, typename Char, typename Context>
void vformat(BasicWriter<Char> &writer, BasicCStringRef<Char> format_str, void vformat(basic_writer<Char> &writer, BasicCStringRef<Char> format_str,
basic_format_args<Context> args) { basic_format_args<Context> args) {
basic_format_context<Char> ctx(format_str.c_str(), args); basic_format_context<Char> ctx(format_str.c_str(), args);
const Char *&s = ctx.ptr(); const Char *&s = ctx.ptr();
@ -3601,7 +3599,7 @@ void vformat(BasicWriter<Char> &writer, BasicCStringRef<Char> format_str,
} }
template <typename Char> template <typename Char>
inline void BasicWriter<Char>::vwrite( inline void basic_writer<Char>::vwrite(
BasicCStringRef<Char> format, BasicCStringRef<Char> format,
basic_format_args<basic_format_context<Char>> args) { basic_format_args<basic_format_context<Char>> args) {
vformat<ArgFormatter<Char>>(*this, format, args); vformat<ArgFormatter<Char>>(*this, format, args);

2
fmt/ostream.cc
View File

@ -12,7 +12,7 @@
namespace fmt { namespace fmt {
namespace internal { namespace internal {
FMT_FUNC void write(std::ostream &os, Writer &w) { FMT_FUNC void write(std::ostream &os, writer &w) {
const char *data = w.data(); const char *data = w.data();
typedef internal::MakeUnsigned<std::streamsize>::Type UnsignedStreamSize; typedef internal::MakeUnsigned<std::streamsize>::Type UnsignedStreamSize;
UnsignedStreamSize size = w.size(); UnsignedStreamSize size = w.size();

4
fmt/ostream.h
View File

@ -68,7 +68,7 @@ struct ConvertToIntImpl<T, true> {
}; };
// Write the content of w to os. // Write the content of w to os.
void write(std::ostream &os, Writer &w); void write(std::ostream &os, writer &w);
template <typename Char, typename T> template <typename Char, typename T>
BasicStringRef<Char> format_value( BasicStringRef<Char> format_value(
@ -83,7 +83,7 @@ BasicStringRef<Char> format_value(
// Formats a value. // Formats a value.
template <typename Char, typename T> template <typename Char, typename T>
void format_value(BasicWriter<Char> &w, const T &value, void format_value(basic_writer<Char> &w, const T &value,
basic_format_context<Char> &ctx) { basic_format_context<Char> &ctx) {
internal::MemoryBuffer<Char, internal::INLINE_BUFFER_SIZE> buffer; internal::MemoryBuffer<Char, internal::INLINE_BUFFER_SIZE> buffer;
auto str = internal::format_value(buffer, value); auto str = internal::format_value(buffer, value);

14
fmt/printf.h
View File

@ -224,7 +224,7 @@ class PrintfArgFormatter : public internal::ArgFormatterBase<Char> {
specifier information for standard argument types. specifier information for standard argument types.
\endrst \endrst
*/ */
PrintfArgFormatter(BasicWriter<Char> &writer, FormatSpec &spec) PrintfArgFormatter(basic_writer<Char> &writer, FormatSpec &spec)
: internal::ArgFormatterBase<Char>(writer, spec) {} : internal::ArgFormatterBase<Char>(writer, spec) {}
using Base::operator(); using Base::operator();
@ -241,10 +241,10 @@ class PrintfArgFormatter : public internal::ArgFormatterBase<Char> {
/** Formats a character. */ /** Formats a character. */
void operator()(Char value) { void operator()(Char value) {
const FormatSpec &fmt_spec = this->spec(); const FormatSpec &fmt_spec = this->spec();
BasicWriter<Char> &w = this->writer(); basic_writer<Char> &w = this->writer();
if (fmt_spec.type_ && fmt_spec.type_ != 'c') if (fmt_spec.type_ && fmt_spec.type_ != 'c')
w.write_int(value, fmt_spec); w.write_int(value, fmt_spec);
typedef typename BasicWriter<Char>::CharPtr CharPtr; typedef typename basic_writer<Char>::CharPtr CharPtr;
CharPtr out = CharPtr(); CharPtr out = CharPtr();
if (fmt_spec.width_ > 1) { if (fmt_spec.width_ > 1) {
Char fill = ' '; Char fill = ' ';
@ -326,7 +326,7 @@ class printf_context :
: Base(format_str.c_str(), args) {} : Base(format_str.c_str(), args) {}
/** Formats stored arguments and writes the output to the writer. */ /** Formats stored arguments and writes the output to the writer. */
FMT_API void format(BasicWriter<Char> &writer); FMT_API void format(basic_writer<Char> &writer);
}; };
template <typename Char, typename AF> template <typename Char, typename AF>
@ -402,7 +402,7 @@ unsigned printf_context<Char, AF>::parse_header(
} }
template <typename Char, typename AF> template <typename Char, typename AF>
void printf_context<Char, AF>::format(BasicWriter<Char> &writer) { void printf_context<Char, AF>::format(basic_writer<Char> &writer) {
const Char *start = this->ptr(); const Char *start = this->ptr();
const Char *s = start; const Char *s = start;
while (*s) { while (*s) {
@ -502,14 +502,14 @@ void printf_context<Char, AF>::format(BasicWriter<Char> &writer) {
// Formats a value. // Formats a value.
template <typename Char, typename T> template <typename Char, typename T>
void format_value(BasicWriter<Char> &w, const T &value, void format_value(basic_writer<Char> &w, const T &value,
printf_context<Char>& ctx) { printf_context<Char>& ctx) {
internal::MemoryBuffer<Char, internal::INLINE_BUFFER_SIZE> buffer; internal::MemoryBuffer<Char, internal::INLINE_BUFFER_SIZE> buffer;
w << internal::format_value(buffer, value); w << internal::format_value(buffer, value);
} }
template <typename Char> template <typename Char>
void printf(BasicWriter<Char> &w, BasicCStringRef<Char> format, void printf(basic_writer<Char> &w, BasicCStringRef<Char> format,
basic_format_args<printf_context<Char>> args) { basic_format_args<printf_context<Char>> args) {
printf_context<Char>(format, args).format(w); printf_context<Char>(format, args).format(w);
} }

4
fmt/string.h
View File

@ -72,7 +72,7 @@ class StringBuffer : public Buffer<Char> {
\endrst \endrst
*/ */
template <typename Char> template <typename Char>
class BasicStringWriter : public BasicWriter<Char> { class BasicStringWriter : public basic_writer<Char> {
private: private:
internal::StringBuffer<Char> buffer_; internal::StringBuffer<Char> buffer_;
@ -82,7 +82,7 @@ class BasicStringWriter : public BasicWriter<Char> {
Constructs a :class:`fmt::BasicStringWriter` object. Constructs a :class:`fmt::BasicStringWriter` object.
\endrst \endrst
*/ */
BasicStringWriter() : BasicWriter<Char>(buffer_) {} BasicStringWriter() : basic_writer<Char>(buffer_) {}
/** /**
\rst \rst

2
fmt/time.h
View File

@ -15,7 +15,7 @@
namespace fmt { namespace fmt {
void format_value(Writer &w, const std::tm &tm, format_context &ctx) { void format_value(writer &w, const std::tm &tm, format_context &ctx) {
const char *&s = ctx.ptr(); const char *&s = ctx.ptr();
if (*s == ':') if (*s == ':')
++s; ++s;

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

@ -16,7 +16,7 @@ using fmt::PrintfArgFormatter;
// rounded to 0. // rounded to 0.
class CustomArgFormatter : public fmt::ArgFormatter<char> { class CustomArgFormatter : public fmt::ArgFormatter<char> {
public: public:
CustomArgFormatter(fmt::Writer &w, fmt::basic_format_context<char> &ctx, CustomArgFormatter(fmt::writer &w, fmt::basic_format_context<char> &ctx,
fmt::FormatSpec &s) fmt::FormatSpec &s)
: fmt::ArgFormatter<char>(w, ctx, s) {} : fmt::ArgFormatter<char>(w, ctx, s) {}
@ -33,7 +33,7 @@ class CustomArgFormatter : public fmt::ArgFormatter<char> {
// rounded to 0. // rounded to 0.
class CustomPrintfArgFormatter : public PrintfArgFormatter<char> { class CustomPrintfArgFormatter : public PrintfArgFormatter<char> {
public: public:
CustomPrintfArgFormatter(fmt::BasicWriter<char> &w, fmt::FormatSpec &spec) CustomPrintfArgFormatter(fmt::basic_writer<char> &w, fmt::FormatSpec &spec)
: PrintfArgFormatter<char>(w, spec) {} : PrintfArgFormatter<char>(w, spec) {}
using PrintfArgFormatter<char>::operator(); using PrintfArgFormatter<char>::operator();

18
test/format-test.cc
View File

@ -70,7 +70,7 @@ lconv *localeconv() {
using std::size_t; using std::size_t;
using fmt::BasicWriter; using fmt::basic_writer;
using fmt::format; using fmt::format;
using fmt::format_error; using fmt::format_error;
using fmt::StringRef; using fmt::StringRef;
@ -165,11 +165,11 @@ TEST(CStringRefTest, Ctor) {
#if FMT_USE_TYPE_TRAITS #if FMT_USE_TYPE_TRAITS
TEST(WriterTest, NotCopyConstructible) { TEST(WriterTest, NotCopyConstructible) {
EXPECT_FALSE(std::is_copy_constructible<BasicWriter<char> >::value); EXPECT_FALSE(std::is_copy_constructible<basic_writer<char> >::value);
} }
TEST(WriterTest, NotCopyAssignable) { TEST(WriterTest, NotCopyAssignable) {
EXPECT_FALSE(std::is_copy_assignable<BasicWriter<char> >::value); EXPECT_FALSE(std::is_copy_assignable<basic_writer<char> >::value);
} }
#endif #endif
@ -399,7 +399,7 @@ TEST(WriterTest, hexu) {
} }
template <typename Char> template <typename Char>
BasicWriter<Char> &operator<<(BasicWriter<Char> &f, const Date &d) { basic_writer<Char> &operator<<(basic_writer<Char> &f, const Date &d) {
return f << d.year() << '-' << d.month() << '-' << d.day(); return f << d.year() << '-' << d.month() << '-' << d.day();
} }
@ -410,8 +410,8 @@ public:
ISO8601DateFormatter(const Date &d) : date_(&d) {} ISO8601DateFormatter(const Date &d) : date_(&d) {}
template <typename Char> template <typename Char>
friend BasicWriter<Char> &operator<<( friend basic_writer<Char> &operator<<(
BasicWriter<Char> &w, const ISO8601DateFormatter &d) { basic_writer<Char> &w, const ISO8601DateFormatter &d) {
return w << pad(d.date_->year(), 4, '0') << '-' return w << pad(d.date_->year(), 4, '0') << '-'
<< pad(d.date_->month(), 2, '0') << '-' << pad(d.date_->day(), 2, '0'); << pad(d.date_->month(), 2, '0') << '-' << pad(d.date_->day(), 2, '0');
} }
@ -1355,7 +1355,7 @@ TEST(FormatterTest, FormatCStringRef) {
EXPECT_EQ("test", format("{0}", CStringRef("test"))); EXPECT_EQ("test", format("{0}", CStringRef("test")));
} }
void format_value(fmt::Writer &w, const Date &d, fmt::format_context &) { void format_value(fmt::writer &w, const Date &d, fmt::format_context &) {
w << d.year() << '-' << d.month() << '-' << d.day(); w << d.year() << '-' << d.month() << '-' << d.day();
} }
@ -1368,7 +1368,7 @@ TEST(FormatterTest, FormatCustom) {
class Answer {}; class Answer {};
template <typename Char> template <typename Char>
void format_value(BasicWriter<Char> &w, Answer, fmt::format_context &) { void format_value(basic_writer<Char> &w, Answer, fmt::format_context &) {
w << "42"; w << "42";
} }
@ -1627,7 +1627,7 @@ class MockArgFormatter : public fmt::internal::ArgFormatterBase<char> {
public: public:
typedef fmt::internal::ArgFormatterBase<char> Base; typedef fmt::internal::ArgFormatterBase<char> Base;
MockArgFormatter(fmt::Writer &w, fmt::format_context &ctx, MockArgFormatter(fmt::writer &w, fmt::format_context &ctx,
fmt::FormatSpec &s) fmt::FormatSpec &s)
: fmt::internal::ArgFormatterBase<char>(w, s) { : fmt::internal::ArgFormatterBase<char>(w, s) {
EXPECT_CALL(*this, call(42)); EXPECT_CALL(*this, call(42));

6
test/ostream-test.cc
View File

@ -59,7 +59,7 @@ TEST(OStreamTest, Enum) {
} }
struct TestArgFormatter : fmt::ArgFormatter<char> { struct TestArgFormatter : fmt::ArgFormatter<char> {
TestArgFormatter(fmt::Writer &w, fmt::format_context &ctx, TestArgFormatter(fmt::writer &w, fmt::format_context &ctx,
fmt::FormatSpec &s) fmt::FormatSpec &s)
: fmt::ArgFormatter<char>(w, ctx, s) {} : fmt::ArgFormatter<char>(w, ctx, s) {}
}; };
@ -134,7 +134,7 @@ TEST(OStreamTest, WriteToOStreamMaxSize) {
if (max_size <= fmt::internal::to_unsigned(max_streamsize)) if (max_size <= fmt::internal::to_unsigned(max_streamsize))
return; return;
class TestWriter : public fmt::BasicWriter<char> { class TestWriter : public fmt::basic_writer<char> {
private: private:
struct TestBuffer : fmt::Buffer<char> { struct TestBuffer : fmt::Buffer<char> {
explicit TestBuffer(std::size_t size) { size_ = size; } explicit TestBuffer(std::size_t size) { size_ = size; }
@ -142,7 +142,7 @@ TEST(OStreamTest, WriteToOStreamMaxSize) {
} buffer_; } buffer_;
public: public:
explicit TestWriter(std::size_t size) explicit TestWriter(std::size_t size)
: fmt::BasicWriter<char>(buffer_), buffer_(size) {} : fmt::basic_writer<char>(buffer_), buffer_(size) {}
} w(max_size); } w(max_size);
struct MockStreamBuf : std::streambuf { struct MockStreamBuf : std::streambuf {

6
test/util-test.cc
View File

@ -68,7 +68,7 @@ namespace {
struct Test {}; struct Test {};
template <typename Char> template <typename Char>
void format_value(fmt::BasicWriter<Char> &w, Test, void format_value(fmt::basic_writer<Char> &w, Test,
fmt::basic_format_context<Char> &) { fmt::basic_format_context<Char> &) {
w << "test"; w << "test";
} }
@ -417,7 +417,7 @@ struct CustomContext {
bool called; bool called;
}; };
void format_value(fmt::Writer &, const Test &, CustomContext &ctx) { void format_value(fmt::writer &, const Test &, CustomContext &ctx) {
ctx.called = true; ctx.called = true;
} }
@ -690,7 +690,7 @@ TEST(UtilTest, UTF16ToUTF8Convert) {
#endif // _WIN32 #endif // _WIN32
typedef void (*FormatErrorMessage)( typedef void (*FormatErrorMessage)(
fmt::Writer &out, int error_code, StringRef message); fmt::writer &out, int error_code, StringRef message);
template <typename Error> template <typename Error>
void check_throw_error(int error_code, FormatErrorMessage format) { void check_throw_error(int error_code, FormatErrorMessage format) {