absl status_macros — ASSIGN_OR_RETURN·RETURN_IF_ERROR

1
absl::Status Process(const std::string& path) {
2
    absl::Status s1 = ValidatePath(path);
3
    if (!s1.ok()) return s1;
4

5
    auto r1 = LoadConfig(path);
6
    if (!r1.ok()) return r1.status();
7
    Config config = *std::move(r1);
8

9
    auto r2 = CreateServer(config);
10
    if (!r2.ok()) return r2.status();
11
    Server server = *std::move(r2);
12

13
    return RunServer(&server);
14
}

1
absl::Status Process(const std::string& path) {
2
    RETURN_IF_ERROR(ValidatePath(path));
3
    ASSIGN_OR_RETURN(Config config, LoadConfig(path));
4
    ASSIGN_OR_RETURN(Server server, CreateServer(config));
5
    return RunServer(&server);
6
}

1
#define RETURN_IF_ERROR(expr) \
2
    do { \
3
        const absl::Status _absl_status_ = (expr); \
4
        if (ABSL_PREDICT_FALSE(!_absl_status_.ok())) return _absl_status_; \
5
    } while (0)

1
RETURN_IF_ERROR(DoStep1());
2
RETURN_IF_ERROR(DoStep2());
3

4
if (cond) RETURN_IF_ERROR(DoIfCond());  // do-while로 안전
5

6
for (int i = 0; i < n; ++i) {
7
    RETURN_IF_ERROR(DoOne(i));
8
}

1
// 기본 형태
2
ASSIGN_OR_RETURN(Config config, LoadConfig(path));
3

4
// 풀면
5
auto _absl_tmp_ = LoadConfig(path);
6
if (!_absl_tmp_.ok()) return _absl_tmp_.status();
7
Config config = *std::move(_absl_tmp_);

1
// 의사 코드
2
#define ASSIGN_OR_RETURN(lhs, rexpr) \
3
    ASSIGN_OR_RETURN_IMPL(\
4
        ABSL_INTERNAL_CONCAT(_status_or_, __LINE__), lhs, rexpr)
5

6
#define ASSIGN_OR_RETURN_IMPL(statusor, lhs, rexpr) \
7
    auto statusor = (rexpr); \
8
    if (ABSL_PREDICT_FALSE(!statusor.ok())) return statusor.status(); \
9
    lhs = *std::move(statusor)

1
// 단순
2
ASSIGN_OR_RETURN(int n, ParseInt("42"));
3

4
// 객체 멤버 접근
5
ASSIGN_OR_RETURN(Config config, LoadConfig(path));
6
LOG(INFO) << "loaded: " << config.name();
7

8
// 기존 변수에 할당 — auto 없이
9
Config config;
10
ASSIGN_OR_RETURN(config, LoadConfig(path));  // 컴파일 에러
11
// 매크로가 `auto`로 가정하지 않음. 새 변수 선언이 보통.

1
absl::Status Pipeline(const std::string& path) {
2
    RETURN_IF_ERROR(ValidatePath(path));
3
    ASSIGN_OR_RETURN(Config config, LoadConfig(path));
4
    RETURN_IF_ERROR(config.Validate());
5
    ASSIGN_OR_RETURN(Server server, CreateServer(config));
6
    RETURN_IF_ERROR(server.Init());
7
    return RunServer(&server);
8
}

1
// 사용자 프로젝트의 status_macros.h
2
#define RETURN_IF_ERROR(expr) \
3
    do { \
4
        const absl::Status _absl_status_ = (expr); \
5
        if (ABSL_PREDICT_FALSE(!_absl_status_.ok())) return _absl_status_; \
6
    } while (0)
7

8
#define ASSIGN_OR_RETURN_IMPL(statusor, lhs, rexpr) \
9
    auto statusor = (rexpr); \
10
    if (ABSL_PREDICT_FALSE(!statusor.ok())) return statusor.status(); \
11
    lhs = *std::move(statusor)
12

13
#define ASSIGN_OR_RETURN(lhs, rexpr) \
14
    ASSIGN_OR_RETURN_IMPL(STATUS_MACROS_CONCAT(_statusor_, __COUNTER__), lhs, rexpr)
15

16
#define STATUS_MACROS_CONCAT_IMPL(x, y) x##y
17
#define STATUS_MACROS_CONCAT(x, y) STATUS_MACROS_CONCAT_IMPL(x, y)

1
#define RETURN_IF_ERROR_PREFIX(expr, prefix) \
2
    do { \
3
        absl::Status _s = (expr); \
4
        if (ABSL_PREDICT_FALSE(!_s.ok())) { \
5
            return absl::Status(_s.code(), \
6
                absl::StrCat(prefix, ": ", _s.message())); \
7
        } \
8
    } while (0)
9

10
// 사용
11
RETURN_IF_ERROR_PREFIX(LoadConfig(path), "loading config");
12
// 에러: "loading config: file not found"

1
// 회피 — 매크로 안의 인자가 부작용 있는 함수
2
RETURN_IF_ERROR(IncrementAndCheck());
3
// 보통은 안전 — _absl_status_에 캐싱됨. 한 번만 호출.
4
// 다만 매크로 정의에 따라 다를 수 있으니 확인.

1
// 회피 — 매크로 안의 인자가 너무 길어 가독성 떨어짐
2
ASSIGN_OR_RETURN(auto result,
3
                 SomeVeryLongFunctionName(argument1, argument2,
4
                                          argument3, argument4));
5
// 한 줄에 모든 게 들어가 읽기 힘듦.
6

7
// Good — 호출을 분리
8
auto temp = SomeVeryLongFunctionName(arg1, arg2, arg3, arg4);
9
ASSIGN_OR_RETURN(auto result, std::move(temp));
10
// 또는 그냥 풀어서
11
auto r = SomeVeryLongFunctionName(...);
12
if (!r.ok()) return r.status();
13
auto result = *std::move(r);

1
// 회피 — 매크로를 if 조건 안에
2
if (RETURN_IF_ERROR(...)) { ... }  // 컴파일 에러
3
// do-while로 감싸진 매크로는 expression이 아님.

1
// 회피 — 매크로를 안 쓰고 매번 손으로
2
auto r = Op();
3
if (!r.ok()) return r.status();
4
auto v = *r;
5
// 자주 반복되면 매크로 사용 검토.
6

7
// Good
8
ASSIGN_OR_RETURN(auto v, Op());

1
// 회피 — 매크로 안에서 추가 처리 시도
2
ASSIGN_OR_RETURN(int x, Parse(s) + 1);  // 어색
3
// `Parse(s) + 1`이 StatusOr<int>를 반환? operator+ 정의 안 됨.
4

5
// Good
6
ASSIGN_OR_RETURN(int x, Parse(s));
7
int y = x + 1;

1
// 회피 — 매크로 매번 작성
2
absl::Status MyFunc() {
3
    auto s = ...;
4
    if (!s.ok()) return s;
5
    // 5번 더 반복
6
}
7
// 매번 손으로. 매크로로 옮길 것.

1
// 회피 — 매크로 안의 변수 이름과 사용자 변수 충돌
2
absl::Status _absl_status_ = ...;  // 매크로 내부 이름과 충돌
3
RETURN_IF_ERROR(Op());  // 일부 구현에서 깨질 수 있음
4
// 매크로 내부 이름을 모르면 충돌 위험. _ 접두사 변수는 보통 reserved.

1
// std::expected — C++23
2
std::expected<int, MyError> r = ParseInt(s)
3
    .transform([](int n) { return n * 2; })
4
    .and_then([](int n) { return Validate(n); });