folly::to·tryTo — text↔num 변환 분석

1
int n = folly::to<int>("42");
2
std::string s = folly::to<std::string>(3.14);
3
double d = folly::to<double>(s);
4

5
auto r = folly::tryTo<int>("not-a-number");
6
if (r.hasValue()) Use(*r);

1
#include <folly/Conv.h>
2

3
// 1. throw-on-error
4
int   i = folly::to<int>("42");                   // OK
5
int   j = folly::to<int>("abc");                  // throws ConversionError
6
auto  s = folly::to<std::string>(42);             // "42"
7
auto  d = folly::to<double>("3.14");
8

9
// 2. 부분 parse — view를 진행시키며 자른다
10
folly::StringPiece sp = "42,17";
11
int x = folly::to<int>(&sp);   // x=42, sp=",17"
12

13
// 3. tryTo — Expected 반환
14
folly::Expected<int, folly::ConversionCode> r = folly::tryTo<int>("99");
15
if (r) { Use(*r); }
16
else   { LOG(WARNING) << "code=" << static_cast<int>(r.error()); }
17

18
// 4. 여러 인자를 한 문자열로
19
std::string s2 = folly::to<std::string>("id=", id, ",v=", val);
20

21
// 5. variadic — output buffer에 append
22
std::string out;
23
folly::toAppend("count=", n, " of ", total, &out);

1
// 약식 — folly/Conv.h
2
template <class Tgt, class Src>
3
Tgt to(const Src& src) {
4
  if constexpr (std::is_same_v<Tgt, Src>) return src;
5
  else return detail::Converter<Tgt, Src>::convert(src);
6
}

1
// 약식 — 2자리씩 처리
2
constexpr char digits[] =
3
  "0001020304050607080910111213141516..."  // "00".."99"
4
;
5

6
uint32_t to_ascii_base10(char* buf, uint64_t v) {
7
  // 8자리씩 SWAR 분할
8
  // 마지막 2-3자리만 1자리씩 처리
9
  // ...
10
}

1
// 약식 — 8 바이트를 한 word로 처리
2
uint64_t parse_8_digits_swar(const char* s) {
3
  uint64_t word;
4
  memcpy(&word, s, 8);
5
  word -= 0x3030303030303030ULL;     // '0' 8개 빼기
6
  // multiply chain 로 자리수 결합
7
  // ...
8
  return result;
9
}

1
// 약식
2
template <class Tgt, class Src>
3
Expected<Tgt, ConversionCode> tryTo(const Src& src) {
4
  Tgt result;
5
  auto code = detail::Converter<Tgt, Src>::tryConvert(src, &result);
6
  if (code == ConversionCode::SUCCESS) return result;
7
  return makeUnexpected(code);
8
}

1
// std::from_chars (C++17) — 저수준이지만 가장 빠른 표준
2
int v;
3
auto r = std::from_chars(sv.data(), sv.data() + sv.size(), v);
4
if (r.ec == std::errc{}) { /* ok */ }
5

6
// abseil
7
int v2;
8
if (absl::SimpleAtoi("42", &v2)) { /* ok */ }
9
std::string s = absl::StrCat(1, ",", 2.5);
10

11
// folly
12
int v3 = folly::to<int>("42");                   // throws
13
auto r3 = folly::tryTo<int>("42");               // Expected
14
std::string s2 = folly::to<std::string>(1, ",", 2.5);

1
// Bad — hot path에서 throw 의존
2
for (auto& s : tokens) {
3
  try {
4
    Process(folly::to<int>(s));
5
  } catch (...) { Skip(); }
6
}
7

8
// Good — tryTo로 분기
9
for (auto& s : tokens) {
10
  if (auto r = folly::tryTo<int>(s)) Process(*r);
11
  else Skip();
12
}

1
// Bad — std::string 누적
2
std::string s;
3
for (int i = 0; i < N; ++i) {
4
  s += folly::to<std::string>(i) + ",";   // 매번 임시 할당
5
}
6

7
// Good — toAppend로 in-place
8
std::string s;
9
for (int i = 0; i < N; ++i) {
10
  folly::toAppend(i, ",", &s);            // s에 직접 append
11
}