fork of https://github.com/oxigraph/rocksdb and https://github.com/facebook/rocksdb for nextgraph and oxigraph
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.
238 lines
7.8 KiB
238 lines
7.8 KiB
// Copyright (c) 2013, Facebook, Inc. All rights reserved.
|
|
// This source code is licensed under the BSD-style license found in the
|
|
// LICENSE file in the root directory of this source tree. An additional grant
|
|
// of patent rights can be found in the PATENTS file in the same directory.
|
|
// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style license that can be
|
|
// found in the LICENSE file. See the AUTHORS file for names of contributors.
|
|
//
|
|
// A Status encapsulates the result of an operation. It may indicate success,
|
|
// or it may indicate an error with an associated error message.
|
|
//
|
|
// Multiple threads can invoke const methods on a Status without
|
|
// external synchronization, but if any of the threads may call a
|
|
// non-const method, all threads accessing the same Status must use
|
|
// external synchronization.
|
|
|
|
#ifndef STORAGE_ROCKSDB_INCLUDE_STATUS_H_
|
|
#define STORAGE_ROCKSDB_INCLUDE_STATUS_H_
|
|
|
|
#include <string>
|
|
#include "rocksdb/slice.h"
|
|
|
|
namespace rocksdb {
|
|
|
|
class Status {
|
|
public:
|
|
// Create a success status.
|
|
Status() : code_(kOk), subcode_(kNone), state_(nullptr) {}
|
|
~Status() { delete[] state_; }
|
|
|
|
// Copy the specified status.
|
|
Status(const Status& s);
|
|
void operator=(const Status& s);
|
|
bool operator==(const Status& rhs) const;
|
|
bool operator!=(const Status& rhs) const;
|
|
|
|
enum Code {
|
|
kOk = 0,
|
|
kNotFound = 1,
|
|
kCorruption = 2,
|
|
kNotSupported = 3,
|
|
kInvalidArgument = 4,
|
|
kIOError = 5,
|
|
kMergeInProgress = 6,
|
|
kIncomplete = 7,
|
|
kShutdownInProgress = 8,
|
|
kTimedOut = 9,
|
|
kAborted = 10,
|
|
kBusy = 11,
|
|
kExpired = 12,
|
|
kTryAgain = 13
|
|
};
|
|
|
|
Code code() const { return code_; }
|
|
|
|
enum SubCode {
|
|
kNone = 0,
|
|
kMutexTimeout = 1,
|
|
kLockTimeout = 2,
|
|
kLockLimit = 3,
|
|
kMaxSubCode
|
|
};
|
|
|
|
SubCode subcode() const { return subcode_; }
|
|
|
|
// Return a success status.
|
|
static Status OK() { return Status(); }
|
|
|
|
// Return error status of an appropriate type.
|
|
static Status NotFound(const Slice& msg, const Slice& msg2 = Slice()) {
|
|
return Status(kNotFound, msg, msg2);
|
|
}
|
|
// Fast path for not found without malloc;
|
|
static Status NotFound(SubCode msg = kNone) { return Status(kNotFound, msg); }
|
|
|
|
static Status Corruption(const Slice& msg, const Slice& msg2 = Slice()) {
|
|
return Status(kCorruption, msg, msg2);
|
|
}
|
|
static Status Corruption(SubCode msg = kNone) {
|
|
return Status(kCorruption, msg);
|
|
}
|
|
|
|
static Status NotSupported(const Slice& msg, const Slice& msg2 = Slice()) {
|
|
return Status(kNotSupported, msg, msg2);
|
|
}
|
|
static Status NotSupported(SubCode msg = kNone) {
|
|
return Status(kNotSupported, msg);
|
|
}
|
|
|
|
static Status InvalidArgument(const Slice& msg, const Slice& msg2 = Slice()) {
|
|
return Status(kInvalidArgument, msg, msg2);
|
|
}
|
|
static Status InvalidArgument(SubCode msg = kNone) {
|
|
return Status(kInvalidArgument, msg);
|
|
}
|
|
|
|
static Status IOError(const Slice& msg, const Slice& msg2 = Slice()) {
|
|
return Status(kIOError, msg, msg2);
|
|
}
|
|
static Status IOError(SubCode msg = kNone) { return Status(kIOError, msg); }
|
|
|
|
static Status MergeInProgress(const Slice& msg, const Slice& msg2 = Slice()) {
|
|
return Status(kMergeInProgress, msg, msg2);
|
|
}
|
|
static Status MergeInProgress(SubCode msg = kNone) {
|
|
return Status(kMergeInProgress, msg);
|
|
}
|
|
|
|
static Status Incomplete(const Slice& msg, const Slice& msg2 = Slice()) {
|
|
return Status(kIncomplete, msg, msg2);
|
|
}
|
|
static Status Incomplete(SubCode msg = kNone) {
|
|
return Status(kIncomplete, msg);
|
|
}
|
|
|
|
static Status ShutdownInProgress(SubCode msg = kNone) {
|
|
return Status(kShutdownInProgress, msg);
|
|
}
|
|
static Status ShutdownInProgress(const Slice& msg,
|
|
const Slice& msg2 = Slice()) {
|
|
return Status(kShutdownInProgress, msg, msg2);
|
|
}
|
|
static Status Aborted(SubCode msg = kNone) { return Status(kAborted, msg); }
|
|
static Status Aborted(const Slice& msg, const Slice& msg2 = Slice()) {
|
|
return Status(kAborted, msg, msg2);
|
|
}
|
|
|
|
static Status Busy(SubCode msg = kNone) { return Status(kBusy, msg); }
|
|
static Status Busy(const Slice& msg, const Slice& msg2 = Slice()) {
|
|
return Status(kBusy, msg, msg2);
|
|
}
|
|
|
|
static Status TimedOut(SubCode msg = kNone) { return Status(kTimedOut, msg); }
|
|
static Status TimedOut(const Slice& msg, const Slice& msg2 = Slice()) {
|
|
return Status(kTimedOut, msg, msg2);
|
|
}
|
|
|
|
static Status Expired(SubCode msg = kNone) { return Status(kExpired, msg); }
|
|
static Status Expired(const Slice& msg, const Slice& msg2 = Slice()) {
|
|
return Status(kExpired, msg, msg2);
|
|
}
|
|
|
|
static Status TryAgain(SubCode msg = kNone) { return Status(kTryAgain, msg); }
|
|
static Status TryAgain(const Slice& msg, const Slice& msg2 = Slice()) {
|
|
return Status(kTryAgain, msg, msg2);
|
|
}
|
|
|
|
// Returns true iff the status indicates success.
|
|
bool ok() const { return code() == kOk; }
|
|
|
|
// Returns true iff the status indicates a NotFound error.
|
|
bool IsNotFound() const { return code() == kNotFound; }
|
|
|
|
// Returns true iff the status indicates a Corruption error.
|
|
bool IsCorruption() const { return code() == kCorruption; }
|
|
|
|
// Returns true iff the status indicates a NotSupported error.
|
|
bool IsNotSupported() const { return code() == kNotSupported; }
|
|
|
|
// Returns true iff the status indicates an InvalidArgument error.
|
|
bool IsInvalidArgument() const { return code() == kInvalidArgument; }
|
|
|
|
// Returns true iff the status indicates an IOError.
|
|
bool IsIOError() const { return code() == kIOError; }
|
|
|
|
// Returns true iff the status indicates an MergeInProgress.
|
|
bool IsMergeInProgress() const { return code() == kMergeInProgress; }
|
|
|
|
// Returns true iff the status indicates Incomplete
|
|
bool IsIncomplete() const { return code() == kIncomplete; }
|
|
|
|
// Returns true iff the status indicates Shutdown In progress
|
|
bool IsShutdownInProgress() const { return code() == kShutdownInProgress; }
|
|
|
|
bool IsTimedOut() const { return code() == kTimedOut; }
|
|
|
|
bool IsAborted() const { return code() == kAborted; }
|
|
|
|
// Returns true iff the status indicates that a resource is Busy and
|
|
// temporarily could not be acquired.
|
|
bool IsBusy() const { return code() == kBusy; }
|
|
|
|
// Returns true iff the status indicated that the operation has Expired.
|
|
bool IsExpired() const { return code() == kExpired; }
|
|
|
|
// Returns true iff the status indicates a TryAgain error.
|
|
// This usually means that the operation failed, but may succeed if
|
|
// re-attempted.
|
|
bool IsTryAgain() const { return code() == kTryAgain; }
|
|
|
|
// Return a string representation of this status suitable for printing.
|
|
// Returns the string "OK" for success.
|
|
std::string ToString() const;
|
|
|
|
private:
|
|
// A nullptr state_ (which is always the case for OK) means the message
|
|
// is empty.
|
|
// of the following form:
|
|
// state_[0..3] == length of message
|
|
// state_[4..] == message
|
|
Code code_;
|
|
SubCode subcode_;
|
|
const char* state_;
|
|
|
|
static const char* msgs[static_cast<int>(kMaxSubCode)];
|
|
|
|
explicit Status(Code _code, SubCode _subcode = kNone)
|
|
: code_(_code), subcode_(_subcode), state_(nullptr) {}
|
|
|
|
Status(Code _code, const Slice& msg, const Slice& msg2);
|
|
static const char* CopyState(const char* s);
|
|
};
|
|
|
|
inline Status::Status(const Status& s) : code_(s.code_), subcode_(s.subcode_) {
|
|
state_ = (s.state_ == nullptr) ? nullptr : CopyState(s.state_);
|
|
}
|
|
inline void Status::operator=(const Status& s) {
|
|
// The following condition catches both aliasing (when this == &s),
|
|
// and the common case where both s and *this are ok.
|
|
code_ = s.code_;
|
|
subcode_ = s.subcode_;
|
|
if (state_ != s.state_) {
|
|
delete[] state_;
|
|
state_ = (s.state_ == nullptr) ? nullptr : CopyState(s.state_);
|
|
}
|
|
}
|
|
|
|
inline bool Status::operator==(const Status& rhs) const {
|
|
return (code_ == rhs.code_);
|
|
}
|
|
|
|
inline bool Status::operator!=(const Status& rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
} // namespace rocksdb
|
|
|
|
#endif // STORAGE_ROCKSDB_INCLUDE_STATUS_H_
|
|
|