basic_writer< Range > Class Template Reference

#include <format.h>

Classes
struct	double_writer
struct	inf_or_nan_writer
struct	int_writer
struct	padded_int_writer
struct	str_writer

Public Types
typedef Range::value_type	char_type
typedef basic_format_specs< char_type >	format_specs

Public Member Functions
	basic_writer (Range out, internal::locale_ref loc=internal::locale_ref())
iterator	out () const
void	write (int value)
void	write (long value)
void	write (long long value)
void	write (unsigned value)
void	write (unsigned long value)
void	write (unsigned long long value)
template<typename T , typename FormatSpec , typename... FormatSpecs>
std::enable_if< std::is_integral< T >::value, void >::type	write (T value, FormatSpec spec, FormatSpecs...specs)
void	write (double value)
void	write (long double value)
void	write (char value)
void	write (wchar_t value)
void	write (string_view value)
void	write (wstring_view value)
template<typename Char >
void	write (const Char *s, std::size_t size, const align_spec &spec)
template<typename Char >
void	write (basic_string_view< Char > s, const format_specs &spec=format_specs())
template<typename T >
std::enable_if< std::is_same< T, void >::value >::type	write (const T *p)

Public Attributes
decltype(internal::declval< Range >().begin()) typedef	iterator

Private Types
enum	{ INF_SIZE = 3 }

Private Member Functions
auto	reserve (std::size_t n) -> decltype(internal::reserve(out_, n))
template<typename F >
void	write_padded (const align_spec &spec, F &&f)
template<typename Spec , typename F >
void	write_int (int num_digits, string_view prefix, const Spec &spec, F f)
template<typename Int >
void	write_decimal (Int value)
template<typename T , typename Spec >
void	write_int (T value, const Spec &spec)
template<typename T >
void	write_double (T value, const format_specs &spec)

Private Attributes
iterator	out_
internal::locale_ref	locale_

Friends
template<typename Char >
class	internal::arg_formatter_base

Detailed Description

template<typename Range>
class basic_writer< Range >

This template provides operations for formatting and writing data into a character range.

Definition at line 330 of file format.h.

Member Typedef Documentation

template<typename Range>

typedef Range::value_type basic_writer< Range >::char_type

Definition at line 2261 of file format.h.

template<typename Range>

typedef basic_format_specs<char_type> basic_writer< Range >::format_specs

Definition at line 2263 of file format.h.

Member Enumeration Documentation

template<typename Range>

anonymous enum

private

Enumerator
INF_SIZE

Definition at line 2504 of file format.h.

{INF_SIZE = 3}; // This is an enum to workaround a bug in MSVC.

Constructor & Destructor Documentation

template<typename Range>

basic_writer< Range >::basic_writer ( Range  out, internal::locale_ref  loc = internal::locale_ref()  )

inlineexplicit

Constructs a basic_writer object.

Definition at line 2567 of file format.h.

    : out_(out.begin()), locale_(loc) {}

Member Function Documentation

template<typename Range>

iterator basic_writer< Range >::out ( ) const

inline

Definition at line 2571 of file format.h.

{ return out_; }

template<typename Range>

auto basic_writer< Range >::reserve ( std::size_t  n ) -> decltype(internal::reserve(out_, n))

inlineprivate

Definition at line 2271 of file format.h.

                                                                  {
    return internal::reserve(out_, n);
  }

template<typename Range>

void basic_writer< Range >::write ( int  value )

inline

Definition at line 2573 of file format.h.

{ write_decimal(value); }

template<typename Range>

void basic_writer< Range >::write ( long  value )

inline

Definition at line 2574 of file format.h.

{ write_decimal(value); }

template<typename Range>

void basic_writer< Range >::write ( long long  value )

inline

Definition at line 2575 of file format.h.

{ write_decimal(value); }

template<typename Range>

void basic_writer< Range >::write ( unsigned  value )

inline

Definition at line 2577 of file format.h.

{ write_decimal(value); }

template<typename Range>

void basic_writer< Range >::write ( unsigned long  value )

inline

Definition at line 2578 of file format.h.

{ write_decimal(value); }

template<typename Range>

void basic_writer< Range >::write ( unsigned long long  value )

inline

Definition at line 2579 of file format.h.

{ write_decimal(value); }

template<typename Range>

template<typename T , typename FormatSpec , typename... FormatSpecs>

