folly::FormatArg Struct Reference

#include <FormatArg.h>

Public Types
enum	Type { Type::INTEGER, Type::FLOAT, Type::OTHER }
enum	Align : uint8_t {   Align::DEFAULT, Align::LEFT, Align::RIGHT, Align::PAD_AFTER_SIGN,   Align::CENTER, Align::INVALID }
enum	Sign : uint8_t {   Sign::DEFAULT, Sign::PLUS_OR_MINUS, Sign::MINUS, Sign::SPACE_OR_MINUS,   Sign::INVALID }

Public Member Functions
	FormatArg (StringPiece sp)
void	validate (Type type) const
template<typename... Args>
void	enforce (bool v, Args &&...args) const
template<typename... Args>
std::string	errorStr (Args &&...args) const
template<typename... Args>
void	error (Args &&...args) const
template<bool emptyOk = false>
StringPiece	splitKey ()
bool	keyEmpty () const
int	splitIntKey ()
void	setNextIntKey (int val)
void	setNextKey (StringPiece val)

Public Attributes
StringPiece	fullArgString
char	fill
Align	align
Sign	sign
bool	basePrefix
bool	thousandsSeparator
bool	trailingDot
int	width
int	widthIndex
int	precision
char	presentation

Static Public Attributes
static constexpr char	kDefaultFill = '\0'
static constexpr int	kDefaultWidth = -1
static constexpr int	kDynamicWidth = -2
static constexpr int	kNoIndex = -1
static constexpr int	kDefaultPrecision = -1
static constexpr char	kDefaultPresentation = '\0'

Private Types
enum	NextKeyMode { NextKeyMode::NONE, NextKeyMode::INT, NextKeyMode::STRING }

Private Member Functions
void	initSlow ()
template<bool emptyOk>
StringPiece	doSplitKey ()

Private Attributes
StringPiece	key_
int	nextIntKey_
StringPiece	nextKey_
NextKeyMode	nextKeyMode_

Detailed Description

Parsed format argument.

Definition at line 37 of file FormatArg.h.

Member Enumeration Documentation

enum folly::FormatArg::Align : uint8_t

strong

Alignment

Enumerator
DEFAULT
LEFT
RIGHT
PAD_AFTER_SIGN
CENTER
INVALID

Definition at line 101 of file FormatArg.h.

                   : uint8_t {
    DEFAULT,
    LEFT,
    RIGHT,
    PAD_AFTER_SIGN,
    CENTER,
    INVALID,
  };

enum folly::FormatArg::NextKeyMode

strongprivate

Enumerator
NONE
INT
STRING

Definition at line 199 of file FormatArg.h.

                         {
    NONE,
    INT,
    STRING,
  };

enum folly::FormatArg::Sign : uint8_t

strong

Sign

Enumerator
DEFAULT
PLUS_OR_MINUS
MINUS
SPACE_OR_MINUS
INVALID

Definition at line 114 of file FormatArg.h.

                  : uint8_t {
    DEFAULT,
    PLUS_OR_MINUS,
    MINUS,
    SPACE_OR_MINUS,
    INVALID,
  };

enum folly::FormatArg::Type

strong

Enumerator
INTEGER
FLOAT
OTHER

Definition at line 60 of file FormatArg.h.

                  {
    INTEGER,
    FLOAT,
    OTHER,
  };

Constructor & Destructor Documentation

folly::FormatArg::FormatArg ( StringPiece  sp )

inlineexplicit

Parse a format argument from a string. Keeps a reference to the passed-in string – does not copy the given characters.

Definition at line 42 of file FormatArg.h.

References folly::Range< Iter >::empty().

      : fullArgString(sp),
        fill(kDefaultFill),
        align(Align::DEFAULT),
        sign(Sign::DEFAULT),
        basePrefix(false),
        thousandsSeparator(false),
        trailingDot(false),
        width(kDefaultWidth),
        widthIndex(kNoIndex),
        precision(kDefaultPrecision),
        presentation(kDefaultPresentation),
        nextKeyMode_(NextKeyMode::NONE) {
    if (!sp.empty()) {
      initSlow();
    }
  }

