folly::format_value Namespace Reference

Functions
template<class FormatCallback >
void	formatString (StringPiece val, FormatArg &arg, FormatCallback &cb)
template<class FormatCallback >
void	formatNumber (StringPiece val, int prefixLen, FormatArg &arg, FormatCallback &cb)
template<class FormatCallback , class Derived , bool containerMode, class... Args>
void	formatFormatter (const BaseFormatter< Derived, containerMode, Args... > &formatter, FormatArg &arg, FormatCallback &cb)

Detailed Description

Utilities for all format value specializations.

Function Documentation

template<class FormatCallback , class Derived , bool containerMode, class... Args>

void folly::format_value::formatFormatter	(	const BaseFormatter< Derived, containerMode, Args... > &	formatter,
		FormatArg &	arg,
		FormatCallback &	cb
	)

Format a Formatter object recursively. Behaves just like formatString(fmt.str(), arg, cb); but avoids creating a temporary string if possible.

Definition at line 380 of file Format-inl.h.

References folly::FormatArg::align, folly::BaseFormatter< Derived, containerMode, Args >::fbstr(), formatString(), max, min, folly::FormatArg::precision, and folly::FormatArg::width.

Referenced by folly::FormatValue< KeyValue >::format(), and folly::vformat().

                        {
  if (arg.width == FormatArg::kDefaultWidth &&
      arg.precision == FormatArg::kDefaultPrecision) {
    // nothing to do
    formatter(cb);
  } else if (
      arg.align != FormatArg::Align::LEFT &&
      arg.align != FormatArg::Align::DEFAULT) {
    // We can only avoid creating a temporary string if we align left,
    // as we'd need to know the size beforehand otherwise
    format_value::formatString(formatter.fbstr(), arg, cb);
  } else {
    auto fn = [&arg, &cb](StringPiece sp) mutable {
      int sz = static_cast<int>(sp.size());
      if (arg.precision != FormatArg::kDefaultPrecision) {
        sz = std::min(arg.precision, sz);
        sp.reset(sp.data(), size_t(sz));
        arg.precision -= sz;
      }
      if (!sp.empty()) {
        cb(sp);
        if (arg.width != FormatArg::kDefaultWidth) {
          arg.width = std::max(arg.width - sz, 0);
        }
      }
    };
    formatter(fn);
    if (arg.width != FormatArg::kDefaultWidth && arg.width != 0) {
      // Rely on formatString to do appropriate padding
      format_value::formatString(StringPiece(), arg, cb);
    }
  }
}

template<class FormatCallback >

void folly::format_value::formatNumber	(	StringPiece	val,
		int	prefixLen,
		FormatArg &	arg,
		FormatCallback &	cb
	)

Format a number in "val"; the first prefixLen characters form the prefix (sign, "0x" base prefix, etc) which must be left-aligned if the alignment is Align::PAD_AFTER_SIGN. Treats Align::DEFAULT as Align::LEFT. Ignores arg.precision, as that has a different meaning for numbers (not "maximum field width")

Definition at line 357 of file Format-inl.h.

References folly::Range< Iter >::advance(), folly::FormatArg::align, testing::Args(), formatString(), max, folly::FormatArg::precision, folly::Range< Iter >::subpiece(), and folly::FormatArg::width.

Referenced by folly::FormatValue< T, typename std::enable_if< std::is_integral< T >::value &&!std::is_same< T, bool >::value >::type >::doFormat(), folly::FormatValue< double >::format(), and folly::vformat().

                        {
  // precision means something different for numbers
  arg.precision = FormatArg::kDefaultPrecision;
  if (arg.align == FormatArg::Align::DEFAULT) {
    arg.align = FormatArg::Align::RIGHT;
  } else if (prefixLen && arg.align == FormatArg::Align::PAD_AFTER_SIGN) {
    // Split off the prefix, then do any padding if necessary
    cb(val.subpiece(0, size_t(prefixLen)));
    val.advance(size_t(prefixLen));
    arg.width = std::max(arg.width - prefixLen, 0);
  }
  format_value::formatString(val, arg, cb);
}

template<class FormatCallback >

void folly::format_value::formatString	(	StringPiece	val,
		FormatArg &	arg,
		FormatCallback &	cb
	)

Format a string in "val", obeying appropriate alignment, padding, width, and precision. Treats Align::DEFAULT as Align::LEFT, and Align::PAD_AFTER_SIGN as Align::RIGHT; use formatNumber for number-specific formatting.

Definition at line 298 of file Format-inl.h.

References folly::FormatArg::align, folly::Range< Iter >::data(), folly::FormatArg::fill, min, folly::FormatArg::precision, folly::Range< Iter >::reset(), folly::Range< Iter >::size(), and folly::FormatArg::width.

Referenced by folly::FormatValue< bool >::format(), formatFormatter(), formatNumber(), and folly::vformat().

                                                                       {
  if (arg.width != FormatArg::kDefaultWidth && arg.width < 0) {
    throw_exception<BadFormatArg>("folly::format: invalid width");
  }
  if (arg.precision != FormatArg::kDefaultPrecision && arg.precision < 0) {
    throw_exception<BadFormatArg>("folly::format: invalid precision");
  }

  if (arg.precision != FormatArg::kDefaultPrecision &&
      val.size() > static_cast<size_t>(arg.precision)) {
    val.reset(val.data(), static_cast<size_t>(arg.precision));
  }

  constexpr int padBufSize = 128;
  char padBuf[padBufSize];

  // Output padding, no more than padBufSize at once
  auto pad = [&padBuf, &cb, padBufSize](int chars) {
    while (chars) {
      int n = std::min(chars, padBufSize);
      cb(StringPiece(padBuf, size_t(n)));
      chars -= n;
    }
  };

  int padRemaining = 0;
  if (arg.width != FormatArg::kDefaultWidth &&
      val.size() < static_cast<size_t>(arg.width)) {
    char fill = arg.fill == FormatArg::kDefaultFill ? ' ' : arg.fill;
    int padChars = static_cast<int>(arg.width - val.size());
    memset(padBuf, fill, size_t(std::min(padBufSize, padChars)));

    switch (arg.align) {
      case FormatArg::Align::DEFAULT:
      case FormatArg::Align::LEFT:
        padRemaining = padChars;
        break;
      case FormatArg::Align::CENTER:
        pad(padChars / 2);
        padRemaining = padChars - padChars / 2;
        break;
      case FormatArg::Align::RIGHT:
      case FormatArg::Align::PAD_AFTER_SIGN:
        pad(padChars);
        break;
      default:
        abort();
        break;
    }
  }

  cb(val);

  if (padRemaining) {
    pad(padRemaining);
  }
}