#include <format.h>

Public Types
typedef CharType	Char

Public Member Functions
	BasicFormatter (const ArgList &args, BasicWriter< Char > &w)

BasicWriter< Char > &	writer ()

void	format (BasicCStringRef< Char > format_str)

const Char *	format (const Char *&format_str, const internal::Arg &arg)

Private Member Functions
	FMT_DISALLOW_COPY_AND_ASSIGN (BasicFormatter)

internal::Arg	get_arg (BasicStringRef< Char > arg_name, const char *&error)

internal::Arg	parse_arg_index (const Char *&s)

internal::Arg	parse_arg_name (const Char *&s)

Private Member Functions inherited from fmt::internal::FormatterBase
const ArgList &	args () const

	FormatterBase (const ArgList &args)

Arg	next_arg (const char *&error)

Arg	get_arg (unsigned arg_index, const char *&error)

bool	check_no_auto_index (const char *&error)

template<typename Char >
void	write (BasicWriter< Char > &w, const Char start, const Char end)

Private Attributes
BasicWriter< Char > &	writer_

internal::ArgMap< Char >	map_

Detailed Description

template<typename CharType>
class fmt::BasicFormatter< CharType >

This template formats data and writes the output to a writer.

Member Typedef Documentation

template<typename CharType>

typedef CharType fmt::BasicFormatter< CharType >::Char

The character type for the output.

Constructor & Destructor Documentation

template<typename CharType>

fmt::BasicFormatter< CharType >::BasicFormatter	(	const ArgList &	args,
		BasicWriter< Char > &	w
	)

inline

Constructs a BasicFormatter object. References to the arguments and the writer are stored in the formatter object so make sure they have appropriate lifetimes.

1921 : internal::FormatterBase(args), writer_(w) {}

fmt::BasicFormatter::writer_

BasicWriter< Char > & writer_

Definition: format.h:1895

fmt::internal::FormatterBase::args

const ArgList & args() const

Definition: format.h:1829

Member Function Documentation

template<typename CharType>

fmt::BasicFormatter< CharType >::FMT_DISALLOW_COPY_AND_ASSIGN ( BasicFormatter< CharType > )

private

template<typename Char >

void fmt::BasicFormatter< Char >::format ( BasicCStringRef< Char > format_str )