Member Function Documentation

template<bool emptyOk>

StringPiece folly::FormatArg::doSplitKey ( )

inlineprivate

Definition at line 228 of file FormatArg.h.

References b, folly::pushmi::operators::error(), folly::NONE, and STRING.

                                         {
  if (nextKeyMode_ == NextKeyMode::STRING) {
    nextKeyMode_ = NextKeyMode::NONE;
    if (!emptyOk) { // static
      enforce(!nextKey_.empty(), "non-empty key required");
    }
    return nextKey_;
  }

  if (key_.empty()) {
    if (!emptyOk) { // static
      error("non-empty key required");
    }
    return StringPiece();
  }

  const char* b = key_.begin();
  const char* e = key_.end();
  const char* p;
  if (e[-1] == ']') {
    --e;
    p = static_cast<const char*>(memchr(b, '[', size_t(e - b)));
    enforce(p != nullptr, "unmatched ']'");
  } else {
    p = static_cast<const char*>(memchr(b, '.', size_t(e - b)));
  }
  if (p) {
    key_.assign(p + 1, e);
  } else {
    p = e;
    key_.clear();
  }
  if (!emptyOk) { // static
    enforce(b != p, "non-empty key required");
  }
  return StringPiece(b, p);
}

template<typename... Args>

void folly::FormatArg::enforce ( bool  v, Args &&...  args  ) const

inline

Throw an exception if the first argument is false. The exception message will contain the argument string as well as any passed-in arguments to enforce, formatted using folly::to<std::string>.

Definition at line 76 of file FormatArg.h.

References testing::Args(), folly::pushmi::operators::error(), string, and UNLIKELY.

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

                                             {
    if (UNLIKELY(!v)) {
      error(std::forward<Args>(args)...);
    }
  }

template<typename... Args>

void folly::FormatArg::error ( Args &&...  args ) const

inline

Definition at line 217 of file FormatArg.h.

Referenced by folly::FormatValue< T, typename std::enable_if< std::is_integral< T >::value &&!std::is_same< T, bool >::value >::type >::doFormat(), folly::BaseFormatter< Formatter< containerMode, Args... >, containerMode, Args... >::doFormatFrom(), folly::FormatValue< double >::formatHelper(), folly::BaseFormatter< Formatter< containerMode, Args... >, containerMode, Args... >::getSizeArgFrom(), and folly::BaseFormatter< Formatter< containerMode, Args... >, containerMode, Args... >::getValue().

                                                              {
  throw_exception<BadFormatArg>(errorStr(std::forward<Args>(args)...));
}

template<typename... Args>

std::string folly::FormatArg::errorStr ( Args &&...  args ) const

inline

Definition at line 208 of file FormatArg.h.

References testing::Args().

                                                         {
  return to<std::string>(
      "invalid format argument {",
      fullArgString,
      "}: ",
      std::forward<Args>(args)...);
}

void folly::FormatArg::initSlow ( )

private

Definition at line 228 of file Format.cpp.

