LFC
5066 lines
170 KiB
C++
5066 lines
170 KiB
C++
// Generated by the protocol buffer compiler. DO NOT EDIT!
|
|
// source: greptime/v1/row.proto
|
|
|
|
#ifndef GOOGLE_PROTOBUF_INCLUDED_greptime_2fv1_2frow_2eproto
|
|
#define GOOGLE_PROTOBUF_INCLUDED_greptime_2fv1_2frow_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_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>
|
|
#include "greptime/v1/common.pb.h"
|
|
// @@protoc_insertion_point(includes)
|
|
#include <google/protobuf/port_def.inc>
|
|
#define PROTOBUF_INTERNAL_EXPORT_greptime_2fv1_2frow_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_2frow_2eproto {
|
|
static const uint32_t offsets[];
|
|
};
|
|
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_greptime_2fv1_2frow_2eproto;
|
|
namespace greptime {
|
|
namespace v1 {
|
|
class ColumnSchema;
|
|
struct ColumnSchemaDefaultTypeInternal;
|
|
extern ColumnSchemaDefaultTypeInternal _ColumnSchema_default_instance_;
|
|
class JsonList;
|
|
struct JsonListDefaultTypeInternal;
|
|
extern JsonListDefaultTypeInternal _JsonList_default_instance_;
|
|
class JsonObject;
|
|
struct JsonObjectDefaultTypeInternal;
|
|
extern JsonObjectDefaultTypeInternal _JsonObject_default_instance_;
|
|
class JsonObject_Entry;
|
|
struct JsonObject_EntryDefaultTypeInternal;
|
|
extern JsonObject_EntryDefaultTypeInternal _JsonObject_Entry_default_instance_;
|
|
class JsonValue;
|
|
struct JsonValueDefaultTypeInternal;
|
|
extern JsonValueDefaultTypeInternal _JsonValue_default_instance_;
|
|
class ListValue;
|
|
struct ListValueDefaultTypeInternal;
|
|
extern ListValueDefaultTypeInternal _ListValue_default_instance_;
|
|
class Row;
|
|
struct RowDefaultTypeInternal;
|
|
extern RowDefaultTypeInternal _Row_default_instance_;
|
|
class Rows;
|
|
struct RowsDefaultTypeInternal;
|
|
extern RowsDefaultTypeInternal _Rows_default_instance_;
|
|
class StructValue;
|
|
struct StructValueDefaultTypeInternal;
|
|
extern StructValueDefaultTypeInternal _StructValue_default_instance_;
|
|
class Value;
|
|
struct ValueDefaultTypeInternal;
|
|
extern ValueDefaultTypeInternal _Value_default_instance_;
|
|
} // namespace v1
|
|
} // namespace greptime
|
|
PROTOBUF_NAMESPACE_OPEN
|
|
template<> ::greptime::v1::ColumnSchema* Arena::CreateMaybeMessage<::greptime::v1::ColumnSchema>(Arena*);
|
|
template<> ::greptime::v1::JsonList* Arena::CreateMaybeMessage<::greptime::v1::JsonList>(Arena*);
|
|
template<> ::greptime::v1::JsonObject* Arena::CreateMaybeMessage<::greptime::v1::JsonObject>(Arena*);
|
|
template<> ::greptime::v1::JsonObject_Entry* Arena::CreateMaybeMessage<::greptime::v1::JsonObject_Entry>(Arena*);
|
|
template<> ::greptime::v1::JsonValue* Arena::CreateMaybeMessage<::greptime::v1::JsonValue>(Arena*);
|
|
template<> ::greptime::v1::ListValue* Arena::CreateMaybeMessage<::greptime::v1::ListValue>(Arena*);
|
|
template<> ::greptime::v1::Row* Arena::CreateMaybeMessage<::greptime::v1::Row>(Arena*);
|
|
template<> ::greptime::v1::Rows* Arena::CreateMaybeMessage<::greptime::v1::Rows>(Arena*);
|
|
template<> ::greptime::v1::StructValue* Arena::CreateMaybeMessage<::greptime::v1::StructValue>(Arena*);
|
|
template<> ::greptime::v1::Value* Arena::CreateMaybeMessage<::greptime::v1::Value>(Arena*);
|
|
PROTOBUF_NAMESPACE_CLOSE
|
|
namespace greptime {
|
|
namespace v1 {
|
|
|
|
// ===================================================================
|
|
|
|
class Rows final :
|
|
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:greptime.v1.Rows) */ {
|
|
public:
|
|
inline Rows() : Rows(nullptr) {}
|
|
~Rows() override;
|
|
explicit PROTOBUF_CONSTEXPR Rows(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
|
|
|
|
Rows(const Rows& from);
|
|
Rows(Rows&& from) noexcept
|
|
: Rows() {
|
|
*this = ::std::move(from);
|
|
}
|
|
|
|
inline Rows& operator=(const Rows& from) {
|
|
CopyFrom(from);
|
|
return *this;
|
|
}
|
|
inline Rows& operator=(Rows&& 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 Rows& default_instance() {
|
|
return *internal_default_instance();
|
|
}
|
|
static inline const Rows* internal_default_instance() {
|
|
return reinterpret_cast<const Rows*>(
|
|
&_Rows_default_instance_);
|
|
}
|
|
static constexpr int kIndexInFileMessages =
|
|
0;
|
|
|
|
friend void swap(Rows& a, Rows& b) {
|
|
a.Swap(&b);
|
|
}
|
|
inline void Swap(Rows* 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(Rows* other) {
|
|
if (other == this) return;
|
|
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
|
|
InternalSwap(other);
|
|
}
|
|
|
|
// implements Message ----------------------------------------------
|
|
|
|
Rows* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
|
|
return CreateMaybeMessage<Rows>(arena);
|
|
}
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
|
|
void CopyFrom(const Rows& from);
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
|
|
void MergeFrom( const Rows& from) {
|
|
Rows::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(Rows* other);
|
|
|
|
private:
|
|
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
|
|
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
|
|
return "greptime.v1.Rows";
|
|
}
|
|
protected:
|
|
explicit Rows(::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 {
|
|
kSchemaFieldNumber = 1,
|
|
kRowsFieldNumber = 2,
|
|
};
|
|
// repeated .greptime.v1.ColumnSchema schema = 1;
|
|
int schema_size() const;
|
|
private:
|
|
int _internal_schema_size() const;
|
|
public:
|
|
void clear_schema();
|
|
::greptime::v1::ColumnSchema* mutable_schema(int index);
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::ColumnSchema >*
|
|
mutable_schema();
|
|
private:
|
|
const ::greptime::v1::ColumnSchema& _internal_schema(int index) const;
|
|
::greptime::v1::ColumnSchema* _internal_add_schema();
|
|
public:
|
|
const ::greptime::v1::ColumnSchema& schema(int index) const;
|
|
::greptime::v1::ColumnSchema* add_schema();
|
|
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::ColumnSchema >&
|
|
schema() const;
|
|
|
|
// repeated .greptime.v1.Row rows = 2;
|
|
int rows_size() const;
|
|
private:
|
|
int _internal_rows_size() const;
|
|
public:
|
|
void clear_rows();
|
|
::greptime::v1::Row* mutable_rows(int index);
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::Row >*
|
|
mutable_rows();
|
|
private:
|
|
const ::greptime::v1::Row& _internal_rows(int index) const;
|
|
::greptime::v1::Row* _internal_add_rows();
|
|
public:
|
|
const ::greptime::v1::Row& rows(int index) const;
|
|
::greptime::v1::Row* add_rows();
|
|
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::Row >&
|
|
rows() const;
|
|
|
|
// @@protoc_insertion_point(class_scope:greptime.v1.Rows)
|
|
private:
|
|
class _Internal;
|
|
|
|
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
|
|
typedef void InternalArenaConstructable_;
|
|
typedef void DestructorSkippable_;
|
|
struct Impl_ {
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::ColumnSchema > schema_;
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::Row > rows_;
|
|
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
|
|
};
|
|
union { Impl_ _impl_; };
|
|
friend struct ::TableStruct_greptime_2fv1_2frow_2eproto;
|
|
};
|
|
// -------------------------------------------------------------------
|
|
|
|
class ColumnSchema final :
|
|
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:greptime.v1.ColumnSchema) */ {
|
|
public:
|
|
inline ColumnSchema() : ColumnSchema(nullptr) {}
|
|
~ColumnSchema() override;
|
|
explicit PROTOBUF_CONSTEXPR ColumnSchema(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
|
|
|
|
ColumnSchema(const ColumnSchema& from);
|
|
ColumnSchema(ColumnSchema&& from) noexcept
|
|
: ColumnSchema() {
|
|
*this = ::std::move(from);
|
|
}
|
|
|
|
inline ColumnSchema& operator=(const ColumnSchema& from) {
|
|
CopyFrom(from);
|
|
return *this;
|
|
}
|
|
inline ColumnSchema& operator=(ColumnSchema&& 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 ColumnSchema& default_instance() {
|
|
return *internal_default_instance();
|
|
}
|
|
static inline const ColumnSchema* internal_default_instance() {
|
|
return reinterpret_cast<const ColumnSchema*>(
|
|
&_ColumnSchema_default_instance_);
|
|
}
|
|
static constexpr int kIndexInFileMessages =
|
|
1;
|
|
|
|
friend void swap(ColumnSchema& a, ColumnSchema& b) {
|
|
a.Swap(&b);
|
|
}
|
|
inline void Swap(ColumnSchema* 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(ColumnSchema* other) {
|
|
if (other == this) return;
|
|
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
|
|
InternalSwap(other);
|
|
}
|
|
|
|
// implements Message ----------------------------------------------
|
|
|
|
ColumnSchema* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
|
|
return CreateMaybeMessage<ColumnSchema>(arena);
|
|
}
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
|
|
void CopyFrom(const ColumnSchema& from);
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
|
|
void MergeFrom( const ColumnSchema& from) {
|
|
ColumnSchema::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(ColumnSchema* other);
|
|
|
|
private:
|
|
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
|
|
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
|
|
return "greptime.v1.ColumnSchema";
|
|
}
|
|
protected:
|
|
explicit ColumnSchema(::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 {
|
|
kColumnNameFieldNumber = 1,
|
|
kDatatypeExtensionFieldNumber = 4,
|
|
kOptionsFieldNumber = 5,
|
|
kDatatypeFieldNumber = 2,
|
|
kSemanticTypeFieldNumber = 3,
|
|
};
|
|
// string column_name = 1;
|
|
void clear_column_name();
|
|
const std::string& column_name() const;
|
|
template <typename ArgT0 = const std::string&, typename... ArgT>
|
|
void set_column_name(ArgT0&& arg0, ArgT... args);
|
|
std::string* mutable_column_name();
|
|
PROTOBUF_NODISCARD std::string* release_column_name();
|
|
void set_allocated_column_name(std::string* column_name);
|
|
private:
|
|
const std::string& _internal_column_name() const;
|
|
inline PROTOBUF_ALWAYS_INLINE void _internal_set_column_name(const std::string& value);
|
|
std::string* _internal_mutable_column_name();
|
|
public:
|
|
|
|
// .greptime.v1.ColumnDataTypeExtension datatype_extension = 4;
|
|
bool has_datatype_extension() const;
|
|
private:
|
|
bool _internal_has_datatype_extension() const;
|
|
public:
|
|
void clear_datatype_extension();
|
|
const ::greptime::v1::ColumnDataTypeExtension& datatype_extension() const;
|
|
PROTOBUF_NODISCARD ::greptime::v1::ColumnDataTypeExtension* release_datatype_extension();
|
|
::greptime::v1::ColumnDataTypeExtension* mutable_datatype_extension();
|
|
void set_allocated_datatype_extension(::greptime::v1::ColumnDataTypeExtension* datatype_extension);
|
|
private:
|
|
const ::greptime::v1::ColumnDataTypeExtension& _internal_datatype_extension() const;
|
|
::greptime::v1::ColumnDataTypeExtension* _internal_mutable_datatype_extension();
|
|
public:
|
|
void unsafe_arena_set_allocated_datatype_extension(
|
|
::greptime::v1::ColumnDataTypeExtension* datatype_extension);
|
|
::greptime::v1::ColumnDataTypeExtension* unsafe_arena_release_datatype_extension();
|
|
|
|
// .greptime.v1.ColumnOptions options = 5;
|
|
bool has_options() const;
|
|
private:
|
|
bool _internal_has_options() const;
|
|
public:
|
|
void clear_options();
|
|
const ::greptime::v1::ColumnOptions& options() const;
|
|
PROTOBUF_NODISCARD ::greptime::v1::ColumnOptions* release_options();
|
|
::greptime::v1::ColumnOptions* mutable_options();
|
|
void set_allocated_options(::greptime::v1::ColumnOptions* options);
|
|
private:
|
|
const ::greptime::v1::ColumnOptions& _internal_options() const;
|
|
::greptime::v1::ColumnOptions* _internal_mutable_options();
|
|
public:
|
|
void unsafe_arena_set_allocated_options(
|
|
::greptime::v1::ColumnOptions* options);
|
|
::greptime::v1::ColumnOptions* unsafe_arena_release_options();
|
|
|
|
// .greptime.v1.ColumnDataType datatype = 2;
|
|
void clear_datatype();
|
|
::greptime::v1::ColumnDataType datatype() const;
|
|
void set_datatype(::greptime::v1::ColumnDataType value);
|
|
private:
|
|
::greptime::v1::ColumnDataType _internal_datatype() const;
|
|
void _internal_set_datatype(::greptime::v1::ColumnDataType value);
|
|
public:
|
|
|
|
// .greptime.v1.SemanticType semantic_type = 3;
|
|
void clear_semantic_type();
|
|
::greptime::v1::SemanticType semantic_type() const;
|
|
void set_semantic_type(::greptime::v1::SemanticType value);
|
|
private:
|
|
::greptime::v1::SemanticType _internal_semantic_type() const;
|
|
void _internal_set_semantic_type(::greptime::v1::SemanticType value);
|
|
public:
|
|
|
|
// @@protoc_insertion_point(class_scope:greptime.v1.ColumnSchema)
|
|
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 column_name_;
|
|
::greptime::v1::ColumnDataTypeExtension* datatype_extension_;
|
|
::greptime::v1::ColumnOptions* options_;
|
|
int datatype_;
|
|
int semantic_type_;
|
|
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
|
|
};
|
|
union { Impl_ _impl_; };
|
|
friend struct ::TableStruct_greptime_2fv1_2frow_2eproto;
|
|
};
|
|
// -------------------------------------------------------------------
|
|
|
|
class Row final :
|
|
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:greptime.v1.Row) */ {
|
|
public:
|
|
inline Row() : Row(nullptr) {}
|
|
~Row() override;
|
|
explicit PROTOBUF_CONSTEXPR Row(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
|
|
|
|
Row(const Row& from);
|
|
Row(Row&& from) noexcept
|
|
: Row() {
|
|
*this = ::std::move(from);
|
|
}
|
|
|
|
inline Row& operator=(const Row& from) {
|
|
CopyFrom(from);
|
|
return *this;
|
|
}
|
|
inline Row& operator=(Row&& 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 Row& default_instance() {
|
|
return *internal_default_instance();
|
|
}
|
|
static inline const Row* internal_default_instance() {
|
|
return reinterpret_cast<const Row*>(
|
|
&_Row_default_instance_);
|
|
}
|
|
static constexpr int kIndexInFileMessages =
|
|
2;
|
|
|
|
friend void swap(Row& a, Row& b) {
|
|
a.Swap(&b);
|
|
}
|
|
inline void Swap(Row* 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(Row* other) {
|
|
if (other == this) return;
|
|
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
|
|
InternalSwap(other);
|
|
}
|
|
|
|
// implements Message ----------------------------------------------
|
|
|
|
Row* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
|
|
return CreateMaybeMessage<Row>(arena);
|
|
}
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
|
|
void CopyFrom(const Row& from);
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
|
|
void MergeFrom( const Row& from) {
|
|
Row::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(Row* other);
|
|
|
|
private:
|
|
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
|
|
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
|
|
return "greptime.v1.Row";
|
|
}
|
|
protected:
|
|
explicit Row(::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 {
|
|
kValuesFieldNumber = 1,
|
|
};
|
|
// repeated .greptime.v1.Value values = 1;
|
|
int values_size() const;
|
|
private:
|
|
int _internal_values_size() const;
|
|
public:
|
|
void clear_values();
|
|
::greptime::v1::Value* mutable_values(int index);
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::Value >*
|
|
mutable_values();
|
|
private:
|
|
const ::greptime::v1::Value& _internal_values(int index) const;
|
|
::greptime::v1::Value* _internal_add_values();
|
|
public:
|
|
const ::greptime::v1::Value& values(int index) const;
|
|
::greptime::v1::Value* add_values();
|
|
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::Value >&
|
|
values() const;
|
|
|
|
// @@protoc_insertion_point(class_scope:greptime.v1.Row)
|
|
private:
|
|
class _Internal;
|
|
|
|
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
|
|
typedef void InternalArenaConstructable_;
|
|
typedef void DestructorSkippable_;
|
|
struct Impl_ {
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::Value > values_;
|
|
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
|
|
};
|
|
union { Impl_ _impl_; };
|
|
friend struct ::TableStruct_greptime_2fv1_2frow_2eproto;
|
|
};
|
|
// -------------------------------------------------------------------
|
|
|
|
class Value final :
|
|
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:greptime.v1.Value) */ {
|
|
public:
|
|
inline Value() : Value(nullptr) {}
|
|
~Value() override;
|
|
explicit PROTOBUF_CONSTEXPR Value(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
|
|
|
|
Value(const Value& from);
|
|
Value(Value&& from) noexcept
|
|
: Value() {
|
|
*this = ::std::move(from);
|
|
}
|
|
|
|
inline Value& operator=(const Value& from) {
|
|
CopyFrom(from);
|
|
return *this;
|
|
}
|
|
inline Value& operator=(Value&& 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 Value& default_instance() {
|
|
return *internal_default_instance();
|
|
}
|
|
enum ValueDataCase {
|
|
kI8Value = 1,
|
|
kI16Value = 2,
|
|
kI32Value = 3,
|
|
kI64Value = 4,
|
|
kU8Value = 5,
|
|
kU16Value = 6,
|
|
kU32Value = 7,
|
|
kU64Value = 8,
|
|
kF32Value = 9,
|
|
kF64Value = 10,
|
|
kBoolValue = 11,
|
|
kBinaryValue = 12,
|
|
kStringValue = 13,
|
|
kDateValue = 14,
|
|
kDatetimeValue = 15,
|
|
kTimestampSecondValue = 16,
|
|
kTimestampMillisecondValue = 17,
|
|
kTimestampMicrosecondValue = 18,
|
|
kTimestampNanosecondValue = 19,
|
|
kTimeSecondValue = 20,
|
|
kTimeMillisecondValue = 21,
|
|
kTimeMicrosecondValue = 22,
|
|
kTimeNanosecondValue = 23,
|
|
kIntervalYearMonthValue = 24,
|
|
kIntervalDayTimeValue = 25,
|
|
kIntervalMonthDayNanoValue = 26,
|
|
kDecimal128Value = 31,
|
|
kListValue = 40,
|
|
kStructValue = 41,
|
|
kJsonValue = 42,
|
|
VALUE_DATA_NOT_SET = 0,
|
|
};
|
|
|
|
static inline const Value* internal_default_instance() {
|
|
return reinterpret_cast<const Value*>(
|
|
&_Value_default_instance_);
|
|
}
|
|
static constexpr int kIndexInFileMessages =
|
|
3;
|
|
|
|
friend void swap(Value& a, Value& b) {
|
|
a.Swap(&b);
|
|
}
|
|
inline void Swap(Value* 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(Value* other) {
|
|
if (other == this) return;
|
|
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
|
|
InternalSwap(other);
|
|
}
|
|
|
|
// implements Message ----------------------------------------------
|
|
|
|
Value* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
|
|
return CreateMaybeMessage<Value>(arena);
|
|
}
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
|
|
void CopyFrom(const Value& from);
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
|
|
void MergeFrom( const Value& from) {
|
|
Value::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(Value* other);
|
|
|
|
private:
|
|
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
|
|
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
|
|
return "greptime.v1.Value";
|
|
}
|
|
protected:
|
|
explicit Value(::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 {
|
|
kI8ValueFieldNumber = 1,
|
|
kI16ValueFieldNumber = 2,
|
|
kI32ValueFieldNumber = 3,
|
|
kI64ValueFieldNumber = 4,
|
|
kU8ValueFieldNumber = 5,
|
|
kU16ValueFieldNumber = 6,
|
|
kU32ValueFieldNumber = 7,
|
|
kU64ValueFieldNumber = 8,
|
|
kF32ValueFieldNumber = 9,
|
|
kF64ValueFieldNumber = 10,
|
|
kBoolValueFieldNumber = 11,
|
|
kBinaryValueFieldNumber = 12,
|
|
kStringValueFieldNumber = 13,
|
|
kDateValueFieldNumber = 14,
|
|
kDatetimeValueFieldNumber = 15,
|
|
kTimestampSecondValueFieldNumber = 16,
|
|
kTimestampMillisecondValueFieldNumber = 17,
|
|
kTimestampMicrosecondValueFieldNumber = 18,
|
|
kTimestampNanosecondValueFieldNumber = 19,
|
|
kTimeSecondValueFieldNumber = 20,
|
|
kTimeMillisecondValueFieldNumber = 21,
|
|
kTimeMicrosecondValueFieldNumber = 22,
|
|
kTimeNanosecondValueFieldNumber = 23,
|
|
kIntervalYearMonthValueFieldNumber = 24,
|
|
kIntervalDayTimeValueFieldNumber = 25,
|
|
kIntervalMonthDayNanoValueFieldNumber = 26,
|
|
kDecimal128ValueFieldNumber = 31,
|
|
kListValueFieldNumber = 40,
|
|
kStructValueFieldNumber = 41,
|
|
kJsonValueFieldNumber = 42,
|
|
};
|
|
// int32 i8_value = 1;
|
|
bool has_i8_value() const;
|
|
private:
|
|
bool _internal_has_i8_value() const;
|
|
public:
|
|
void clear_i8_value();
|
|
int32_t i8_value() const;
|
|
void set_i8_value(int32_t value);
|
|
private:
|
|
int32_t _internal_i8_value() const;
|
|
void _internal_set_i8_value(int32_t value);
|
|
public:
|
|
|
|
// int32 i16_value = 2;
|
|
bool has_i16_value() const;
|
|
private:
|
|
bool _internal_has_i16_value() const;
|
|
public:
|
|
void clear_i16_value();
|
|
int32_t i16_value() const;
|
|
void set_i16_value(int32_t value);
|
|
private:
|
|
int32_t _internal_i16_value() const;
|
|
void _internal_set_i16_value(int32_t value);
|
|
public:
|
|
|
|
// int32 i32_value = 3;
|
|
bool has_i32_value() const;
|
|
private:
|
|
bool _internal_has_i32_value() const;
|
|
public:
|
|
void clear_i32_value();
|
|
int32_t i32_value() const;
|
|
void set_i32_value(int32_t value);
|
|
private:
|
|
int32_t _internal_i32_value() const;
|
|
void _internal_set_i32_value(int32_t value);
|
|
public:
|
|
|
|
// int64 i64_value = 4;
|
|
bool has_i64_value() const;
|
|
private:
|
|
bool _internal_has_i64_value() const;
|
|
public:
|
|
void clear_i64_value();
|
|
int64_t i64_value() const;
|
|
void set_i64_value(int64_t value);
|
|
private:
|
|
int64_t _internal_i64_value() const;
|
|
void _internal_set_i64_value(int64_t value);
|
|
public:
|
|
|
|
// uint32 u8_value = 5;
|
|
bool has_u8_value() const;
|
|
private:
|
|
bool _internal_has_u8_value() const;
|
|
public:
|
|
void clear_u8_value();
|
|
uint32_t u8_value() const;
|
|
void set_u8_value(uint32_t value);
|
|
private:
|
|
uint32_t _internal_u8_value() const;
|
|
void _internal_set_u8_value(uint32_t value);
|
|
public:
|
|
|
|
// uint32 u16_value = 6;
|
|
bool has_u16_value() const;
|
|
private:
|
|
bool _internal_has_u16_value() const;
|
|
public:
|
|
void clear_u16_value();
|
|
uint32_t u16_value() const;
|
|
void set_u16_value(uint32_t value);
|
|
private:
|
|
uint32_t _internal_u16_value() const;
|
|
void _internal_set_u16_value(uint32_t value);
|
|
public:
|
|
|
|
// uint32 u32_value = 7;
|
|
bool has_u32_value() const;
|
|
private:
|
|
bool _internal_has_u32_value() const;
|
|
public:
|
|
void clear_u32_value();
|
|
uint32_t u32_value() const;
|
|
void set_u32_value(uint32_t value);
|
|
private:
|
|
uint32_t _internal_u32_value() const;
|
|
void _internal_set_u32_value(uint32_t value);
|
|
public:
|
|
|
|
// uint64 u64_value = 8;
|
|
bool has_u64_value() const;
|
|
private:
|
|
bool _internal_has_u64_value() const;
|
|
public:
|
|
void clear_u64_value();
|
|
uint64_t u64_value() const;
|
|
void set_u64_value(uint64_t value);
|
|
private:
|
|
uint64_t _internal_u64_value() const;
|
|
void _internal_set_u64_value(uint64_t value);
|
|
public:
|
|
|
|
// float f32_value = 9;
|
|
bool has_f32_value() const;
|
|
private:
|
|
bool _internal_has_f32_value() const;
|
|
public:
|
|
void clear_f32_value();
|
|
float f32_value() const;
|
|
void set_f32_value(float value);
|
|
private:
|
|
float _internal_f32_value() const;
|
|
void _internal_set_f32_value(float value);
|
|
public:
|
|
|
|
// double f64_value = 10;
|
|
bool has_f64_value() const;
|
|
private:
|
|
bool _internal_has_f64_value() const;
|
|
public:
|
|
void clear_f64_value();
|
|
double f64_value() const;
|
|
void set_f64_value(double value);
|
|
private:
|
|
double _internal_f64_value() const;
|
|
void _internal_set_f64_value(double value);
|
|
public:
|
|
|
|
// bool bool_value = 11;
|
|
bool has_bool_value() const;
|
|
private:
|
|
bool _internal_has_bool_value() const;
|
|
public:
|
|
void clear_bool_value();
|
|
bool bool_value() const;
|
|
void set_bool_value(bool value);
|
|
private:
|
|
bool _internal_bool_value() const;
|
|
void _internal_set_bool_value(bool value);
|
|
public:
|
|
|
|
// bytes binary_value = 12;
|
|
bool has_binary_value() const;
|
|
private:
|
|
bool _internal_has_binary_value() const;
|
|
public:
|
|
void clear_binary_value();
|
|
const std::string& binary_value() const;
|
|
template <typename ArgT0 = const std::string&, typename... ArgT>
|
|
void set_binary_value(ArgT0&& arg0, ArgT... args);
|
|
std::string* mutable_binary_value();
|
|
PROTOBUF_NODISCARD std::string* release_binary_value();
|
|
void set_allocated_binary_value(std::string* binary_value);
|
|
private:
|
|
const std::string& _internal_binary_value() const;
|
|
inline PROTOBUF_ALWAYS_INLINE void _internal_set_binary_value(const std::string& value);
|
|
std::string* _internal_mutable_binary_value();
|
|
public:
|
|
|
|
// string string_value = 13;
|
|
bool has_string_value() const;
|
|
private:
|
|
bool _internal_has_string_value() const;
|
|
public:
|
|
void clear_string_value();
|
|
const std::string& string_value() const;
|
|
template <typename ArgT0 = const std::string&, typename... ArgT>
|
|
void set_string_value(ArgT0&& arg0, ArgT... args);
|
|
std::string* mutable_string_value();
|
|
PROTOBUF_NODISCARD std::string* release_string_value();
|
|
void set_allocated_string_value(std::string* string_value);
|
|
private:
|
|
const std::string& _internal_string_value() const;
|
|
inline PROTOBUF_ALWAYS_INLINE void _internal_set_string_value(const std::string& value);
|
|
std::string* _internal_mutable_string_value();
|
|
public:
|
|
|
|
// int32 date_value = 14;
|
|
bool has_date_value() const;
|
|
private:
|
|
bool _internal_has_date_value() const;
|
|
public:
|
|
void clear_date_value();
|
|
int32_t date_value() const;
|
|
void set_date_value(int32_t value);
|
|
private:
|
|
int32_t _internal_date_value() const;
|
|
void _internal_set_date_value(int32_t value);
|
|
public:
|
|
|
|
// int64 datetime_value = 15;
|
|
bool has_datetime_value() const;
|
|
private:
|
|
bool _internal_has_datetime_value() const;
|
|
public:
|
|
void clear_datetime_value();
|
|
int64_t datetime_value() const;
|
|
void set_datetime_value(int64_t value);
|
|
private:
|
|
int64_t _internal_datetime_value() const;
|
|
void _internal_set_datetime_value(int64_t value);
|
|
public:
|
|
|
|
// int64 timestamp_second_value = 16;
|
|
bool has_timestamp_second_value() const;
|
|
private:
|
|
bool _internal_has_timestamp_second_value() const;
|
|
public:
|
|
void clear_timestamp_second_value();
|
|
int64_t timestamp_second_value() const;
|
|
void set_timestamp_second_value(int64_t value);
|
|
private:
|
|
int64_t _internal_timestamp_second_value() const;
|
|
void _internal_set_timestamp_second_value(int64_t value);
|
|
public:
|
|
|
|
// int64 timestamp_millisecond_value = 17;
|
|
bool has_timestamp_millisecond_value() const;
|
|
private:
|
|
bool _internal_has_timestamp_millisecond_value() const;
|
|
public:
|
|
void clear_timestamp_millisecond_value();
|
|
int64_t timestamp_millisecond_value() const;
|
|
void set_timestamp_millisecond_value(int64_t value);
|
|
private:
|
|
int64_t _internal_timestamp_millisecond_value() const;
|
|
void _internal_set_timestamp_millisecond_value(int64_t value);
|
|
public:
|
|
|
|
// int64 timestamp_microsecond_value = 18;
|
|
bool has_timestamp_microsecond_value() const;
|
|
private:
|
|
bool _internal_has_timestamp_microsecond_value() const;
|
|
public:
|
|
void clear_timestamp_microsecond_value();
|
|
int64_t timestamp_microsecond_value() const;
|
|
void set_timestamp_microsecond_value(int64_t value);
|
|
private:
|
|
int64_t _internal_timestamp_microsecond_value() const;
|
|
void _internal_set_timestamp_microsecond_value(int64_t value);
|
|
public:
|
|
|
|
// int64 timestamp_nanosecond_value = 19;
|
|
bool has_timestamp_nanosecond_value() const;
|
|
private:
|
|
bool _internal_has_timestamp_nanosecond_value() const;
|
|
public:
|
|
void clear_timestamp_nanosecond_value();
|
|
int64_t timestamp_nanosecond_value() const;
|
|
void set_timestamp_nanosecond_value(int64_t value);
|
|
private:
|
|
int64_t _internal_timestamp_nanosecond_value() const;
|
|
void _internal_set_timestamp_nanosecond_value(int64_t value);
|
|
public:
|
|
|
|
// int64 time_second_value = 20;
|
|
bool has_time_second_value() const;
|
|
private:
|
|
bool _internal_has_time_second_value() const;
|
|
public:
|
|
void clear_time_second_value();
|
|
int64_t time_second_value() const;
|
|
void set_time_second_value(int64_t value);
|
|
private:
|
|
int64_t _internal_time_second_value() const;
|
|
void _internal_set_time_second_value(int64_t value);
|
|
public:
|
|
|
|
// int64 time_millisecond_value = 21;
|
|
bool has_time_millisecond_value() const;
|
|
private:
|
|
bool _internal_has_time_millisecond_value() const;
|
|
public:
|
|
void clear_time_millisecond_value();
|
|
int64_t time_millisecond_value() const;
|
|
void set_time_millisecond_value(int64_t value);
|
|
private:
|
|
int64_t _internal_time_millisecond_value() const;
|
|
void _internal_set_time_millisecond_value(int64_t value);
|
|
public:
|
|
|
|
// int64 time_microsecond_value = 22;
|
|
bool has_time_microsecond_value() const;
|
|
private:
|
|
bool _internal_has_time_microsecond_value() const;
|
|
public:
|
|
void clear_time_microsecond_value();
|
|
int64_t time_microsecond_value() const;
|
|
void set_time_microsecond_value(int64_t value);
|
|
private:
|
|
int64_t _internal_time_microsecond_value() const;
|
|
void _internal_set_time_microsecond_value(int64_t value);
|
|
public:
|
|
|
|
// int64 time_nanosecond_value = 23;
|
|
bool has_time_nanosecond_value() const;
|
|
private:
|
|
bool _internal_has_time_nanosecond_value() const;
|
|
public:
|
|
void clear_time_nanosecond_value();
|
|
int64_t time_nanosecond_value() const;
|
|
void set_time_nanosecond_value(int64_t value);
|
|
private:
|
|
int64_t _internal_time_nanosecond_value() const;
|
|
void _internal_set_time_nanosecond_value(int64_t value);
|
|
public:
|
|
|
|
// int32 interval_year_month_value = 24;
|
|
bool has_interval_year_month_value() const;
|
|
private:
|
|
bool _internal_has_interval_year_month_value() const;
|
|
public:
|
|
void clear_interval_year_month_value();
|
|
int32_t interval_year_month_value() const;
|
|
void set_interval_year_month_value(int32_t value);
|
|
private:
|
|
int32_t _internal_interval_year_month_value() const;
|
|
void _internal_set_interval_year_month_value(int32_t value);
|
|
public:
|
|
|
|
// int64 interval_day_time_value = 25;
|
|
bool has_interval_day_time_value() const;
|
|
private:
|
|
bool _internal_has_interval_day_time_value() const;
|
|
public:
|
|
void clear_interval_day_time_value();
|
|
int64_t interval_day_time_value() const;
|
|
void set_interval_day_time_value(int64_t value);
|
|
private:
|
|
int64_t _internal_interval_day_time_value() const;
|
|
void _internal_set_interval_day_time_value(int64_t value);
|
|
public:
|
|
|
|
// .greptime.v1.IntervalMonthDayNano interval_month_day_nano_value = 26;
|
|
bool has_interval_month_day_nano_value() const;
|
|
private:
|
|
bool _internal_has_interval_month_day_nano_value() const;
|
|
public:
|
|
void clear_interval_month_day_nano_value();
|
|
const ::greptime::v1::IntervalMonthDayNano& interval_month_day_nano_value() const;
|
|
PROTOBUF_NODISCARD ::greptime::v1::IntervalMonthDayNano* release_interval_month_day_nano_value();
|
|
::greptime::v1::IntervalMonthDayNano* mutable_interval_month_day_nano_value();
|
|
void set_allocated_interval_month_day_nano_value(::greptime::v1::IntervalMonthDayNano* interval_month_day_nano_value);
|
|
private:
|
|
const ::greptime::v1::IntervalMonthDayNano& _internal_interval_month_day_nano_value() const;
|
|
::greptime::v1::IntervalMonthDayNano* _internal_mutable_interval_month_day_nano_value();
|
|
public:
|
|
void unsafe_arena_set_allocated_interval_month_day_nano_value(
|
|
::greptime::v1::IntervalMonthDayNano* interval_month_day_nano_value);
|
|
::greptime::v1::IntervalMonthDayNano* unsafe_arena_release_interval_month_day_nano_value();
|
|
|
|
// .greptime.v1.Decimal128 decimal128_value = 31;
|
|
bool has_decimal128_value() const;
|
|
private:
|
|
bool _internal_has_decimal128_value() const;
|
|
public:
|
|
void clear_decimal128_value();
|
|
const ::greptime::v1::Decimal128& decimal128_value() const;
|
|
PROTOBUF_NODISCARD ::greptime::v1::Decimal128* release_decimal128_value();
|
|
::greptime::v1::Decimal128* mutable_decimal128_value();
|
|
void set_allocated_decimal128_value(::greptime::v1::Decimal128* decimal128_value);
|
|
private:
|
|
const ::greptime::v1::Decimal128& _internal_decimal128_value() const;
|
|
::greptime::v1::Decimal128* _internal_mutable_decimal128_value();
|
|
public:
|
|
void unsafe_arena_set_allocated_decimal128_value(
|
|
::greptime::v1::Decimal128* decimal128_value);
|
|
::greptime::v1::Decimal128* unsafe_arena_release_decimal128_value();
|
|
|
|
// .greptime.v1.ListValue list_value = 40;
|
|
bool has_list_value() const;
|
|
private:
|
|
bool _internal_has_list_value() const;
|
|
public:
|
|
void clear_list_value();
|
|
const ::greptime::v1::ListValue& list_value() const;
|
|
PROTOBUF_NODISCARD ::greptime::v1::ListValue* release_list_value();
|
|
::greptime::v1::ListValue* mutable_list_value();
|
|
void set_allocated_list_value(::greptime::v1::ListValue* list_value);
|
|
private:
|
|
const ::greptime::v1::ListValue& _internal_list_value() const;
|
|
::greptime::v1::ListValue* _internal_mutable_list_value();
|
|
public:
|
|
void unsafe_arena_set_allocated_list_value(
|
|
::greptime::v1::ListValue* list_value);
|
|
::greptime::v1::ListValue* unsafe_arena_release_list_value();
|
|
|
|
// .greptime.v1.StructValue struct_value = 41;
|
|
bool has_struct_value() const;
|
|
private:
|
|
bool _internal_has_struct_value() const;
|
|
public:
|
|
void clear_struct_value();
|
|
const ::greptime::v1::StructValue& struct_value() const;
|
|
PROTOBUF_NODISCARD ::greptime::v1::StructValue* release_struct_value();
|
|
::greptime::v1::StructValue* mutable_struct_value();
|
|
void set_allocated_struct_value(::greptime::v1::StructValue* struct_value);
|
|
private:
|
|
const ::greptime::v1::StructValue& _internal_struct_value() const;
|
|
::greptime::v1::StructValue* _internal_mutable_struct_value();
|
|
public:
|
|
void unsafe_arena_set_allocated_struct_value(
|
|
::greptime::v1::StructValue* struct_value);
|
|
::greptime::v1::StructValue* unsafe_arena_release_struct_value();
|
|
|
|
// .greptime.v1.JsonValue json_value = 42;
|
|
bool has_json_value() const;
|
|
private:
|
|
bool _internal_has_json_value() const;
|
|
public:
|
|
void clear_json_value();
|
|
const ::greptime::v1::JsonValue& json_value() const;
|
|
PROTOBUF_NODISCARD ::greptime::v1::JsonValue* release_json_value();
|
|
::greptime::v1::JsonValue* mutable_json_value();
|
|
void set_allocated_json_value(::greptime::v1::JsonValue* json_value);
|
|
private:
|
|
const ::greptime::v1::JsonValue& _internal_json_value() const;
|
|
::greptime::v1::JsonValue* _internal_mutable_json_value();
|
|
public:
|
|
void unsafe_arena_set_allocated_json_value(
|
|
::greptime::v1::JsonValue* json_value);
|
|
::greptime::v1::JsonValue* unsafe_arena_release_json_value();
|
|
|
|
void clear_value_data();
|
|
ValueDataCase value_data_case() const;
|
|
// @@protoc_insertion_point(class_scope:greptime.v1.Value)
|
|
private:
|
|
class _Internal;
|
|
void set_has_i8_value();
|
|
void set_has_i16_value();
|
|
void set_has_i32_value();
|
|
void set_has_i64_value();
|
|
void set_has_u8_value();
|
|
void set_has_u16_value();
|
|
void set_has_u32_value();
|
|
void set_has_u64_value();
|
|
void set_has_f32_value();
|
|
void set_has_f64_value();
|
|
void set_has_bool_value();
|
|
void set_has_binary_value();
|
|
void set_has_string_value();
|
|
void set_has_date_value();
|
|
void set_has_datetime_value();
|
|
void set_has_timestamp_second_value();
|
|
void set_has_timestamp_millisecond_value();
|
|
void set_has_timestamp_microsecond_value();
|
|
void set_has_timestamp_nanosecond_value();
|
|
void set_has_time_second_value();
|
|
void set_has_time_millisecond_value();
|
|
void set_has_time_microsecond_value();
|
|
void set_has_time_nanosecond_value();
|
|
void set_has_interval_year_month_value();
|
|
void set_has_interval_day_time_value();
|
|
void set_has_interval_month_day_nano_value();
|
|
void set_has_decimal128_value();
|
|
void set_has_list_value();
|
|
void set_has_struct_value();
|
|
void set_has_json_value();
|
|
|
|
inline bool has_value_data() const;
|
|
inline void clear_has_value_data();
|
|
|
|
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
|
|
typedef void InternalArenaConstructable_;
|
|
typedef void DestructorSkippable_;
|
|
struct Impl_ {
|
|
union ValueDataUnion {
|
|
constexpr ValueDataUnion() : _constinit_{} {}
|
|
::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
|
|
int32_t i8_value_;
|
|
int32_t i16_value_;
|
|
int32_t i32_value_;
|
|
int64_t i64_value_;
|
|
uint32_t u8_value_;
|
|
uint32_t u16_value_;
|
|
uint32_t u32_value_;
|
|
uint64_t u64_value_;
|
|
float f32_value_;
|
|
double f64_value_;
|
|
bool bool_value_;
|
|
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr binary_value_;
|
|
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr string_value_;
|
|
int32_t date_value_;
|
|
int64_t datetime_value_;
|
|
int64_t timestamp_second_value_;
|
|
int64_t timestamp_millisecond_value_;
|
|
int64_t timestamp_microsecond_value_;
|
|
int64_t timestamp_nanosecond_value_;
|
|
int64_t time_second_value_;
|
|
int64_t time_millisecond_value_;
|
|
int64_t time_microsecond_value_;
|
|
int64_t time_nanosecond_value_;
|
|
int32_t interval_year_month_value_;
|
|
int64_t interval_day_time_value_;
|
|
::greptime::v1::IntervalMonthDayNano* interval_month_day_nano_value_;
|
|
::greptime::v1::Decimal128* decimal128_value_;
|
|
::greptime::v1::ListValue* list_value_;
|
|
::greptime::v1::StructValue* struct_value_;
|
|
::greptime::v1::JsonValue* json_value_;
|
|
} value_data_;
|
|
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
|
|
uint32_t _oneof_case_[1];
|
|
|
|
};
|
|
union { Impl_ _impl_; };
|
|
friend struct ::TableStruct_greptime_2fv1_2frow_2eproto;
|
|
};
|
|
// -------------------------------------------------------------------
|
|
|
|
class ListValue final :
|
|
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:greptime.v1.ListValue) */ {
|
|
public:
|
|
inline ListValue() : ListValue(nullptr) {}
|
|
~ListValue() override;
|
|
explicit PROTOBUF_CONSTEXPR ListValue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
|
|
|
|
ListValue(const ListValue& from);
|
|
ListValue(ListValue&& from) noexcept
|
|
: ListValue() {
|
|
*this = ::std::move(from);
|
|
}
|
|
|
|
inline ListValue& operator=(const ListValue& from) {
|
|
CopyFrom(from);
|
|
return *this;
|
|
}
|
|
inline ListValue& operator=(ListValue&& 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 ListValue& default_instance() {
|
|
return *internal_default_instance();
|
|
}
|
|
static inline const ListValue* internal_default_instance() {
|
|
return reinterpret_cast<const ListValue*>(
|
|
&_ListValue_default_instance_);
|
|
}
|
|
static constexpr int kIndexInFileMessages =
|
|
4;
|
|
|
|
friend void swap(ListValue& a, ListValue& b) {
|
|
a.Swap(&b);
|
|
}
|
|
inline void Swap(ListValue* 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(ListValue* other) {
|
|
if (other == this) return;
|
|
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
|
|
InternalSwap(other);
|
|
}
|
|
|
|
// implements Message ----------------------------------------------
|
|
|
|
ListValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
|
|
return CreateMaybeMessage<ListValue>(arena);
|
|
}
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
|
|
void CopyFrom(const ListValue& from);
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
|
|
void MergeFrom( const ListValue& from) {
|
|
ListValue::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(ListValue* other);
|
|
|
|
private:
|
|
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
|
|
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
|
|
return "greptime.v1.ListValue";
|
|
}
|
|
protected:
|
|
explicit ListValue(::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 {
|
|
kItemsFieldNumber = 1,
|
|
};
|
|
// repeated .greptime.v1.Value items = 1;
|
|
int items_size() const;
|
|
private:
|
|
int _internal_items_size() const;
|
|
public:
|
|
void clear_items();
|
|
::greptime::v1::Value* mutable_items(int index);
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::Value >*
|
|
mutable_items();
|
|
private:
|
|
const ::greptime::v1::Value& _internal_items(int index) const;
|
|
::greptime::v1::Value* _internal_add_items();
|
|
public:
|
|
const ::greptime::v1::Value& items(int index) const;
|
|
::greptime::v1::Value* add_items();
|
|
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::Value >&
|
|
items() const;
|
|
|
|
// @@protoc_insertion_point(class_scope:greptime.v1.ListValue)
|
|
private:
|
|
class _Internal;
|
|
|
|
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
|
|
typedef void InternalArenaConstructable_;
|
|
typedef void DestructorSkippable_;
|
|
struct Impl_ {
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::Value > items_;
|
|
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
|
|
};
|
|
union { Impl_ _impl_; };
|
|
friend struct ::TableStruct_greptime_2fv1_2frow_2eproto;
|
|
};
|
|
// -------------------------------------------------------------------
|
|
|
|
class StructValue final :
|
|
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:greptime.v1.StructValue) */ {
|
|
public:
|
|
inline StructValue() : StructValue(nullptr) {}
|
|
~StructValue() override;
|
|
explicit PROTOBUF_CONSTEXPR StructValue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
|
|
|
|
StructValue(const StructValue& from);
|
|
StructValue(StructValue&& from) noexcept
|
|
: StructValue() {
|
|
*this = ::std::move(from);
|
|
}
|
|
|
|
inline StructValue& operator=(const StructValue& from) {
|
|
CopyFrom(from);
|
|
return *this;
|
|
}
|
|
inline StructValue& operator=(StructValue&& 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 StructValue& default_instance() {
|
|
return *internal_default_instance();
|
|
}
|
|
static inline const StructValue* internal_default_instance() {
|
|
return reinterpret_cast<const StructValue*>(
|
|
&_StructValue_default_instance_);
|
|
}
|
|
static constexpr int kIndexInFileMessages =
|
|
5;
|
|
|
|
friend void swap(StructValue& a, StructValue& b) {
|
|
a.Swap(&b);
|
|
}
|
|
inline void Swap(StructValue* 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(StructValue* other) {
|
|
if (other == this) return;
|
|
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
|
|
InternalSwap(other);
|
|
}
|
|
|
|
// implements Message ----------------------------------------------
|
|
|
|
StructValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
|
|
return CreateMaybeMessage<StructValue>(arena);
|
|
}
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
|
|
void CopyFrom(const StructValue& from);
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
|
|
void MergeFrom( const StructValue& from) {
|
|
StructValue::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(StructValue* other);
|
|
|
|
private:
|
|
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
|
|
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
|
|
return "greptime.v1.StructValue";
|
|
}
|
|
protected:
|
|
explicit StructValue(::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 {
|
|
kItemsFieldNumber = 2,
|
|
};
|
|
// repeated .greptime.v1.Value items = 2;
|
|
int items_size() const;
|
|
private:
|
|
int _internal_items_size() const;
|
|
public:
|
|
void clear_items();
|
|
::greptime::v1::Value* mutable_items(int index);
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::Value >*
|
|
mutable_items();
|
|
private:
|
|
const ::greptime::v1::Value& _internal_items(int index) const;
|
|
::greptime::v1::Value* _internal_add_items();
|
|
public:
|
|
const ::greptime::v1::Value& items(int index) const;
|
|
::greptime::v1::Value* add_items();
|
|
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::Value >&
|
|
items() const;
|
|
|
|
// @@protoc_insertion_point(class_scope:greptime.v1.StructValue)
|
|
private:
|
|
class _Internal;
|
|
|
|
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
|
|
typedef void InternalArenaConstructable_;
|
|
typedef void DestructorSkippable_;
|
|
struct Impl_ {
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::Value > items_;
|
|
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
|
|
};
|
|
union { Impl_ _impl_; };
|
|
friend struct ::TableStruct_greptime_2fv1_2frow_2eproto;
|
|
};
|
|
// -------------------------------------------------------------------
|
|
|
|
class JsonValue final :
|
|
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:greptime.v1.JsonValue) */ {
|
|
public:
|
|
inline JsonValue() : JsonValue(nullptr) {}
|
|
~JsonValue() override;
|
|
explicit PROTOBUF_CONSTEXPR JsonValue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
|
|
|
|
JsonValue(const JsonValue& from);
|
|
JsonValue(JsonValue&& from) noexcept
|
|
: JsonValue() {
|
|
*this = ::std::move(from);
|
|
}
|
|
|
|
inline JsonValue& operator=(const JsonValue& from) {
|
|
CopyFrom(from);
|
|
return *this;
|
|
}
|
|
inline JsonValue& operator=(JsonValue&& 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 JsonValue& default_instance() {
|
|
return *internal_default_instance();
|
|
}
|
|
enum ValueCase {
|
|
kBoolean = 1,
|
|
kInt = 2,
|
|
kUint = 3,
|
|
kFloat = 4,
|
|
kStr = 5,
|
|
kArray = 6,
|
|
kObject = 7,
|
|
kVariant = 8,
|
|
VALUE_NOT_SET = 0,
|
|
};
|
|
|
|
static inline const JsonValue* internal_default_instance() {
|
|
return reinterpret_cast<const JsonValue*>(
|
|
&_JsonValue_default_instance_);
|
|
}
|
|
static constexpr int kIndexInFileMessages =
|
|
6;
|
|
|
|
friend void swap(JsonValue& a, JsonValue& b) {
|
|
a.Swap(&b);
|
|
}
|
|
inline void Swap(JsonValue* 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(JsonValue* other) {
|
|
if (other == this) return;
|
|
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
|
|
InternalSwap(other);
|
|
}
|
|
|
|
// implements Message ----------------------------------------------
|
|
|
|
JsonValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
|
|
return CreateMaybeMessage<JsonValue>(arena);
|
|
}
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
|
|
void CopyFrom(const JsonValue& from);
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
|
|
void MergeFrom( const JsonValue& from) {
|
|
JsonValue::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(JsonValue* other);
|
|
|
|
private:
|
|
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
|
|
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
|
|
return "greptime.v1.JsonValue";
|
|
}
|
|
protected:
|
|
explicit JsonValue(::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 {
|
|
kBooleanFieldNumber = 1,
|
|
kIntFieldNumber = 2,
|
|
kUintFieldNumber = 3,
|
|
kFloatFieldNumber = 4,
|
|
kStrFieldNumber = 5,
|
|
kArrayFieldNumber = 6,
|
|
kObjectFieldNumber = 7,
|
|
kVariantFieldNumber = 8,
|
|
};
|
|
// bool boolean = 1;
|
|
bool has_boolean() const;
|
|
private:
|
|
bool _internal_has_boolean() const;
|
|
public:
|
|
void clear_boolean();
|
|
bool boolean() const;
|
|
void set_boolean(bool value);
|
|
private:
|
|
bool _internal_boolean() const;
|
|
void _internal_set_boolean(bool value);
|
|
public:
|
|
|
|
// int64 int = 2;
|
|
bool has_int_() const;
|
|
private:
|
|
bool _internal_has_int_() const;
|
|
public:
|
|
void clear_int_();
|
|
int64_t int_() const;
|
|
void set_int_(int64_t value);
|
|
private:
|
|
int64_t _internal_int_() const;
|
|
void _internal_set_int_(int64_t value);
|
|
public:
|
|
|
|
// uint64 uint = 3;
|
|
bool has_uint() const;
|
|
private:
|
|
bool _internal_has_uint() const;
|
|
public:
|
|
void clear_uint();
|
|
uint64_t uint() const;
|
|
void set_uint(uint64_t value);
|
|
private:
|
|
uint64_t _internal_uint() const;
|
|
void _internal_set_uint(uint64_t value);
|
|
public:
|
|
|
|
// double float = 4;
|
|
bool has_float_() const;
|
|
private:
|
|
bool _internal_has_float_() const;
|
|
public:
|
|
void clear_float_();
|
|
double float_() const;
|
|
void set_float_(double value);
|
|
private:
|
|
double _internal_float_() const;
|
|
void _internal_set_float_(double value);
|
|
public:
|
|
|
|
// string str = 5;
|
|
bool has_str() const;
|
|
private:
|
|
bool _internal_has_str() const;
|
|
public:
|
|
void clear_str();
|
|
const std::string& str() const;
|
|
template <typename ArgT0 = const std::string&, typename... ArgT>
|
|
void set_str(ArgT0&& arg0, ArgT... args);
|
|
std::string* mutable_str();
|
|
PROTOBUF_NODISCARD std::string* release_str();
|
|
void set_allocated_str(std::string* str);
|
|
private:
|
|
const std::string& _internal_str() const;
|
|
inline PROTOBUF_ALWAYS_INLINE void _internal_set_str(const std::string& value);
|
|
std::string* _internal_mutable_str();
|
|
public:
|
|
|
|
// .greptime.v1.JsonList array = 6;
|
|
bool has_array() const;
|
|
private:
|
|
bool _internal_has_array() const;
|
|
public:
|
|
void clear_array();
|
|
const ::greptime::v1::JsonList& array() const;
|
|
PROTOBUF_NODISCARD ::greptime::v1::JsonList* release_array();
|
|
::greptime::v1::JsonList* mutable_array();
|
|
void set_allocated_array(::greptime::v1::JsonList* array);
|
|
private:
|
|
const ::greptime::v1::JsonList& _internal_array() const;
|
|
::greptime::v1::JsonList* _internal_mutable_array();
|
|
public:
|
|
void unsafe_arena_set_allocated_array(
|
|
::greptime::v1::JsonList* array);
|
|
::greptime::v1::JsonList* unsafe_arena_release_array();
|
|
|
|
// .greptime.v1.JsonObject object = 7;
|
|
bool has_object() const;
|
|
private:
|
|
bool _internal_has_object() const;
|
|
public:
|
|
void clear_object();
|
|
const ::greptime::v1::JsonObject& object() const;
|
|
PROTOBUF_NODISCARD ::greptime::v1::JsonObject* release_object();
|
|
::greptime::v1::JsonObject* mutable_object();
|
|
void set_allocated_object(::greptime::v1::JsonObject* object);
|
|
private:
|
|
const ::greptime::v1::JsonObject& _internal_object() const;
|
|
::greptime::v1::JsonObject* _internal_mutable_object();
|
|
public:
|
|
void unsafe_arena_set_allocated_object(
|
|
::greptime::v1::JsonObject* object);
|
|
::greptime::v1::JsonObject* unsafe_arena_release_object();
|
|
|
|
// bytes variant = 8;
|
|
bool has_variant() const;
|
|
private:
|
|
bool _internal_has_variant() const;
|
|
public:
|
|
void clear_variant();
|
|
const std::string& variant() const;
|
|
template <typename ArgT0 = const std::string&, typename... ArgT>
|
|
void set_variant(ArgT0&& arg0, ArgT... args);
|
|
std::string* mutable_variant();
|
|
PROTOBUF_NODISCARD std::string* release_variant();
|
|
void set_allocated_variant(std::string* variant);
|
|
private:
|
|
const std::string& _internal_variant() const;
|
|
inline PROTOBUF_ALWAYS_INLINE void _internal_set_variant(const std::string& value);
|
|
std::string* _internal_mutable_variant();
|
|
public:
|
|
|
|
void clear_value();
|
|
ValueCase value_case() const;
|
|
// @@protoc_insertion_point(class_scope:greptime.v1.JsonValue)
|
|
private:
|
|
class _Internal;
|
|
void set_has_boolean();
|
|
void set_has_int_();
|
|
void set_has_uint();
|
|
void set_has_float_();
|
|
void set_has_str();
|
|
void set_has_array();
|
|
void set_has_object();
|
|
void set_has_variant();
|
|
|
|
inline bool has_value() const;
|
|
inline void clear_has_value();
|
|
|
|
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
|
|
typedef void InternalArenaConstructable_;
|
|
typedef void DestructorSkippable_;
|
|
struct Impl_ {
|
|
union ValueUnion {
|
|
constexpr ValueUnion() : _constinit_{} {}
|
|
::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
|
|
bool boolean_;
|
|
int64_t int__;
|
|
uint64_t uint_;
|
|
double float__;
|
|
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr str_;
|
|
::greptime::v1::JsonList* array_;
|
|
::greptime::v1::JsonObject* object_;
|
|
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr variant_;
|
|
} value_;
|
|
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
|
|
uint32_t _oneof_case_[1];
|
|
|
|
};
|
|
union { Impl_ _impl_; };
|
|
friend struct ::TableStruct_greptime_2fv1_2frow_2eproto;
|
|
};
|
|
// -------------------------------------------------------------------
|
|
|
|
class JsonList final :
|
|
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:greptime.v1.JsonList) */ {
|
|
public:
|
|
inline JsonList() : JsonList(nullptr) {}
|
|
~JsonList() override;
|
|
explicit PROTOBUF_CONSTEXPR JsonList(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
|
|
|
|
JsonList(const JsonList& from);
|
|
JsonList(JsonList&& from) noexcept
|
|
: JsonList() {
|
|
*this = ::std::move(from);
|
|
}
|
|
|
|
inline JsonList& operator=(const JsonList& from) {
|
|
CopyFrom(from);
|
|
return *this;
|
|
}
|
|
inline JsonList& operator=(JsonList&& 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 JsonList& default_instance() {
|
|
return *internal_default_instance();
|
|
}
|
|
static inline const JsonList* internal_default_instance() {
|
|
return reinterpret_cast<const JsonList*>(
|
|
&_JsonList_default_instance_);
|
|
}
|
|
static constexpr int kIndexInFileMessages =
|
|
7;
|
|
|
|
friend void swap(JsonList& a, JsonList& b) {
|
|
a.Swap(&b);
|
|
}
|
|
inline void Swap(JsonList* 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(JsonList* other) {
|
|
if (other == this) return;
|
|
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
|
|
InternalSwap(other);
|
|
}
|
|
|
|
// implements Message ----------------------------------------------
|
|
|
|
JsonList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
|
|
return CreateMaybeMessage<JsonList>(arena);
|
|
}
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
|
|
void CopyFrom(const JsonList& from);
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
|
|
void MergeFrom( const JsonList& from) {
|
|
JsonList::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(JsonList* other);
|
|
|
|
private:
|
|
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
|
|
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
|
|
return "greptime.v1.JsonList";
|
|
}
|
|
protected:
|
|
explicit JsonList(::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 {
|
|
kItemsFieldNumber = 1,
|
|
};
|
|
// repeated .greptime.v1.JsonValue items = 1;
|
|
int items_size() const;
|
|
private:
|
|
int _internal_items_size() const;
|
|
public:
|
|
void clear_items();
|
|
::greptime::v1::JsonValue* mutable_items(int index);
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::JsonValue >*
|
|
mutable_items();
|
|
private:
|
|
const ::greptime::v1::JsonValue& _internal_items(int index) const;
|
|
::greptime::v1::JsonValue* _internal_add_items();
|
|
public:
|
|
const ::greptime::v1::JsonValue& items(int index) const;
|
|
::greptime::v1::JsonValue* add_items();
|
|
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::JsonValue >&
|
|
items() const;
|
|
|
|
// @@protoc_insertion_point(class_scope:greptime.v1.JsonList)
|
|
private:
|
|
class _Internal;
|
|
|
|
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
|
|
typedef void InternalArenaConstructable_;
|
|
typedef void DestructorSkippable_;
|
|
struct Impl_ {
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::JsonValue > items_;
|
|
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
|
|
};
|
|
union { Impl_ _impl_; };
|
|
friend struct ::TableStruct_greptime_2fv1_2frow_2eproto;
|
|
};
|
|
// -------------------------------------------------------------------
|
|
|
|
class JsonObject_Entry final :
|
|
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:greptime.v1.JsonObject.Entry) */ {
|
|
public:
|
|
inline JsonObject_Entry() : JsonObject_Entry(nullptr) {}
|
|
~JsonObject_Entry() override;
|
|
explicit PROTOBUF_CONSTEXPR JsonObject_Entry(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
|
|
|
|
JsonObject_Entry(const JsonObject_Entry& from);
|
|
JsonObject_Entry(JsonObject_Entry&& from) noexcept
|
|
: JsonObject_Entry() {
|
|
*this = ::std::move(from);
|
|
}
|
|
|
|
inline JsonObject_Entry& operator=(const JsonObject_Entry& from) {
|
|
CopyFrom(from);
|
|
return *this;
|
|
}
|
|
inline JsonObject_Entry& operator=(JsonObject_Entry&& 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 JsonObject_Entry& default_instance() {
|
|
return *internal_default_instance();
|
|
}
|
|
static inline const JsonObject_Entry* internal_default_instance() {
|
|
return reinterpret_cast<const JsonObject_Entry*>(
|
|
&_JsonObject_Entry_default_instance_);
|
|
}
|
|
static constexpr int kIndexInFileMessages =
|
|
8;
|
|
|
|
friend void swap(JsonObject_Entry& a, JsonObject_Entry& b) {
|
|
a.Swap(&b);
|
|
}
|
|
inline void Swap(JsonObject_Entry* 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(JsonObject_Entry* other) {
|
|
if (other == this) return;
|
|
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
|
|
InternalSwap(other);
|
|
}
|
|
|
|
// implements Message ----------------------------------------------
|
|
|
|
JsonObject_Entry* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
|
|
return CreateMaybeMessage<JsonObject_Entry>(arena);
|
|
}
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
|
|
void CopyFrom(const JsonObject_Entry& from);
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
|
|
void MergeFrom( const JsonObject_Entry& from) {
|
|
JsonObject_Entry::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(JsonObject_Entry* other);
|
|
|
|
private:
|
|
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
|
|
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
|
|
return "greptime.v1.JsonObject.Entry";
|
|
}
|
|
protected:
|
|
explicit JsonObject_Entry(::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 {
|
|
kKeyFieldNumber = 1,
|
|
kValueFieldNumber = 2,
|
|
};
|
|
// string key = 1;
|
|
void clear_key();
|
|
const std::string& key() const;
|
|
template <typename ArgT0 = const std::string&, typename... ArgT>
|
|
void set_key(ArgT0&& arg0, ArgT... args);
|
|
std::string* mutable_key();
|
|
PROTOBUF_NODISCARD std::string* release_key();
|
|
void set_allocated_key(std::string* key);
|
|
private:
|
|
const std::string& _internal_key() const;
|
|
inline PROTOBUF_ALWAYS_INLINE void _internal_set_key(const std::string& value);
|
|
std::string* _internal_mutable_key();
|
|
public:
|
|
|
|
// .greptime.v1.JsonValue value = 2;
|
|
bool has_value() const;
|
|
private:
|
|
bool _internal_has_value() const;
|
|
public:
|
|
void clear_value();
|
|
const ::greptime::v1::JsonValue& value() const;
|
|
PROTOBUF_NODISCARD ::greptime::v1::JsonValue* release_value();
|
|
::greptime::v1::JsonValue* mutable_value();
|
|
void set_allocated_value(::greptime::v1::JsonValue* value);
|
|
private:
|
|
const ::greptime::v1::JsonValue& _internal_value() const;
|
|
::greptime::v1::JsonValue* _internal_mutable_value();
|
|
public:
|
|
void unsafe_arena_set_allocated_value(
|
|
::greptime::v1::JsonValue* value);
|
|
::greptime::v1::JsonValue* unsafe_arena_release_value();
|
|
|
|
// @@protoc_insertion_point(class_scope:greptime.v1.JsonObject.Entry)
|
|
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 key_;
|
|
::greptime::v1::JsonValue* value_;
|
|
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
|
|
};
|
|
union { Impl_ _impl_; };
|
|
friend struct ::TableStruct_greptime_2fv1_2frow_2eproto;
|
|
};
|
|
// -------------------------------------------------------------------
|
|
|
|
class JsonObject final :
|
|
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:greptime.v1.JsonObject) */ {
|
|
public:
|
|
inline JsonObject() : JsonObject(nullptr) {}
|
|
~JsonObject() override;
|
|
explicit PROTOBUF_CONSTEXPR JsonObject(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
|
|
|
|
JsonObject(const JsonObject& from);
|
|
JsonObject(JsonObject&& from) noexcept
|
|
: JsonObject() {
|
|
*this = ::std::move(from);
|
|
}
|
|
|
|
inline JsonObject& operator=(const JsonObject& from) {
|
|
CopyFrom(from);
|
|
return *this;
|
|
}
|
|
inline JsonObject& operator=(JsonObject&& 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 JsonObject& default_instance() {
|
|
return *internal_default_instance();
|
|
}
|
|
static inline const JsonObject* internal_default_instance() {
|
|
return reinterpret_cast<const JsonObject*>(
|
|
&_JsonObject_default_instance_);
|
|
}
|
|
static constexpr int kIndexInFileMessages =
|
|
9;
|
|
|
|
friend void swap(JsonObject& a, JsonObject& b) {
|
|
a.Swap(&b);
|
|
}
|
|
inline void Swap(JsonObject* 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(JsonObject* other) {
|
|
if (other == this) return;
|
|
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
|
|
InternalSwap(other);
|
|
}
|
|
|
|
// implements Message ----------------------------------------------
|
|
|
|
JsonObject* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
|
|
return CreateMaybeMessage<JsonObject>(arena);
|
|
}
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
|
|
void CopyFrom(const JsonObject& from);
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
|
|
void MergeFrom( const JsonObject& from) {
|
|
JsonObject::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(JsonObject* other);
|
|
|
|
private:
|
|
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
|
|
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
|
|
return "greptime.v1.JsonObject";
|
|
}
|
|
protected:
|
|
explicit JsonObject(::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 ----------------------------------------------------
|
|
|
|
typedef JsonObject_Entry Entry;
|
|
|
|
// accessors -------------------------------------------------------
|
|
|
|
enum : int {
|
|
kEntriesFieldNumber = 1,
|
|
};
|
|
// repeated .greptime.v1.JsonObject.Entry entries = 1;
|
|
int entries_size() const;
|
|
private:
|
|
int _internal_entries_size() const;
|
|
public:
|
|
void clear_entries();
|
|
::greptime::v1::JsonObject_Entry* mutable_entries(int index);
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::JsonObject_Entry >*
|
|
mutable_entries();
|
|
private:
|
|
const ::greptime::v1::JsonObject_Entry& _internal_entries(int index) const;
|
|
::greptime::v1::JsonObject_Entry* _internal_add_entries();
|
|
public:
|
|
const ::greptime::v1::JsonObject_Entry& entries(int index) const;
|
|
::greptime::v1::JsonObject_Entry* add_entries();
|
|
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::JsonObject_Entry >&
|
|
entries() const;
|
|
|
|
// @@protoc_insertion_point(class_scope:greptime.v1.JsonObject)
|
|
private:
|
|
class _Internal;
|
|
|
|
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
|
|
typedef void InternalArenaConstructable_;
|
|
typedef void DestructorSkippable_;
|
|
struct Impl_ {
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::JsonObject_Entry > entries_;
|
|
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
|
|
};
|
|
union { Impl_ _impl_; };
|
|
friend struct ::TableStruct_greptime_2fv1_2frow_2eproto;
|
|
};
|
|
// ===================================================================
|
|
|
|
|
|
// ===================================================================
|
|
|
|
#ifdef __GNUC__
|
|
#pragma GCC diagnostic push
|
|
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
|
|
#endif // __GNUC__
|
|
// Rows
|
|
|
|
// repeated .greptime.v1.ColumnSchema schema = 1;
|
|
inline int Rows::_internal_schema_size() const {
|
|
return _impl_.schema_.size();
|
|
}
|
|
inline int Rows::schema_size() const {
|
|
return _internal_schema_size();
|
|
}
|
|
inline void Rows::clear_schema() {
|
|
_impl_.schema_.Clear();
|
|
}
|
|
inline ::greptime::v1::ColumnSchema* Rows::mutable_schema(int index) {
|
|
// @@protoc_insertion_point(field_mutable:greptime.v1.Rows.schema)
|
|
return _impl_.schema_.Mutable(index);
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::ColumnSchema >*
|
|
Rows::mutable_schema() {
|
|
// @@protoc_insertion_point(field_mutable_list:greptime.v1.Rows.schema)
|
|
return &_impl_.schema_;
|
|
}
|
|
inline const ::greptime::v1::ColumnSchema& Rows::_internal_schema(int index) const {
|
|
return _impl_.schema_.Get(index);
|
|
}
|
|
inline const ::greptime::v1::ColumnSchema& Rows::schema(int index) const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.Rows.schema)
|
|
return _internal_schema(index);
|
|
}
|
|
inline ::greptime::v1::ColumnSchema* Rows::_internal_add_schema() {
|
|
return _impl_.schema_.Add();
|
|
}
|
|
inline ::greptime::v1::ColumnSchema* Rows::add_schema() {
|
|
::greptime::v1::ColumnSchema* _add = _internal_add_schema();
|
|
// @@protoc_insertion_point(field_add:greptime.v1.Rows.schema)
|
|
return _add;
|
|
}
|
|
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::ColumnSchema >&
|
|
Rows::schema() const {
|
|
// @@protoc_insertion_point(field_list:greptime.v1.Rows.schema)
|
|
return _impl_.schema_;
|
|
}
|
|
|
|
// repeated .greptime.v1.Row rows = 2;
|
|
inline int Rows::_internal_rows_size() const {
|
|
return _impl_.rows_.size();
|
|
}
|
|
inline int Rows::rows_size() const {
|
|
return _internal_rows_size();
|
|
}
|
|
inline void Rows::clear_rows() {
|
|
_impl_.rows_.Clear();
|
|
}
|
|
inline ::greptime::v1::Row* Rows::mutable_rows(int index) {
|
|
// @@protoc_insertion_point(field_mutable:greptime.v1.Rows.rows)
|
|
return _impl_.rows_.Mutable(index);
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::Row >*
|
|
Rows::mutable_rows() {
|
|
// @@protoc_insertion_point(field_mutable_list:greptime.v1.Rows.rows)
|
|
return &_impl_.rows_;
|
|
}
|
|
inline const ::greptime::v1::Row& Rows::_internal_rows(int index) const {
|
|
return _impl_.rows_.Get(index);
|
|
}
|
|
inline const ::greptime::v1::Row& Rows::rows(int index) const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.Rows.rows)
|
|
return _internal_rows(index);
|
|
}
|
|
inline ::greptime::v1::Row* Rows::_internal_add_rows() {
|
|
return _impl_.rows_.Add();
|
|
}
|
|
inline ::greptime::v1::Row* Rows::add_rows() {
|
|
::greptime::v1::Row* _add = _internal_add_rows();
|
|
// @@protoc_insertion_point(field_add:greptime.v1.Rows.rows)
|
|
return _add;
|
|
}
|
|
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::Row >&
|
|
Rows::rows() const {
|
|
// @@protoc_insertion_point(field_list:greptime.v1.Rows.rows)
|
|
return _impl_.rows_;
|
|
}
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
// ColumnSchema
|
|
|
|
// string column_name = 1;
|
|
inline void ColumnSchema::clear_column_name() {
|
|
_impl_.column_name_.ClearToEmpty();
|
|
}
|
|
inline const std::string& ColumnSchema::column_name() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.ColumnSchema.column_name)
|
|
return _internal_column_name();
|
|
}
|
|
template <typename ArgT0, typename... ArgT>
|
|
inline PROTOBUF_ALWAYS_INLINE
|
|
void ColumnSchema::set_column_name(ArgT0&& arg0, ArgT... args) {
|
|
|
|
_impl_.column_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
|
|
// @@protoc_insertion_point(field_set:greptime.v1.ColumnSchema.column_name)
|
|
}
|
|
inline std::string* ColumnSchema::mutable_column_name() {
|
|
std::string* _s = _internal_mutable_column_name();
|
|
// @@protoc_insertion_point(field_mutable:greptime.v1.ColumnSchema.column_name)
|
|
return _s;
|
|
}
|
|
inline const std::string& ColumnSchema::_internal_column_name() const {
|
|
return _impl_.column_name_.Get();
|
|
}
|
|
inline void ColumnSchema::_internal_set_column_name(const std::string& value) {
|
|
|
|
_impl_.column_name_.Set(value, GetArenaForAllocation());
|
|
}
|
|
inline std::string* ColumnSchema::_internal_mutable_column_name() {
|
|
|
|
return _impl_.column_name_.Mutable(GetArenaForAllocation());
|
|
}
|
|
inline std::string* ColumnSchema::release_column_name() {
|
|
// @@protoc_insertion_point(field_release:greptime.v1.ColumnSchema.column_name)
|
|
return _impl_.column_name_.Release();
|
|
}
|
|
inline void ColumnSchema::set_allocated_column_name(std::string* column_name) {
|
|
if (column_name != nullptr) {
|
|
|
|
} else {
|
|
|
|
}
|
|
_impl_.column_name_.SetAllocated(column_name, GetArenaForAllocation());
|
|
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
if (_impl_.column_name_.IsDefault()) {
|
|
_impl_.column_name_.Set("", GetArenaForAllocation());
|
|
}
|
|
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
// @@protoc_insertion_point(field_set_allocated:greptime.v1.ColumnSchema.column_name)
|
|
}
|
|
|
|
// .greptime.v1.ColumnDataType datatype = 2;
|
|
inline void ColumnSchema::clear_datatype() {
|
|
_impl_.datatype_ = 0;
|
|
}
|
|
inline ::greptime::v1::ColumnDataType ColumnSchema::_internal_datatype() const {
|
|
return static_cast< ::greptime::v1::ColumnDataType >(_impl_.datatype_);
|
|
}
|
|
inline ::greptime::v1::ColumnDataType ColumnSchema::datatype() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.ColumnSchema.datatype)
|
|
return _internal_datatype();
|
|
}
|
|
inline void ColumnSchema::_internal_set_datatype(::greptime::v1::ColumnDataType value) {
|
|
|
|
_impl_.datatype_ = value;
|
|
}
|
|
inline void ColumnSchema::set_datatype(::greptime::v1::ColumnDataType value) {
|
|
_internal_set_datatype(value);
|
|
// @@protoc_insertion_point(field_set:greptime.v1.ColumnSchema.datatype)
|
|
}
|
|
|
|
// .greptime.v1.SemanticType semantic_type = 3;
|
|
inline void ColumnSchema::clear_semantic_type() {
|
|
_impl_.semantic_type_ = 0;
|
|
}
|
|
inline ::greptime::v1::SemanticType ColumnSchema::_internal_semantic_type() const {
|
|
return static_cast< ::greptime::v1::SemanticType >(_impl_.semantic_type_);
|
|
}
|
|
inline ::greptime::v1::SemanticType ColumnSchema::semantic_type() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.ColumnSchema.semantic_type)
|
|
return _internal_semantic_type();
|
|
}
|
|
inline void ColumnSchema::_internal_set_semantic_type(::greptime::v1::SemanticType value) {
|
|
|
|
_impl_.semantic_type_ = value;
|
|
}
|
|
inline void ColumnSchema::set_semantic_type(::greptime::v1::SemanticType value) {
|
|
_internal_set_semantic_type(value);
|
|
// @@protoc_insertion_point(field_set:greptime.v1.ColumnSchema.semantic_type)
|
|
}
|
|
|
|
// .greptime.v1.ColumnDataTypeExtension datatype_extension = 4;
|
|
inline bool ColumnSchema::_internal_has_datatype_extension() const {
|
|
return this != internal_default_instance() && _impl_.datatype_extension_ != nullptr;
|
|
}
|
|
inline bool ColumnSchema::has_datatype_extension() const {
|
|
return _internal_has_datatype_extension();
|
|
}
|
|
inline const ::greptime::v1::ColumnDataTypeExtension& ColumnSchema::_internal_datatype_extension() const {
|
|
const ::greptime::v1::ColumnDataTypeExtension* p = _impl_.datatype_extension_;
|
|
return p != nullptr ? *p : reinterpret_cast<const ::greptime::v1::ColumnDataTypeExtension&>(
|
|
::greptime::v1::_ColumnDataTypeExtension_default_instance_);
|
|
}
|
|
inline const ::greptime::v1::ColumnDataTypeExtension& ColumnSchema::datatype_extension() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.ColumnSchema.datatype_extension)
|
|
return _internal_datatype_extension();
|
|
}
|
|
inline void ColumnSchema::unsafe_arena_set_allocated_datatype_extension(
|
|
::greptime::v1::ColumnDataTypeExtension* datatype_extension) {
|
|
if (GetArenaForAllocation() == nullptr) {
|
|
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.datatype_extension_);
|
|
}
|
|
_impl_.datatype_extension_ = datatype_extension;
|
|
if (datatype_extension) {
|
|
|
|
} else {
|
|
|
|
}
|
|
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:greptime.v1.ColumnSchema.datatype_extension)
|
|
}
|
|
inline ::greptime::v1::ColumnDataTypeExtension* ColumnSchema::release_datatype_extension() {
|
|
|
|
::greptime::v1::ColumnDataTypeExtension* temp = _impl_.datatype_extension_;
|
|
_impl_.datatype_extension_ = 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::ColumnDataTypeExtension* ColumnSchema::unsafe_arena_release_datatype_extension() {
|
|
// @@protoc_insertion_point(field_release:greptime.v1.ColumnSchema.datatype_extension)
|
|
|
|
::greptime::v1::ColumnDataTypeExtension* temp = _impl_.datatype_extension_;
|
|
_impl_.datatype_extension_ = nullptr;
|
|
return temp;
|
|
}
|
|
inline ::greptime::v1::ColumnDataTypeExtension* ColumnSchema::_internal_mutable_datatype_extension() {
|
|
|
|
if (_impl_.datatype_extension_ == nullptr) {
|
|
auto* p = CreateMaybeMessage<::greptime::v1::ColumnDataTypeExtension>(GetArenaForAllocation());
|
|
_impl_.datatype_extension_ = p;
|
|
}
|
|
return _impl_.datatype_extension_;
|
|
}
|
|
inline ::greptime::v1::ColumnDataTypeExtension* ColumnSchema::mutable_datatype_extension() {
|
|
::greptime::v1::ColumnDataTypeExtension* _msg = _internal_mutable_datatype_extension();
|
|
// @@protoc_insertion_point(field_mutable:greptime.v1.ColumnSchema.datatype_extension)
|
|
return _msg;
|
|
}
|
|
inline void ColumnSchema::set_allocated_datatype_extension(::greptime::v1::ColumnDataTypeExtension* datatype_extension) {
|
|
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
|
|
if (message_arena == nullptr) {
|
|
delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.datatype_extension_);
|
|
}
|
|
if (datatype_extension) {
|
|
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
|
|
::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
|
|
reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(datatype_extension));
|
|
if (message_arena != submessage_arena) {
|
|
datatype_extension = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
|
|
message_arena, datatype_extension, submessage_arena);
|
|
}
|
|
|
|
} else {
|
|
|
|
}
|
|
_impl_.datatype_extension_ = datatype_extension;
|
|
// @@protoc_insertion_point(field_set_allocated:greptime.v1.ColumnSchema.datatype_extension)
|
|
}
|
|
|
|
// .greptime.v1.ColumnOptions options = 5;
|
|
inline bool ColumnSchema::_internal_has_options() const {
|
|
return this != internal_default_instance() && _impl_.options_ != nullptr;
|
|
}
|
|
inline bool ColumnSchema::has_options() const {
|
|
return _internal_has_options();
|
|
}
|
|
inline const ::greptime::v1::ColumnOptions& ColumnSchema::_internal_options() const {
|
|
const ::greptime::v1::ColumnOptions* p = _impl_.options_;
|
|
return p != nullptr ? *p : reinterpret_cast<const ::greptime::v1::ColumnOptions&>(
|
|
::greptime::v1::_ColumnOptions_default_instance_);
|
|
}
|
|
inline const ::greptime::v1::ColumnOptions& ColumnSchema::options() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.ColumnSchema.options)
|
|
return _internal_options();
|
|
}
|
|
inline void ColumnSchema::unsafe_arena_set_allocated_options(
|
|
::greptime::v1::ColumnOptions* options) {
|
|
if (GetArenaForAllocation() == nullptr) {
|
|
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.options_);
|
|
}
|
|
_impl_.options_ = options;
|
|
if (options) {
|
|
|
|
} else {
|
|
|
|
}
|
|
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:greptime.v1.ColumnSchema.options)
|
|
}
|
|
inline ::greptime::v1::ColumnOptions* ColumnSchema::release_options() {
|
|
|
|
::greptime::v1::ColumnOptions* temp = _impl_.options_;
|
|
_impl_.options_ = 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::ColumnOptions* ColumnSchema::unsafe_arena_release_options() {
|
|
// @@protoc_insertion_point(field_release:greptime.v1.ColumnSchema.options)
|
|
|
|
::greptime::v1::ColumnOptions* temp = _impl_.options_;
|
|
_impl_.options_ = nullptr;
|
|
return temp;
|
|
}
|
|
inline ::greptime::v1::ColumnOptions* ColumnSchema::_internal_mutable_options() {
|
|
|
|
if (_impl_.options_ == nullptr) {
|
|
auto* p = CreateMaybeMessage<::greptime::v1::ColumnOptions>(GetArenaForAllocation());
|
|
_impl_.options_ = p;
|
|
}
|
|
return _impl_.options_;
|
|
}
|
|
inline ::greptime::v1::ColumnOptions* ColumnSchema::mutable_options() {
|
|
::greptime::v1::ColumnOptions* _msg = _internal_mutable_options();
|
|
// @@protoc_insertion_point(field_mutable:greptime.v1.ColumnSchema.options)
|
|
return _msg;
|
|
}
|
|
inline void ColumnSchema::set_allocated_options(::greptime::v1::ColumnOptions* options) {
|
|
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
|
|
if (message_arena == nullptr) {
|
|
delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.options_);
|
|
}
|
|
if (options) {
|
|
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
|
|
::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
|
|
reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(options));
|
|
if (message_arena != submessage_arena) {
|
|
options = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
|
|
message_arena, options, submessage_arena);
|
|
}
|
|
|
|
} else {
|
|
|
|
}
|
|
_impl_.options_ = options;
|
|
// @@protoc_insertion_point(field_set_allocated:greptime.v1.ColumnSchema.options)
|
|
}
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
// Row
|
|
|
|
// repeated .greptime.v1.Value values = 1;
|
|
inline int Row::_internal_values_size() const {
|
|
return _impl_.values_.size();
|
|
}
|
|
inline int Row::values_size() const {
|
|
return _internal_values_size();
|
|
}
|
|
inline void Row::clear_values() {
|
|
_impl_.values_.Clear();
|
|
}
|
|
inline ::greptime::v1::Value* Row::mutable_values(int index) {
|
|
// @@protoc_insertion_point(field_mutable:greptime.v1.Row.values)
|
|
return _impl_.values_.Mutable(index);
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::Value >*
|
|
Row::mutable_values() {
|
|
// @@protoc_insertion_point(field_mutable_list:greptime.v1.Row.values)
|
|
return &_impl_.values_;
|
|
}
|
|
inline const ::greptime::v1::Value& Row::_internal_values(int index) const {
|
|
return _impl_.values_.Get(index);
|
|
}
|
|
inline const ::greptime::v1::Value& Row::values(int index) const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.Row.values)
|
|
return _internal_values(index);
|
|
}
|
|
inline ::greptime::v1::Value* Row::_internal_add_values() {
|
|
return _impl_.values_.Add();
|
|
}
|
|
inline ::greptime::v1::Value* Row::add_values() {
|
|
::greptime::v1::Value* _add = _internal_add_values();
|
|
// @@protoc_insertion_point(field_add:greptime.v1.Row.values)
|
|
return _add;
|
|
}
|
|
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::Value >&
|
|
Row::values() const {
|
|
// @@protoc_insertion_point(field_list:greptime.v1.Row.values)
|
|
return _impl_.values_;
|
|
}
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
// Value
|
|
|
|
// int32 i8_value = 1;
|
|
inline bool Value::_internal_has_i8_value() const {
|
|
return value_data_case() == kI8Value;
|
|
}
|
|
inline bool Value::has_i8_value() const {
|
|
return _internal_has_i8_value();
|
|
}
|
|
inline void Value::set_has_i8_value() {
|
|
_impl_._oneof_case_[0] = kI8Value;
|
|
}
|
|
inline void Value::clear_i8_value() {
|
|
if (_internal_has_i8_value()) {
|
|
_impl_.value_data_.i8_value_ = 0;
|
|
clear_has_value_data();
|
|
}
|
|
}
|
|
inline int32_t Value::_internal_i8_value() const {
|
|
if (_internal_has_i8_value()) {
|
|
return _impl_.value_data_.i8_value_;
|
|
}
|
|
return 0;
|
|
}
|
|
inline void Value::_internal_set_i8_value(int32_t value) {
|
|
if (!_internal_has_i8_value()) {
|
|
clear_value_data();
|
|
set_has_i8_value();
|
|
}
|
|
_impl_.value_data_.i8_value_ = value;
|
|
}
|
|
inline int32_t Value::i8_value() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.Value.i8_value)
|
|
return _internal_i8_value();
|
|
}
|
|
inline void Value::set_i8_value(int32_t value) {
|
|
_internal_set_i8_value(value);
|
|
// @@protoc_insertion_point(field_set:greptime.v1.Value.i8_value)
|
|
}
|
|
|
|
// int32 i16_value = 2;
|
|
inline bool Value::_internal_has_i16_value() const {
|
|
return value_data_case() == kI16Value;
|
|
}
|
|
inline bool Value::has_i16_value() const {
|
|
return _internal_has_i16_value();
|
|
}
|
|
inline void Value::set_has_i16_value() {
|
|
_impl_._oneof_case_[0] = kI16Value;
|
|
}
|
|
inline void Value::clear_i16_value() {
|
|
if (_internal_has_i16_value()) {
|
|
_impl_.value_data_.i16_value_ = 0;
|
|
clear_has_value_data();
|
|
}
|
|
}
|
|
inline int32_t Value::_internal_i16_value() const {
|
|
if (_internal_has_i16_value()) {
|
|
return _impl_.value_data_.i16_value_;
|
|
}
|
|
return 0;
|
|
}
|
|
inline void Value::_internal_set_i16_value(int32_t value) {
|
|
if (!_internal_has_i16_value()) {
|
|
clear_value_data();
|
|
set_has_i16_value();
|
|
}
|
|
_impl_.value_data_.i16_value_ = value;
|
|
}
|
|
inline int32_t Value::i16_value() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.Value.i16_value)
|
|
return _internal_i16_value();
|
|
}
|
|
inline void Value::set_i16_value(int32_t value) {
|
|
_internal_set_i16_value(value);
|
|
// @@protoc_insertion_point(field_set:greptime.v1.Value.i16_value)
|
|
}
|
|
|
|
// int32 i32_value = 3;
|
|
inline bool Value::_internal_has_i32_value() const {
|
|
return value_data_case() == kI32Value;
|
|
}
|
|
inline bool Value::has_i32_value() const {
|
|
return _internal_has_i32_value();
|
|
}
|
|
inline void Value::set_has_i32_value() {
|
|
_impl_._oneof_case_[0] = kI32Value;
|
|
}
|
|
inline void Value::clear_i32_value() {
|
|
if (_internal_has_i32_value()) {
|
|
_impl_.value_data_.i32_value_ = 0;
|
|
clear_has_value_data();
|
|
}
|
|
}
|
|
inline int32_t Value::_internal_i32_value() const {
|
|
if (_internal_has_i32_value()) {
|
|
return _impl_.value_data_.i32_value_;
|
|
}
|
|
return 0;
|
|
}
|
|
inline void Value::_internal_set_i32_value(int32_t value) {
|
|
if (!_internal_has_i32_value()) {
|
|
clear_value_data();
|
|
set_has_i32_value();
|
|
}
|
|
_impl_.value_data_.i32_value_ = value;
|
|
}
|
|
inline int32_t Value::i32_value() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.Value.i32_value)
|
|
return _internal_i32_value();
|
|
}
|
|
inline void Value::set_i32_value(int32_t value) {
|
|
_internal_set_i32_value(value);
|
|
// @@protoc_insertion_point(field_set:greptime.v1.Value.i32_value)
|
|
}
|
|
|
|
// int64 i64_value = 4;
|
|
inline bool Value::_internal_has_i64_value() const {
|
|
return value_data_case() == kI64Value;
|
|
}
|
|
inline bool Value::has_i64_value() const {
|
|
return _internal_has_i64_value();
|
|
}
|
|
inline void Value::set_has_i64_value() {
|
|
_impl_._oneof_case_[0] = kI64Value;
|
|
}
|
|
inline void Value::clear_i64_value() {
|
|
if (_internal_has_i64_value()) {
|
|
_impl_.value_data_.i64_value_ = int64_t{0};
|
|
clear_has_value_data();
|
|
}
|
|
}
|
|
inline int64_t Value::_internal_i64_value() const {
|
|
if (_internal_has_i64_value()) {
|
|
return _impl_.value_data_.i64_value_;
|
|
}
|
|
return int64_t{0};
|
|
}
|
|
inline void Value::_internal_set_i64_value(int64_t value) {
|
|
if (!_internal_has_i64_value()) {
|
|
clear_value_data();
|
|
set_has_i64_value();
|
|
}
|
|
_impl_.value_data_.i64_value_ = value;
|
|
}
|
|
inline int64_t Value::i64_value() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.Value.i64_value)
|
|
return _internal_i64_value();
|
|
}
|
|
inline void Value::set_i64_value(int64_t value) {
|
|
_internal_set_i64_value(value);
|
|
// @@protoc_insertion_point(field_set:greptime.v1.Value.i64_value)
|
|
}
|
|
|
|
// uint32 u8_value = 5;
|
|
inline bool Value::_internal_has_u8_value() const {
|
|
return value_data_case() == kU8Value;
|
|
}
|
|
inline bool Value::has_u8_value() const {
|
|
return _internal_has_u8_value();
|
|
}
|
|
inline void Value::set_has_u8_value() {
|
|
_impl_._oneof_case_[0] = kU8Value;
|
|
}
|
|
inline void Value::clear_u8_value() {
|
|
if (_internal_has_u8_value()) {
|
|
_impl_.value_data_.u8_value_ = 0u;
|
|
clear_has_value_data();
|
|
}
|
|
}
|
|
inline uint32_t Value::_internal_u8_value() const {
|
|
if (_internal_has_u8_value()) {
|
|
return _impl_.value_data_.u8_value_;
|
|
}
|
|
return 0u;
|
|
}
|
|
inline void Value::_internal_set_u8_value(uint32_t value) {
|
|
if (!_internal_has_u8_value()) {
|
|
clear_value_data();
|
|
set_has_u8_value();
|
|
}
|
|
_impl_.value_data_.u8_value_ = value;
|
|
}
|
|
inline uint32_t Value::u8_value() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.Value.u8_value)
|
|
return _internal_u8_value();
|
|
}
|
|
inline void Value::set_u8_value(uint32_t value) {
|
|
_internal_set_u8_value(value);
|
|
// @@protoc_insertion_point(field_set:greptime.v1.Value.u8_value)
|
|
}
|
|
|
|
// uint32 u16_value = 6;
|
|
inline bool Value::_internal_has_u16_value() const {
|
|
return value_data_case() == kU16Value;
|
|
}
|
|
inline bool Value::has_u16_value() const {
|
|
return _internal_has_u16_value();
|
|
}
|
|
inline void Value::set_has_u16_value() {
|
|
_impl_._oneof_case_[0] = kU16Value;
|
|
}
|
|
inline void Value::clear_u16_value() {
|
|
if (_internal_has_u16_value()) {
|
|
_impl_.value_data_.u16_value_ = 0u;
|
|
clear_has_value_data();
|
|
}
|
|
}
|
|
inline uint32_t Value::_internal_u16_value() const {
|
|
if (_internal_has_u16_value()) {
|
|
return _impl_.value_data_.u16_value_;
|
|
}
|
|
return 0u;
|
|
}
|
|
inline void Value::_internal_set_u16_value(uint32_t value) {
|
|
if (!_internal_has_u16_value()) {
|
|
clear_value_data();
|
|
set_has_u16_value();
|
|
}
|
|
_impl_.value_data_.u16_value_ = value;
|
|
}
|
|
inline uint32_t Value::u16_value() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.Value.u16_value)
|
|
return _internal_u16_value();
|
|
}
|
|
inline void Value::set_u16_value(uint32_t value) {
|
|
_internal_set_u16_value(value);
|
|
// @@protoc_insertion_point(field_set:greptime.v1.Value.u16_value)
|
|
}
|
|
|
|
// uint32 u32_value = 7;
|
|
inline bool Value::_internal_has_u32_value() const {
|
|
return value_data_case() == kU32Value;
|
|
}
|
|
inline bool Value::has_u32_value() const {
|
|
return _internal_has_u32_value();
|
|
}
|
|
inline void Value::set_has_u32_value() {
|
|
_impl_._oneof_case_[0] = kU32Value;
|
|
}
|
|
inline void Value::clear_u32_value() {
|
|
if (_internal_has_u32_value()) {
|
|
_impl_.value_data_.u32_value_ = 0u;
|
|
clear_has_value_data();
|
|
}
|
|
}
|
|
inline uint32_t Value::_internal_u32_value() const {
|
|
if (_internal_has_u32_value()) {
|
|
return _impl_.value_data_.u32_value_;
|
|
}
|
|
return 0u;
|
|
}
|
|
inline void Value::_internal_set_u32_value(uint32_t value) {
|
|
if (!_internal_has_u32_value()) {
|
|
clear_value_data();
|
|
set_has_u32_value();
|
|
}
|
|
_impl_.value_data_.u32_value_ = value;
|
|
}
|
|
inline uint32_t Value::u32_value() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.Value.u32_value)
|
|
return _internal_u32_value();
|
|
}
|
|
inline void Value::set_u32_value(uint32_t value) {
|
|
_internal_set_u32_value(value);
|
|
// @@protoc_insertion_point(field_set:greptime.v1.Value.u32_value)
|
|
}
|
|
|
|
// uint64 u64_value = 8;
|
|
inline bool Value::_internal_has_u64_value() const {
|
|
return value_data_case() == kU64Value;
|
|
}
|
|
inline bool Value::has_u64_value() const {
|
|
return _internal_has_u64_value();
|
|
}
|
|
inline void Value::set_has_u64_value() {
|
|
_impl_._oneof_case_[0] = kU64Value;
|
|
}
|
|
inline void Value::clear_u64_value() {
|
|
if (_internal_has_u64_value()) {
|
|
_impl_.value_data_.u64_value_ = uint64_t{0u};
|
|
clear_has_value_data();
|
|
}
|
|
}
|
|
inline uint64_t Value::_internal_u64_value() const {
|
|
if (_internal_has_u64_value()) {
|
|
return _impl_.value_data_.u64_value_;
|
|
}
|
|
return uint64_t{0u};
|
|
}
|
|
inline void Value::_internal_set_u64_value(uint64_t value) {
|
|
if (!_internal_has_u64_value()) {
|
|
clear_value_data();
|
|
set_has_u64_value();
|
|
}
|
|
_impl_.value_data_.u64_value_ = value;
|
|
}
|
|
inline uint64_t Value::u64_value() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.Value.u64_value)
|
|
return _internal_u64_value();
|
|
}
|
|
inline void Value::set_u64_value(uint64_t value) {
|
|
_internal_set_u64_value(value);
|
|
// @@protoc_insertion_point(field_set:greptime.v1.Value.u64_value)
|
|
}
|
|
|
|
// float f32_value = 9;
|
|
inline bool Value::_internal_has_f32_value() const {
|
|
return value_data_case() == kF32Value;
|
|
}
|
|
inline bool Value::has_f32_value() const {
|
|
return _internal_has_f32_value();
|
|
}
|
|
inline void Value::set_has_f32_value() {
|
|
_impl_._oneof_case_[0] = kF32Value;
|
|
}
|
|
inline void Value::clear_f32_value() {
|
|
if (_internal_has_f32_value()) {
|
|
_impl_.value_data_.f32_value_ = 0;
|
|
clear_has_value_data();
|
|
}
|
|
}
|
|
inline float Value::_internal_f32_value() const {
|
|
if (_internal_has_f32_value()) {
|
|
return _impl_.value_data_.f32_value_;
|
|
}
|
|
return 0;
|
|
}
|
|
inline void Value::_internal_set_f32_value(float value) {
|
|
if (!_internal_has_f32_value()) {
|
|
clear_value_data();
|
|
set_has_f32_value();
|
|
}
|
|
_impl_.value_data_.f32_value_ = value;
|
|
}
|
|
inline float Value::f32_value() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.Value.f32_value)
|
|
return _internal_f32_value();
|
|
}
|
|
inline void Value::set_f32_value(float value) {
|
|
_internal_set_f32_value(value);
|
|
// @@protoc_insertion_point(field_set:greptime.v1.Value.f32_value)
|
|
}
|
|
|
|
// double f64_value = 10;
|
|
inline bool Value::_internal_has_f64_value() const {
|
|
return value_data_case() == kF64Value;
|
|
}
|
|
inline bool Value::has_f64_value() const {
|
|
return _internal_has_f64_value();
|
|
}
|
|
inline void Value::set_has_f64_value() {
|
|
_impl_._oneof_case_[0] = kF64Value;
|
|
}
|
|
inline void Value::clear_f64_value() {
|
|
if (_internal_has_f64_value()) {
|
|
_impl_.value_data_.f64_value_ = 0;
|
|
clear_has_value_data();
|
|
}
|
|
}
|
|
inline double Value::_internal_f64_value() const {
|
|
if (_internal_has_f64_value()) {
|
|
return _impl_.value_data_.f64_value_;
|
|
}
|
|
return 0;
|
|
}
|
|
inline void Value::_internal_set_f64_value(double value) {
|
|
if (!_internal_has_f64_value()) {
|
|
clear_value_data();
|
|
set_has_f64_value();
|
|
}
|
|
_impl_.value_data_.f64_value_ = value;
|
|
}
|
|
inline double Value::f64_value() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.Value.f64_value)
|
|
return _internal_f64_value();
|
|
}
|
|
inline void Value::set_f64_value(double value) {
|
|
_internal_set_f64_value(value);
|
|
// @@protoc_insertion_point(field_set:greptime.v1.Value.f64_value)
|
|
}
|
|
|
|
// bool bool_value = 11;
|
|
inline bool Value::_internal_has_bool_value() const {
|
|
return value_data_case() == kBoolValue;
|
|
}
|
|
inline bool Value::has_bool_value() const {
|
|
return _internal_has_bool_value();
|
|
}
|
|
inline void Value::set_has_bool_value() {
|
|
_impl_._oneof_case_[0] = kBoolValue;
|
|
}
|
|
inline void Value::clear_bool_value() {
|
|
if (_internal_has_bool_value()) {
|
|
_impl_.value_data_.bool_value_ = false;
|
|
clear_has_value_data();
|
|
}
|
|
}
|
|
inline bool Value::_internal_bool_value() const {
|
|
if (_internal_has_bool_value()) {
|
|
return _impl_.value_data_.bool_value_;
|
|
}
|
|
return false;
|
|
}
|
|
inline void Value::_internal_set_bool_value(bool value) {
|
|
if (!_internal_has_bool_value()) {
|
|
clear_value_data();
|
|
set_has_bool_value();
|
|
}
|
|
_impl_.value_data_.bool_value_ = value;
|
|
}
|
|
inline bool Value::bool_value() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.Value.bool_value)
|
|
return _internal_bool_value();
|
|
}
|
|
inline void Value::set_bool_value(bool value) {
|
|
_internal_set_bool_value(value);
|
|
// @@protoc_insertion_point(field_set:greptime.v1.Value.bool_value)
|
|
}
|
|
|
|
// bytes binary_value = 12;
|
|
inline bool Value::_internal_has_binary_value() const {
|
|
return value_data_case() == kBinaryValue;
|
|
}
|
|
inline bool Value::has_binary_value() const {
|
|
return _internal_has_binary_value();
|
|
}
|
|
inline void Value::set_has_binary_value() {
|
|
_impl_._oneof_case_[0] = kBinaryValue;
|
|
}
|
|
inline void Value::clear_binary_value() {
|
|
if (_internal_has_binary_value()) {
|
|
_impl_.value_data_.binary_value_.Destroy();
|
|
clear_has_value_data();
|
|
}
|
|
}
|
|
inline const std::string& Value::binary_value() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.Value.binary_value)
|
|
return _internal_binary_value();
|
|
}
|
|
template <typename ArgT0, typename... ArgT>
|
|
inline void Value::set_binary_value(ArgT0&& arg0, ArgT... args) {
|
|
if (!_internal_has_binary_value()) {
|
|
clear_value_data();
|
|
set_has_binary_value();
|
|
_impl_.value_data_.binary_value_.InitDefault();
|
|
}
|
|
_impl_.value_data_.binary_value_.SetBytes( static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
|
|
// @@protoc_insertion_point(field_set:greptime.v1.Value.binary_value)
|
|
}
|
|
inline std::string* Value::mutable_binary_value() {
|
|
std::string* _s = _internal_mutable_binary_value();
|
|
// @@protoc_insertion_point(field_mutable:greptime.v1.Value.binary_value)
|
|
return _s;
|
|
}
|
|
inline const std::string& Value::_internal_binary_value() const {
|
|
if (_internal_has_binary_value()) {
|
|
return _impl_.value_data_.binary_value_.Get();
|
|
}
|
|
return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
|
|
}
|
|
inline void Value::_internal_set_binary_value(const std::string& value) {
|
|
if (!_internal_has_binary_value()) {
|
|
clear_value_data();
|
|
set_has_binary_value();
|
|
_impl_.value_data_.binary_value_.InitDefault();
|
|
}
|
|
_impl_.value_data_.binary_value_.Set(value, GetArenaForAllocation());
|
|
}
|
|
inline std::string* Value::_internal_mutable_binary_value() {
|
|
if (!_internal_has_binary_value()) {
|
|
clear_value_data();
|
|
set_has_binary_value();
|
|
_impl_.value_data_.binary_value_.InitDefault();
|
|
}
|
|
return _impl_.value_data_.binary_value_.Mutable( GetArenaForAllocation());
|
|
}
|
|
inline std::string* Value::release_binary_value() {
|
|
// @@protoc_insertion_point(field_release:greptime.v1.Value.binary_value)
|
|
if (_internal_has_binary_value()) {
|
|
clear_has_value_data();
|
|
return _impl_.value_data_.binary_value_.Release();
|
|
} else {
|
|
return nullptr;
|
|
}
|
|
}
|
|
inline void Value::set_allocated_binary_value(std::string* binary_value) {
|
|
if (has_value_data()) {
|
|
clear_value_data();
|
|
}
|
|
if (binary_value != nullptr) {
|
|
set_has_binary_value();
|
|
_impl_.value_data_.binary_value_.InitAllocated(binary_value, GetArenaForAllocation());
|
|
}
|
|
// @@protoc_insertion_point(field_set_allocated:greptime.v1.Value.binary_value)
|
|
}
|
|
|
|
// string string_value = 13;
|
|
inline bool Value::_internal_has_string_value() const {
|
|
return value_data_case() == kStringValue;
|
|
}
|
|
inline bool Value::has_string_value() const {
|
|
return _internal_has_string_value();
|
|
}
|
|
inline void Value::set_has_string_value() {
|
|
_impl_._oneof_case_[0] = kStringValue;
|
|
}
|
|
inline void Value::clear_string_value() {
|
|
if (_internal_has_string_value()) {
|
|
_impl_.value_data_.string_value_.Destroy();
|
|
clear_has_value_data();
|
|
}
|
|
}
|
|
inline const std::string& Value::string_value() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.Value.string_value)
|
|
return _internal_string_value();
|
|
}
|
|
template <typename ArgT0, typename... ArgT>
|
|
inline void Value::set_string_value(ArgT0&& arg0, ArgT... args) {
|
|
if (!_internal_has_string_value()) {
|
|
clear_value_data();
|
|
set_has_string_value();
|
|
_impl_.value_data_.string_value_.InitDefault();
|
|
}
|
|
_impl_.value_data_.string_value_.Set( static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
|
|
// @@protoc_insertion_point(field_set:greptime.v1.Value.string_value)
|
|
}
|
|
inline std::string* Value::mutable_string_value() {
|
|
std::string* _s = _internal_mutable_string_value();
|
|
// @@protoc_insertion_point(field_mutable:greptime.v1.Value.string_value)
|
|
return _s;
|
|
}
|
|
inline const std::string& Value::_internal_string_value() const {
|
|
if (_internal_has_string_value()) {
|
|
return _impl_.value_data_.string_value_.Get();
|
|
}
|
|
return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
|
|
}
|
|
inline void Value::_internal_set_string_value(const std::string& value) {
|
|
if (!_internal_has_string_value()) {
|
|
clear_value_data();
|
|
set_has_string_value();
|
|
_impl_.value_data_.string_value_.InitDefault();
|
|
}
|
|
_impl_.value_data_.string_value_.Set(value, GetArenaForAllocation());
|
|
}
|
|
inline std::string* Value::_internal_mutable_string_value() {
|
|
if (!_internal_has_string_value()) {
|
|
clear_value_data();
|
|
set_has_string_value();
|
|
_impl_.value_data_.string_value_.InitDefault();
|
|
}
|
|
return _impl_.value_data_.string_value_.Mutable( GetArenaForAllocation());
|
|
}
|
|
inline std::string* Value::release_string_value() {
|
|
// @@protoc_insertion_point(field_release:greptime.v1.Value.string_value)
|
|
if (_internal_has_string_value()) {
|
|
clear_has_value_data();
|
|
return _impl_.value_data_.string_value_.Release();
|
|
} else {
|
|
return nullptr;
|
|
}
|
|
}
|
|
inline void Value::set_allocated_string_value(std::string* string_value) {
|
|
if (has_value_data()) {
|
|
clear_value_data();
|
|
}
|
|
if (string_value != nullptr) {
|
|
set_has_string_value();
|
|
_impl_.value_data_.string_value_.InitAllocated(string_value, GetArenaForAllocation());
|
|
}
|
|
// @@protoc_insertion_point(field_set_allocated:greptime.v1.Value.string_value)
|
|
}
|
|
|
|
// int32 date_value = 14;
|
|
inline bool Value::_internal_has_date_value() const {
|
|
return value_data_case() == kDateValue;
|
|
}
|
|
inline bool Value::has_date_value() const {
|
|
return _internal_has_date_value();
|
|
}
|
|
inline void Value::set_has_date_value() {
|
|
_impl_._oneof_case_[0] = kDateValue;
|
|
}
|
|
inline void Value::clear_date_value() {
|
|
if (_internal_has_date_value()) {
|
|
_impl_.value_data_.date_value_ = 0;
|
|
clear_has_value_data();
|
|
}
|
|
}
|
|
inline int32_t Value::_internal_date_value() const {
|
|
if (_internal_has_date_value()) {
|
|
return _impl_.value_data_.date_value_;
|
|
}
|
|
return 0;
|
|
}
|
|
inline void Value::_internal_set_date_value(int32_t value) {
|
|
if (!_internal_has_date_value()) {
|
|
clear_value_data();
|
|
set_has_date_value();
|
|
}
|
|
_impl_.value_data_.date_value_ = value;
|
|
}
|
|
inline int32_t Value::date_value() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.Value.date_value)
|
|
return _internal_date_value();
|
|
}
|
|
inline void Value::set_date_value(int32_t value) {
|
|
_internal_set_date_value(value);
|
|
// @@protoc_insertion_point(field_set:greptime.v1.Value.date_value)
|
|
}
|
|
|
|
// int64 datetime_value = 15;
|
|
inline bool Value::_internal_has_datetime_value() const {
|
|
return value_data_case() == kDatetimeValue;
|
|
}
|
|
inline bool Value::has_datetime_value() const {
|
|
return _internal_has_datetime_value();
|
|
}
|
|
inline void Value::set_has_datetime_value() {
|
|
_impl_._oneof_case_[0] = kDatetimeValue;
|
|
}
|
|
inline void Value::clear_datetime_value() {
|
|
if (_internal_has_datetime_value()) {
|
|
_impl_.value_data_.datetime_value_ = int64_t{0};
|
|
clear_has_value_data();
|
|
}
|
|
}
|
|
inline int64_t Value::_internal_datetime_value() const {
|
|
if (_internal_has_datetime_value()) {
|
|
return _impl_.value_data_.datetime_value_;
|
|
}
|
|
return int64_t{0};
|
|
}
|
|
inline void Value::_internal_set_datetime_value(int64_t value) {
|
|
if (!_internal_has_datetime_value()) {
|
|
clear_value_data();
|
|
set_has_datetime_value();
|
|
}
|
|
_impl_.value_data_.datetime_value_ = value;
|
|
}
|
|
inline int64_t Value::datetime_value() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.Value.datetime_value)
|
|
return _internal_datetime_value();
|
|
}
|
|
inline void Value::set_datetime_value(int64_t value) {
|
|
_internal_set_datetime_value(value);
|
|
// @@protoc_insertion_point(field_set:greptime.v1.Value.datetime_value)
|
|
}
|
|
|
|
// int64 timestamp_second_value = 16;
|
|
inline bool Value::_internal_has_timestamp_second_value() const {
|
|
return value_data_case() == kTimestampSecondValue;
|
|
}
|
|
inline bool Value::has_timestamp_second_value() const {
|
|
return _internal_has_timestamp_second_value();
|
|
}
|
|
inline void Value::set_has_timestamp_second_value() {
|
|
_impl_._oneof_case_[0] = kTimestampSecondValue;
|
|
}
|
|
inline void Value::clear_timestamp_second_value() {
|
|
if (_internal_has_timestamp_second_value()) {
|
|
_impl_.value_data_.timestamp_second_value_ = int64_t{0};
|
|
clear_has_value_data();
|
|
}
|
|
}
|
|
inline int64_t Value::_internal_timestamp_second_value() const {
|
|
if (_internal_has_timestamp_second_value()) {
|
|
return _impl_.value_data_.timestamp_second_value_;
|
|
}
|
|
return int64_t{0};
|
|
}
|
|
inline void Value::_internal_set_timestamp_second_value(int64_t value) {
|
|
if (!_internal_has_timestamp_second_value()) {
|
|
clear_value_data();
|
|
set_has_timestamp_second_value();
|
|
}
|
|
_impl_.value_data_.timestamp_second_value_ = value;
|
|
}
|
|
inline int64_t Value::timestamp_second_value() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.Value.timestamp_second_value)
|
|
return _internal_timestamp_second_value();
|
|
}
|
|
inline void Value::set_timestamp_second_value(int64_t value) {
|
|
_internal_set_timestamp_second_value(value);
|
|
// @@protoc_insertion_point(field_set:greptime.v1.Value.timestamp_second_value)
|
|
}
|
|
|
|
// int64 timestamp_millisecond_value = 17;
|
|
inline bool Value::_internal_has_timestamp_millisecond_value() const {
|
|
return value_data_case() == kTimestampMillisecondValue;
|
|
}
|
|
inline bool Value::has_timestamp_millisecond_value() const {
|
|
return _internal_has_timestamp_millisecond_value();
|
|
}
|
|
inline void Value::set_has_timestamp_millisecond_value() {
|
|
_impl_._oneof_case_[0] = kTimestampMillisecondValue;
|
|
}
|
|
inline void Value::clear_timestamp_millisecond_value() {
|
|
if (_internal_has_timestamp_millisecond_value()) {
|
|
_impl_.value_data_.timestamp_millisecond_value_ = int64_t{0};
|
|
clear_has_value_data();
|
|
}
|
|
}
|
|
inline int64_t Value::_internal_timestamp_millisecond_value() const {
|
|
if (_internal_has_timestamp_millisecond_value()) {
|
|
return _impl_.value_data_.timestamp_millisecond_value_;
|
|
}
|
|
return int64_t{0};
|
|
}
|
|
inline void Value::_internal_set_timestamp_millisecond_value(int64_t value) {
|
|
if (!_internal_has_timestamp_millisecond_value()) {
|
|
clear_value_data();
|
|
set_has_timestamp_millisecond_value();
|
|
}
|
|
_impl_.value_data_.timestamp_millisecond_value_ = value;
|
|
}
|
|
inline int64_t Value::timestamp_millisecond_value() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.Value.timestamp_millisecond_value)
|
|
return _internal_timestamp_millisecond_value();
|
|
}
|
|
inline void Value::set_timestamp_millisecond_value(int64_t value) {
|
|
_internal_set_timestamp_millisecond_value(value);
|
|
// @@protoc_insertion_point(field_set:greptime.v1.Value.timestamp_millisecond_value)
|
|
}
|
|
|
|
// int64 timestamp_microsecond_value = 18;
|
|
inline bool Value::_internal_has_timestamp_microsecond_value() const {
|
|
return value_data_case() == kTimestampMicrosecondValue;
|
|
}
|
|
inline bool Value::has_timestamp_microsecond_value() const {
|
|
return _internal_has_timestamp_microsecond_value();
|
|
}
|
|
inline void Value::set_has_timestamp_microsecond_value() {
|
|
_impl_._oneof_case_[0] = kTimestampMicrosecondValue;
|
|
}
|
|
inline void Value::clear_timestamp_microsecond_value() {
|
|
if (_internal_has_timestamp_microsecond_value()) {
|
|
_impl_.value_data_.timestamp_microsecond_value_ = int64_t{0};
|
|
clear_has_value_data();
|
|
}
|
|
}
|
|
inline int64_t Value::_internal_timestamp_microsecond_value() const {
|
|
if (_internal_has_timestamp_microsecond_value()) {
|
|
return _impl_.value_data_.timestamp_microsecond_value_;
|
|
}
|
|
return int64_t{0};
|
|
}
|
|
inline void Value::_internal_set_timestamp_microsecond_value(int64_t value) {
|
|
if (!_internal_has_timestamp_microsecond_value()) {
|
|
clear_value_data();
|
|
set_has_timestamp_microsecond_value();
|
|
}
|
|
_impl_.value_data_.timestamp_microsecond_value_ = value;
|
|
}
|
|
inline int64_t Value::timestamp_microsecond_value() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.Value.timestamp_microsecond_value)
|
|
return _internal_timestamp_microsecond_value();
|
|
}
|
|
inline void Value::set_timestamp_microsecond_value(int64_t value) {
|
|
_internal_set_timestamp_microsecond_value(value);
|
|
// @@protoc_insertion_point(field_set:greptime.v1.Value.timestamp_microsecond_value)
|
|
}
|
|
|
|
// int64 timestamp_nanosecond_value = 19;
|
|
inline bool Value::_internal_has_timestamp_nanosecond_value() const {
|
|
return value_data_case() == kTimestampNanosecondValue;
|
|
}
|
|
inline bool Value::has_timestamp_nanosecond_value() const {
|
|
return _internal_has_timestamp_nanosecond_value();
|
|
}
|
|
inline void Value::set_has_timestamp_nanosecond_value() {
|
|
_impl_._oneof_case_[0] = kTimestampNanosecondValue;
|
|
}
|
|
inline void Value::clear_timestamp_nanosecond_value() {
|
|
if (_internal_has_timestamp_nanosecond_value()) {
|
|
_impl_.value_data_.timestamp_nanosecond_value_ = int64_t{0};
|
|
clear_has_value_data();
|
|
}
|
|
}
|
|
inline int64_t Value::_internal_timestamp_nanosecond_value() const {
|
|
if (_internal_has_timestamp_nanosecond_value()) {
|
|
return _impl_.value_data_.timestamp_nanosecond_value_;
|
|
}
|
|
return int64_t{0};
|
|
}
|
|
inline void Value::_internal_set_timestamp_nanosecond_value(int64_t value) {
|
|
if (!_internal_has_timestamp_nanosecond_value()) {
|
|
clear_value_data();
|
|
set_has_timestamp_nanosecond_value();
|
|
}
|
|
_impl_.value_data_.timestamp_nanosecond_value_ = value;
|
|
}
|
|
inline int64_t Value::timestamp_nanosecond_value() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.Value.timestamp_nanosecond_value)
|
|
return _internal_timestamp_nanosecond_value();
|
|
}
|
|
inline void Value::set_timestamp_nanosecond_value(int64_t value) {
|
|
_internal_set_timestamp_nanosecond_value(value);
|
|
// @@protoc_insertion_point(field_set:greptime.v1.Value.timestamp_nanosecond_value)
|
|
}
|
|
|
|
// int64 time_second_value = 20;
|
|
inline bool Value::_internal_has_time_second_value() const {
|
|
return value_data_case() == kTimeSecondValue;
|
|
}
|
|
inline bool Value::has_time_second_value() const {
|
|
return _internal_has_time_second_value();
|
|
}
|
|
inline void Value::set_has_time_second_value() {
|
|
_impl_._oneof_case_[0] = kTimeSecondValue;
|
|
}
|
|
inline void Value::clear_time_second_value() {
|
|
if (_internal_has_time_second_value()) {
|
|
_impl_.value_data_.time_second_value_ = int64_t{0};
|
|
clear_has_value_data();
|
|
}
|
|
}
|
|
inline int64_t Value::_internal_time_second_value() const {
|
|
if (_internal_has_time_second_value()) {
|
|
return _impl_.value_data_.time_second_value_;
|
|
}
|
|
return int64_t{0};
|
|
}
|
|
inline void Value::_internal_set_time_second_value(int64_t value) {
|
|
if (!_internal_has_time_second_value()) {
|
|
clear_value_data();
|
|
set_has_time_second_value();
|
|
}
|
|
_impl_.value_data_.time_second_value_ = value;
|
|
}
|
|
inline int64_t Value::time_second_value() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.Value.time_second_value)
|
|
return _internal_time_second_value();
|
|
}
|
|
inline void Value::set_time_second_value(int64_t value) {
|
|
_internal_set_time_second_value(value);
|
|
// @@protoc_insertion_point(field_set:greptime.v1.Value.time_second_value)
|
|
}
|
|
|
|
// int64 time_millisecond_value = 21;
|
|
inline bool Value::_internal_has_time_millisecond_value() const {
|
|
return value_data_case() == kTimeMillisecondValue;
|
|
}
|
|
inline bool Value::has_time_millisecond_value() const {
|
|
return _internal_has_time_millisecond_value();
|
|
}
|
|
inline void Value::set_has_time_millisecond_value() {
|
|
_impl_._oneof_case_[0] = kTimeMillisecondValue;
|
|
}
|
|
inline void Value::clear_time_millisecond_value() {
|
|
if (_internal_has_time_millisecond_value()) {
|
|
_impl_.value_data_.time_millisecond_value_ = int64_t{0};
|
|
clear_has_value_data();
|
|
}
|
|
}
|
|
inline int64_t Value::_internal_time_millisecond_value() const {
|
|
if (_internal_has_time_millisecond_value()) {
|
|
return _impl_.value_data_.time_millisecond_value_;
|
|
}
|
|
return int64_t{0};
|
|
}
|
|
inline void Value::_internal_set_time_millisecond_value(int64_t value) {
|
|
if (!_internal_has_time_millisecond_value()) {
|
|
clear_value_data();
|
|
set_has_time_millisecond_value();
|
|
}
|
|
_impl_.value_data_.time_millisecond_value_ = value;
|
|
}
|
|
inline int64_t Value::time_millisecond_value() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.Value.time_millisecond_value)
|
|
return _internal_time_millisecond_value();
|
|
}
|
|
inline void Value::set_time_millisecond_value(int64_t value) {
|
|
_internal_set_time_millisecond_value(value);
|
|
// @@protoc_insertion_point(field_set:greptime.v1.Value.time_millisecond_value)
|
|
}
|
|
|
|
// int64 time_microsecond_value = 22;
|
|
inline bool Value::_internal_has_time_microsecond_value() const {
|
|
return value_data_case() == kTimeMicrosecondValue;
|
|
}
|
|
inline bool Value::has_time_microsecond_value() const {
|
|
return _internal_has_time_microsecond_value();
|
|
}
|
|
inline void Value::set_has_time_microsecond_value() {
|
|
_impl_._oneof_case_[0] = kTimeMicrosecondValue;
|
|
}
|
|
inline void Value::clear_time_microsecond_value() {
|
|
if (_internal_has_time_microsecond_value()) {
|
|
_impl_.value_data_.time_microsecond_value_ = int64_t{0};
|
|
clear_has_value_data();
|
|
}
|
|
}
|
|
inline int64_t Value::_internal_time_microsecond_value() const {
|
|
if (_internal_has_time_microsecond_value()) {
|
|
return _impl_.value_data_.time_microsecond_value_;
|
|
}
|
|
return int64_t{0};
|
|
}
|
|
inline void Value::_internal_set_time_microsecond_value(int64_t value) {
|
|
if (!_internal_has_time_microsecond_value()) {
|
|
clear_value_data();
|
|
set_has_time_microsecond_value();
|
|
}
|
|
_impl_.value_data_.time_microsecond_value_ = value;
|
|
}
|
|
inline int64_t Value::time_microsecond_value() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.Value.time_microsecond_value)
|
|
return _internal_time_microsecond_value();
|
|
}
|
|
inline void Value::set_time_microsecond_value(int64_t value) {
|
|
_internal_set_time_microsecond_value(value);
|
|
// @@protoc_insertion_point(field_set:greptime.v1.Value.time_microsecond_value)
|
|
}
|
|
|
|
// int64 time_nanosecond_value = 23;
|
|
inline bool Value::_internal_has_time_nanosecond_value() const {
|
|
return value_data_case() == kTimeNanosecondValue;
|
|
}
|
|
inline bool Value::has_time_nanosecond_value() const {
|
|
return _internal_has_time_nanosecond_value();
|
|
}
|
|
inline void Value::set_has_time_nanosecond_value() {
|
|
_impl_._oneof_case_[0] = kTimeNanosecondValue;
|
|
}
|
|
inline void Value::clear_time_nanosecond_value() {
|
|
if (_internal_has_time_nanosecond_value()) {
|
|
_impl_.value_data_.time_nanosecond_value_ = int64_t{0};
|
|
clear_has_value_data();
|
|
}
|
|
}
|
|
inline int64_t Value::_internal_time_nanosecond_value() const {
|
|
if (_internal_has_time_nanosecond_value()) {
|
|
return _impl_.value_data_.time_nanosecond_value_;
|
|
}
|
|
return int64_t{0};
|
|
}
|
|
inline void Value::_internal_set_time_nanosecond_value(int64_t value) {
|
|
if (!_internal_has_time_nanosecond_value()) {
|
|
clear_value_data();
|
|
set_has_time_nanosecond_value();
|
|
}
|
|
_impl_.value_data_.time_nanosecond_value_ = value;
|
|
}
|
|
inline int64_t Value::time_nanosecond_value() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.Value.time_nanosecond_value)
|
|
return _internal_time_nanosecond_value();
|
|
}
|
|
inline void Value::set_time_nanosecond_value(int64_t value) {
|
|
_internal_set_time_nanosecond_value(value);
|
|
// @@protoc_insertion_point(field_set:greptime.v1.Value.time_nanosecond_value)
|
|
}
|
|
|
|
// int32 interval_year_month_value = 24;
|
|
inline bool Value::_internal_has_interval_year_month_value() const {
|
|
return value_data_case() == kIntervalYearMonthValue;
|
|
}
|
|
inline bool Value::has_interval_year_month_value() const {
|
|
return _internal_has_interval_year_month_value();
|
|
}
|
|
inline void Value::set_has_interval_year_month_value() {
|
|
_impl_._oneof_case_[0] = kIntervalYearMonthValue;
|
|
}
|
|
inline void Value::clear_interval_year_month_value() {
|
|
if (_internal_has_interval_year_month_value()) {
|
|
_impl_.value_data_.interval_year_month_value_ = 0;
|
|
clear_has_value_data();
|
|
}
|
|
}
|
|
inline int32_t Value::_internal_interval_year_month_value() const {
|
|
if (_internal_has_interval_year_month_value()) {
|
|
return _impl_.value_data_.interval_year_month_value_;
|
|
}
|
|
return 0;
|
|
}
|
|
inline void Value::_internal_set_interval_year_month_value(int32_t value) {
|
|
if (!_internal_has_interval_year_month_value()) {
|
|
clear_value_data();
|
|
set_has_interval_year_month_value();
|
|
}
|
|
_impl_.value_data_.interval_year_month_value_ = value;
|
|
}
|
|
inline int32_t Value::interval_year_month_value() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.Value.interval_year_month_value)
|
|
return _internal_interval_year_month_value();
|
|
}
|
|
inline void Value::set_interval_year_month_value(int32_t value) {
|
|
_internal_set_interval_year_month_value(value);
|
|
// @@protoc_insertion_point(field_set:greptime.v1.Value.interval_year_month_value)
|
|
}
|
|
|
|
// int64 interval_day_time_value = 25;
|
|
inline bool Value::_internal_has_interval_day_time_value() const {
|
|
return value_data_case() == kIntervalDayTimeValue;
|
|
}
|
|
inline bool Value::has_interval_day_time_value() const {
|
|
return _internal_has_interval_day_time_value();
|
|
}
|
|
inline void Value::set_has_interval_day_time_value() {
|
|
_impl_._oneof_case_[0] = kIntervalDayTimeValue;
|
|
}
|
|
inline void Value::clear_interval_day_time_value() {
|
|
if (_internal_has_interval_day_time_value()) {
|
|
_impl_.value_data_.interval_day_time_value_ = int64_t{0};
|
|
clear_has_value_data();
|
|
}
|
|
}
|
|
inline int64_t Value::_internal_interval_day_time_value() const {
|
|
if (_internal_has_interval_day_time_value()) {
|
|
return _impl_.value_data_.interval_day_time_value_;
|
|
}
|
|
return int64_t{0};
|
|
}
|
|
inline void Value::_internal_set_interval_day_time_value(int64_t value) {
|
|
if (!_internal_has_interval_day_time_value()) {
|
|
clear_value_data();
|
|
set_has_interval_day_time_value();
|
|
}
|
|
_impl_.value_data_.interval_day_time_value_ = value;
|
|
}
|
|
inline int64_t Value::interval_day_time_value() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.Value.interval_day_time_value)
|
|
return _internal_interval_day_time_value();
|
|
}
|
|
inline void Value::set_interval_day_time_value(int64_t value) {
|
|
_internal_set_interval_day_time_value(value);
|
|
// @@protoc_insertion_point(field_set:greptime.v1.Value.interval_day_time_value)
|
|
}
|
|
|
|
// .greptime.v1.IntervalMonthDayNano interval_month_day_nano_value = 26;
|
|
inline bool Value::_internal_has_interval_month_day_nano_value() const {
|
|
return value_data_case() == kIntervalMonthDayNanoValue;
|
|
}
|
|
inline bool Value::has_interval_month_day_nano_value() const {
|
|
return _internal_has_interval_month_day_nano_value();
|
|
}
|
|
inline void Value::set_has_interval_month_day_nano_value() {
|
|
_impl_._oneof_case_[0] = kIntervalMonthDayNanoValue;
|
|
}
|
|
inline ::greptime::v1::IntervalMonthDayNano* Value::release_interval_month_day_nano_value() {
|
|
// @@protoc_insertion_point(field_release:greptime.v1.Value.interval_month_day_nano_value)
|
|
if (_internal_has_interval_month_day_nano_value()) {
|
|
clear_has_value_data();
|
|
::greptime::v1::IntervalMonthDayNano* temp = _impl_.value_data_.interval_month_day_nano_value_;
|
|
if (GetArenaForAllocation() != nullptr) {
|
|
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
|
|
}
|
|
_impl_.value_data_.interval_month_day_nano_value_ = nullptr;
|
|
return temp;
|
|
} else {
|
|
return nullptr;
|
|
}
|
|
}
|
|
inline const ::greptime::v1::IntervalMonthDayNano& Value::_internal_interval_month_day_nano_value() const {
|
|
return _internal_has_interval_month_day_nano_value()
|
|
? *_impl_.value_data_.interval_month_day_nano_value_
|
|
: reinterpret_cast< ::greptime::v1::IntervalMonthDayNano&>(::greptime::v1::_IntervalMonthDayNano_default_instance_);
|
|
}
|
|
inline const ::greptime::v1::IntervalMonthDayNano& Value::interval_month_day_nano_value() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.Value.interval_month_day_nano_value)
|
|
return _internal_interval_month_day_nano_value();
|
|
}
|
|
inline ::greptime::v1::IntervalMonthDayNano* Value::unsafe_arena_release_interval_month_day_nano_value() {
|
|
// @@protoc_insertion_point(field_unsafe_arena_release:greptime.v1.Value.interval_month_day_nano_value)
|
|
if (_internal_has_interval_month_day_nano_value()) {
|
|
clear_has_value_data();
|
|
::greptime::v1::IntervalMonthDayNano* temp = _impl_.value_data_.interval_month_day_nano_value_;
|
|
_impl_.value_data_.interval_month_day_nano_value_ = nullptr;
|
|
return temp;
|
|
} else {
|
|
return nullptr;
|
|
}
|
|
}
|
|
inline void Value::unsafe_arena_set_allocated_interval_month_day_nano_value(::greptime::v1::IntervalMonthDayNano* interval_month_day_nano_value) {
|
|
clear_value_data();
|
|
if (interval_month_day_nano_value) {
|
|
set_has_interval_month_day_nano_value();
|
|
_impl_.value_data_.interval_month_day_nano_value_ = interval_month_day_nano_value;
|
|
}
|
|
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:greptime.v1.Value.interval_month_day_nano_value)
|
|
}
|
|
inline ::greptime::v1::IntervalMonthDayNano* Value::_internal_mutable_interval_month_day_nano_value() {
|
|
if (!_internal_has_interval_month_day_nano_value()) {
|
|
clear_value_data();
|
|
set_has_interval_month_day_nano_value();
|
|
_impl_.value_data_.interval_month_day_nano_value_ = CreateMaybeMessage< ::greptime::v1::IntervalMonthDayNano >(GetArenaForAllocation());
|
|
}
|
|
return _impl_.value_data_.interval_month_day_nano_value_;
|
|
}
|
|
inline ::greptime::v1::IntervalMonthDayNano* Value::mutable_interval_month_day_nano_value() {
|
|
::greptime::v1::IntervalMonthDayNano* _msg = _internal_mutable_interval_month_day_nano_value();
|
|
// @@protoc_insertion_point(field_mutable:greptime.v1.Value.interval_month_day_nano_value)
|
|
return _msg;
|
|
}
|
|
|
|
// .greptime.v1.Decimal128 decimal128_value = 31;
|
|
inline bool Value::_internal_has_decimal128_value() const {
|
|
return value_data_case() == kDecimal128Value;
|
|
}
|
|
inline bool Value::has_decimal128_value() const {
|
|
return _internal_has_decimal128_value();
|
|
}
|
|
inline void Value::set_has_decimal128_value() {
|
|
_impl_._oneof_case_[0] = kDecimal128Value;
|
|
}
|
|
inline ::greptime::v1::Decimal128* Value::release_decimal128_value() {
|
|
// @@protoc_insertion_point(field_release:greptime.v1.Value.decimal128_value)
|
|
if (_internal_has_decimal128_value()) {
|
|
clear_has_value_data();
|
|
::greptime::v1::Decimal128* temp = _impl_.value_data_.decimal128_value_;
|
|
if (GetArenaForAllocation() != nullptr) {
|
|
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
|
|
}
|
|
_impl_.value_data_.decimal128_value_ = nullptr;
|
|
return temp;
|
|
} else {
|
|
return nullptr;
|
|
}
|
|
}
|
|
inline const ::greptime::v1::Decimal128& Value::_internal_decimal128_value() const {
|
|
return _internal_has_decimal128_value()
|
|
? *_impl_.value_data_.decimal128_value_
|
|
: reinterpret_cast< ::greptime::v1::Decimal128&>(::greptime::v1::_Decimal128_default_instance_);
|
|
}
|
|
inline const ::greptime::v1::Decimal128& Value::decimal128_value() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.Value.decimal128_value)
|
|
return _internal_decimal128_value();
|
|
}
|
|
inline ::greptime::v1::Decimal128* Value::unsafe_arena_release_decimal128_value() {
|
|
// @@protoc_insertion_point(field_unsafe_arena_release:greptime.v1.Value.decimal128_value)
|
|
if (_internal_has_decimal128_value()) {
|
|
clear_has_value_data();
|
|
::greptime::v1::Decimal128* temp = _impl_.value_data_.decimal128_value_;
|
|
_impl_.value_data_.decimal128_value_ = nullptr;
|
|
return temp;
|
|
} else {
|
|
return nullptr;
|
|
}
|
|
}
|
|
inline void Value::unsafe_arena_set_allocated_decimal128_value(::greptime::v1::Decimal128* decimal128_value) {
|
|
clear_value_data();
|
|
if (decimal128_value) {
|
|
set_has_decimal128_value();
|
|
_impl_.value_data_.decimal128_value_ = decimal128_value;
|
|
}
|
|
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:greptime.v1.Value.decimal128_value)
|
|
}
|
|
inline ::greptime::v1::Decimal128* Value::_internal_mutable_decimal128_value() {
|
|
if (!_internal_has_decimal128_value()) {
|
|
clear_value_data();
|
|
set_has_decimal128_value();
|
|
_impl_.value_data_.decimal128_value_ = CreateMaybeMessage< ::greptime::v1::Decimal128 >(GetArenaForAllocation());
|
|
}
|
|
return _impl_.value_data_.decimal128_value_;
|
|
}
|
|
inline ::greptime::v1::Decimal128* Value::mutable_decimal128_value() {
|
|
::greptime::v1::Decimal128* _msg = _internal_mutable_decimal128_value();
|
|
// @@protoc_insertion_point(field_mutable:greptime.v1.Value.decimal128_value)
|
|
return _msg;
|
|
}
|
|
|
|
// .greptime.v1.ListValue list_value = 40;
|
|
inline bool Value::_internal_has_list_value() const {
|
|
return value_data_case() == kListValue;
|
|
}
|
|
inline bool Value::has_list_value() const {
|
|
return _internal_has_list_value();
|
|
}
|
|
inline void Value::set_has_list_value() {
|
|
_impl_._oneof_case_[0] = kListValue;
|
|
}
|
|
inline void Value::clear_list_value() {
|
|
if (_internal_has_list_value()) {
|
|
if (GetArenaForAllocation() == nullptr) {
|
|
delete _impl_.value_data_.list_value_;
|
|
}
|
|
clear_has_value_data();
|
|
}
|
|
}
|
|
inline ::greptime::v1::ListValue* Value::release_list_value() {
|
|
// @@protoc_insertion_point(field_release:greptime.v1.Value.list_value)
|
|
if (_internal_has_list_value()) {
|
|
clear_has_value_data();
|
|
::greptime::v1::ListValue* temp = _impl_.value_data_.list_value_;
|
|
if (GetArenaForAllocation() != nullptr) {
|
|
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
|
|
}
|
|
_impl_.value_data_.list_value_ = nullptr;
|
|
return temp;
|
|
} else {
|
|
return nullptr;
|
|
}
|
|
}
|
|
inline const ::greptime::v1::ListValue& Value::_internal_list_value() const {
|
|
return _internal_has_list_value()
|
|
? *_impl_.value_data_.list_value_
|
|
: reinterpret_cast< ::greptime::v1::ListValue&>(::greptime::v1::_ListValue_default_instance_);
|
|
}
|
|
inline const ::greptime::v1::ListValue& Value::list_value() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.Value.list_value)
|
|
return _internal_list_value();
|
|
}
|
|
inline ::greptime::v1::ListValue* Value::unsafe_arena_release_list_value() {
|
|
// @@protoc_insertion_point(field_unsafe_arena_release:greptime.v1.Value.list_value)
|
|
if (_internal_has_list_value()) {
|
|
clear_has_value_data();
|
|
::greptime::v1::ListValue* temp = _impl_.value_data_.list_value_;
|
|
_impl_.value_data_.list_value_ = nullptr;
|
|
return temp;
|
|
} else {
|
|
return nullptr;
|
|
}
|
|
}
|
|
inline void Value::unsafe_arena_set_allocated_list_value(::greptime::v1::ListValue* list_value) {
|
|
clear_value_data();
|
|
if (list_value) {
|
|
set_has_list_value();
|
|
_impl_.value_data_.list_value_ = list_value;
|
|
}
|
|
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:greptime.v1.Value.list_value)
|
|
}
|
|
inline ::greptime::v1::ListValue* Value::_internal_mutable_list_value() {
|
|
if (!_internal_has_list_value()) {
|
|
clear_value_data();
|
|
set_has_list_value();
|
|
_impl_.value_data_.list_value_ = CreateMaybeMessage< ::greptime::v1::ListValue >(GetArenaForAllocation());
|
|
}
|
|
return _impl_.value_data_.list_value_;
|
|
}
|
|
inline ::greptime::v1::ListValue* Value::mutable_list_value() {
|
|
::greptime::v1::ListValue* _msg = _internal_mutable_list_value();
|
|
// @@protoc_insertion_point(field_mutable:greptime.v1.Value.list_value)
|
|
return _msg;
|
|
}
|
|
|
|
// .greptime.v1.StructValue struct_value = 41;
|
|
inline bool Value::_internal_has_struct_value() const {
|
|
return value_data_case() == kStructValue;
|
|
}
|
|
inline bool Value::has_struct_value() const {
|
|
return _internal_has_struct_value();
|
|
}
|
|
inline void Value::set_has_struct_value() {
|
|
_impl_._oneof_case_[0] = kStructValue;
|
|
}
|
|
inline void Value::clear_struct_value() {
|
|
if (_internal_has_struct_value()) {
|
|
if (GetArenaForAllocation() == nullptr) {
|
|
delete _impl_.value_data_.struct_value_;
|
|
}
|
|
clear_has_value_data();
|
|
}
|
|
}
|
|
inline ::greptime::v1::StructValue* Value::release_struct_value() {
|
|
// @@protoc_insertion_point(field_release:greptime.v1.Value.struct_value)
|
|
if (_internal_has_struct_value()) {
|
|
clear_has_value_data();
|
|
::greptime::v1::StructValue* temp = _impl_.value_data_.struct_value_;
|
|
if (GetArenaForAllocation() != nullptr) {
|
|
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
|
|
}
|
|
_impl_.value_data_.struct_value_ = nullptr;
|
|
return temp;
|
|
} else {
|
|
return nullptr;
|
|
}
|
|
}
|
|
inline const ::greptime::v1::StructValue& Value::_internal_struct_value() const {
|
|
return _internal_has_struct_value()
|
|
? *_impl_.value_data_.struct_value_
|
|
: reinterpret_cast< ::greptime::v1::StructValue&>(::greptime::v1::_StructValue_default_instance_);
|
|
}
|
|
inline const ::greptime::v1::StructValue& Value::struct_value() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.Value.struct_value)
|
|
return _internal_struct_value();
|
|
}
|
|
inline ::greptime::v1::StructValue* Value::unsafe_arena_release_struct_value() {
|
|
// @@protoc_insertion_point(field_unsafe_arena_release:greptime.v1.Value.struct_value)
|
|
if (_internal_has_struct_value()) {
|
|
clear_has_value_data();
|
|
::greptime::v1::StructValue* temp = _impl_.value_data_.struct_value_;
|
|
_impl_.value_data_.struct_value_ = nullptr;
|
|
return temp;
|
|
} else {
|
|
return nullptr;
|
|
}
|
|
}
|
|
inline void Value::unsafe_arena_set_allocated_struct_value(::greptime::v1::StructValue* struct_value) {
|
|
clear_value_data();
|
|
if (struct_value) {
|
|
set_has_struct_value();
|
|
_impl_.value_data_.struct_value_ = struct_value;
|
|
}
|
|
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:greptime.v1.Value.struct_value)
|
|
}
|
|
inline ::greptime::v1::StructValue* Value::_internal_mutable_struct_value() {
|
|
if (!_internal_has_struct_value()) {
|
|
clear_value_data();
|
|
set_has_struct_value();
|
|
_impl_.value_data_.struct_value_ = CreateMaybeMessage< ::greptime::v1::StructValue >(GetArenaForAllocation());
|
|
}
|
|
return _impl_.value_data_.struct_value_;
|
|
}
|
|
inline ::greptime::v1::StructValue* Value::mutable_struct_value() {
|
|
::greptime::v1::StructValue* _msg = _internal_mutable_struct_value();
|
|
// @@protoc_insertion_point(field_mutable:greptime.v1.Value.struct_value)
|
|
return _msg;
|
|
}
|
|
|
|
// .greptime.v1.JsonValue json_value = 42;
|
|
inline bool Value::_internal_has_json_value() const {
|
|
return value_data_case() == kJsonValue;
|
|
}
|
|
inline bool Value::has_json_value() const {
|
|
return _internal_has_json_value();
|
|
}
|
|
inline void Value::set_has_json_value() {
|
|
_impl_._oneof_case_[0] = kJsonValue;
|
|
}
|
|
inline void Value::clear_json_value() {
|
|
if (_internal_has_json_value()) {
|
|
if (GetArenaForAllocation() == nullptr) {
|
|
delete _impl_.value_data_.json_value_;
|
|
}
|
|
clear_has_value_data();
|
|
}
|
|
}
|
|
inline ::greptime::v1::JsonValue* Value::release_json_value() {
|
|
// @@protoc_insertion_point(field_release:greptime.v1.Value.json_value)
|
|
if (_internal_has_json_value()) {
|
|
clear_has_value_data();
|
|
::greptime::v1::JsonValue* temp = _impl_.value_data_.json_value_;
|
|
if (GetArenaForAllocation() != nullptr) {
|
|
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
|
|
}
|
|
_impl_.value_data_.json_value_ = nullptr;
|
|
return temp;
|
|
} else {
|
|
return nullptr;
|
|
}
|
|
}
|
|
inline const ::greptime::v1::JsonValue& Value::_internal_json_value() const {
|
|
return _internal_has_json_value()
|
|
? *_impl_.value_data_.json_value_
|
|
: reinterpret_cast< ::greptime::v1::JsonValue&>(::greptime::v1::_JsonValue_default_instance_);
|
|
}
|
|
inline const ::greptime::v1::JsonValue& Value::json_value() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.Value.json_value)
|
|
return _internal_json_value();
|
|
}
|
|
inline ::greptime::v1::JsonValue* Value::unsafe_arena_release_json_value() {
|
|
// @@protoc_insertion_point(field_unsafe_arena_release:greptime.v1.Value.json_value)
|
|
if (_internal_has_json_value()) {
|
|
clear_has_value_data();
|
|
::greptime::v1::JsonValue* temp = _impl_.value_data_.json_value_;
|
|
_impl_.value_data_.json_value_ = nullptr;
|
|
return temp;
|
|
} else {
|
|
return nullptr;
|
|
}
|
|
}
|
|
inline void Value::unsafe_arena_set_allocated_json_value(::greptime::v1::JsonValue* json_value) {
|
|
clear_value_data();
|
|
if (json_value) {
|
|
set_has_json_value();
|
|
_impl_.value_data_.json_value_ = json_value;
|
|
}
|
|
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:greptime.v1.Value.json_value)
|
|
}
|
|
inline ::greptime::v1::JsonValue* Value::_internal_mutable_json_value() {
|
|
if (!_internal_has_json_value()) {
|
|
clear_value_data();
|
|
set_has_json_value();
|
|
_impl_.value_data_.json_value_ = CreateMaybeMessage< ::greptime::v1::JsonValue >(GetArenaForAllocation());
|
|
}
|
|
return _impl_.value_data_.json_value_;
|
|
}
|
|
inline ::greptime::v1::JsonValue* Value::mutable_json_value() {
|
|
::greptime::v1::JsonValue* _msg = _internal_mutable_json_value();
|
|
// @@protoc_insertion_point(field_mutable:greptime.v1.Value.json_value)
|
|
return _msg;
|
|
}
|
|
|
|
inline bool Value::has_value_data() const {
|
|
return value_data_case() != VALUE_DATA_NOT_SET;
|
|
}
|
|
inline void Value::clear_has_value_data() {
|
|
_impl_._oneof_case_[0] = VALUE_DATA_NOT_SET;
|
|
}
|
|
inline Value::ValueDataCase Value::value_data_case() const {
|
|
return Value::ValueDataCase(_impl_._oneof_case_[0]);
|
|
}
|
|
// -------------------------------------------------------------------
|
|
|
|
// ListValue
|
|
|
|
// repeated .greptime.v1.Value items = 1;
|
|
inline int ListValue::_internal_items_size() const {
|
|
return _impl_.items_.size();
|
|
}
|
|
inline int ListValue::items_size() const {
|
|
return _internal_items_size();
|
|
}
|
|
inline void ListValue::clear_items() {
|
|
_impl_.items_.Clear();
|
|
}
|
|
inline ::greptime::v1::Value* ListValue::mutable_items(int index) {
|
|
// @@protoc_insertion_point(field_mutable:greptime.v1.ListValue.items)
|
|
return _impl_.items_.Mutable(index);
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::Value >*
|
|
ListValue::mutable_items() {
|
|
// @@protoc_insertion_point(field_mutable_list:greptime.v1.ListValue.items)
|
|
return &_impl_.items_;
|
|
}
|
|
inline const ::greptime::v1::Value& ListValue::_internal_items(int index) const {
|
|
return _impl_.items_.Get(index);
|
|
}
|
|
inline const ::greptime::v1::Value& ListValue::items(int index) const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.ListValue.items)
|
|
return _internal_items(index);
|
|
}
|
|
inline ::greptime::v1::Value* ListValue::_internal_add_items() {
|
|
return _impl_.items_.Add();
|
|
}
|
|
inline ::greptime::v1::Value* ListValue::add_items() {
|
|
::greptime::v1::Value* _add = _internal_add_items();
|
|
// @@protoc_insertion_point(field_add:greptime.v1.ListValue.items)
|
|
return _add;
|
|
}
|
|
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::Value >&
|
|
ListValue::items() const {
|
|
// @@protoc_insertion_point(field_list:greptime.v1.ListValue.items)
|
|
return _impl_.items_;
|
|
}
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
// StructValue
|
|
|
|
// repeated .greptime.v1.Value items = 2;
|
|
inline int StructValue::_internal_items_size() const {
|
|
return _impl_.items_.size();
|
|
}
|
|
inline int StructValue::items_size() const {
|
|
return _internal_items_size();
|
|
}
|
|
inline void StructValue::clear_items() {
|
|
_impl_.items_.Clear();
|
|
}
|
|
inline ::greptime::v1::Value* StructValue::mutable_items(int index) {
|
|
// @@protoc_insertion_point(field_mutable:greptime.v1.StructValue.items)
|
|
return _impl_.items_.Mutable(index);
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::Value >*
|
|
StructValue::mutable_items() {
|
|
// @@protoc_insertion_point(field_mutable_list:greptime.v1.StructValue.items)
|
|
return &_impl_.items_;
|
|
}
|
|
inline const ::greptime::v1::Value& StructValue::_internal_items(int index) const {
|
|
return _impl_.items_.Get(index);
|
|
}
|
|
inline const ::greptime::v1::Value& StructValue::items(int index) const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.StructValue.items)
|
|
return _internal_items(index);
|
|
}
|
|
inline ::greptime::v1::Value* StructValue::_internal_add_items() {
|
|
return _impl_.items_.Add();
|
|
}
|
|
inline ::greptime::v1::Value* StructValue::add_items() {
|
|
::greptime::v1::Value* _add = _internal_add_items();
|
|
// @@protoc_insertion_point(field_add:greptime.v1.StructValue.items)
|
|
return _add;
|
|
}
|
|
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::Value >&
|
|
StructValue::items() const {
|
|
// @@protoc_insertion_point(field_list:greptime.v1.StructValue.items)
|
|
return _impl_.items_;
|
|
}
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
// JsonValue
|
|
|
|
// bool boolean = 1;
|
|
inline bool JsonValue::_internal_has_boolean() const {
|
|
return value_case() == kBoolean;
|
|
}
|
|
inline bool JsonValue::has_boolean() const {
|
|
return _internal_has_boolean();
|
|
}
|
|
inline void JsonValue::set_has_boolean() {
|
|
_impl_._oneof_case_[0] = kBoolean;
|
|
}
|
|
inline void JsonValue::clear_boolean() {
|
|
if (_internal_has_boolean()) {
|
|
_impl_.value_.boolean_ = false;
|
|
clear_has_value();
|
|
}
|
|
}
|
|
inline bool JsonValue::_internal_boolean() const {
|
|
if (_internal_has_boolean()) {
|
|
return _impl_.value_.boolean_;
|
|
}
|
|
return false;
|
|
}
|
|
inline void JsonValue::_internal_set_boolean(bool value) {
|
|
if (!_internal_has_boolean()) {
|
|
clear_value();
|
|
set_has_boolean();
|
|
}
|
|
_impl_.value_.boolean_ = value;
|
|
}
|
|
inline bool JsonValue::boolean() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.JsonValue.boolean)
|
|
return _internal_boolean();
|
|
}
|
|
inline void JsonValue::set_boolean(bool value) {
|
|
_internal_set_boolean(value);
|
|
// @@protoc_insertion_point(field_set:greptime.v1.JsonValue.boolean)
|
|
}
|
|
|
|
// int64 int = 2;
|
|
inline bool JsonValue::_internal_has_int_() const {
|
|
return value_case() == kInt;
|
|
}
|
|
inline bool JsonValue::has_int_() const {
|
|
return _internal_has_int_();
|
|
}
|
|
inline void JsonValue::set_has_int_() {
|
|
_impl_._oneof_case_[0] = kInt;
|
|
}
|
|
inline void JsonValue::clear_int_() {
|
|
if (_internal_has_int_()) {
|
|
_impl_.value_.int__ = int64_t{0};
|
|
clear_has_value();
|
|
}
|
|
}
|
|
inline int64_t JsonValue::_internal_int_() const {
|
|
if (_internal_has_int_()) {
|
|
return _impl_.value_.int__;
|
|
}
|
|
return int64_t{0};
|
|
}
|
|
inline void JsonValue::_internal_set_int_(int64_t value) {
|
|
if (!_internal_has_int_()) {
|
|
clear_value();
|
|
set_has_int_();
|
|
}
|
|
_impl_.value_.int__ = value;
|
|
}
|
|
inline int64_t JsonValue::int_() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.JsonValue.int)
|
|
return _internal_int_();
|
|
}
|
|
inline void JsonValue::set_int_(int64_t value) {
|
|
_internal_set_int_(value);
|
|
// @@protoc_insertion_point(field_set:greptime.v1.JsonValue.int)
|
|
}
|
|
|
|
// uint64 uint = 3;
|
|
inline bool JsonValue::_internal_has_uint() const {
|
|
return value_case() == kUint;
|
|
}
|
|
inline bool JsonValue::has_uint() const {
|
|
return _internal_has_uint();
|
|
}
|
|
inline void JsonValue::set_has_uint() {
|
|
_impl_._oneof_case_[0] = kUint;
|
|
}
|
|
inline void JsonValue::clear_uint() {
|
|
if (_internal_has_uint()) {
|
|
_impl_.value_.uint_ = uint64_t{0u};
|
|
clear_has_value();
|
|
}
|
|
}
|
|
inline uint64_t JsonValue::_internal_uint() const {
|
|
if (_internal_has_uint()) {
|
|
return _impl_.value_.uint_;
|
|
}
|
|
return uint64_t{0u};
|
|
}
|
|
inline void JsonValue::_internal_set_uint(uint64_t value) {
|
|
if (!_internal_has_uint()) {
|
|
clear_value();
|
|
set_has_uint();
|
|
}
|
|
_impl_.value_.uint_ = value;
|
|
}
|
|
inline uint64_t JsonValue::uint() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.JsonValue.uint)
|
|
return _internal_uint();
|
|
}
|
|
inline void JsonValue::set_uint(uint64_t value) {
|
|
_internal_set_uint(value);
|
|
// @@protoc_insertion_point(field_set:greptime.v1.JsonValue.uint)
|
|
}
|
|
|
|
// double float = 4;
|
|
inline bool JsonValue::_internal_has_float_() const {
|
|
return value_case() == kFloat;
|
|
}
|
|
inline bool JsonValue::has_float_() const {
|
|
return _internal_has_float_();
|
|
}
|
|
inline void JsonValue::set_has_float_() {
|
|
_impl_._oneof_case_[0] = kFloat;
|
|
}
|
|
inline void JsonValue::clear_float_() {
|
|
if (_internal_has_float_()) {
|
|
_impl_.value_.float__ = 0;
|
|
clear_has_value();
|
|
}
|
|
}
|
|
inline double JsonValue::_internal_float_() const {
|
|
if (_internal_has_float_()) {
|
|
return _impl_.value_.float__;
|
|
}
|
|
return 0;
|
|
}
|
|
inline void JsonValue::_internal_set_float_(double value) {
|
|
if (!_internal_has_float_()) {
|
|
clear_value();
|
|
set_has_float_();
|
|
}
|
|
_impl_.value_.float__ = value;
|
|
}
|
|
inline double JsonValue::float_() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.JsonValue.float)
|
|
return _internal_float_();
|
|
}
|
|
inline void JsonValue::set_float_(double value) {
|
|
_internal_set_float_(value);
|
|
// @@protoc_insertion_point(field_set:greptime.v1.JsonValue.float)
|
|
}
|
|
|
|
// string str = 5;
|
|
inline bool JsonValue::_internal_has_str() const {
|
|
return value_case() == kStr;
|
|
}
|
|
inline bool JsonValue::has_str() const {
|
|
return _internal_has_str();
|
|
}
|
|
inline void JsonValue::set_has_str() {
|
|
_impl_._oneof_case_[0] = kStr;
|
|
}
|
|
inline void JsonValue::clear_str() {
|
|
if (_internal_has_str()) {
|
|
_impl_.value_.str_.Destroy();
|
|
clear_has_value();
|
|
}
|
|
}
|
|
inline const std::string& JsonValue::str() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.JsonValue.str)
|
|
return _internal_str();
|
|
}
|
|
template <typename ArgT0, typename... ArgT>
|
|
inline void JsonValue::set_str(ArgT0&& arg0, ArgT... args) {
|
|
if (!_internal_has_str()) {
|
|
clear_value();
|
|
set_has_str();
|
|
_impl_.value_.str_.InitDefault();
|
|
}
|
|
_impl_.value_.str_.Set( static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
|
|
// @@protoc_insertion_point(field_set:greptime.v1.JsonValue.str)
|
|
}
|
|
inline std::string* JsonValue::mutable_str() {
|
|
std::string* _s = _internal_mutable_str();
|
|
// @@protoc_insertion_point(field_mutable:greptime.v1.JsonValue.str)
|
|
return _s;
|
|
}
|
|
inline const std::string& JsonValue::_internal_str() const {
|
|
if (_internal_has_str()) {
|
|
return _impl_.value_.str_.Get();
|
|
}
|
|
return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
|
|
}
|
|
inline void JsonValue::_internal_set_str(const std::string& value) {
|
|
if (!_internal_has_str()) {
|
|
clear_value();
|
|
set_has_str();
|
|
_impl_.value_.str_.InitDefault();
|
|
}
|
|
_impl_.value_.str_.Set(value, GetArenaForAllocation());
|
|
}
|
|
inline std::string* JsonValue::_internal_mutable_str() {
|
|
if (!_internal_has_str()) {
|
|
clear_value();
|
|
set_has_str();
|
|
_impl_.value_.str_.InitDefault();
|
|
}
|
|
return _impl_.value_.str_.Mutable( GetArenaForAllocation());
|
|
}
|
|
inline std::string* JsonValue::release_str() {
|
|
// @@protoc_insertion_point(field_release:greptime.v1.JsonValue.str)
|
|
if (_internal_has_str()) {
|
|
clear_has_value();
|
|
return _impl_.value_.str_.Release();
|
|
} else {
|
|
return nullptr;
|
|
}
|
|
}
|
|
inline void JsonValue::set_allocated_str(std::string* str) {
|
|
if (has_value()) {
|
|
clear_value();
|
|
}
|
|
if (str != nullptr) {
|
|
set_has_str();
|
|
_impl_.value_.str_.InitAllocated(str, GetArenaForAllocation());
|
|
}
|
|
// @@protoc_insertion_point(field_set_allocated:greptime.v1.JsonValue.str)
|
|
}
|
|
|
|
// .greptime.v1.JsonList array = 6;
|
|
inline bool JsonValue::_internal_has_array() const {
|
|
return value_case() == kArray;
|
|
}
|
|
inline bool JsonValue::has_array() const {
|
|
return _internal_has_array();
|
|
}
|
|
inline void JsonValue::set_has_array() {
|
|
_impl_._oneof_case_[0] = kArray;
|
|
}
|
|
inline void JsonValue::clear_array() {
|
|
if (_internal_has_array()) {
|
|
if (GetArenaForAllocation() == nullptr) {
|
|
delete _impl_.value_.array_;
|
|
}
|
|
clear_has_value();
|
|
}
|
|
}
|
|
inline ::greptime::v1::JsonList* JsonValue::release_array() {
|
|
// @@protoc_insertion_point(field_release:greptime.v1.JsonValue.array)
|
|
if (_internal_has_array()) {
|
|
clear_has_value();
|
|
::greptime::v1::JsonList* temp = _impl_.value_.array_;
|
|
if (GetArenaForAllocation() != nullptr) {
|
|
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
|
|
}
|
|
_impl_.value_.array_ = nullptr;
|
|
return temp;
|
|
} else {
|
|
return nullptr;
|
|
}
|
|
}
|
|
inline const ::greptime::v1::JsonList& JsonValue::_internal_array() const {
|
|
return _internal_has_array()
|
|
? *_impl_.value_.array_
|
|
: reinterpret_cast< ::greptime::v1::JsonList&>(::greptime::v1::_JsonList_default_instance_);
|
|
}
|
|
inline const ::greptime::v1::JsonList& JsonValue::array() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.JsonValue.array)
|
|
return _internal_array();
|
|
}
|
|
inline ::greptime::v1::JsonList* JsonValue::unsafe_arena_release_array() {
|
|
// @@protoc_insertion_point(field_unsafe_arena_release:greptime.v1.JsonValue.array)
|
|
if (_internal_has_array()) {
|
|
clear_has_value();
|
|
::greptime::v1::JsonList* temp = _impl_.value_.array_;
|
|
_impl_.value_.array_ = nullptr;
|
|
return temp;
|
|
} else {
|
|
return nullptr;
|
|
}
|
|
}
|
|
inline void JsonValue::unsafe_arena_set_allocated_array(::greptime::v1::JsonList* array) {
|
|
clear_value();
|
|
if (array) {
|
|
set_has_array();
|
|
_impl_.value_.array_ = array;
|
|
}
|
|
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:greptime.v1.JsonValue.array)
|
|
}
|
|
inline ::greptime::v1::JsonList* JsonValue::_internal_mutable_array() {
|
|
if (!_internal_has_array()) {
|
|
clear_value();
|
|
set_has_array();
|
|
_impl_.value_.array_ = CreateMaybeMessage< ::greptime::v1::JsonList >(GetArenaForAllocation());
|
|
}
|
|
return _impl_.value_.array_;
|
|
}
|
|
inline ::greptime::v1::JsonList* JsonValue::mutable_array() {
|
|
::greptime::v1::JsonList* _msg = _internal_mutable_array();
|
|
// @@protoc_insertion_point(field_mutable:greptime.v1.JsonValue.array)
|
|
return _msg;
|
|
}
|
|
|
|
// .greptime.v1.JsonObject object = 7;
|
|
inline bool JsonValue::_internal_has_object() const {
|
|
return value_case() == kObject;
|
|
}
|
|
inline bool JsonValue::has_object() const {
|
|
return _internal_has_object();
|
|
}
|
|
inline void JsonValue::set_has_object() {
|
|
_impl_._oneof_case_[0] = kObject;
|
|
}
|
|
inline void JsonValue::clear_object() {
|
|
if (_internal_has_object()) {
|
|
if (GetArenaForAllocation() == nullptr) {
|
|
delete _impl_.value_.object_;
|
|
}
|
|
clear_has_value();
|
|
}
|
|
}
|
|
inline ::greptime::v1::JsonObject* JsonValue::release_object() {
|
|
// @@protoc_insertion_point(field_release:greptime.v1.JsonValue.object)
|
|
if (_internal_has_object()) {
|
|
clear_has_value();
|
|
::greptime::v1::JsonObject* temp = _impl_.value_.object_;
|
|
if (GetArenaForAllocation() != nullptr) {
|
|
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
|
|
}
|
|
_impl_.value_.object_ = nullptr;
|
|
return temp;
|
|
} else {
|
|
return nullptr;
|
|
}
|
|
}
|
|
inline const ::greptime::v1::JsonObject& JsonValue::_internal_object() const {
|
|
return _internal_has_object()
|
|
? *_impl_.value_.object_
|
|
: reinterpret_cast< ::greptime::v1::JsonObject&>(::greptime::v1::_JsonObject_default_instance_);
|
|
}
|
|
inline const ::greptime::v1::JsonObject& JsonValue::object() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.JsonValue.object)
|
|
return _internal_object();
|
|
}
|
|
inline ::greptime::v1::JsonObject* JsonValue::unsafe_arena_release_object() {
|
|
// @@protoc_insertion_point(field_unsafe_arena_release:greptime.v1.JsonValue.object)
|
|
if (_internal_has_object()) {
|
|
clear_has_value();
|
|
::greptime::v1::JsonObject* temp = _impl_.value_.object_;
|
|
_impl_.value_.object_ = nullptr;
|
|
return temp;
|
|
} else {
|
|
return nullptr;
|
|
}
|
|
}
|
|
inline void JsonValue::unsafe_arena_set_allocated_object(::greptime::v1::JsonObject* object) {
|
|
clear_value();
|
|
if (object) {
|
|
set_has_object();
|
|
_impl_.value_.object_ = object;
|
|
}
|
|
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:greptime.v1.JsonValue.object)
|
|
}
|
|
inline ::greptime::v1::JsonObject* JsonValue::_internal_mutable_object() {
|
|
if (!_internal_has_object()) {
|
|
clear_value();
|
|
set_has_object();
|
|
_impl_.value_.object_ = CreateMaybeMessage< ::greptime::v1::JsonObject >(GetArenaForAllocation());
|
|
}
|
|
return _impl_.value_.object_;
|
|
}
|
|
inline ::greptime::v1::JsonObject* JsonValue::mutable_object() {
|
|
::greptime::v1::JsonObject* _msg = _internal_mutable_object();
|
|
// @@protoc_insertion_point(field_mutable:greptime.v1.JsonValue.object)
|
|
return _msg;
|
|
}
|
|
|
|
// bytes variant = 8;
|
|
inline bool JsonValue::_internal_has_variant() const {
|
|
return value_case() == kVariant;
|
|
}
|
|
inline bool JsonValue::has_variant() const {
|
|
return _internal_has_variant();
|
|
}
|
|
inline void JsonValue::set_has_variant() {
|
|
_impl_._oneof_case_[0] = kVariant;
|
|
}
|
|
inline void JsonValue::clear_variant() {
|
|
if (_internal_has_variant()) {
|
|
_impl_.value_.variant_.Destroy();
|
|
clear_has_value();
|
|
}
|
|
}
|
|
inline const std::string& JsonValue::variant() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.JsonValue.variant)
|
|
return _internal_variant();
|
|
}
|
|
template <typename ArgT0, typename... ArgT>
|
|
inline void JsonValue::set_variant(ArgT0&& arg0, ArgT... args) {
|
|
if (!_internal_has_variant()) {
|
|
clear_value();
|
|
set_has_variant();
|
|
_impl_.value_.variant_.InitDefault();
|
|
}
|
|
_impl_.value_.variant_.SetBytes( static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
|
|
// @@protoc_insertion_point(field_set:greptime.v1.JsonValue.variant)
|
|
}
|
|
inline std::string* JsonValue::mutable_variant() {
|
|
std::string* _s = _internal_mutable_variant();
|
|
// @@protoc_insertion_point(field_mutable:greptime.v1.JsonValue.variant)
|
|
return _s;
|
|
}
|
|
inline const std::string& JsonValue::_internal_variant() const {
|
|
if (_internal_has_variant()) {
|
|
return _impl_.value_.variant_.Get();
|
|
}
|
|
return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
|
|
}
|
|
inline void JsonValue::_internal_set_variant(const std::string& value) {
|
|
if (!_internal_has_variant()) {
|
|
clear_value();
|
|
set_has_variant();
|
|
_impl_.value_.variant_.InitDefault();
|
|
}
|
|
_impl_.value_.variant_.Set(value, GetArenaForAllocation());
|
|
}
|
|
inline std::string* JsonValue::_internal_mutable_variant() {
|
|
if (!_internal_has_variant()) {
|
|
clear_value();
|
|
set_has_variant();
|
|
_impl_.value_.variant_.InitDefault();
|
|
}
|
|
return _impl_.value_.variant_.Mutable( GetArenaForAllocation());
|
|
}
|
|
inline std::string* JsonValue::release_variant() {
|
|
// @@protoc_insertion_point(field_release:greptime.v1.JsonValue.variant)
|
|
if (_internal_has_variant()) {
|
|
clear_has_value();
|
|
return _impl_.value_.variant_.Release();
|
|
} else {
|
|
return nullptr;
|
|
}
|
|
}
|
|
inline void JsonValue::set_allocated_variant(std::string* variant) {
|
|
if (has_value()) {
|
|
clear_value();
|
|
}
|
|
if (variant != nullptr) {
|
|
set_has_variant();
|
|
_impl_.value_.variant_.InitAllocated(variant, GetArenaForAllocation());
|
|
}
|
|
// @@protoc_insertion_point(field_set_allocated:greptime.v1.JsonValue.variant)
|
|
}
|
|
|
|
inline bool JsonValue::has_value() const {
|
|
return value_case() != VALUE_NOT_SET;
|
|
}
|
|
inline void JsonValue::clear_has_value() {
|
|
_impl_._oneof_case_[0] = VALUE_NOT_SET;
|
|
}
|
|
inline JsonValue::ValueCase JsonValue::value_case() const {
|
|
return JsonValue::ValueCase(_impl_._oneof_case_[0]);
|
|
}
|
|
// -------------------------------------------------------------------
|
|
|
|
// JsonList
|
|
|
|
// repeated .greptime.v1.JsonValue items = 1;
|
|
inline int JsonList::_internal_items_size() const {
|
|
return _impl_.items_.size();
|
|
}
|
|
inline int JsonList::items_size() const {
|
|
return _internal_items_size();
|
|
}
|
|
inline void JsonList::clear_items() {
|
|
_impl_.items_.Clear();
|
|
}
|
|
inline ::greptime::v1::JsonValue* JsonList::mutable_items(int index) {
|
|
// @@protoc_insertion_point(field_mutable:greptime.v1.JsonList.items)
|
|
return _impl_.items_.Mutable(index);
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::JsonValue >*
|
|
JsonList::mutable_items() {
|
|
// @@protoc_insertion_point(field_mutable_list:greptime.v1.JsonList.items)
|
|
return &_impl_.items_;
|
|
}
|
|
inline const ::greptime::v1::JsonValue& JsonList::_internal_items(int index) const {
|
|
return _impl_.items_.Get(index);
|
|
}
|
|
inline const ::greptime::v1::JsonValue& JsonList::items(int index) const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.JsonList.items)
|
|
return _internal_items(index);
|
|
}
|
|
inline ::greptime::v1::JsonValue* JsonList::_internal_add_items() {
|
|
return _impl_.items_.Add();
|
|
}
|
|
inline ::greptime::v1::JsonValue* JsonList::add_items() {
|
|
::greptime::v1::JsonValue* _add = _internal_add_items();
|
|
// @@protoc_insertion_point(field_add:greptime.v1.JsonList.items)
|
|
return _add;
|
|
}
|
|
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::JsonValue >&
|
|
JsonList::items() const {
|
|
// @@protoc_insertion_point(field_list:greptime.v1.JsonList.items)
|
|
return _impl_.items_;
|
|
}
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
// JsonObject_Entry
|
|
|
|
// string key = 1;
|
|
inline void JsonObject_Entry::clear_key() {
|
|
_impl_.key_.ClearToEmpty();
|
|
}
|
|
inline const std::string& JsonObject_Entry::key() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.JsonObject.Entry.key)
|
|
return _internal_key();
|
|
}
|
|
template <typename ArgT0, typename... ArgT>
|
|
inline PROTOBUF_ALWAYS_INLINE
|
|
void JsonObject_Entry::set_key(ArgT0&& arg0, ArgT... args) {
|
|
|
|
_impl_.key_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
|
|
// @@protoc_insertion_point(field_set:greptime.v1.JsonObject.Entry.key)
|
|
}
|
|
inline std::string* JsonObject_Entry::mutable_key() {
|
|
std::string* _s = _internal_mutable_key();
|
|
// @@protoc_insertion_point(field_mutable:greptime.v1.JsonObject.Entry.key)
|
|
return _s;
|
|
}
|
|
inline const std::string& JsonObject_Entry::_internal_key() const {
|
|
return _impl_.key_.Get();
|
|
}
|
|
inline void JsonObject_Entry::_internal_set_key(const std::string& value) {
|
|
|
|
_impl_.key_.Set(value, GetArenaForAllocation());
|
|
}
|
|
inline std::string* JsonObject_Entry::_internal_mutable_key() {
|
|
|
|
return _impl_.key_.Mutable(GetArenaForAllocation());
|
|
}
|
|
inline std::string* JsonObject_Entry::release_key() {
|
|
// @@protoc_insertion_point(field_release:greptime.v1.JsonObject.Entry.key)
|
|
return _impl_.key_.Release();
|
|
}
|
|
inline void JsonObject_Entry::set_allocated_key(std::string* key) {
|
|
if (key != nullptr) {
|
|
|
|
} else {
|
|
|
|
}
|
|
_impl_.key_.SetAllocated(key, GetArenaForAllocation());
|
|
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
if (_impl_.key_.IsDefault()) {
|
|
_impl_.key_.Set("", GetArenaForAllocation());
|
|
}
|
|
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
// @@protoc_insertion_point(field_set_allocated:greptime.v1.JsonObject.Entry.key)
|
|
}
|
|
|
|
// .greptime.v1.JsonValue value = 2;
|
|
inline bool JsonObject_Entry::_internal_has_value() const {
|
|
return this != internal_default_instance() && _impl_.value_ != nullptr;
|
|
}
|
|
inline bool JsonObject_Entry::has_value() const {
|
|
return _internal_has_value();
|
|
}
|
|
inline void JsonObject_Entry::clear_value() {
|
|
if (GetArenaForAllocation() == nullptr && _impl_.value_ != nullptr) {
|
|
delete _impl_.value_;
|
|
}
|
|
_impl_.value_ = nullptr;
|
|
}
|
|
inline const ::greptime::v1::JsonValue& JsonObject_Entry::_internal_value() const {
|
|
const ::greptime::v1::JsonValue* p = _impl_.value_;
|
|
return p != nullptr ? *p : reinterpret_cast<const ::greptime::v1::JsonValue&>(
|
|
::greptime::v1::_JsonValue_default_instance_);
|
|
}
|
|
inline const ::greptime::v1::JsonValue& JsonObject_Entry::value() const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.JsonObject.Entry.value)
|
|
return _internal_value();
|
|
}
|
|
inline void JsonObject_Entry::unsafe_arena_set_allocated_value(
|
|
::greptime::v1::JsonValue* value) {
|
|
if (GetArenaForAllocation() == nullptr) {
|
|
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.value_);
|
|
}
|
|
_impl_.value_ = value;
|
|
if (value) {
|
|
|
|
} else {
|
|
|
|
}
|
|
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:greptime.v1.JsonObject.Entry.value)
|
|
}
|
|
inline ::greptime::v1::JsonValue* JsonObject_Entry::release_value() {
|
|
|
|
::greptime::v1::JsonValue* temp = _impl_.value_;
|
|
_impl_.value_ = 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::JsonValue* JsonObject_Entry::unsafe_arena_release_value() {
|
|
// @@protoc_insertion_point(field_release:greptime.v1.JsonObject.Entry.value)
|
|
|
|
::greptime::v1::JsonValue* temp = _impl_.value_;
|
|
_impl_.value_ = nullptr;
|
|
return temp;
|
|
}
|
|
inline ::greptime::v1::JsonValue* JsonObject_Entry::_internal_mutable_value() {
|
|
|
|
if (_impl_.value_ == nullptr) {
|
|
auto* p = CreateMaybeMessage<::greptime::v1::JsonValue>(GetArenaForAllocation());
|
|
_impl_.value_ = p;
|
|
}
|
|
return _impl_.value_;
|
|
}
|
|
inline ::greptime::v1::JsonValue* JsonObject_Entry::mutable_value() {
|
|
::greptime::v1::JsonValue* _msg = _internal_mutable_value();
|
|
// @@protoc_insertion_point(field_mutable:greptime.v1.JsonObject.Entry.value)
|
|
return _msg;
|
|
}
|
|
inline void JsonObject_Entry::set_allocated_value(::greptime::v1::JsonValue* value) {
|
|
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
|
|
if (message_arena == nullptr) {
|
|
delete _impl_.value_;
|
|
}
|
|
if (value) {
|
|
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
|
|
::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(value);
|
|
if (message_arena != submessage_arena) {
|
|
value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
|
|
message_arena, value, submessage_arena);
|
|
}
|
|
|
|
} else {
|
|
|
|
}
|
|
_impl_.value_ = value;
|
|
// @@protoc_insertion_point(field_set_allocated:greptime.v1.JsonObject.Entry.value)
|
|
}
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
// JsonObject
|
|
|
|
// repeated .greptime.v1.JsonObject.Entry entries = 1;
|
|
inline int JsonObject::_internal_entries_size() const {
|
|
return _impl_.entries_.size();
|
|
}
|
|
inline int JsonObject::entries_size() const {
|
|
return _internal_entries_size();
|
|
}
|
|
inline void JsonObject::clear_entries() {
|
|
_impl_.entries_.Clear();
|
|
}
|
|
inline ::greptime::v1::JsonObject_Entry* JsonObject::mutable_entries(int index) {
|
|
// @@protoc_insertion_point(field_mutable:greptime.v1.JsonObject.entries)
|
|
return _impl_.entries_.Mutable(index);
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::JsonObject_Entry >*
|
|
JsonObject::mutable_entries() {
|
|
// @@protoc_insertion_point(field_mutable_list:greptime.v1.JsonObject.entries)
|
|
return &_impl_.entries_;
|
|
}
|
|
inline const ::greptime::v1::JsonObject_Entry& JsonObject::_internal_entries(int index) const {
|
|
return _impl_.entries_.Get(index);
|
|
}
|
|
inline const ::greptime::v1::JsonObject_Entry& JsonObject::entries(int index) const {
|
|
// @@protoc_insertion_point(field_get:greptime.v1.JsonObject.entries)
|
|
return _internal_entries(index);
|
|
}
|
|
inline ::greptime::v1::JsonObject_Entry* JsonObject::_internal_add_entries() {
|
|
return _impl_.entries_.Add();
|
|
}
|
|
inline ::greptime::v1::JsonObject_Entry* JsonObject::add_entries() {
|
|
::greptime::v1::JsonObject_Entry* _add = _internal_add_entries();
|
|
// @@protoc_insertion_point(field_add:greptime.v1.JsonObject.entries)
|
|
return _add;
|
|
}
|
|
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::JsonObject_Entry >&
|
|
JsonObject::entries() const {
|
|
// @@protoc_insertion_point(field_list:greptime.v1.JsonObject.entries)
|
|
return _impl_.entries_;
|
|
}
|
|
|
|
#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_2frow_2eproto
|