std::enable_if<std::is_integral<T>::value, void>::type basic_writer< Range >::write ( T  value, FormatSpec  spec, FormatSpecs...  specs  )

inline

Formats value and writes it to the buffer.

Definition at line 2588 of file format.h.

                                                            {
    format_specs s(spec, specs...);
    s.align_ = ALIGN_RIGHT;
    write_int(value, s);
  }

template<typename Range>

void basic_writer< Range >::write ( double  value )

inline

Definition at line 2594 of file format.h.

                           {
    write_double(value, format_specs());
  }

template<typename Range>

void basic_writer< Range >::write ( long double  value )

inline

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

Definition at line 2604 of file format.h.

                                {
    write_double(value, format_specs());
  }

template<typename Range>

void basic_writer< Range >::write ( char  value )

inline

Writes a character to the buffer.

Definition at line 2609 of file format.h.

                         {
    *reserve(1) = value;
  }

template<typename Range>

void basic_writer< Range >::write ( wchar_t  value )

inline

Definition at line 2612 of file format.h.

                            {
    static_assert(std::is_same<char_type, wchar_t>::value, "");
    *reserve(1) = value;
  }

template<typename Range>

void basic_writer< Range >::write ( string_view  value )

inline

Writes value to the buffer.

Definition at line 2622 of file format.h.

                                {
    auto &&it = reserve(value.size());
    it = internal::copy_str<char_type>(value.begin(), value.end(), it);
  }

template<typename Range>

void basic_writer< Range >::write ( wstring_view  value )

inline

Definition at line 2626 of file format.h.

                                 {
    static_assert(std::is_same<char_type, wchar_t>::value, "");
    auto &&it = reserve(value.size());
    it = std::copy(value.begin(), value.end(), it);
  }

template<typename Range>

template<typename Char >

void basic_writer< Range >::write ( const Char *  s, std::size_t  size, const align_spec &  spec  )

inline

Definition at line 2634 of file format.h.

                                                                    {
    write_padded(spec, str_writer<Char>{s, size});
  }

template<typename Range>

template<typename Char >

void basic_writer< Range >::write ( basic_string_view< Char >  s, const format_specs &  spec = format_specs()  )

inline

Definition at line 2639 of file format.h.

                                                        {
    const Char *data = s.data();
    std::size_t size = s.size();
    if (spec.precision >= 0 && internal::to_unsigned(spec.precision) < size)
      size = internal::to_unsigned(spec.precision);
    write(data, size, spec);
  }

template<typename Range>

template<typename T >

std::enable_if<std::is_same<T, void>::value>::type basic_writer< Range >::write ( const T *  p )

inline

Definition at line 2650 of file format.h.

                        {
    format_specs specs;
    specs.flags = HASH_FLAG;
    specs.type = 'x';
    write_int(reinterpret_cast<uintptr_t>(p), specs);
  }

template<typename Range>

template<typename Int >

void basic_writer< Range >::write_decimal ( Int  value )

inlineprivate

Definition at line 2349 of file format.h.

                                {
    typedef typename internal::int_traits<Int>::main_type main_type;
    main_type abs_value = static_cast<main_type>(value);
    bool is_negative = internal::is_negative(value);
    if (is_negative)
      abs_value = 0 - abs_value;
    int num_digits = internal::count_digits(abs_value);
    auto &&it = reserve((is_negative ? 1 : 0) + static_cast<size_t>(num_digits));
    if (is_negative)
      *it++ = static_cast<char_type>('-');
    it = internal::format_decimal<char_type>(it, abs_value, num_digits);
  }

template<typename Range >

template<typename T >

void basic_writer< Range >::write_double ( T  value, const format_specs &  spec  )

private