References a, b, c, folly::test::end(), folly::pushmi::operators::error(), folly::detail::formatAlignTable, folly::detail::formatSignTable, and s.

                         {
  auto b = fullArgString.begin();
  auto end = fullArgString.end();

  // Parse key
  auto p = static_cast<const char*>(memchr(b, ':', size_t(end - b)));
  if (!p) {
    key_ = StringPiece(b, end);
    return;
  }
  key_ = StringPiece(b, p);

  if (*p == ':') {
    // parse format spec
    if (++p == end) {
      return;
    }

    // fill/align, or just align
    Align a;
    if (p + 1 != end &&
        (a = formatAlignTable[static_cast<unsigned char>(p[1])]) !=
            Align::INVALID) {
      fill = *p;
      align = a;
      p += 2;
      if (p == end) {
        return;
      }
    } else if (
        (a = formatAlignTable[static_cast<unsigned char>(*p)]) !=
        Align::INVALID) {
      align = a;
      if (++p == end) {
        return;
      }
    }

    Sign s;
    unsigned char uSign = static_cast<unsigned char>(*p);
    if ((s = formatSignTable[uSign]) != Sign::INVALID) {
      sign = s;
      if (++p == end) {
        return;
      }
    }

    if (*p == '#') {
      basePrefix = true;
      if (++p == end) {
        return;
      }
    }

    if (*p == '0') {
      enforce(align == Align::DEFAULT, "alignment specified twice");
      fill = '0';
      align = Align::PAD_AFTER_SIGN;
      if (++p == end) {
        return;
      }
    }

    auto readInt = [&] {
      auto const c = p;
      do {
        ++p;
      } while (p != end && *p >= '0' && *p <= '9');
      return to<int>(StringPiece(c, p));
    };

    if (*p == '*') {
      width = kDynamicWidth;
      ++p;

      if (p == end) {
        return;
      }

      if (*p >= '0' && *p <= '9') {
        widthIndex = readInt();
      }

      if (p == end) {
        return;
      }
    } else if (*p >= '0' && *p <= '9') {
      width = readInt();

      if (p == end) {
        return;
      }
    }

    if (*p == ',') {
      thousandsSeparator = true;
      if (++p == end) {
        return;
      }
    }

    if (*p == '.') {
      auto d = ++p;
      while (p != end && *p >= '0' && *p <= '9') {
        ++p;
      }
      if (p != d) {
        precision = to<int>(StringPiece(d, p));
        if (p != end && *p == '.') {
          trailingDot = true;
          ++p;
        }
      } else {
        trailingDot = true;
      }

      if (p == end) {
        return;
      }
    }

    presentation = *p;
    if (++p == end) {
      return;
    }
  }

  error("extra characters in format string");
}

bool folly::FormatArg::keyEmpty ( ) const

inline

Is the entire key empty?

Definition at line 169 of file FormatArg.h.

References folly::NONE.

                        {
    return nextKeyMode_ == NextKeyMode::NONE && key_.empty();
  }

void folly::FormatArg::setNextIntKey ( int  val )

inline

Definition at line 179 of file FormatArg.h.

References folly::NONE, and val.

                              {
    assert(nextKeyMode_ == NextKeyMode::NONE);
    nextKeyMode_ = NextKeyMode::INT;
    nextIntKey_ = val;
  }

void folly::FormatArg::setNextKey ( StringPiece  val )

inline

Definition at line 185 of file FormatArg.h.

References folly::NONE, STRING, and val.

                                   {
    assert(nextKeyMode_ == NextKeyMode::NONE);
    nextKeyMode_ = NextKeyMode::STRING;
    nextKey_ = val;
  }

int folly::FormatArg::splitIntKey ( )

inline

Split an key component from "key", which must be non-empty and a valid integer (an exception is thrown otherwise).

Definition at line 266 of file FormatArg.h.

References folly::pushmi::operators::error(), and folly::NONE.

Referenced by folly::FormatValue< dynamic >::format(), and folly::FormatValue< detail::DefaultValueWrapper< dynamic, V > >::format().

                                  {
  if (nextKeyMode_ == NextKeyMode::INT) {
    nextKeyMode_ = NextKeyMode::NONE;
    return nextIntKey_;
  }
  try {
    return to<int>(doSplitKey<true>());
  } catch (const std::out_of_range&) {
    error("integer key required");
    return 0; // unreached
  }
}

template<bool emptyOk>

StringPiece folly::FormatArg::splitKey ( )

inline

Split a key component from "key", which must be non-empty (an exception is thrown otherwise).

Definition at line 222 of file FormatArg.h.

Referenced by folly::FormatValue< dynamic >::format(), and folly::FormatValue< detail::DefaultValueWrapper< dynamic, V > >::format().

                                       {
  enforce(nextKeyMode_ != NextKeyMode::INT, "integer key expected");
  return doSplitKey<emptyOk>();
}

void folly::FormatArg::validate

(

Type

type

)

const

Validate the argument for the given type; throws on error.

