Abseil Common Libraries (C++) (grcp 依赖)
https://abseil.io/
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
617 lines
19 KiB
617 lines
19 KiB
// Copyright 2019 The Abseil Authors. |
|
// |
|
// Licensed under the Apache License, Version 2.0 (the "License"); |
|
// you may not use this file except in compliance with the License. |
|
// You may obtain a copy of the License at |
|
// |
|
// https://www.apache.org/licenses/LICENSE-2.0 |
|
// |
|
// Unless required by applicable law or agreed to in writing, software |
|
// distributed under the License is distributed on an "AS IS" BASIS, |
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
|
// See the License for the specific language governing permissions and |
|
// limitations under the License. |
|
#include "absl/status/status.h" |
|
|
|
#include <errno.h> |
|
|
|
#include <cassert> |
|
|
|
#include "absl/base/internal/raw_logging.h" |
|
#include "absl/base/internal/strerror.h" |
|
#include "absl/debugging/stacktrace.h" |
|
#include "absl/debugging/symbolize.h" |
|
#include "absl/status/status_payload_printer.h" |
|
#include "absl/strings/escaping.h" |
|
#include "absl/strings/str_cat.h" |
|
#include "absl/strings/str_format.h" |
|
#include "absl/strings/str_split.h" |
|
|
|
namespace absl { |
|
ABSL_NAMESPACE_BEGIN |
|
|
|
std::string StatusCodeToString(StatusCode code) { |
|
switch (code) { |
|
case StatusCode::kOk: |
|
return "OK"; |
|
case StatusCode::kCancelled: |
|
return "CANCELLED"; |
|
case StatusCode::kUnknown: |
|
return "UNKNOWN"; |
|
case StatusCode::kInvalidArgument: |
|
return "INVALID_ARGUMENT"; |
|
case StatusCode::kDeadlineExceeded: |
|
return "DEADLINE_EXCEEDED"; |
|
case StatusCode::kNotFound: |
|
return "NOT_FOUND"; |
|
case StatusCode::kAlreadyExists: |
|
return "ALREADY_EXISTS"; |
|
case StatusCode::kPermissionDenied: |
|
return "PERMISSION_DENIED"; |
|
case StatusCode::kUnauthenticated: |
|
return "UNAUTHENTICATED"; |
|
case StatusCode::kResourceExhausted: |
|
return "RESOURCE_EXHAUSTED"; |
|
case StatusCode::kFailedPrecondition: |
|
return "FAILED_PRECONDITION"; |
|
case StatusCode::kAborted: |
|
return "ABORTED"; |
|
case StatusCode::kOutOfRange: |
|
return "OUT_OF_RANGE"; |
|
case StatusCode::kUnimplemented: |
|
return "UNIMPLEMENTED"; |
|
case StatusCode::kInternal: |
|
return "INTERNAL"; |
|
case StatusCode::kUnavailable: |
|
return "UNAVAILABLE"; |
|
case StatusCode::kDataLoss: |
|
return "DATA_LOSS"; |
|
default: |
|
return ""; |
|
} |
|
} |
|
|
|
std::ostream& operator<<(std::ostream& os, StatusCode code) { |
|
return os << StatusCodeToString(code); |
|
} |
|
|
|
namespace status_internal { |
|
|
|
static int FindPayloadIndexByUrl(const Payloads* payloads, |
|
absl::string_view type_url) { |
|
if (payloads == nullptr) return -1; |
|
|
|
for (size_t i = 0; i < payloads->size(); ++i) { |
|
if ((*payloads)[i].type_url == type_url) return i; |
|
} |
|
|
|
return -1; |
|
} |
|
|
|
// Convert canonical code to a value known to this binary. |
|
absl::StatusCode MapToLocalCode(int value) { |
|
absl::StatusCode code = static_cast<absl::StatusCode>(value); |
|
switch (code) { |
|
case absl::StatusCode::kOk: |
|
case absl::StatusCode::kCancelled: |
|
case absl::StatusCode::kUnknown: |
|
case absl::StatusCode::kInvalidArgument: |
|
case absl::StatusCode::kDeadlineExceeded: |
|
case absl::StatusCode::kNotFound: |
|
case absl::StatusCode::kAlreadyExists: |
|
case absl::StatusCode::kPermissionDenied: |
|
case absl::StatusCode::kResourceExhausted: |
|
case absl::StatusCode::kFailedPrecondition: |
|
case absl::StatusCode::kAborted: |
|
case absl::StatusCode::kOutOfRange: |
|
case absl::StatusCode::kUnimplemented: |
|
case absl::StatusCode::kInternal: |
|
case absl::StatusCode::kUnavailable: |
|
case absl::StatusCode::kDataLoss: |
|
case absl::StatusCode::kUnauthenticated: |
|
return code; |
|
default: |
|
return absl::StatusCode::kUnknown; |
|
} |
|
} |
|
} // namespace status_internal |
|
|
|
absl::optional<absl::Cord> Status::GetPayload( |
|
absl::string_view type_url) const { |
|
const auto* payloads = GetPayloads(); |
|
int index = status_internal::FindPayloadIndexByUrl(payloads, type_url); |
|
if (index != -1) return (*payloads)[index].payload; |
|
|
|
return absl::nullopt; |
|
} |
|
|
|
void Status::SetPayload(absl::string_view type_url, absl::Cord payload) { |
|
if (ok()) return; |
|
|
|
PrepareToModify(); |
|
|
|
status_internal::StatusRep* rep = RepToPointer(rep_); |
|
if (!rep->payloads) { |
|
rep->payloads = absl::make_unique<status_internal::Payloads>(); |
|
} |
|
|
|
int index = |
|
status_internal::FindPayloadIndexByUrl(rep->payloads.get(), type_url); |
|
if (index != -1) { |
|
(*rep->payloads)[index].payload = std::move(payload); |
|
return; |
|
} |
|
|
|
rep->payloads->push_back({std::string(type_url), std::move(payload)}); |
|
} |
|
|
|
bool Status::ErasePayload(absl::string_view type_url) { |
|
int index = status_internal::FindPayloadIndexByUrl(GetPayloads(), type_url); |
|
if (index != -1) { |
|
PrepareToModify(); |
|
GetPayloads()->erase(GetPayloads()->begin() + index); |
|
if (GetPayloads()->empty() && message().empty()) { |
|
// Special case: If this can be represented inlined, it MUST be |
|
// inlined (EqualsSlow depends on this behavior). |
|
StatusCode c = static_cast<StatusCode>(raw_code()); |
|
Unref(rep_); |
|
rep_ = CodeToInlinedRep(c); |
|
} |
|
return true; |
|
} |
|
|
|
return false; |
|
} |
|
|
|
void Status::ForEachPayload( |
|
absl::FunctionRef<void(absl::string_view, const absl::Cord&)> visitor) |
|
const { |
|
if (auto* payloads = GetPayloads()) { |
|
bool in_reverse = |
|
payloads->size() > 1 && reinterpret_cast<uintptr_t>(payloads) % 13 > 6; |
|
|
|
for (size_t index = 0; index < payloads->size(); ++index) { |
|
const auto& elem = |
|
(*payloads)[in_reverse ? payloads->size() - 1 - index : index]; |
|
|
|
#ifdef NDEBUG |
|
visitor(elem.type_url, elem.payload); |
|
#else |
|
// In debug mode invalidate the type url to prevent users from relying on |
|
// this string lifetime. |
|
|
|
// NOLINTNEXTLINE intentional extra conversion to force temporary. |
|
visitor(std::string(elem.type_url), elem.payload); |
|
#endif // NDEBUG |
|
} |
|
} |
|
} |
|
|
|
const std::string* Status::EmptyString() { |
|
static union EmptyString { |
|
std::string str; |
|
~EmptyString() {} |
|
} empty = {{}}; |
|
return &empty.str; |
|
} |
|
|
|
#ifdef ABSL_INTERNAL_NEED_REDUNDANT_CONSTEXPR_DECL |
|
constexpr const char Status::kMovedFromString[]; |
|
#endif |
|
|
|
const std::string* Status::MovedFromString() { |
|
static std::string* moved_from_string = new std::string(kMovedFromString); |
|
return moved_from_string; |
|
} |
|
|
|
void Status::UnrefNonInlined(uintptr_t rep) { |
|
status_internal::StatusRep* r = RepToPointer(rep); |
|
// Fast path: if ref==1, there is no need for a RefCountDec (since |
|
// this is the only reference and therefore no other thread is |
|
// allowed to be mucking with r). |
|
if (r->ref.load(std::memory_order_acquire) == 1 || |
|
r->ref.fetch_sub(1, std::memory_order_acq_rel) - 1 == 0) { |
|
delete r; |
|
} |
|
} |
|
|
|
Status::Status(absl::StatusCode code, absl::string_view msg) |
|
: rep_(CodeToInlinedRep(code)) { |
|
if (code != absl::StatusCode::kOk && !msg.empty()) { |
|
rep_ = PointerToRep(new status_internal::StatusRep(code, msg, nullptr)); |
|
} |
|
} |
|
|
|
int Status::raw_code() const { |
|
if (IsInlined(rep_)) { |
|
return static_cast<int>(InlinedRepToCode(rep_)); |
|
} |
|
status_internal::StatusRep* rep = RepToPointer(rep_); |
|
return static_cast<int>(rep->code); |
|
} |
|
|
|
absl::StatusCode Status::code() const { |
|
return status_internal::MapToLocalCode(raw_code()); |
|
} |
|
|
|
void Status::PrepareToModify() { |
|
ABSL_RAW_CHECK(!ok(), "PrepareToModify shouldn't be called on OK status."); |
|
if (IsInlined(rep_)) { |
|
rep_ = PointerToRep(new status_internal::StatusRep( |
|
static_cast<absl::StatusCode>(raw_code()), absl::string_view(), |
|
nullptr)); |
|
return; |
|
} |
|
|
|
uintptr_t rep_i = rep_; |
|
status_internal::StatusRep* rep = RepToPointer(rep_); |
|
if (rep->ref.load(std::memory_order_acquire) != 1) { |
|
std::unique_ptr<status_internal::Payloads> payloads; |
|
if (rep->payloads) { |
|
payloads = absl::make_unique<status_internal::Payloads>(*rep->payloads); |
|
} |
|
status_internal::StatusRep* const new_rep = new status_internal::StatusRep( |
|
rep->code, message(), std::move(payloads)); |
|
rep_ = PointerToRep(new_rep); |
|
UnrefNonInlined(rep_i); |
|
} |
|
} |
|
|
|
bool Status::EqualsSlow(const absl::Status& a, const absl::Status& b) { |
|
if (IsInlined(a.rep_) != IsInlined(b.rep_)) return false; |
|
if (a.message() != b.message()) return false; |
|
if (a.raw_code() != b.raw_code()) return false; |
|
if (a.GetPayloads() == b.GetPayloads()) return true; |
|
|
|
const status_internal::Payloads no_payloads; |
|
const status_internal::Payloads* larger_payloads = |
|
a.GetPayloads() ? a.GetPayloads() : &no_payloads; |
|
const status_internal::Payloads* smaller_payloads = |
|
b.GetPayloads() ? b.GetPayloads() : &no_payloads; |
|
if (larger_payloads->size() < smaller_payloads->size()) { |
|
std::swap(larger_payloads, smaller_payloads); |
|
} |
|
if ((larger_payloads->size() - smaller_payloads->size()) > 1) return false; |
|
// Payloads can be ordered differently, so we can't just compare payload |
|
// vectors. |
|
for (const auto& payload : *larger_payloads) { |
|
|
|
bool found = false; |
|
for (const auto& other_payload : *smaller_payloads) { |
|
if (payload.type_url == other_payload.type_url) { |
|
if (payload.payload != other_payload.payload) { |
|
return false; |
|
} |
|
found = true; |
|
break; |
|
} |
|
} |
|
if (!found) return false; |
|
} |
|
return true; |
|
} |
|
|
|
std::string Status::ToStringSlow(StatusToStringMode mode) const { |
|
std::string text; |
|
absl::StrAppend(&text, absl::StatusCodeToString(code()), ": ", message()); |
|
|
|
const bool with_payload = (mode & StatusToStringMode::kWithPayload) == |
|
StatusToStringMode::kWithPayload; |
|
|
|
if (with_payload) { |
|
status_internal::StatusPayloadPrinter printer = |
|
status_internal::GetStatusPayloadPrinter(); |
|
this->ForEachPayload([&](absl::string_view type_url, |
|
const absl::Cord& payload) { |
|
absl::optional<std::string> result; |
|
if (printer) result = printer(type_url, payload); |
|
absl::StrAppend( |
|
&text, " [", type_url, "='", |
|
result.has_value() ? *result : absl::CHexEscape(std::string(payload)), |
|
"']"); |
|
}); |
|
} |
|
|
|
return text; |
|
} |
|
|
|
std::ostream& operator<<(std::ostream& os, const Status& x) { |
|
os << x.ToString(StatusToStringMode::kWithEverything); |
|
return os; |
|
} |
|
|
|
Status AbortedError(absl::string_view message) { |
|
return Status(absl::StatusCode::kAborted, message); |
|
} |
|
|
|
Status AlreadyExistsError(absl::string_view message) { |
|
return Status(absl::StatusCode::kAlreadyExists, message); |
|
} |
|
|
|
Status CancelledError(absl::string_view message) { |
|
return Status(absl::StatusCode::kCancelled, message); |
|
} |
|
|
|
Status DataLossError(absl::string_view message) { |
|
return Status(absl::StatusCode::kDataLoss, message); |
|
} |
|
|
|
Status DeadlineExceededError(absl::string_view message) { |
|
return Status(absl::StatusCode::kDeadlineExceeded, message); |
|
} |
|
|
|
Status FailedPreconditionError(absl::string_view message) { |
|
return Status(absl::StatusCode::kFailedPrecondition, message); |
|
} |
|
|
|
Status InternalError(absl::string_view message) { |
|
return Status(absl::StatusCode::kInternal, message); |
|
} |
|
|
|
Status InvalidArgumentError(absl::string_view message) { |
|
return Status(absl::StatusCode::kInvalidArgument, message); |
|
} |
|
|
|
Status NotFoundError(absl::string_view message) { |
|
return Status(absl::StatusCode::kNotFound, message); |
|
} |
|
|
|
Status OutOfRangeError(absl::string_view message) { |
|
return Status(absl::StatusCode::kOutOfRange, message); |
|
} |
|
|
|
Status PermissionDeniedError(absl::string_view message) { |
|
return Status(absl::StatusCode::kPermissionDenied, message); |
|
} |
|
|
|
Status ResourceExhaustedError(absl::string_view message) { |
|
return Status(absl::StatusCode::kResourceExhausted, message); |
|
} |
|
|
|
Status UnauthenticatedError(absl::string_view message) { |
|
return Status(absl::StatusCode::kUnauthenticated, message); |
|
} |
|
|
|
Status UnavailableError(absl::string_view message) { |
|
return Status(absl::StatusCode::kUnavailable, message); |
|
} |
|
|
|
Status UnimplementedError(absl::string_view message) { |
|
return Status(absl::StatusCode::kUnimplemented, message); |
|
} |
|
|
|
Status UnknownError(absl::string_view message) { |
|
return Status(absl::StatusCode::kUnknown, message); |
|
} |
|
|
|
bool IsAborted(const Status& status) { |
|
return status.code() == absl::StatusCode::kAborted; |
|
} |
|
|
|
bool IsAlreadyExists(const Status& status) { |
|
return status.code() == absl::StatusCode::kAlreadyExists; |
|
} |
|
|
|
bool IsCancelled(const Status& status) { |
|
return status.code() == absl::StatusCode::kCancelled; |
|
} |
|
|
|
bool IsDataLoss(const Status& status) { |
|
return status.code() == absl::StatusCode::kDataLoss; |
|
} |
|
|
|
bool IsDeadlineExceeded(const Status& status) { |
|
return status.code() == absl::StatusCode::kDeadlineExceeded; |
|
} |
|
|
|
bool IsFailedPrecondition(const Status& status) { |
|
return status.code() == absl::StatusCode::kFailedPrecondition; |
|
} |
|
|
|
bool IsInternal(const Status& status) { |
|
return status.code() == absl::StatusCode::kInternal; |
|
} |
|
|
|
bool IsInvalidArgument(const Status& status) { |
|
return status.code() == absl::StatusCode::kInvalidArgument; |
|
} |
|
|
|
bool IsNotFound(const Status& status) { |
|
return status.code() == absl::StatusCode::kNotFound; |
|
} |
|
|
|
bool IsOutOfRange(const Status& status) { |
|
return status.code() == absl::StatusCode::kOutOfRange; |
|
} |
|
|
|
bool IsPermissionDenied(const Status& status) { |
|
return status.code() == absl::StatusCode::kPermissionDenied; |
|
} |
|
|
|
bool IsResourceExhausted(const Status& status) { |
|
return status.code() == absl::StatusCode::kResourceExhausted; |
|
} |
|
|
|
bool IsUnauthenticated(const Status& status) { |
|
return status.code() == absl::StatusCode::kUnauthenticated; |
|
} |
|
|
|
bool IsUnavailable(const Status& status) { |
|
return status.code() == absl::StatusCode::kUnavailable; |
|
} |
|
|
|
bool IsUnimplemented(const Status& status) { |
|
return status.code() == absl::StatusCode::kUnimplemented; |
|
} |
|
|
|
bool IsUnknown(const Status& status) { |
|
return status.code() == absl::StatusCode::kUnknown; |
|
} |
|
|
|
StatusCode ErrnoToStatusCode(int error_number) { |
|
switch (error_number) { |
|
case 0: |
|
return StatusCode::kOk; |
|
case EINVAL: // Invalid argument |
|
case ENAMETOOLONG: // Filename too long |
|
case E2BIG: // Argument list too long |
|
case EDESTADDRREQ: // Destination address required |
|
case EDOM: // Mathematics argument out of domain of function |
|
case EFAULT: // Bad address |
|
case EILSEQ: // Illegal byte sequence |
|
case ENOPROTOOPT: // Protocol not available |
|
case ENOSTR: // Not a STREAM |
|
case ENOTSOCK: // Not a socket |
|
case ENOTTY: // Inappropriate I/O control operation |
|
case EPROTOTYPE: // Protocol wrong type for socket |
|
case ESPIPE: // Invalid seek |
|
return StatusCode::kInvalidArgument; |
|
case ETIMEDOUT: // Connection timed out |
|
case ETIME: // Timer expired |
|
return StatusCode::kDeadlineExceeded; |
|
case ENODEV: // No such device |
|
case ENOENT: // No such file or directory |
|
#ifdef ENOMEDIUM |
|
case ENOMEDIUM: // No medium found |
|
#endif |
|
case ENXIO: // No such device or address |
|
case ESRCH: // No such process |
|
return StatusCode::kNotFound; |
|
case EEXIST: // File exists |
|
case EADDRNOTAVAIL: // Address not available |
|
case EALREADY: // Connection already in progress |
|
#ifdef ENOTUNIQ |
|
case ENOTUNIQ: // Name not unique on network |
|
#endif |
|
return StatusCode::kAlreadyExists; |
|
case EPERM: // Operation not permitted |
|
case EACCES: // Permission denied |
|
#ifdef ENOKEY |
|
case ENOKEY: // Required key not available |
|
#endif |
|
case EROFS: // Read only file system |
|
return StatusCode::kPermissionDenied; |
|
case ENOTEMPTY: // Directory not empty |
|
case EISDIR: // Is a directory |
|
case ENOTDIR: // Not a directory |
|
case EADDRINUSE: // Address already in use |
|
case EBADF: // Invalid file descriptor |
|
#ifdef EBADFD |
|
case EBADFD: // File descriptor in bad state |
|
#endif |
|
case EBUSY: // Device or resource busy |
|
case ECHILD: // No child processes |
|
case EISCONN: // Socket is connected |
|
#ifdef EISNAM |
|
case EISNAM: // Is a named type file |
|
#endif |
|
#ifdef ENOTBLK |
|
case ENOTBLK: // Block device required |
|
#endif |
|
case ENOTCONN: // The socket is not connected |
|
case EPIPE: // Broken pipe |
|
#ifdef ESHUTDOWN |
|
case ESHUTDOWN: // Cannot send after transport endpoint shutdown |
|
#endif |
|
case ETXTBSY: // Text file busy |
|
#ifdef EUNATCH |
|
case EUNATCH: // Protocol driver not attached |
|
#endif |
|
return StatusCode::kFailedPrecondition; |
|
case ENOSPC: // No space left on device |
|
#ifdef EDQUOT |
|
case EDQUOT: // Disk quota exceeded |
|
#endif |
|
case EMFILE: // Too many open files |
|
case EMLINK: // Too many links |
|
case ENFILE: // Too many open files in system |
|
case ENOBUFS: // No buffer space available |
|
case ENODATA: // No message is available on the STREAM read queue |
|
case ENOMEM: // Not enough space |
|
case ENOSR: // No STREAM resources |
|
#ifdef EUSERS |
|
case EUSERS: // Too many users |
|
#endif |
|
return StatusCode::kResourceExhausted; |
|
#ifdef ECHRNG |
|
case ECHRNG: // Channel number out of range |
|
#endif |
|
case EFBIG: // File too large |
|
case EOVERFLOW: // Value too large to be stored in data type |
|
case ERANGE: // Result too large |
|
return StatusCode::kOutOfRange; |
|
#ifdef ENOPKG |
|
case ENOPKG: // Package not installed |
|
#endif |
|
case ENOSYS: // Function not implemented |
|
case ENOTSUP: // Operation not supported |
|
case EAFNOSUPPORT: // Address family not supported |
|
#ifdef EPFNOSUPPORT |
|
case EPFNOSUPPORT: // Protocol family not supported |
|
#endif |
|
case EPROTONOSUPPORT: // Protocol not supported |
|
#ifdef ESOCKTNOSUPPORT |
|
case ESOCKTNOSUPPORT: // Socket type not supported |
|
#endif |
|
case EXDEV: // Improper link |
|
return StatusCode::kUnimplemented; |
|
case EAGAIN: // Resource temporarily unavailable |
|
#ifdef ECOMM |
|
case ECOMM: // Communication error on send |
|
#endif |
|
case ECONNREFUSED: // Connection refused |
|
case ECONNABORTED: // Connection aborted |
|
case ECONNRESET: // Connection reset |
|
case EINTR: // Interrupted function call |
|
#ifdef EHOSTDOWN |
|
case EHOSTDOWN: // Host is down |
|
#endif |
|
case EHOSTUNREACH: // Host is unreachable |
|
case ENETDOWN: // Network is down |
|
case ENETRESET: // Connection aborted by network |
|
case ENETUNREACH: // Network unreachable |
|
case ENOLCK: // No locks available |
|
case ENOLINK: // Link has been severed |
|
#ifdef ENONET |
|
case ENONET: // Machine is not on the network |
|
#endif |
|
return StatusCode::kUnavailable; |
|
case EDEADLK: // Resource deadlock avoided |
|
#ifdef ESTALE |
|
case ESTALE: // Stale file handle |
|
#endif |
|
return StatusCode::kAborted; |
|
case ECANCELED: // Operation cancelled |
|
return StatusCode::kCancelled; |
|
default: |
|
return StatusCode::kUnknown; |
|
} |
|
} |
|
|
|
namespace { |
|
std::string MessageForErrnoToStatus(int error_number, |
|
absl::string_view message) { |
|
return absl::StrCat(message, ": ", |
|
absl::base_internal::StrError(error_number)); |
|
} |
|
} // namespace |
|
|
|
Status ErrnoToStatus(int error_number, absl::string_view message) { |
|
return Status(ErrnoToStatusCode(error_number), |
|
MessageForErrnoToStatus(error_number, message)); |
|
} |
|
|
|
namespace status_internal { |
|
|
|
std::string* MakeCheckFailString(const absl::Status& status, |
|
const char* prefix) { |
|
if (status.ok()) { return nullptr; } |
|
return new std::string( |
|
absl::StrCat(prefix, " (", |
|
status.ToString(StatusToStringMode::kWithEverything), ")")); |
|
} |
|
|
|
} // namespace status_internal |
|
|
|
ABSL_NAMESPACE_END |
|
} // namespace absl
|
|
|