fmt::BasicWriter< Char > Class Template Reference

#include <format.h>

Public Member Functions
virtual	~BasicWriter ()
std::size_t	size () const
const Char *	data () const FMT_NOEXCEPT
const Char *	c_str () const
std::basic_string< Char >	str () const
void	write (BasicCStringRef< Char > format, ArgList args)
BasicWriter &	operator<< (int value)
BasicWriter &	operator<< (unsigned value)
BasicWriter &	operator<< (long value)
BasicWriter &	operator<< (unsigned long value)
BasicWriter &	operator<< (LongLong value)
BasicWriter &	operator<< (ULongLong value)
BasicWriter &	operator<< (double value)
BasicWriter &	operator<< (long double value)
BasicWriter &	operator<< (char value)
BasicWriter &	operator<< (typename internal::WCharHelper< wchar_t, Char >::Supported value)
BasicWriter &	operator<< (fmt::BasicStringRef< Char > value)
BasicWriter &	operator<< (typename internal::WCharHelper< StringRef, Char >::Supported value)
template<typename T , typename Spec , typename FillChar >
BasicWriter &	operator<< (IntFormatSpec< T, Spec, FillChar > spec)
template<typename StrChar >
BasicWriter &	operator<< (const StrFormatSpec< StrChar > &spec)
void	clear () FMT_NOEXCEPT

Protected Member Functions
	BasicWriter (Buffer< Char > &b)

Private Types
typedef internal::CharTraits < Char >::CharPtr	CharPtr

Private Member Functions
	FMT_DISALLOW_COPY_AND_ASSIGN (BasicWriter)
CharPtr	grow_buffer (std::size_t n)
template<typename UInt >
Char *	write_unsigned_decimal (UInt value, unsigned prefix_size=0)
template<typename Int >
void	write_decimal (Int value)
CharPtr	prepare_int_buffer (unsigned num_digits, const EmptySpec &, const char *prefix, unsigned prefix_size)
template<typename Spec >
CharPtr	prepare_int_buffer (unsigned num_digits, const Spec &spec, const char *prefix, unsigned prefix_size)
template<typename T , typename Spec >
void	write_int (T value, Spec spec)
template<typename T >
void	write_double (T value, const FormatSpec &spec)
template<typename StrChar >
CharPtr	write_str (const StrChar *s, std::size_t size, const AlignSpec &spec)
template<typename StrChar >
void	write_str (const internal::Arg::StringValue< StrChar > &str, const FormatSpec &spec)
void	operator<< (typename internal::WCharHelper< wchar_t, Char >::Unsupported)
void	operator<< (typename internal::WCharHelper< const wchar_t *, Char >::Unsupported)
void	append_float_length (Char *&format_ptr, long double)
template<typename T >
void	append_float_length (Char *&, T)

Static Private Member Functions
static Char *	get (Char *p)
static CharPtr	fill_padding (CharPtr buffer, unsigned total_size, std::size_t content_size, wchar_t fill)

Private Attributes
Buffer< Char > &	buffer_

Friends
template<typename Impl , typename Char_ >
class	internal::ArgFormatterBase
class	internal::PrintfArgFormatter< Char >

Detailed Description

template<typename Char>
class fmt::BasicWriter< Char >

This template provides operations for formatting and writing data into a character stream. The output is stored in a buffer provided by a subclass such as :class:fmt::BasicMemoryWriter.

You can use one of the following typedefs for common character types:

+------—+-------------------—+ | Type | Definition | +=========+======================+ | Writer | BasicWriter<char> | +------—+-------------------—+ | WWriter | BasicWriter<wchar_t> | +------—+-------------------—+

Member Typedef Documentation

template<typename Char>

typedef internal::CharTraits<Char>::CharPtr fmt::BasicWriter< Char >::CharPtr

private

Constructor & Destructor Documentation

template<typename Char>

fmt::BasicWriter< Char >::BasicWriter ( Buffer< Char > &  b )

inlineexplicitprotected

Constructs a BasicWriter object.

: buffer_(b) {}

template<typename Char>

virtual fmt::BasicWriter< Char >::~BasicWriter ( )

inlinevirtual

Destroys a BasicWriter object.

{}

Member Function Documentation