Formats stored arguments and writes the output to the writer.

  {
  const Char *s = format_str.c_str();
  const Char *start = s;
  while (*s) {
  Char c = *s++;
  if (c != '{' && c != '}') continue;
  if (*s == c) {
  write(writer_, start, s);
  start = ++s;
  continue;
  }
  if (c == '}')
  FMT_THROW(FormatError("unmatched '}' in format string"));
  write(writer_, start, s - 1);
  internal::Arg arg = internal::is_name_start(*s) ?
  parse_arg_name(s) : parse_arg_index(s);
  start = s = format(s, arg);
  }
  write(writer_, start, s);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename Char >

const Char * fmt::BasicFormatter< Char >::format	(	const Char *&	format_str,
		const internal::Arg &	arg
	)

  {
  using internal::Arg;
  const Char *s = format_str;
  FormatSpec spec;
  if (*s == ':') {
  if (arg.type == Arg::CUSTOM) {
  arg.custom.format(this, arg.custom.value, &s);
  return s;
  }
  ++s;
  // Parse fill and alignment.
  if (Char c = *s) {
  const Char *p = s + 1;
  spec.align_ = ALIGN_DEFAULT;
  do {
  switch (*p) {
  case '<':
  spec.align_ = ALIGN_LEFT;
  break;
  case '>':
  spec.align_ = ALIGN_RIGHT;
  break;
  case '=':
  spec.align_ = ALIGN_NUMERIC;
  break;
  case '^':
  spec.align_ = ALIGN_CENTER;
  break;
  }
  if (spec.align_ != ALIGN_DEFAULT) {
  if (p != s) {
  if (c == '}') break;
  if (c == '{')
  FMT_THROW(FormatError("invalid fill character '{'"));
  s += 2;
  spec.fill_ = c;
  } else ++s;
  if (spec.align_ == ALIGN_NUMERIC)
  require_numeric_argument(arg, '=');
  break;
  }
  } while (--p >= s);
  }
 
  // Parse sign.
  switch (*s) {
  case '+':
  check_sign(s, arg);
  spec.flags_ |= SIGN_FLAG | PLUS_FLAG;
  break;
  case '-':
  check_sign(s, arg);
  spec.flags_ |= MINUS_FLAG;
  break;
  case ' ':
  check_sign(s, arg);
  spec.flags_ |= SIGN_FLAG;
  break;
  }
 
  if (*s == '#') {
  require_numeric_argument(arg, '#');
  spec.flags_ |= HASH_FLAG;
  ++s;
  }
 
  // Parse zero flag.
  if (*s == '0') {
  require_numeric_argument(arg, '0');
  spec.align_ = ALIGN_NUMERIC;
  spec.fill_ = '0';
  ++s;
  }
 
  // Parse width.
  if ('0' <= *s && *s <= '9') {
  spec.width_ = internal::parse_nonnegative_int(s);
  } else if (*s == '{') {
  ++s;
  Arg width_arg = internal::is_name_start(*s) ?
  parse_arg_name(s) : parse_arg_index(s);
  if (*s++ != '}')
  FMT_THROW(FormatError("invalid format string"));
  ULongLong value = 0;
  switch (width_arg.type) {
  case Arg::INT:
  if (width_arg.int_value < 0)
  FMT_THROW(FormatError("negative width"));
  value = width_arg.int_value;
  break;
  case Arg::UINT:
  value = width_arg.uint_value;
  break;
  case Arg::LONG_LONG:
  if (width_arg.long_long_value < 0)
  FMT_THROW(FormatError("negative width"));
  value = width_arg.long_long_value;
  break;
  case Arg::ULONG_LONG:
  value = width_arg.ulong_long_value;
  break;
  default:
  FMT_THROW(FormatError("width is not integer"));
  }
  if (value > (std::numeric_limits<int>::max)())
  FMT_THROW(FormatError("number is too big"));
  spec.width_ = static_cast<int>(value);
  }
 
  // Parse precision.
  if (*s == '.') {
  ++s;
  spec.precision_ = 0;
  if ('0' <= *s && *s <= '9') {
  spec.precision_ = internal::parse_nonnegative_int(s);
  } else if (*s == '{') {
  ++s;
  Arg precision_arg = internal::is_name_start(*s) ?
  parse_arg_name(s) : parse_arg_index(s);
  if (*s++ != '}')
  FMT_THROW(FormatError("invalid format string"));
  ULongLong value = 0;
  switch (precision_arg.type) {
  case Arg::INT:
  if (precision_arg.int_value < 0)
  FMT_THROW(FormatError("negative precision"));
  value = precision_arg.int_value;
  break;
  case Arg::UINT:
  value = precision_arg.uint_value;
  break;
  case Arg::LONG_LONG:
  if (precision_arg.long_long_value < 0)
  FMT_THROW(FormatError("negative precision"));
  value = precision_arg.long_long_value;
  break;
  case Arg::ULONG_LONG:
  value = precision_arg.ulong_long_value;
  break;
  default:
  FMT_THROW(FormatError("precision is not integer"));
  }
  if (value > (std::numeric_limits<int>::max)())
  FMT_THROW(FormatError("number is too big"));
  spec.precision_ = static_cast<int>(value);
  } else {
  FMT_THROW(FormatError("missing precision specifier"));
  }
  if (arg.type <= Arg::LAST_INTEGER_TYPE || arg.type == Arg::POINTER) {
  FMT_THROW(FormatError(
  fmt::format("precision not allowed in {} format specifier",
  arg.type == Arg::POINTER ? "pointer" : "integer")));
  }
  }
 
  // Parse type.
  if (*s != '}' && *s)
  spec.type_ = static_cast<char>(*s++);
  }
 
  if (*s++ != '}')
  FMT_THROW(FormatError("missing '}' in format string"));
 
  // Format argument.
  internal::BasicArgFormatter<Char>(*this, spec, s - 1).visit(arg);
  return s;
 }

Here is the call graph for this function:

template<typename Char >

internal::Arg fmt::BasicFormatter< Char >::get_arg	(	BasicStringRef< Char >	arg_name,
		const char *&	error
	)

inlineprivate

  {
  if (check_no_auto_index(error)) {
  map_.init(args());
  const internal::Arg *arg = map_.find(arg_name);
  if (arg)
  return *arg;
  error = "argument not found";
  }
  return internal::Arg();
 }

Here is the call graph for this function:

template<typename Char >

internal::Arg fmt::BasicFormatter< Char >::parse_arg_index ( const Char *& s )

inlineprivate

  {
  const char *error = 0;
  internal::Arg arg = *s < '0' || *s > '9' ?
  next_arg(error) : get_arg(internal::parse_nonnegative_int(s), error);
  if (error) {
  FMT_THROW(FormatError(
  *s != '}' && *s != ':' ? "invalid format string" : error));
  }
  return arg;
 }

Here is the call graph for this function:

template<typename Char >

internal::Arg fmt::BasicFormatter< Char >::parse_arg_name ( const Char *& s )

inlineprivate

  {
  assert(internal::is_name_start(*s));
  const Char *start = s;
  Char c;
  do {
  c = *++s;
  } while (internal::is_name_start(c) || ('0' <= c && c <= '9'));
  const char *error = 0;
  internal::Arg arg = get_arg(BasicStringRef<Char>(start, s - start), error);
  if (error)
  FMT_THROW(FormatError(error));
  return arg;
 }