1061 lines
24 KiB
C++
1061 lines
24 KiB
C++
/**
|
|
* Autogenerated by Thrift
|
|
*
|
|
* DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
|
|
* @generated
|
|
*/
|
|
#ifndef leveldb_TYPES_H
|
|
#define leveldb_TYPES_H
|
|
|
|
#include <Thrift.h>
|
|
#include <TApplicationException.h>
|
|
#include <protocol/TProtocol.h>
|
|
#include <transport/TTransport.h>
|
|
|
|
namespace apache { namespace thrift { namespace reflection {
|
|
class Schema;
|
|
}}}
|
|
|
|
|
|
namespace Tleveldb {
|
|
|
|
enum CompressionType {
|
|
kNoCompression = 0,
|
|
kSnappyCompression = 1
|
|
};
|
|
|
|
extern const std::map<int, const char*> _CompressionType_VALUES_TO_NAMES;
|
|
|
|
extern const std::map<const char*, int, apache::thrift::ltstr> _CompressionType_NAMES_TO_VALUES;
|
|
|
|
} // namespace
|
|
namespace apache { namespace thrift {
|
|
template<>
|
|
inline constexpr ::Tleveldb::CompressionType TEnumTraits< ::Tleveldb::CompressionType>::min() {
|
|
return ::Tleveldb::CompressionType::kNoCompression;
|
|
}
|
|
template<>
|
|
inline constexpr ::Tleveldb::CompressionType TEnumTraits< ::Tleveldb::CompressionType>::max() {
|
|
return ::Tleveldb::CompressionType::kSnappyCompression;
|
|
}
|
|
}} // apache:thrift
|
|
|
|
namespace Tleveldb {
|
|
enum Code {
|
|
kOk = 0,
|
|
kNotFound = 1,
|
|
kCorruption = 2,
|
|
kNotSupported = 3,
|
|
kInvalidArgument = 4,
|
|
kIOError = 5,
|
|
kEnd = 6
|
|
};
|
|
|
|
extern const std::map<int, const char*> _Code_VALUES_TO_NAMES;
|
|
|
|
extern const std::map<const char*, int, apache::thrift::ltstr> _Code_NAMES_TO_VALUES;
|
|
|
|
} // namespace
|
|
namespace apache { namespace thrift {
|
|
template<>
|
|
inline constexpr ::Tleveldb::Code TEnumTraits< ::Tleveldb::Code>::min() {
|
|
return ::Tleveldb::Code::kOk;
|
|
}
|
|
template<>
|
|
inline constexpr ::Tleveldb::Code TEnumTraits< ::Tleveldb::Code>::max() {
|
|
return ::Tleveldb::Code::kEnd;
|
|
}
|
|
}} // apache:thrift
|
|
|
|
namespace Tleveldb {
|
|
enum IteratorType {
|
|
seekToFirst = 0,
|
|
seekToLast = 1,
|
|
seekToKey = 2
|
|
};
|
|
|
|
extern const std::map<int, const char*> _IteratorType_VALUES_TO_NAMES;
|
|
|
|
extern const std::map<const char*, int, apache::thrift::ltstr> _IteratorType_NAMES_TO_VALUES;
|
|
|
|
} // namespace
|
|
namespace apache { namespace thrift {
|
|
template<>
|
|
inline constexpr ::Tleveldb::IteratorType TEnumTraits< ::Tleveldb::IteratorType>::min() {
|
|
return ::Tleveldb::IteratorType::seekToFirst;
|
|
}
|
|
template<>
|
|
inline constexpr ::Tleveldb::IteratorType TEnumTraits< ::Tleveldb::IteratorType>::max() {
|
|
return ::Tleveldb::IteratorType::seekToKey;
|
|
}
|
|
}} // apache:thrift
|
|
|
|
namespace Tleveldb {
|
|
enum AssocVisibility {
|
|
VISIBLE = 0,
|
|
DELETED = 1,
|
|
UNUSED1 = 2,
|
|
HIDDEN = 3,
|
|
UNUSED2 = 4,
|
|
HARD_DELETE = 4
|
|
};
|
|
|
|
extern const std::map<int, const char*> _AssocVisibility_VALUES_TO_NAMES;
|
|
|
|
extern const std::map<const char*, int, apache::thrift::ltstr> _AssocVisibility_NAMES_TO_VALUES;
|
|
|
|
} // namespace
|
|
namespace apache { namespace thrift {
|
|
template<>
|
|
inline constexpr ::Tleveldb::AssocVisibility TEnumTraits< ::Tleveldb::AssocVisibility>::min() {
|
|
return ::Tleveldb::AssocVisibility::VISIBLE;
|
|
}
|
|
template<>
|
|
inline constexpr ::Tleveldb::AssocVisibility TEnumTraits< ::Tleveldb::AssocVisibility>::max() {
|
|
return ::Tleveldb::AssocVisibility::HARD_DELETE;
|
|
}
|
|
}} // apache:thrift
|
|
|
|
namespace Tleveldb {
|
|
typedef std::string Text;
|
|
|
|
typedef std::string Bytes;
|
|
|
|
class Slice {
|
|
public:
|
|
|
|
static const uint64_t _reflection_id = 2199896239461470156U;
|
|
static void _reflection_register(::apache::thrift::reflection::Schema&);
|
|
Slice() : data(""), size(0) {
|
|
}
|
|
|
|
Slice(const Slice&) = default;
|
|
Slice& operator=(const Slice&) = default;
|
|
Slice(Slice&&) = default;
|
|
Slice& operator=(Slice&&) = default;
|
|
|
|
void __clear() {
|
|
data = "";
|
|
size = 0;
|
|
__isset.__clear();
|
|
}
|
|
|
|
virtual ~Slice() throw() {}
|
|
|
|
Text data;
|
|
int32_t size;
|
|
|
|
struct __isset {
|
|
__isset() { __clear(); }
|
|
void __clear() {
|
|
data = false;
|
|
size = false;
|
|
}
|
|
bool data;
|
|
bool size;
|
|
} __isset;
|
|
|
|
bool operator == (const Slice & rhs) const
|
|
{
|
|
if (!(this->data == rhs.data))
|
|
return false;
|
|
if (!(this->size == rhs.size))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const Slice &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const Slice & ) const;
|
|
|
|
uint32_t read(apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
class Slice;
|
|
void swap(Slice &a, Slice &b);
|
|
|
|
class Range {
|
|
public:
|
|
|
|
static const uint64_t _reflection_id = 6170219570187881516U;
|
|
static void _reflection_register(::apache::thrift::reflection::Schema&);
|
|
Range() {
|
|
}
|
|
|
|
Range(const Range&) = default;
|
|
Range& operator=(const Range&) = default;
|
|
Range(Range&&) = default;
|
|
Range& operator=(Range&&) = default;
|
|
|
|
void __clear() {
|
|
start.__clear();
|
|
limit.__clear();
|
|
__isset.__clear();
|
|
}
|
|
|
|
virtual ~Range() throw() {}
|
|
|
|
Slice start;
|
|
Slice limit;
|
|
|
|
struct __isset {
|
|
__isset() { __clear(); }
|
|
void __clear() {
|
|
start = false;
|
|
limit = false;
|
|
}
|
|
bool start;
|
|
bool limit;
|
|
} __isset;
|
|
|
|
bool operator == (const Range & rhs) const
|
|
{
|
|
if (!(this->start == rhs.start))
|
|
return false;
|
|
if (!(this->limit == rhs.limit))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const Range &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const Range & ) const;
|
|
|
|
uint32_t read(apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
class Range;
|
|
void swap(Range &a, Range &b);
|
|
|
|
class DBOptions {
|
|
public:
|
|
|
|
static const uint64_t _reflection_id = 6731746507948871532U;
|
|
static void _reflection_register(::apache::thrift::reflection::Schema&);
|
|
DBOptions() : create_if_missing(0), error_if_exists(0), write_buffer_size(0), max_open_files(0), block_size(0), block_restart_interval(0), compression(static_cast<CompressionType>(0)) {
|
|
}
|
|
|
|
DBOptions(const DBOptions&) = default;
|
|
DBOptions& operator=(const DBOptions&) = default;
|
|
DBOptions(DBOptions&&) = default;
|
|
DBOptions& operator=(DBOptions&&) = default;
|
|
|
|
void __clear() {
|
|
create_if_missing = 0;
|
|
error_if_exists = 0;
|
|
write_buffer_size = 0;
|
|
max_open_files = 0;
|
|
block_size = 0;
|
|
block_restart_interval = 0;
|
|
compression = static_cast<CompressionType>(0);
|
|
__isset.__clear();
|
|
}
|
|
|
|
virtual ~DBOptions() throw() {}
|
|
|
|
bool create_if_missing;
|
|
bool error_if_exists;
|
|
int32_t write_buffer_size;
|
|
int32_t max_open_files;
|
|
int32_t block_size;
|
|
int32_t block_restart_interval;
|
|
CompressionType compression;
|
|
|
|
struct __isset {
|
|
__isset() { __clear(); }
|
|
void __clear() {
|
|
create_if_missing = false;
|
|
error_if_exists = false;
|
|
write_buffer_size = false;
|
|
max_open_files = false;
|
|
block_size = false;
|
|
block_restart_interval = false;
|
|
compression = false;
|
|
}
|
|
bool create_if_missing;
|
|
bool error_if_exists;
|
|
bool write_buffer_size;
|
|
bool max_open_files;
|
|
bool block_size;
|
|
bool block_restart_interval;
|
|
bool compression;
|
|
} __isset;
|
|
|
|
bool operator == (const DBOptions & rhs) const
|
|
{
|
|
if (!(this->create_if_missing == rhs.create_if_missing))
|
|
return false;
|
|
if (!(this->error_if_exists == rhs.error_if_exists))
|
|
return false;
|
|
if (!(this->write_buffer_size == rhs.write_buffer_size))
|
|
return false;
|
|
if (!(this->max_open_files == rhs.max_open_files))
|
|
return false;
|
|
if (!(this->block_size == rhs.block_size))
|
|
return false;
|
|
if (!(this->block_restart_interval == rhs.block_restart_interval))
|
|
return false;
|
|
if (!(this->compression == rhs.compression))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const DBOptions &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const DBOptions & ) const;
|
|
|
|
uint32_t read(apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
class DBOptions;
|
|
void swap(DBOptions &a, DBOptions &b);
|
|
|
|
class WriteOptions {
|
|
public:
|
|
|
|
static const uint64_t _reflection_id = 8830325115029814540U;
|
|
static void _reflection_register(::apache::thrift::reflection::Schema&);
|
|
WriteOptions() : sync(0) {
|
|
}
|
|
|
|
WriteOptions(const WriteOptions&) = default;
|
|
WriteOptions& operator=(const WriteOptions&) = default;
|
|
WriteOptions(WriteOptions&&) = default;
|
|
WriteOptions& operator=(WriteOptions&&) = default;
|
|
|
|
void __clear() {
|
|
sync = 0;
|
|
__isset.__clear();
|
|
}
|
|
|
|
virtual ~WriteOptions() throw() {}
|
|
|
|
bool sync;
|
|
|
|
struct __isset {
|
|
__isset() { __clear(); }
|
|
void __clear() {
|
|
sync = false;
|
|
}
|
|
bool sync;
|
|
} __isset;
|
|
|
|
bool operator == (const WriteOptions & rhs) const
|
|
{
|
|
if (!(this->sync == rhs.sync))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const WriteOptions &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const WriteOptions & ) const;
|
|
|
|
uint32_t read(apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
class WriteOptions;
|
|
void swap(WriteOptions &a, WriteOptions &b);
|
|
|
|
class Snapshot {
|
|
public:
|
|
|
|
static const uint64_t _reflection_id = 15670548806217660204U;
|
|
static void _reflection_register(::apache::thrift::reflection::Schema&);
|
|
Snapshot() : snapshotid(0) {
|
|
}
|
|
|
|
Snapshot(const Snapshot&) = default;
|
|
Snapshot& operator=(const Snapshot&) = default;
|
|
Snapshot(Snapshot&&) = default;
|
|
Snapshot& operator=(Snapshot&&) = default;
|
|
|
|
void __clear() {
|
|
snapshotid = 0;
|
|
__isset.__clear();
|
|
}
|
|
|
|
virtual ~Snapshot() throw() {}
|
|
|
|
int64_t snapshotid;
|
|
|
|
struct __isset {
|
|
__isset() { __clear(); }
|
|
void __clear() {
|
|
snapshotid = false;
|
|
}
|
|
bool snapshotid;
|
|
} __isset;
|
|
|
|
bool operator == (const Snapshot & rhs) const
|
|
{
|
|
if (!(this->snapshotid == rhs.snapshotid))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const Snapshot &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const Snapshot & ) const;
|
|
|
|
uint32_t read(apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
class Snapshot;
|
|
void swap(Snapshot &a, Snapshot &b);
|
|
|
|
class ReadOptions {
|
|
public:
|
|
|
|
static const uint64_t _reflection_id = 1092669993626789804U;
|
|
static void _reflection_register(::apache::thrift::reflection::Schema&);
|
|
ReadOptions() : verify_checksums(0), fill_cache(0) {
|
|
}
|
|
|
|
ReadOptions(const ReadOptions&) = default;
|
|
ReadOptions& operator=(const ReadOptions&) = default;
|
|
ReadOptions(ReadOptions&&) = default;
|
|
ReadOptions& operator=(ReadOptions&&) = default;
|
|
|
|
void __clear() {
|
|
verify_checksums = 0;
|
|
fill_cache = 0;
|
|
snapshot.__clear();
|
|
__isset.__clear();
|
|
}
|
|
|
|
virtual ~ReadOptions() throw() {}
|
|
|
|
bool verify_checksums;
|
|
bool fill_cache;
|
|
Snapshot snapshot;
|
|
|
|
struct __isset {
|
|
__isset() { __clear(); }
|
|
void __clear() {
|
|
verify_checksums = false;
|
|
fill_cache = false;
|
|
snapshot = false;
|
|
}
|
|
bool verify_checksums;
|
|
bool fill_cache;
|
|
bool snapshot;
|
|
} __isset;
|
|
|
|
bool operator == (const ReadOptions & rhs) const
|
|
{
|
|
if (!(this->verify_checksums == rhs.verify_checksums))
|
|
return false;
|
|
if (!(this->fill_cache == rhs.fill_cache))
|
|
return false;
|
|
if (!(this->snapshot == rhs.snapshot))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const ReadOptions &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const ReadOptions & ) const;
|
|
|
|
uint32_t read(apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
class ReadOptions;
|
|
void swap(ReadOptions &a, ReadOptions &b);
|
|
|
|
class DBHandle {
|
|
public:
|
|
|
|
static const uint64_t _reflection_id = 8973827971994157004U;
|
|
static void _reflection_register(::apache::thrift::reflection::Schema&);
|
|
DBHandle() : dbname("") {
|
|
}
|
|
|
|
DBHandle(const DBHandle&) = default;
|
|
DBHandle& operator=(const DBHandle&) = default;
|
|
DBHandle(DBHandle&&) = default;
|
|
DBHandle& operator=(DBHandle&&) = default;
|
|
|
|
void __clear() {
|
|
dbname = "";
|
|
__isset.__clear();
|
|
}
|
|
|
|
virtual ~DBHandle() throw() {}
|
|
|
|
Text dbname;
|
|
|
|
struct __isset {
|
|
__isset() { __clear(); }
|
|
void __clear() {
|
|
dbname = false;
|
|
}
|
|
bool dbname;
|
|
} __isset;
|
|
|
|
bool operator == (const DBHandle & rhs) const
|
|
{
|
|
if (!(this->dbname == rhs.dbname))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const DBHandle &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const DBHandle & ) const;
|
|
|
|
uint32_t read(apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
class DBHandle;
|
|
void swap(DBHandle &a, DBHandle &b);
|
|
|
|
class Iterator {
|
|
public:
|
|
|
|
static const uint64_t _reflection_id = 11184146435197093740U;
|
|
static void _reflection_register(::apache::thrift::reflection::Schema&);
|
|
Iterator() : iteratorid(0) {
|
|
}
|
|
|
|
Iterator(const Iterator&) = default;
|
|
Iterator& operator=(const Iterator&) = default;
|
|
Iterator(Iterator&&) = default;
|
|
Iterator& operator=(Iterator&&) = default;
|
|
|
|
void __clear() {
|
|
iteratorid = 0;
|
|
__isset.__clear();
|
|
}
|
|
|
|
virtual ~Iterator() throw() {}
|
|
|
|
int64_t iteratorid;
|
|
|
|
struct __isset {
|
|
__isset() { __clear(); }
|
|
void __clear() {
|
|
iteratorid = false;
|
|
}
|
|
bool iteratorid;
|
|
} __isset;
|
|
|
|
bool operator == (const Iterator & rhs) const
|
|
{
|
|
if (!(this->iteratorid == rhs.iteratorid))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const Iterator &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const Iterator & ) const;
|
|
|
|
uint32_t read(apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
class Iterator;
|
|
void swap(Iterator &a, Iterator &b);
|
|
|
|
class kv {
|
|
public:
|
|
|
|
static const uint64_t _reflection_id = 16082992224095104076U;
|
|
static void _reflection_register(::apache::thrift::reflection::Schema&);
|
|
kv() {
|
|
}
|
|
|
|
kv(const kv&) = default;
|
|
kv& operator=(const kv&) = default;
|
|
kv(kv&&) = default;
|
|
kv& operator=(kv&&) = default;
|
|
|
|
void __clear() {
|
|
key.__clear();
|
|
value.__clear();
|
|
__isset.__clear();
|
|
}
|
|
|
|
virtual ~kv() throw() {}
|
|
|
|
Slice key;
|
|
Slice value;
|
|
|
|
struct __isset {
|
|
__isset() { __clear(); }
|
|
void __clear() {
|
|
key = false;
|
|
value = false;
|
|
}
|
|
bool key;
|
|
bool value;
|
|
} __isset;
|
|
|
|
bool operator == (const kv & rhs) const
|
|
{
|
|
if (!(this->key == rhs.key))
|
|
return false;
|
|
if (!(this->value == rhs.value))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const kv &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const kv & ) const;
|
|
|
|
uint32_t read(apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
class kv;
|
|
void swap(kv &a, kv &b);
|
|
|
|
class ResultItem {
|
|
public:
|
|
|
|
static const uint64_t _reflection_id = 13211316281207238796U;
|
|
static void _reflection_register(::apache::thrift::reflection::Schema&);
|
|
ResultItem() : status(static_cast<Code>(0)) {
|
|
}
|
|
|
|
ResultItem(const ResultItem&) = default;
|
|
ResultItem& operator=(const ResultItem&) = default;
|
|
ResultItem(ResultItem&&) = default;
|
|
ResultItem& operator=(ResultItem&&) = default;
|
|
|
|
void __clear() {
|
|
status = static_cast<Code>(0);
|
|
value.__clear();
|
|
__isset.__clear();
|
|
}
|
|
|
|
virtual ~ResultItem() throw() {}
|
|
|
|
Code status;
|
|
Slice value;
|
|
|
|
struct __isset {
|
|
__isset() { __clear(); }
|
|
void __clear() {
|
|
status = false;
|
|
value = false;
|
|
}
|
|
bool status;
|
|
bool value;
|
|
} __isset;
|
|
|
|
bool operator == (const ResultItem & rhs) const
|
|
{
|
|
if (!(this->status == rhs.status))
|
|
return false;
|
|
if (!(this->value == rhs.value))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const ResultItem &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const ResultItem & ) const;
|
|
|
|
uint32_t read(apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
class ResultItem;
|
|
void swap(ResultItem &a, ResultItem &b);
|
|
|
|
class ResultPair {
|
|
public:
|
|
|
|
static const uint64_t _reflection_id = 14875242256166808460U;
|
|
static void _reflection_register(::apache::thrift::reflection::Schema&);
|
|
ResultPair() : status(static_cast<Code>(0)) {
|
|
}
|
|
|
|
ResultPair(const ResultPair&) = default;
|
|
ResultPair& operator=(const ResultPair&) = default;
|
|
ResultPair(ResultPair&&) = default;
|
|
ResultPair& operator=(ResultPair&&) = default;
|
|
|
|
void __clear() {
|
|
status = static_cast<Code>(0);
|
|
keyvalue.__clear();
|
|
__isset.__clear();
|
|
}
|
|
|
|
virtual ~ResultPair() throw() {}
|
|
|
|
Code status;
|
|
kv keyvalue;
|
|
|
|
struct __isset {
|
|
__isset() { __clear(); }
|
|
void __clear() {
|
|
status = false;
|
|
keyvalue = false;
|
|
}
|
|
bool status;
|
|
bool keyvalue;
|
|
} __isset;
|
|
|
|
bool operator == (const ResultPair & rhs) const
|
|
{
|
|
if (!(this->status == rhs.status))
|
|
return false;
|
|
if (!(this->keyvalue == rhs.keyvalue))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const ResultPair &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const ResultPair & ) const;
|
|
|
|
uint32_t read(apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
class ResultPair;
|
|
void swap(ResultPair &a, ResultPair &b);
|
|
|
|
class ResultSnapshot {
|
|
public:
|
|
|
|
static const uint64_t _reflection_id = 16627180600575569004U;
|
|
static void _reflection_register(::apache::thrift::reflection::Schema&);
|
|
ResultSnapshot() : status(static_cast<Code>(0)) {
|
|
}
|
|
|
|
ResultSnapshot(const ResultSnapshot&) = default;
|
|
ResultSnapshot& operator=(const ResultSnapshot&) = default;
|
|
ResultSnapshot(ResultSnapshot&&) = default;
|
|
ResultSnapshot& operator=(ResultSnapshot&&) = default;
|
|
|
|
void __clear() {
|
|
status = static_cast<Code>(0);
|
|
snapshot.__clear();
|
|
__isset.__clear();
|
|
}
|
|
|
|
virtual ~ResultSnapshot() throw() {}
|
|
|
|
Code status;
|
|
Snapshot snapshot;
|
|
|
|
struct __isset {
|
|
__isset() { __clear(); }
|
|
void __clear() {
|
|
status = false;
|
|
snapshot = false;
|
|
}
|
|
bool status;
|
|
bool snapshot;
|
|
} __isset;
|
|
|
|
bool operator == (const ResultSnapshot & rhs) const
|
|
{
|
|
if (!(this->status == rhs.status))
|
|
return false;
|
|
if (!(this->snapshot == rhs.snapshot))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const ResultSnapshot &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const ResultSnapshot & ) const;
|
|
|
|
uint32_t read(apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
class ResultSnapshot;
|
|
void swap(ResultSnapshot &a, ResultSnapshot &b);
|
|
|
|
class ResultIterator {
|
|
public:
|
|
|
|
static const uint64_t _reflection_id = 595886977232564460U;
|
|
static void _reflection_register(::apache::thrift::reflection::Schema&);
|
|
ResultIterator() : status(static_cast<Code>(0)) {
|
|
}
|
|
|
|
ResultIterator(const ResultIterator&) = default;
|
|
ResultIterator& operator=(const ResultIterator&) = default;
|
|
ResultIterator(ResultIterator&&) = default;
|
|
ResultIterator& operator=(ResultIterator&&) = default;
|
|
|
|
void __clear() {
|
|
status = static_cast<Code>(0);
|
|
iterator.__clear();
|
|
__isset.__clear();
|
|
}
|
|
|
|
virtual ~ResultIterator() throw() {}
|
|
|
|
Code status;
|
|
Iterator iterator;
|
|
|
|
struct __isset {
|
|
__isset() { __clear(); }
|
|
void __clear() {
|
|
status = false;
|
|
iterator = false;
|
|
}
|
|
bool status;
|
|
bool iterator;
|
|
} __isset;
|
|
|
|
bool operator == (const ResultIterator & rhs) const
|
|
{
|
|
if (!(this->status == rhs.status))
|
|
return false;
|
|
if (!(this->iterator == rhs.iterator))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const ResultIterator &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const ResultIterator & ) const;
|
|
|
|
uint32_t read(apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
class ResultIterator;
|
|
void swap(ResultIterator &a, ResultIterator &b);
|
|
|
|
class LeveldbException : public apache::thrift::TException {
|
|
public:
|
|
|
|
static const uint64_t _reflection_id = 2551220192341843436U;
|
|
static void _reflection_register(::apache::thrift::reflection::Schema&);
|
|
LeveldbException() : message(""), errorCode(static_cast<Code>(0)) {
|
|
}
|
|
|
|
LeveldbException(const LeveldbException&) = default;
|
|
LeveldbException& operator=(const LeveldbException&) = default;
|
|
LeveldbException(LeveldbException&&) = default;
|
|
LeveldbException& operator=(LeveldbException&&) = default;
|
|
|
|
void __clear() {
|
|
message = "";
|
|
errorCode = static_cast<Code>(0);
|
|
__isset.__clear();
|
|
}
|
|
|
|
virtual ~LeveldbException() throw() {}
|
|
|
|
Text message;
|
|
Code errorCode;
|
|
|
|
struct __isset {
|
|
__isset() { __clear(); }
|
|
void __clear() {
|
|
message = false;
|
|
errorCode = false;
|
|
}
|
|
bool message;
|
|
bool errorCode;
|
|
} __isset;
|
|
|
|
bool operator == (const LeveldbException & rhs) const
|
|
{
|
|
if (!(this->message == rhs.message))
|
|
return false;
|
|
if (!(this->errorCode == rhs.errorCode))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const LeveldbException &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const LeveldbException & ) const;
|
|
|
|
uint32_t read(apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
virtual const char* what() const throw() {
|
|
return "LeveldbException";
|
|
}
|
|
|
|
};
|
|
|
|
class LeveldbException;
|
|
void swap(LeveldbException &a, LeveldbException &b);
|
|
|
|
class IOError : public apache::thrift::TException {
|
|
public:
|
|
|
|
static const uint64_t _reflection_id = 8460881927871070060U;
|
|
static void _reflection_register(::apache::thrift::reflection::Schema&);
|
|
IOError() : message("") {
|
|
}
|
|
|
|
IOError(const IOError&) = default;
|
|
IOError& operator=(const IOError&) = default;
|
|
IOError(IOError&&) = default;
|
|
IOError& operator=(IOError&&) = default;
|
|
|
|
void __clear() {
|
|
message = "";
|
|
__isset.__clear();
|
|
}
|
|
|
|
virtual ~IOError() throw() {}
|
|
|
|
std::string message;
|
|
|
|
struct __isset {
|
|
__isset() { __clear(); }
|
|
void __clear() {
|
|
message = false;
|
|
}
|
|
bool message;
|
|
} __isset;
|
|
|
|
bool operator == (const IOError & rhs) const
|
|
{
|
|
if (!(this->message == rhs.message))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const IOError &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const IOError & ) const;
|
|
|
|
uint32_t read(apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
virtual const char* what() const throw() {
|
|
return "IOError";
|
|
}
|
|
|
|
};
|
|
|
|
class IOError;
|
|
void swap(IOError &a, IOError &b);
|
|
|
|
class TaoAssocGetResult {
|
|
public:
|
|
|
|
static const uint64_t _reflection_id = 6301164048086986412U;
|
|
static void _reflection_register(::apache::thrift::reflection::Schema&);
|
|
TaoAssocGetResult() : id2(0), id1Type(0), id2Type(0), time(0), dataVersion(0), data("") {
|
|
}
|
|
|
|
TaoAssocGetResult(const TaoAssocGetResult&) = default;
|
|
TaoAssocGetResult& operator=(const TaoAssocGetResult&) = default;
|
|
TaoAssocGetResult(TaoAssocGetResult&&) = default;
|
|
TaoAssocGetResult& operator=(TaoAssocGetResult&&) = default;
|
|
|
|
void __clear() {
|
|
id2 = 0;
|
|
id1Type = 0;
|
|
id2Type = 0;
|
|
time = 0;
|
|
dataVersion = 0;
|
|
data = "";
|
|
__isset.__clear();
|
|
}
|
|
|
|
virtual ~TaoAssocGetResult() throw() {}
|
|
|
|
int64_t id2;
|
|
int64_t id1Type;
|
|
int64_t id2Type;
|
|
int64_t time;
|
|
int64_t dataVersion;
|
|
Text data;
|
|
|
|
struct __isset {
|
|
__isset() { __clear(); }
|
|
void __clear() {
|
|
id2 = false;
|
|
id1Type = false;
|
|
id2Type = false;
|
|
time = false;
|
|
dataVersion = false;
|
|
data = false;
|
|
}
|
|
bool id2;
|
|
bool id1Type;
|
|
bool id2Type;
|
|
bool time;
|
|
bool dataVersion;
|
|
bool data;
|
|
} __isset;
|
|
|
|
bool operator == (const TaoAssocGetResult & rhs) const
|
|
{
|
|
if (!(this->id2 == rhs.id2))
|
|
return false;
|
|
if (!(this->id1Type == rhs.id1Type))
|
|
return false;
|
|
if (!(this->id2Type == rhs.id2Type))
|
|
return false;
|
|
if (!(this->time == rhs.time))
|
|
return false;
|
|
if (!(this->dataVersion == rhs.dataVersion))
|
|
return false;
|
|
if (!(this->data == rhs.data))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const TaoAssocGetResult &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const TaoAssocGetResult & ) const;
|
|
|
|
uint32_t read(apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
class TaoAssocGetResult;
|
|
void swap(TaoAssocGetResult &a, TaoAssocGetResult &b);
|
|
|
|
} // namespace
|
|
|
|
#endif
|