folly dynamic ↔ struct — manual marshaling

1
[ JSON string ]
2
        ↓ parseJson
3
[ dynamic ]                  ← 여기까지가 boundary
4
        ↓ fromDynamic
5
[ User struct ]              ← 이후는 type-safe
6
        ↓ business logic
7
[ User struct ]
8
        ↓ toDynamic
9
[ dynamic ]
10
        ↓ toJson
11
[ JSON string ]

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

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

17
folly::dynamic userToDynamic(const User& u) {
18
  folly::dynamic arr = folly::dynamic::array;
19
  for (auto& r : u.roles) arr.push_back(r);
20
  return folly::dynamic::object
21
    ("name", u.name)
22
    ("age", u.age)
23
    ("roles", std::move(arr));
24
}

1
folly::Expected<User, std::string> tryUserFromDynamic(const folly::dynamic& d) {
2
  if (!d.isObject()) return folly::makeUnexpected("not object");
3
  if (!d.count("name")) return folly::makeUnexpected("missing name");
4

5
  const auto& nameD = d["name"];
6
  if (!nameD.isString()) return folly::makeUnexpected("name not string");
7

8
  User u;
9
  u.name = nameD.getString();
10

11
  // age는 optional, default 0
12
  u.age = d.getDefault("age", 0).asInt();
13

14
  // roles는 optional, default []
15
  if (d.count("roles")) {
16
    if (!d["roles"].isArray()) return folly::makeUnexpected("roles not array");
17
    for (const auto& r : d["roles"]) {
18
      if (!r.isString()) return folly::makeUnexpected("role not string");
19
      u.roles.push_back(r.getString());
20
    }
21
  }
22
  return u;
23
}

1
template <typename T>
2
T getOrThrow(const folly::dynamic& d, const std::string& key);
3

4
template <>
5
std::string getOrThrow(const folly::dynamic& d, const std::string& key) {
6
  if (!d.count(key)) throw std::runtime_error("missing: " + key);
7
  const auto& v = d[key];
8
  if (!v.isString()) throw std::runtime_error("type: " + key);
9
  return v.getString();
10
}
11

12
template <>
13
int64_t getOrThrow(const folly::dynamic& d, const std::string& key) {
14
  if (!d.count(key)) throw std::runtime_error("missing: " + key);
15
  const auto& v = d[key];
16
  if (!v.isInt()) throw std::runtime_error("type: " + key);
17
  return v.getInt();
18
}
19

20
// 사용
21
User u;
22
u.name = getOrThrow<std::string>(d, "name");
23
u.age  = getOrThrow<int64_t>(d, "age");

1
// 회피 — 여러 곳에서 dynamic ↔ struct 변환
2
void handlerA(folly::dynamic d) {
3
  auto u = parseUser(d);
4
  ...
5
}
6
void handlerB(folly::dynamic d) {
7
  // 또 parsing
8
}
9

10
// Good — boundary 한 군데
11
User parseUser(const folly::dynamic& d);  // 한 군데서 정의
12
void handlerA(const User& u);             // 이후는 struct만
13
void handlerB(const User& u);

1
// 회피 — 외부 JSON에 asInt
2
u.age = d["age"].asInt();   // "30"도 30으로 받아들임 (silent drift)
3

4
// Good — strict
5
if (!d["age"].isInt()) throw ...;
6
u.age = d["age"].getInt();

1
// 옵션 1 — silent ignore (포워드 호환 위해)
2
auto u = parseUser(d); // d에 unknown 키 있어도 무시
3

4
// 옵션 2 — strict (오타 잡기 위해)
5
for (auto& k : d.keys()) {
6
  if (!known_keys.count(k.asString())) {
7
    throw "unknown key: " + k.asString();
8
  }
9
}

1
struct User {
2
  std::string name;
3
  int age;
4
  std::optional<std::string> email; // optional
5
};
6

7
User parseUser(const folly::dynamic& d) {
8
  User u;
9
  u.name = getOrThrow<std::string>(d, "name");
10
  u.age  = getOrThrow<int64_t>(d, "age");
11
  if (d.count("email") && d["email"].isString()) {
12
    u.email = d["email"].getString();
13
  }
14
  return u;
15
}

1
// 회피
2
void deepInnerLogic(folly::dynamic d) {
3
  // 5단계 깊은 곳에서도 d["x"]["y"] 접근
4
}

1
// 회피 — 같은 dynamic을 반복 parsing
2
for (auto& req : requests) {
3
  auto u = parseUser(req.body); // 매번 throw 가능
4
  process(u);
5
}
6

7
// 변환 실패 처리 명확화
8
for (auto& req : requests) {
9
  auto userOrErr = tryParseUser(req.body);
10
  if (userOrErr.hasError()) { /* log */ continue; }
11
  process(*userOrErr);
12
}

1
// 회피
2
auto d = userToDynamic(u);
3
auto u2 = userFromDynamic(d); // copy 의도면 그냥 auto u2 = u;