본문으로 건너뛰기
Folly Code Review · 52/89

folly dynamic Visitor pattern — type별 분기

· Hawk · 4분 읽기
cpp folly dynamic visitor pattern

#한 줄 요약

folly::dynamic은 6가지 타입을 담는 tagged union이고, 처리 코드도 type별로 분기가 잦다. switch + isXxx의 반복을 줄이려면 visitor 헬퍼를 만든다. std::visit와 같은 정신이지만 dynamic은 closed type set이라 더 단순한 형태가 가능하다.

#동기 — 반복되는 type 분기

JSON-like dynamic을 일반화 처리할 때 자주 나오는 모양.

void print(const folly::dynamic& d) {
  if (d.isNull())       std::cout << "null";
  else if (d.isBool())   std::cout << d.getBool();
  else if (d.isInt())    std::cout << d.getInt();
  else if (d.isDouble()) std::cout << d.getDouble();
  else if (d.isString()) std::cout << d.getString();
  else if (d.isArray())  printArray(d);
  else if (d.isObject()) printObject(d);
}

이 패턴이 print, validate, transform, schema check 등 곳곳에서 반복된다. type 하나 빼먹으면 silent buggy. helper로 한 번에 처리하자는 게 visitor 패턴이다.

#직접 visitor — overloaded helper

C++17의 overloaded 트릭으로 lambda 세트를 visitor로 만들 수 있다.

template <class... Ts> struct overloaded : Ts... { using Ts::operator()...; };
template <class... Ts> overloaded(Ts...) -> overloaded<Ts...>;


void visit(const folly::dynamic& d, auto&& v) {
  if (d.isNull())        v(nullptr);
  else if (d.isBool())   v(d.getBool());
  else if (d.isInt())    v(d.getInt());
  else if (d.isDouble()) v(d.getDouble());
  else if (d.isString()) v(d.getString());
  else if (d.isArray())  v(d.items_array());  // const reference to array
  else if (d.isObject()) v(d.items_object());
}


// 사용
visit(d, overloaded{
  [](std::nullptr_t)   { std::cout << "null"; },
  [](bool b)           { std::cout << b; },
  [](int64_t i)        { std::cout << i; },
  [](double dv)        { std::cout << dv; },
  [](const std::string& s) { std::cout << s; },
  [](const auto& container) { std::cout << "container"; },
});

std::visit(variant, overloaded{...})와 같은 모양이다. lambda 한 줄로 type 분기.

장점:

  • 컴파일러가 타입별 처리 누락을 잡아준다 (auto로 catch-all 두지 않으면).
  • 코드가 한 군데 모인다.
  • 람다 별 type-specific 처리가 명료.

단점:

  • dynamic은 std::visit과 달리 native 지원이 아니므로 위 visit 함수를 직접 작성.

#recursive traversal

JSON tree 전체를 도는 패턴.

void traverse(const folly::dynamic& d, auto&& fn) {
  fn(d); // visit current
  if (d.isArray()) {
    for (const auto& e : d) traverse(e, fn);
  } else if (d.isObject()) {
    for (const auto& [k, v] : d.items()) traverse(v, fn);
  }
}


// 사용 — 모든 string 값 수집
std::vector<std::string> strings;
traverse(json, [&](const folly::dynamic& v) {
  if (v.isString()) strings.push_back(v.getString());
});

이런 helper는 schema validation, redaction(민감정보 마스킹), telemetry 추출 등에 자주 쓰인다.

#transform — 새 dynamic 생성

folly::dynamic transform(const folly::dynamic& d, auto&& fn) {
  if (d.isArray()) {
    folly::dynamic out = folly::dynamic::array;
    for (const auto& e : d) out.push_back(transform(e, fn));
    return out;
  } else if (d.isObject()) {
    folly::dynamic out = folly::dynamic::object;
    for (const auto& [k, v] : d.items()) out[k] = transform(v, fn);
    return out;
  }
  return fn(d); // leaf
}


// 사용 — 모든 password 필드를 *** 로 마스킹
auto redacted = transform(d, [](const folly::dynamic& v) -> folly::dynamic {
  // leaf 처리만, key는 부모에서 처리 필요(여기선 단순화)
  return v;
});

leaf만 변환하는 패턴. key까지 보려면 traverse에서 (key, value) 쌍을 함께 넘기는 변형 필요.

#std::visit와의 차이

std::visitdynamic visitor
대상std::variant<Ts...>folly::dynamic (6 fixed types)
dispatchjump table 또는 if chainif chain
누락 type 컴파일 에러yesno (런타임에 못 매칭하면 무시)
recursive직접직접

dynamic은 std::visit를 직접 못 쓴다(타입 시스템이 다름). 위 visit helper가 그 자리를 메운다. 누락 검출이 약한 게 약점이라, catch-all lambda를 두거나 __builtin_unreachable()로 끝맺어 missing case를 빨리 잡는다.

#코드 리뷰 포인트

#1. 누락 type 검출

// 회피 — catch-all 없음, missing type silent
if (d.isString()) handle(d.getString());
else if (d.isInt()) handle(d.getInt());
// double/bool/null/array/object가 silent 무시


