folly Conv Customization — 사용자 타입 지원

1
struct UserId { uint64_t value; };
2

3
// 두 hook만 추가하면
4
void toAppend(const UserId& u, std::string* out) { /* ... */ }
5
folly::Expected<folly::StringPiece, folly::ConversionCode>
6
parseTo(folly::StringPiece sp, UserId& out)                 { /* ... */ }
7

8
// 자동 동작
9
auto s = folly::to<std::string>(UserId{42});
10
auto u = folly::to<UserId>("U#42");

1
namespace myns {
2

3
struct Money {
4
  int64_t cents;
5
  std::string currency;   // "USD" 등
6
};
7

8
// 자유 함수, 같은 namespace
9
void toAppend(const Money& m, std::string* out) {
10
  folly::toAppend(m.cents / 100, '.',
11
                  folly::to<std::string>(m.cents % 100).insert(0, "00", 2 - 1),
12
                  ' ', m.currency, out);
13
}
14

15
// optional — size hint
16
size_t estimateSpaceNeeded(const Money& m) {
17
  return 32 + m.currency.size();
18
}
19

20
}  // myns
21

22
std::string s = folly::to<std::string>(myns::Money{12345, "USD"});
23
// "123.45 USD"

1
namespace myns {
2

3
folly::Expected<folly::StringPiece, folly::ConversionCode>
4
parseTo(folly::StringPiece sp, Money& out) {
5
  // "123.45 USD" 형태 가정
6
  auto dot = sp.find('.');
7
  if (dot == folly::StringPiece::npos) {
8
    return folly::makeUnexpected(folly::ConversionCode::INVALID_LEADING_CHAR);
9
  }
10
  int64_t whole, cents;
11
  auto r1 = folly::tryTo<int64_t>(sp.subpiece(0, dot));
12
  if (!r1) return folly::makeUnexpected(r1.error());
13
  // ... cents, currency
14
  out = Money{whole * 100 + cents, "USD"};
15
  return folly::StringPiece{};   // 모두 소비
16
}
17

18
}  // myns
19

20
auto r = folly::tryTo<myns::Money>("123.45 USD");

1
// 약식 — folly/Conv.h
2
namespace folly {
3

4
template <class Tgt>
5
Tgt to(StringPiece sp) {
6
  Tgt result;
7
  using detail::parseTo_;     // 내부 default
8
  using ::parseTo;            // global parseTo도 보이게
9
  // ADL: sp가 user namespace의 parseTo도 찾는다
10
  auto remaining = parseTo(sp, result);
11
  if (!remaining) throw ConversionError{};
12
  if (!remaining->empty()) throw ConversionError{"trailing"};
13
  return result;
14
}
15

16
}

1
folly::to<std::string>(a, b, c)
2
  → folly::toAppend(a, &out);   // ADL → user 또는 folly 기본
3
  → folly::toAppend(b, &out);
4
  → folly::toAppend(c, &out);

1
enum class Color { Red, Green, Blue };
2

3
inline void toAppend(Color c, std::string* out) {
4
  switch (c) {
5
    case Color::Red:   out->append("Red");   break;
6
    case Color::Green: out->append("Green"); break;
7
    case Color::Blue:  out->append("Blue");  break;
8
  }
9
}

1
// abseil — AbslStringify 멤버 또는 free function
2
struct UserId { uint64_t value; };
3

4
template <typename Sink>
5
void AbslStringify(Sink& sink, const UserId& u) {
6
  absl::Format(&sink, "U#%016x", u.value);
7
}
8
// 이제 absl::StrCat(UserId{42}), absl::StrFormat("%v", UserId{42}) 동작

1
// Bad — friend 멤버
2
struct UserId {
3
  friend std::string ToString(const UserId& u) { /* ... */ }
4
  // folly::to가 보지 못한다
5
};
6

7
// Good — ADL 자유 함수
8
struct UserId { uint64_t value; };
9
void toAppend(const UserId& u, std::string* out) { /* ... */ }

1
// 위험 — parseTo가 estimateSpaceNeeded 없음
2
void toAppend(const Big& b, std::string* out) { /* 1KB 출력 */ }
3
// reserve 부정확 → realloc 여러 번
4

5
// 권장
6
size_t estimateSpaceNeeded(const Big& b) { return 1024; }