template<typename Char>

void fmt::BasicWriter< Char >::append_float_length ( Char *&  format_ptr, long  double  )

inlineprivate

 {
 *format_ptr++ = 'L';
 }

template<typename Char>

template<typename T >

void fmt::BasicWriter< Char >::append_float_length ( Char *&  , T    )

inlineprivate

{}

template<typename Char>

const Char* fmt::BasicWriter< Char >::c_str ( ) const

inline

Returns a pointer to the output buffer content with terminating null character appended.

 {
 std::size_t size = buffer_.size();
 buffer_.reserve(size + 1);
 buffer_[size] = '\0';
 return &buffer_[0];
 }

Here is the call graph for this function:

template<typename Char>

void fmt::BasicWriter< Char >::clear ( )

inline

{ buffer_.clear(); }

Here is the call graph for this function:

template<typename Char>

const Char* fmt::BasicWriter< Char >::data ( ) const

inline

Returns a pointer to the output buffer content. No terminating null character is appended.

{ return &buffer_[0]; }

template<typename Char >

BasicWriter< Char >::CharPtr fmt::BasicWriter< Char >::fill_padding ( CharPtr  buffer, unsigned  total_size, std::size_t  content_size, wchar_t  fill  )

staticprivate

 {
 std::size_t padding = total_size - content_size;
 std::size_t left_padding = padding / 2;
 Char fill_char = internal::CharTraits<Char>::cast(fill);
 std::uninitialized_fill_n(buffer, left_padding, fill_char);
 buffer += left_padding;
 CharPtr content = buffer;
 std::uninitialized_fill_n(buffer + content_size,
 padding - left_padding, fill_char);
 return content;
}

Here is the caller graph for this function:

template<typename Char>

fmt::BasicWriter< Char >::FMT_DISALLOW_COPY_AND_ASSIGN ( BasicWriter< Char >  )

private

template<typename Char>

static Char* fmt::BasicWriter< Char >::get ( Char *  p )

inlinestaticprivate

{ return p; }

template<typename Char>

CharPtr fmt::BasicWriter< Char >::grow_buffer ( std::size_t  n )