// Good — 명시적 else
if (d.isString()) handle(d.getString());
else if (d.isInt()) handle(d.getInt());
else throw "unsupported type: " + d.typeName();

dynamic은 컴파일러가 도와주지 않으므로 unhandled case는 명시적으로 throw/log.

#2. visit helper를 한 헤더에 두고 재사용

utility/DynamicVisit.h
namespace mylib {
  template <class V>
  decltype(auto) visit(const folly::dynamic& d, V&& v) {
    // ... 위 구현 ...
  }
}

dynamic을 다루는 모든 모듈에서 이 visit을 쓰게 하면 일관성이 생긴다.

#3. recursive traversal에 깊이 제한

void traverse(const folly::dynamic& d, auto&& fn, int depth = 0) {
  if (depth > 64) throw "too deep"; // DoS 방어
  fn(d);
  if (d.isArray()) for (const auto& e : d) traverse(e, fn, depth + 1);
  else if (d.isObject()) for (const auto& [k, v] : d.items()) traverse(v, fn, depth + 1);
}

외부 JSON은 깊이 무한이 가능. recursion limit으로 stack overflow 방어.

#4. const-correctness

// 회피 — const& 안 받음
void process(folly::dynamic& d) { ... } // 호출자가 const 객체 못 넘김


// Good
void process(const folly::dynamic& d) { ... }

visitor가 변경을 안 한다면 const&로.

#안티패턴

#1. visit 안에서 dynamic을 다시 dynamic으로 변환

// 회피
visit(d, overloaded{
  [](int64_t i) { folly::dynamic dd = i; ... } // 의미 없음
});

이미 type-specific 람다인데 다시 dynamic으로 감싸면 visitor를 쓰는 의미가 사라진다.

#2. visitor에서 비싼 작업

// 회피
traverse(huge_json, [](const folly::dynamic& v) {
  if (v.isString()) sendToLogger(v.getString()); // I/O — 매 string마다
});

leaf마다 I/O를 호출하면 매우 느려진다. 일단 모은 뒤 batch로.

#3. switch on typeName() string

// 회피
auto t = d.typeName(); // string
if (t == "string") ...
else if (t == "int64") ...

typeName은 디버그/로그용. 분기에는 is* 메서드 사용.

#정리

  • dynamic은 6가지 closed type이므로 visitor helper가 자연스럽다.
  • overloaded{...} lambda 세트로 type별 처리를 한 곳에.
  • recursive traversal로 tree 전체 순회 (redaction, schema check 등).
  • transform helper로 새 dynamic 트리 생성.
  • 컴파일러 도움이 약하므로 catch-all + recursion limit 명시.
  • visit/traverse/transform 같은 helper는 공용 헤더에 두고 재사용.

#다음 편

Part 12-01 Singleton vs Meyers — Part 12 시작. Folly의 SingletonVault가 왜 Meyers singleton보다 안전한지.

#관련 항목

