Lei, HUANG
7de3f31fd0
* feat: support c++ targets * fix: compile all protos under ./proto * chore: Apply suggestions from code review --------- Co-authored-by: Yingwen <realevenyag@gmail.com>
2035 lines
70 KiB
C++
2035 lines
70 KiB
C++
// Generated by the protocol buffer compiler. DO NOT EDIT!
|
|
// source: greptime/v1/common.proto
|
|
|
|
#ifndef GOOGLE_PROTOBUF_INCLUDED_greptime_2fv1_2fcommon_2eproto
|
|
#define GOOGLE_PROTOBUF_INCLUDED_greptime_2fv1_2fcommon_2eproto
|
|
|
|
#include <limits>
|
|
#include <string>
|
|
|
|
#include <google/protobuf/port_def.inc>
|
|
#if PROTOBUF_VERSION < 3021000
|
|
#error This file was generated by a newer version of protoc which is
|
|
#error incompatible with your Protocol Buffer headers. Please update
|
|
#error your headers.
|
|
#endif
|
|
#if 3021006 < PROTOBUF_MIN_PROTOC_VERSION
|
|
#error This file was generated by an older version of protoc which is
|
|
#error incompatible with your Protocol Buffer headers. Please
|
|
#error regenerate this file with a newer version of protoc.
|
|
#endif
|
|
|
|
#include <google/protobuf/port_undef.inc>
|
|
#include <google/protobuf/io/coded_stream.h>
|
|
#include <google/protobuf/arena.h>
|
|
#include <google/protobuf/arenastring.h>
|
|
#include <google/protobuf/generated_message_bases.h>
|
|
#include <google/protobuf/generated_message_util.h>
|
|
#include <google/protobuf/metadata_lite.h>
|
|
#include <google/protobuf/generated_message_reflection.h>
|
|
#include <google/protobuf/message.h>
|
|
#include <google/protobuf/repeated_field.h> // IWYU pragma: export
|
|
#include <google/protobuf/extension_set.h> // IWYU pragma: export
|
|
#include <google/protobuf/unknown_field_set.h>
|
|
// @@protoc_insertion_point(includes)
|
|
#include <google/protobuf/port_def.inc>
|
|
#define PROTOBUF_INTERNAL_EXPORT_greptime_2fv1_2fcommon_2eproto
|
|
PROTOBUF_NAMESPACE_OPEN
|
|
namespace internal {
|
|
class AnyMetadata;
|
|
} // namespace internal
|
|
PROTOBUF_NAMESPACE_CLOSE
|
|
|
|
// Internal implementation detail -- do not use these members.
|
|
struct TableStruct_greptime_2fv1_2fcommon_2eproto {
|
|
static const uint32_t offsets[];
|
|
};
|
|
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_greptime_2fv1_2fcommon_2eproto;
|
|
namespace greptime {
|
|
namespace v1 {
|
|
class AffectedRows;
|
|
struct AffectedRowsDefaultTypeInternal;
|
|
extern AffectedRowsDefaultTypeInternal _AffectedRows_default_instance_;
|
|
class AuthHeader;
|
|
struct AuthHeaderDefaultTypeInternal;
|
|
extern AuthHeaderDefaultTypeInternal _AuthHeader_default_instance_;
|
|
class Basic;
|
|
struct BasicDefaultTypeInternal;
|
|
extern BasicDefaultTypeInternal _Basic_default_instance_;
|
|
class FlightMetadata;
|
|
struct FlightMetadataDefaultTypeInternal;
|
|
extern FlightMetadataDefaultTypeInternal _FlightMetadata_default_instance_;
|
|
class RequestHeader;
|
|
struct RequestHeaderDefaultTypeInternal;
|
|
extern RequestHeaderDefaultTypeInternal _RequestHeader_default_instance_;
|
|
class ResponseHeader;
|
|
struct ResponseHeaderDefaultTypeInternal;
|
|
extern ResponseHeaderDefaultTypeInternal _ResponseHeader_default_instance_;
|
|
class Token;
|
|
struct TokenDefaultTypeInternal;
|
|
extern TokenDefaultTypeInternal _Token_default_instance_;
|
|
} // namespace v1
|
|
} // namespace greptime
|
|
PROTOBUF_NAMESPACE_OPEN
|
|
template<> ::greptime::v1::AffectedRows* Arena::CreateMaybeMessage<::greptime::v1::AffectedRows>(Arena*);
|
|
template<> ::greptime::v1::AuthHeader* Arena::CreateMaybeMessage<::greptime::v1::AuthHeader>(Arena*);
|
|
template<> ::greptime::v1::Basic* Arena::CreateMaybeMessage<::greptime::v1::Basic>(Arena*);
|
|
template<> ::greptime::v1::FlightMetadata* Arena::CreateMaybeMessage<::greptime::v1::FlightMetadata>(Arena*);
|
|
template<> ::greptime::v1::RequestHeader* Arena::CreateMaybeMessage<::greptime::v1::RequestHeader>(Arena*);
|
|
template<> ::greptime::v1::ResponseHeader* Arena::CreateMaybeMessage<::greptime::v1::ResponseHeader>(Arena*);
|
|
template<> ::greptime::v1::Token* Arena::CreateMaybeMessage<::greptime::v1::Token>(Arena*);
|
|
PROTOBUF_NAMESPACE_CLOSE
|
|
namespace greptime {
|
|
namespace v1 {
|
|
|
|
// ===================================================================
|
|
|
|
class ResponseHeader final :
|
|
public ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:greptime.v1.ResponseHeader) */ {
|
|
public:
|
|
inline ResponseHeader() : ResponseHeader(nullptr) {}
|
|
explicit PROTOBUF_CONSTEXPR ResponseHeader(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
|
|
|
|
ResponseHeader(const ResponseHeader& from);
|
|
ResponseHeader(ResponseHeader&& from) noexcept
|
|
: ResponseHeader() {
|
|
*this = ::std::move(from);
|
|
}
|
|
|
|
inline ResponseHeader& operator=(const ResponseHeader& from) {
|
|
CopyFrom(from);
|
|
return *this;
|
|
}
|
|
inline ResponseHeader& operator=(ResponseHeader&& from) noexcept {
|
|
if (this == &from) return *this;
|
|
if (GetOwningArena() == from.GetOwningArena()
|
|
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
|
|
&& GetOwningArena() != nullptr
|
|
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
|
|
) {
|
|
InternalSwap(&from);
|
|
} else {
|
|
CopyFrom(from);
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
|
|
return GetDescriptor();
|
|
}
|
|
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
|
|
return default_instance().GetMetadata().descriptor;
|
|
}
|
|
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
|
|
return default_instance().GetMetadata().reflection;
|
|
}
|
|
static const ResponseHeader& default_instance() {
|
|
return *internal_default_instance();
|
|
}
|
|
static inline const ResponseHeader* internal_default_instance() {
|
|
return reinterpret_cast<const ResponseHeader*>(
|
|
&_ResponseHeader_default_instance_);
|
|
}
|
|
static constexpr int kIndexInFileMessages =
|
|
0;
|
|
|
|
friend void swap(ResponseHeader& a, ResponseHeader& b) {
|
|
a.Swap(&b);
|
|
}
|
|
inline void Swap(ResponseHeader* other) {
|
|
if (other == this) return;
|
|
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
|
|
if (GetOwningArena() != nullptr &&
|
|
GetOwningArena() == other->GetOwningArena()) {
|
|
#else // PROTOBUF_FORCE_COPY_IN_SWAP
|
|
if (GetOwningArena() == other->GetOwningArena()) {
|
|
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
|
|
InternalSwap(other);
|
|
} else {
|
|
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
|
|
}
|
|
}
|
|
void UnsafeArenaSwap(ResponseHeader* other) {
|
|
if (other == this) return;
|
|
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
|
|
InternalSwap(other);
|
|
}
|
|
|
|
// implements Message ----------------------------------------------
|
|
|
|
ResponseHeader* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
|
|
return CreateMaybeMessage<ResponseHeader>(arena);
|
|
}
|
|
using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyFrom;
|
|
inline void CopyFrom(const ResponseHeader& from) {
|
|
::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl(*this, from);
|
|
}
|
|
using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeFrom;
|
|
void MergeFrom(const ResponseHeader& from) {
|
|
::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl(*this, from);
|
|
}
|
|
public:
|
|
|
|
private:
|
|
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
|
|
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
|
|
return "greptime.v1.ResponseHeader";
|
|
}
|
|
protected:
|
|
explicit ResponseHeader(::PROTOBUF_NAMESPACE_ID::Arena* arena,
|
|
bool is_message_owned = false);
|
|
public:
|
|
|
|
static const ClassData _class_data_;
|
|
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
|
|
|
|
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
|
|
|
|
// nested types ----------------------------------------------------
|
|
|
|
// accessors -------------------------------------------------------
|
|
|
|
// @@protoc_insertion_point(class_scope:greptime.v1.ResponseHeader)
|
|
private:
|
|
class _Internal;
|
|
|
|
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
|
|
typedef void InternalArenaConstructable_;
|
|
typedef void DestructorSkippable_;
|
|
struct Impl_ {
|
|
};
|
|
friend struct ::TableStruct_greptime_2fv1_2fcommon_2eproto;
|
|
};
|
|
// -------------------------------------------------------------------
|
|
|
|
class RequestHeader final :
|
|
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:greptime.v1.RequestHeader) */ {
|
|
public:
|
|
inline RequestHeader() : RequestHeader(nullptr) {}
|
|
~RequestHeader() override;
|
|
explicit PROTOBUF_CONSTEXPR RequestHeader(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
|
|
|
|
RequestHeader(const RequestHeader& from);
|
|
RequestHeader(RequestHeader&& from) noexcept
|
|
: RequestHeader() {
|
|
*this = ::std::move(from);
|
|
}
|
|
|
|
inline RequestHeader& operator=(const RequestHeader& from) {
|
|
CopyFrom(from);
|
|
return *this;
|
|
}
|
|
inline RequestHeader& operator=(RequestHeader&& from) noexcept {
|
|
if (this == &from) return *this;
|
|
if (GetOwningArena() == from.GetOwningArena()
|
|
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
|
|
&& GetOwningArena() != nullptr
|
|
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
|
|
) {
|
|
InternalSwap(&from);
|
|
} else {
|
|
CopyFrom(from);
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
|
|
return GetDescriptor();
|
|
}
|
|
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
|
|
return default_instance().GetMetadata().descriptor;
|
|
}
|
|
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
|
|
return default_instance().GetMetadata().reflection;
|
|
}
|
|
static const RequestHeader& default_instance() {
|
|
return *internal_default_instance();
|
|
}
|
|
static inline const RequestHeader* internal_default_instance() {
|
|
return reinterpret_cast<const RequestHeader*>(
|
|
&_RequestHeader_default_instance_);
|
|
}
|
|
static constexpr int kIndexInFileMessages =
|
|
1;
|
|
|
|
friend void swap(RequestHeader& a, RequestHeader& b) {
|
|
a.Swap(&b);
|
|
}
|
|
inline void Swap(RequestHeader* other) {
|
|
if (other == this) return;
|
|
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
|
|
if (GetOwningArena() != nullptr &&
|
|
GetOwningArena() == other->GetOwningArena()) {
|
|
#else // PROTOBUF_FORCE_COPY_IN_SWAP
|
|
if (GetOwningArena() == other->GetOwningArena()) {
|
|
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
|
|
InternalSwap(other);
|
|
} else {
|
|
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
|
|
}
|
|
}
|
|
void UnsafeArenaSwap(RequestHeader* other) {
|
|
if (other == this) return;
|
|
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
|
|
InternalSwap(other);
|
|
}
|
|
|
|
// implements Message ----------------------------------------------
|
|
|
|
RequestHeader* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
|
|
return CreateMaybeMessage<RequestHeader>(arena);
|
|
}
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
|
|
void CopyFrom(const RequestHeader& from);
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
|
|
void MergeFrom( const RequestHeader& from) {
|
|
RequestHeader::MergeImpl(*this, from);
|
|
}
|
|
private:
|
|
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
|
|
public:
|
|
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
|
|
bool IsInitialized() const final;
|
|
|
|
size_t ByteSizeLong() const final;
|
|
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
|
|
uint8_t* _InternalSerialize(
|
|
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
|
|
int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
|
|
|
|
private:
|
|
void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
|
|
void SharedDtor();
|
|
void SetCachedSize(int size) const final;
|
|
void InternalSwap(RequestHeader* other);
|
|
|
|
private:
|
|
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
|
|
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
|
|
return "greptime.v1.RequestHeader";
|
|
}
|
|
protected:
|
|
explicit RequestHeader(::PROTOBUF_NAMESPACE_ID::Arena* arena,
|
|
bool is_message_owned = false);
|
|
public:
|
|
|
|
static const ClassData _class_data_;
|
|
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
|
|
|
|
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
|
|
|
|
// nested types ----------------------------------------------------
|
|
|
|
// accessors -------------------------------------------------------
|
|
|
|
enum : int {
|
|
kCatalogFieldNumber = 1,
|
|
kSchemaFieldNumber = 2,
|
|
kDbnameFieldNumber = 4,
|
|
kAuthorizationFieldNumber = 3,
|
|
kTraceIdFieldNumber = 5,
|
|
kSpanIdFieldNumber = 6,
|
|
};
|
|
// string catalog = 1;
|
|
void clear_catalog();
|
|
const std::string& catalog() const;
|
|
template <typename ArgT0 = const std::string&, typename... ArgT>
|
|
void set_catalog(ArgT0&& arg0, ArgT... args);
|
|
std::string* mutable_catalog();
|
|
PROTOBUF_NODISCARD std::string* release_catalog();
|
|
void set_allocated_catalog(std::string* catalog);
|
|
private:
|
|
const std::string& _internal_catalog() const;
|
|
inline PROTOBUF_ALWAYS_INLINE void _internal_set_catalog(const std::string& value);
|
|
std::string* _internal_mutable_catalog();
|
|
public:
|
|
|
|
// string schema = 2;
|
|
void clear_schema();
|
|
const std::string& schema() const;
|
|
template <typename ArgT0 = const std::string&, typename... ArgT>
|
|
void set_schema(ArgT0&& arg0, ArgT... args);
|
|
std::string* mutable_schema();
|
|
PROTOBUF_NODISCARD std::string* release_schema();
|
|
void set_allocated_schema(std::string* schema);
|
|
private:
|
|
const std::string& _internal_schema() const;
|
|
inline PROTOBUF_ALWAYS_INLINE void _internal_set_schema(const std::string& value);
|
|
std::string* _internal_mutable_schema();
|
|
public:
|
|
|
|
// string dbname = 4;
|
|
void clear_dbname();
|
|
const std::string& dbname() const;
|
|
template <typename ArgT0 = const std::string&, typename... ArgT>
|
|
void set_dbname(ArgT0&& arg0, ArgT... args);
|
|
std::string* mutable_dbname();
|
|
PROTOBUF_NODISCARD std::string* release_dbname();
|
|
void set_allocated_dbname(std::string* dbname);
|
|
private:
|
|
const std::string& _internal_dbname() const;
|
|
inline PROTOBUF_ALWAYS_INLINE void _internal_set_dbname(const std::string& value);
|
|
std::string* _internal_mutable_dbname();
|
|
public:
|
|
|
|
// .greptime.v1.AuthHeader authorization = 3;
|
|
bool has_authorization() const;
|
|
private:
|
|
bool _internal_has_authorization() const;
|
|
public:
|
|
void clear_authorization();
|
|
const ::greptime::v1::AuthHeader& authorization() const;
|
|
PROTOBUF_NODISCARD ::greptime::v1::AuthHeader* release_authorization();
|
|
::greptime::v1::AuthHeader* mutable_authorization();
|
|
void set_allocated_authorization(::greptime::v1::AuthHeader* authorization);
|
|
private:
|
|
const ::greptime::v1::AuthHeader& _internal_authorization() const;
|
|
::greptime::v1::AuthHeader* _internal_mutable_authorization();
|
|
public:
|
|
void unsafe_arena_set_allocated_authorization(
|
|
::greptime::v1::AuthHeader* authorization);
|
|
::greptime::v1::AuthHeader* unsafe_arena_release_authorization();
|
|
|
|
// optional uint64 trace_id = 5;
|
|
bool has_trace_id() const;
|
|
private:
|
|
bool _internal_has_trace_id() const;
|
|
public:
|
|
void clear_trace_id();
|
|
uint64_t trace_id() const;
|
|
void set_trace_id(uint64_t value);
|
|
private:
|
|
uint64_t _internal_trace_id() const;
|
|
void _internal_set_trace_id(uint64_t value);
|
|
public:
|
|
|
|
// optional uint64 span_id = 6;
|
|
bool has_span_id() const;
|
|
private:
|
|
bool _internal_has_span_id() const;
|
|
public:
|
|
void clear_span_id();
|
|
uint64_t span_id() const;
|
|
void set_span_id(uint64_t value);
|
|
private:
|
|
uint64_t _internal_span_id() const;
|
|
void _internal_set_span_id(uint64_t value);
|
|
public:
|
|
|
|
// @@protoc_insertion_point(class_scope:greptime.v1.RequestHeader)
|
|
private:
|
|
class _Internal;
|
|
|
|
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
|
|
typedef void InternalArenaConstructable_;
|
|
typedef void DestructorSkippable_;
|
|
struct Impl_ {
|
|
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
|
|
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
|
|
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr catalog_;
|
|
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr schema_;
|
|
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr dbname_;
|
|
::greptime::v1::AuthHeader* authorization_;
|
|
uint64_t trace_id_;
|
|
uint64_t span_id_;
|
|
};
|
|
union { Impl_ _impl_; };
|
|
friend struct ::TableStruct_greptime_2fv1_2fcommon_2eproto;
|
|
};
|
|
// -------------------------------------------------------------------
|
|
|
|
class AuthHeader final :
|
|
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:greptime.v1.AuthHeader) */ {
|
|
public:
|
|
inline AuthHeader() : AuthHeader(nullptr) {}
|
|
~AuthHeader() override;
|
|
explicit PROTOBUF_CONSTEXPR AuthHeader(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
|
|
|
|
AuthHeader(const AuthHeader& from);
|
|
AuthHeader(AuthHeader&& from) noexcept
|
|
: AuthHeader() {
|
|
*this = ::std::move(from);
|
|
}
|
|
|
|
inline AuthHeader& operator=(const AuthHeader& from) {
|
|
CopyFrom(from);
|
|
return *this;
|
|
}
|
|
inline AuthHeader& operator=(AuthHeader&& from) noexcept {
|
|
if (this == &from) return *this;
|
|
if (GetOwningArena() == from.GetOwningArena()
|
|
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
|
|
&& GetOwningArena() != nullptr
|
|
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
|
|
) {
|
|
InternalSwap(&from);
|
|
} else {
|
|
CopyFrom(from);
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
|
|
return GetDescriptor();
|
|
}
|
|
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
|
|
return default_instance().GetMetadata().descriptor;
|
|
}
|
|
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
|
|
return default_instance().GetMetadata().reflection;
|
|
}
|
|
static const AuthHeader& default_instance() {
|
|
return *internal_default_instance();
|
|
}
|
|
enum AuthSchemeCase {
|
|
kBasic = 1,
|
|
kToken = 2,
|
|
AUTH_SCHEME_NOT_SET = 0,
|
|
};
|
|
|
|
static inline const AuthHeader* internal_default_instance() {
|
|
return reinterpret_cast<const AuthHeader*>(
|
|
&_AuthHeader_default_instance_);
|
|
}
|
|
static constexpr int kIndexInFileMessages =
|
|
2;
|
|
|
|
friend void swap(AuthHeader& a, AuthHeader& b) {
|
|
a.Swap(&b);
|
|
}
|
|
inline void Swap(AuthHeader* other) {
|
|
if (other == this) return;
|
|
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
|
|
if (GetOwningArena() != nullptr &&
|
|
GetOwningArena() == other->GetOwningArena()) {
|
|
#else // PROTOBUF_FORCE_COPY_IN_SWAP
|
|
if (GetOwningArena() == other->GetOwningArena()) {
|
|
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
|
|
InternalSwap(other);
|
|
} else {
|
|
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
|
|
}
|
|
}
|
|
void UnsafeArenaSwap(AuthHeader* other) {
|
|
if (other == this) return;
|
|
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
|
|
InternalSwap(other);
|
|
}
|
|
|
|
// implements Message ----------------------------------------------
|
|
|
|
AuthHeader* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
|
|
return CreateMaybeMessage<AuthHeader>(arena);
|
|
}
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
|
|
void CopyFrom(const AuthHeader& from);
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
|
|
void MergeFrom( const AuthHeader& from) {
|
|
AuthHeader::MergeImpl(*this, from);
|
|
}
|
|
private:
|
|
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
|
|
public:
|
|
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
|
|
bool IsInitialized() const final;
|
|
|
|
size_t ByteSizeLong() const final;
|
|
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
|
|
uint8_t* _InternalSerialize(
|
|
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
|
|
int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
|
|
|
|
private:
|
|
void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
|
|
void SharedDtor();
|
|
void SetCachedSize(int size) const final;
|
|
void InternalSwap(AuthHeader* other);
|
|
|
|
private:
|
|
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
|
|
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
|
|
return "greptime.v1.AuthHeader";
|
|
}
|
|
protected:
|
|
explicit AuthHeader(::PROTOBUF_NAMESPACE_ID::Arena* arena,
|
|
bool is_message_owned = false);
|
|
public:
|
|
|
|
static const ClassData _class_data_;
|
|
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
|
|
|
|
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
|
|
|
|
// nested types ----------------------------------------------------
|
|
|
|
// accessors -------------------------------------------------------
|
|
|
|
enum : int {
|
|
kBasicFieldNumber = 1,
|
|
kTokenFieldNumber = 2,
|
|
};
|
|
// .greptime.v1.Basic basic = 1;
|
|
bool has_basic() const;
|
|
private:
|
|
bool _internal_has_basic() const;
|
|
public:
|
|
void clear_basic();
|
|
const ::greptime::v1::Basic& basic() const;
|
|
PROTOBUF_NODISCARD ::greptime::v1::Basic* release_basic();
|
|
::greptime::v1::Basic* mutable_basic();
|
|
void set_allocated_basic(::greptime::v1::Basic* basic);
|
|
private:
|
|
const ::greptime::v1::Basic& _internal_basic() const;
|
|
::greptime::v1::Basic* _internal_mutable_basic();
|
|
public:
|
|
void unsafe_arena_set_allocated_basic(
|
|
::greptime::v1::Basic* basic);
|
|
::greptime::v1::Basic* unsafe_arena_release_basic();
|
|
|
|
// .greptime.v1.Token token = 2;
|
|
bool has_token() const;
|
|
private:
|
|
bool _internal_has_token() const;
|
|
public:
|
|
void clear_token();
|
|
const ::greptime::v1::Token& token() const;
|
|
PROTOBUF_NODISCARD ::greptime::v1::Token* release_token();
|
|
::greptime::v1::Token* mutable_token();
|
|
void set_allocated_token(::greptime::v1::Token* token);
|
|
private:
|
|
const ::greptime::v1::Token& _internal_token() const;
|
|
::greptime::v1::Token* _internal_mutable_token();
|
|
public:
|
|
void unsafe_arena_set_allocated_token(
|
|
::greptime::v1::Token* token);
|
|
::greptime::v1::Token* unsafe_arena_release_token();
|
|
|
|
void clear_auth_scheme();
|
|
AuthSchemeCase auth_scheme_case() const;
|
|
// @@protoc_insertion_point(class_scope:greptime.v1.AuthHeader)
|
|
private:
|
|
class _Internal;
|
|
void set_has_basic();
|
|
void set_has_token();
|
|
|
|
inline bool has_auth_scheme() const;
|
|
inline void clear_has_auth_scheme();
|
|
|
|
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
|
|
typedef void InternalArenaConstructable_;
|
|
typedef void DestructorSkippable_;
|
|
struct Impl_ {
|
|
union AuthSchemeUnion {
|
|
constexpr AuthSchemeUnion() : _constinit_{} {}
|
|
::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
|
|
::greptime::v1::Basic* basic_;
|
|
::greptime::v1::Token* token_;
|
|
} auth_scheme_;
|
|
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
|
|
uint32_t _oneof_case_[1];
|
|
|
|
};
|
|
union { Impl_ _impl_; };
|
|
friend struct ::TableStruct_greptime_2fv1_2fcommon_2eproto;
|
|
};
|
|
// -------------------------------------------------------------------
|
|
|
|
class Basic final :
|
|
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:greptime.v1.Basic) */ {
|
|
public:
|
|
inline Basic() : Basic(nullptr) {}
|
|
~Basic() override;
|
|
explicit PROTOBUF_CONSTEXPR Basic(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
|
|
|
|
Basic(const Basic& from);
|
|
Basic(Basic&& from) noexcept
|
|
: Basic() {
|
|
*this = ::std::move(from);
|
|
}
|
|
|
|
inline Basic& operator=(const Basic& from) {
|
|
CopyFrom(from);
|
|
return *this;
|
|
}
|
|
inline Basic& operator=(Basic&& from) noexcept {
|
|
if (this == &from) return *this;
|
|
if (GetOwningArena() == from.GetOwningArena()
|
|
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
|
|
&& GetOwningArena() != nullptr
|
|
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
|
|
) {
|
|
InternalSwap(&from);
|
|
} else {
|
|
CopyFrom(from);
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
|
|
return GetDescriptor();
|
|
}
|
|
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
|
|
return default_instance().GetMetadata().descriptor;
|
|
}
|
|
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
|
|
return default_instance().GetMetadata().reflection;
|
|
}
|
|
static const Basic& default_instance() {
|
|
return *internal_default_instance();
|
|
}
|
|
static inline const Basic* internal_default_instance() {
|
|
return reinterpret_cast<const Basic*>(
|
|
&_Basic_default_instance_);
|
|
}
|
|
static constexpr int kIndexInFileMessages =
|
|
3;
|
|
|
|
friend void swap(Basic& a, Basic& b) {
|
|
a.Swap(&b);
|
|
}
|
|
inline void Swap(Basic* other) {
|
|
if (other == this) return;
|
|
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
|
|
if (GetOwningArena() != nullptr &&
|
|
GetOwningArena() == other->GetOwningArena()) {
|
|
#else // PROTOBUF_FORCE_COPY_IN_SWAP
|
|
if (GetOwningArena() == other->GetOwningArena()) {
|
|
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
|
|
InternalSwap(other);
|
|
} else {
|
|
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
|
|
}
|
|
}
|
|
void UnsafeArenaSwap(Basic* other) {
|
|
if (other == this) return;
|
|
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
|
|
InternalSwap(other);
|
|
}
|
|
|
|
// implements Message ----------------------------------------------
|
|
|
|
Basic* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
|
|
return CreateMaybeMessage<Basic>(arena);
|
|
}
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
|
|
void CopyFrom(const Basic& from);
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
|
|
void MergeFrom( const Basic& from) {
|
|
Basic::MergeImpl(*this, from);
|
|
}
|
|
private:
|
|
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
|
|
public:
|
|
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
|
|
bool IsInitialized() const final;
|
|
|
|
size_t ByteSizeLong() const final;
|
|
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
|
|
uint8_t* _InternalSerialize(
|
|
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
|
|
int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
|
|
|
|
private:
|
|
void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
|
|
void SharedDtor();
|
|
void SetCachedSize(int size) const final;
|
|
void InternalSwap(Basic* other);
|
|
|
|
private:
|
|
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
|
|
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
|
|
return "greptime.v1.Basic";
|
|
}
|
|
protected:
|
|
explicit Basic(::PROTOBUF_NAMESPACE_ID::Arena* arena,
|
|
bool is_message_owned = false);
|
|
public:
|
|
|
|
static const ClassData _class_data_;
|
|
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
|
|
|
|
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
|
|
|
|
// nested types ----------------------------------------------------
|
|
|
|
// accessors -------------------------------------------------------
|
|
|
|
enum : int {
|
|
kUsernameFieldNumber = 1,
|
|
kPasswordFieldNumber = 2,
|
|
};
|
|
// string username = 1;
|
|
void clear_username();
|
|
const std::string& username() const;
|
|
template <typename ArgT0 = const std::string&, typename... ArgT>
|
|
void set_username(ArgT0&& arg0, ArgT... args);
|
|
std::string* mutable_username();
|
|
PROTOBUF_NODISCARD std::string* release_username();
|
|
void set_allocated_username(std::string* username);
|
|
private:
|
|
const std::string& _internal_username() const;
|
|
inline PROTOBUF_ALWAYS_INLINE void _internal_set_username(const std::string& value);
|
|
std::string* _internal_mutable_username();
|
|
public:
|
|
|
|
// string password = 2;
|
|
void clear_password();
|
|
const std::string& password() const;
|
|
template <typename ArgT0 = const std::string&, typename... ArgT>
|
|
void set_password(ArgT0&& arg0, ArgT... args);
|
|
std::string* mutable_password();
|
|
PROTOBUF_NODISCARD std::string* release_password();
|
|
void set_allocated_password(std::string* password);
|
|
private:
|
|
const std::string& _internal_password() const;
|
|
inline PROTOBUF_ALWAYS_INLINE void _internal_set_password(const std::string& value);
|
|
std::string* _internal_mutable_password();
|
|
public:
|
|
|
|
// @@protoc_insertion_point(class_scope:greptime.v1.Basic)
|
|
private:
|
|
class _Internal;
|
|
|
|
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
|
|
typedef void InternalArenaConstructable_;
|
|
typedef void DestructorSkippable_;
|
|
struct Impl_ {
|
|
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr username_;
|
|
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr password_;
|
|
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
|
|
};
|
|
union { Impl_ _impl_; };
|
|
friend struct ::TableStruct_greptime_2fv1_2fcommon_2eproto;
|
|
};
|
|
// -------------------------------------------------------------------
|
|
|
|
class Token final :
|
|
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:greptime.v1.Token) */ {
|
|
public:
|
|
inline Token() : Token(nullptr) {}
|
|
~Token() override;
|
|
explicit PROTOBUF_CONSTEXPR Token(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
|
|
|
|
Token(const Token& from);
|
|
Token(Token&& from) noexcept
|
|
: Token() {
|
|
*this = ::std::move(from);
|
|
}
|
|
|
|
inline Token& operator=(const Token& from) {
|
|
CopyFrom(from);
|
|
return *this;
|
|
}
|
|
inline Token& operator=(Token&& from) noexcept {
|
|
if (this == &from) return *this;
|
|
if (GetOwningArena() == from.GetOwningArena()
|
|
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
|
|
&& GetOwningArena() != nullptr
|
|
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
|
|
) {
|
|
InternalSwap(&from);
|
|
} else {
|
|
CopyFrom(from);
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
|
|
return GetDescriptor();
|
|
}
|
|
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
|
|
return default_instance().GetMetadata().descriptor;
|
|
}
|
|
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
|
|
return default_instance().GetMetadata().reflection;
|
|
}
|
|
static const Token& default_instance() {
|
|
return *internal_default_instance();
|
|
}
|
|
static inline const Token* internal_default_instance() {
|
|
return reinterpret_cast<const Token*>(
|
|
&_Token_default_instance_);
|
|
}
|
|
static constexpr int kIndexInFileMessages =
|
|
4;
|
|
|
|
friend void swap(Token& a, Token& b) {
|
|
a.Swap(&b);
|
|
}
|
|
inline void Swap(Token* other) {
|
|
if (other == this) return;
|
|
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
|
|
if (GetOwningArena() != nullptr &&
|
|
GetOwningArena() == other->GetOwningArena()) {
|
|
#else // PROTOBUF_FORCE_COPY_IN_SWAP
|
|
if (GetOwningArena() == other->GetOwningArena()) {
|
|
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
|
|
InternalSwap(other);
|
|
} else {
|
|
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
|
|
}
|
|
}
|
|
void UnsafeArenaSwap(Token* other) {
|
|
if (other == this) return;
|
|
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
|
|
InternalSwap(other);
|
|
}
|
|
|
|
// implements Message ----------------------------------------------
|
|
|
|
Token* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
|
|
return CreateMaybeMessage<Token>(arena);
|
|
}
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
|
|
void CopyFrom(const Token& from);
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
|
|
void MergeFrom( const Token& from) {
|
|
Token::MergeImpl(*this, from);
|
|
}
|
|
private:
|
|
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
|
|
public:
|
|
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
|
|
bool IsInitialized() const final;
|
|
|
|
size_t ByteSizeLong() const final;
|
|
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
|
|
uint8_t* _InternalSerialize(
|
|
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
|
|
int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
|
|
|
|
private:
|
|
void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
|
|
void SharedDtor();
|
|
void SetCachedSize(int size) const final;
|
|
void InternalSwap(Token* other);
|
|
|
|
private:
|
|
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
|
|
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
|
|
return "greptime.v1.Token";
|
|
}
|
|
protected:
|
|
explicit Token(::PROTOBUF_NAMESPACE_ID::Arena* arena,
|
|
bool is_message_owned = false);
|
|
public:
|
|
|
|
static const ClassData _class_data_;
|
|
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
|
|
|
|
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
|
|
|
|
// nested types ----------------------------------------------------
|
|
|
|
// accessors -------------------------------------------------------
|
|
|
|
enum : int {
|
|
kTokenFieldNumber = 1,
|
|
};
|
|
// string token = 1;
|
|
void clear_token();
|
|
const std::string& token() const;
|
|
template <typename ArgT0 = const std::string&, typename... ArgT>
|
|
void set_token(ArgT0&& arg0, ArgT... args);
|
|
std::string* mutable_token();
|
|
PROTOBUF_NODISCARD std::string* release_token();
|
|
void set_allocated_token(std::string* token);
|
|
private:
|
|
const std::string& _internal_token() const;
|
|
inline PROTOBUF_ALWAYS_INLINE void _internal_set_token(const std::string& value);
|
|
std::string* _internal_mutable_token();
|
|
public:
|
|
|
|
// @@protoc_insertion_point(class_scope:greptime.v1.Token)
|
|
private:
|
|
class _Internal;
|
|
|
|
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
|
|
typedef void InternalArenaConstructable_;
|
|
typedef void DestructorSkippable_;
|
|
struct Impl_ {
|
|
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr token_;
|
|
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
|
|
};
|
|
union { Impl_ _impl_; };
|
|
friend struct ::TableStruct_greptime_2fv1_2fcommon_2eproto;
|
|
};
|
|
// -------------------------------------------------------------------
|
|
|
|
class AffectedRows final :
|
|
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:greptime.v1.AffectedRows) */ {
|
|
public:
|
|
inline AffectedRows() : AffectedRows(nullptr) {}
|
|
~AffectedRows() override;
|
|
explicit PROTOBUF_CONSTEXPR AffectedRows(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
|
|
|
|
AffectedRows(const AffectedRows& from);
|
|
AffectedRows(AffectedRows&& from) noexcept
|
|
: AffectedRows() {
|
|
*this = ::std::move(from);
|
|
}
|
|
|
|
inline AffectedRows& operator=(const AffectedRows& from) {
|
|
CopyFrom(from);
|
|
return *this;
|
|
}
|
|
inline AffectedRows& operator=(AffectedRows&& from) noexcept {
|
|
if (this == &from) return *this;
|
|
if (GetOwningArena() == from.GetOwningArena()
|
|
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
|
|
&& GetOwningArena() != nullptr
|
|
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
|
|
) {
|
|
InternalSwap(&from);
|
|
} else {
|
|
CopyFrom(from);
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
|
|
return GetDescriptor();
|
|
}
|
|
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
|
|
return default_instance().GetMetadata().descriptor;
|
|
}
|
|
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
|
|
return default_instance().GetMetadata().reflection;
|
|
}
|
|
static const AffectedRows& default_instance() {
|
|
return *internal_default_instance();
|
|
}
|
|
static inline const AffectedRows* internal_default_instance() {
|
|
return reinterpret_cast<const AffectedRows*>(
|
|
&_AffectedRows_default_instance_);
|
|
}
|
|
static constexpr int kIndexInFileMessages =
|
|
5;
|
|
|
|
friend void swap(AffectedRows& a, AffectedRows& b) {
|
|
a.Swap(&b);
|
|
}
|
|
inline void Swap(AffectedRows* other) {
|
|
if (other == this) return;
|
|
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
|
|
if (GetOwningArena() != nullptr &&
|
|
GetOwningArena() == other->GetOwningArena()) {
|
|
#else // PROTOBUF_FORCE_COPY_IN_SWAP
|
|
if (GetOwningArena() == other->GetOwningArena()) {
|
|
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
|
|
InternalSwap(other);
|
|
} else {
|
|
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
|
|
}
|
|
}
|
|
void UnsafeArenaSwap(AffectedRows* other) {
|
|
if (other == this) return;
|
|
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
|
|
InternalSwap(other);
|
|
}
|
|
|
|
// implements Message ----------------------------------------------
|
|
|
|
AffectedRows* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
|
|
return CreateMaybeMessage<AffectedRows>(arena);
|
|
}
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
|
|
void CopyFrom(const AffectedRows& from);
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
|
|
void MergeFrom( const AffectedRows& from) {
|
|
AffectedRows::MergeImpl(*this, from);
|
|
}
|
|
private:
|
|
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
|
|
public:
|
|
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
|
|
bool IsInitialized() const final;
|
|
|
|
size_t ByteSizeLong() const final;
|
|
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
|
|
uint8_t* _InternalSerialize(
|
|
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
|
|
int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
|
|
|
|
private:
|
|
void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
|
|
void SharedDtor();
|
|
void SetCachedSize(int size) const final;
|
|
void InternalSwap(AffectedRows* other);
|
|
|
|
private:
|
|
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
|
|
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
|
|
return "greptime.v1.AffectedRows";
|
|
}
|
|
protected:
|
|
explicit AffectedRows(::PROTOBUF_NAMESPACE_ID::Arena* arena,
|
|
bool is_message_owned = false);
|
|
public:
|
|
|
|
static const ClassData _class_data_;
|
|
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
|
|
|
|
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
|
|
|
|
// nested types ----------------------------------------------------
|
|
|
|
// accessors -------------------------------------------------------
|
|
|
|
enum : int {
|
|
kValueFieldNumber = 1,
|
|
};
|
|
// uint32 value = 1;
|
|
void clear_value();
|
|
uint32_t value() const;
|
|
void set_value(uint32_t value);
|
|
private:
|
|
uint32_t _internal_value() const;
|
|
void _internal_set_value(uint32_t value);
|
|
public:
|
|
|
|
// @@protoc_insertion_point(class_scope:greptime.v1.AffectedRows)
|
|
private:
|
|
class _Internal;
|
|
|
|
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
|
|
typedef void InternalArenaConstructable_;
|
|
typedef void DestructorSkippable_;
|
|
struct Impl_ {
|
|
uint32_t value_;
|
|
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
|
|
};
|
|
union { Impl_ _impl_; };
|
|
friend struct ::TableStruct_greptime_2fv1_2fcommon_2eproto;
|
|
};
|
|
// -------------------------------------------------------------------
|
|
|
|
class FlightMetadata final :
|
|
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:greptime.v1.FlightMetadata) */ {
|
|
public:
|
|
inline FlightMetadata() : FlightMetadata(nullptr) {}
|
|
~FlightMetadata() override;
|
|
explicit PROTOBUF_CONSTEXPR FlightMetadata(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
|
|
|
|
FlightMetadata(const FlightMetadata& from);
|
|
FlightMetadata(FlightMetadata&& from) noexcept
|
|
: FlightMetadata() {
|
|
*this = ::std::move(from);
|
|
}
|
|
|
|
inline FlightMetadata& operator=(const FlightMetadata& from) {
|
|
CopyFrom(from);
|
|
return *this;
|
|
}
|
|
inline FlightMetadata& operator=(FlightMetadata&& from) noexcept {
|
|
if (this == &from) return *this;
|
|
if (GetOwningArena() == from.GetOwningArena()
|
|
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
|
|
&& GetOwningArena() != nullptr
|
|
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
|
|
) {
|
|
InternalSwap(&from);
|
|
} else {
|
|
CopyFrom(from);
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
|
|
return GetDescriptor();
|
|
}
|
|
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
|
|
return default_instance().GetMetadata().descriptor;
|
|
}
|
|
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
|
|
return default_instance().GetMetadata().reflection;
|
|
}
|
|
static const FlightMetadata& default_instance() {
|
|
return *internal_default_instance();
|
|
}
|
|
static inline const FlightMetadata* internal_default_instance() {
|
|
return reinterpret_cast<const FlightMetadata*>(
|
|
&_FlightMetadata_default_instance_);
|
|
}
|
|
static constexpr int kIndexInFileMessages =
|
|
6;
|
|
|
|
friend void swap(FlightMetadata& a, FlightMetadata& b) {
|
|
a.Swap(&b);
|
|
}
|
|
inline void Swap(FlightMetadata* other) {
|
|
if (other == this) return;
|
|
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
|
|
if (GetOwningArena() != nullptr &&
|
|
GetOwningArena() == other->GetOwningArena()) {
|
|
#else // PROTOBUF_FORCE_COPY_IN_SWAP
|
|
if (GetOwningArena() == other->GetOwningArena()) {
|
|
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
|
|
InternalSwap(other);
|
|
} else {
|
|
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
|
|
}
|
|
}
|
|
void UnsafeArenaSwap(FlightMetadata* other) {
|
|
if (other == this) return;
|
|
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
|
|
InternalSwap(other);
|
|
}
|
|
|
|
// implements Message ----------------------------------------------
|
|
|
|
FlightMetadata* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
|
|
return CreateMaybeMessage<FlightMetadata>(arena);
|
|
}
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
|
|
void CopyFrom(const FlightMetadata& from);
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
|
|
void MergeFrom( const FlightMetadata& from) {
|
|
FlightMetadata::MergeImpl(*this, from);
|
|
}
|
|
private:
|
|
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
|
|
public:
|
|
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
|
|
bool IsInitialized() const final;
|
|
|
|
size_t ByteSizeLong() const final;
|
|
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
|
|
uint8_t* _InternalSerialize(
|
|
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
|
|
int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
|
|
|
|
private:
|
|
void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
|
|
void SharedDtor();
|
|
void SetCachedSize(int size) const final;
|
|
void InternalSwap(FlightMetadata* other);
|
|
|
|
private:
|
|
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
|
|
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
|
|
return "greptime.v1.FlightMetadata";
|
|
}
|
|
protected:
|
|
explicit FlightMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena,
|
|
bool is_message_owned = false);
|
|
public:
|
|
|
|
static const ClassData _class_data_;
|
|
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
|
|
|
|
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
|
|
|
|
// nested types ----------------------------------------------------
|
|
|
|
// accessors -------------------------------------------------------
|
|
|
|
enum : int {
|
|
kAffectedRowsFieldNumber = 1,
|
|
};
|
|
// .greptime.v1.AffectedRows affected_rows = 1;
|
|
bool has_affected_rows() const;
|
|
private:
|
|
bool _internal_has_affected_rows() const;
|
|
public:
|
|
void clear_affected_rows();
|
|
const ::greptime::v1::AffectedRows& affected_rows() const;
|
|
PROTOBUF_NODISCARD ::greptime::v1::AffectedRows* release_affected_rows();
|
|
::greptime::v1::AffectedRows* mutable_affected_rows();
|
|
void set_allocated_affected_rows(::greptime::v1::AffectedRows* affected_rows);
|
|
private:
|
|
const ::greptime::v1::AffectedRows& _internal_affected_rows() const;
|
|
::greptime::v1::AffectedRows* _internal_mutable_affected_rows();
|
|
public:
|
|
void unsafe_arena_set_allocated_affected_rows(
|
|
::greptime::v1::AffectedRows* affected_rows);
|
|
::greptime::v1::AffectedRows* unsafe_arena_release_affected_rows();
|
|
|
|
// @@protoc_insertion_point(class_scope:greptime.v1.FlightMetadata)
|
|
private:
|
|
class _Internal;
|
|
|
|
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
|
|
typedef void InternalArenaConstructable_;
|
|
typedef void DestructorSkippable_;
|
|
struct Impl_ {
|
|
::greptime::v1::AffectedRows* affected_rows_;
|
|
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
|
|
};
|
|
union { Impl_ _impl_; };
|
|
friend struct ::TableStruct_greptime_2fv1_2fcommon_2eproto;
|
|
};
|
|
// ===================================================================
|
|
|
|
|
|
// ===================================================================
|
|
|
|
#ifdef __GNUC__
|
|
#pragma GCC diagnostic push
|
|
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
|
|
#endif // __GNUC__
|
|
// ResponseHeader
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
// RequestHeader
|
|
|
|
// string catalog = 1;
|
|
inline void RequestHeader::clear_catalog() {
|
|
_impl_.catalog_.ClearToEmpty();
|
|
}
|
|
inline const std::string& RequestHeader::catalog() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.RequestHeader.catalog)
|
|
return _internal_catalog();
|
|
}
|
|
template <typename ArgT0, typename... ArgT>
|
|
inline PROTOBUF_ALWAYS_INLINE
|
|
void RequestHeader::set_catalog(ArgT0&& arg0, ArgT... args) {
|
|
|
|
_impl_.catalog_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
|
|
// @@protoc_insertion_point(field_set:greptime.v1.RequestHeader.catalog)
|
|
}
|
|
inline std::string* RequestHeader::mutable_catalog() {
|
|
std::string* _s = _internal_mutable_catalog();
|
|
// @@protoc_insertion_point(field_mutable:greptime.v1.RequestHeader.catalog)
|
|
return _s;
|
|
}
|
|
inline const std::string& RequestHeader::_internal_catalog() const {
|
|
return _impl_.catalog_.Get();
|
|
}
|
|
inline void RequestHeader::_internal_set_catalog(const std::string& value) {
|
|
|
|
_impl_.catalog_.Set(value, GetArenaForAllocation());
|
|
}
|
|
inline std::string* RequestHeader::_internal_mutable_catalog() {
|
|
|
|
return _impl_.catalog_.Mutable(GetArenaForAllocation());
|
|
}
|
|
inline std::string* RequestHeader::release_catalog() {
|
|
// @@protoc_insertion_point(field_release:greptime.v1.RequestHeader.catalog)
|
|
return _impl_.catalog_.Release();
|
|
}
|
|
inline void RequestHeader::set_allocated_catalog(std::string* catalog) {
|
|
if (catalog != nullptr) {
|
|
|
|
} else {
|
|
|
|
}
|
|
_impl_.catalog_.SetAllocated(catalog, GetArenaForAllocation());
|
|
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
if (_impl_.catalog_.IsDefault()) {
|
|
_impl_.catalog_.Set("", GetArenaForAllocation());
|
|
}
|
|
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
// @@protoc_insertion_point(field_set_allocated:greptime.v1.RequestHeader.catalog)
|
|
}
|
|
|
|
// string schema = 2;
|
|
inline void RequestHeader::clear_schema() {
|
|
_impl_.schema_.ClearToEmpty();
|
|
}
|
|
inline const std::string& RequestHeader::schema() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.RequestHeader.schema)
|
|
return _internal_schema();
|
|
}
|
|
template <typename ArgT0, typename... ArgT>
|
|
inline PROTOBUF_ALWAYS_INLINE
|
|
void RequestHeader::set_schema(ArgT0&& arg0, ArgT... args) {
|
|
|
|
_impl_.schema_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
|
|
// @@protoc_insertion_point(field_set:greptime.v1.RequestHeader.schema)
|
|
}
|
|
inline std::string* RequestHeader::mutable_schema() {
|
|
std::string* _s = _internal_mutable_schema();
|
|
// @@protoc_insertion_point(field_mutable:greptime.v1.RequestHeader.schema)
|
|
return _s;
|
|
}
|
|
inline const std::string& RequestHeader::_internal_schema() const {
|
|
return _impl_.schema_.Get();
|
|
}
|
|
inline void RequestHeader::_internal_set_schema(const std::string& value) {
|
|
|
|
_impl_.schema_.Set(value, GetArenaForAllocation());
|
|
}
|
|
inline std::string* RequestHeader::_internal_mutable_schema() {
|
|
|
|
return _impl_.schema_.Mutable(GetArenaForAllocation());
|
|
}
|
|
inline std::string* RequestHeader::release_schema() {
|
|
// @@protoc_insertion_point(field_release:greptime.v1.RequestHeader.schema)
|
|
return _impl_.schema_.Release();
|
|
}
|
|
inline void RequestHeader::set_allocated_schema(std::string* schema) {
|
|
if (schema != nullptr) {
|
|
|
|
} else {
|
|
|
|
}
|
|
_impl_.schema_.SetAllocated(schema, GetArenaForAllocation());
|
|
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
if (_impl_.schema_.IsDefault()) {
|
|
_impl_.schema_.Set("", GetArenaForAllocation());
|
|
}
|
|
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
// @@protoc_insertion_point(field_set_allocated:greptime.v1.RequestHeader.schema)
|
|
}
|
|
|
|
// .greptime.v1.AuthHeader authorization = 3;
|
|
inline bool RequestHeader::_internal_has_authorization() const {
|
|
return this != internal_default_instance() && _impl_.authorization_ != nullptr;
|
|
}
|
|
inline bool RequestHeader::has_authorization() const {
|
|
return _internal_has_authorization();
|
|
}
|
|
inline void RequestHeader::clear_authorization() {
|
|
if (GetArenaForAllocation() == nullptr && _impl_.authorization_ != nullptr) {
|
|
delete _impl_.authorization_;
|
|
}
|
|
_impl_.authorization_ = nullptr;
|
|
}
|
|
inline const ::greptime::v1::AuthHeader& RequestHeader::_internal_authorization() const {
|
|
const ::greptime::v1::AuthHeader* p = _impl_.authorization_;
|
|
return p != nullptr ? *p : reinterpret_cast<const ::greptime::v1::AuthHeader&>(
|
|
::greptime::v1::_AuthHeader_default_instance_);
|
|
}
|
|
inline const ::greptime::v1::AuthHeader& RequestHeader::authorization() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.RequestHeader.authorization)
|
|
return _internal_authorization();
|
|
}
|
|
inline void RequestHeader::unsafe_arena_set_allocated_authorization(
|
|
::greptime::v1::AuthHeader* authorization) {
|
|
if (GetArenaForAllocation() == nullptr) {
|
|
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.authorization_);
|
|
}
|
|
_impl_.authorization_ = authorization;
|
|
if (authorization) {
|
|
|
|
} else {
|
|
|
|
}
|
|
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:greptime.v1.RequestHeader.authorization)
|
|
}
|
|
inline ::greptime::v1::AuthHeader* RequestHeader::release_authorization() {
|
|
|
|
::greptime::v1::AuthHeader* temp = _impl_.authorization_;
|
|
_impl_.authorization_ = nullptr;
|
|
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
|
|
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
|
|
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
|
|
if (GetArenaForAllocation() == nullptr) { delete old; }
|
|
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
|
|
if (GetArenaForAllocation() != nullptr) {
|
|
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
|
|
}
|
|
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
|
|
return temp;
|
|
}
|
|
inline ::greptime::v1::AuthHeader* RequestHeader::unsafe_arena_release_authorization() {
|
|
// @@protoc_insertion_point(field_release:greptime.v1.RequestHeader.authorization)
|
|
|
|
::greptime::v1::AuthHeader* temp = _impl_.authorization_;
|
|
_impl_.authorization_ = nullptr;
|
|
return temp;
|
|
}
|
|
inline ::greptime::v1::AuthHeader* RequestHeader::_internal_mutable_authorization() {
|
|
|
|
if (_impl_.authorization_ == nullptr) {
|
|
auto* p = CreateMaybeMessage<::greptime::v1::AuthHeader>(GetArenaForAllocation());
|
|
_impl_.authorization_ = p;
|
|
}
|
|
return _impl_.authorization_;
|
|
}
|
|
inline ::greptime::v1::AuthHeader* RequestHeader::mutable_authorization() {
|
|
::greptime::v1::AuthHeader* _msg = _internal_mutable_authorization();
|
|
// @@protoc_insertion_point(field_mutable:greptime.v1.RequestHeader.authorization)
|
|
return _msg;
|
|
}
|
|
inline void RequestHeader::set_allocated_authorization(::greptime::v1::AuthHeader* authorization) {
|
|
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
|
|
if (message_arena == nullptr) {
|
|
delete _impl_.authorization_;
|
|
}
|
|
if (authorization) {
|
|
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
|
|
::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(authorization);
|
|
if (message_arena != submessage_arena) {
|
|
authorization = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
|
|
message_arena, authorization, submessage_arena);
|
|
}
|
|
|
|
} else {
|
|
|
|
}
|
|
_impl_.authorization_ = authorization;
|
|
// @@protoc_insertion_point(field_set_allocated:greptime.v1.RequestHeader.authorization)
|
|
}
|
|
|
|
// string dbname = 4;
|
|
inline void RequestHeader::clear_dbname() {
|
|
_impl_.dbname_.ClearToEmpty();
|
|
}
|
|
inline const std::string& RequestHeader::dbname() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.RequestHeader.dbname)
|
|
return _internal_dbname();
|
|
}
|
|
template <typename ArgT0, typename... ArgT>
|
|
inline PROTOBUF_ALWAYS_INLINE
|
|
void RequestHeader::set_dbname(ArgT0&& arg0, ArgT... args) {
|
|
|
|
_impl_.dbname_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
|
|
// @@protoc_insertion_point(field_set:greptime.v1.RequestHeader.dbname)
|
|
}
|
|
inline std::string* RequestHeader::mutable_dbname() {
|
|
std::string* _s = _internal_mutable_dbname();
|
|
// @@protoc_insertion_point(field_mutable:greptime.v1.RequestHeader.dbname)
|
|
return _s;
|
|
}
|
|
inline const std::string& RequestHeader::_internal_dbname() const {
|
|
return _impl_.dbname_.Get();
|
|
}
|
|
inline void RequestHeader::_internal_set_dbname(const std::string& value) {
|
|
|
|
_impl_.dbname_.Set(value, GetArenaForAllocation());
|
|
}
|
|
inline std::string* RequestHeader::_internal_mutable_dbname() {
|
|
|
|
return _impl_.dbname_.Mutable(GetArenaForAllocation());
|
|
}
|
|
inline std::string* RequestHeader::release_dbname() {
|
|
// @@protoc_insertion_point(field_release:greptime.v1.RequestHeader.dbname)
|
|
return _impl_.dbname_.Release();
|
|
}
|
|
inline void RequestHeader::set_allocated_dbname(std::string* dbname) {
|
|
if (dbname != nullptr) {
|
|
|
|
} else {
|
|
|
|
}
|
|
_impl_.dbname_.SetAllocated(dbname, GetArenaForAllocation());
|
|
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
if (_impl_.dbname_.IsDefault()) {
|
|
_impl_.dbname_.Set("", GetArenaForAllocation());
|
|
}
|
|
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
// @@protoc_insertion_point(field_set_allocated:greptime.v1.RequestHeader.dbname)
|
|
}
|
|
|
|
// optional uint64 trace_id = 5;
|
|
inline bool RequestHeader::_internal_has_trace_id() const {
|
|
bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
|
|
return value;
|
|
}
|
|
inline bool RequestHeader::has_trace_id() const {
|
|
return _internal_has_trace_id();
|
|
}
|
|
inline void RequestHeader::clear_trace_id() {
|
|
_impl_.trace_id_ = uint64_t{0u};
|
|
_impl_._has_bits_[0] &= ~0x00000001u;
|
|
}
|
|
inline uint64_t RequestHeader::_internal_trace_id() const {
|
|
return _impl_.trace_id_;
|
|
}
|
|
inline uint64_t RequestHeader::trace_id() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.RequestHeader.trace_id)
|
|
return _internal_trace_id();
|
|
}
|
|
inline void RequestHeader::_internal_set_trace_id(uint64_t value) {
|
|
_impl_._has_bits_[0] |= 0x00000001u;
|
|
_impl_.trace_id_ = value;
|
|
}
|
|
inline void RequestHeader::set_trace_id(uint64_t value) {
|
|
_internal_set_trace_id(value);
|
|
// @@protoc_insertion_point(field_set:greptime.v1.RequestHeader.trace_id)
|
|
}
|
|
|
|
// optional uint64 span_id = 6;
|
|
inline bool RequestHeader::_internal_has_span_id() const {
|
|
bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
|
|
return value;
|
|
}
|
|
inline bool RequestHeader::has_span_id() const {
|
|
return _internal_has_span_id();
|
|
}
|
|
inline void RequestHeader::clear_span_id() {
|
|
_impl_.span_id_ = uint64_t{0u};
|
|
_impl_._has_bits_[0] &= ~0x00000002u;
|
|
}
|
|
inline uint64_t RequestHeader::_internal_span_id() const {
|
|
return _impl_.span_id_;
|
|
}
|
|
inline uint64_t RequestHeader::span_id() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.RequestHeader.span_id)
|
|
return _internal_span_id();
|
|
}
|
|
inline void RequestHeader::_internal_set_span_id(uint64_t value) {
|
|
_impl_._has_bits_[0] |= 0x00000002u;
|
|
_impl_.span_id_ = value;
|
|
}
|
|
inline void RequestHeader::set_span_id(uint64_t value) {
|
|
_internal_set_span_id(value);
|
|
// @@protoc_insertion_point(field_set:greptime.v1.RequestHeader.span_id)
|
|
}
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
// AuthHeader
|
|
|
|
// .greptime.v1.Basic basic = 1;
|
|
inline bool AuthHeader::_internal_has_basic() const {
|
|
return auth_scheme_case() == kBasic;
|
|
}
|
|
inline bool AuthHeader::has_basic() const {
|
|
return _internal_has_basic();
|
|
}
|
|
inline void AuthHeader::set_has_basic() {
|
|
_impl_._oneof_case_[0] = kBasic;
|
|
}
|
|
inline void AuthHeader::clear_basic() {
|
|
if (_internal_has_basic()) {
|
|
if (GetArenaForAllocation() == nullptr) {
|
|
delete _impl_.auth_scheme_.basic_;
|
|
}
|
|
clear_has_auth_scheme();
|
|
}
|
|
}
|
|
inline ::greptime::v1::Basic* AuthHeader::release_basic() {
|
|
// @@protoc_insertion_point(field_release:greptime.v1.AuthHeader.basic)
|
|
if (_internal_has_basic()) {
|
|
clear_has_auth_scheme();
|
|
::greptime::v1::Basic* temp = _impl_.auth_scheme_.basic_;
|
|
if (GetArenaForAllocation() != nullptr) {
|
|
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
|
|
}
|
|
_impl_.auth_scheme_.basic_ = nullptr;
|
|
return temp;
|
|
} else {
|
|
return nullptr;
|
|
}
|
|
}
|
|
inline const ::greptime::v1::Basic& AuthHeader::_internal_basic() const {
|
|
return _internal_has_basic()
|
|
? *_impl_.auth_scheme_.basic_
|
|
: reinterpret_cast< ::greptime::v1::Basic&>(::greptime::v1::_Basic_default_instance_);
|
|
}
|
|
inline const ::greptime::v1::Basic& AuthHeader::basic() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.AuthHeader.basic)
|
|
return _internal_basic();
|
|
}
|
|
inline ::greptime::v1::Basic* AuthHeader::unsafe_arena_release_basic() {
|
|
// @@protoc_insertion_point(field_unsafe_arena_release:greptime.v1.AuthHeader.basic)
|
|
if (_internal_has_basic()) {
|
|
clear_has_auth_scheme();
|
|
::greptime::v1::Basic* temp = _impl_.auth_scheme_.basic_;
|
|
_impl_.auth_scheme_.basic_ = nullptr;
|
|
return temp;
|
|
} else {
|
|
return nullptr;
|
|
}
|
|
}
|
|
inline void AuthHeader::unsafe_arena_set_allocated_basic(::greptime::v1::Basic* basic) {
|
|
clear_auth_scheme();
|
|
if (basic) {
|
|
set_has_basic();
|
|
_impl_.auth_scheme_.basic_ = basic;
|
|
}
|
|
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:greptime.v1.AuthHeader.basic)
|
|
}
|
|
inline ::greptime::v1::Basic* AuthHeader::_internal_mutable_basic() {
|
|
if (!_internal_has_basic()) {
|
|
clear_auth_scheme();
|
|
set_has_basic();
|
|
_impl_.auth_scheme_.basic_ = CreateMaybeMessage< ::greptime::v1::Basic >(GetArenaForAllocation());
|
|
}
|
|
return _impl_.auth_scheme_.basic_;
|
|
}
|
|
inline ::greptime::v1::Basic* AuthHeader::mutable_basic() {
|
|
::greptime::v1::Basic* _msg = _internal_mutable_basic();
|
|
// @@protoc_insertion_point(field_mutable:greptime.v1.AuthHeader.basic)
|
|
return _msg;
|
|
}
|
|
|
|
// .greptime.v1.Token token = 2;
|
|
inline bool AuthHeader::_internal_has_token() const {
|
|
return auth_scheme_case() == kToken;
|
|
}
|
|
inline bool AuthHeader::has_token() const {
|
|
return _internal_has_token();
|
|
}
|
|
inline void AuthHeader::set_has_token() {
|
|
_impl_._oneof_case_[0] = kToken;
|
|
}
|
|
inline void AuthHeader::clear_token() {
|
|
if (_internal_has_token()) {
|
|
if (GetArenaForAllocation() == nullptr) {
|
|
delete _impl_.auth_scheme_.token_;
|
|
}
|
|
clear_has_auth_scheme();
|
|
}
|
|
}
|
|
inline ::greptime::v1::Token* AuthHeader::release_token() {
|
|
// @@protoc_insertion_point(field_release:greptime.v1.AuthHeader.token)
|
|
if (_internal_has_token()) {
|
|
clear_has_auth_scheme();
|
|
::greptime::v1::Token* temp = _impl_.auth_scheme_.token_;
|
|
if (GetArenaForAllocation() != nullptr) {
|
|
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
|
|
}
|
|
_impl_.auth_scheme_.token_ = nullptr;
|
|
return temp;
|
|
} else {
|
|
return nullptr;
|
|
}
|
|
}
|
|
inline const ::greptime::v1::Token& AuthHeader::_internal_token() const {
|
|
return _internal_has_token()
|
|
? *_impl_.auth_scheme_.token_
|
|
: reinterpret_cast< ::greptime::v1::Token&>(::greptime::v1::_Token_default_instance_);
|
|
}
|
|
inline const ::greptime::v1::Token& AuthHeader::token() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.AuthHeader.token)
|
|
return _internal_token();
|
|
}
|
|
inline ::greptime::v1::Token* AuthHeader::unsafe_arena_release_token() {
|
|
// @@protoc_insertion_point(field_unsafe_arena_release:greptime.v1.AuthHeader.token)
|
|
if (_internal_has_token()) {
|
|
clear_has_auth_scheme();
|
|
::greptime::v1::Token* temp = _impl_.auth_scheme_.token_;
|
|
_impl_.auth_scheme_.token_ = nullptr;
|
|
return temp;
|
|
} else {
|
|
return nullptr;
|
|
}
|
|
}
|
|
inline void AuthHeader::unsafe_arena_set_allocated_token(::greptime::v1::Token* token) {
|
|
clear_auth_scheme();
|
|
if (token) {
|
|
set_has_token();
|
|
_impl_.auth_scheme_.token_ = token;
|
|
}
|
|
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:greptime.v1.AuthHeader.token)
|
|
}
|
|
inline ::greptime::v1::Token* AuthHeader::_internal_mutable_token() {
|
|
if (!_internal_has_token()) {
|
|
clear_auth_scheme();
|
|
set_has_token();
|
|
_impl_.auth_scheme_.token_ = CreateMaybeMessage< ::greptime::v1::Token >(GetArenaForAllocation());
|
|
}
|
|
return _impl_.auth_scheme_.token_;
|
|
}
|
|
inline ::greptime::v1::Token* AuthHeader::mutable_token() {
|
|
::greptime::v1::Token* _msg = _internal_mutable_token();
|
|
// @@protoc_insertion_point(field_mutable:greptime.v1.AuthHeader.token)
|
|
return _msg;
|
|
}
|
|
|
|
inline bool AuthHeader::has_auth_scheme() const {
|
|
return auth_scheme_case() != AUTH_SCHEME_NOT_SET;
|
|
}
|
|
inline void AuthHeader::clear_has_auth_scheme() {
|
|
_impl_._oneof_case_[0] = AUTH_SCHEME_NOT_SET;
|
|
}
|
|
inline AuthHeader::AuthSchemeCase AuthHeader::auth_scheme_case() const {
|
|
return AuthHeader::AuthSchemeCase(_impl_._oneof_case_[0]);
|
|
}
|
|
// -------------------------------------------------------------------
|
|
|
|
// Basic
|
|
|
|
// string username = 1;
|
|
inline void Basic::clear_username() {
|
|
_impl_.username_.ClearToEmpty();
|
|
}
|
|
inline const std::string& Basic::username() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.Basic.username)
|
|
return _internal_username();
|
|
}
|
|
template <typename ArgT0, typename... ArgT>
|
|
inline PROTOBUF_ALWAYS_INLINE
|
|
void Basic::set_username(ArgT0&& arg0, ArgT... args) {
|
|
|
|
_impl_.username_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
|
|
// @@protoc_insertion_point(field_set:greptime.v1.Basic.username)
|
|
}
|
|
inline std::string* Basic::mutable_username() {
|
|
std::string* _s = _internal_mutable_username();
|
|
// @@protoc_insertion_point(field_mutable:greptime.v1.Basic.username)
|
|
return _s;
|
|
}
|
|
inline const std::string& Basic::_internal_username() const {
|
|
return _impl_.username_.Get();
|
|
}
|
|
inline void Basic::_internal_set_username(const std::string& value) {
|
|
|
|
_impl_.username_.Set(value, GetArenaForAllocation());
|
|
}
|
|
inline std::string* Basic::_internal_mutable_username() {
|
|
|
|
return _impl_.username_.Mutable(GetArenaForAllocation());
|
|
}
|
|
inline std::string* Basic::release_username() {
|
|
// @@protoc_insertion_point(field_release:greptime.v1.Basic.username)
|
|
return _impl_.username_.Release();
|
|
}
|
|
inline void Basic::set_allocated_username(std::string* username) {
|
|
if (username != nullptr) {
|
|
|
|
} else {
|
|
|
|
}
|
|
_impl_.username_.SetAllocated(username, GetArenaForAllocation());
|
|
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
if (_impl_.username_.IsDefault()) {
|
|
_impl_.username_.Set("", GetArenaForAllocation());
|
|
}
|
|
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
// @@protoc_insertion_point(field_set_allocated:greptime.v1.Basic.username)
|
|
}
|
|
|
|
// string password = 2;
|
|
inline void Basic::clear_password() {
|
|
_impl_.password_.ClearToEmpty();
|
|
}
|
|
inline const std::string& Basic::password() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.Basic.password)
|
|
return _internal_password();
|
|
}
|
|
template <typename ArgT0, typename... ArgT>
|
|
inline PROTOBUF_ALWAYS_INLINE
|
|
void Basic::set_password(ArgT0&& arg0, ArgT... args) {
|
|
|
|
_impl_.password_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
|
|
// @@protoc_insertion_point(field_set:greptime.v1.Basic.password)
|
|
}
|
|
inline std::string* Basic::mutable_password() {
|
|
std::string* _s = _internal_mutable_password();
|
|
// @@protoc_insertion_point(field_mutable:greptime.v1.Basic.password)
|
|
return _s;
|
|
}
|
|
inline const std::string& Basic::_internal_password() const {
|
|
return _impl_.password_.Get();
|
|
}
|
|
inline void Basic::_internal_set_password(const std::string& value) {
|
|
|
|
_impl_.password_.Set(value, GetArenaForAllocation());
|
|
}
|
|
inline std::string* Basic::_internal_mutable_password() {
|
|
|
|
return _impl_.password_.Mutable(GetArenaForAllocation());
|
|
}
|
|
inline std::string* Basic::release_password() {
|
|
// @@protoc_insertion_point(field_release:greptime.v1.Basic.password)
|
|
return _impl_.password_.Release();
|
|
}
|
|
inline void Basic::set_allocated_password(std::string* password) {
|
|
if (password != nullptr) {
|
|
|
|
} else {
|
|
|
|
}
|
|
_impl_.password_.SetAllocated(password, GetArenaForAllocation());
|
|
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
if (_impl_.password_.IsDefault()) {
|
|
_impl_.password_.Set("", GetArenaForAllocation());
|
|
}
|
|
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
// @@protoc_insertion_point(field_set_allocated:greptime.v1.Basic.password)
|
|
}
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
// Token
|
|
|
|
// string token = 1;
|
|
inline void Token::clear_token() {
|
|
_impl_.token_.ClearToEmpty();
|
|
}
|
|
inline const std::string& Token::token() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.Token.token)
|
|
return _internal_token();
|
|
}
|
|
template <typename ArgT0, typename... ArgT>
|
|
inline PROTOBUF_ALWAYS_INLINE
|
|
void Token::set_token(ArgT0&& arg0, ArgT... args) {
|
|
|
|
_impl_.token_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
|
|
// @@protoc_insertion_point(field_set:greptime.v1.Token.token)
|
|
}
|
|
inline std::string* Token::mutable_token() {
|
|
std::string* _s = _internal_mutable_token();
|
|
// @@protoc_insertion_point(field_mutable:greptime.v1.Token.token)
|
|
return _s;
|
|
}
|
|
inline const std::string& Token::_internal_token() const {
|
|
return _impl_.token_.Get();
|
|
}
|
|
inline void Token::_internal_set_token(const std::string& value) {
|
|
|
|
_impl_.token_.Set(value, GetArenaForAllocation());
|
|
}
|
|
inline std::string* Token::_internal_mutable_token() {
|
|
|
|
return _impl_.token_.Mutable(GetArenaForAllocation());
|
|
}
|
|
inline std::string* Token::release_token() {
|
|
// @@protoc_insertion_point(field_release:greptime.v1.Token.token)
|
|
return _impl_.token_.Release();
|
|
}
|
|
inline void Token::set_allocated_token(std::string* token) {
|
|
if (token != nullptr) {
|
|
|
|
} else {
|
|
|
|
}
|
|
_impl_.token_.SetAllocated(token, GetArenaForAllocation());
|
|
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
if (_impl_.token_.IsDefault()) {
|
|
_impl_.token_.Set("", GetArenaForAllocation());
|
|
}
|
|
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
// @@protoc_insertion_point(field_set_allocated:greptime.v1.Token.token)
|
|
}
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
// AffectedRows
|
|
|
|
// uint32 value = 1;
|
|
inline void AffectedRows::clear_value() {
|
|
_impl_.value_ = 0u;
|
|
}
|
|
inline uint32_t AffectedRows::_internal_value() const {
|
|
return _impl_.value_;
|
|
}
|
|
inline uint32_t AffectedRows::value() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.AffectedRows.value)
|
|
return _internal_value();
|
|
}
|
|
inline void AffectedRows::_internal_set_value(uint32_t value) {
|
|
|
|
_impl_.value_ = value;
|
|
}
|
|
inline void AffectedRows::set_value(uint32_t value) {
|
|
_internal_set_value(value);
|
|
// @@protoc_insertion_point(field_set:greptime.v1.AffectedRows.value)
|
|
}
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
// FlightMetadata
|
|
|
|
// .greptime.v1.AffectedRows affected_rows = 1;
|
|
inline bool FlightMetadata::_internal_has_affected_rows() const {
|
|
return this != internal_default_instance() && _impl_.affected_rows_ != nullptr;
|
|
}
|
|
inline bool FlightMetadata::has_affected_rows() const {
|
|
return _internal_has_affected_rows();
|
|
}
|
|
inline void FlightMetadata::clear_affected_rows() {
|
|
if (GetArenaForAllocation() == nullptr && _impl_.affected_rows_ != nullptr) {
|
|
delete _impl_.affected_rows_;
|
|
}
|
|
_impl_.affected_rows_ = nullptr;
|
|
}
|
|
inline const ::greptime::v1::AffectedRows& FlightMetadata::_internal_affected_rows() const {
|
|
const ::greptime::v1::AffectedRows* p = _impl_.affected_rows_;
|
|
return p != nullptr ? *p : reinterpret_cast<const ::greptime::v1::AffectedRows&>(
|
|
::greptime::v1::_AffectedRows_default_instance_);
|
|
}
|
|
inline const ::greptime::v1::AffectedRows& FlightMetadata::affected_rows() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.FlightMetadata.affected_rows)
|
|
return _internal_affected_rows();
|
|
}
|
|
inline void FlightMetadata::unsafe_arena_set_allocated_affected_rows(
|
|
::greptime::v1::AffectedRows* affected_rows) {
|
|
if (GetArenaForAllocation() == nullptr) {
|
|
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.affected_rows_);
|
|
}
|
|
_impl_.affected_rows_ = affected_rows;
|
|
if (affected_rows) {
|
|
|
|
} else {
|
|
|
|
}
|
|
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:greptime.v1.FlightMetadata.affected_rows)
|
|
}
|
|
inline ::greptime::v1::AffectedRows* FlightMetadata::release_affected_rows() {
|
|
|
|
::greptime::v1::AffectedRows* temp = _impl_.affected_rows_;
|
|
_impl_.affected_rows_ = nullptr;
|
|
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
|
|
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
|
|
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
|
|
if (GetArenaForAllocation() == nullptr) { delete old; }
|
|
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
|
|
if (GetArenaForAllocation() != nullptr) {
|
|
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
|
|
}
|
|
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
|
|
return temp;
|
|
}
|
|
inline ::greptime::v1::AffectedRows* FlightMetadata::unsafe_arena_release_affected_rows() {
|
|
// @@protoc_insertion_point(field_release:greptime.v1.FlightMetadata.affected_rows)
|
|
|
|
::greptime::v1::AffectedRows* temp = _impl_.affected_rows_;
|
|
_impl_.affected_rows_ = nullptr;
|
|
return temp;
|
|
}
|
|
inline ::greptime::v1::AffectedRows* FlightMetadata::_internal_mutable_affected_rows() {
|
|
|
|
if (_impl_.affected_rows_ == nullptr) {
|
|
auto* p = CreateMaybeMessage<::greptime::v1::AffectedRows>(GetArenaForAllocation());
|
|
_impl_.affected_rows_ = p;
|
|
}
|
|
return _impl_.affected_rows_;
|
|
}
|
|
inline ::greptime::v1::AffectedRows* FlightMetadata::mutable_affected_rows() {
|
|
::greptime::v1::AffectedRows* _msg = _internal_mutable_affected_rows();
|
|
// @@protoc_insertion_point(field_mutable:greptime.v1.FlightMetadata.affected_rows)
|
|
return _msg;
|
|
}
|
|
inline void FlightMetadata::set_allocated_affected_rows(::greptime::v1::AffectedRows* affected_rows) {
|
|
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
|
|
if (message_arena == nullptr) {
|
|
delete _impl_.affected_rows_;
|
|
}
|
|
if (affected_rows) {
|
|
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
|
|
::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(affected_rows);
|
|
if (message_arena != submessage_arena) {
|
|
affected_rows = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
|
|
message_arena, affected_rows, submessage_arena);
|
|
}
|
|
|
|
} else {
|
|
|
|
}
|
|
_impl_.affected_rows_ = affected_rows;
|
|
// @@protoc_insertion_point(field_set_allocated:greptime.v1.FlightMetadata.affected_rows)
|
|
}
|
|
|
|
#ifdef __GNUC__
|
|
#pragma GCC diagnostic pop
|
|
#endif // __GNUC__
|
|
// -------------------------------------------------------------------
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
|
|
// @@protoc_insertion_point(namespace_scope)
|
|
|
|
} // namespace v1
|
|
} // namespace greptime
|
|
|
|
// @@protoc_insertion_point(global_scope)
|
|
|
|
#include <google/protobuf/port_undef.inc>
|
|
#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_greptime_2fv1_2fcommon_2eproto
|