Abseil Flag introspection·validation

1
#include "absl/flags/flag.h"
2

3
ABSL_FLAG(int32_t, port, 8080, "HTTP port");
4

5
static const auto port_validator = []() {
6
    int32_t p = absl::GetFlag(FLAGS_port);
7
    if (p <= 0 || p > 65535) {
8
        LOG(FATAL) << "invalid --port: " << p;
9
    }
10
    return true;
11
}();

1
struct LogLevel {
2
    enum Value { kDebug, kInfo, kWarn, kError } value;
3
};
4

5
bool AbslParseFlag(absl::string_view text, LogLevel* out, std::string* error) {
6
    if (text == "debug")      { out->value = LogLevel::kDebug; return true; }
7
    if (text == "info")       { out->value = LogLevel::kInfo; return true; }
8
    if (text == "warn")       { out->value = LogLevel::kWarn; return true; }
9
    if (text == "error")      { out->value = LogLevel::kError; return true; }
10
    *error = absl::StrCat("expected debug/info/warn/error, got ", text);
11
    return false;
12
}
13

14
std::string AbslUnparseFlag(LogLevel level) {
15
    switch (level.value) {
16
        case LogLevel::kDebug: return "debug";
17
        case LogLevel::kInfo: return "info";
18
        case LogLevel::kWarn: return "warn";
19
        case LogLevel::kError: return "error";
20
    }
21
    return "?";
22
}
23

24
ABSL_FLAG(LogLevel, log_level, LogLevel{LogLevel::kInfo}, "logging level");

1
enum class Verbosity { kQuiet, kNormal, kVerbose, kDebug };
2

3
bool AbslParseFlag(absl::string_view text, Verbosity* v, std::string* err) {
4
    static const auto kMap = absl::flat_hash_map<absl::string_view, Verbosity>{
5
        {"quiet", Verbosity::kQuiet},
6
        {"normal", Verbosity::kNormal},
7
        {"verbose", Verbosity::kVerbose},
8
        {"debug", Verbosity::kDebug},
9
    };
10
    auto it = kMap.find(text);
11
    if (it == kMap.end()) {
12
        *err = absl::StrCat("unknown verbosity: ", text);
13
        return false;
14
    }
15
    *v = it->second;
16
    return true;
17
}
18

19
std::string AbslUnparseFlag(Verbosity v) {
20
    switch (v) {
21
        case Verbosity::kQuiet: return "quiet";
22
        case Verbosity::kNormal: return "normal";
23
        case Verbosity::kVerbose: return "verbose";
24
        case Verbosity::kDebug: return "debug";
25
    }
26
    return "?";
27
}
28

29
ABSL_FLAG(Verbosity, verbosity, Verbosity::kNormal, "logging verbosity");

1
struct PortNumber {
2
    uint16_t value;
3
};
4

5
bool AbslParseFlag(absl::string_view text, PortNumber* p, std::string* err) {
6
    int n;
7
    if (!absl::SimpleAtoi(text, &n)) {
8
        *err = absl::StrCat("not a number: ", text);
9
        return false;
10
    }
11
    if (n <= 0 || n > 65535) {
12
        *err = absl::StrCat("out of range [1, 65535]: ", n);
13
        return false;
14
    }
15
    p->value = static_cast<uint16_t>(n);
16
    return true;
17
}
18

19
std::string AbslUnparseFlag(PortNumber p) { return absl::StrCat(p.value); }
20

21
ABSL_FLAG(PortNumber, port, PortNumber{8080}, "HTTP port");

1
#include "absl/flags/reflection.h"
2

3
const absl::CommandLineFlag* f = absl::FindCommandLineFlag("port");
4
if (f) {
5
    LOG(INFO) << "name: " << f->Name();
6
    LOG(INFO) << "help: " << f->Help();
7
    LOG(INFO) << "type: " << f->Typename();
8
    LOG(INFO) << "current: " << f->CurrentValue();
9
    LOG(INFO) << "default: " << f->DefaultValue();
10
}

1
absl::flags_internal::ForEachFlag([](absl::CommandLineFlag& f) {
2
    LOG(INFO) << f.Name() << " = " << f.CurrentValue();
3
});

1
absl::SetFlag(&FLAGS_port, 9090);   // 타입 안전
2

3
// 이름(문자열)으로 설정하려면 reflection API를 거친다
4
std::string err;
5
absl::FindCommandLineFlag("port")->ParseFrom("9090", &err);

1
const bool verbose = absl::GetFlag(FLAGS_verbose);   // 캡처
2
absl::SetFlag(&FLAGS_verbose, true);
3
if (verbose) { ... }   // 여전히 이전 값

1
void HandleSetFlag(absl::string_view name, absl::string_view value) {
2
    auto* f = absl::FindCommandLineFlag(std::string(name));
3
    if (!f) {
4
        Respond(404, "no such flag");
5
        return;
6
    }
7
    std::string err;
8
    if (!f->ParseFrom(value, &err)) {
9
        Respond(400, absl::StrCat("invalid value: ", err));
10
        return;
11
    }
12
    LOG(INFO) << "flag changed: " << name << " = " << value;
13
    Respond(200, "ok");
14
}

1
// 회피 — custom type validation 누락
2
bool AbslParseFlag(absl::string_view text, MyType* m, std::string* err) {
3
    m->value = ParseSomething(text);   // ❌ 항상 true 반환
4
    return true;
5
}
6

7
// Good — 검증
8
bool AbslParseFlag(absl::string_view text, MyType* m, std::string* err) {
9
    if (!Validate(text, err)) return false;
10
    m->value = ParseSomething(text);
11
    return true;
12
}

1
// 회피 — int flag로 enum 표현
2
ABSL_FLAG(int, log_level, 2, "0=debug, 1=info, 2=warn, 3=error");   // ❌ 의미 모호
3

4
// Good — enum + custom parser
5
ABSL_FLAG(LogLevel, log_level, LogLevel::kWarn, "...");

1
// 회피 — 런타임 변경에 의존하면서 캡처
2
int worker_count = absl::GetFlag(FLAGS_workers);
3
StartPool(worker_count);
4
// 이후 SetFlag(workers, ...) 해도 풀 크기 안 바뀜