Folly Code Review · 53 of 89

  1. 1 Folly Code Review — Meta의 production-grade C++ 라이브러리 코드 분석
  2. 2 Folly 개요 — Meta가 production에서 검증한 utility 모음 분석
  3. 3 Folly vs Abseil 철학 비교 — performance-first vs std-compatible
  4. 4 Folly 빌드와 fbcode 환경 — monorepo의 그림자
  5. 5 Folly API stability 정책 — 어떤 보장도 없다는 솔직함
  6. 6 Folly production validation 문화 — peta-scale에서 단련된 코드
  7. 7 folly::Future 분석 — std::future의 한계를 넘는 composable async
  8. 8 folly::Promise·makeFuture — Future를 만드는 두 길
  9. 9 folly::SemiFuture vs Future — executor binding의 명시화
  10. 10 folly::Future thenValue·thenError·thenTry — continuation 체인 분석
  11. 11 folly::collect·collectAll·collectAny — fan-in 패턴 분석
  12. 12 folly::Future retry·window·via — 제어 흐름 조합자
  13. 13 folly::fibers 분석 — M:N stackful coroutine
  14. 14 folly::InlineExecutor — 호출자 thread에서 즉시 실행
  15. 15 folly::CPUThreadPoolExecutor — CPU-bound 작업의 표준 thread pool
  16. 16 folly::IOThreadPoolExecutor — libevent 기반 I/O pool
  17. 17 folly::ManualExecutor — 결정적 테스트를 위한 수동 진행
  18. 18 folly::EventBase 분석 — libevent 이벤트 루프의 핵심
  19. 19 folly::IOBuf 분석 — zero-copy buffer chain의 기본 단위
  20. 20 folly::IOBufQueue — chain의 push/pull 추상화
  21. 21 folly::io::Cursor·RWCursor — chain 위의 stream
  22. 22 folly Zero-copy 패턴 — IOBuf로 ScatterGather I/O 표현
  23. 23 folly::IOBuf shared semantics — clone·unshare·takeOwnership
  24. 24 folly::FBString 분석 — SSO + COW 구현
  25. 25 folly의 fmt::format 통합 — 모던 포맷팅 채택
  26. 26 folly::StringPiece — string_view 호환 분석
  27. 27 folly Join·Split utilities — 문자열 분해와 결합
  28. 28 folly::to·tryTo — text↔num 변환 분석
  29. 29 folly Conv Customization — 사용자 타입 지원
  30. 30 folly Conv 성능 비교 — sprintf·stringstream 대비
  31. 31 folly::F14ValueMap vs std::unordered_map
  32. 32 folly::F14NodeMap — stable pointer가 필요할 때
  33. 33 folly::F14VectorMap — cache-friendly iteration
  34. 34 folly::F14FastMap — auto-select 동작
  35. 35 folly F14 internals — SIMD probing 메커니즘
  36. 36 folly::small_vector — inline storage 분석
  37. 37 folly::FixedString — compile-time string
  38. 38 folly::AtomicHashMap — lock-free read 분석
  39. 39 folly::ConcurrentHashMap — sharded 동시 해시 맵
  40. 40 folly::EvictingCacheMap — LRU 구현 분석
  41. 41 folly::Synchronized — lock wrapper 패턴
  42. 42 folly::SharedMutex 분석
  43. 43 folly::Baton — one-shot wait 동기화
  44. 44 folly::RWSpinLock 분석
  45. 45 folly::PicoSpinLock — 1-byte spinlock
  46. 46 folly::ProducerConsumerQueue — SPSC 큐 분석
  47. 47 folly::MPMCQueue — multi-producer multi-consumer
  48. 48 folly::UnboundedQueue — 동적 크기 lock-free
  49. 49 folly::fibers::Channel — Go-like channel
  50. 50 folly::dynamic — JSON-like dynamic type 분석
  51. 51 folly JSON conversion — toJson·parseJson
  52. 52 folly dynamic ↔ struct — manual marshaling
  53. 53 folly dynamic Visitor pattern — type별 분기
  54. 54 folly::Singleton vs Meyers/static — 왜 Folly의 Singleton인가
  55. 55 folly::SingletonVault 분석 — 등록·소멸·의존성
  56. 56 folly::Singleton try_get·try_get_fast — TLS-cached 접근
  57. 57 folly::ExceptionWrapper — type-erased exception holder
  58. 58 folly::ScopeGuard·SCOPE_EXIT — RAII cleanup
  59. 59 folly::Optional vs std::optional
  60. 60 folly::Function vs std::function
  61. 61 folly::Lazy — 지연 초기화 wrapper
  62. 62 folly Meta 스타일 code review 패턴
  63. 63 folly anti-patterns — 잘못 쓰면 std보다 느림
  64. 64 folly vs std 선택 기준 분석
  65. 65 folly::coro 개요 — production C++20 코루틴 어댑터
  66. 66 folly::coro::Task — lazy single-shot 코루틴
  67. 67 folly::coro::AsyncGenerator — 비동기 스트림
  68. 68 folly coro blockingWait·collectAll — 동기 경계와 fan-in
  69. 69 folly::coro::Baton·Mutex — 코루틴-aware 동기화
  70. 70 folly::Expected — 결과 또는 오류
  71. 71 folly::Try — Future 결과 wrapper
  72. 72 folly::Try vs Expected 선택 기준
  73. 73 folly::Range — 일반 iterator pair
  74. 74 folly::Uri — URL 파서
  75. 75 folly Fingerprint64·128 — 분산 hash
  76. 76 folly SpookyHashV2 — fast non-crypto hash
  77. 77 folly::Init — main() 부트스트랩
  78. 78 folly::Indestructible — global lifetime 패턴
  79. 79 folly::MicroLock — 1-byte 락
  80. 80 folly::MicroSpinLock — 가장 좁은 spin lock
  81. 81 folly::format — legacy formatter 분석
  82. 82 folly::demangle — typeid 디망글링
  83. 83 folly::DynamicConverter — dynamic ↔ struct
  84. 84 folly::RecordIO — append-only 로그 파일 포맷
  85. 85 folly::io::Compression — zstd·lz4·snappy wrapper
  86. 86 folly::AsyncIO — io_uring·Linux AIO
  87. 87 folly::CancellationToken — 코루틴·Future 취소 전파
  88. 88 folly::observer — hot config의 atomic refresh
  89. 89 fbcode 패턴 모음 — folly 사용의 실전

관련 글

folly::DynamicConverter — dynamic ↔ struct

DynamicConverter의 역할 — folly::dynamic과 user struct 사이 boilerplate 없는 양방향 변환.

· cpp

같은 시리즈에서 이어 읽기

folly dynamic ↔ struct — manual marshaling

Part 11-03: dynamic을 strongly-typed struct로. type safety boundary를 어디에 그을지, marshaling 패턴 비교.

· cpp

같은 시리즈에서 이어 읽기

folly JSON conversion — toJson·parseJson

Part 11-02: toJson / parseJson — folly::dynamic ↔ JSON 문자열. parse 옵션, 성능, schema-less 처리.

· cpp

같은 시리즈에서 이어 읽기

이 글을 참조하는 글 (1)