Folly Code Review · 82/89

folly::DynamicConverter — dynamic ↔ struct

2026년 6월 8일 · Hawk · 3분 읽기

한 줄 요약: DynamicConverter는 folly::dynamic과 사용자 struct 사이를 변환하는 traits 기반 framework다. JSON → struct, struct → JSON을 boilerplate 없이 처리하기 위해 만들어졌다.

#동기

JSON ↔ struct 변환을 직접 짜면 매번 같은 boilerplate가 쌓인다.

1
struct User {
2
  std::string name;
3
  int         age;
4
  std::vector<std::string> emails;
5
};
6

7
User FromDynamic(const folly::dynamic& d) {
8
  User u;
9
  u.name = d["name"].asString();
10
  u.age  = d["age"].asInt();
11
  for (const auto& e : d["emails"]) u.emails.push_back(e.asString());
12
  return u;
13
}
14

15
folly::dynamic ToDynamic(const User& u) {
16
  auto d = folly::dynamic::object;
17
  d["name"] = u.name;
18
  d["age"]  = u.age;
19
  d["emails"] = folly::dynamic::array;
20
  for (const auto& e : u.emails) d["emails"].push_back(e);
21
  return d;
22
}

50% 코드가 “필드를 베껴라”. 더구나 nested struct, optional, variant 등이 등장하면 폭발.

DynamicConverter는 traits 특수화로 변환 규칙을 등록하면 folly::convertTo<T>(dyn) / folly::toDynamic(obj) 한 줄로 끝난다.

1
auto u = folly::convertTo<User>(d);
2
auto d = folly::toDynamic(u);

조건: User의 변환 규칙을 어딘가에 한 번 정의해야.

#API

1
#include <folly/DynamicConverter.h>
2

3
// built-in 타입은 즉시 변환
4
folly::dynamic d = 42;
5
int i = folly::convertTo<int>(d);   // 42
6

7
folly::dynamic arr = folly::dynamic::array(1, 2, 3);
8
std::vector<int> v = folly::convertTo<std::vector<int>>(arr);   // [1,2,3]
9

10
folly::dynamic obj = folly::dynamic::object("a", 1)("b", 2);
11
std::map<std::string, int> m = folly::convertTo<std::map<std::string, int>>(obj);

기본적으로 int, double, string, vector, map, set, pair, tuple 같은 STL 타입이 지원된다.

#사용자 타입 등록

1
struct Point {
2
  int x, y;
3
};
4

5
namespace folly {
6

7
template <>
8
struct DynamicConverter<Point> {
9
  static Point convert(const dynamic& d) {
10
    return Point{
11
      convertTo<int>(d["x"]),
12
      convertTo<int>(d["y"]),
13
    };
14
  }
15
};
16

17
template <>
18
struct DynamicConstructor<Point> {
19
  static dynamic construct(const Point& p) {
20
    return dynamic::object("x", p.x)("y", p.y);
21
  }
22
};
23

24
}
25

26
void Use() {
27
  Point p{3, 4};
28
  auto d = folly::toDynamic(p);
29
  auto p2 = folly::convertTo<Point>(d);
30
}

두 traits.

DynamicConverter<T>::convert(const dynamic&) — dynamic → T.
DynamicConstructor<T>::construct(const T&) — T → dynamic.

convertTo<T>(d)와 toDynamic(obj)는 각각 이 traits를 호출.

#Nested 타입 자동 처리

1
struct Address { std::string city; int zip; };
2
struct User    { std::string name; Address addr; };
3

4
// Address, User 모두 traits 정의됐다면
5
auto d = folly::toDynamic(user);
6
auto u2 = folly::convertTo<User>(d);

Address가 등록되면 User의 addr 필드도 자동 변환. convertTo<User>가 내부에서 convertTo<Address>를 호출.

std::vector<User>, std::map<std::string, User> 같은 컨테이너도 traits 합성으로 처리.

#내부 구현

1
// folly/DynamicConverter.h 약식
2
template <class T>
3
struct DynamicConverter {
4
  static T convert(const dynamic& d) {
5
    return T(d);  // default — T가 dynamic 받는 생성자가 있으면
6
  }
7
};
8

9
// vector 부분 특수화
10
template <class T>
11
struct DynamicConverter<std::vector<T>> {
12
  static std::vector<T> convert(const dynamic& d) {
13
    std::vector<T> out;
14
    out.reserve(d.size());
15
    for (const auto& e : d) {
16
      out.push_back(convertTo<T>(e));   // 재귀
17
    }
18
    return out;
19
  }
20
};
21