Definition at line 358 of file Format.cpp.

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

                                        {
  enforce(keyEmpty(), "index not allowed");
  switch (type) {
    case Type::INTEGER:
      enforce(
          precision == kDefaultPrecision, "precision not allowed on integers");
      break;
    case Type::FLOAT:
      enforce(
          !basePrefix, "base prefix ('#') specifier only allowed on integers");
      enforce(
          !thousandsSeparator,
          "thousands separator (',') only allowed on integers");
      break;
    case Type::OTHER:
      enforce(
          align != Align::PAD_AFTER_SIGN,
          "'='alignment only allowed on numbers");
      enforce(sign == Sign::DEFAULT, "sign specifier only allowed on numbers");
      enforce(
          !basePrefix, "base prefix ('#') specifier only allowed on integers");
      enforce(
          !thousandsSeparator,
          "thousands separator (',') only allowed on integers");
      break;
  }
}

Member Data Documentation

Align folly::FormatArg::align

Definition at line 109 of file FormatArg.h.

Referenced by folly::format_value::formatFormatter(), folly::format_value::formatNumber(), and folly::format_value::formatString().

bool folly::FormatArg::basePrefix

Output base prefix (0 for octal, 0x for hex)

Definition at line 126 of file FormatArg.h.

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

char folly::FormatArg::fill

Definition at line 96 of file FormatArg.h.

Referenced by folly::format_value::formatString().

StringPiece folly::FormatArg::fullArgString

Full argument string, as passed in to the constructor.

Definition at line 90 of file FormatArg.h.

constexpr char folly::FormatArg::kDefaultFill = '\0'

static

Fill

Definition at line 95 of file FormatArg.h.

constexpr int folly::FormatArg::kDefaultPrecision = -1

static

Precision

Definition at line 150 of file FormatArg.h.

Referenced by folly::FormatValue< double >::formatHelper().

constexpr char folly::FormatArg::kDefaultPresentation = '\0'

static

Presentation

Definition at line 156 of file FormatArg.h.

Referenced by folly::FormatValue< double >::formatHelper().

constexpr int folly::FormatArg::kDefaultWidth = -1

static

Field width and optional argument index

Definition at line 141 of file FormatArg.h.

constexpr int folly::FormatArg::kDynamicWidth = -2

static

Definition at line 142 of file FormatArg.h.

StringPiece folly::FormatArg::key_

private

Definition at line 196 of file FormatArg.h.

constexpr int folly::FormatArg::kNoIndex = -1

static

Definition at line 143 of file FormatArg.h.

int folly::FormatArg::nextIntKey_

private

Definition at line 197 of file FormatArg.h.

StringPiece folly::FormatArg::nextKey_

private

Definition at line 198 of file FormatArg.h.

NextKeyMode folly::FormatArg::nextKeyMode_

private

Definition at line 204 of file FormatArg.h.

int folly::FormatArg::precision

Definition at line 151 of file FormatArg.h.

Referenced by folly::format_value::formatFormatter(), folly::FormatValue< double >::formatHelper(), folly::format_value::formatNumber(), and folly::format_value::formatString().

char folly::FormatArg::presentation

Definition at line 157 of file FormatArg.h.

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

Sign folly::FormatArg::sign

Definition at line 121 of file FormatArg.h.

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

bool folly::FormatArg::thousandsSeparator

Output thousands separator (comma)

Definition at line 131 of file FormatArg.h.

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

bool folly::FormatArg::trailingDot

Force a trailing decimal on doubles which could be rendered as ints

Definition at line 136 of file FormatArg.h.

Referenced by folly::FormatValue< double >::formatHelper().

int folly::FormatArg::width

Definition at line 144 of file FormatArg.h.

Referenced by folly::format_value::formatFormatter(), folly::format_value::formatNumber(), and folly::format_value::formatString().

int folly::FormatArg::widthIndex

Definition at line 145 of file FormatArg.h.

---

The documentation for this struct was generated from the following files:

• proxygen/folly/folly/FormatArg.h
• proxygen/folly/folly/Format.cpp