folly::format — legacy formatter 분석

1
#include <folly/Format.h>
2

3
// 1. format → folly::Formatter (operator<<로 출력 가능)
4
std::cout << folly::format("hello {}, {}\n", name, age);
5

6
// 2. format → fbstring (str())
7
auto s = folly::format("x={}, y={}", x, y).str();
8

9
// 3. format → append to string buffer
10
folly::format(&buffer, "value = {}", v);   // buffer(std::string)에 append
11

12
// 4. positional
13
auto a = folly::format("{0}-{1}-{0}", "x", "y").str();   // "x-y-x"
14

15
// 5. width/precision
16
auto b = folly::format("{:>10}", "hi").str();    // "        hi"
17
auto c = folly::format("{:.3f}", 3.14159).str(); // "3.142"

1
// folly::format → Formatter 객체 반환 (lazy)
2
auto fmt = folly::format("x={}", x);
3
std::cout << fmt;    // 이 시점에 format 수행
4
auto s = fmt.str();  // 또는 str() 호출
5

6
// fmt::format / std::format → string 반환 (eager)
7
auto s2 = fmt::format("x={}", x);  // 즉시 std::string

1
// folly/Format.h 약식
2
template <bool ContainerMode, class... Args>
3
class Formatter {
4
 public:
5
  Formatter(StringPiece fmt, Args&&... args)
6
    : fmt_(fmt), args_(std::forward<Args>(args)...) {}
7

8
  template <class Out>
9
  void operator()(Out& out) const {
10
    // 1. fmt_ 파싱 (runtime)
11
    // 2. 각 {}에 args_의 해당 element를 변환
12
    // 3. out에 write
13
  }
14

15
  fbstring str() const {
16
    fbstring s;
17
    auto adapter = stringAppender(s);
18
    (*this)(adapter);
19
    return s;
20
  }
21
};

1
// folly — runtime throw
2
folly::format("x={}, y={}", 42).str();   // y 인자 없음 → 예외
3

4
// std::format — compile error (C++20+)
5
auto s = std::format("x={}, y={}", 42);  // 컴파일 안 됨

1
// Before (legacy)
2
auto s = folly::format("{}-{}", a, b).str();
3
LOG(INFO) << folly::format("x={}, y={}", x, y);
4

5
// After (fmt)
6
auto s = fmt::format("{}-{}", a, b);
7
LOG(INFO) << fmt::format("x={}, y={}", x, y);
8

9
// After (std::format, C++20+)
10
auto s = std::format("{}-{}", a, b);

1
// folly 방식
2
namespace folly {
3
template <>
4
class FormatValue<MyType> {
5
 public:
6
  explicit FormatValue(const MyType& v) : v_(v) {}
7

8
  template <class FormatCallback>
9
  void format(FormatArg& arg, FormatCallback& cb) const {
10
    cb(folly::to<fbstring>(v_.toString()));
11
  }
12

13
 private:
14
  const MyType& v_;
15
};
16
}

1
// fmt 방식
2
namespace fmt {
3
template <>
4
struct formatter<MyType> : formatter<std::string> {
5
  template <class FormatContext>
6
  auto format(const MyType& v, FormatContext& ctx) const {
7
    return formatter<std::string>::format(v.toString(), ctx);
8
  }
9
};
10
}

1
// 1. folly::format 객체를 보관 후 늦게 .str()
2
auto fmt = folly::format("x={}", x);   // x가 reference로 캡처될 수도
3
sleep(100);
4
auto s = fmt.str();                     // x가 살아있어야 — 위험
5

6
// 2. format string이 동적
7
std::string fmtStr = LoadTemplate();
8
folly::format(fmtStr, args...).str();   // compile-time 검사 불가능
9

10
// 3. exception 무시
11
auto s = folly::format("{} {}", x).str();   // arg 수 불일치 → 예외
12
// → catch 없으면 process abort