inlineprivate

 {
 std::size_t size = buffer_.size();
 buffer_.resize(size + n);
 return internal::make_ptr(&buffer_[size], n);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename Char>

void fmt::BasicWriter< Char >::operator<< ( typename internal::WCharHelper< wchar_t, Char >::Unsupported  )

private

template<typename Char>

void fmt::BasicWriter< Char >::operator<< ( typename internal::WCharHelper< const wchar_t *, Char >::Unsupported  )

private

template<typename Char>

BasicWriter& fmt::BasicWriter< Char >::operator<< ( int  value )

inline

 {
 write_decimal(value);
 return *this;
 }

template<typename Char>

BasicWriter& fmt::BasicWriter< Char >::operator<< ( unsigned  value )

inline

 {
 return *this << IntFormatSpec<unsigned>(value);
 }

template<typename Char>

BasicWriter& fmt::BasicWriter< Char >::operator<< ( long  value )

inline

 {
 write_decimal(value);
 return *this;
 }

template<typename Char>

BasicWriter& fmt::BasicWriter< Char >::operator<< ( unsigned long  value )

inline

 {
 return *this << IntFormatSpec<unsigned long>(value);
 }

template<typename Char>

BasicWriter& fmt::BasicWriter< Char >::operator<< ( LongLong  value )

inline

 {
 write_decimal(value);
 return *this;
 }

template<typename Char>

BasicWriter& fmt::BasicWriter< Char >::operator<< ( ULongLong  value )

inline

Formats value and writes it to the stream.

 {
 return *this << IntFormatSpec<ULongLong>(value);
 }

template<typename Char>

BasicWriter& fmt::BasicWriter< Char >::operator<< ( double  value )

inline

 {
 write_double(value, FormatSpec());
 return *this;
 }

template<typename Char>

BasicWriter& fmt::BasicWriter< Char >::operator<< ( long double  value )

inline

Formats value using the general format for floating-point numbers ('g') and writes it to the stream.

 {
 write_double(value, FormatSpec());
 return *this;
 }

template<typename Char>

BasicWriter& fmt::BasicWriter< Char >::operator<< ( char  value )

inline

Writes a character to the stream.

 {
 buffer_.push_back(value);
 return *this;
 }

Here is the call graph for this function:

template<typename Char>

BasicWriter& fmt::BasicWriter< Char >::operator<< ( typename internal::WCharHelper< wchar_t, Char >::Supported  value )

inline

 {
 buffer_.push_back(value);
 return *this;
 }

Here is the call graph for this function:

template<typename Char>

BasicWriter& fmt::BasicWriter< Char >::operator<< ( fmt::BasicStringRef< Char >  value )

inline

Writes value to the stream.

 {
 const Char *str = value.data();
 buffer_.append(str, str + value.size());
 return *this;
 }

Here is the call graph for this function:

template<typename Char>

BasicWriter& fmt::BasicWriter< Char >::operator<< ( typename internal::WCharHelper< StringRef, Char >::Supported  value )

inline

 {
 const char *str = value.data();
 buffer_.append(str, str + value.size());
 return *this;
 }

Here is the call graph for this function:

template<typename Char>

template<typename T , typename Spec , typename FillChar >

BasicWriter& fmt::BasicWriter< Char >::operator<< ( IntFormatSpec< T, Spec, FillChar >  spec )

inline

 {
 internal::CharTraits<Char>::convert(FillChar());
 write_int(spec.value(), spec);
 return *this;
 }

Here is the call graph for this function:

template<typename Char>

template<typename StrChar >

BasicWriter& fmt::BasicWriter< Char >::operator<< ( const StrFormatSpec< StrChar > &  spec )

inline

 {
 const StrChar *s = spec.str();
 write_str(s, std::char_traits<Char>::length(s), spec);
 return *this;
 }

Here is the call graph for this function:

template<typename Char>

CharPtr fmt::BasicWriter< Char >::prepare_int_buffer ( unsigned  num_digits, const EmptySpec &  , const char *  prefix, unsigned  prefix_size  )

inlineprivate

 {
 unsigned size = prefix_size + num_digits;
 CharPtr p = grow_buffer(size);
 std::uninitialized_copy(prefix, prefix + prefix_size, p);
 return p + size - 1;
 }

template<typename Char >

template<typename Spec >

BasicWriter< Char >::CharPtr fmt::BasicWriter< Char >::prepare_int_buffer ( unsigned  num_digits, const Spec &  spec, const char *  prefix, unsigned  prefix_size  )

private

 {
 unsigned width = spec.width();
 Alignment align = spec.align();
 Char fill = internal::CharTraits<Char>::cast(spec.fill());
 if (spec.precision() > static_cast<int>(num_digits)) {
 // Octal prefix '0' is counted as a digit, so ignore it if precision
 // is specified.
 if (prefix_size > 0 && prefix[prefix_size - 1] == '0')
 --prefix_size;
 unsigned number_size =
 prefix_size + internal::to_unsigned(spec.precision());
 AlignSpec subspec(number_size, '0', ALIGN_NUMERIC);
 if (number_size >= width)
 return prepare_int_buffer(num_digits, subspec, prefix, prefix_size);
 buffer_.reserve(width);
 unsigned fill_size = width - number_size;
 if (align != ALIGN_LEFT) {
 CharPtr p = grow_buffer(fill_size);
 std::uninitialized_fill(p, p + fill_size, fill);
 }
 CharPtr result = prepare_int_buffer(
 num_digits, subspec, prefix, prefix_size);
 if (align == ALIGN_LEFT) {
 CharPtr p = grow_buffer(fill_size);
 std::uninitialized_fill(p, p + fill_size, fill);
 }
 return result;
 }
 unsigned size = prefix_size + num_digits;
 if (width <= size) {
 CharPtr p = grow_buffer(size);
 std::uninitialized_copy(prefix, prefix + prefix_size, p);
 return p + size - 1;
 }
 CharPtr p = grow_buffer(width);
 CharPtr end = p + width;
 if (align == ALIGN_LEFT) {
 std::uninitialized_copy(prefix, prefix + prefix_size, p);
 p += size;
 std::uninitialized_fill(p, end, fill);
 } else if (align == ALIGN_CENTER) {
 p = fill_padding(p, width, size, fill);
 std::uninitialized_copy(prefix, prefix + prefix_size, p);
 p += size;
 } else {
 if (align == ALIGN_NUMERIC) {
 if (prefix_size != 0) {
 p = std::uninitialized_copy(prefix, prefix + prefix_size, p);
 size -= prefix_size;
 }
 } else {
 std::uninitialized_copy(prefix, prefix + prefix_size, end - size);
 }
 std::uninitialized_fill(p, end - size, fill);
 p = end;
 }
 return p - 1;
}

Here is the call graph for this function:

template<typename Char>

std::size_t fmt::BasicWriter< Char >::size ( ) const

inline

Returns the total number of characters written.

{ return buffer_.size(); }

Here is the call graph for this function:

template<typename Char>

std::basic_string<Char> fmt::BasicWriter< Char >::str ( ) const

inline

Returns the content of the output buffer as an std::string.

 {
 return std::basic_string<Char>(&buffer_[0], buffer_.size());
 }

Here is the caller graph for this function:

template<typename Char>

void fmt::BasicWriter< Char >::write ( BasicCStringRef< Char >  format, ArgList  args  )

inline

Writes formatted data.

args* is an argument list representing arbitrary arguments.

Example**::

MemoryWriter out; out.write("Current point:\n"); out.write("({:+f}, {:+f})", -3.14, 3.14);

This will write the following output to the out object:

.. code-block:: none

Current point: (-3.140000, +3.140000)

The output can be accessed using :func:data(), :func:c_str or :func:str methods.

See also :ref:syntax.

 {
 BasicFormatter<Char>(args, *this).format(format);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename Char>

template<typename Int >

void fmt::BasicWriter< Char >::write_decimal ( Int  value )

inlineprivate

 {
 typedef typename internal::IntTraits<Int>::MainType MainType;
 MainType abs_value = static_cast<MainType>(value);
 if (internal::is_negative(value)) {
 abs_value = 0 - abs_value;
 *write_unsigned_decimal(abs_value, 1) = '-';
 } else {
 write_unsigned_decimal(abs_value, 0);
 }
 }

Here is the call graph for this function:

template<typename Char >

template<typename T >

void fmt::BasicWriter< Char >::write_double ( T  value, const FormatSpec &  spec  )

private

 {
 // Check type.
 char type = spec.type();
 bool upper = false;
 switch (type) {
 case 0:
 type = 'g';
 break;
 case 'e': case 'f': case 'g': case 'a':
 break;
 case 'F':
#ifdef _MSC_VER
 // MSVC's printf doesn't support 'F'.
 type = 'f';
#endif
 // Fall through.
 case 'E': case 'G': case 'A':
 upper = true;
 break;
 default:
 internal::report_unknown_type(type, "double");
 break;
 }

 char sign = 0;
 // Use isnegative instead of value < 0 because the latter is always
 // false for NaN.
 if (internal::FPUtil::isnegative(static_cast<double>(value))) {
 sign = '-';
 value = -value;
 } else if (spec.flag(SIGN_FLAG)) {
 sign = spec.flag(PLUS_FLAG) ? '+' : ' ';
 }

 if (internal::FPUtil::isnotanumber(value)) {
 // Format NaN ourselves because sprintf's output is not consistent
 // across platforms.
 std::size_t nan_size = 4;
 const char *nan = upper ? " NAN" : " nan";
 if (!sign) {
 --nan_size;
 ++nan;
 }
 CharPtr out = write_str(nan, nan_size, spec);
 if (sign)
 *out = sign;
 return;
 }

 if (internal::FPUtil::isinfinity(value)) {
 // Format infinity ourselves because sprintf's output is not consistent
 // across platforms.
 std::size_t inf_size = 4;
 const char *inf = upper ? " INF" : " inf";
 if (!sign) {
 --inf_size;
 ++inf;
 }
 CharPtr out = write_str(inf, inf_size, spec);
 if (sign)
 *out = sign;
 return;
 }

 std::size_t offset = buffer_.size();
 unsigned width = spec.width();
 if (sign) {
 buffer_.reserve(buffer_.size() + (width > 1u ? width : 1u));
 if (width > 0)
 --width;
 ++offset;
 }

 // Build format string.
 enum { MAX_FORMAT_SIZE = 10}; // longest format: %#-*.*Lg
 Char format[MAX_FORMAT_SIZE];
 Char *format_ptr = format;
 *format_ptr++ = '%';
 unsigned width_for_sprintf = width;
 if (spec.flag(HASH_FLAG))
 *format_ptr++ = '#';
 if (spec.align() == ALIGN_CENTER) {
 width_for_sprintf = 0;
 } else {
 if (spec.align() == ALIGN_LEFT)
 *format_ptr++ = '-';
 if (width != 0)
 *format_ptr++ = '*';
 }
 if (spec.precision() >= 0) {
 *format_ptr++ = '.';
 *format_ptr++ = '*';
 }

 append_float_length(format_ptr, value);
 *format_ptr++ = type;
 *format_ptr = '\0';

 // Format using snprintf.
 Char fill = internal::CharTraits<Char>::cast(spec.fill());
 unsigned n = 0;
 Char *start = 0;
 for (;;) {
 std::size_t buffer_size = buffer_.capacity() - offset;
#ifdef _MSC_VER
 // MSVC's vsnprintf_s doesn't work with zero size, so reserve
 // space for at least one extra character to make the size non-zero.
 // Note that the buffer's capacity will increase by more than 1.
 if (buffer_size == 0) {
 buffer_.reserve(offset + 1);
 buffer_size = buffer_.capacity() - offset;
 }
#endif
 start = &buffer_[offset];
 int result = internal::CharTraits<Char>::format_float(
 start, buffer_size, format, width_for_sprintf, spec.precision(), value);
 if (result >= 0) {
 n = internal::to_unsigned(result);
 if (offset + n < buffer_.capacity())
 break; // The buffer is large enough - continue with formatting.
 buffer_.reserve(offset + n + 1);
 } else {
 // If result is negative we ask to increase the capacity by at least 1,
 // but as std::vector, the buffer grows exponentially.
 buffer_.reserve(buffer_.capacity() + 1);
 }
 }
 if (sign) {
 if ((spec.align() != ALIGN_RIGHT && spec.align() != ALIGN_DEFAULT) ||
 *start != ' ') {
 *(start - 1) = sign;
 sign = 0;
 } else {
 *(start - 1) = fill;
 }
 ++n;
 }
 if (spec.align() == ALIGN_CENTER && spec.width() > n) {
 width = spec.width();
 CharPtr p = grow_buffer(width);
 std::memmove(get(p) + (width - n) / 2, get(p), n * sizeof(Char));
 fill_padding(p, spec.width(), n, fill);
 return;
 }
 if (spec.fill() != ' ' || sign) {
 while (*start == ' ')
 *start++ = fill;
 if (sign)
 *(start - 1) = sign;
 }
 grow_buffer(n);
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename Char >

template<typename T , typename Spec >

void fmt::BasicWriter< Char >::write_int ( T  value, Spec  spec  )

private

 {
 unsigned prefix_size = 0;
 typedef typename internal::IntTraits<T>::MainType UnsignedType;
 UnsignedType abs_value = static_cast<UnsignedType>(value);
 char prefix[4] = "";
 if (internal::is_negative(value)) {
 prefix[0] = '-';
 ++prefix_size;
 abs_value = 0 - abs_value;
 } else if (spec.flag(SIGN_FLAG)) {
 prefix[0] = spec.flag(PLUS_FLAG) ? '+' : ' ';
 ++prefix_size;
 }
 switch (spec.type()) {
 case 0: case 'd': {
 unsigned num_digits = internal::count_digits(abs_value);
 CharPtr p = prepare_int_buffer(
 num_digits, spec, prefix, prefix_size) + 1 - num_digits;
 internal::format_decimal(get(p), abs_value, num_digits);
 break;
 }
 case 'x': case 'X': {
 UnsignedType n = abs_value;
 if (spec.flag(HASH_FLAG)) {
 prefix[prefix_size++] = '0';
 prefix[prefix_size++] = spec.type();
 }
 unsigned num_digits = 0;
 do {
 ++num_digits;
 } while ((n >>= 4) != 0);
 Char *p = get(prepare_int_buffer(
 num_digits, spec, prefix, prefix_size));
 n = abs_value;
 const char *digits = spec.type() == 'x' ?
 "0123456789abcdef" : "0123456789ABCDEF";
 do {
 *p-- = digits[n & 0xf];
 } while ((n >>= 4) != 0);
 break;
 }
 case 'b': case 'B': {
 UnsignedType n = abs_value;
 if (spec.flag(HASH_FLAG)) {
 prefix[prefix_size++] = '0';
 prefix[prefix_size++] = spec.type();
 }
 unsigned num_digits = 0;
 do {
 ++num_digits;
 } while ((n >>= 1) != 0);
 Char *p = get(prepare_int_buffer(num_digits, spec, prefix, prefix_size));
 n = abs_value;
 do {
 *p-- = static_cast<Char>('0' + (n & 1));
 } while ((n >>= 1) != 0);
 break;
 }
 case 'o': {
 UnsignedType n = abs_value;
 if (spec.flag(HASH_FLAG))
 prefix[prefix_size++] = '0';
 unsigned num_digits = 0;
 do {
 ++num_digits;
 } while ((n >>= 3) != 0);
 Char *p = get(prepare_int_buffer(num_digits, spec, prefix, prefix_size));
 n = abs_value;
 do {
 *p-- = static_cast<Char>('0' + (n & 7));
 } while ((n >>= 3) != 0);
 break;
 }
 default:
 internal::report_unknown_type(
 spec.type(), spec.flag(CHAR_FLAG) ? "char" : "integer");
 break;
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename Char >

template<typename StrChar >

BasicWriter< Char >::CharPtr fmt::BasicWriter< Char >::write_str ( const StrChar *  s, std::size_t  size, const AlignSpec &  spec  )

private

 {
 CharPtr out = CharPtr();
 if (spec.width() > size) {
 out = grow_buffer(spec.width());
 Char fill = internal::CharTraits<Char>::cast(spec.fill());
 if (spec.align() == ALIGN_RIGHT) {
 std::uninitialized_fill_n(out, spec.width() - size, fill);
 out += spec.width() - size;
 } else if (spec.align() == ALIGN_CENTER) {
 out = fill_padding(out, spec.width(), size, fill);
 } else {
 std::uninitialized_fill_n(out + size, spec.width() - size, fill);
 }
 } else {
 out = grow_buffer(size);
 }
 std::uninitialized_copy(s, s + size, out);
 return out;
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename Char >

template<typename StrChar >

void fmt::BasicWriter< Char >::write_str ( const internal::Arg::StringValue< StrChar > &  str, const FormatSpec &  spec  )

private

 {
 // Check if StrChar is convertible to Char.
 internal::CharTraits<Char>::convert(StrChar());
 if (spec.type_ && spec.type_ != 's')
 internal::report_unknown_type(spec.type_, "string");
 const StrChar *str_value = s.value;
 std::size_t str_size = s.size;
 if (str_size == 0) {
 if (!str_value) {
 FMT_THROW(FormatError("string pointer is null"));
 return;
 }
 }
 std::size_t precision = static_cast<std::size_t>(spec.precision_);
 if (spec.precision_ >= 0 && precision < str_size)
 str_size = precision;
 write_str(str_value, str_size, spec);
}

Here is the call graph for this function:

template<typename Char>

template<typename UInt >

Char* fmt::BasicWriter< Char >::write_unsigned_decimal ( UInt  value, unsigned  prefix_size = 0  )

inlineprivate

 {
 unsigned num_digits = internal::count_digits(value);
 Char *ptr = get(grow_buffer(prefix_size + num_digits));
 internal::format_decimal(ptr + prefix_size, value, num_digits);
 return ptr;
 }

Here is the call graph for this function:

Friends And Related Function Documentation

template<typename Char>

template<typename Impl , typename Char_ >

friend class internal::ArgFormatterBase

friend

template<typename Char>

friend class internal::PrintfArgFormatter< Char >

friend

Member Data Documentation

template<typename Char>

Buffer<Char>& fmt::BasicWriter< Char >::buffer_

private

---

The documentation for this class was generated from the following file:

• dep/cppformat/cppformat/format.h