folly::ExceptionWrapper — type-erased exception holder

1
std::exception_ptr ep;
2
try { throw std::runtime_error("oops"); }
3
catch (...) { ep = std::current_exception(); }
4

5
// 다른 스레드에서
6
try { std::rethrow_exception(ep); }
7
catch (const std::exception& e) { LOG(ERROR) << e.what(); }

1
#include <folly/ExceptionWrapper.h>
2

3
folly::exception_wrapper ew = folly::make_exception_wrapper<std::runtime_error>("oops");
4

5
// throw 없이 검사
6
if (ew.is_compatible_with<std::runtime_error>()) {
7
  LOG(ERROR) << ew.class_name() << ": " << ew.what();
8
}
9

10
// 핸들러로 분기 (throw 없이)
11
ew.handle(
12
  [](const std::runtime_error& e) { handleRuntime(e); },
13
  [](const std::exception& e) { handleStd(e); },
14
  [] { handleUnknown(); }
15
);
16

17
// 필요하면 throw
18
ew.throw_exception();

1
class exception_wrapper {
2
  enum Mode { Empty, Inline, Exception_Ptr };
3
  Mode mode_;
4

5
  union {
6
    InlineStorage inline_;       // SBO — 작은 exception은 인라인
7
    std::exception_ptr eptr_;    // 큰 경우 fallback
8
  };
9

10
  const std::type_info* type_;   // type 정보
11
  std::string what_;             // 미리 추출
12
};

1
folly::Future<int> compute() {
2
  return folly::makeFuture<int>(folly::exception_wrapper(
3
    std::runtime_error("bad")));
4
}
5

6
future.thenTry([](folly::Try<int> t) {
7
  if (t.hasException()) {
8
    auto& ew = t.exception(); // exception_wrapper&
9
    LOG(ERROR) << ew.what();
10
  }
11
});

1
ew.handle(
2
  [](const std::system_error& e) { /* OS error */ },
3
  [](const std::runtime_error& e) { /* logic error */ },
4
  [](const std::exception& e) { /* generic */ },
5
  [] { /* non-std exception */ }
6
);

1
ew.with_exception([](const std::runtime_error& e) {
2
  LOG(ERROR) << e.what();
3
}); // 다른 type이면 false 반환

1
// 회피 — async에서 throw
2
folly::Future<int> f = doAsync().then([] {
3
  throw std::runtime_error("oops"); // future가 잡아 exception_ptr로 변환
4
});
5

6
// Good — exception_wrapper로 직접
7
folly::Future<int> f = folly::makeFuture<int>(
8
  folly::make_exception_wrapper<std::runtime_error>("oops"));

1
// 회피 — base가 먼저
2
ew.handle(
3
  [](const std::exception& e) { ... },     // 모든 std::exception 매칭
4
  [](const std::runtime_error& e) { ... }  // 절대 도달 안 함
5
);
6

7
// Good — derived가 먼저
8
ew.handle(
9
  [](const std::runtime_error& e) { ... },
10
  [](const std::exception& e) { ... }
11
);

1
// 회피
2
ew.with_exception([](const std::runtime_error& e) { ... });
3
// runtime_error가 아니면 silent
4

5
// Good
6
if (!ew.with_exception(...)) {
7
  LOG(WARNING) << "Unexpected exception: " << ew.class_name();
8
}

1
// API boundary
2
int doWork() {
3
  auto result = futureWork().get(); // Try<int>
4
  if (result.hasException()) {
5
    result.exception().throw_exception(); // 여기서만 throw
6
  }
7
  return result.value();
8
}

1
// 회피 — 콜백마다 wrapper 생성
2
.thenTry([](folly::Try<int> t) {
3
  if (t.hasException()) {
4
    auto ew = folly::exception_wrapper(t.exception()); // 이미 wrapper인데 wrap
5
  }
6
});
7

8
// Good
9
.thenTry([](folly::Try<int> t) {
10
  if (t.hasException()) {
11
    auto& ew = t.exception(); // 이미 wrapper
12
  }
13
});

1
// 회피 — 왕복
2
try { ew.throw_exception(); }
3
catch (...) { auto ew2 = folly::exception_wrapper(); ... }

1
// 회피
2
ew.with_exception([](const std::exception& e) { ... });
3
// 사용자 정의 비-std 예외 누락