22
template <class K, class V>
23
struct DynamicConverter<std::map<K, V>> {
24
  static std::map<K, V> convert(const dynamic& d) {
25
    std::map<K, V> out;
26
    for (const auto& kv : d.items()) {
27
      out.emplace(convertTo<K>(kv.first), convertTo<V>(kv.second));
28
    }
29
    return out;
30
  }
31
};
32

33
// 사용자가 특수화하는 자리
34
// template <> struct DynamicConverter<MyType> { ... };

핵심 idea는 컨테이너 trait + element trait의 재귀 합성. Boost.Hana나 reflection 라이브러리와 같은 모델.

#Optional / Variant

1
template <class T>
2
struct DynamicConverter<std::optional<T>> {
3
  static std::optional<T> convert(const dynamic& d) {
4
    if (d.isNull()) return std::nullopt;
5
    return convertTo<T>(d);
6
  }
7
};

optional은 null이면 nullopt, 아니면 inner T 변환. null 처리가 명시적.

variant는 어떤 alternative인지 추론이 필요해 사용자가 직접 traits를 짜야 한다.

#std와의 비교

항목	std (없음)	folly::DynamicConverter	nlohmann::json	Boost.PFR
JSON 인터페이스	N/A	folly::dynamic	자체 json	N/A
사용자 타입	N/A	traits 특수화	ADL (from_json/to_json)	자동 reflection (구조체만)
boilerplate	N/A	traits 한 번	from_json/to_json 한 번	0 (자동)
optional/variant	N/A	optional 자동	optional 자동	어려움
표준	N/A	folly	외부	외부

nlohmann::json은 ADL 기반이라 더 친숙. folly::DynamicConverter는 fbcode 내부 dynamic 생태계에 맞춰진 형태. 기능은 비슷.

Boost.PFR (Precise Reflection)은 단순 구조체에 한해 자동 변환 (C++26 reflection의 미리보기). 복잡한 타입은 traits가 여전히 필요.

#실전 — config struct

1
struct ServerConfig {
2
  std::string host;
3
  int port;
4
  std::vector<std::string> allowedOrigins;
5
  std::map<std::string, int> rateLimits;
6
};
7

8
namespace folly {
9
template <> struct DynamicConverter<ServerConfig> {
10
  static ServerConfig convert(const dynamic& d) {
11
    return ServerConfig{
12
      convertTo<std::string>(d["host"]),
13
      convertTo<int>(d["port"]),
14
      convertTo<std::vector<std::string>>(d["allowed_origins"]),
15
      convertTo<std::map<std::string, int>>(d["rate_limits"]),
16
    };
17
  }
18
};
19
}
20

21
void LoadConfig() {
22
  std::string text = ReadFile("config.json");
23
  auto d = folly::parseJson(text);
24
  auto cfg = folly::convertTo<ServerConfig>(d);
25
}

config 로딩 패턴. JSON → struct가 한 줄.

#코드 리뷰 포인트

사용자 traits를 같은 namespace에 두지 않으면 ADL/특수화 매칭 실패.
nested struct 변환이 매번 새 dynamic을 만들고 다시 변환 → 성능 hot path면 직접 처리.
traits에 noexcept를 안 붙여 변환 실패 시 throw 흐름이 다를 수 있음.
field 이름 typo는 runtime 발견 (d["hsot"]이 null로 반환). reflection 없는 만큼 신중.
C++23 reflection이 들어오면 traits boilerplate가 사라진다 — 미래 마이그레이션 가능성.

#자주 보는 안티패턴

1
// 1. dynamic→struct 변환을 매번 매뉴얼로
2
User FromDyn(const dynamic& d) { /* 10 라인 */ }
3
// → DynamicConverter traits로 한 번 정의 후 convertTo<User>(d)
4

5
// 2. dynamic을 멤버로 보관
6
struct Config {
7
  folly::dynamic raw;   // type-erased 채로 사용
8
};
9
// → struct로 변환 후 type-safe 사용이 옳음
10

11
// 3. dynamic 변환을 hot path에서 매번
12
for (auto& obj : list) {
13
  auto u = folly::convertTo<User>(obj);   // 매번 traits dispatch
14
  Process(u);
15
}
16
// → 가능하면 한 번에 vector<User>로 변환 후 iterate
17

18
// 4. field 누락 시 default 처리 안 함
19
auto port = convertTo<int>(d["port"]);   // port key 없으면 throw
20
// → optional 또는 d.getDefault("port", 8080) 명시