Definition at line 2698 of file format.h.

                                                                        {
  // Check type.
  float_spec_handler handler(static_cast<char>(spec.type));
  internal::handle_float_type_spec(handler.type, handler);

  char sign = 0;
  // Use signbit instead of value < 0 because the latter is always
  // false for NaN.
  if (std::signbit(value)) {
    sign = '-';
    value = -value;
  } else if (spec.has(SIGN_FLAG)) {
    sign = spec.has(PLUS_FLAG) ? '+' : ' ';
  }

  struct write_inf_or_nan_t {
    basic_writer &writer;
    format_specs spec;
    char sign;
    void operator()(const char *str) const {
      writer.write_padded(spec, inf_or_nan_writer{sign, str});
    }
  } write_inf_or_nan = {*this, spec, sign};

  // Format NaN and ininity ourselves because sprintf's output is not consistent
  // across platforms.
  if (internal::fputil::isnotanumber(value))
    return write_inf_or_nan(handler.upper ? "NAN" : "nan");
  if (internal::fputil::isinfinity(value))
    return write_inf_or_nan(handler.upper ? "INF" : "inf");

  memory_buffer buffer;
  bool use_grisu = FMT_USE_GRISU && sizeof(T) <= sizeof(double) &&
      spec.type != 'a' && spec.type != 'A' &&
      internal::grisu2_format(static_cast<double>(value), buffer, spec);
  if (!use_grisu) {
    format_specs normalized_spec(spec);
    normalized_spec.type = handler.type;
    internal::sprintf_format(value, buffer, normalized_spec);
  }
  size_t n = buffer.size();
  align_spec as = spec;
  if (spec.align() == ALIGN_NUMERIC) {
    if (sign) {
      auto &&it = reserve(1);
      *it++ = static_cast<char_type>(sign);
      sign = 0;
      if (as.width_)
        --as.width_;
    }
    as.align_ = ALIGN_RIGHT;
  } else {
    if (spec.align() == ALIGN_DEFAULT)
      as.align_ = ALIGN_RIGHT;
    if (sign)
      ++n;
  }
  write_padded(as, double_writer{n, sign, buffer});
}

template<typename Range>

template<typename Spec , typename F >

void basic_writer< Range >::write_int ( int  num_digits, string_view  prefix, const Spec &  spec, F  f  )

inlineprivate

Definition at line 2326 of file format.h.

                                        {
    std::size_t size = prefix.size() + internal::to_unsigned(num_digits);
    char_type fill = static_cast<char_type>(spec.fill());
    std::size_t padding = 0;
    if (spec.align() == ALIGN_NUMERIC) {
      if (spec.width() > size) {
        padding = spec.width() - size;
        size = spec.width();
      }
    } else if (spec.precision > num_digits) {
      size = prefix.size() + internal::to_unsigned(spec.precision);
      padding = internal::to_unsigned(spec.precision - num_digits);
      fill = static_cast<char_type>('0');
    }
    align_spec as = spec;
    if (spec.align() == ALIGN_DEFAULT)
      as.align_ = ALIGN_RIGHT;
    write_padded(as, padded_int_writer<F>{size, prefix, fill, padding, f});
  }

template<typename Range>

template<typename T , typename Spec >

void basic_writer< Range >::write_int ( T  value, const Spec &  spec  )

inlineprivate

Definition at line 2499 of file format.h.

                                            {
    internal::handle_int_type_spec(spec.type,
                                   int_writer<T, Spec>(*this, value, spec));
  }

template<typename Range>

template<typename F >

void basic_writer< Range >::write_padded ( const align_spec &  spec, F &&  f  )

inlineprivate

Definition at line 2279 of file format.h.

                                                   {
    unsigned width = spec.width(); // User-perceived width (in code points).
    size_t size = f.size(); // The number of code units.
    size_t num_code_points = width != 0 ? f.width() : size;
    if (width <= num_code_points)
      return f(reserve(size));
    auto &&it = reserve(width + (size - num_code_points));
    char_type fill = static_cast<char_type>(spec.fill());
    std::size_t padding = width - num_code_points;
    if (spec.align() == ALIGN_RIGHT) {
      it = std::fill_n(it, padding, fill);
      f(it);
    } else if (spec.align() == ALIGN_CENTER) {
      std::size_t left_padding = padding / 2;
      it = std::fill_n(it, left_padding, fill);
      f(it);
      it = std::fill_n(it, padding - left_padding, fill);
    } else {
      f(it);
      it = std::fill_n(it, padding, fill);
    }
  }

Friends And Related Function Documentation

template<typename Range>

template<typename Char >

friend class internal::arg_formatter_base

friend

Definition at line 2563 of file format.h.

Member Data Documentation

template<typename Range>

decltype(internal::declval<Range>().begin()) typedef basic_writer< Range >::iterator

Definition at line 2262 of file format.h.

template<typename Range>

internal::locale_ref basic_writer< Range >::locale_

private

Definition at line 2267 of file format.h.

template<typename Range>

iterator basic_writer< Range >::out_

private

Definition at line 2266 of file format.h.

---

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

• wire-cell-build/util/inc/spdlog/fmt/bundled/format.h