From 8c260e8112853cd5f8184a319f0a032b238cd2cd Mon Sep 17 00:00:00 2001 From: shengjh <1572099106@qq.com> Date: Sat, 19 Sep 2020 17:10:23 +0800 Subject: [PATCH] Fix bug and add meta wrapper Signed-off-by: shengjh <1572099106@qq.com> --- conf/config.yaml | 4 +- core/CMakeLists_old.txt | 20 - core/include/segment_c.h | 3 + core/src/CMakeLists_old.txt | 4 - core/src/dog_segment/CMakeLists.txt | 7 +- core/src/dog_segment/Collection.cpp | 26 +- core/src/dog_segment/segment_c.cpp | 7 + core/src/dog_segment/segment_c.h | 3 + core/src/pb/master.pb.cc | 1654 ++ core/src/pb/master.pb.h | 1088 + core/src/pb/message.pb.cc | 19734 ++++++++++++++++ core/src/pb/message.pb.h | 13531 +++++++++++ core/src/utils/Types.h | 1 + core/thirdparty/CMakeLists.txt | 4 +- core/thirdparty/protobuf/CMakeLists.txt | 66 + core/thirdparty/versions.txt | 1 + core/unittest/test_c_api.cpp | 44 + pkg/master/common/config.go | 2 +- pkg/master/kv/etcd_kv.go | 5 + pkg/master/server.go | 1 - proxy/src/CMakeLists.txt | 2 +- proxy/src/config/ConfigMgr.cpp | 16 +- proxy/src/config/ServerConfig.h | 9 + proxy/src/grpc/etcd.grpc.pb.cc | 61 + proxy/src/grpc/etcd.grpc.pb.h | 211 + proxy/src/grpc/etcd.pb.cc | 1417 +- proxy/src/grpc/etcd.pb.h | 923 +- proxy/src/grpc/master.pb.cc | 82 +- proxy/src/grpc/master.pb.h | 64 + proxy/src/grpc/proto/etcd.proto | 84 + proxy/src/message_client/ClientV2.cpp | 232 +- proxy/src/message_client/ClientV2.h | 8 +- proxy/src/meta/CMakeLists.txt | 7 +- proxy/src/meta/etcd_client/Etcd_client.cpp | 23 + proxy/src/meta/etcd_client/Etcd_client.h | 18 + proxy/src/meta/etcd_watcher/Watcher.h | 6 +- proxy/src/meta/master/GrpcClient.cpp | 2 +- proxy/src/server/MetaWrapper.cpp | 149 +- proxy/src/server/MetaWrapper.h | 41 +- proxy/src/server/delivery/ReqHandler.cpp | 10 +- proxy/src/server/delivery/ReqHandler.h | 6 +- proxy/src/server/delivery/ReqScheduler.cpp | 9 +- .../delivery/request/CreateCollectionReq.cpp | 22 +- .../delivery/request/CreateCollectionReq.h | 17 +- .../delivery/request/DeleteEntityByIDReq.cpp | 8 +- .../delivery/request/GetCollectionInfoReq.cpp | 24 +- .../delivery/request/GetCollectionInfoReq.h | 15 +- .../src/server/delivery/request/InsertReq.cpp | 9 +- proxy/src/server/delivery/request/InsertReq.h | 2 +- .../server/grpc_impl/GrpcRequestHandler.cpp | 20 +- proxy/src/server/grpc_impl/GrpcServer.cpp | 2 +- proxy/thirdparty/grpc/CMakeLists.txt | 2 +- proxy/thirdparty/pulsar/CMakeLists.txt | 14 - reader/main.go | 2 +- reader/read_node/collection.go | 6 +- reader/read_node/index_test.go | 7 +- reader/read_node/meta.go | 78 +- reader/read_node/partition.go | 4 +- reader/read_node/query_node.go | 7 +- reader/read_node/result_test.go | 15 +- reader/read_node/segment.go | 10 +- reader/read_node/segment_service_test.go | 8 +- reader/read_node/segment_test.go | 80 +- reader/read_node/util_functions.go | 20 + reader/read_node/util_functions_test.go | 10 +- sdk/examples/simple/CMakeLists.txt | 6 +- sdk/examples/simple/CreateCollection.cpp | 46 + 67 files changed, 39645 insertions(+), 374 deletions(-) delete mode 100644 core/CMakeLists_old.txt delete mode 100644 core/src/CMakeLists_old.txt create mode 100644 core/src/pb/master.pb.cc create mode 100644 core/src/pb/master.pb.h create mode 100644 core/src/pb/message.pb.cc create mode 100644 core/src/pb/message.pb.h create mode 100644 core/thirdparty/protobuf/CMakeLists.txt create mode 100644 proxy/src/meta/etcd_client/Etcd_client.cpp create mode 100644 proxy/src/meta/etcd_client/Etcd_client.h create mode 100644 sdk/examples/simple/CreateCollection.cpp diff --git a/conf/config.yaml b/conf/config.yaml index da6355c85c..8684845959 100644 --- a/conf/config.yaml +++ b/conf/config.yaml @@ -11,12 +11,12 @@ master: address: localhost - port: 6000 + port: 53100 etcd: address: localhost port: 2379 - rootpath: suvlim + rootpath: by-dev/ segthreshold: 10000 timesync: diff --git a/core/CMakeLists_old.txt b/core/CMakeLists_old.txt deleted file mode 100644 index d3cfcc4b09..0000000000 --- a/core/CMakeLists_old.txt +++ /dev/null @@ -1,20 +0,0 @@ -project(sulvim_core) - -set(CMAKE_POSITION_INDEPENDENT_CODE ON) - -cmake_minimum_required(VERSION 3.16) -set( CMAKE_CXX_STANDARD 17 ) -set( CMAKE_CXX_STANDARD_REQUIRED on ) -set (CMAKE_MODULE_PATH "${CMAKE_MODULE_PATH};${CMAKE_CURRENT_SOURCE_DIR}/cmake") -include_directories(src) -add_subdirectory(src) -add_subdirectory(unittest) - -install( - DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/src/dog_segment/ - DESTINATION ${CMAKE_CURRENT_SOURCE_DIR}/include - FILES_MATCHING PATTERN "*_c.h" -) - -install(FILES ${CMAKE_BINARY_DIR}/src/dog_segment/libmilvus_dog_segment.so - DESTINATION ${CMAKE_CURRENT_SOURCE_DIR}/lib) diff --git a/core/include/segment_c.h b/core/include/segment_c.h index 1f29087876..116f6de2e2 100644 --- a/core/include/segment_c.h +++ b/core/include/segment_c.h @@ -73,6 +73,9 @@ BuildIndex(CSegmentBase c_segment); bool IsOpened(CSegmentBase c_segment); +long int +GetMemoryUsageInBytes(CSegmentBase c_segment); + ////////////////////////////////////////////////////////////////// long int diff --git a/core/src/CMakeLists_old.txt b/core/src/CMakeLists_old.txt deleted file mode 100644 index 746c72aac8..0000000000 --- a/core/src/CMakeLists_old.txt +++ /dev/null @@ -1,4 +0,0 @@ -add_subdirectory(utils) -add_subdirectory(dog_segment) -#add_subdirectory(index) -add_subdirectory(query) diff --git a/core/src/dog_segment/CMakeLists.txt b/core/src/dog_segment/CMakeLists.txt index e87bad6daf..43890955c6 100644 --- a/core/src/dog_segment/CMakeLists.txt +++ b/core/src/dog_segment/CMakeLists.txt @@ -1,3 +1,5 @@ +aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR}/../pb PB_SRC_FILES) + set(DOG_SEGMENT_FILES SegmentNaive.cpp IndexMeta.cpp @@ -7,10 +9,13 @@ set(DOG_SEGMENT_FILES collection_c.cpp partition_c.cpp segment_c.cpp + ${PB_SRC_FILES} ) add_library(milvus_dog_segment SHARED ${DOG_SEGMENT_FILES} ) + + #add_dependencies( segment sqlite mysqlpp ) -target_link_libraries(milvus_dog_segment tbb utils pthread knowhere log) +target_link_libraries(milvus_dog_segment tbb utils pthread knowhere log libprotobuf) diff --git a/core/src/dog_segment/Collection.cpp b/core/src/dog_segment/Collection.cpp index 82664ed927..56905031b4 100644 --- a/core/src/dog_segment/Collection.cpp +++ b/core/src/dog_segment/Collection.cpp @@ -1,5 +1,7 @@ #include "Collection.h" - +#include "pb/master.pb.h" +//using Collection = masterpb::Collection; +#include namespace milvus::dog_segment { Collection::Collection(std::string &collection_name, std::string &schema): @@ -12,10 +14,32 @@ Collection::set_index() {} void Collection::parse() { + if(schema_json_ == "") { + auto schema = std::make_shared(); + schema->AddField("fakevec", DataType::VECTOR_FLOAT, 16); + schema->AddField("age", DataType::INT32); + schema_ = schema; + return; + } + + masterpb::Collection collection; + auto suc = google::protobuf::TextFormat::ParseFromString(schema_json_, &collection); + + + if (!suc) { + std::cerr << "unmarshal failed" << std::endl; + } auto schema = std::make_shared(); + for (const milvus::grpc::FieldMeta & child: collection.schema().field_metas()){ + std::cout<<"add Field, name :" << child.field_name() << std::endl; + schema->AddField(std::string_view(child.field_name()), DataType {child.type()}, int(child.dim())); + } + /* schema->AddField("fakevec", DataType::VECTOR_FLOAT, 16); schema->AddField("age", DataType::INT32); + */ schema_ = schema; + } } diff --git a/core/src/dog_segment/segment_c.cpp b/core/src/dog_segment/segment_c.cpp index 0400835124..84f88f6e94 100644 --- a/core/src/dog_segment/segment_c.cpp +++ b/core/src/dog_segment/segment_c.cpp @@ -177,6 +177,13 @@ IsOpened(CSegmentBase c_segment) { return status == milvus::dog_segment::SegmentBase::SegmentState::Open; } +long int +GetMemoryUsageInBytes(CSegmentBase c_segment) { + auto segment = (milvus::dog_segment::SegmentBase*)c_segment; + auto mem_size = segment->GetMemoryUsageInBytes(); + return mem_size; +} + ////////////////////////////////////////////////////////////////// long int diff --git a/core/src/dog_segment/segment_c.h b/core/src/dog_segment/segment_c.h index 1f29087876..116f6de2e2 100644 --- a/core/src/dog_segment/segment_c.h +++ b/core/src/dog_segment/segment_c.h @@ -73,6 +73,9 @@ BuildIndex(CSegmentBase c_segment); bool IsOpened(CSegmentBase c_segment); +long int +GetMemoryUsageInBytes(CSegmentBase c_segment); + ////////////////////////////////////////////////////////////////// long int diff --git a/core/src/pb/master.pb.cc b/core/src/pb/master.pb.cc new file mode 100644 index 0000000000..513ffd860b --- /dev/null +++ b/core/src/pb/master.pb.cc @@ -0,0 +1,1654 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: master.proto + +#include "master.pb.h" + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +// @@protoc_insertion_point(includes) +#include +extern PROTOBUF_INTERNAL_EXPORT_message_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_Schema_message_2eproto; +namespace masterpb { +class CollectionDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _Collection_default_instance_; +class SegmentDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _Segment_default_instance_; +class SegmentStatDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _SegmentStat_default_instance_; +} // namespace masterpb +static void InitDefaultsscc_info_Collection_master_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::masterpb::_Collection_default_instance_; + new (ptr) ::masterpb::Collection(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::masterpb::Collection::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_Collection_master_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_Collection_master_2eproto}, { + &scc_info_Schema_message_2eproto.base,}}; + +static void InitDefaultsscc_info_Segment_master_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::masterpb::_Segment_default_instance_; + new (ptr) ::masterpb::Segment(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::masterpb::Segment::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_Segment_master_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_Segment_master_2eproto}, {}}; + +static void InitDefaultsscc_info_SegmentStat_master_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::masterpb::_SegmentStat_default_instance_; + new (ptr) ::masterpb::SegmentStat(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::masterpb::SegmentStat::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_SegmentStat_master_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_SegmentStat_master_2eproto}, {}}; + +static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_master_2eproto[3]; +static constexpr ::PROTOBUF_NAMESPACE_ID::EnumDescriptor const** file_level_enum_descriptors_master_2eproto = nullptr; +static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_master_2eproto = nullptr; + +const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_master_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::masterpb::Collection, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::masterpb::Collection, id_), + PROTOBUF_FIELD_OFFSET(::masterpb::Collection, name_), + PROTOBUF_FIELD_OFFSET(::masterpb::Collection, schema_), + PROTOBUF_FIELD_OFFSET(::masterpb::Collection, create_time_), + PROTOBUF_FIELD_OFFSET(::masterpb::Collection, segment_ids_), + PROTOBUF_FIELD_OFFSET(::masterpb::Collection, partition_tags_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::masterpb::Segment, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::masterpb::Segment, segment_id_), + PROTOBUF_FIELD_OFFSET(::masterpb::Segment, collection_id_), + PROTOBUF_FIELD_OFFSET(::masterpb::Segment, partition_tag_), + PROTOBUF_FIELD_OFFSET(::masterpb::Segment, channel_start_), + PROTOBUF_FIELD_OFFSET(::masterpb::Segment, channel_end_), + PROTOBUF_FIELD_OFFSET(::masterpb::Segment, open_timestamp_), + PROTOBUF_FIELD_OFFSET(::masterpb::Segment, close_timestamp_), + PROTOBUF_FIELD_OFFSET(::masterpb::Segment, collection_name_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::masterpb::SegmentStat, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::masterpb::SegmentStat, segment_id_), + PROTOBUF_FIELD_OFFSET(::masterpb::SegmentStat, memory_size_), + PROTOBUF_FIELD_OFFSET(::masterpb::SegmentStat, memory_rate_), +}; +static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { + { 0, -1, sizeof(::masterpb::Collection)}, + { 11, -1, sizeof(::masterpb::Segment)}, + { 24, -1, sizeof(::masterpb::SegmentStat)}, +}; + +static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { + reinterpret_cast(&::masterpb::_Collection_default_instance_), + reinterpret_cast(&::masterpb::_Segment_default_instance_), + reinterpret_cast(&::masterpb::_SegmentStat_default_instance_), +}; + +const char descriptor_table_protodef_master_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = + "\n\014master.proto\022\010masterpb\032\rmessage.proto\"" + "\215\001\n\nCollection\022\n\n\002id\030\001 \001(\004\022\014\n\004name\030\002 \001(\t" + "\022#\n\006schema\030\003 \001(\0132\023.milvus.grpc.Schema\022\023\n" + "\013create_time\030\004 \001(\004\022\023\n\013segment_ids\030\005 \003(\004\022" + "\026\n\016partition_tags\030\006 \003(\t\"\301\001\n\007Segment\022\022\n\ns" + "egment_id\030\001 \001(\004\022\025\n\rcollection_id\030\002 \001(\004\022\025" + "\n\rpartition_tag\030\003 \001(\t\022\025\n\rchannel_start\030\004" + " \001(\005\022\023\n\013channel_end\030\005 \001(\005\022\026\n\016open_timest" + "amp\030\006 \001(\004\022\027\n\017close_timestamp\030\007 \001(\004\022\027\n\017co" + "llection_name\030\010 \001(\t\"K\n\013SegmentStat\022\022\n\nse" + "gment_id\030\001 \001(\004\022\023\n\013memory_size\030\002 \001(\004\022\023\n\013m" + "emory_rate\030\003 \001(\0022I\n\006Master\022\?\n\020CreateColl" + "ection\022\024.milvus.grpc.Mapping\032\023.milvus.gr" + "pc.Status\"\000B\010Z\006masterb\006proto3" + ; +static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_master_2eproto_deps[1] = { + &::descriptor_table_message_2eproto, +}; +static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_master_2eproto_sccs[3] = { + &scc_info_Collection_master_2eproto.base, + &scc_info_Segment_master_2eproto.base, + &scc_info_SegmentStat_master_2eproto.base, +}; +static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_master_2eproto_once; +static bool descriptor_table_master_2eproto_initialized = false; +const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_master_2eproto = { + &descriptor_table_master_2eproto_initialized, descriptor_table_protodef_master_2eproto, "master.proto", 549, + &descriptor_table_master_2eproto_once, descriptor_table_master_2eproto_sccs, descriptor_table_master_2eproto_deps, 3, 1, + schemas, file_default_instances, TableStruct_master_2eproto::offsets, + file_level_metadata_master_2eproto, 3, file_level_enum_descriptors_master_2eproto, file_level_service_descriptors_master_2eproto, +}; + +// Force running AddDescriptors() at dynamic initialization time. +static bool dynamic_init_dummy_master_2eproto = ( ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptors(&descriptor_table_master_2eproto), true); +namespace masterpb { + +// =================================================================== + +void Collection::InitAsDefaultInstance() { + ::masterpb::_Collection_default_instance_._instance.get_mutable()->schema_ = const_cast< ::milvus::grpc::Schema*>( + ::milvus::grpc::Schema::internal_default_instance()); +} +class Collection::_Internal { + public: + static const ::milvus::grpc::Schema& schema(const Collection* msg); +}; + +const ::milvus::grpc::Schema& +Collection::_Internal::schema(const Collection* msg) { + return *msg->schema_; +} +void Collection::clear_schema() { + if (GetArenaNoVirtual() == nullptr && schema_ != nullptr) { + delete schema_; + } + schema_ = nullptr; +} +Collection::Collection() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:masterpb.Collection) +} +Collection::Collection(const Collection& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + segment_ids_(from.segment_ids_), + partition_tags_(from.partition_tags_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.name().empty()) { + name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.name_); + } + if (from.has_schema()) { + schema_ = new ::milvus::grpc::Schema(*from.schema_); + } else { + schema_ = nullptr; + } + ::memcpy(&id_, &from.id_, + static_cast(reinterpret_cast(&create_time_) - + reinterpret_cast(&id_)) + sizeof(create_time_)); + // @@protoc_insertion_point(copy_constructor:masterpb.Collection) +} + +void Collection::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Collection_master_2eproto.base); + name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + ::memset(&schema_, 0, static_cast( + reinterpret_cast(&create_time_) - + reinterpret_cast(&schema_)) + sizeof(create_time_)); +} + +Collection::~Collection() { + // @@protoc_insertion_point(destructor:masterpb.Collection) + SharedDtor(); +} + +void Collection::SharedDtor() { + name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (this != internal_default_instance()) delete schema_; +} + +void Collection::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const Collection& Collection::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_Collection_master_2eproto.base); + return *internal_default_instance(); +} + + +void Collection::Clear() { +// @@protoc_insertion_point(message_clear_start:masterpb.Collection) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + segment_ids_.Clear(); + partition_tags_.Clear(); + name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (GetArenaNoVirtual() == nullptr && schema_ != nullptr) { + delete schema_; + } + schema_ = nullptr; + ::memset(&id_, 0, static_cast( + reinterpret_cast(&create_time_) - + reinterpret_cast(&id_)) + sizeof(create_time_)); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* Collection::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // uint64 id = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // string name = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_name(), ptr, ctx, "masterpb.Collection.name"); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .milvus.grpc.Schema schema = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr = ctx->ParseMessage(mutable_schema(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // uint64 create_time = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) { + create_time_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated uint64 segment_ids = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt64Parser(mutable_segment_ids(), ptr, ctx); + CHK_(ptr); + } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40) { + add_segment_ids(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr)); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated string partition_tags = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) { + ptr -= 1; + do { + ptr += 1; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(add_partition_tags(), ptr, ctx, "masterpb.Collection.partition_tags"); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 50); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool Collection::MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + // @@protoc_insertion_point(parse_start:masterpb.Collection) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // uint64 id = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>( + input, &id_))); + } else { + goto handle_unusual; + } + break; + } + + // string name = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_name())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->name().data(), static_cast(this->name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "masterpb.Collection.name")); + } else { + goto handle_unusual; + } + break; + } + + // .milvus.grpc.Schema schema = 3; + case 3: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, mutable_schema())); + } else { + goto handle_unusual; + } + break; + } + + // uint64 create_time = 4; + case 4: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (32 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>( + input, &create_time_))); + } else { + goto handle_unusual; + } + break; + } + + // repeated uint64 segment_ids = 5; + case 5: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (42 & 0xFF)) { + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPackedPrimitive< + ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>( + input, this->mutable_segment_ids()))); + } else if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (40 & 0xFF)) { + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< + ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>( + 1, 42u, input, this->mutable_segment_ids()))); + } else { + goto handle_unusual; + } + break; + } + + // repeated string partition_tags = 6; + case 6: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (50 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->add_partition_tags())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->partition_tags(this->partition_tags_size() - 1).data(), + static_cast(this->partition_tags(this->partition_tags_size() - 1).length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "masterpb.Collection.partition_tags")); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:masterpb.Collection) + return true; +failure: + // @@protoc_insertion_point(parse_failure:masterpb.Collection) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void Collection::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:masterpb.Collection) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // uint64 id = 1; + if (this->id() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(1, this->id(), output); + } + + // string name = 2; + if (this->name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->name().data(), static_cast(this->name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "masterpb.Collection.name"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 2, this->name(), output); + } + + // .milvus.grpc.Schema schema = 3; + if (this->has_schema()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 3, _Internal::schema(this), output); + } + + // uint64 create_time = 4; + if (this->create_time() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(4, this->create_time(), output); + } + + // repeated uint64 segment_ids = 5; + if (this->segment_ids_size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTag(5, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(_segment_ids_cached_byte_size_.load( + std::memory_order_relaxed)); + } + for (int i = 0, n = this->segment_ids_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64NoTag( + this->segment_ids(i), output); + } + + // repeated string partition_tags = 6; + for (int i = 0, n = this->partition_tags_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->partition_tags(i).data(), static_cast(this->partition_tags(i).length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "masterpb.Collection.partition_tags"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteString( + 6, this->partition_tags(i), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:masterpb.Collection) +} + +::PROTOBUF_NAMESPACE_ID::uint8* Collection::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:masterpb.Collection) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // uint64 id = 1; + if (this->id() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(1, this->id(), target); + } + + // string name = 2; + if (this->name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->name().data(), static_cast(this->name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "masterpb.Collection.name"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 2, this->name(), target); + } + + // .milvus.grpc.Schema schema = 3; + if (this->has_schema()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 3, _Internal::schema(this), target); + } + + // uint64 create_time = 4; + if (this->create_time() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(4, this->create_time(), target); + } + + // repeated uint64 segment_ids = 5; + if (this->segment_ids_size() > 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTagToArray( + 5, + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + target); + target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray( + _segment_ids_cached_byte_size_.load(std::memory_order_relaxed), + target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + WriteUInt64NoTagToArray(this->segment_ids_, target); + } + + // repeated string partition_tags = 6; + for (int i = 0, n = this->partition_tags_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->partition_tags(i).data(), static_cast(this->partition_tags(i).length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "masterpb.Collection.partition_tags"); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + WriteStringToArray(6, this->partition_tags(i), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:masterpb.Collection) + return target; +} + +size_t Collection::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:masterpb.Collection) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated uint64 segment_ids = 5; + { + size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + UInt64Size(this->segment_ids_); + if (data_size > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size)); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size); + _segment_ids_cached_byte_size_.store(cached_size, + std::memory_order_relaxed); + total_size += data_size; + } + + // repeated string partition_tags = 6; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->partition_tags_size()); + for (int i = 0, n = this->partition_tags_size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->partition_tags(i)); + } + + // string name = 2; + if (this->name().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->name()); + } + + // .milvus.grpc.Schema schema = 3; + if (this->has_schema()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *schema_); + } + + // uint64 id = 1; + if (this->id() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size( + this->id()); + } + + // uint64 create_time = 4; + if (this->create_time() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size( + this->create_time()); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Collection::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:masterpb.Collection) + GOOGLE_DCHECK_NE(&from, this); + const Collection* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:masterpb.Collection) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:masterpb.Collection) + MergeFrom(*source); + } +} + +void Collection::MergeFrom(const Collection& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:masterpb.Collection) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + segment_ids_.MergeFrom(from.segment_ids_); + partition_tags_.MergeFrom(from.partition_tags_); + if (from.name().size() > 0) { + + name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.name_); + } + if (from.has_schema()) { + mutable_schema()->::milvus::grpc::Schema::MergeFrom(from.schema()); + } + if (from.id() != 0) { + set_id(from.id()); + } + if (from.create_time() != 0) { + set_create_time(from.create_time()); + } +} + +void Collection::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:masterpb.Collection) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Collection::CopyFrom(const Collection& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:masterpb.Collection) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Collection::IsInitialized() const { + return true; +} + +void Collection::InternalSwap(Collection* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + segment_ids_.InternalSwap(&other->segment_ids_); + partition_tags_.InternalSwap(CastToBase(&other->partition_tags_)); + name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(schema_, other->schema_); + swap(id_, other->id_); + swap(create_time_, other->create_time_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Collection::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void Segment::InitAsDefaultInstance() { +} +class Segment::_Internal { + public: +}; + +Segment::Segment() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:masterpb.Segment) +} +Segment::Segment(const Segment& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + partition_tag_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.partition_tag().empty()) { + partition_tag_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.partition_tag_); + } + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.collection_name().empty()) { + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); + } + ::memcpy(&segment_id_, &from.segment_id_, + static_cast(reinterpret_cast(&close_timestamp_) - + reinterpret_cast(&segment_id_)) + sizeof(close_timestamp_)); + // @@protoc_insertion_point(copy_constructor:masterpb.Segment) +} + +void Segment::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Segment_master_2eproto.base); + partition_tag_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + ::memset(&segment_id_, 0, static_cast( + reinterpret_cast(&close_timestamp_) - + reinterpret_cast(&segment_id_)) + sizeof(close_timestamp_)); +} + +Segment::~Segment() { + // @@protoc_insertion_point(destructor:masterpb.Segment) + SharedDtor(); +} + +void Segment::SharedDtor() { + partition_tag_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + collection_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void Segment::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const Segment& Segment::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_Segment_master_2eproto.base); + return *internal_default_instance(); +} + + +void Segment::Clear() { +// @@protoc_insertion_point(message_clear_start:masterpb.Segment) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + partition_tag_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + ::memset(&segment_id_, 0, static_cast( + reinterpret_cast(&close_timestamp_) - + reinterpret_cast(&segment_id_)) + sizeof(close_timestamp_)); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* Segment::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // uint64 segment_id = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + segment_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // uint64 collection_id = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + collection_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // string partition_tag = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_partition_tag(), ptr, ctx, "masterpb.Segment.partition_tag"); + CHK_(ptr); + } else goto handle_unusual; + continue; + // int32 channel_start = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) { + channel_start_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // int32 channel_end = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) { + channel_end_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // uint64 open_timestamp = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 48)) { + open_timestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // uint64 close_timestamp = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 56)) { + close_timestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // string collection_name = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_collection_name(), ptr, ctx, "masterpb.Segment.collection_name"); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool Segment::MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + // @@protoc_insertion_point(parse_start:masterpb.Segment) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // uint64 segment_id = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>( + input, &segment_id_))); + } else { + goto handle_unusual; + } + break; + } + + // uint64 collection_id = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>( + input, &collection_id_))); + } else { + goto handle_unusual; + } + break; + } + + // string partition_tag = 3; + case 3: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_partition_tag())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->partition_tag().data(), static_cast(this->partition_tag().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "masterpb.Segment.partition_tag")); + } else { + goto handle_unusual; + } + break; + } + + // int32 channel_start = 4; + case 4: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (32 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + ::PROTOBUF_NAMESPACE_ID::int32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32>( + input, &channel_start_))); + } else { + goto handle_unusual; + } + break; + } + + // int32 channel_end = 5; + case 5: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (40 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + ::PROTOBUF_NAMESPACE_ID::int32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32>( + input, &channel_end_))); + } else { + goto handle_unusual; + } + break; + } + + // uint64 open_timestamp = 6; + case 6: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (48 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>( + input, &open_timestamp_))); + } else { + goto handle_unusual; + } + break; + } + + // uint64 close_timestamp = 7; + case 7: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (56 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>( + input, &close_timestamp_))); + } else { + goto handle_unusual; + } + break; + } + + // string collection_name = 8; + case 8: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (66 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_collection_name())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "masterpb.Segment.collection_name")); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:masterpb.Segment) + return true; +failure: + // @@protoc_insertion_point(parse_failure:masterpb.Segment) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void Segment::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:masterpb.Segment) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // uint64 segment_id = 1; + if (this->segment_id() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(1, this->segment_id(), output); + } + + // uint64 collection_id = 2; + if (this->collection_id() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(2, this->collection_id(), output); + } + + // string partition_tag = 3; + if (this->partition_tag().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->partition_tag().data(), static_cast(this->partition_tag().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "masterpb.Segment.partition_tag"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 3, this->partition_tag(), output); + } + + // int32 channel_start = 4; + if (this->channel_start() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32(4, this->channel_start(), output); + } + + // int32 channel_end = 5; + if (this->channel_end() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32(5, this->channel_end(), output); + } + + // uint64 open_timestamp = 6; + if (this->open_timestamp() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(6, this->open_timestamp(), output); + } + + // uint64 close_timestamp = 7; + if (this->close_timestamp() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(7, this->close_timestamp(), output); + } + + // string collection_name = 8; + if (this->collection_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "masterpb.Segment.collection_name"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 8, this->collection_name(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:masterpb.Segment) +} + +::PROTOBUF_NAMESPACE_ID::uint8* Segment::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:masterpb.Segment) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // uint64 segment_id = 1; + if (this->segment_id() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(1, this->segment_id(), target); + } + + // uint64 collection_id = 2; + if (this->collection_id() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(2, this->collection_id(), target); + } + + // string partition_tag = 3; + if (this->partition_tag().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->partition_tag().data(), static_cast(this->partition_tag().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "masterpb.Segment.partition_tag"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 3, this->partition_tag(), target); + } + + // int32 channel_start = 4; + if (this->channel_start() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(4, this->channel_start(), target); + } + + // int32 channel_end = 5; + if (this->channel_end() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(5, this->channel_end(), target); + } + + // uint64 open_timestamp = 6; + if (this->open_timestamp() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(6, this->open_timestamp(), target); + } + + // uint64 close_timestamp = 7; + if (this->close_timestamp() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(7, this->close_timestamp(), target); + } + + // string collection_name = 8; + if (this->collection_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "masterpb.Segment.collection_name"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 8, this->collection_name(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:masterpb.Segment) + return target; +} + +size_t Segment::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:masterpb.Segment) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // string partition_tag = 3; + if (this->partition_tag().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->partition_tag()); + } + + // string collection_name = 8; + if (this->collection_name().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->collection_name()); + } + + // uint64 segment_id = 1; + if (this->segment_id() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size( + this->segment_id()); + } + + // uint64 collection_id = 2; + if (this->collection_id() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size( + this->collection_id()); + } + + // int32 channel_start = 4; + if (this->channel_start() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + this->channel_start()); + } + + // int32 channel_end = 5; + if (this->channel_end() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + this->channel_end()); + } + + // uint64 open_timestamp = 6; + if (this->open_timestamp() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size( + this->open_timestamp()); + } + + // uint64 close_timestamp = 7; + if (this->close_timestamp() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size( + this->close_timestamp()); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Segment::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:masterpb.Segment) + GOOGLE_DCHECK_NE(&from, this); + const Segment* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:masterpb.Segment) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:masterpb.Segment) + MergeFrom(*source); + } +} + +void Segment::MergeFrom(const Segment& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:masterpb.Segment) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.partition_tag().size() > 0) { + + partition_tag_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.partition_tag_); + } + if (from.collection_name().size() > 0) { + + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); + } + if (from.segment_id() != 0) { + set_segment_id(from.segment_id()); + } + if (from.collection_id() != 0) { + set_collection_id(from.collection_id()); + } + if (from.channel_start() != 0) { + set_channel_start(from.channel_start()); + } + if (from.channel_end() != 0) { + set_channel_end(from.channel_end()); + } + if (from.open_timestamp() != 0) { + set_open_timestamp(from.open_timestamp()); + } + if (from.close_timestamp() != 0) { + set_close_timestamp(from.close_timestamp()); + } +} + +void Segment::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:masterpb.Segment) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Segment::CopyFrom(const Segment& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:masterpb.Segment) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Segment::IsInitialized() const { + return true; +} + +void Segment::InternalSwap(Segment* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + partition_tag_.Swap(&other->partition_tag_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + collection_name_.Swap(&other->collection_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(segment_id_, other->segment_id_); + swap(collection_id_, other->collection_id_); + swap(channel_start_, other->channel_start_); + swap(channel_end_, other->channel_end_); + swap(open_timestamp_, other->open_timestamp_); + swap(close_timestamp_, other->close_timestamp_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Segment::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void SegmentStat::InitAsDefaultInstance() { +} +class SegmentStat::_Internal { + public: +}; + +SegmentStat::SegmentStat() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:masterpb.SegmentStat) +} +SegmentStat::SegmentStat(const SegmentStat& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::memcpy(&segment_id_, &from.segment_id_, + static_cast(reinterpret_cast(&memory_rate_) - + reinterpret_cast(&segment_id_)) + sizeof(memory_rate_)); + // @@protoc_insertion_point(copy_constructor:masterpb.SegmentStat) +} + +void SegmentStat::SharedCtor() { + ::memset(&segment_id_, 0, static_cast( + reinterpret_cast(&memory_rate_) - + reinterpret_cast(&segment_id_)) + sizeof(memory_rate_)); +} + +SegmentStat::~SegmentStat() { + // @@protoc_insertion_point(destructor:masterpb.SegmentStat) + SharedDtor(); +} + +void SegmentStat::SharedDtor() { +} + +void SegmentStat::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const SegmentStat& SegmentStat::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_SegmentStat_master_2eproto.base); + return *internal_default_instance(); +} + + +void SegmentStat::Clear() { +// @@protoc_insertion_point(message_clear_start:masterpb.SegmentStat) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + ::memset(&segment_id_, 0, static_cast( + reinterpret_cast(&memory_rate_) - + reinterpret_cast(&segment_id_)) + sizeof(memory_rate_)); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* SegmentStat::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // uint64 segment_id = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + segment_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // uint64 memory_size = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + memory_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // float memory_rate = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 29)) { + memory_rate_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool SegmentStat::MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + // @@protoc_insertion_point(parse_start:masterpb.SegmentStat) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // uint64 segment_id = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>( + input, &segment_id_))); + } else { + goto handle_unusual; + } + break; + } + + // uint64 memory_size = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>( + input, &memory_size_))); + } else { + goto handle_unusual; + } + break; + } + + // float memory_rate = 3; + case 3: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (29 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>( + input, &memory_rate_))); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:masterpb.SegmentStat) + return true; +failure: + // @@protoc_insertion_point(parse_failure:masterpb.SegmentStat) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void SegmentStat::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:masterpb.SegmentStat) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // uint64 segment_id = 1; + if (this->segment_id() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(1, this->segment_id(), output); + } + + // uint64 memory_size = 2; + if (this->memory_size() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(2, this->memory_size(), output); + } + + // float memory_rate = 3; + if (!(this->memory_rate() <= 0 && this->memory_rate() >= 0)) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloat(3, this->memory_rate(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:masterpb.SegmentStat) +} + +::PROTOBUF_NAMESPACE_ID::uint8* SegmentStat::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:masterpb.SegmentStat) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // uint64 segment_id = 1; + if (this->segment_id() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(1, this->segment_id(), target); + } + + // uint64 memory_size = 2; + if (this->memory_size() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(2, this->memory_size(), target); + } + + // float memory_rate = 3; + if (!(this->memory_rate() <= 0 && this->memory_rate() >= 0)) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(3, this->memory_rate(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:masterpb.SegmentStat) + return target; +} + +size_t SegmentStat::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:masterpb.SegmentStat) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // uint64 segment_id = 1; + if (this->segment_id() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size( + this->segment_id()); + } + + // uint64 memory_size = 2; + if (this->memory_size() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size( + this->memory_size()); + } + + // float memory_rate = 3; + if (!(this->memory_rate() <= 0 && this->memory_rate() >= 0)) { + total_size += 1 + 4; + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void SegmentStat::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:masterpb.SegmentStat) + GOOGLE_DCHECK_NE(&from, this); + const SegmentStat* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:masterpb.SegmentStat) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:masterpb.SegmentStat) + MergeFrom(*source); + } +} + +void SegmentStat::MergeFrom(const SegmentStat& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:masterpb.SegmentStat) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.segment_id() != 0) { + set_segment_id(from.segment_id()); + } + if (from.memory_size() != 0) { + set_memory_size(from.memory_size()); + } + if (!(from.memory_rate() <= 0 && from.memory_rate() >= 0)) { + set_memory_rate(from.memory_rate()); + } +} + +void SegmentStat::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:masterpb.SegmentStat) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void SegmentStat::CopyFrom(const SegmentStat& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:masterpb.SegmentStat) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SegmentStat::IsInitialized() const { + return true; +} + +void SegmentStat::InternalSwap(SegmentStat* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(segment_id_, other->segment_id_); + swap(memory_size_, other->memory_size_); + swap(memory_rate_, other->memory_rate_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SegmentStat::GetMetadata() const { + return GetMetadataStatic(); +} + + +// @@protoc_insertion_point(namespace_scope) +} // namespace masterpb +PROTOBUF_NAMESPACE_OPEN +template<> PROTOBUF_NOINLINE ::masterpb::Collection* Arena::CreateMaybeMessage< ::masterpb::Collection >(Arena* arena) { + return Arena::CreateInternal< ::masterpb::Collection >(arena); +} +template<> PROTOBUF_NOINLINE ::masterpb::Segment* Arena::CreateMaybeMessage< ::masterpb::Segment >(Arena* arena) { + return Arena::CreateInternal< ::masterpb::Segment >(arena); +} +template<> PROTOBUF_NOINLINE ::masterpb::SegmentStat* Arena::CreateMaybeMessage< ::masterpb::SegmentStat >(Arena* arena) { + return Arena::CreateInternal< ::masterpb::SegmentStat >(arena); +} +PROTOBUF_NAMESPACE_CLOSE + +// @@protoc_insertion_point(global_scope) +#include diff --git a/core/src/pb/master.pb.h b/core/src/pb/master.pb.h new file mode 100644 index 0000000000..89f3eeb8cc --- /dev/null +++ b/core/src/pb/master.pb.h @@ -0,0 +1,1088 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: master.proto + +#ifndef GOOGLE_PROTOBUF_INCLUDED_master_2eproto +#define GOOGLE_PROTOBUF_INCLUDED_master_2eproto + +#include +#include + +#include +#if PROTOBUF_VERSION < 3009000 +#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 3009000 < 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include // IWYU pragma: export +#include // IWYU pragma: export +#include +#include "message.pb.h" +// @@protoc_insertion_point(includes) +#include +#define PROTOBUF_INTERNAL_EXPORT_master_2eproto +PROTOBUF_NAMESPACE_OPEN +namespace internal { +class AnyMetadata; +} // namespace internal +PROTOBUF_NAMESPACE_CLOSE + +// Internal implementation detail -- do not use these members. +struct TableStruct_master_2eproto { + static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[] + PROTOBUF_SECTION_VARIABLE(protodesc_cold); + static const ::PROTOBUF_NAMESPACE_ID::internal::AuxillaryParseTableField aux[] + PROTOBUF_SECTION_VARIABLE(protodesc_cold); + static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[3] + PROTOBUF_SECTION_VARIABLE(protodesc_cold); + static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[]; + static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[]; + static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[]; +}; +extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_master_2eproto; +namespace masterpb { +class Collection; +class CollectionDefaultTypeInternal; +extern CollectionDefaultTypeInternal _Collection_default_instance_; +class Segment; +class SegmentDefaultTypeInternal; +extern SegmentDefaultTypeInternal _Segment_default_instance_; +class SegmentStat; +class SegmentStatDefaultTypeInternal; +extern SegmentStatDefaultTypeInternal _SegmentStat_default_instance_; +} // namespace masterpb +PROTOBUF_NAMESPACE_OPEN +template<> ::masterpb::Collection* Arena::CreateMaybeMessage<::masterpb::Collection>(Arena*); +template<> ::masterpb::Segment* Arena::CreateMaybeMessage<::masterpb::Segment>(Arena*); +template<> ::masterpb::SegmentStat* Arena::CreateMaybeMessage<::masterpb::SegmentStat>(Arena*); +PROTOBUF_NAMESPACE_CLOSE +namespace masterpb { + +// =================================================================== + +class Collection : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:masterpb.Collection) */ { + public: + Collection(); + virtual ~Collection(); + + Collection(const Collection& from); + Collection(Collection&& from) noexcept + : Collection() { + *this = ::std::move(from); + } + + inline Collection& operator=(const Collection& from) { + CopyFrom(from); + return *this; + } + inline Collection& operator=(Collection&& from) noexcept { + if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const Collection& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const Collection* internal_default_instance() { + return reinterpret_cast( + &_Collection_default_instance_); + } + static constexpr int kIndexInFileMessages = + 0; + + friend void swap(Collection& a, Collection& b) { + a.Swap(&b); + } + inline void Swap(Collection* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Collection* New() const final { + return CreateMaybeMessage(nullptr); + } + + Collection* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Collection& from); + void MergeFrom(const Collection& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + #else + bool MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final; + #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + void SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final; + ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Collection* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "masterpb.Collection"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_master_2eproto); + return ::descriptor_table_master_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kSegmentIdsFieldNumber = 5, + kPartitionTagsFieldNumber = 6, + kNameFieldNumber = 2, + kSchemaFieldNumber = 3, + kIdFieldNumber = 1, + kCreateTimeFieldNumber = 4, + }; + // repeated uint64 segment_ids = 5; + int segment_ids_size() const; + void clear_segment_ids(); + ::PROTOBUF_NAMESPACE_ID::uint64 segment_ids(int index) const; + void set_segment_ids(int index, ::PROTOBUF_NAMESPACE_ID::uint64 value); + void add_segment_ids(::PROTOBUF_NAMESPACE_ID::uint64 value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint64 >& + segment_ids() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint64 >* + mutable_segment_ids(); + + // repeated string partition_tags = 6; + int partition_tags_size() const; + void clear_partition_tags(); + const std::string& partition_tags(int index) const; + std::string* mutable_partition_tags(int index); + void set_partition_tags(int index, const std::string& value); + void set_partition_tags(int index, std::string&& value); + void set_partition_tags(int index, const char* value); + void set_partition_tags(int index, const char* value, size_t size); + std::string* add_partition_tags(); + void add_partition_tags(const std::string& value); + void add_partition_tags(std::string&& value); + void add_partition_tags(const char* value); + void add_partition_tags(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& partition_tags() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_partition_tags(); + + // string name = 2; + void clear_name(); + const std::string& name() const; + void set_name(const std::string& value); + void set_name(std::string&& value); + void set_name(const char* value); + void set_name(const char* value, size_t size); + std::string* mutable_name(); + std::string* release_name(); + void set_allocated_name(std::string* name); + + // .milvus.grpc.Schema schema = 3; + bool has_schema() const; + void clear_schema(); + const ::milvus::grpc::Schema& schema() const; + ::milvus::grpc::Schema* release_schema(); + ::milvus::grpc::Schema* mutable_schema(); + void set_allocated_schema(::milvus::grpc::Schema* schema); + + // uint64 id = 1; + void clear_id(); + ::PROTOBUF_NAMESPACE_ID::uint64 id() const; + void set_id(::PROTOBUF_NAMESPACE_ID::uint64 value); + + // uint64 create_time = 4; + void clear_create_time(); + ::PROTOBUF_NAMESPACE_ID::uint64 create_time() const; + void set_create_time(::PROTOBUF_NAMESPACE_ID::uint64 value); + + // @@protoc_insertion_point(class_scope:masterpb.Collection) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint64 > segment_ids_; + mutable std::atomic _segment_ids_cached_byte_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField partition_tags_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; + ::milvus::grpc::Schema* schema_; + ::PROTOBUF_NAMESPACE_ID::uint64 id_; + ::PROTOBUF_NAMESPACE_ID::uint64 create_time_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_master_2eproto; +}; +// ------------------------------------------------------------------- + +class Segment : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:masterpb.Segment) */ { + public: + Segment(); + virtual ~Segment(); + + Segment(const Segment& from); + Segment(Segment&& from) noexcept + : Segment() { + *this = ::std::move(from); + } + + inline Segment& operator=(const Segment& from) { + CopyFrom(from); + return *this; + } + inline Segment& operator=(Segment&& from) noexcept { + if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const Segment& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const Segment* internal_default_instance() { + return reinterpret_cast( + &_Segment_default_instance_); + } + static constexpr int kIndexInFileMessages = + 1; + + friend void swap(Segment& a, Segment& b) { + a.Swap(&b); + } + inline void Swap(Segment* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Segment* New() const final { + return CreateMaybeMessage(nullptr); + } + + Segment* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Segment& from); + void MergeFrom(const Segment& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + #else + bool MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final; + #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + void SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final; + ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Segment* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "masterpb.Segment"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_master_2eproto); + return ::descriptor_table_master_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kPartitionTagFieldNumber = 3, + kCollectionNameFieldNumber = 8, + kSegmentIdFieldNumber = 1, + kCollectionIdFieldNumber = 2, + kChannelStartFieldNumber = 4, + kChannelEndFieldNumber = 5, + kOpenTimestampFieldNumber = 6, + kCloseTimestampFieldNumber = 7, + }; + // string partition_tag = 3; + void clear_partition_tag(); + const std::string& partition_tag() const; + void set_partition_tag(const std::string& value); + void set_partition_tag(std::string&& value); + void set_partition_tag(const char* value); + void set_partition_tag(const char* value, size_t size); + std::string* mutable_partition_tag(); + std::string* release_partition_tag(); + void set_allocated_partition_tag(std::string* partition_tag); + + // string collection_name = 8; + void clear_collection_name(); + const std::string& collection_name() const; + void set_collection_name(const std::string& value); + void set_collection_name(std::string&& value); + void set_collection_name(const char* value); + void set_collection_name(const char* value, size_t size); + std::string* mutable_collection_name(); + std::string* release_collection_name(); + void set_allocated_collection_name(std::string* collection_name); + + // uint64 segment_id = 1; + void clear_segment_id(); + ::PROTOBUF_NAMESPACE_ID::uint64 segment_id() const; + void set_segment_id(::PROTOBUF_NAMESPACE_ID::uint64 value); + + // uint64 collection_id = 2; + void clear_collection_id(); + ::PROTOBUF_NAMESPACE_ID::uint64 collection_id() const; + void set_collection_id(::PROTOBUF_NAMESPACE_ID::uint64 value); + + // int32 channel_start = 4; + void clear_channel_start(); + ::PROTOBUF_NAMESPACE_ID::int32 channel_start() const; + void set_channel_start(::PROTOBUF_NAMESPACE_ID::int32 value); + + // int32 channel_end = 5; + void clear_channel_end(); + ::PROTOBUF_NAMESPACE_ID::int32 channel_end() const; + void set_channel_end(::PROTOBUF_NAMESPACE_ID::int32 value); + + // uint64 open_timestamp = 6; + void clear_open_timestamp(); + ::PROTOBUF_NAMESPACE_ID::uint64 open_timestamp() const; + void set_open_timestamp(::PROTOBUF_NAMESPACE_ID::uint64 value); + + // uint64 close_timestamp = 7; + void clear_close_timestamp(); + ::PROTOBUF_NAMESPACE_ID::uint64 close_timestamp() const; + void set_close_timestamp(::PROTOBUF_NAMESPACE_ID::uint64 value); + + // @@protoc_insertion_point(class_scope:masterpb.Segment) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr partition_tag_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collection_name_; + ::PROTOBUF_NAMESPACE_ID::uint64 segment_id_; + ::PROTOBUF_NAMESPACE_ID::uint64 collection_id_; + ::PROTOBUF_NAMESPACE_ID::int32 channel_start_; + ::PROTOBUF_NAMESPACE_ID::int32 channel_end_; + ::PROTOBUF_NAMESPACE_ID::uint64 open_timestamp_; + ::PROTOBUF_NAMESPACE_ID::uint64 close_timestamp_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_master_2eproto; +}; +// ------------------------------------------------------------------- + +class SegmentStat : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:masterpb.SegmentStat) */ { + public: + SegmentStat(); + virtual ~SegmentStat(); + + SegmentStat(const SegmentStat& from); + SegmentStat(SegmentStat&& from) noexcept + : SegmentStat() { + *this = ::std::move(from); + } + + inline SegmentStat& operator=(const SegmentStat& from) { + CopyFrom(from); + return *this; + } + inline SegmentStat& operator=(SegmentStat&& from) noexcept { + if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const SegmentStat& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const SegmentStat* internal_default_instance() { + return reinterpret_cast( + &_SegmentStat_default_instance_); + } + static constexpr int kIndexInFileMessages = + 2; + + friend void swap(SegmentStat& a, SegmentStat& b) { + a.Swap(&b); + } + inline void Swap(SegmentStat* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline SegmentStat* New() const final { + return CreateMaybeMessage(nullptr); + } + + SegmentStat* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const SegmentStat& from); + void MergeFrom(const SegmentStat& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + #else + bool MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final; + #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + void SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final; + ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(SegmentStat* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "masterpb.SegmentStat"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_master_2eproto); + return ::descriptor_table_master_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kSegmentIdFieldNumber = 1, + kMemorySizeFieldNumber = 2, + kMemoryRateFieldNumber = 3, + }; + // uint64 segment_id = 1; + void clear_segment_id(); + ::PROTOBUF_NAMESPACE_ID::uint64 segment_id() const; + void set_segment_id(::PROTOBUF_NAMESPACE_ID::uint64 value); + + // uint64 memory_size = 2; + void clear_memory_size(); + ::PROTOBUF_NAMESPACE_ID::uint64 memory_size() const; + void set_memory_size(::PROTOBUF_NAMESPACE_ID::uint64 value); + + // float memory_rate = 3; + void clear_memory_rate(); + float memory_rate() const; + void set_memory_rate(float value); + + // @@protoc_insertion_point(class_scope:masterpb.SegmentStat) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::uint64 segment_id_; + ::PROTOBUF_NAMESPACE_ID::uint64 memory_size_; + float memory_rate_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_master_2eproto; +}; +// =================================================================== + + +// =================================================================== + +#ifdef __GNUC__ + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wstrict-aliasing" +#endif // __GNUC__ +// Collection + +// uint64 id = 1; +inline void Collection::clear_id() { + id_ = PROTOBUF_ULONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::uint64 Collection::id() const { + // @@protoc_insertion_point(field_get:masterpb.Collection.id) + return id_; +} +inline void Collection::set_id(::PROTOBUF_NAMESPACE_ID::uint64 value) { + + id_ = value; + // @@protoc_insertion_point(field_set:masterpb.Collection.id) +} + +// string name = 2; +inline void Collection::clear_name() { + name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& Collection::name() const { + // @@protoc_insertion_point(field_get:masterpb.Collection.name) + return name_.GetNoArena(); +} +inline void Collection::set_name(const std::string& value) { + + name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:masterpb.Collection.name) +} +inline void Collection::set_name(std::string&& value) { + + name_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:masterpb.Collection.name) +} +inline void Collection::set_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:masterpb.Collection.name) +} +inline void Collection::set_name(const char* value, size_t size) { + + name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:masterpb.Collection.name) +} +inline std::string* Collection::mutable_name() { + + // @@protoc_insertion_point(field_mutable:masterpb.Collection.name) + return name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* Collection::release_name() { + // @@protoc_insertion_point(field_release:masterpb.Collection.name) + + return name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void Collection::set_allocated_name(std::string* name) { + if (name != nullptr) { + + } else { + + } + name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name); + // @@protoc_insertion_point(field_set_allocated:masterpb.Collection.name) +} + +// .milvus.grpc.Schema schema = 3; +inline bool Collection::has_schema() const { + return this != internal_default_instance() && schema_ != nullptr; +} +inline const ::milvus::grpc::Schema& Collection::schema() const { + const ::milvus::grpc::Schema* p = schema_; + // @@protoc_insertion_point(field_get:masterpb.Collection.schema) + return p != nullptr ? *p : *reinterpret_cast( + &::milvus::grpc::_Schema_default_instance_); +} +inline ::milvus::grpc::Schema* Collection::release_schema() { + // @@protoc_insertion_point(field_release:masterpb.Collection.schema) + + ::milvus::grpc::Schema* temp = schema_; + schema_ = nullptr; + return temp; +} +inline ::milvus::grpc::Schema* Collection::mutable_schema() { + + if (schema_ == nullptr) { + auto* p = CreateMaybeMessage<::milvus::grpc::Schema>(GetArenaNoVirtual()); + schema_ = p; + } + // @@protoc_insertion_point(field_mutable:masterpb.Collection.schema) + return schema_; +} +inline void Collection::set_allocated_schema(::milvus::grpc::Schema* schema) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(schema_); + } + if (schema) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + schema = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, schema, submessage_arena); + } + + } else { + + } + schema_ = schema; + // @@protoc_insertion_point(field_set_allocated:masterpb.Collection.schema) +} + +// uint64 create_time = 4; +inline void Collection::clear_create_time() { + create_time_ = PROTOBUF_ULONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::uint64 Collection::create_time() const { + // @@protoc_insertion_point(field_get:masterpb.Collection.create_time) + return create_time_; +} +inline void Collection::set_create_time(::PROTOBUF_NAMESPACE_ID::uint64 value) { + + create_time_ = value; + // @@protoc_insertion_point(field_set:masterpb.Collection.create_time) +} + +// repeated uint64 segment_ids = 5; +inline int Collection::segment_ids_size() const { + return segment_ids_.size(); +} +inline void Collection::clear_segment_ids() { + segment_ids_.Clear(); +} +inline ::PROTOBUF_NAMESPACE_ID::uint64 Collection::segment_ids(int index) const { + // @@protoc_insertion_point(field_get:masterpb.Collection.segment_ids) + return segment_ids_.Get(index); +} +inline void Collection::set_segment_ids(int index, ::PROTOBUF_NAMESPACE_ID::uint64 value) { + segment_ids_.Set(index, value); + // @@protoc_insertion_point(field_set:masterpb.Collection.segment_ids) +} +inline void Collection::add_segment_ids(::PROTOBUF_NAMESPACE_ID::uint64 value) { + segment_ids_.Add(value); + // @@protoc_insertion_point(field_add:masterpb.Collection.segment_ids) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint64 >& +Collection::segment_ids() const { + // @@protoc_insertion_point(field_list:masterpb.Collection.segment_ids) + return segment_ids_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint64 >* +Collection::mutable_segment_ids() { + // @@protoc_insertion_point(field_mutable_list:masterpb.Collection.segment_ids) + return &segment_ids_; +} + +// repeated string partition_tags = 6; +inline int Collection::partition_tags_size() const { + return partition_tags_.size(); +} +inline void Collection::clear_partition_tags() { + partition_tags_.Clear(); +} +inline const std::string& Collection::partition_tags(int index) const { + // @@protoc_insertion_point(field_get:masterpb.Collection.partition_tags) + return partition_tags_.Get(index); +} +inline std::string* Collection::mutable_partition_tags(int index) { + // @@protoc_insertion_point(field_mutable:masterpb.Collection.partition_tags) + return partition_tags_.Mutable(index); +} +inline void Collection::set_partition_tags(int index, const std::string& value) { + // @@protoc_insertion_point(field_set:masterpb.Collection.partition_tags) + partition_tags_.Mutable(index)->assign(value); +} +inline void Collection::set_partition_tags(int index, std::string&& value) { + // @@protoc_insertion_point(field_set:masterpb.Collection.partition_tags) + partition_tags_.Mutable(index)->assign(std::move(value)); +} +inline void Collection::set_partition_tags(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + partition_tags_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:masterpb.Collection.partition_tags) +} +inline void Collection::set_partition_tags(int index, const char* value, size_t size) { + partition_tags_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:masterpb.Collection.partition_tags) +} +inline std::string* Collection::add_partition_tags() { + // @@protoc_insertion_point(field_add_mutable:masterpb.Collection.partition_tags) + return partition_tags_.Add(); +} +inline void Collection::add_partition_tags(const std::string& value) { + partition_tags_.Add()->assign(value); + // @@protoc_insertion_point(field_add:masterpb.Collection.partition_tags) +} +inline void Collection::add_partition_tags(std::string&& value) { + partition_tags_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:masterpb.Collection.partition_tags) +} +inline void Collection::add_partition_tags(const char* value) { + GOOGLE_DCHECK(value != nullptr); + partition_tags_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:masterpb.Collection.partition_tags) +} +inline void Collection::add_partition_tags(const char* value, size_t size) { + partition_tags_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:masterpb.Collection.partition_tags) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +Collection::partition_tags() const { + // @@protoc_insertion_point(field_list:masterpb.Collection.partition_tags) + return partition_tags_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +Collection::mutable_partition_tags() { + // @@protoc_insertion_point(field_mutable_list:masterpb.Collection.partition_tags) + return &partition_tags_; +} + +// ------------------------------------------------------------------- + +// Segment + +// uint64 segment_id = 1; +inline void Segment::clear_segment_id() { + segment_id_ = PROTOBUF_ULONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::uint64 Segment::segment_id() const { + // @@protoc_insertion_point(field_get:masterpb.Segment.segment_id) + return segment_id_; +} +inline void Segment::set_segment_id(::PROTOBUF_NAMESPACE_ID::uint64 value) { + + segment_id_ = value; + // @@protoc_insertion_point(field_set:masterpb.Segment.segment_id) +} + +// uint64 collection_id = 2; +inline void Segment::clear_collection_id() { + collection_id_ = PROTOBUF_ULONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::uint64 Segment::collection_id() const { + // @@protoc_insertion_point(field_get:masterpb.Segment.collection_id) + return collection_id_; +} +inline void Segment::set_collection_id(::PROTOBUF_NAMESPACE_ID::uint64 value) { + + collection_id_ = value; + // @@protoc_insertion_point(field_set:masterpb.Segment.collection_id) +} + +// string partition_tag = 3; +inline void Segment::clear_partition_tag() { + partition_tag_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& Segment::partition_tag() const { + // @@protoc_insertion_point(field_get:masterpb.Segment.partition_tag) + return partition_tag_.GetNoArena(); +} +inline void Segment::set_partition_tag(const std::string& value) { + + partition_tag_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:masterpb.Segment.partition_tag) +} +inline void Segment::set_partition_tag(std::string&& value) { + + partition_tag_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:masterpb.Segment.partition_tag) +} +inline void Segment::set_partition_tag(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + partition_tag_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:masterpb.Segment.partition_tag) +} +inline void Segment::set_partition_tag(const char* value, size_t size) { + + partition_tag_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:masterpb.Segment.partition_tag) +} +inline std::string* Segment::mutable_partition_tag() { + + // @@protoc_insertion_point(field_mutable:masterpb.Segment.partition_tag) + return partition_tag_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* Segment::release_partition_tag() { + // @@protoc_insertion_point(field_release:masterpb.Segment.partition_tag) + + return partition_tag_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void Segment::set_allocated_partition_tag(std::string* partition_tag) { + if (partition_tag != nullptr) { + + } else { + + } + partition_tag_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), partition_tag); + // @@protoc_insertion_point(field_set_allocated:masterpb.Segment.partition_tag) +} + +// int32 channel_start = 4; +inline void Segment::clear_channel_start() { + channel_start_ = 0; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 Segment::channel_start() const { + // @@protoc_insertion_point(field_get:masterpb.Segment.channel_start) + return channel_start_; +} +inline void Segment::set_channel_start(::PROTOBUF_NAMESPACE_ID::int32 value) { + + channel_start_ = value; + // @@protoc_insertion_point(field_set:masterpb.Segment.channel_start) +} + +// int32 channel_end = 5; +inline void Segment::clear_channel_end() { + channel_end_ = 0; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 Segment::channel_end() const { + // @@protoc_insertion_point(field_get:masterpb.Segment.channel_end) + return channel_end_; +} +inline void Segment::set_channel_end(::PROTOBUF_NAMESPACE_ID::int32 value) { + + channel_end_ = value; + // @@protoc_insertion_point(field_set:masterpb.Segment.channel_end) +} + +// uint64 open_timestamp = 6; +inline void Segment::clear_open_timestamp() { + open_timestamp_ = PROTOBUF_ULONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::uint64 Segment::open_timestamp() const { + // @@protoc_insertion_point(field_get:masterpb.Segment.open_timestamp) + return open_timestamp_; +} +inline void Segment::set_open_timestamp(::PROTOBUF_NAMESPACE_ID::uint64 value) { + + open_timestamp_ = value; + // @@protoc_insertion_point(field_set:masterpb.Segment.open_timestamp) +} + +// uint64 close_timestamp = 7; +inline void Segment::clear_close_timestamp() { + close_timestamp_ = PROTOBUF_ULONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::uint64 Segment::close_timestamp() const { + // @@protoc_insertion_point(field_get:masterpb.Segment.close_timestamp) + return close_timestamp_; +} +inline void Segment::set_close_timestamp(::PROTOBUF_NAMESPACE_ID::uint64 value) { + + close_timestamp_ = value; + // @@protoc_insertion_point(field_set:masterpb.Segment.close_timestamp) +} + +// string collection_name = 8; +inline void Segment::clear_collection_name() { + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& Segment::collection_name() const { + // @@protoc_insertion_point(field_get:masterpb.Segment.collection_name) + return collection_name_.GetNoArena(); +} +inline void Segment::set_collection_name(const std::string& value) { + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:masterpb.Segment.collection_name) +} +inline void Segment::set_collection_name(std::string&& value) { + + collection_name_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:masterpb.Segment.collection_name) +} +inline void Segment::set_collection_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:masterpb.Segment.collection_name) +} +inline void Segment::set_collection_name(const char* value, size_t size) { + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:masterpb.Segment.collection_name) +} +inline std::string* Segment::mutable_collection_name() { + + // @@protoc_insertion_point(field_mutable:masterpb.Segment.collection_name) + return collection_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* Segment::release_collection_name() { + // @@protoc_insertion_point(field_release:masterpb.Segment.collection_name) + + return collection_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void Segment::set_allocated_collection_name(std::string* collection_name) { + if (collection_name != nullptr) { + + } else { + + } + collection_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), collection_name); + // @@protoc_insertion_point(field_set_allocated:masterpb.Segment.collection_name) +} + +// ------------------------------------------------------------------- + +// SegmentStat + +// uint64 segment_id = 1; +inline void SegmentStat::clear_segment_id() { + segment_id_ = PROTOBUF_ULONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::uint64 SegmentStat::segment_id() const { + // @@protoc_insertion_point(field_get:masterpb.SegmentStat.segment_id) + return segment_id_; +} +inline void SegmentStat::set_segment_id(::PROTOBUF_NAMESPACE_ID::uint64 value) { + + segment_id_ = value; + // @@protoc_insertion_point(field_set:masterpb.SegmentStat.segment_id) +} + +// uint64 memory_size = 2; +inline void SegmentStat::clear_memory_size() { + memory_size_ = PROTOBUF_ULONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::uint64 SegmentStat::memory_size() const { + // @@protoc_insertion_point(field_get:masterpb.SegmentStat.memory_size) + return memory_size_; +} +inline void SegmentStat::set_memory_size(::PROTOBUF_NAMESPACE_ID::uint64 value) { + + memory_size_ = value; + // @@protoc_insertion_point(field_set:masterpb.SegmentStat.memory_size) +} + +// float memory_rate = 3; +inline void SegmentStat::clear_memory_rate() { + memory_rate_ = 0; +} +inline float SegmentStat::memory_rate() const { + // @@protoc_insertion_point(field_get:masterpb.SegmentStat.memory_rate) + return memory_rate_; +} +inline void SegmentStat::set_memory_rate(float value) { + + memory_rate_ = value; + // @@protoc_insertion_point(field_set:masterpb.SegmentStat.memory_rate) +} + +#ifdef __GNUC__ + #pragma GCC diagnostic pop +#endif // __GNUC__ +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace masterpb + +// @@protoc_insertion_point(global_scope) + +#include +#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_master_2eproto diff --git a/core/src/pb/message.pb.cc b/core/src/pb/message.pb.cc new file mode 100644 index 0000000000..72a3d4b7b7 --- /dev/null +++ b/core/src/pb/message.pb.cc @@ -0,0 +1,19734 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: message.proto + +#include "message.pb.h" + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +// @@protoc_insertion_point(includes) +#include +extern PROTOBUF_INTERNAL_EXPORT_message_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<3> scc_info_BooleanQuery_message_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_message_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_CompareExpr_message_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_message_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_Entities_message_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_message_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_FieldMeta_message_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_message_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_KeyValuePair_message_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_message_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<3> scc_info_Mapping_message_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_message_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_RangeQuery_message_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_message_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_RowData_message_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_message_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_Schema_message_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_message_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_SearchParam_message_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_message_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_Status_message_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_message_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_TermQuery_message_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_message_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_VectorFieldParam_message_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_message_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_VectorParam_message_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_message_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_VectorQuery_message_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_message_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_VectorRecord_message_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_message_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_VectorRowRecord_message_2eproto; +namespace milvus { +namespace grpc { +class StatusDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _Status_default_instance_; +class KeyValuePairDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _KeyValuePair_default_instance_; +class CollectionNameDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _CollectionName_default_instance_; +class CollectionNameListDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _CollectionNameList_default_instance_; +class FieldNameDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _FieldName_default_instance_; +class MappingDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _Mapping_default_instance_; +class MappingListDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _MappingList_default_instance_; +class PartitionParamDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _PartitionParam_default_instance_; +class PartitionListDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _PartitionList_default_instance_; +class VectorRowRecordDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _VectorRowRecord_default_instance_; +class EntityIdsDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _EntityIds_default_instance_; +class VectorRecordDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _VectorRecord_default_instance_; +class VectorParamDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _VectorParam_default_instance_; +class FieldMetaDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _FieldMeta_default_instance_; +class SchemaDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _Schema_default_instance_; +class RowDataDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _RowData_default_instance_; +class InsertParamDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _InsertParam_default_instance_; +class SearchParamDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _SearchParam_default_instance_; +class SearchInSegmentParamDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _SearchInSegmentParam_default_instance_; +class EntitiesDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _Entities_default_instance_; +class QueryResultDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _QueryResult_default_instance_; +class StringReplyDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _StringReply_default_instance_; +class BoolReplyDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _BoolReply_default_instance_; +class CollectionRowCountDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _CollectionRowCount_default_instance_; +class CommandDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _Command_default_instance_; +class IndexParamDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _IndexParam_default_instance_; +class FlushParamDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _FlushParam_default_instance_; +class CompactParamDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _CompactParam_default_instance_; +class DeleteByIDParamDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _DeleteByIDParam_default_instance_; +class CollectionInfoDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _CollectionInfo_default_instance_; +class GetEntityIDsParamDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _GetEntityIDsParam_default_instance_; +class EntityIdentityDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _EntityIdentity_default_instance_; +class VectorFieldParamDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _VectorFieldParam_default_instance_; +class FieldTypeDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; + int data_type_; + const ::milvus::grpc::VectorFieldParam* vector_param_; +} _FieldType_default_instance_; +class FieldParamDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _FieldParam_default_instance_; +class VectorFieldRecordDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _VectorFieldRecord_default_instance_; +class TermQueryDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _TermQuery_default_instance_; +class CompareExprDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _CompareExpr_default_instance_; +class RangeQueryDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _RangeQuery_default_instance_; +class VectorQueryDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _VectorQuery_default_instance_; +class BooleanQueryDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _BooleanQuery_default_instance_; +class GeneralQueryDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; + const ::milvus::grpc::BooleanQuery* boolean_query_; + const ::milvus::grpc::TermQuery* term_query_; + const ::milvus::grpc::RangeQuery* range_query_; + const ::milvus::grpc::VectorQuery* vector_query_; +} _GeneralQuery_default_instance_; +class SearchParamPBDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _SearchParamPB_default_instance_; +class InsertOrDeleteMsgDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _InsertOrDeleteMsg_default_instance_; +class SearchMsgDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _SearchMsg_default_instance_; +class TimeSyncMsgDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _TimeSyncMsg_default_instance_; +class Key2SegMsgDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _Key2SegMsg_default_instance_; +} // namespace grpc +} // namespace milvus +static void InitDefaultsscc_info_BoolReply_message_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_BoolReply_default_instance_; + new (ptr) ::milvus::grpc::BoolReply(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::BoolReply::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_BoolReply_message_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_BoolReply_message_2eproto}, { + &scc_info_Status_message_2eproto.base,}}; + +static void InitDefaultsscc_info_BooleanQuery_message_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_BooleanQuery_default_instance_; + new (ptr) ::milvus::grpc::BooleanQuery(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + { + void* ptr = &::milvus::grpc::_GeneralQuery_default_instance_; + new (ptr) ::milvus::grpc::GeneralQuery(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::BooleanQuery::InitAsDefaultInstance(); + ::milvus::grpc::GeneralQuery::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<3> scc_info_BooleanQuery_message_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 3, InitDefaultsscc_info_BooleanQuery_message_2eproto}, { + &scc_info_TermQuery_message_2eproto.base, + &scc_info_RangeQuery_message_2eproto.base, + &scc_info_VectorQuery_message_2eproto.base,}}; + +static void InitDefaultsscc_info_CollectionInfo_message_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_CollectionInfo_default_instance_; + new (ptr) ::milvus::grpc::CollectionInfo(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::CollectionInfo::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_CollectionInfo_message_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_CollectionInfo_message_2eproto}, { + &scc_info_Status_message_2eproto.base,}}; + +static void InitDefaultsscc_info_CollectionName_message_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_CollectionName_default_instance_; + new (ptr) ::milvus::grpc::CollectionName(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::CollectionName::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_CollectionName_message_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_CollectionName_message_2eproto}, {}}; + +static void InitDefaultsscc_info_CollectionNameList_message_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_CollectionNameList_default_instance_; + new (ptr) ::milvus::grpc::CollectionNameList(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::CollectionNameList::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_CollectionNameList_message_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_CollectionNameList_message_2eproto}, { + &scc_info_Status_message_2eproto.base,}}; + +static void InitDefaultsscc_info_CollectionRowCount_message_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_CollectionRowCount_default_instance_; + new (ptr) ::milvus::grpc::CollectionRowCount(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::CollectionRowCount::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_CollectionRowCount_message_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_CollectionRowCount_message_2eproto}, { + &scc_info_Status_message_2eproto.base,}}; + +static void InitDefaultsscc_info_Command_message_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_Command_default_instance_; + new (ptr) ::milvus::grpc::Command(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::Command::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_Command_message_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_Command_message_2eproto}, {}}; + +static void InitDefaultsscc_info_CompactParam_message_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_CompactParam_default_instance_; + new (ptr) ::milvus::grpc::CompactParam(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::CompactParam::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_CompactParam_message_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_CompactParam_message_2eproto}, {}}; + +static void InitDefaultsscc_info_CompareExpr_message_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_CompareExpr_default_instance_; + new (ptr) ::milvus::grpc::CompareExpr(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::CompareExpr::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_CompareExpr_message_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_CompareExpr_message_2eproto}, {}}; + +static void InitDefaultsscc_info_DeleteByIDParam_message_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_DeleteByIDParam_default_instance_; + new (ptr) ::milvus::grpc::DeleteByIDParam(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::DeleteByIDParam::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_DeleteByIDParam_message_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_DeleteByIDParam_message_2eproto}, {}}; + +static void InitDefaultsscc_info_Entities_message_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_Entities_default_instance_; + new (ptr) ::milvus::grpc::Entities(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::Entities::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_Entities_message_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, InitDefaultsscc_info_Entities_message_2eproto}, { + &scc_info_Status_message_2eproto.base, + &scc_info_RowData_message_2eproto.base,}}; + +static void InitDefaultsscc_info_EntityIdentity_message_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_EntityIdentity_default_instance_; + new (ptr) ::milvus::grpc::EntityIdentity(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::EntityIdentity::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_EntityIdentity_message_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_EntityIdentity_message_2eproto}, {}}; + +static void InitDefaultsscc_info_EntityIds_message_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_EntityIds_default_instance_; + new (ptr) ::milvus::grpc::EntityIds(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::EntityIds::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_EntityIds_message_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_EntityIds_message_2eproto}, { + &scc_info_Status_message_2eproto.base,}}; + +static void InitDefaultsscc_info_FieldMeta_message_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_FieldMeta_default_instance_; + new (ptr) ::milvus::grpc::FieldMeta(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::FieldMeta::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_FieldMeta_message_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_FieldMeta_message_2eproto}, {}}; + +static void InitDefaultsscc_info_FieldName_message_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_FieldName_default_instance_; + new (ptr) ::milvus::grpc::FieldName(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::FieldName::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_FieldName_message_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_FieldName_message_2eproto}, {}}; + +static void InitDefaultsscc_info_FieldParam_message_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_FieldParam_default_instance_; + new (ptr) ::milvus::grpc::FieldParam(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::FieldParam::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_FieldParam_message_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_FieldParam_message_2eproto}, { + &scc_info_KeyValuePair_message_2eproto.base,}}; + +static void InitDefaultsscc_info_FieldType_message_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_FieldType_default_instance_; + new (ptr) ::milvus::grpc::FieldType(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::FieldType::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_FieldType_message_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_FieldType_message_2eproto}, { + &scc_info_VectorFieldParam_message_2eproto.base,}}; + +static void InitDefaultsscc_info_FlushParam_message_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_FlushParam_default_instance_; + new (ptr) ::milvus::grpc::FlushParam(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::FlushParam::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_FlushParam_message_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_FlushParam_message_2eproto}, {}}; + +static void InitDefaultsscc_info_GetEntityIDsParam_message_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_GetEntityIDsParam_default_instance_; + new (ptr) ::milvus::grpc::GetEntityIDsParam(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::GetEntityIDsParam::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_GetEntityIDsParam_message_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_GetEntityIDsParam_message_2eproto}, {}}; + +static void InitDefaultsscc_info_IndexParam_message_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_IndexParam_default_instance_; + new (ptr) ::milvus::grpc::IndexParam(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::IndexParam::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_IndexParam_message_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, InitDefaultsscc_info_IndexParam_message_2eproto}, { + &scc_info_Status_message_2eproto.base, + &scc_info_KeyValuePair_message_2eproto.base,}}; + +static void InitDefaultsscc_info_InsertOrDeleteMsg_message_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_InsertOrDeleteMsg_default_instance_; + new (ptr) ::milvus::grpc::InsertOrDeleteMsg(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::InsertOrDeleteMsg::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_InsertOrDeleteMsg_message_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, InitDefaultsscc_info_InsertOrDeleteMsg_message_2eproto}, { + &scc_info_RowData_message_2eproto.base, + &scc_info_KeyValuePair_message_2eproto.base,}}; + +static void InitDefaultsscc_info_InsertParam_message_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_InsertParam_default_instance_; + new (ptr) ::milvus::grpc::InsertParam(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::InsertParam::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<3> scc_info_InsertParam_message_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 3, InitDefaultsscc_info_InsertParam_message_2eproto}, { + &scc_info_Schema_message_2eproto.base, + &scc_info_RowData_message_2eproto.base, + &scc_info_KeyValuePair_message_2eproto.base,}}; + +static void InitDefaultsscc_info_Key2SegMsg_message_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_Key2SegMsg_default_instance_; + new (ptr) ::milvus::grpc::Key2SegMsg(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::Key2SegMsg::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_Key2SegMsg_message_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_Key2SegMsg_message_2eproto}, {}}; + +static void InitDefaultsscc_info_KeyValuePair_message_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_KeyValuePair_default_instance_; + new (ptr) ::milvus::grpc::KeyValuePair(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::KeyValuePair::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_KeyValuePair_message_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_KeyValuePair_message_2eproto}, {}}; + +static void InitDefaultsscc_info_Mapping_message_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_Mapping_default_instance_; + new (ptr) ::milvus::grpc::Mapping(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::Mapping::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<3> scc_info_Mapping_message_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 3, InitDefaultsscc_info_Mapping_message_2eproto}, { + &scc_info_Status_message_2eproto.base, + &scc_info_Schema_message_2eproto.base, + &scc_info_KeyValuePair_message_2eproto.base,}}; + +static void InitDefaultsscc_info_MappingList_message_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_MappingList_default_instance_; + new (ptr) ::milvus::grpc::MappingList(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::MappingList::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_MappingList_message_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, InitDefaultsscc_info_MappingList_message_2eproto}, { + &scc_info_Status_message_2eproto.base, + &scc_info_Mapping_message_2eproto.base,}}; + +static void InitDefaultsscc_info_PartitionList_message_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_PartitionList_default_instance_; + new (ptr) ::milvus::grpc::PartitionList(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::PartitionList::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_PartitionList_message_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_PartitionList_message_2eproto}, { + &scc_info_Status_message_2eproto.base,}}; + +static void InitDefaultsscc_info_PartitionParam_message_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_PartitionParam_default_instance_; + new (ptr) ::milvus::grpc::PartitionParam(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::PartitionParam::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_PartitionParam_message_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_PartitionParam_message_2eproto}, {}}; + +static void InitDefaultsscc_info_QueryResult_message_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_QueryResult_default_instance_; + new (ptr) ::milvus::grpc::QueryResult(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::QueryResult::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<3> scc_info_QueryResult_message_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 3, InitDefaultsscc_info_QueryResult_message_2eproto}, { + &scc_info_Status_message_2eproto.base, + &scc_info_Entities_message_2eproto.base, + &scc_info_KeyValuePair_message_2eproto.base,}}; + +static void InitDefaultsscc_info_RangeQuery_message_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_RangeQuery_default_instance_; + new (ptr) ::milvus::grpc::RangeQuery(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::RangeQuery::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_RangeQuery_message_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, InitDefaultsscc_info_RangeQuery_message_2eproto}, { + &scc_info_CompareExpr_message_2eproto.base, + &scc_info_KeyValuePair_message_2eproto.base,}}; + +static void InitDefaultsscc_info_RowData_message_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_RowData_default_instance_; + new (ptr) ::milvus::grpc::RowData(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::RowData::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_RowData_message_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_RowData_message_2eproto}, {}}; + +static void InitDefaultsscc_info_Schema_message_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_Schema_default_instance_; + new (ptr) ::milvus::grpc::Schema(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::Schema::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_Schema_message_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_Schema_message_2eproto}, { + &scc_info_FieldMeta_message_2eproto.base,}}; + +static void InitDefaultsscc_info_SearchInSegmentParam_message_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_SearchInSegmentParam_default_instance_; + new (ptr) ::milvus::grpc::SearchInSegmentParam(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::SearchInSegmentParam::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_SearchInSegmentParam_message_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_SearchInSegmentParam_message_2eproto}, { + &scc_info_SearchParam_message_2eproto.base,}}; + +static void InitDefaultsscc_info_SearchMsg_message_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_SearchMsg_default_instance_; + new (ptr) ::milvus::grpc::SearchMsg(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::SearchMsg::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_SearchMsg_message_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, InitDefaultsscc_info_SearchMsg_message_2eproto}, { + &scc_info_VectorRowRecord_message_2eproto.base, + &scc_info_KeyValuePair_message_2eproto.base,}}; + +static void InitDefaultsscc_info_SearchParam_message_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_SearchParam_default_instance_; + new (ptr) ::milvus::grpc::SearchParam(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::SearchParam::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_SearchParam_message_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, InitDefaultsscc_info_SearchParam_message_2eproto}, { + &scc_info_VectorParam_message_2eproto.base, + &scc_info_KeyValuePair_message_2eproto.base,}}; + +static void InitDefaultsscc_info_SearchParamPB_message_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_SearchParamPB_default_instance_; + new (ptr) ::milvus::grpc::SearchParamPB(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::SearchParamPB::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_SearchParamPB_message_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, InitDefaultsscc_info_SearchParamPB_message_2eproto}, { + &scc_info_BooleanQuery_message_2eproto.base, + &scc_info_KeyValuePair_message_2eproto.base,}}; + +static void InitDefaultsscc_info_Status_message_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_Status_default_instance_; + new (ptr) ::milvus::grpc::Status(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::Status::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_Status_message_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_Status_message_2eproto}, {}}; + +static void InitDefaultsscc_info_StringReply_message_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_StringReply_default_instance_; + new (ptr) ::milvus::grpc::StringReply(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::StringReply::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_StringReply_message_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_StringReply_message_2eproto}, { + &scc_info_Status_message_2eproto.base,}}; + +static void InitDefaultsscc_info_TermQuery_message_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_TermQuery_default_instance_; + new (ptr) ::milvus::grpc::TermQuery(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::TermQuery::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_TermQuery_message_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_TermQuery_message_2eproto}, { + &scc_info_KeyValuePair_message_2eproto.base,}}; + +static void InitDefaultsscc_info_TimeSyncMsg_message_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_TimeSyncMsg_default_instance_; + new (ptr) ::milvus::grpc::TimeSyncMsg(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::TimeSyncMsg::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_TimeSyncMsg_message_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_TimeSyncMsg_message_2eproto}, {}}; + +static void InitDefaultsscc_info_VectorFieldParam_message_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_VectorFieldParam_default_instance_; + new (ptr) ::milvus::grpc::VectorFieldParam(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::VectorFieldParam::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_VectorFieldParam_message_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_VectorFieldParam_message_2eproto}, {}}; + +static void InitDefaultsscc_info_VectorFieldRecord_message_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_VectorFieldRecord_default_instance_; + new (ptr) ::milvus::grpc::VectorFieldRecord(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::VectorFieldRecord::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_VectorFieldRecord_message_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_VectorFieldRecord_message_2eproto}, { + &scc_info_VectorRowRecord_message_2eproto.base,}}; + +static void InitDefaultsscc_info_VectorParam_message_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_VectorParam_default_instance_; + new (ptr) ::milvus::grpc::VectorParam(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::VectorParam::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_VectorParam_message_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_VectorParam_message_2eproto}, { + &scc_info_VectorRecord_message_2eproto.base,}}; + +static void InitDefaultsscc_info_VectorQuery_message_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_VectorQuery_default_instance_; + new (ptr) ::milvus::grpc::VectorQuery(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::VectorQuery::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_VectorQuery_message_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, InitDefaultsscc_info_VectorQuery_message_2eproto}, { + &scc_info_VectorRowRecord_message_2eproto.base, + &scc_info_KeyValuePair_message_2eproto.base,}}; + +static void InitDefaultsscc_info_VectorRecord_message_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_VectorRecord_default_instance_; + new (ptr) ::milvus::grpc::VectorRecord(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::VectorRecord::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_VectorRecord_message_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_VectorRecord_message_2eproto}, { + &scc_info_VectorRowRecord_message_2eproto.base,}}; + +static void InitDefaultsscc_info_VectorRowRecord_message_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_VectorRowRecord_default_instance_; + new (ptr) ::milvus::grpc::VectorRowRecord(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::VectorRowRecord::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_VectorRowRecord_message_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_VectorRowRecord_message_2eproto}, {}}; + +static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_message_2eproto[47]; +static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_message_2eproto[6]; +static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_message_2eproto = nullptr; + +const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_message_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::Status, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::Status, error_code_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::Status, reason_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::KeyValuePair, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::KeyValuePair, key_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::KeyValuePair, value_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::CollectionName, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::CollectionName, collection_name_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::CollectionNameList, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::CollectionNameList, status_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::CollectionNameList, collection_names_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::FieldName, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::FieldName, collection_name_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::FieldName, field_name_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::Mapping, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::Mapping, status_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::Mapping, collection_name_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::Mapping, schema_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::Mapping, extra_params_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::MappingList, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::MappingList, status_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::MappingList, mapping_list_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::PartitionParam, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::PartitionParam, collection_name_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::PartitionParam, tag_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::PartitionList, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::PartitionList, status_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::PartitionList, partition_tag_array_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::VectorRowRecord, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::VectorRowRecord, float_data_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::VectorRowRecord, binary_data_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::EntityIds, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::EntityIds, status_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::EntityIds, entity_id_array_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::VectorRecord, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::VectorRecord, records_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::VectorParam, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::VectorParam, json_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::VectorParam, row_record_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::FieldMeta, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::FieldMeta, field_name_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::FieldMeta, type_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::FieldMeta, dim_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::Schema, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::Schema, field_metas_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::RowData, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::RowData, blob_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::InsertParam, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::InsertParam, collection_name_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::InsertParam, schema_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::InsertParam, rows_data_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::InsertParam, entity_id_array_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::InsertParam, partition_tag_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::InsertParam, extra_params_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::SearchParam, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::SearchParam, collection_name_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::SearchParam, vector_param_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::SearchParam, dsl_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::SearchParam, partition_tag_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::SearchParam, extra_params_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::SearchInSegmentParam, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::SearchInSegmentParam, file_id_array_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::SearchInSegmentParam, search_param_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::Entities, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::Entities, status_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::Entities, ids_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::Entities, valid_row_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::Entities, rows_data_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::QueryResult, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::QueryResult, status_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::QueryResult, entities_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::QueryResult, row_num_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::QueryResult, scores_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::QueryResult, distances_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::QueryResult, extra_params_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::QueryResult, query_id_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::QueryResult, client_id_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::StringReply, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::StringReply, status_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::StringReply, string_reply_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::BoolReply, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::BoolReply, status_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::BoolReply, bool_reply_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::CollectionRowCount, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::CollectionRowCount, status_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::CollectionRowCount, collection_row_count_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::Command, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::Command, cmd_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::IndexParam, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::IndexParam, status_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::IndexParam, collection_name_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::IndexParam, field_name_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::IndexParam, index_name_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::IndexParam, extra_params_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::FlushParam, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::FlushParam, collection_name_array_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::CompactParam, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::CompactParam, collection_name_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::CompactParam, threshold_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::DeleteByIDParam, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::DeleteByIDParam, collection_name_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::DeleteByIDParam, id_array_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::CollectionInfo, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::CollectionInfo, status_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::CollectionInfo, json_info_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::GetEntityIDsParam, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::GetEntityIDsParam, collection_name_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::GetEntityIDsParam, segment_id_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::EntityIdentity, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::EntityIdentity, collection_name_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::EntityIdentity, id_array_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::EntityIdentity, field_names_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::VectorFieldParam, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::VectorFieldParam, dimension_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::FieldType, _internal_metadata_), + ~0u, // no _extensions_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::FieldType, _oneof_case_[0]), + ~0u, // no _weak_field_map_ + offsetof(::milvus::grpc::FieldTypeDefaultTypeInternal, data_type_), + offsetof(::milvus::grpc::FieldTypeDefaultTypeInternal, vector_param_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::FieldType, value_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::FieldParam, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::FieldParam, id_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::FieldParam, name_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::FieldParam, type_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::FieldParam, index_params_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::FieldParam, extra_params_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::VectorFieldRecord, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::VectorFieldRecord, value_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::TermQuery, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::TermQuery, field_name_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::TermQuery, int_value_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::TermQuery, double_value_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::TermQuery, value_num_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::TermQuery, boost_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::TermQuery, extra_params_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::CompareExpr, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::CompareExpr, operator__), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::CompareExpr, operand_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::RangeQuery, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::RangeQuery, field_name_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::RangeQuery, operand_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::RangeQuery, boost_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::RangeQuery, extra_params_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::VectorQuery, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::VectorQuery, field_name_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::VectorQuery, query_boost_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::VectorQuery, records_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::VectorQuery, topk_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::VectorQuery, extra_params_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::BooleanQuery, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::BooleanQuery, occur_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::BooleanQuery, general_query_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::GeneralQuery, _internal_metadata_), + ~0u, // no _extensions_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::GeneralQuery, _oneof_case_[0]), + ~0u, // no _weak_field_map_ + offsetof(::milvus::grpc::GeneralQueryDefaultTypeInternal, boolean_query_), + offsetof(::milvus::grpc::GeneralQueryDefaultTypeInternal, term_query_), + offsetof(::milvus::grpc::GeneralQueryDefaultTypeInternal, range_query_), + offsetof(::milvus::grpc::GeneralQueryDefaultTypeInternal, vector_query_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::GeneralQuery, query_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::SearchParamPB, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::SearchParamPB, collection_name_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::SearchParamPB, partition_tag_array_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::SearchParamPB, general_query_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::SearchParamPB, extra_params_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::InsertOrDeleteMsg, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::InsertOrDeleteMsg, collection_name_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::InsertOrDeleteMsg, rows_data_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::InsertOrDeleteMsg, uid_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::InsertOrDeleteMsg, partition_tag_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::InsertOrDeleteMsg, timestamp_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::InsertOrDeleteMsg, segment_id_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::InsertOrDeleteMsg, channel_id_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::InsertOrDeleteMsg, op_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::InsertOrDeleteMsg, client_id_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::InsertOrDeleteMsg, extra_params_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::SearchMsg, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::SearchMsg, collection_name_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::SearchMsg, records_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::SearchMsg, partition_tag_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::SearchMsg, uid_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::SearchMsg, timestamp_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::SearchMsg, client_id_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::SearchMsg, extra_params_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::SearchMsg, json_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::SearchMsg, dsl_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::TimeSyncMsg, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::TimeSyncMsg, peer_id_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::TimeSyncMsg, timestamp_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::TimeSyncMsg, sync_type_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::Key2SegMsg, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::Key2SegMsg, uid_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::Key2SegMsg, timestamp_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::Key2SegMsg, segment_id_), +}; +static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { + { 0, -1, sizeof(::milvus::grpc::Status)}, + { 7, -1, sizeof(::milvus::grpc::KeyValuePair)}, + { 14, -1, sizeof(::milvus::grpc::CollectionName)}, + { 20, -1, sizeof(::milvus::grpc::CollectionNameList)}, + { 27, -1, sizeof(::milvus::grpc::FieldName)}, + { 34, -1, sizeof(::milvus::grpc::Mapping)}, + { 43, -1, sizeof(::milvus::grpc::MappingList)}, + { 50, -1, sizeof(::milvus::grpc::PartitionParam)}, + { 57, -1, sizeof(::milvus::grpc::PartitionList)}, + { 64, -1, sizeof(::milvus::grpc::VectorRowRecord)}, + { 71, -1, sizeof(::milvus::grpc::EntityIds)}, + { 78, -1, sizeof(::milvus::grpc::VectorRecord)}, + { 84, -1, sizeof(::milvus::grpc::VectorParam)}, + { 91, -1, sizeof(::milvus::grpc::FieldMeta)}, + { 99, -1, sizeof(::milvus::grpc::Schema)}, + { 105, -1, sizeof(::milvus::grpc::RowData)}, + { 111, -1, sizeof(::milvus::grpc::InsertParam)}, + { 122, -1, sizeof(::milvus::grpc::SearchParam)}, + { 132, -1, sizeof(::milvus::grpc::SearchInSegmentParam)}, + { 139, -1, sizeof(::milvus::grpc::Entities)}, + { 148, -1, sizeof(::milvus::grpc::QueryResult)}, + { 161, -1, sizeof(::milvus::grpc::StringReply)}, + { 168, -1, sizeof(::milvus::grpc::BoolReply)}, + { 175, -1, sizeof(::milvus::grpc::CollectionRowCount)}, + { 182, -1, sizeof(::milvus::grpc::Command)}, + { 188, -1, sizeof(::milvus::grpc::IndexParam)}, + { 198, -1, sizeof(::milvus::grpc::FlushParam)}, + { 204, -1, sizeof(::milvus::grpc::CompactParam)}, + { 211, -1, sizeof(::milvus::grpc::DeleteByIDParam)}, + { 218, -1, sizeof(::milvus::grpc::CollectionInfo)}, + { 225, -1, sizeof(::milvus::grpc::GetEntityIDsParam)}, + { 232, -1, sizeof(::milvus::grpc::EntityIdentity)}, + { 240, -1, sizeof(::milvus::grpc::VectorFieldParam)}, + { 246, -1, sizeof(::milvus::grpc::FieldType)}, + { 254, -1, sizeof(::milvus::grpc::FieldParam)}, + { 264, -1, sizeof(::milvus::grpc::VectorFieldRecord)}, + { 270, -1, sizeof(::milvus::grpc::TermQuery)}, + { 281, -1, sizeof(::milvus::grpc::CompareExpr)}, + { 288, -1, sizeof(::milvus::grpc::RangeQuery)}, + { 297, -1, sizeof(::milvus::grpc::VectorQuery)}, + { 307, -1, sizeof(::milvus::grpc::BooleanQuery)}, + { 314, -1, sizeof(::milvus::grpc::GeneralQuery)}, + { 324, -1, sizeof(::milvus::grpc::SearchParamPB)}, + { 333, -1, sizeof(::milvus::grpc::InsertOrDeleteMsg)}, + { 348, -1, sizeof(::milvus::grpc::SearchMsg)}, + { 362, -1, sizeof(::milvus::grpc::TimeSyncMsg)}, + { 370, -1, sizeof(::milvus::grpc::Key2SegMsg)}, +}; + +static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { + reinterpret_cast(&::milvus::grpc::_Status_default_instance_), + reinterpret_cast(&::milvus::grpc::_KeyValuePair_default_instance_), + reinterpret_cast(&::milvus::grpc::_CollectionName_default_instance_), + reinterpret_cast(&::milvus::grpc::_CollectionNameList_default_instance_), + reinterpret_cast(&::milvus::grpc::_FieldName_default_instance_), + reinterpret_cast(&::milvus::grpc::_Mapping_default_instance_), + reinterpret_cast(&::milvus::grpc::_MappingList_default_instance_), + reinterpret_cast(&::milvus::grpc::_PartitionParam_default_instance_), + reinterpret_cast(&::milvus::grpc::_PartitionList_default_instance_), + reinterpret_cast(&::milvus::grpc::_VectorRowRecord_default_instance_), + reinterpret_cast(&::milvus::grpc::_EntityIds_default_instance_), + reinterpret_cast(&::milvus::grpc::_VectorRecord_default_instance_), + reinterpret_cast(&::milvus::grpc::_VectorParam_default_instance_), + reinterpret_cast(&::milvus::grpc::_FieldMeta_default_instance_), + reinterpret_cast(&::milvus::grpc::_Schema_default_instance_), + reinterpret_cast(&::milvus::grpc::_RowData_default_instance_), + reinterpret_cast(&::milvus::grpc::_InsertParam_default_instance_), + reinterpret_cast(&::milvus::grpc::_SearchParam_default_instance_), + reinterpret_cast(&::milvus::grpc::_SearchInSegmentParam_default_instance_), + reinterpret_cast(&::milvus::grpc::_Entities_default_instance_), + reinterpret_cast(&::milvus::grpc::_QueryResult_default_instance_), + reinterpret_cast(&::milvus::grpc::_StringReply_default_instance_), + reinterpret_cast(&::milvus::grpc::_BoolReply_default_instance_), + reinterpret_cast(&::milvus::grpc::_CollectionRowCount_default_instance_), + reinterpret_cast(&::milvus::grpc::_Command_default_instance_), + reinterpret_cast(&::milvus::grpc::_IndexParam_default_instance_), + reinterpret_cast(&::milvus::grpc::_FlushParam_default_instance_), + reinterpret_cast(&::milvus::grpc::_CompactParam_default_instance_), + reinterpret_cast(&::milvus::grpc::_DeleteByIDParam_default_instance_), + reinterpret_cast(&::milvus::grpc::_CollectionInfo_default_instance_), + reinterpret_cast(&::milvus::grpc::_GetEntityIDsParam_default_instance_), + reinterpret_cast(&::milvus::grpc::_EntityIdentity_default_instance_), + reinterpret_cast(&::milvus::grpc::_VectorFieldParam_default_instance_), + reinterpret_cast(&::milvus::grpc::_FieldType_default_instance_), + reinterpret_cast(&::milvus::grpc::_FieldParam_default_instance_), + reinterpret_cast(&::milvus::grpc::_VectorFieldRecord_default_instance_), + reinterpret_cast(&::milvus::grpc::_TermQuery_default_instance_), + reinterpret_cast(&::milvus::grpc::_CompareExpr_default_instance_), + reinterpret_cast(&::milvus::grpc::_RangeQuery_default_instance_), + reinterpret_cast(&::milvus::grpc::_VectorQuery_default_instance_), + reinterpret_cast(&::milvus::grpc::_BooleanQuery_default_instance_), + reinterpret_cast(&::milvus::grpc::_GeneralQuery_default_instance_), + reinterpret_cast(&::milvus::grpc::_SearchParamPB_default_instance_), + reinterpret_cast(&::milvus::grpc::_InsertOrDeleteMsg_default_instance_), + reinterpret_cast(&::milvus::grpc::_SearchMsg_default_instance_), + reinterpret_cast(&::milvus::grpc::_TimeSyncMsg_default_instance_), + reinterpret_cast(&::milvus::grpc::_Key2SegMsg_default_instance_), +}; + +const char descriptor_table_protodef_message_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = + "\n\rmessage.proto\022\013milvus.grpc\"D\n\006Status\022*" + "\n\nerror_code\030\001 \001(\0162\026.milvus.grpc.ErrorCo" + "de\022\016\n\006reason\030\002 \001(\t\"*\n\014KeyValuePair\022\013\n\003ke" + "y\030\001 \001(\t\022\r\n\005value\030\002 \001(\t\")\n\016CollectionName" + "\022\027\n\017collection_name\030\001 \001(\t\"S\n\022CollectionN" + "ameList\022#\n\006status\030\001 \001(\0132\023.milvus.grpc.St" + "atus\022\030\n\020collection_names\030\002 \003(\t\"8\n\tFieldN" + "ame\022\027\n\017collection_name\030\001 \001(\t\022\022\n\nfield_na" + "me\030\002 \001(\t\"\235\001\n\007Mapping\022#\n\006status\030\001 \001(\0132\023.m" + "ilvus.grpc.Status\022\027\n\017collection_name\030\002 \001" + "(\t\022#\n\006schema\030\003 \001(\0132\023.milvus.grpc.Schema\022" + "/\n\014extra_params\030\004 \003(\0132\031.milvus.grpc.KeyV" + "aluePair\"^\n\013MappingList\022#\n\006status\030\001 \001(\0132" + "\023.milvus.grpc.Status\022*\n\014mapping_list\030\002 \003" + "(\0132\024.milvus.grpc.Mapping\"6\n\016PartitionPar" + "am\022\027\n\017collection_name\030\001 \001(\t\022\013\n\003tag\030\002 \001(\t" + "\"Q\n\rPartitionList\022#\n\006status\030\001 \001(\0132\023.milv" + "us.grpc.Status\022\033\n\023partition_tag_array\030\002 " + "\003(\t\":\n\017VectorRowRecord\022\022\n\nfloat_data\030\001 \003" + "(\002\022\023\n\013binary_data\030\002 \001(\014\"I\n\tEntityIds\022#\n\006" + "status\030\001 \001(\0132\023.milvus.grpc.Status\022\027\n\017ent" + "ity_id_array\030\002 \003(\003\"=\n\014VectorRecord\022-\n\007re" + "cords\030\001 \003(\0132\034.milvus.grpc.VectorRowRecor" + "d\"J\n\013VectorParam\022\014\n\004json\030\001 \001(\t\022-\n\nrow_re" + "cord\030\002 \001(\0132\031.milvus.grpc.VectorRecord\"Q\n" + "\tFieldMeta\022\022\n\nfield_name\030\001 \001(\t\022#\n\004type\030\002" + " \001(\0162\025.milvus.grpc.DataType\022\013\n\003dim\030\003 \001(\003" + "\"5\n\006Schema\022+\n\013field_metas\030\001 \003(\0132\026.milvus" + ".grpc.FieldMeta\"\027\n\007RowData\022\014\n\004blob\030\001 \001(\014" + "\"\325\001\n\013InsertParam\022\027\n\017collection_name\030\001 \001(" + "\t\022#\n\006schema\030\002 \001(\0132\023.milvus.grpc.Schema\022\'" + "\n\trows_data\030\003 \003(\0132\024.milvus.grpc.RowData\022" + "\027\n\017entity_id_array\030\004 \003(\003\022\025\n\rpartition_ta" + "g\030\005 \001(\t\022/\n\014extra_params\030\006 \003(\0132\031.milvus.g" + "rpc.KeyValuePair\"\253\001\n\013SearchParam\022\027\n\017coll" + "ection_name\030\001 \001(\t\022.\n\014vector_param\030\002 \003(\0132" + "\030.milvus.grpc.VectorParam\022\013\n\003dsl\030\003 \001(\t\022\025" + "\n\rpartition_tag\030\004 \003(\t\022/\n\014extra_params\030\005 " + "\003(\0132\031.milvus.grpc.KeyValuePair\"]\n\024Search" + "InSegmentParam\022\025\n\rfile_id_array\030\001 \003(\t\022.\n" + "\014search_param\030\002 \001(\0132\030.milvus.grpc.Search" + "Param\"x\n\010Entities\022#\n\006status\030\001 \001(\0132\023.milv" + "us.grpc.Status\022\013\n\003ids\030\002 \003(\003\022\021\n\tvalid_row" + "\030\003 \003(\010\022\'\n\trows_data\030\004 \003(\0132\024.milvus.grpc." + "RowData\"\345\001\n\013QueryResult\022#\n\006status\030\001 \001(\0132" + "\023.milvus.grpc.Status\022\'\n\010entities\030\002 \001(\0132\025" + ".milvus.grpc.Entities\022\017\n\007row_num\030\003 \001(\003\022\016" + "\n\006scores\030\004 \003(\002\022\021\n\tdistances\030\005 \003(\002\022/\n\014ext" + "ra_params\030\006 \003(\0132\031.milvus.grpc.KeyValuePa" + "ir\022\020\n\010query_id\030\007 \001(\003\022\021\n\tclient_id\030\010 \001(\003\"" + "H\n\013StringReply\022#\n\006status\030\001 \001(\0132\023.milvus." + "grpc.Status\022\024\n\014string_reply\030\002 \001(\t\"D\n\tBoo" + "lReply\022#\n\006status\030\001 \001(\0132\023.milvus.grpc.Sta" + "tus\022\022\n\nbool_reply\030\002 \001(\010\"W\n\022CollectionRow" + "Count\022#\n\006status\030\001 \001(\0132\023.milvus.grpc.Stat" + "us\022\034\n\024collection_row_count\030\002 \001(\003\"\026\n\007Comm" + "and\022\013\n\003cmd\030\001 \001(\t\"\243\001\n\nIndexParam\022#\n\006statu" + "s\030\001 \001(\0132\023.milvus.grpc.Status\022\027\n\017collecti" + "on_name\030\002 \001(\t\022\022\n\nfield_name\030\003 \001(\t\022\022\n\nind" + "ex_name\030\004 \001(\t\022/\n\014extra_params\030\005 \003(\0132\031.mi" + "lvus.grpc.KeyValuePair\"+\n\nFlushParam\022\035\n\025" + "collection_name_array\030\001 \003(\t\":\n\014CompactPa" + "ram\022\027\n\017collection_name\030\001 \001(\t\022\021\n\tthreshol" + "d\030\002 \001(\001\"<\n\017DeleteByIDParam\022\027\n\017collection" + "_name\030\001 \001(\t\022\020\n\010id_array\030\002 \003(\003\"H\n\016Collect" + "ionInfo\022#\n\006status\030\001 \001(\0132\023.milvus.grpc.St" + "atus\022\021\n\tjson_info\030\002 \001(\t\"@\n\021GetEntityIDsP" + "aram\022\027\n\017collection_name\030\001 \001(\t\022\022\n\nsegment" + "_id\030\002 \001(\003\"P\n\016EntityIdentity\022\027\n\017collectio" + "n_name\030\001 \001(\t\022\020\n\010id_array\030\002 \003(\003\022\023\n\013field_" + "names\030\003 \003(\t\"%\n\020VectorFieldParam\022\021\n\tdimen" + "sion\030\001 \001(\003\"w\n\tFieldType\022*\n\tdata_type\030\001 \001" + "(\0162\025.milvus.grpc.DataTypeH\000\0225\n\014vector_pa" + "ram\030\002 \001(\0132\035.milvus.grpc.VectorFieldParam" + "H\000B\007\n\005value\"\255\001\n\nFieldParam\022\n\n\002id\030\001 \001(\004\022\014" + "\n\004name\030\002 \001(\t\022#\n\004type\030\003 \001(\0162\025.milvus.grpc" + ".DataType\022/\n\014index_params\030\004 \003(\0132\031.milvus" + ".grpc.KeyValuePair\022/\n\014extra_params\030\005 \003(\013" + "2\031.milvus.grpc.KeyValuePair\"@\n\021VectorFie" + "ldRecord\022+\n\005value\030\001 \003(\0132\034.milvus.grpc.Ve" + "ctorRowRecord\"\233\001\n\tTermQuery\022\022\n\nfield_nam" + "e\030\001 \001(\t\022\021\n\tint_value\030\002 \003(\003\022\024\n\014double_val" + "ue\030\003 \003(\001\022\021\n\tvalue_num\030\004 \001(\003\022\r\n\005boost\030\005 \001" + "(\002\022/\n\014extra_params\030\006 \003(\0132\031.milvus.grpc.K" + "eyValuePair\"N\n\013CompareExpr\022.\n\010operator\030\001" + " \001(\0162\034.milvus.grpc.CompareOperator\022\017\n\007op" + "erand\030\002 \001(\t\"\213\001\n\nRangeQuery\022\022\n\nfield_name" + "\030\001 \001(\t\022)\n\007operand\030\002 \003(\0132\030.milvus.grpc.Co" + "mpareExpr\022\r\n\005boost\030\003 \001(\002\022/\n\014extra_params" + "\030\004 \003(\0132\031.milvus.grpc.KeyValuePair\"\244\001\n\013Ve" + "ctorQuery\022\022\n\nfield_name\030\001 \001(\t\022\023\n\013query_b" + "oost\030\002 \001(\002\022-\n\007records\030\003 \003(\0132\034.milvus.grp" + "c.VectorRowRecord\022\014\n\004topk\030\004 \001(\003\022/\n\014extra" + "_params\030\005 \003(\0132\031.milvus.grpc.KeyValuePair" + "\"c\n\014BooleanQuery\022!\n\005occur\030\001 \001(\0162\022.milvus" + ".grpc.Occur\0220\n\rgeneral_query\030\002 \003(\0132\031.mil" + "vus.grpc.GeneralQuery\"\333\001\n\014GeneralQuery\0222" + "\n\rboolean_query\030\001 \001(\0132\031.milvus.grpc.Bool" + "eanQueryH\000\022,\n\nterm_query\030\002 \001(\0132\026.milvus." + "grpc.TermQueryH\000\022.\n\013range_query\030\003 \001(\0132\027." + "milvus.grpc.RangeQueryH\000\0220\n\014vector_query" + "\030\004 \001(\0132\030.milvus.grpc.VectorQueryH\000B\007\n\005qu" + "ery\"\250\001\n\rSearchParamPB\022\027\n\017collection_name" + "\030\001 \001(\t\022\033\n\023partition_tag_array\030\002 \003(\t\0220\n\rg" + "eneral_query\030\003 \001(\0132\031.milvus.grpc.General" + "Query\022/\n\014extra_params\030\004 \003(\0132\031.milvus.grp" + "c.KeyValuePair\"\231\002\n\021InsertOrDeleteMsg\022\027\n\017" + "collection_name\030\001 \001(\t\022\'\n\trows_data\030\002 \001(\013" + "2\024.milvus.grpc.RowData\022\013\n\003uid\030\003 \001(\003\022\025\n\rp" + "artition_tag\030\004 \001(\t\022\021\n\ttimestamp\030\005 \001(\004\022\022\n" + "\nsegment_id\030\006 \001(\003\022\022\n\nchannel_id\030\007 \001(\003\022\037\n" + "\002op\030\010 \001(\0162\023.milvus.grpc.OpType\022\021\n\tclient" + "_id\030\t \001(\003\022/\n\014extra_params\030\n \003(\0132\031.milvus" + ".grpc.KeyValuePair\"\351\001\n\tSearchMsg\022\027\n\017coll" + "ection_name\030\001 \001(\t\022-\n\007records\030\002 \001(\0132\034.mil" + "vus.grpc.VectorRowRecord\022\025\n\rpartition_ta" + "g\030\003 \003(\t\022\013\n\003uid\030\004 \001(\003\022\021\n\ttimestamp\030\005 \001(\004\022" + "\021\n\tclient_id\030\006 \001(\003\022/\n\014extra_params\030\007 \003(\013" + "2\031.milvus.grpc.KeyValuePair\022\014\n\004json\030\010 \003(" + "\t\022\013\n\003dsl\030\t \001(\t\"[\n\013TimeSyncMsg\022\017\n\007peer_Id" + "\030\001 \001(\003\022\021\n\tTimestamp\030\002 \001(\004\022(\n\tsync_type\030\003" + " \001(\0162\025.milvus.grpc.SyncType\"@\n\nKey2SegMs" + "g\022\013\n\003uid\030\001 \001(\003\022\021\n\ttimestamp\030\002 \001(\004\022\022\n\nseg" + "ment_id\030\003 \003(\003*\242\004\n\tErrorCode\022\013\n\007SUCCESS\020\000" + "\022\024\n\020UNEXPECTED_ERROR\020\001\022\022\n\016CONNECT_FAILED" + "\020\002\022\025\n\021PERMISSION_DENIED\020\003\022\031\n\025COLLECTION_" + "NOT_EXISTS\020\004\022\024\n\020ILLEGAL_ARGUMENT\020\005\022\025\n\021IL" + "LEGAL_DIMENSION\020\007\022\026\n\022ILLEGAL_INDEX_TYPE\020" + "\010\022\033\n\027ILLEGAL_COLLECTION_NAME\020\t\022\020\n\014ILLEGA" + "L_TOPK\020\n\022\025\n\021ILLEGAL_ROWRECORD\020\013\022\025\n\021ILLEG" + "AL_VECTOR_ID\020\014\022\031\n\025ILLEGAL_SEARCH_RESULT\020" + "\r\022\022\n\016FILE_NOT_FOUND\020\016\022\017\n\013META_FAILED\020\017\022\020" + "\n\014CACHE_FAILED\020\020\022\030\n\024CANNOT_CREATE_FOLDER" + "\020\021\022\026\n\022CANNOT_CREATE_FILE\020\022\022\030\n\024CANNOT_DEL" + "ETE_FOLDER\020\023\022\026\n\022CANNOT_DELETE_FILE\020\024\022\025\n\021" + "BUILD_INDEX_ERROR\020\025\022\021\n\rILLEGAL_NLIST\020\026\022\027" + "\n\023ILLEGAL_METRIC_TYPE\020\027\022\021\n\rOUT_OF_MEMORY" + "\020\030*\221\001\n\010DataType\022\010\n\004NONE\020\000\022\010\n\004BOOL\020\001\022\010\n\004I" + "NT8\020\002\022\t\n\005INT16\020\003\022\t\n\005INT32\020\004\022\t\n\005INT64\020\005\022\t" + "\n\005FLOAT\020\n\022\n\n\006DOUBLE\020\013\022\n\n\006STRING\020\024\022\021\n\rVEC" + "TOR_BINARY\020d\022\020\n\014VECTOR_FLOAT\020e*C\n\017Compar" + "eOperator\022\006\n\002LT\020\000\022\007\n\003LTE\020\001\022\006\n\002EQ\020\002\022\006\n\002GT" + "\020\003\022\007\n\003GTE\020\004\022\006\n\002NE\020\005*8\n\005Occur\022\013\n\007INVALID\020" + "\000\022\010\n\004MUST\020\001\022\n\n\006SHOULD\020\002\022\014\n\010MUST_NOT\020\003* \n" + "\006OpType\022\n\n\006INSERT\020\000\022\n\n\006DELETE\020\001*\037\n\010SyncT" + "ype\022\010\n\004READ\020\000\022\t\n\005WRITE\020\0012\333\r\n\rMilvusServi" + "ce\022\?\n\020CreateCollection\022\024.milvus.grpc.Map" + "ping\032\023.milvus.grpc.Status\"\000\022F\n\rHasCollec" + "tion\022\033.milvus.grpc.CollectionName\032\026.milv" + "us.grpc.BoolReply\"\000\022I\n\022DescribeCollectio" + "n\022\033.milvus.grpc.CollectionName\032\024.milvus." + "grpc.Mapping\"\000\022Q\n\017CountCollection\022\033.milv" + "us.grpc.CollectionName\032\037.milvus.grpc.Col" + "lectionRowCount\"\000\022J\n\017ShowCollections\022\024.m" + "ilvus.grpc.Command\032\037.milvus.grpc.Collect" + "ionNameList\"\000\022P\n\022ShowCollectionInfo\022\033.mi" + "lvus.grpc.CollectionName\032\033.milvus.grpc.C" + "ollectionInfo\"\000\022D\n\016DropCollection\022\033.milv" + "us.grpc.CollectionName\032\023.milvus.grpc.Sta" + "tus\"\000\022=\n\013CreateIndex\022\027.milvus.grpc.Index" + "Param\032\023.milvus.grpc.Status\"\000\022C\n\rDescribe" + "Index\022\027.milvus.grpc.IndexParam\032\027.milvus." + "grpc.IndexParam\"\000\022;\n\tDropIndex\022\027.milvus." + "grpc.IndexParam\032\023.milvus.grpc.Status\"\000\022E" + "\n\017CreatePartition\022\033.milvus.grpc.Partitio" + "nParam\032\023.milvus.grpc.Status\"\000\022E\n\014HasPart" + "ition\022\033.milvus.grpc.PartitionParam\032\026.mil" + "vus.grpc.BoolReply\"\000\022K\n\016ShowPartitions\022\033" + ".milvus.grpc.CollectionName\032\032.milvus.grp" + "c.PartitionList\"\000\022C\n\rDropPartition\022\033.mil" + "vus.grpc.PartitionParam\032\023.milvus.grpc.St" + "atus\"\000\022<\n\006Insert\022\030.milvus.grpc.InsertPar" + "am\032\026.milvus.grpc.EntityIds\"\000\022E\n\rGetEntit" + "yByID\022\033.milvus.grpc.EntityIdentity\032\025.mil" + "vus.grpc.Entities\"\000\022H\n\014GetEntityIDs\022\036.mi" + "lvus.grpc.GetEntityIDsParam\032\026.milvus.grp" + "c.EntityIds\"\000\022>\n\006Search\022\030.milvus.grpc.Se" + "archParam\032\030.milvus.grpc.QueryResult\"\000\022P\n" + "\017SearchInSegment\022!.milvus.grpc.SearchInS" + "egmentParam\032\030.milvus.grpc.QueryResult\"\000\022" + "7\n\003Cmd\022\024.milvus.grpc.Command\032\030.milvus.gr" + "pc.StringReply\"\000\022A\n\nDeleteByID\022\034.milvus." + "grpc.DeleteByIDParam\032\023.milvus.grpc.Statu" + "s\"\000\022G\n\021PreloadCollection\022\033.milvus.grpc.C" + "ollectionName\032\023.milvus.grpc.Status\"\000\0227\n\005" + "Flush\022\027.milvus.grpc.FlushParam\032\023.milvus." + "grpc.Status\"\000\022;\n\007Compact\022\031.milvus.grpc.C" + "ompactParam\032\023.milvus.grpc.Status\"\000\022B\n\010Se" + "archPB\022\032.milvus.grpc.SearchParamPB\032\030.mil" + "vus.grpc.QueryResult\"\000B\007Z\005msgpbb\006proto3" + ; +static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_message_2eproto_deps[1] = { +}; +static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_message_2eproto_sccs[46] = { + &scc_info_BoolReply_message_2eproto.base, + &scc_info_BooleanQuery_message_2eproto.base, + &scc_info_CollectionInfo_message_2eproto.base, + &scc_info_CollectionName_message_2eproto.base, + &scc_info_CollectionNameList_message_2eproto.base, + &scc_info_CollectionRowCount_message_2eproto.base, + &scc_info_Command_message_2eproto.base, + &scc_info_CompactParam_message_2eproto.base, + &scc_info_CompareExpr_message_2eproto.base, + &scc_info_DeleteByIDParam_message_2eproto.base, + &scc_info_Entities_message_2eproto.base, + &scc_info_EntityIdentity_message_2eproto.base, + &scc_info_EntityIds_message_2eproto.base, + &scc_info_FieldMeta_message_2eproto.base, + &scc_info_FieldName_message_2eproto.base, + &scc_info_FieldParam_message_2eproto.base, + &scc_info_FieldType_message_2eproto.base, + &scc_info_FlushParam_message_2eproto.base, + &scc_info_GetEntityIDsParam_message_2eproto.base, + &scc_info_IndexParam_message_2eproto.base, + &scc_info_InsertOrDeleteMsg_message_2eproto.base, + &scc_info_InsertParam_message_2eproto.base, + &scc_info_Key2SegMsg_message_2eproto.base, + &scc_info_KeyValuePair_message_2eproto.base, + &scc_info_Mapping_message_2eproto.base, + &scc_info_MappingList_message_2eproto.base, + &scc_info_PartitionList_message_2eproto.base, + &scc_info_PartitionParam_message_2eproto.base, + &scc_info_QueryResult_message_2eproto.base, + &scc_info_RangeQuery_message_2eproto.base, + &scc_info_RowData_message_2eproto.base, + &scc_info_Schema_message_2eproto.base, + &scc_info_SearchInSegmentParam_message_2eproto.base, + &scc_info_SearchMsg_message_2eproto.base, + &scc_info_SearchParam_message_2eproto.base, + &scc_info_SearchParamPB_message_2eproto.base, + &scc_info_Status_message_2eproto.base, + &scc_info_StringReply_message_2eproto.base, + &scc_info_TermQuery_message_2eproto.base, + &scc_info_TimeSyncMsg_message_2eproto.base, + &scc_info_VectorFieldParam_message_2eproto.base, + &scc_info_VectorFieldRecord_message_2eproto.base, + &scc_info_VectorParam_message_2eproto.base, + &scc_info_VectorQuery_message_2eproto.base, + &scc_info_VectorRecord_message_2eproto.base, + &scc_info_VectorRowRecord_message_2eproto.base, +}; +static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_message_2eproto_once; +static bool descriptor_table_message_2eproto_initialized = false; +const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_message_2eproto = { + &descriptor_table_message_2eproto_initialized, descriptor_table_protodef_message_2eproto, "message.proto", 7599, + &descriptor_table_message_2eproto_once, descriptor_table_message_2eproto_sccs, descriptor_table_message_2eproto_deps, 46, 0, + schemas, file_default_instances, TableStruct_message_2eproto::offsets, + file_level_metadata_message_2eproto, 47, file_level_enum_descriptors_message_2eproto, file_level_service_descriptors_message_2eproto, +}; + +// Force running AddDescriptors() at dynamic initialization time. +static bool dynamic_init_dummy_message_2eproto = ( ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptors(&descriptor_table_message_2eproto), true); +namespace milvus { +namespace grpc { +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ErrorCode_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_message_2eproto); + return file_level_enum_descriptors_message_2eproto[0]; +} +bool ErrorCode_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + case 4: + case 5: + case 7: + case 8: + case 9: + case 10: + case 11: + case 12: + case 13: + case 14: + case 15: + case 16: + case 17: + case 18: + case 19: + case 20: + case 21: + case 22: + case 23: + case 24: + return true; + default: + return false; + } +} + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DataType_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_message_2eproto); + return file_level_enum_descriptors_message_2eproto[1]; +} +bool DataType_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + case 4: + case 5: + case 10: + case 11: + case 20: + case 100: + case 101: + return true; + default: + return false; + } +} + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* CompareOperator_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_message_2eproto); + return file_level_enum_descriptors_message_2eproto[2]; +} +bool CompareOperator_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + case 4: + case 5: + return true; + default: + return false; + } +} + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Occur_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_message_2eproto); + return file_level_enum_descriptors_message_2eproto[3]; +} +bool Occur_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + return true; + default: + return false; + } +} + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* OpType_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_message_2eproto); + return file_level_enum_descriptors_message_2eproto[4]; +} +bool OpType_IsValid(int value) { + switch (value) { + case 0: + case 1: + return true; + default: + return false; + } +} + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SyncType_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_message_2eproto); + return file_level_enum_descriptors_message_2eproto[5]; +} +bool SyncType_IsValid(int value) { + switch (value) { + case 0: + case 1: + return true; + default: + return false; + } +} + + +// =================================================================== + +void Status::InitAsDefaultInstance() { +} +class Status::_Internal { + public: +}; + +Status::Status() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.Status) +} +Status::Status(const Status& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + reason_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.reason().empty()) { + reason_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.reason_); + } + error_code_ = from.error_code_; + // @@protoc_insertion_point(copy_constructor:milvus.grpc.Status) +} + +void Status::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Status_message_2eproto.base); + reason_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + error_code_ = 0; +} + +Status::~Status() { + // @@protoc_insertion_point(destructor:milvus.grpc.Status) + SharedDtor(); +} + +void Status::SharedDtor() { + reason_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void Status::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const Status& Status::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_Status_message_2eproto.base); + return *internal_default_instance(); +} + + +void Status::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.Status) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + reason_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + error_code_ = 0; + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* Status::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // .milvus.grpc.ErrorCode error_code = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + set_error_code(static_cast<::milvus::grpc::ErrorCode>(val)); + } else goto handle_unusual; + continue; + // string reason = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_reason(), ptr, ctx, "milvus.grpc.Status.reason"); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool Status::MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + // @@protoc_insertion_point(parse_start:milvus.grpc.Status) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // .milvus.grpc.ErrorCode error_code = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) { + int value = 0; + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + int, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + set_error_code(static_cast< ::milvus::grpc::ErrorCode >(value)); + } else { + goto handle_unusual; + } + break; + } + + // string reason = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_reason())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->reason().data(), static_cast(this->reason().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.Status.reason")); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:milvus.grpc.Status) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.Status) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void Status::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.Status) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.grpc.ErrorCode error_code = 1; + if (this->error_code() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnum( + 1, this->error_code(), output); + } + + // string reason = 2; + if (this->reason().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->reason().data(), static_cast(this->reason().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.Status.reason"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 2, this->reason(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:milvus.grpc.Status) +} + +::PROTOBUF_NAMESPACE_ID::uint8* Status::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.Status) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.grpc.ErrorCode error_code = 1; + if (this->error_code() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 1, this->error_code(), target); + } + + // string reason = 2; + if (this->reason().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->reason().data(), static_cast(this->reason().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.Status.reason"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 2, this->reason(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.Status) + return target; +} + +size_t Status::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.Status) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // string reason = 2; + if (this->reason().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->reason()); + } + + // .milvus.grpc.ErrorCode error_code = 1; + if (this->error_code() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->error_code()); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Status::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.Status) + GOOGLE_DCHECK_NE(&from, this); + const Status* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.Status) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.Status) + MergeFrom(*source); + } +} + +void Status::MergeFrom(const Status& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.Status) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.reason().size() > 0) { + + reason_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.reason_); + } + if (from.error_code() != 0) { + set_error_code(from.error_code()); + } +} + +void Status::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.Status) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Status::CopyFrom(const Status& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.Status) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Status::IsInitialized() const { + return true; +} + +void Status::InternalSwap(Status* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + reason_.Swap(&other->reason_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(error_code_, other->error_code_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Status::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void KeyValuePair::InitAsDefaultInstance() { +} +class KeyValuePair::_Internal { + public: +}; + +KeyValuePair::KeyValuePair() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.KeyValuePair) +} +KeyValuePair::KeyValuePair(const KeyValuePair& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + key_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.key().empty()) { + key_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.key_); + } + value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.value().empty()) { + value_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.value_); + } + // @@protoc_insertion_point(copy_constructor:milvus.grpc.KeyValuePair) +} + +void KeyValuePair::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_KeyValuePair_message_2eproto.base); + key_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +KeyValuePair::~KeyValuePair() { + // @@protoc_insertion_point(destructor:milvus.grpc.KeyValuePair) + SharedDtor(); +} + +void KeyValuePair::SharedDtor() { + key_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + value_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void KeyValuePair::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const KeyValuePair& KeyValuePair::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_KeyValuePair_message_2eproto.base); + return *internal_default_instance(); +} + + +void KeyValuePair::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.KeyValuePair) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + key_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + value_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* KeyValuePair::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // string key = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_key(), ptr, ctx, "milvus.grpc.KeyValuePair.key"); + CHK_(ptr); + } else goto handle_unusual; + continue; + // string value = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_value(), ptr, ctx, "milvus.grpc.KeyValuePair.value"); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool KeyValuePair::MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + // @@protoc_insertion_point(parse_start:milvus.grpc.KeyValuePair) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // string key = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_key())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->key().data(), static_cast(this->key().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.KeyValuePair.key")); + } else { + goto handle_unusual; + } + break; + } + + // string value = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_value())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->value().data(), static_cast(this->value().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.KeyValuePair.value")); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:milvus.grpc.KeyValuePair) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.KeyValuePair) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void KeyValuePair::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.KeyValuePair) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string key = 1; + if (this->key().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->key().data(), static_cast(this->key().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.KeyValuePair.key"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->key(), output); + } + + // string value = 2; + if (this->value().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->value().data(), static_cast(this->value().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.KeyValuePair.value"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 2, this->value(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:milvus.grpc.KeyValuePair) +} + +::PROTOBUF_NAMESPACE_ID::uint8* KeyValuePair::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.KeyValuePair) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string key = 1; + if (this->key().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->key().data(), static_cast(this->key().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.KeyValuePair.key"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 1, this->key(), target); + } + + // string value = 2; + if (this->value().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->value().data(), static_cast(this->value().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.KeyValuePair.value"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 2, this->value(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.KeyValuePair) + return target; +} + +size_t KeyValuePair::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.KeyValuePair) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // string key = 1; + if (this->key().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->key()); + } + + // string value = 2; + if (this->value().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->value()); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void KeyValuePair::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.KeyValuePair) + GOOGLE_DCHECK_NE(&from, this); + const KeyValuePair* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.KeyValuePair) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.KeyValuePair) + MergeFrom(*source); + } +} + +void KeyValuePair::MergeFrom(const KeyValuePair& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.KeyValuePair) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.key().size() > 0) { + + key_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.key_); + } + if (from.value().size() > 0) { + + value_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.value_); + } +} + +void KeyValuePair::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.KeyValuePair) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void KeyValuePair::CopyFrom(const KeyValuePair& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.KeyValuePair) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool KeyValuePair::IsInitialized() const { + return true; +} + +void KeyValuePair::InternalSwap(KeyValuePair* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + key_.Swap(&other->key_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + value_.Swap(&other->value_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} + +::PROTOBUF_NAMESPACE_ID::Metadata KeyValuePair::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void CollectionName::InitAsDefaultInstance() { +} +class CollectionName::_Internal { + public: +}; + +CollectionName::CollectionName() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.CollectionName) +} +CollectionName::CollectionName(const CollectionName& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.collection_name().empty()) { + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); + } + // @@protoc_insertion_point(copy_constructor:milvus.grpc.CollectionName) +} + +void CollectionName::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_CollectionName_message_2eproto.base); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +CollectionName::~CollectionName() { + // @@protoc_insertion_point(destructor:milvus.grpc.CollectionName) + SharedDtor(); +} + +void CollectionName::SharedDtor() { + collection_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void CollectionName::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const CollectionName& CollectionName::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_CollectionName_message_2eproto.base); + return *internal_default_instance(); +} + + +void CollectionName::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.CollectionName) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* CollectionName::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // string collection_name = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_collection_name(), ptr, ctx, "milvus.grpc.CollectionName.collection_name"); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool CollectionName::MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + // @@protoc_insertion_point(parse_start:milvus.grpc.CollectionName) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // string collection_name = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_collection_name())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.CollectionName.collection_name")); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:milvus.grpc.CollectionName) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.CollectionName) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void CollectionName::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.CollectionName) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string collection_name = 1; + if (this->collection_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.CollectionName.collection_name"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->collection_name(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:milvus.grpc.CollectionName) +} + +::PROTOBUF_NAMESPACE_ID::uint8* CollectionName::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.CollectionName) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string collection_name = 1; + if (this->collection_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.CollectionName.collection_name"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 1, this->collection_name(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.CollectionName) + return target; +} + +size_t CollectionName::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.CollectionName) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // string collection_name = 1; + if (this->collection_name().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->collection_name()); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void CollectionName::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.CollectionName) + GOOGLE_DCHECK_NE(&from, this); + const CollectionName* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.CollectionName) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.CollectionName) + MergeFrom(*source); + } +} + +void CollectionName::MergeFrom(const CollectionName& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.CollectionName) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.collection_name().size() > 0) { + + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); + } +} + +void CollectionName::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.CollectionName) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void CollectionName::CopyFrom(const CollectionName& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.CollectionName) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool CollectionName::IsInitialized() const { + return true; +} + +void CollectionName::InternalSwap(CollectionName* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + collection_name_.Swap(&other->collection_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} + +::PROTOBUF_NAMESPACE_ID::Metadata CollectionName::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void CollectionNameList::InitAsDefaultInstance() { + ::milvus::grpc::_CollectionNameList_default_instance_._instance.get_mutable()->status_ = const_cast< ::milvus::grpc::Status*>( + ::milvus::grpc::Status::internal_default_instance()); +} +class CollectionNameList::_Internal { + public: + static const ::milvus::grpc::Status& status(const CollectionNameList* msg); +}; + +const ::milvus::grpc::Status& +CollectionNameList::_Internal::status(const CollectionNameList* msg) { + return *msg->status_; +} +CollectionNameList::CollectionNameList() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.CollectionNameList) +} +CollectionNameList::CollectionNameList(const CollectionNameList& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + collection_names_(from.collection_names_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + if (from.has_status()) { + status_ = new ::milvus::grpc::Status(*from.status_); + } else { + status_ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:milvus.grpc.CollectionNameList) +} + +void CollectionNameList::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_CollectionNameList_message_2eproto.base); + status_ = nullptr; +} + +CollectionNameList::~CollectionNameList() { + // @@protoc_insertion_point(destructor:milvus.grpc.CollectionNameList) + SharedDtor(); +} + +void CollectionNameList::SharedDtor() { + if (this != internal_default_instance()) delete status_; +} + +void CollectionNameList::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const CollectionNameList& CollectionNameList::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_CollectionNameList_message_2eproto.base); + return *internal_default_instance(); +} + + +void CollectionNameList::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.CollectionNameList) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + collection_names_.Clear(); + if (GetArenaNoVirtual() == nullptr && status_ != nullptr) { + delete status_; + } + status_ = nullptr; + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* CollectionNameList::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // .milvus.grpc.Status status = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(mutable_status(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated string collection_names = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr -= 1; + do { + ptr += 1; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(add_collection_names(), ptr, ctx, "milvus.grpc.CollectionNameList.collection_names"); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 18); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool CollectionNameList::MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + // @@protoc_insertion_point(parse_start:milvus.grpc.CollectionNameList) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // .milvus.grpc.Status status = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, mutable_status())); + } else { + goto handle_unusual; + } + break; + } + + // repeated string collection_names = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->add_collection_names())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_names(this->collection_names_size() - 1).data(), + static_cast(this->collection_names(this->collection_names_size() - 1).length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.CollectionNameList.collection_names")); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:milvus.grpc.CollectionNameList) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.CollectionNameList) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void CollectionNameList::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.CollectionNameList) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.grpc.Status status = 1; + if (this->has_status()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, _Internal::status(this), output); + } + + // repeated string collection_names = 2; + for (int i = 0, n = this->collection_names_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_names(i).data(), static_cast(this->collection_names(i).length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.CollectionNameList.collection_names"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteString( + 2, this->collection_names(i), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:milvus.grpc.CollectionNameList) +} + +::PROTOBUF_NAMESPACE_ID::uint8* CollectionNameList::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.CollectionNameList) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.grpc.Status status = 1; + if (this->has_status()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 1, _Internal::status(this), target); + } + + // repeated string collection_names = 2; + for (int i = 0, n = this->collection_names_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_names(i).data(), static_cast(this->collection_names(i).length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.CollectionNameList.collection_names"); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + WriteStringToArray(2, this->collection_names(i), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.CollectionNameList) + return target; +} + +size_t CollectionNameList::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.CollectionNameList) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated string collection_names = 2; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->collection_names_size()); + for (int i = 0, n = this->collection_names_size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->collection_names(i)); + } + + // .milvus.grpc.Status status = 1; + if (this->has_status()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *status_); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void CollectionNameList::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.CollectionNameList) + GOOGLE_DCHECK_NE(&from, this); + const CollectionNameList* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.CollectionNameList) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.CollectionNameList) + MergeFrom(*source); + } +} + +void CollectionNameList::MergeFrom(const CollectionNameList& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.CollectionNameList) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + collection_names_.MergeFrom(from.collection_names_); + if (from.has_status()) { + mutable_status()->::milvus::grpc::Status::MergeFrom(from.status()); + } +} + +void CollectionNameList::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.CollectionNameList) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void CollectionNameList::CopyFrom(const CollectionNameList& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.CollectionNameList) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool CollectionNameList::IsInitialized() const { + return true; +} + +void CollectionNameList::InternalSwap(CollectionNameList* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + collection_names_.InternalSwap(CastToBase(&other->collection_names_)); + swap(status_, other->status_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata CollectionNameList::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void FieldName::InitAsDefaultInstance() { +} +class FieldName::_Internal { + public: +}; + +FieldName::FieldName() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.FieldName) +} +FieldName::FieldName(const FieldName& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.collection_name().empty()) { + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); + } + field_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.field_name().empty()) { + field_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.field_name_); + } + // @@protoc_insertion_point(copy_constructor:milvus.grpc.FieldName) +} + +void FieldName::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_FieldName_message_2eproto.base); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + field_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +FieldName::~FieldName() { + // @@protoc_insertion_point(destructor:milvus.grpc.FieldName) + SharedDtor(); +} + +void FieldName::SharedDtor() { + collection_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + field_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void FieldName::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const FieldName& FieldName::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_FieldName_message_2eproto.base); + return *internal_default_instance(); +} + + +void FieldName::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.FieldName) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + field_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* FieldName::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // string collection_name = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_collection_name(), ptr, ctx, "milvus.grpc.FieldName.collection_name"); + CHK_(ptr); + } else goto handle_unusual; + continue; + // string field_name = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_field_name(), ptr, ctx, "milvus.grpc.FieldName.field_name"); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool FieldName::MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + // @@protoc_insertion_point(parse_start:milvus.grpc.FieldName) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // string collection_name = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_collection_name())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.FieldName.collection_name")); + } else { + goto handle_unusual; + } + break; + } + + // string field_name = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_field_name())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->field_name().data(), static_cast(this->field_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.FieldName.field_name")); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:milvus.grpc.FieldName) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.FieldName) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void FieldName::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.FieldName) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string collection_name = 1; + if (this->collection_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.FieldName.collection_name"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->collection_name(), output); + } + + // string field_name = 2; + if (this->field_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->field_name().data(), static_cast(this->field_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.FieldName.field_name"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 2, this->field_name(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:milvus.grpc.FieldName) +} + +::PROTOBUF_NAMESPACE_ID::uint8* FieldName::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.FieldName) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string collection_name = 1; + if (this->collection_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.FieldName.collection_name"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 1, this->collection_name(), target); + } + + // string field_name = 2; + if (this->field_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->field_name().data(), static_cast(this->field_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.FieldName.field_name"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 2, this->field_name(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.FieldName) + return target; +} + +size_t FieldName::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.FieldName) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // string collection_name = 1; + if (this->collection_name().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->collection_name()); + } + + // string field_name = 2; + if (this->field_name().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->field_name()); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void FieldName::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.FieldName) + GOOGLE_DCHECK_NE(&from, this); + const FieldName* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.FieldName) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.FieldName) + MergeFrom(*source); + } +} + +void FieldName::MergeFrom(const FieldName& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.FieldName) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.collection_name().size() > 0) { + + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); + } + if (from.field_name().size() > 0) { + + field_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.field_name_); + } +} + +void FieldName::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.FieldName) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void FieldName::CopyFrom(const FieldName& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.FieldName) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool FieldName::IsInitialized() const { + return true; +} + +void FieldName::InternalSwap(FieldName* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + collection_name_.Swap(&other->collection_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + field_name_.Swap(&other->field_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} + +::PROTOBUF_NAMESPACE_ID::Metadata FieldName::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void Mapping::InitAsDefaultInstance() { + ::milvus::grpc::_Mapping_default_instance_._instance.get_mutable()->status_ = const_cast< ::milvus::grpc::Status*>( + ::milvus::grpc::Status::internal_default_instance()); + ::milvus::grpc::_Mapping_default_instance_._instance.get_mutable()->schema_ = const_cast< ::milvus::grpc::Schema*>( + ::milvus::grpc::Schema::internal_default_instance()); +} +class Mapping::_Internal { + public: + static const ::milvus::grpc::Status& status(const Mapping* msg); + static const ::milvus::grpc::Schema& schema(const Mapping* msg); +}; + +const ::milvus::grpc::Status& +Mapping::_Internal::status(const Mapping* msg) { + return *msg->status_; +} +const ::milvus::grpc::Schema& +Mapping::_Internal::schema(const Mapping* msg) { + return *msg->schema_; +} +Mapping::Mapping() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.Mapping) +} +Mapping::Mapping(const Mapping& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + extra_params_(from.extra_params_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.collection_name().empty()) { + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); + } + if (from.has_status()) { + status_ = new ::milvus::grpc::Status(*from.status_); + } else { + status_ = nullptr; + } + if (from.has_schema()) { + schema_ = new ::milvus::grpc::Schema(*from.schema_); + } else { + schema_ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:milvus.grpc.Mapping) +} + +void Mapping::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Mapping_message_2eproto.base); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + ::memset(&status_, 0, static_cast( + reinterpret_cast(&schema_) - + reinterpret_cast(&status_)) + sizeof(schema_)); +} + +Mapping::~Mapping() { + // @@protoc_insertion_point(destructor:milvus.grpc.Mapping) + SharedDtor(); +} + +void Mapping::SharedDtor() { + collection_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (this != internal_default_instance()) delete status_; + if (this != internal_default_instance()) delete schema_; +} + +void Mapping::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const Mapping& Mapping::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_Mapping_message_2eproto.base); + return *internal_default_instance(); +} + + +void Mapping::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.Mapping) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + extra_params_.Clear(); + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (GetArenaNoVirtual() == nullptr && status_ != nullptr) { + delete status_; + } + status_ = nullptr; + if (GetArenaNoVirtual() == nullptr && schema_ != nullptr) { + delete schema_; + } + schema_ = nullptr; + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* Mapping::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // .milvus.grpc.Status status = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(mutable_status(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // string collection_name = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_collection_name(), ptr, ctx, "milvus.grpc.Mapping.collection_name"); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .milvus.grpc.Schema schema = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr = ctx->ParseMessage(mutable_schema(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(add_extra_params(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 34); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool Mapping::MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + // @@protoc_insertion_point(parse_start:milvus.grpc.Mapping) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // .milvus.grpc.Status status = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, mutable_status())); + } else { + goto handle_unusual; + } + break; + } + + // string collection_name = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_collection_name())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.Mapping.collection_name")); + } else { + goto handle_unusual; + } + break; + } + + // .milvus.grpc.Schema schema = 3; + case 3: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, mutable_schema())); + } else { + goto handle_unusual; + } + break; + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + case 4: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (34 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, add_extra_params())); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:milvus.grpc.Mapping) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.Mapping) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void Mapping::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.Mapping) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.grpc.Status status = 1; + if (this->has_status()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, _Internal::status(this), output); + } + + // string collection_name = 2; + if (this->collection_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.Mapping.collection_name"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 2, this->collection_name(), output); + } + + // .milvus.grpc.Schema schema = 3; + if (this->has_schema()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 3, _Internal::schema(this), output); + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + for (unsigned int i = 0, + n = static_cast(this->extra_params_size()); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 4, + this->extra_params(static_cast(i)), + output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:milvus.grpc.Mapping) +} + +::PROTOBUF_NAMESPACE_ID::uint8* Mapping::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.Mapping) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.grpc.Status status = 1; + if (this->has_status()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 1, _Internal::status(this), target); + } + + // string collection_name = 2; + if (this->collection_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.Mapping.collection_name"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 2, this->collection_name(), target); + } + + // .milvus.grpc.Schema schema = 3; + if (this->has_schema()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 3, _Internal::schema(this), target); + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + for (unsigned int i = 0, + n = static_cast(this->extra_params_size()); i < n; i++) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 4, this->extra_params(static_cast(i)), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.Mapping) + return target; +} + +size_t Mapping::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.Mapping) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + { + unsigned int count = static_cast(this->extra_params_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + this->extra_params(static_cast(i))); + } + } + + // string collection_name = 2; + if (this->collection_name().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->collection_name()); + } + + // .milvus.grpc.Status status = 1; + if (this->has_status()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *status_); + } + + // .milvus.grpc.Schema schema = 3; + if (this->has_schema()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *schema_); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Mapping::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.Mapping) + GOOGLE_DCHECK_NE(&from, this); + const Mapping* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.Mapping) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.Mapping) + MergeFrom(*source); + } +} + +void Mapping::MergeFrom(const Mapping& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.Mapping) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + extra_params_.MergeFrom(from.extra_params_); + if (from.collection_name().size() > 0) { + + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); + } + if (from.has_status()) { + mutable_status()->::milvus::grpc::Status::MergeFrom(from.status()); + } + if (from.has_schema()) { + mutable_schema()->::milvus::grpc::Schema::MergeFrom(from.schema()); + } +} + +void Mapping::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.Mapping) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Mapping::CopyFrom(const Mapping& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.Mapping) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Mapping::IsInitialized() const { + return true; +} + +void Mapping::InternalSwap(Mapping* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + CastToBase(&extra_params_)->InternalSwap(CastToBase(&other->extra_params_)); + collection_name_.Swap(&other->collection_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(status_, other->status_); + swap(schema_, other->schema_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Mapping::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void MappingList::InitAsDefaultInstance() { + ::milvus::grpc::_MappingList_default_instance_._instance.get_mutable()->status_ = const_cast< ::milvus::grpc::Status*>( + ::milvus::grpc::Status::internal_default_instance()); +} +class MappingList::_Internal { + public: + static const ::milvus::grpc::Status& status(const MappingList* msg); +}; + +const ::milvus::grpc::Status& +MappingList::_Internal::status(const MappingList* msg) { + return *msg->status_; +} +MappingList::MappingList() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.MappingList) +} +MappingList::MappingList(const MappingList& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + mapping_list_(from.mapping_list_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + if (from.has_status()) { + status_ = new ::milvus::grpc::Status(*from.status_); + } else { + status_ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:milvus.grpc.MappingList) +} + +void MappingList::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_MappingList_message_2eproto.base); + status_ = nullptr; +} + +MappingList::~MappingList() { + // @@protoc_insertion_point(destructor:milvus.grpc.MappingList) + SharedDtor(); +} + +void MappingList::SharedDtor() { + if (this != internal_default_instance()) delete status_; +} + +void MappingList::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const MappingList& MappingList::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_MappingList_message_2eproto.base); + return *internal_default_instance(); +} + + +void MappingList::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.MappingList) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + mapping_list_.Clear(); + if (GetArenaNoVirtual() == nullptr && status_ != nullptr) { + delete status_; + } + status_ = nullptr; + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* MappingList::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // .milvus.grpc.Status status = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(mutable_status(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated .milvus.grpc.Mapping mapping_list = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(add_mapping_list(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 18); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool MappingList::MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + // @@protoc_insertion_point(parse_start:milvus.grpc.MappingList) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // .milvus.grpc.Status status = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, mutable_status())); + } else { + goto handle_unusual; + } + break; + } + + // repeated .milvus.grpc.Mapping mapping_list = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, add_mapping_list())); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:milvus.grpc.MappingList) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.MappingList) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void MappingList::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.MappingList) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.grpc.Status status = 1; + if (this->has_status()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, _Internal::status(this), output); + } + + // repeated .milvus.grpc.Mapping mapping_list = 2; + for (unsigned int i = 0, + n = static_cast(this->mapping_list_size()); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, + this->mapping_list(static_cast(i)), + output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:milvus.grpc.MappingList) +} + +::PROTOBUF_NAMESPACE_ID::uint8* MappingList::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.MappingList) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.grpc.Status status = 1; + if (this->has_status()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 1, _Internal::status(this), target); + } + + // repeated .milvus.grpc.Mapping mapping_list = 2; + for (unsigned int i = 0, + n = static_cast(this->mapping_list_size()); i < n; i++) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 2, this->mapping_list(static_cast(i)), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.MappingList) + return target; +} + +size_t MappingList::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.MappingList) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .milvus.grpc.Mapping mapping_list = 2; + { + unsigned int count = static_cast(this->mapping_list_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + this->mapping_list(static_cast(i))); + } + } + + // .milvus.grpc.Status status = 1; + if (this->has_status()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *status_); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void MappingList::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.MappingList) + GOOGLE_DCHECK_NE(&from, this); + const MappingList* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.MappingList) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.MappingList) + MergeFrom(*source); + } +} + +void MappingList::MergeFrom(const MappingList& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.MappingList) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + mapping_list_.MergeFrom(from.mapping_list_); + if (from.has_status()) { + mutable_status()->::milvus::grpc::Status::MergeFrom(from.status()); + } +} + +void MappingList::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.MappingList) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void MappingList::CopyFrom(const MappingList& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.MappingList) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool MappingList::IsInitialized() const { + return true; +} + +void MappingList::InternalSwap(MappingList* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + CastToBase(&mapping_list_)->InternalSwap(CastToBase(&other->mapping_list_)); + swap(status_, other->status_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata MappingList::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void PartitionParam::InitAsDefaultInstance() { +} +class PartitionParam::_Internal { + public: +}; + +PartitionParam::PartitionParam() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.PartitionParam) +} +PartitionParam::PartitionParam(const PartitionParam& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.collection_name().empty()) { + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); + } + tag_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.tag().empty()) { + tag_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.tag_); + } + // @@protoc_insertion_point(copy_constructor:milvus.grpc.PartitionParam) +} + +void PartitionParam::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_PartitionParam_message_2eproto.base); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + tag_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +PartitionParam::~PartitionParam() { + // @@protoc_insertion_point(destructor:milvus.grpc.PartitionParam) + SharedDtor(); +} + +void PartitionParam::SharedDtor() { + collection_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + tag_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void PartitionParam::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const PartitionParam& PartitionParam::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_PartitionParam_message_2eproto.base); + return *internal_default_instance(); +} + + +void PartitionParam::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.PartitionParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + tag_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* PartitionParam::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // string collection_name = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_collection_name(), ptr, ctx, "milvus.grpc.PartitionParam.collection_name"); + CHK_(ptr); + } else goto handle_unusual; + continue; + // string tag = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_tag(), ptr, ctx, "milvus.grpc.PartitionParam.tag"); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool PartitionParam::MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + // @@protoc_insertion_point(parse_start:milvus.grpc.PartitionParam) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // string collection_name = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_collection_name())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.PartitionParam.collection_name")); + } else { + goto handle_unusual; + } + break; + } + + // string tag = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_tag())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->tag().data(), static_cast(this->tag().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.PartitionParam.tag")); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:milvus.grpc.PartitionParam) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.PartitionParam) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void PartitionParam::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.PartitionParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string collection_name = 1; + if (this->collection_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.PartitionParam.collection_name"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->collection_name(), output); + } + + // string tag = 2; + if (this->tag().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->tag().data(), static_cast(this->tag().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.PartitionParam.tag"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 2, this->tag(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:milvus.grpc.PartitionParam) +} + +::PROTOBUF_NAMESPACE_ID::uint8* PartitionParam::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.PartitionParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string collection_name = 1; + if (this->collection_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.PartitionParam.collection_name"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 1, this->collection_name(), target); + } + + // string tag = 2; + if (this->tag().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->tag().data(), static_cast(this->tag().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.PartitionParam.tag"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 2, this->tag(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.PartitionParam) + return target; +} + +size_t PartitionParam::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.PartitionParam) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // string collection_name = 1; + if (this->collection_name().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->collection_name()); + } + + // string tag = 2; + if (this->tag().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->tag()); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void PartitionParam::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.PartitionParam) + GOOGLE_DCHECK_NE(&from, this); + const PartitionParam* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.PartitionParam) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.PartitionParam) + MergeFrom(*source); + } +} + +void PartitionParam::MergeFrom(const PartitionParam& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.PartitionParam) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.collection_name().size() > 0) { + + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); + } + if (from.tag().size() > 0) { + + tag_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.tag_); + } +} + +void PartitionParam::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.PartitionParam) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void PartitionParam::CopyFrom(const PartitionParam& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.PartitionParam) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool PartitionParam::IsInitialized() const { + return true; +} + +void PartitionParam::InternalSwap(PartitionParam* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + collection_name_.Swap(&other->collection_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + tag_.Swap(&other->tag_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} + +::PROTOBUF_NAMESPACE_ID::Metadata PartitionParam::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void PartitionList::InitAsDefaultInstance() { + ::milvus::grpc::_PartitionList_default_instance_._instance.get_mutable()->status_ = const_cast< ::milvus::grpc::Status*>( + ::milvus::grpc::Status::internal_default_instance()); +} +class PartitionList::_Internal { + public: + static const ::milvus::grpc::Status& status(const PartitionList* msg); +}; + +const ::milvus::grpc::Status& +PartitionList::_Internal::status(const PartitionList* msg) { + return *msg->status_; +} +PartitionList::PartitionList() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.PartitionList) +} +PartitionList::PartitionList(const PartitionList& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + partition_tag_array_(from.partition_tag_array_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + if (from.has_status()) { + status_ = new ::milvus::grpc::Status(*from.status_); + } else { + status_ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:milvus.grpc.PartitionList) +} + +void PartitionList::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_PartitionList_message_2eproto.base); + status_ = nullptr; +} + +PartitionList::~PartitionList() { + // @@protoc_insertion_point(destructor:milvus.grpc.PartitionList) + SharedDtor(); +} + +void PartitionList::SharedDtor() { + if (this != internal_default_instance()) delete status_; +} + +void PartitionList::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const PartitionList& PartitionList::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_PartitionList_message_2eproto.base); + return *internal_default_instance(); +} + + +void PartitionList::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.PartitionList) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + partition_tag_array_.Clear(); + if (GetArenaNoVirtual() == nullptr && status_ != nullptr) { + delete status_; + } + status_ = nullptr; + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* PartitionList::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // .milvus.grpc.Status status = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(mutable_status(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated string partition_tag_array = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr -= 1; + do { + ptr += 1; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(add_partition_tag_array(), ptr, ctx, "milvus.grpc.PartitionList.partition_tag_array"); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 18); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool PartitionList::MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + // @@protoc_insertion_point(parse_start:milvus.grpc.PartitionList) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // .milvus.grpc.Status status = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, mutable_status())); + } else { + goto handle_unusual; + } + break; + } + + // repeated string partition_tag_array = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->add_partition_tag_array())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->partition_tag_array(this->partition_tag_array_size() - 1).data(), + static_cast(this->partition_tag_array(this->partition_tag_array_size() - 1).length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.PartitionList.partition_tag_array")); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:milvus.grpc.PartitionList) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.PartitionList) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void PartitionList::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.PartitionList) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.grpc.Status status = 1; + if (this->has_status()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, _Internal::status(this), output); + } + + // repeated string partition_tag_array = 2; + for (int i = 0, n = this->partition_tag_array_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->partition_tag_array(i).data(), static_cast(this->partition_tag_array(i).length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.PartitionList.partition_tag_array"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteString( + 2, this->partition_tag_array(i), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:milvus.grpc.PartitionList) +} + +::PROTOBUF_NAMESPACE_ID::uint8* PartitionList::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.PartitionList) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.grpc.Status status = 1; + if (this->has_status()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 1, _Internal::status(this), target); + } + + // repeated string partition_tag_array = 2; + for (int i = 0, n = this->partition_tag_array_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->partition_tag_array(i).data(), static_cast(this->partition_tag_array(i).length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.PartitionList.partition_tag_array"); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + WriteStringToArray(2, this->partition_tag_array(i), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.PartitionList) + return target; +} + +size_t PartitionList::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.PartitionList) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated string partition_tag_array = 2; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->partition_tag_array_size()); + for (int i = 0, n = this->partition_tag_array_size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->partition_tag_array(i)); + } + + // .milvus.grpc.Status status = 1; + if (this->has_status()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *status_); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void PartitionList::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.PartitionList) + GOOGLE_DCHECK_NE(&from, this); + const PartitionList* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.PartitionList) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.PartitionList) + MergeFrom(*source); + } +} + +void PartitionList::MergeFrom(const PartitionList& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.PartitionList) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + partition_tag_array_.MergeFrom(from.partition_tag_array_); + if (from.has_status()) { + mutable_status()->::milvus::grpc::Status::MergeFrom(from.status()); + } +} + +void PartitionList::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.PartitionList) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void PartitionList::CopyFrom(const PartitionList& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.PartitionList) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool PartitionList::IsInitialized() const { + return true; +} + +void PartitionList::InternalSwap(PartitionList* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + partition_tag_array_.InternalSwap(CastToBase(&other->partition_tag_array_)); + swap(status_, other->status_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata PartitionList::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void VectorRowRecord::InitAsDefaultInstance() { +} +class VectorRowRecord::_Internal { + public: +}; + +VectorRowRecord::VectorRowRecord() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.VectorRowRecord) +} +VectorRowRecord::VectorRowRecord(const VectorRowRecord& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + float_data_(from.float_data_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + binary_data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.binary_data().empty()) { + binary_data_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.binary_data_); + } + // @@protoc_insertion_point(copy_constructor:milvus.grpc.VectorRowRecord) +} + +void VectorRowRecord::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_VectorRowRecord_message_2eproto.base); + binary_data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +VectorRowRecord::~VectorRowRecord() { + // @@protoc_insertion_point(destructor:milvus.grpc.VectorRowRecord) + SharedDtor(); +} + +void VectorRowRecord::SharedDtor() { + binary_data_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void VectorRowRecord::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const VectorRowRecord& VectorRowRecord::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_VectorRowRecord_message_2eproto.base); + return *internal_default_instance(); +} + + +void VectorRowRecord::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.VectorRowRecord) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + float_data_.Clear(); + binary_data_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* VectorRowRecord::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // repeated float float_data = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser(mutable_float_data(), ptr, ctx); + CHK_(ptr); + } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 13) { + add_float_data(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); + ptr += sizeof(float); + } else goto handle_unusual; + continue; + // bytes binary_data = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(mutable_binary_data(), ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool VectorRowRecord::MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + // @@protoc_insertion_point(parse_start:milvus.grpc.VectorRowRecord) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // repeated float float_data = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPackedPrimitive< + float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>( + input, this->mutable_float_data()))); + } else if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (13 & 0xFF)) { + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< + float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>( + 1, 10u, input, this->mutable_float_data()))); + } else { + goto handle_unusual; + } + break; + } + + // bytes binary_data = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadBytes( + input, this->mutable_binary_data())); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:milvus.grpc.VectorRowRecord) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.VectorRowRecord) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void VectorRowRecord::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.VectorRowRecord) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated float float_data = 1; + if (this->float_data_size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTag(1, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(_float_data_cached_byte_size_.load( + std::memory_order_relaxed)); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatArray( + this->float_data().data(), this->float_data_size(), output); + } + + // bytes binary_data = 2; + if (this->binary_data().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesMaybeAliased( + 2, this->binary_data(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:milvus.grpc.VectorRowRecord) +} + +::PROTOBUF_NAMESPACE_ID::uint8* VectorRowRecord::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.VectorRowRecord) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated float float_data = 1; + if (this->float_data_size() > 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTagToArray( + 1, + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + target); + target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray( + _float_data_cached_byte_size_.load(std::memory_order_relaxed), + target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + WriteFloatNoTagToArray(this->float_data_, target); + } + + // bytes binary_data = 2; + if (this->binary_data().size() > 0) { + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesToArray( + 2, this->binary_data(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.VectorRowRecord) + return target; +} + +size_t VectorRowRecord::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.VectorRowRecord) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated float float_data = 1; + { + unsigned int count = static_cast(this->float_data_size()); + size_t data_size = 4UL * count; + if (data_size > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size)); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size); + _float_data_cached_byte_size_.store(cached_size, + std::memory_order_relaxed); + total_size += data_size; + } + + // bytes binary_data = 2; + if (this->binary_data().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->binary_data()); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void VectorRowRecord::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.VectorRowRecord) + GOOGLE_DCHECK_NE(&from, this); + const VectorRowRecord* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.VectorRowRecord) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.VectorRowRecord) + MergeFrom(*source); + } +} + +void VectorRowRecord::MergeFrom(const VectorRowRecord& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.VectorRowRecord) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + float_data_.MergeFrom(from.float_data_); + if (from.binary_data().size() > 0) { + + binary_data_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.binary_data_); + } +} + +void VectorRowRecord::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.VectorRowRecord) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void VectorRowRecord::CopyFrom(const VectorRowRecord& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.VectorRowRecord) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool VectorRowRecord::IsInitialized() const { + return true; +} + +void VectorRowRecord::InternalSwap(VectorRowRecord* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + float_data_.InternalSwap(&other->float_data_); + binary_data_.Swap(&other->binary_data_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} + +::PROTOBUF_NAMESPACE_ID::Metadata VectorRowRecord::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void EntityIds::InitAsDefaultInstance() { + ::milvus::grpc::_EntityIds_default_instance_._instance.get_mutable()->status_ = const_cast< ::milvus::grpc::Status*>( + ::milvus::grpc::Status::internal_default_instance()); +} +class EntityIds::_Internal { + public: + static const ::milvus::grpc::Status& status(const EntityIds* msg); +}; + +const ::milvus::grpc::Status& +EntityIds::_Internal::status(const EntityIds* msg) { + return *msg->status_; +} +EntityIds::EntityIds() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.EntityIds) +} +EntityIds::EntityIds(const EntityIds& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + entity_id_array_(from.entity_id_array_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + if (from.has_status()) { + status_ = new ::milvus::grpc::Status(*from.status_); + } else { + status_ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:milvus.grpc.EntityIds) +} + +void EntityIds::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_EntityIds_message_2eproto.base); + status_ = nullptr; +} + +EntityIds::~EntityIds() { + // @@protoc_insertion_point(destructor:milvus.grpc.EntityIds) + SharedDtor(); +} + +void EntityIds::SharedDtor() { + if (this != internal_default_instance()) delete status_; +} + +void EntityIds::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const EntityIds& EntityIds::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_EntityIds_message_2eproto.base); + return *internal_default_instance(); +} + + +void EntityIds::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.EntityIds) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + entity_id_array_.Clear(); + if (GetArenaNoVirtual() == nullptr && status_ != nullptr) { + delete status_; + } + status_ = nullptr; + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* EntityIds::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // .milvus.grpc.Status status = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(mutable_status(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated int64 entity_id_array = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt64Parser(mutable_entity_id_array(), ptr, ctx); + CHK_(ptr); + } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16) { + add_entity_id_array(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr)); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool EntityIds::MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + // @@protoc_insertion_point(parse_start:milvus.grpc.EntityIds) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // .milvus.grpc.Status status = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, mutable_status())); + } else { + goto handle_unusual; + } + break; + } + + // repeated int64 entity_id_array = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPackedPrimitive< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + input, this->mutable_entity_id_array()))); + } else if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) { + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + 1, 18u, input, this->mutable_entity_id_array()))); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:milvus.grpc.EntityIds) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.EntityIds) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void EntityIds::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.EntityIds) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.grpc.Status status = 1; + if (this->has_status()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, _Internal::status(this), output); + } + + // repeated int64 entity_id_array = 2; + if (this->entity_id_array_size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTag(2, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(_entity_id_array_cached_byte_size_.load( + std::memory_order_relaxed)); + } + for (int i = 0, n = this->entity_id_array_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64NoTag( + this->entity_id_array(i), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:milvus.grpc.EntityIds) +} + +::PROTOBUF_NAMESPACE_ID::uint8* EntityIds::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.EntityIds) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.grpc.Status status = 1; + if (this->has_status()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 1, _Internal::status(this), target); + } + + // repeated int64 entity_id_array = 2; + if (this->entity_id_array_size() > 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTagToArray( + 2, + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + target); + target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray( + _entity_id_array_cached_byte_size_.load(std::memory_order_relaxed), + target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + WriteInt64NoTagToArray(this->entity_id_array_, target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.EntityIds) + return target; +} + +size_t EntityIds::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.EntityIds) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated int64 entity_id_array = 2; + { + size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + Int64Size(this->entity_id_array_); + if (data_size > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size)); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size); + _entity_id_array_cached_byte_size_.store(cached_size, + std::memory_order_relaxed); + total_size += data_size; + } + + // .milvus.grpc.Status status = 1; + if (this->has_status()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *status_); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void EntityIds::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.EntityIds) + GOOGLE_DCHECK_NE(&from, this); + const EntityIds* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.EntityIds) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.EntityIds) + MergeFrom(*source); + } +} + +void EntityIds::MergeFrom(const EntityIds& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.EntityIds) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + entity_id_array_.MergeFrom(from.entity_id_array_); + if (from.has_status()) { + mutable_status()->::milvus::grpc::Status::MergeFrom(from.status()); + } +} + +void EntityIds::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.EntityIds) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void EntityIds::CopyFrom(const EntityIds& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.EntityIds) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool EntityIds::IsInitialized() const { + return true; +} + +void EntityIds::InternalSwap(EntityIds* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + entity_id_array_.InternalSwap(&other->entity_id_array_); + swap(status_, other->status_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata EntityIds::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void VectorRecord::InitAsDefaultInstance() { +} +class VectorRecord::_Internal { + public: +}; + +VectorRecord::VectorRecord() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.VectorRecord) +} +VectorRecord::VectorRecord(const VectorRecord& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + records_(from.records_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:milvus.grpc.VectorRecord) +} + +void VectorRecord::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_VectorRecord_message_2eproto.base); +} + +VectorRecord::~VectorRecord() { + // @@protoc_insertion_point(destructor:milvus.grpc.VectorRecord) + SharedDtor(); +} + +void VectorRecord::SharedDtor() { +} + +void VectorRecord::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const VectorRecord& VectorRecord::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_VectorRecord_message_2eproto.base); + return *internal_default_instance(); +} + + +void VectorRecord::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.VectorRecord) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + records_.Clear(); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* VectorRecord::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // repeated .milvus.grpc.VectorRowRecord records = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(add_records(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 10); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool VectorRecord::MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + // @@protoc_insertion_point(parse_start:milvus.grpc.VectorRecord) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // repeated .milvus.grpc.VectorRowRecord records = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, add_records())); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:milvus.grpc.VectorRecord) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.VectorRecord) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void VectorRecord::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.VectorRecord) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated .milvus.grpc.VectorRowRecord records = 1; + for (unsigned int i = 0, + n = static_cast(this->records_size()); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, + this->records(static_cast(i)), + output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:milvus.grpc.VectorRecord) +} + +::PROTOBUF_NAMESPACE_ID::uint8* VectorRecord::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.VectorRecord) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated .milvus.grpc.VectorRowRecord records = 1; + for (unsigned int i = 0, + n = static_cast(this->records_size()); i < n; i++) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 1, this->records(static_cast(i)), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.VectorRecord) + return target; +} + +size_t VectorRecord::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.VectorRecord) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .milvus.grpc.VectorRowRecord records = 1; + { + unsigned int count = static_cast(this->records_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + this->records(static_cast(i))); + } + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void VectorRecord::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.VectorRecord) + GOOGLE_DCHECK_NE(&from, this); + const VectorRecord* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.VectorRecord) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.VectorRecord) + MergeFrom(*source); + } +} + +void VectorRecord::MergeFrom(const VectorRecord& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.VectorRecord) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + records_.MergeFrom(from.records_); +} + +void VectorRecord::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.VectorRecord) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void VectorRecord::CopyFrom(const VectorRecord& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.VectorRecord) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool VectorRecord::IsInitialized() const { + return true; +} + +void VectorRecord::InternalSwap(VectorRecord* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + CastToBase(&records_)->InternalSwap(CastToBase(&other->records_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata VectorRecord::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void VectorParam::InitAsDefaultInstance() { + ::milvus::grpc::_VectorParam_default_instance_._instance.get_mutable()->row_record_ = const_cast< ::milvus::grpc::VectorRecord*>( + ::milvus::grpc::VectorRecord::internal_default_instance()); +} +class VectorParam::_Internal { + public: + static const ::milvus::grpc::VectorRecord& row_record(const VectorParam* msg); +}; + +const ::milvus::grpc::VectorRecord& +VectorParam::_Internal::row_record(const VectorParam* msg) { + return *msg->row_record_; +} +VectorParam::VectorParam() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.VectorParam) +} +VectorParam::VectorParam(const VectorParam& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + json_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.json().empty()) { + json_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.json_); + } + if (from.has_row_record()) { + row_record_ = new ::milvus::grpc::VectorRecord(*from.row_record_); + } else { + row_record_ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:milvus.grpc.VectorParam) +} + +void VectorParam::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_VectorParam_message_2eproto.base); + json_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + row_record_ = nullptr; +} + +VectorParam::~VectorParam() { + // @@protoc_insertion_point(destructor:milvus.grpc.VectorParam) + SharedDtor(); +} + +void VectorParam::SharedDtor() { + json_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (this != internal_default_instance()) delete row_record_; +} + +void VectorParam::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const VectorParam& VectorParam::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_VectorParam_message_2eproto.base); + return *internal_default_instance(); +} + + +void VectorParam::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.VectorParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + json_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (GetArenaNoVirtual() == nullptr && row_record_ != nullptr) { + delete row_record_; + } + row_record_ = nullptr; + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* VectorParam::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // string json = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_json(), ptr, ctx, "milvus.grpc.VectorParam.json"); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .milvus.grpc.VectorRecord row_record = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(mutable_row_record(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool VectorParam::MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + // @@protoc_insertion_point(parse_start:milvus.grpc.VectorParam) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // string json = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_json())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->json().data(), static_cast(this->json().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.VectorParam.json")); + } else { + goto handle_unusual; + } + break; + } + + // .milvus.grpc.VectorRecord row_record = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, mutable_row_record())); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:milvus.grpc.VectorParam) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.VectorParam) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void VectorParam::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.VectorParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string json = 1; + if (this->json().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->json().data(), static_cast(this->json().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.VectorParam.json"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->json(), output); + } + + // .milvus.grpc.VectorRecord row_record = 2; + if (this->has_row_record()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, _Internal::row_record(this), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:milvus.grpc.VectorParam) +} + +::PROTOBUF_NAMESPACE_ID::uint8* VectorParam::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.VectorParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string json = 1; + if (this->json().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->json().data(), static_cast(this->json().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.VectorParam.json"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 1, this->json(), target); + } + + // .milvus.grpc.VectorRecord row_record = 2; + if (this->has_row_record()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 2, _Internal::row_record(this), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.VectorParam) + return target; +} + +size_t VectorParam::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.VectorParam) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // string json = 1; + if (this->json().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->json()); + } + + // .milvus.grpc.VectorRecord row_record = 2; + if (this->has_row_record()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *row_record_); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void VectorParam::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.VectorParam) + GOOGLE_DCHECK_NE(&from, this); + const VectorParam* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.VectorParam) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.VectorParam) + MergeFrom(*source); + } +} + +void VectorParam::MergeFrom(const VectorParam& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.VectorParam) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.json().size() > 0) { + + json_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.json_); + } + if (from.has_row_record()) { + mutable_row_record()->::milvus::grpc::VectorRecord::MergeFrom(from.row_record()); + } +} + +void VectorParam::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.VectorParam) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void VectorParam::CopyFrom(const VectorParam& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.VectorParam) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool VectorParam::IsInitialized() const { + return true; +} + +void VectorParam::InternalSwap(VectorParam* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + json_.Swap(&other->json_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(row_record_, other->row_record_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata VectorParam::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void FieldMeta::InitAsDefaultInstance() { +} +class FieldMeta::_Internal { + public: +}; + +FieldMeta::FieldMeta() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.FieldMeta) +} +FieldMeta::FieldMeta(const FieldMeta& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + field_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.field_name().empty()) { + field_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.field_name_); + } + ::memcpy(&dim_, &from.dim_, + static_cast(reinterpret_cast(&type_) - + reinterpret_cast(&dim_)) + sizeof(type_)); + // @@protoc_insertion_point(copy_constructor:milvus.grpc.FieldMeta) +} + +void FieldMeta::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_FieldMeta_message_2eproto.base); + field_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + ::memset(&dim_, 0, static_cast( + reinterpret_cast(&type_) - + reinterpret_cast(&dim_)) + sizeof(type_)); +} + +FieldMeta::~FieldMeta() { + // @@protoc_insertion_point(destructor:milvus.grpc.FieldMeta) + SharedDtor(); +} + +void FieldMeta::SharedDtor() { + field_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void FieldMeta::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const FieldMeta& FieldMeta::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_FieldMeta_message_2eproto.base); + return *internal_default_instance(); +} + + +void FieldMeta::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.FieldMeta) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + field_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + ::memset(&dim_, 0, static_cast( + reinterpret_cast(&type_) - + reinterpret_cast(&dim_)) + sizeof(type_)); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* FieldMeta::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // string field_name = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_field_name(), ptr, ctx, "milvus.grpc.FieldMeta.field_name"); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .milvus.grpc.DataType type = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + set_type(static_cast<::milvus::grpc::DataType>(val)); + } else goto handle_unusual; + continue; + // int64 dim = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + dim_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool FieldMeta::MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + // @@protoc_insertion_point(parse_start:milvus.grpc.FieldMeta) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // string field_name = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_field_name())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->field_name().data(), static_cast(this->field_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.FieldMeta.field_name")); + } else { + goto handle_unusual; + } + break; + } + + // .milvus.grpc.DataType type = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) { + int value = 0; + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + int, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + set_type(static_cast< ::milvus::grpc::DataType >(value)); + } else { + goto handle_unusual; + } + break; + } + + // int64 dim = 3; + case 3: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (24 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + input, &dim_))); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:milvus.grpc.FieldMeta) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.FieldMeta) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void FieldMeta::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.FieldMeta) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string field_name = 1; + if (this->field_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->field_name().data(), static_cast(this->field_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.FieldMeta.field_name"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->field_name(), output); + } + + // .milvus.grpc.DataType type = 2; + if (this->type() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnum( + 2, this->type(), output); + } + + // int64 dim = 3; + if (this->dim() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(3, this->dim(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:milvus.grpc.FieldMeta) +} + +::PROTOBUF_NAMESPACE_ID::uint8* FieldMeta::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.FieldMeta) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string field_name = 1; + if (this->field_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->field_name().data(), static_cast(this->field_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.FieldMeta.field_name"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 1, this->field_name(), target); + } + + // .milvus.grpc.DataType type = 2; + if (this->type() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 2, this->type(), target); + } + + // int64 dim = 3; + if (this->dim() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(3, this->dim(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.FieldMeta) + return target; +} + +size_t FieldMeta::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.FieldMeta) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // string field_name = 1; + if (this->field_name().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->field_name()); + } + + // int64 dim = 3; + if (this->dim() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( + this->dim()); + } + + // .milvus.grpc.DataType type = 2; + if (this->type() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->type()); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void FieldMeta::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.FieldMeta) + GOOGLE_DCHECK_NE(&from, this); + const FieldMeta* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.FieldMeta) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.FieldMeta) + MergeFrom(*source); + } +} + +void FieldMeta::MergeFrom(const FieldMeta& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.FieldMeta) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.field_name().size() > 0) { + + field_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.field_name_); + } + if (from.dim() != 0) { + set_dim(from.dim()); + } + if (from.type() != 0) { + set_type(from.type()); + } +} + +void FieldMeta::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.FieldMeta) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void FieldMeta::CopyFrom(const FieldMeta& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.FieldMeta) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool FieldMeta::IsInitialized() const { + return true; +} + +void FieldMeta::InternalSwap(FieldMeta* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + field_name_.Swap(&other->field_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(dim_, other->dim_); + swap(type_, other->type_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata FieldMeta::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void Schema::InitAsDefaultInstance() { +} +class Schema::_Internal { + public: +}; + +Schema::Schema() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.Schema) +} +Schema::Schema(const Schema& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + field_metas_(from.field_metas_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:milvus.grpc.Schema) +} + +void Schema::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Schema_message_2eproto.base); +} + +Schema::~Schema() { + // @@protoc_insertion_point(destructor:milvus.grpc.Schema) + SharedDtor(); +} + +void Schema::SharedDtor() { +} + +void Schema::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const Schema& Schema::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_Schema_message_2eproto.base); + return *internal_default_instance(); +} + + +void Schema::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.Schema) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + field_metas_.Clear(); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* Schema::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // repeated .milvus.grpc.FieldMeta field_metas = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(add_field_metas(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 10); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool Schema::MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + // @@protoc_insertion_point(parse_start:milvus.grpc.Schema) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // repeated .milvus.grpc.FieldMeta field_metas = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, add_field_metas())); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:milvus.grpc.Schema) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.Schema) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void Schema::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.Schema) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated .milvus.grpc.FieldMeta field_metas = 1; + for (unsigned int i = 0, + n = static_cast(this->field_metas_size()); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, + this->field_metas(static_cast(i)), + output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:milvus.grpc.Schema) +} + +::PROTOBUF_NAMESPACE_ID::uint8* Schema::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.Schema) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated .milvus.grpc.FieldMeta field_metas = 1; + for (unsigned int i = 0, + n = static_cast(this->field_metas_size()); i < n; i++) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 1, this->field_metas(static_cast(i)), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.Schema) + return target; +} + +size_t Schema::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.Schema) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .milvus.grpc.FieldMeta field_metas = 1; + { + unsigned int count = static_cast(this->field_metas_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + this->field_metas(static_cast(i))); + } + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Schema::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.Schema) + GOOGLE_DCHECK_NE(&from, this); + const Schema* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.Schema) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.Schema) + MergeFrom(*source); + } +} + +void Schema::MergeFrom(const Schema& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.Schema) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + field_metas_.MergeFrom(from.field_metas_); +} + +void Schema::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.Schema) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Schema::CopyFrom(const Schema& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.Schema) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Schema::IsInitialized() const { + return true; +} + +void Schema::InternalSwap(Schema* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + CastToBase(&field_metas_)->InternalSwap(CastToBase(&other->field_metas_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Schema::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void RowData::InitAsDefaultInstance() { +} +class RowData::_Internal { + public: +}; + +RowData::RowData() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.RowData) +} +RowData::RowData(const RowData& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + blob_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.blob().empty()) { + blob_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.blob_); + } + // @@protoc_insertion_point(copy_constructor:milvus.grpc.RowData) +} + +void RowData::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_RowData_message_2eproto.base); + blob_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +RowData::~RowData() { + // @@protoc_insertion_point(destructor:milvus.grpc.RowData) + SharedDtor(); +} + +void RowData::SharedDtor() { + blob_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void RowData::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const RowData& RowData::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_RowData_message_2eproto.base); + return *internal_default_instance(); +} + + +void RowData::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.RowData) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + blob_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* RowData::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // bytes blob = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(mutable_blob(), ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool RowData::MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + // @@protoc_insertion_point(parse_start:milvus.grpc.RowData) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // bytes blob = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadBytes( + input, this->mutable_blob())); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:milvus.grpc.RowData) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.RowData) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void RowData::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.RowData) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // bytes blob = 1; + if (this->blob().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesMaybeAliased( + 1, this->blob(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:milvus.grpc.RowData) +} + +::PROTOBUF_NAMESPACE_ID::uint8* RowData::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.RowData) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // bytes blob = 1; + if (this->blob().size() > 0) { + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesToArray( + 1, this->blob(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.RowData) + return target; +} + +size_t RowData::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.RowData) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // bytes blob = 1; + if (this->blob().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->blob()); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void RowData::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.RowData) + GOOGLE_DCHECK_NE(&from, this); + const RowData* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.RowData) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.RowData) + MergeFrom(*source); + } +} + +void RowData::MergeFrom(const RowData& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.RowData) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.blob().size() > 0) { + + blob_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.blob_); + } +} + +void RowData::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.RowData) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void RowData::CopyFrom(const RowData& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.RowData) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool RowData::IsInitialized() const { + return true; +} + +void RowData::InternalSwap(RowData* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + blob_.Swap(&other->blob_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} + +::PROTOBUF_NAMESPACE_ID::Metadata RowData::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void InsertParam::InitAsDefaultInstance() { + ::milvus::grpc::_InsertParam_default_instance_._instance.get_mutable()->schema_ = const_cast< ::milvus::grpc::Schema*>( + ::milvus::grpc::Schema::internal_default_instance()); +} +class InsertParam::_Internal { + public: + static const ::milvus::grpc::Schema& schema(const InsertParam* msg); +}; + +const ::milvus::grpc::Schema& +InsertParam::_Internal::schema(const InsertParam* msg) { + return *msg->schema_; +} +InsertParam::InsertParam() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.InsertParam) +} +InsertParam::InsertParam(const InsertParam& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + rows_data_(from.rows_data_), + entity_id_array_(from.entity_id_array_), + extra_params_(from.extra_params_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.collection_name().empty()) { + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); + } + partition_tag_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.partition_tag().empty()) { + partition_tag_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.partition_tag_); + } + if (from.has_schema()) { + schema_ = new ::milvus::grpc::Schema(*from.schema_); + } else { + schema_ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:milvus.grpc.InsertParam) +} + +void InsertParam::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_InsertParam_message_2eproto.base); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + partition_tag_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + schema_ = nullptr; +} + +InsertParam::~InsertParam() { + // @@protoc_insertion_point(destructor:milvus.grpc.InsertParam) + SharedDtor(); +} + +void InsertParam::SharedDtor() { + collection_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + partition_tag_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (this != internal_default_instance()) delete schema_; +} + +void InsertParam::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const InsertParam& InsertParam::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_InsertParam_message_2eproto.base); + return *internal_default_instance(); +} + + +void InsertParam::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.InsertParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + rows_data_.Clear(); + entity_id_array_.Clear(); + extra_params_.Clear(); + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + partition_tag_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (GetArenaNoVirtual() == nullptr && schema_ != nullptr) { + delete schema_; + } + schema_ = nullptr; + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* InsertParam::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // string collection_name = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_collection_name(), ptr, ctx, "milvus.grpc.InsertParam.collection_name"); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .milvus.grpc.Schema schema = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(mutable_schema(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated .milvus.grpc.RowData rows_data = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(add_rows_data(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 26); + } else goto handle_unusual; + continue; + // repeated int64 entity_id_array = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt64Parser(mutable_entity_id_array(), ptr, ctx); + CHK_(ptr); + } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32) { + add_entity_id_array(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr)); + CHK_(ptr); + } else goto handle_unusual; + continue; + // string partition_tag = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_partition_tag(), ptr, ctx, "milvus.grpc.InsertParam.partition_tag"); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated .milvus.grpc.KeyValuePair extra_params = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(add_extra_params(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 50); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool InsertParam::MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + // @@protoc_insertion_point(parse_start:milvus.grpc.InsertParam) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // string collection_name = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_collection_name())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.InsertParam.collection_name")); + } else { + goto handle_unusual; + } + break; + } + + // .milvus.grpc.Schema schema = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, mutable_schema())); + } else { + goto handle_unusual; + } + break; + } + + // repeated .milvus.grpc.RowData rows_data = 3; + case 3: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, add_rows_data())); + } else { + goto handle_unusual; + } + break; + } + + // repeated int64 entity_id_array = 4; + case 4: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (34 & 0xFF)) { + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPackedPrimitive< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + input, this->mutable_entity_id_array()))); + } else if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (32 & 0xFF)) { + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + 1, 34u, input, this->mutable_entity_id_array()))); + } else { + goto handle_unusual; + } + break; + } + + // string partition_tag = 5; + case 5: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (42 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_partition_tag())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->partition_tag().data(), static_cast(this->partition_tag().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.InsertParam.partition_tag")); + } else { + goto handle_unusual; + } + break; + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 6; + case 6: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (50 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, add_extra_params())); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:milvus.grpc.InsertParam) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.InsertParam) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void InsertParam::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.InsertParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string collection_name = 1; + if (this->collection_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.InsertParam.collection_name"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->collection_name(), output); + } + + // .milvus.grpc.Schema schema = 2; + if (this->has_schema()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, _Internal::schema(this), output); + } + + // repeated .milvus.grpc.RowData rows_data = 3; + for (unsigned int i = 0, + n = static_cast(this->rows_data_size()); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 3, + this->rows_data(static_cast(i)), + output); + } + + // repeated int64 entity_id_array = 4; + if (this->entity_id_array_size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTag(4, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(_entity_id_array_cached_byte_size_.load( + std::memory_order_relaxed)); + } + for (int i = 0, n = this->entity_id_array_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64NoTag( + this->entity_id_array(i), output); + } + + // string partition_tag = 5; + if (this->partition_tag().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->partition_tag().data(), static_cast(this->partition_tag().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.InsertParam.partition_tag"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 5, this->partition_tag(), output); + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 6; + for (unsigned int i = 0, + n = static_cast(this->extra_params_size()); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 6, + this->extra_params(static_cast(i)), + output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:milvus.grpc.InsertParam) +} + +::PROTOBUF_NAMESPACE_ID::uint8* InsertParam::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.InsertParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string collection_name = 1; + if (this->collection_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.InsertParam.collection_name"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 1, this->collection_name(), target); + } + + // .milvus.grpc.Schema schema = 2; + if (this->has_schema()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 2, _Internal::schema(this), target); + } + + // repeated .milvus.grpc.RowData rows_data = 3; + for (unsigned int i = 0, + n = static_cast(this->rows_data_size()); i < n; i++) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 3, this->rows_data(static_cast(i)), target); + } + + // repeated int64 entity_id_array = 4; + if (this->entity_id_array_size() > 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTagToArray( + 4, + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + target); + target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray( + _entity_id_array_cached_byte_size_.load(std::memory_order_relaxed), + target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + WriteInt64NoTagToArray(this->entity_id_array_, target); + } + + // string partition_tag = 5; + if (this->partition_tag().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->partition_tag().data(), static_cast(this->partition_tag().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.InsertParam.partition_tag"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 5, this->partition_tag(), target); + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 6; + for (unsigned int i = 0, + n = static_cast(this->extra_params_size()); i < n; i++) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 6, this->extra_params(static_cast(i)), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.InsertParam) + return target; +} + +size_t InsertParam::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.InsertParam) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .milvus.grpc.RowData rows_data = 3; + { + unsigned int count = static_cast(this->rows_data_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + this->rows_data(static_cast(i))); + } + } + + // repeated int64 entity_id_array = 4; + { + size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + Int64Size(this->entity_id_array_); + if (data_size > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size)); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size); + _entity_id_array_cached_byte_size_.store(cached_size, + std::memory_order_relaxed); + total_size += data_size; + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 6; + { + unsigned int count = static_cast(this->extra_params_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + this->extra_params(static_cast(i))); + } + } + + // string collection_name = 1; + if (this->collection_name().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->collection_name()); + } + + // string partition_tag = 5; + if (this->partition_tag().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->partition_tag()); + } + + // .milvus.grpc.Schema schema = 2; + if (this->has_schema()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *schema_); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void InsertParam::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.InsertParam) + GOOGLE_DCHECK_NE(&from, this); + const InsertParam* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.InsertParam) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.InsertParam) + MergeFrom(*source); + } +} + +void InsertParam::MergeFrom(const InsertParam& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.InsertParam) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + rows_data_.MergeFrom(from.rows_data_); + entity_id_array_.MergeFrom(from.entity_id_array_); + extra_params_.MergeFrom(from.extra_params_); + if (from.collection_name().size() > 0) { + + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); + } + if (from.partition_tag().size() > 0) { + + partition_tag_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.partition_tag_); + } + if (from.has_schema()) { + mutable_schema()->::milvus::grpc::Schema::MergeFrom(from.schema()); + } +} + +void InsertParam::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.InsertParam) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void InsertParam::CopyFrom(const InsertParam& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.InsertParam) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool InsertParam::IsInitialized() const { + return true; +} + +void InsertParam::InternalSwap(InsertParam* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + CastToBase(&rows_data_)->InternalSwap(CastToBase(&other->rows_data_)); + entity_id_array_.InternalSwap(&other->entity_id_array_); + CastToBase(&extra_params_)->InternalSwap(CastToBase(&other->extra_params_)); + collection_name_.Swap(&other->collection_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + partition_tag_.Swap(&other->partition_tag_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(schema_, other->schema_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata InsertParam::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void SearchParam::InitAsDefaultInstance() { +} +class SearchParam::_Internal { + public: +}; + +SearchParam::SearchParam() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.SearchParam) +} +SearchParam::SearchParam(const SearchParam& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + vector_param_(from.vector_param_), + partition_tag_(from.partition_tag_), + extra_params_(from.extra_params_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.collection_name().empty()) { + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); + } + dsl_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.dsl().empty()) { + dsl_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.dsl_); + } + // @@protoc_insertion_point(copy_constructor:milvus.grpc.SearchParam) +} + +void SearchParam::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_SearchParam_message_2eproto.base); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + dsl_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +SearchParam::~SearchParam() { + // @@protoc_insertion_point(destructor:milvus.grpc.SearchParam) + SharedDtor(); +} + +void SearchParam::SharedDtor() { + collection_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + dsl_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void SearchParam::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const SearchParam& SearchParam::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_SearchParam_message_2eproto.base); + return *internal_default_instance(); +} + + +void SearchParam::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.SearchParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + vector_param_.Clear(); + partition_tag_.Clear(); + extra_params_.Clear(); + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + dsl_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* SearchParam::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // string collection_name = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_collection_name(), ptr, ctx, "milvus.grpc.SearchParam.collection_name"); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated .milvus.grpc.VectorParam vector_param = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(add_vector_param(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 18); + } else goto handle_unusual; + continue; + // string dsl = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_dsl(), ptr, ctx, "milvus.grpc.SearchParam.dsl"); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated string partition_tag = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + ptr -= 1; + do { + ptr += 1; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(add_partition_tag(), ptr, ctx, "milvus.grpc.SearchParam.partition_tag"); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 34); + } else goto handle_unusual; + continue; + // repeated .milvus.grpc.KeyValuePair extra_params = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(add_extra_params(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 42); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool SearchParam::MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + // @@protoc_insertion_point(parse_start:milvus.grpc.SearchParam) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // string collection_name = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_collection_name())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.SearchParam.collection_name")); + } else { + goto handle_unusual; + } + break; + } + + // repeated .milvus.grpc.VectorParam vector_param = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, add_vector_param())); + } else { + goto handle_unusual; + } + break; + } + + // string dsl = 3; + case 3: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_dsl())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->dsl().data(), static_cast(this->dsl().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.SearchParam.dsl")); + } else { + goto handle_unusual; + } + break; + } + + // repeated string partition_tag = 4; + case 4: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (34 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->add_partition_tag())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->partition_tag(this->partition_tag_size() - 1).data(), + static_cast(this->partition_tag(this->partition_tag_size() - 1).length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.SearchParam.partition_tag")); + } else { + goto handle_unusual; + } + break; + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 5; + case 5: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (42 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, add_extra_params())); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:milvus.grpc.SearchParam) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.SearchParam) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void SearchParam::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.SearchParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string collection_name = 1; + if (this->collection_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.SearchParam.collection_name"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->collection_name(), output); + } + + // repeated .milvus.grpc.VectorParam vector_param = 2; + for (unsigned int i = 0, + n = static_cast(this->vector_param_size()); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, + this->vector_param(static_cast(i)), + output); + } + + // string dsl = 3; + if (this->dsl().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->dsl().data(), static_cast(this->dsl().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.SearchParam.dsl"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 3, this->dsl(), output); + } + + // repeated string partition_tag = 4; + for (int i = 0, n = this->partition_tag_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->partition_tag(i).data(), static_cast(this->partition_tag(i).length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.SearchParam.partition_tag"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteString( + 4, this->partition_tag(i), output); + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 5; + for (unsigned int i = 0, + n = static_cast(this->extra_params_size()); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 5, + this->extra_params(static_cast(i)), + output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:milvus.grpc.SearchParam) +} + +::PROTOBUF_NAMESPACE_ID::uint8* SearchParam::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.SearchParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string collection_name = 1; + if (this->collection_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.SearchParam.collection_name"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 1, this->collection_name(), target); + } + + // repeated .milvus.grpc.VectorParam vector_param = 2; + for (unsigned int i = 0, + n = static_cast(this->vector_param_size()); i < n; i++) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 2, this->vector_param(static_cast(i)), target); + } + + // string dsl = 3; + if (this->dsl().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->dsl().data(), static_cast(this->dsl().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.SearchParam.dsl"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 3, this->dsl(), target); + } + + // repeated string partition_tag = 4; + for (int i = 0, n = this->partition_tag_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->partition_tag(i).data(), static_cast(this->partition_tag(i).length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.SearchParam.partition_tag"); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + WriteStringToArray(4, this->partition_tag(i), target); + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 5; + for (unsigned int i = 0, + n = static_cast(this->extra_params_size()); i < n; i++) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 5, this->extra_params(static_cast(i)), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.SearchParam) + return target; +} + +size_t SearchParam::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.SearchParam) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .milvus.grpc.VectorParam vector_param = 2; + { + unsigned int count = static_cast(this->vector_param_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + this->vector_param(static_cast(i))); + } + } + + // repeated string partition_tag = 4; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->partition_tag_size()); + for (int i = 0, n = this->partition_tag_size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->partition_tag(i)); + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 5; + { + unsigned int count = static_cast(this->extra_params_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + this->extra_params(static_cast(i))); + } + } + + // string collection_name = 1; + if (this->collection_name().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->collection_name()); + } + + // string dsl = 3; + if (this->dsl().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->dsl()); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void SearchParam::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.SearchParam) + GOOGLE_DCHECK_NE(&from, this); + const SearchParam* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.SearchParam) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.SearchParam) + MergeFrom(*source); + } +} + +void SearchParam::MergeFrom(const SearchParam& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.SearchParam) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + vector_param_.MergeFrom(from.vector_param_); + partition_tag_.MergeFrom(from.partition_tag_); + extra_params_.MergeFrom(from.extra_params_); + if (from.collection_name().size() > 0) { + + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); + } + if (from.dsl().size() > 0) { + + dsl_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.dsl_); + } +} + +void SearchParam::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.SearchParam) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void SearchParam::CopyFrom(const SearchParam& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.SearchParam) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SearchParam::IsInitialized() const { + return true; +} + +void SearchParam::InternalSwap(SearchParam* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + CastToBase(&vector_param_)->InternalSwap(CastToBase(&other->vector_param_)); + partition_tag_.InternalSwap(CastToBase(&other->partition_tag_)); + CastToBase(&extra_params_)->InternalSwap(CastToBase(&other->extra_params_)); + collection_name_.Swap(&other->collection_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + dsl_.Swap(&other->dsl_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SearchParam::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void SearchInSegmentParam::InitAsDefaultInstance() { + ::milvus::grpc::_SearchInSegmentParam_default_instance_._instance.get_mutable()->search_param_ = const_cast< ::milvus::grpc::SearchParam*>( + ::milvus::grpc::SearchParam::internal_default_instance()); +} +class SearchInSegmentParam::_Internal { + public: + static const ::milvus::grpc::SearchParam& search_param(const SearchInSegmentParam* msg); +}; + +const ::milvus::grpc::SearchParam& +SearchInSegmentParam::_Internal::search_param(const SearchInSegmentParam* msg) { + return *msg->search_param_; +} +SearchInSegmentParam::SearchInSegmentParam() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.SearchInSegmentParam) +} +SearchInSegmentParam::SearchInSegmentParam(const SearchInSegmentParam& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + file_id_array_(from.file_id_array_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + if (from.has_search_param()) { + search_param_ = new ::milvus::grpc::SearchParam(*from.search_param_); + } else { + search_param_ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:milvus.grpc.SearchInSegmentParam) +} + +void SearchInSegmentParam::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_SearchInSegmentParam_message_2eproto.base); + search_param_ = nullptr; +} + +SearchInSegmentParam::~SearchInSegmentParam() { + // @@protoc_insertion_point(destructor:milvus.grpc.SearchInSegmentParam) + SharedDtor(); +} + +void SearchInSegmentParam::SharedDtor() { + if (this != internal_default_instance()) delete search_param_; +} + +void SearchInSegmentParam::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const SearchInSegmentParam& SearchInSegmentParam::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_SearchInSegmentParam_message_2eproto.base); + return *internal_default_instance(); +} + + +void SearchInSegmentParam::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.SearchInSegmentParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + file_id_array_.Clear(); + if (GetArenaNoVirtual() == nullptr && search_param_ != nullptr) { + delete search_param_; + } + search_param_ = nullptr; + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* SearchInSegmentParam::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // repeated string file_id_array = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(add_file_id_array(), ptr, ctx, "milvus.grpc.SearchInSegmentParam.file_id_array"); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 10); + } else goto handle_unusual; + continue; + // .milvus.grpc.SearchParam search_param = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(mutable_search_param(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool SearchInSegmentParam::MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + // @@protoc_insertion_point(parse_start:milvus.grpc.SearchInSegmentParam) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // repeated string file_id_array = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->add_file_id_array())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->file_id_array(this->file_id_array_size() - 1).data(), + static_cast(this->file_id_array(this->file_id_array_size() - 1).length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.SearchInSegmentParam.file_id_array")); + } else { + goto handle_unusual; + } + break; + } + + // .milvus.grpc.SearchParam search_param = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, mutable_search_param())); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:milvus.grpc.SearchInSegmentParam) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.SearchInSegmentParam) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void SearchInSegmentParam::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.SearchInSegmentParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated string file_id_array = 1; + for (int i = 0, n = this->file_id_array_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->file_id_array(i).data(), static_cast(this->file_id_array(i).length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.SearchInSegmentParam.file_id_array"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteString( + 1, this->file_id_array(i), output); + } + + // .milvus.grpc.SearchParam search_param = 2; + if (this->has_search_param()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, _Internal::search_param(this), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:milvus.grpc.SearchInSegmentParam) +} + +::PROTOBUF_NAMESPACE_ID::uint8* SearchInSegmentParam::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.SearchInSegmentParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated string file_id_array = 1; + for (int i = 0, n = this->file_id_array_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->file_id_array(i).data(), static_cast(this->file_id_array(i).length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.SearchInSegmentParam.file_id_array"); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + WriteStringToArray(1, this->file_id_array(i), target); + } + + // .milvus.grpc.SearchParam search_param = 2; + if (this->has_search_param()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 2, _Internal::search_param(this), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.SearchInSegmentParam) + return target; +} + +size_t SearchInSegmentParam::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.SearchInSegmentParam) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated string file_id_array = 1; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->file_id_array_size()); + for (int i = 0, n = this->file_id_array_size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->file_id_array(i)); + } + + // .milvus.grpc.SearchParam search_param = 2; + if (this->has_search_param()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *search_param_); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void SearchInSegmentParam::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.SearchInSegmentParam) + GOOGLE_DCHECK_NE(&from, this); + const SearchInSegmentParam* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.SearchInSegmentParam) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.SearchInSegmentParam) + MergeFrom(*source); + } +} + +void SearchInSegmentParam::MergeFrom(const SearchInSegmentParam& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.SearchInSegmentParam) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + file_id_array_.MergeFrom(from.file_id_array_); + if (from.has_search_param()) { + mutable_search_param()->::milvus::grpc::SearchParam::MergeFrom(from.search_param()); + } +} + +void SearchInSegmentParam::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.SearchInSegmentParam) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void SearchInSegmentParam::CopyFrom(const SearchInSegmentParam& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.SearchInSegmentParam) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SearchInSegmentParam::IsInitialized() const { + return true; +} + +void SearchInSegmentParam::InternalSwap(SearchInSegmentParam* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + file_id_array_.InternalSwap(CastToBase(&other->file_id_array_)); + swap(search_param_, other->search_param_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SearchInSegmentParam::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void Entities::InitAsDefaultInstance() { + ::milvus::grpc::_Entities_default_instance_._instance.get_mutable()->status_ = const_cast< ::milvus::grpc::Status*>( + ::milvus::grpc::Status::internal_default_instance()); +} +class Entities::_Internal { + public: + static const ::milvus::grpc::Status& status(const Entities* msg); +}; + +const ::milvus::grpc::Status& +Entities::_Internal::status(const Entities* msg) { + return *msg->status_; +} +Entities::Entities() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.Entities) +} +Entities::Entities(const Entities& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + ids_(from.ids_), + valid_row_(from.valid_row_), + rows_data_(from.rows_data_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + if (from.has_status()) { + status_ = new ::milvus::grpc::Status(*from.status_); + } else { + status_ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:milvus.grpc.Entities) +} + +void Entities::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Entities_message_2eproto.base); + status_ = nullptr; +} + +Entities::~Entities() { + // @@protoc_insertion_point(destructor:milvus.grpc.Entities) + SharedDtor(); +} + +void Entities::SharedDtor() { + if (this != internal_default_instance()) delete status_; +} + +void Entities::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const Entities& Entities::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_Entities_message_2eproto.base); + return *internal_default_instance(); +} + + +void Entities::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.Entities) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + ids_.Clear(); + valid_row_.Clear(); + rows_data_.Clear(); + if (GetArenaNoVirtual() == nullptr && status_ != nullptr) { + delete status_; + } + status_ = nullptr; + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* Entities::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // .milvus.grpc.Status status = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(mutable_status(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated int64 ids = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt64Parser(mutable_ids(), ptr, ctx); + CHK_(ptr); + } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16) { + add_ids(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr)); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated bool valid_row = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedBoolParser(mutable_valid_row(), ptr, ctx); + CHK_(ptr); + } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24) { + add_valid_row(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr)); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated .milvus.grpc.RowData rows_data = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(add_rows_data(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 34); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool Entities::MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + // @@protoc_insertion_point(parse_start:milvus.grpc.Entities) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // .milvus.grpc.Status status = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, mutable_status())); + } else { + goto handle_unusual; + } + break; + } + + // repeated int64 ids = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPackedPrimitive< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + input, this->mutable_ids()))); + } else if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) { + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + 1, 18u, input, this->mutable_ids()))); + } else { + goto handle_unusual; + } + break; + } + + // repeated bool valid_row = 3; + case 3: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) { + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPackedPrimitive< + bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>( + input, this->mutable_valid_row()))); + } else if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (24 & 0xFF)) { + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< + bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>( + 1, 26u, input, this->mutable_valid_row()))); + } else { + goto handle_unusual; + } + break; + } + + // repeated .milvus.grpc.RowData rows_data = 4; + case 4: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (34 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, add_rows_data())); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:milvus.grpc.Entities) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.Entities) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void Entities::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.Entities) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.grpc.Status status = 1; + if (this->has_status()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, _Internal::status(this), output); + } + + // repeated int64 ids = 2; + if (this->ids_size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTag(2, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(_ids_cached_byte_size_.load( + std::memory_order_relaxed)); + } + for (int i = 0, n = this->ids_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64NoTag( + this->ids(i), output); + } + + // repeated bool valid_row = 3; + if (this->valid_row_size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTag(3, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(_valid_row_cached_byte_size_.load( + std::memory_order_relaxed)); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolArray( + this->valid_row().data(), this->valid_row_size(), output); + } + + // repeated .milvus.grpc.RowData rows_data = 4; + for (unsigned int i = 0, + n = static_cast(this->rows_data_size()); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 4, + this->rows_data(static_cast(i)), + output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:milvus.grpc.Entities) +} + +::PROTOBUF_NAMESPACE_ID::uint8* Entities::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.Entities) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.grpc.Status status = 1; + if (this->has_status()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 1, _Internal::status(this), target); + } + + // repeated int64 ids = 2; + if (this->ids_size() > 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTagToArray( + 2, + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + target); + target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray( + _ids_cached_byte_size_.load(std::memory_order_relaxed), + target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + WriteInt64NoTagToArray(this->ids_, target); + } + + // repeated bool valid_row = 3; + if (this->valid_row_size() > 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTagToArray( + 3, + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + target); + target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray( + _valid_row_cached_byte_size_.load(std::memory_order_relaxed), + target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + WriteBoolNoTagToArray(this->valid_row_, target); + } + + // repeated .milvus.grpc.RowData rows_data = 4; + for (unsigned int i = 0, + n = static_cast(this->rows_data_size()); i < n; i++) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 4, this->rows_data(static_cast(i)), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.Entities) + return target; +} + +size_t Entities::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.Entities) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated int64 ids = 2; + { + size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + Int64Size(this->ids_); + if (data_size > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size)); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size); + _ids_cached_byte_size_.store(cached_size, + std::memory_order_relaxed); + total_size += data_size; + } + + // repeated bool valid_row = 3; + { + unsigned int count = static_cast(this->valid_row_size()); + size_t data_size = 1UL * count; + if (data_size > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size)); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size); + _valid_row_cached_byte_size_.store(cached_size, + std::memory_order_relaxed); + total_size += data_size; + } + + // repeated .milvus.grpc.RowData rows_data = 4; + { + unsigned int count = static_cast(this->rows_data_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + this->rows_data(static_cast(i))); + } + } + + // .milvus.grpc.Status status = 1; + if (this->has_status()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *status_); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Entities::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.Entities) + GOOGLE_DCHECK_NE(&from, this); + const Entities* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.Entities) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.Entities) + MergeFrom(*source); + } +} + +void Entities::MergeFrom(const Entities& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.Entities) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + ids_.MergeFrom(from.ids_); + valid_row_.MergeFrom(from.valid_row_); + rows_data_.MergeFrom(from.rows_data_); + if (from.has_status()) { + mutable_status()->::milvus::grpc::Status::MergeFrom(from.status()); + } +} + +void Entities::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.Entities) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Entities::CopyFrom(const Entities& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.Entities) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Entities::IsInitialized() const { + return true; +} + +void Entities::InternalSwap(Entities* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + ids_.InternalSwap(&other->ids_); + valid_row_.InternalSwap(&other->valid_row_); + CastToBase(&rows_data_)->InternalSwap(CastToBase(&other->rows_data_)); + swap(status_, other->status_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Entities::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void QueryResult::InitAsDefaultInstance() { + ::milvus::grpc::_QueryResult_default_instance_._instance.get_mutable()->status_ = const_cast< ::milvus::grpc::Status*>( + ::milvus::grpc::Status::internal_default_instance()); + ::milvus::grpc::_QueryResult_default_instance_._instance.get_mutable()->entities_ = const_cast< ::milvus::grpc::Entities*>( + ::milvus::grpc::Entities::internal_default_instance()); +} +class QueryResult::_Internal { + public: + static const ::milvus::grpc::Status& status(const QueryResult* msg); + static const ::milvus::grpc::Entities& entities(const QueryResult* msg); +}; + +const ::milvus::grpc::Status& +QueryResult::_Internal::status(const QueryResult* msg) { + return *msg->status_; +} +const ::milvus::grpc::Entities& +QueryResult::_Internal::entities(const QueryResult* msg) { + return *msg->entities_; +} +QueryResult::QueryResult() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.QueryResult) +} +QueryResult::QueryResult(const QueryResult& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + scores_(from.scores_), + distances_(from.distances_), + extra_params_(from.extra_params_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + if (from.has_status()) { + status_ = new ::milvus::grpc::Status(*from.status_); + } else { + status_ = nullptr; + } + if (from.has_entities()) { + entities_ = new ::milvus::grpc::Entities(*from.entities_); + } else { + entities_ = nullptr; + } + ::memcpy(&row_num_, &from.row_num_, + static_cast(reinterpret_cast(&client_id_) - + reinterpret_cast(&row_num_)) + sizeof(client_id_)); + // @@protoc_insertion_point(copy_constructor:milvus.grpc.QueryResult) +} + +void QueryResult::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_QueryResult_message_2eproto.base); + ::memset(&status_, 0, static_cast( + reinterpret_cast(&client_id_) - + reinterpret_cast(&status_)) + sizeof(client_id_)); +} + +QueryResult::~QueryResult() { + // @@protoc_insertion_point(destructor:milvus.grpc.QueryResult) + SharedDtor(); +} + +void QueryResult::SharedDtor() { + if (this != internal_default_instance()) delete status_; + if (this != internal_default_instance()) delete entities_; +} + +void QueryResult::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const QueryResult& QueryResult::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_QueryResult_message_2eproto.base); + return *internal_default_instance(); +} + + +void QueryResult::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.QueryResult) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + scores_.Clear(); + distances_.Clear(); + extra_params_.Clear(); + if (GetArenaNoVirtual() == nullptr && status_ != nullptr) { + delete status_; + } + status_ = nullptr; + if (GetArenaNoVirtual() == nullptr && entities_ != nullptr) { + delete entities_; + } + entities_ = nullptr; + ::memset(&row_num_, 0, static_cast( + reinterpret_cast(&client_id_) - + reinterpret_cast(&row_num_)) + sizeof(client_id_)); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* QueryResult::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // .milvus.grpc.Status status = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(mutable_status(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .milvus.grpc.Entities entities = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(mutable_entities(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // int64 row_num = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + row_num_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated float scores = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser(mutable_scores(), ptr, ctx); + CHK_(ptr); + } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 37) { + add_scores(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); + ptr += sizeof(float); + } else goto handle_unusual; + continue; + // repeated float distances = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser(mutable_distances(), ptr, ctx); + CHK_(ptr); + } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 45) { + add_distances(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); + ptr += sizeof(float); + } else goto handle_unusual; + continue; + // repeated .milvus.grpc.KeyValuePair extra_params = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(add_extra_params(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 50); + } else goto handle_unusual; + continue; + // int64 query_id = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 56)) { + query_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // int64 client_id = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 64)) { + client_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool QueryResult::MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + // @@protoc_insertion_point(parse_start:milvus.grpc.QueryResult) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // .milvus.grpc.Status status = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, mutable_status())); + } else { + goto handle_unusual; + } + break; + } + + // .milvus.grpc.Entities entities = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, mutable_entities())); + } else { + goto handle_unusual; + } + break; + } + + // int64 row_num = 3; + case 3: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (24 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + input, &row_num_))); + } else { + goto handle_unusual; + } + break; + } + + // repeated float scores = 4; + case 4: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (34 & 0xFF)) { + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPackedPrimitive< + float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>( + input, this->mutable_scores()))); + } else if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (37 & 0xFF)) { + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< + float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>( + 1, 34u, input, this->mutable_scores()))); + } else { + goto handle_unusual; + } + break; + } + + // repeated float distances = 5; + case 5: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (42 & 0xFF)) { + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPackedPrimitive< + float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>( + input, this->mutable_distances()))); + } else if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (45 & 0xFF)) { + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< + float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>( + 1, 42u, input, this->mutable_distances()))); + } else { + goto handle_unusual; + } + break; + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 6; + case 6: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (50 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, add_extra_params())); + } else { + goto handle_unusual; + } + break; + } + + // int64 query_id = 7; + case 7: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (56 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + input, &query_id_))); + } else { + goto handle_unusual; + } + break; + } + + // int64 client_id = 8; + case 8: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (64 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + input, &client_id_))); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:milvus.grpc.QueryResult) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.QueryResult) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void QueryResult::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.QueryResult) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.grpc.Status status = 1; + if (this->has_status()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, _Internal::status(this), output); + } + + // .milvus.grpc.Entities entities = 2; + if (this->has_entities()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, _Internal::entities(this), output); + } + + // int64 row_num = 3; + if (this->row_num() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(3, this->row_num(), output); + } + + // repeated float scores = 4; + if (this->scores_size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTag(4, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(_scores_cached_byte_size_.load( + std::memory_order_relaxed)); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatArray( + this->scores().data(), this->scores_size(), output); + } + + // repeated float distances = 5; + if (this->distances_size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTag(5, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(_distances_cached_byte_size_.load( + std::memory_order_relaxed)); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatArray( + this->distances().data(), this->distances_size(), output); + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 6; + for (unsigned int i = 0, + n = static_cast(this->extra_params_size()); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 6, + this->extra_params(static_cast(i)), + output); + } + + // int64 query_id = 7; + if (this->query_id() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(7, this->query_id(), output); + } + + // int64 client_id = 8; + if (this->client_id() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(8, this->client_id(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:milvus.grpc.QueryResult) +} + +::PROTOBUF_NAMESPACE_ID::uint8* QueryResult::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.QueryResult) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.grpc.Status status = 1; + if (this->has_status()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 1, _Internal::status(this), target); + } + + // .milvus.grpc.Entities entities = 2; + if (this->has_entities()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 2, _Internal::entities(this), target); + } + + // int64 row_num = 3; + if (this->row_num() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(3, this->row_num(), target); + } + + // repeated float scores = 4; + if (this->scores_size() > 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTagToArray( + 4, + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + target); + target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray( + _scores_cached_byte_size_.load(std::memory_order_relaxed), + target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + WriteFloatNoTagToArray(this->scores_, target); + } + + // repeated float distances = 5; + if (this->distances_size() > 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTagToArray( + 5, + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + target); + target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray( + _distances_cached_byte_size_.load(std::memory_order_relaxed), + target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + WriteFloatNoTagToArray(this->distances_, target); + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 6; + for (unsigned int i = 0, + n = static_cast(this->extra_params_size()); i < n; i++) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 6, this->extra_params(static_cast(i)), target); + } + + // int64 query_id = 7; + if (this->query_id() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(7, this->query_id(), target); + } + + // int64 client_id = 8; + if (this->client_id() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(8, this->client_id(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.QueryResult) + return target; +} + +size_t QueryResult::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.QueryResult) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated float scores = 4; + { + unsigned int count = static_cast(this->scores_size()); + size_t data_size = 4UL * count; + if (data_size > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size)); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size); + _scores_cached_byte_size_.store(cached_size, + std::memory_order_relaxed); + total_size += data_size; + } + + // repeated float distances = 5; + { + unsigned int count = static_cast(this->distances_size()); + size_t data_size = 4UL * count; + if (data_size > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size)); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size); + _distances_cached_byte_size_.store(cached_size, + std::memory_order_relaxed); + total_size += data_size; + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 6; + { + unsigned int count = static_cast(this->extra_params_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + this->extra_params(static_cast(i))); + } + } + + // .milvus.grpc.Status status = 1; + if (this->has_status()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *status_); + } + + // .milvus.grpc.Entities entities = 2; + if (this->has_entities()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *entities_); + } + + // int64 row_num = 3; + if (this->row_num() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( + this->row_num()); + } + + // int64 query_id = 7; + if (this->query_id() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( + this->query_id()); + } + + // int64 client_id = 8; + if (this->client_id() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( + this->client_id()); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void QueryResult::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.QueryResult) + GOOGLE_DCHECK_NE(&from, this); + const QueryResult* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.QueryResult) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.QueryResult) + MergeFrom(*source); + } +} + +void QueryResult::MergeFrom(const QueryResult& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.QueryResult) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + scores_.MergeFrom(from.scores_); + distances_.MergeFrom(from.distances_); + extra_params_.MergeFrom(from.extra_params_); + if (from.has_status()) { + mutable_status()->::milvus::grpc::Status::MergeFrom(from.status()); + } + if (from.has_entities()) { + mutable_entities()->::milvus::grpc::Entities::MergeFrom(from.entities()); + } + if (from.row_num() != 0) { + set_row_num(from.row_num()); + } + if (from.query_id() != 0) { + set_query_id(from.query_id()); + } + if (from.client_id() != 0) { + set_client_id(from.client_id()); + } +} + +void QueryResult::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.QueryResult) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void QueryResult::CopyFrom(const QueryResult& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.QueryResult) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool QueryResult::IsInitialized() const { + return true; +} + +void QueryResult::InternalSwap(QueryResult* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + scores_.InternalSwap(&other->scores_); + distances_.InternalSwap(&other->distances_); + CastToBase(&extra_params_)->InternalSwap(CastToBase(&other->extra_params_)); + swap(status_, other->status_); + swap(entities_, other->entities_); + swap(row_num_, other->row_num_); + swap(query_id_, other->query_id_); + swap(client_id_, other->client_id_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata QueryResult::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void StringReply::InitAsDefaultInstance() { + ::milvus::grpc::_StringReply_default_instance_._instance.get_mutable()->status_ = const_cast< ::milvus::grpc::Status*>( + ::milvus::grpc::Status::internal_default_instance()); +} +class StringReply::_Internal { + public: + static const ::milvus::grpc::Status& status(const StringReply* msg); +}; + +const ::milvus::grpc::Status& +StringReply::_Internal::status(const StringReply* msg) { + return *msg->status_; +} +StringReply::StringReply() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.StringReply) +} +StringReply::StringReply(const StringReply& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + string_reply_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.string_reply().empty()) { + string_reply_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.string_reply_); + } + if (from.has_status()) { + status_ = new ::milvus::grpc::Status(*from.status_); + } else { + status_ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:milvus.grpc.StringReply) +} + +void StringReply::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_StringReply_message_2eproto.base); + string_reply_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + status_ = nullptr; +} + +StringReply::~StringReply() { + // @@protoc_insertion_point(destructor:milvus.grpc.StringReply) + SharedDtor(); +} + +void StringReply::SharedDtor() { + string_reply_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (this != internal_default_instance()) delete status_; +} + +void StringReply::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const StringReply& StringReply::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_StringReply_message_2eproto.base); + return *internal_default_instance(); +} + + +void StringReply::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.StringReply) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + string_reply_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (GetArenaNoVirtual() == nullptr && status_ != nullptr) { + delete status_; + } + status_ = nullptr; + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* StringReply::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // .milvus.grpc.Status status = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(mutable_status(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // string string_reply = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_string_reply(), ptr, ctx, "milvus.grpc.StringReply.string_reply"); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool StringReply::MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + // @@protoc_insertion_point(parse_start:milvus.grpc.StringReply) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // .milvus.grpc.Status status = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, mutable_status())); + } else { + goto handle_unusual; + } + break; + } + + // string string_reply = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_string_reply())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->string_reply().data(), static_cast(this->string_reply().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.StringReply.string_reply")); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:milvus.grpc.StringReply) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.StringReply) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void StringReply::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.StringReply) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.grpc.Status status = 1; + if (this->has_status()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, _Internal::status(this), output); + } + + // string string_reply = 2; + if (this->string_reply().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->string_reply().data(), static_cast(this->string_reply().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.StringReply.string_reply"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 2, this->string_reply(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:milvus.grpc.StringReply) +} + +::PROTOBUF_NAMESPACE_ID::uint8* StringReply::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.StringReply) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.grpc.Status status = 1; + if (this->has_status()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 1, _Internal::status(this), target); + } + + // string string_reply = 2; + if (this->string_reply().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->string_reply().data(), static_cast(this->string_reply().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.StringReply.string_reply"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 2, this->string_reply(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.StringReply) + return target; +} + +size_t StringReply::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.StringReply) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // string string_reply = 2; + if (this->string_reply().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->string_reply()); + } + + // .milvus.grpc.Status status = 1; + if (this->has_status()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *status_); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void StringReply::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.StringReply) + GOOGLE_DCHECK_NE(&from, this); + const StringReply* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.StringReply) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.StringReply) + MergeFrom(*source); + } +} + +void StringReply::MergeFrom(const StringReply& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.StringReply) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.string_reply().size() > 0) { + + string_reply_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.string_reply_); + } + if (from.has_status()) { + mutable_status()->::milvus::grpc::Status::MergeFrom(from.status()); + } +} + +void StringReply::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.StringReply) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void StringReply::CopyFrom(const StringReply& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.StringReply) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool StringReply::IsInitialized() const { + return true; +} + +void StringReply::InternalSwap(StringReply* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + string_reply_.Swap(&other->string_reply_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(status_, other->status_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata StringReply::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void BoolReply::InitAsDefaultInstance() { + ::milvus::grpc::_BoolReply_default_instance_._instance.get_mutable()->status_ = const_cast< ::milvus::grpc::Status*>( + ::milvus::grpc::Status::internal_default_instance()); +} +class BoolReply::_Internal { + public: + static const ::milvus::grpc::Status& status(const BoolReply* msg); +}; + +const ::milvus::grpc::Status& +BoolReply::_Internal::status(const BoolReply* msg) { + return *msg->status_; +} +BoolReply::BoolReply() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.BoolReply) +} +BoolReply::BoolReply(const BoolReply& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + if (from.has_status()) { + status_ = new ::milvus::grpc::Status(*from.status_); + } else { + status_ = nullptr; + } + bool_reply_ = from.bool_reply_; + // @@protoc_insertion_point(copy_constructor:milvus.grpc.BoolReply) +} + +void BoolReply::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_BoolReply_message_2eproto.base); + ::memset(&status_, 0, static_cast( + reinterpret_cast(&bool_reply_) - + reinterpret_cast(&status_)) + sizeof(bool_reply_)); +} + +BoolReply::~BoolReply() { + // @@protoc_insertion_point(destructor:milvus.grpc.BoolReply) + SharedDtor(); +} + +void BoolReply::SharedDtor() { + if (this != internal_default_instance()) delete status_; +} + +void BoolReply::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const BoolReply& BoolReply::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_BoolReply_message_2eproto.base); + return *internal_default_instance(); +} + + +void BoolReply::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.BoolReply) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArenaNoVirtual() == nullptr && status_ != nullptr) { + delete status_; + } + status_ = nullptr; + bool_reply_ = false; + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* BoolReply::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // .milvus.grpc.Status status = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(mutable_status(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // bool bool_reply = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + bool_reply_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool BoolReply::MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + // @@protoc_insertion_point(parse_start:milvus.grpc.BoolReply) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // .milvus.grpc.Status status = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, mutable_status())); + } else { + goto handle_unusual; + } + break; + } + + // bool bool_reply = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>( + input, &bool_reply_))); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:milvus.grpc.BoolReply) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.BoolReply) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void BoolReply::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.BoolReply) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.grpc.Status status = 1; + if (this->has_status()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, _Internal::status(this), output); + } + + // bool bool_reply = 2; + if (this->bool_reply() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBool(2, this->bool_reply(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:milvus.grpc.BoolReply) +} + +::PROTOBUF_NAMESPACE_ID::uint8* BoolReply::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.BoolReply) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.grpc.Status status = 1; + if (this->has_status()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 1, _Internal::status(this), target); + } + + // bool bool_reply = 2; + if (this->bool_reply() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(2, this->bool_reply(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.BoolReply) + return target; +} + +size_t BoolReply::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.BoolReply) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .milvus.grpc.Status status = 1; + if (this->has_status()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *status_); + } + + // bool bool_reply = 2; + if (this->bool_reply() != 0) { + total_size += 1 + 1; + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void BoolReply::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.BoolReply) + GOOGLE_DCHECK_NE(&from, this); + const BoolReply* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.BoolReply) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.BoolReply) + MergeFrom(*source); + } +} + +void BoolReply::MergeFrom(const BoolReply& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.BoolReply) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.has_status()) { + mutable_status()->::milvus::grpc::Status::MergeFrom(from.status()); + } + if (from.bool_reply() != 0) { + set_bool_reply(from.bool_reply()); + } +} + +void BoolReply::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.BoolReply) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void BoolReply::CopyFrom(const BoolReply& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.BoolReply) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool BoolReply::IsInitialized() const { + return true; +} + +void BoolReply::InternalSwap(BoolReply* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(status_, other->status_); + swap(bool_reply_, other->bool_reply_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata BoolReply::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void CollectionRowCount::InitAsDefaultInstance() { + ::milvus::grpc::_CollectionRowCount_default_instance_._instance.get_mutable()->status_ = const_cast< ::milvus::grpc::Status*>( + ::milvus::grpc::Status::internal_default_instance()); +} +class CollectionRowCount::_Internal { + public: + static const ::milvus::grpc::Status& status(const CollectionRowCount* msg); +}; + +const ::milvus::grpc::Status& +CollectionRowCount::_Internal::status(const CollectionRowCount* msg) { + return *msg->status_; +} +CollectionRowCount::CollectionRowCount() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.CollectionRowCount) +} +CollectionRowCount::CollectionRowCount(const CollectionRowCount& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + if (from.has_status()) { + status_ = new ::milvus::grpc::Status(*from.status_); + } else { + status_ = nullptr; + } + collection_row_count_ = from.collection_row_count_; + // @@protoc_insertion_point(copy_constructor:milvus.grpc.CollectionRowCount) +} + +void CollectionRowCount::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_CollectionRowCount_message_2eproto.base); + ::memset(&status_, 0, static_cast( + reinterpret_cast(&collection_row_count_) - + reinterpret_cast(&status_)) + sizeof(collection_row_count_)); +} + +CollectionRowCount::~CollectionRowCount() { + // @@protoc_insertion_point(destructor:milvus.grpc.CollectionRowCount) + SharedDtor(); +} + +void CollectionRowCount::SharedDtor() { + if (this != internal_default_instance()) delete status_; +} + +void CollectionRowCount::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const CollectionRowCount& CollectionRowCount::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_CollectionRowCount_message_2eproto.base); + return *internal_default_instance(); +} + + +void CollectionRowCount::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.CollectionRowCount) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArenaNoVirtual() == nullptr && status_ != nullptr) { + delete status_; + } + status_ = nullptr; + collection_row_count_ = PROTOBUF_LONGLONG(0); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* CollectionRowCount::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // .milvus.grpc.Status status = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(mutable_status(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // int64 collection_row_count = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + collection_row_count_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool CollectionRowCount::MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + // @@protoc_insertion_point(parse_start:milvus.grpc.CollectionRowCount) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // .milvus.grpc.Status status = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, mutable_status())); + } else { + goto handle_unusual; + } + break; + } + + // int64 collection_row_count = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + input, &collection_row_count_))); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:milvus.grpc.CollectionRowCount) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.CollectionRowCount) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void CollectionRowCount::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.CollectionRowCount) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.grpc.Status status = 1; + if (this->has_status()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, _Internal::status(this), output); + } + + // int64 collection_row_count = 2; + if (this->collection_row_count() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(2, this->collection_row_count(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:milvus.grpc.CollectionRowCount) +} + +::PROTOBUF_NAMESPACE_ID::uint8* CollectionRowCount::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.CollectionRowCount) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.grpc.Status status = 1; + if (this->has_status()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 1, _Internal::status(this), target); + } + + // int64 collection_row_count = 2; + if (this->collection_row_count() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(2, this->collection_row_count(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.CollectionRowCount) + return target; +} + +size_t CollectionRowCount::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.CollectionRowCount) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .milvus.grpc.Status status = 1; + if (this->has_status()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *status_); + } + + // int64 collection_row_count = 2; + if (this->collection_row_count() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( + this->collection_row_count()); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void CollectionRowCount::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.CollectionRowCount) + GOOGLE_DCHECK_NE(&from, this); + const CollectionRowCount* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.CollectionRowCount) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.CollectionRowCount) + MergeFrom(*source); + } +} + +void CollectionRowCount::MergeFrom(const CollectionRowCount& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.CollectionRowCount) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.has_status()) { + mutable_status()->::milvus::grpc::Status::MergeFrom(from.status()); + } + if (from.collection_row_count() != 0) { + set_collection_row_count(from.collection_row_count()); + } +} + +void CollectionRowCount::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.CollectionRowCount) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void CollectionRowCount::CopyFrom(const CollectionRowCount& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.CollectionRowCount) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool CollectionRowCount::IsInitialized() const { + return true; +} + +void CollectionRowCount::InternalSwap(CollectionRowCount* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(status_, other->status_); + swap(collection_row_count_, other->collection_row_count_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata CollectionRowCount::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void Command::InitAsDefaultInstance() { +} +class Command::_Internal { + public: +}; + +Command::Command() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.Command) +} +Command::Command(const Command& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + cmd_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.cmd().empty()) { + cmd_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.cmd_); + } + // @@protoc_insertion_point(copy_constructor:milvus.grpc.Command) +} + +void Command::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Command_message_2eproto.base); + cmd_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +Command::~Command() { + // @@protoc_insertion_point(destructor:milvus.grpc.Command) + SharedDtor(); +} + +void Command::SharedDtor() { + cmd_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void Command::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const Command& Command::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_Command_message_2eproto.base); + return *internal_default_instance(); +} + + +void Command::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.Command) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cmd_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* Command::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // string cmd = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_cmd(), ptr, ctx, "milvus.grpc.Command.cmd"); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool Command::MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + // @@protoc_insertion_point(parse_start:milvus.grpc.Command) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // string cmd = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_cmd())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->cmd().data(), static_cast(this->cmd().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.Command.cmd")); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:milvus.grpc.Command) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.Command) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void Command::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.Command) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string cmd = 1; + if (this->cmd().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->cmd().data(), static_cast(this->cmd().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.Command.cmd"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->cmd(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:milvus.grpc.Command) +} + +::PROTOBUF_NAMESPACE_ID::uint8* Command::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.Command) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string cmd = 1; + if (this->cmd().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->cmd().data(), static_cast(this->cmd().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.Command.cmd"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 1, this->cmd(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.Command) + return target; +} + +size_t Command::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.Command) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // string cmd = 1; + if (this->cmd().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->cmd()); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Command::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.Command) + GOOGLE_DCHECK_NE(&from, this); + const Command* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.Command) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.Command) + MergeFrom(*source); + } +} + +void Command::MergeFrom(const Command& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.Command) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.cmd().size() > 0) { + + cmd_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.cmd_); + } +} + +void Command::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.Command) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Command::CopyFrom(const Command& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.Command) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Command::IsInitialized() const { + return true; +} + +void Command::InternalSwap(Command* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + cmd_.Swap(&other->cmd_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Command::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void IndexParam::InitAsDefaultInstance() { + ::milvus::grpc::_IndexParam_default_instance_._instance.get_mutable()->status_ = const_cast< ::milvus::grpc::Status*>( + ::milvus::grpc::Status::internal_default_instance()); +} +class IndexParam::_Internal { + public: + static const ::milvus::grpc::Status& status(const IndexParam* msg); +}; + +const ::milvus::grpc::Status& +IndexParam::_Internal::status(const IndexParam* msg) { + return *msg->status_; +} +IndexParam::IndexParam() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.IndexParam) +} +IndexParam::IndexParam(const IndexParam& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + extra_params_(from.extra_params_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.collection_name().empty()) { + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); + } + field_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.field_name().empty()) { + field_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.field_name_); + } + index_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.index_name().empty()) { + index_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.index_name_); + } + if (from.has_status()) { + status_ = new ::milvus::grpc::Status(*from.status_); + } else { + status_ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:milvus.grpc.IndexParam) +} + +void IndexParam::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_IndexParam_message_2eproto.base); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + field_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + index_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + status_ = nullptr; +} + +IndexParam::~IndexParam() { + // @@protoc_insertion_point(destructor:milvus.grpc.IndexParam) + SharedDtor(); +} + +void IndexParam::SharedDtor() { + collection_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + field_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + index_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (this != internal_default_instance()) delete status_; +} + +void IndexParam::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const IndexParam& IndexParam::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_IndexParam_message_2eproto.base); + return *internal_default_instance(); +} + + +void IndexParam::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.IndexParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + extra_params_.Clear(); + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + field_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + index_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (GetArenaNoVirtual() == nullptr && status_ != nullptr) { + delete status_; + } + status_ = nullptr; + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* IndexParam::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // .milvus.grpc.Status status = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(mutable_status(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // string collection_name = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_collection_name(), ptr, ctx, "milvus.grpc.IndexParam.collection_name"); + CHK_(ptr); + } else goto handle_unusual; + continue; + // string field_name = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_field_name(), ptr, ctx, "milvus.grpc.IndexParam.field_name"); + CHK_(ptr); + } else goto handle_unusual; + continue; + // string index_name = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_index_name(), ptr, ctx, "milvus.grpc.IndexParam.index_name"); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated .milvus.grpc.KeyValuePair extra_params = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(add_extra_params(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 42); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool IndexParam::MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + // @@protoc_insertion_point(parse_start:milvus.grpc.IndexParam) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // .milvus.grpc.Status status = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, mutable_status())); + } else { + goto handle_unusual; + } + break; + } + + // string collection_name = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_collection_name())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.IndexParam.collection_name")); + } else { + goto handle_unusual; + } + break; + } + + // string field_name = 3; + case 3: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_field_name())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->field_name().data(), static_cast(this->field_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.IndexParam.field_name")); + } else { + goto handle_unusual; + } + break; + } + + // string index_name = 4; + case 4: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (34 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_index_name())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->index_name().data(), static_cast(this->index_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.IndexParam.index_name")); + } else { + goto handle_unusual; + } + break; + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 5; + case 5: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (42 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, add_extra_params())); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:milvus.grpc.IndexParam) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.IndexParam) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void IndexParam::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.IndexParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.grpc.Status status = 1; + if (this->has_status()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, _Internal::status(this), output); + } + + // string collection_name = 2; + if (this->collection_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.IndexParam.collection_name"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 2, this->collection_name(), output); + } + + // string field_name = 3; + if (this->field_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->field_name().data(), static_cast(this->field_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.IndexParam.field_name"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 3, this->field_name(), output); + } + + // string index_name = 4; + if (this->index_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->index_name().data(), static_cast(this->index_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.IndexParam.index_name"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 4, this->index_name(), output); + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 5; + for (unsigned int i = 0, + n = static_cast(this->extra_params_size()); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 5, + this->extra_params(static_cast(i)), + output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:milvus.grpc.IndexParam) +} + +::PROTOBUF_NAMESPACE_ID::uint8* IndexParam::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.IndexParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.grpc.Status status = 1; + if (this->has_status()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 1, _Internal::status(this), target); + } + + // string collection_name = 2; + if (this->collection_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.IndexParam.collection_name"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 2, this->collection_name(), target); + } + + // string field_name = 3; + if (this->field_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->field_name().data(), static_cast(this->field_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.IndexParam.field_name"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 3, this->field_name(), target); + } + + // string index_name = 4; + if (this->index_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->index_name().data(), static_cast(this->index_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.IndexParam.index_name"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 4, this->index_name(), target); + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 5; + for (unsigned int i = 0, + n = static_cast(this->extra_params_size()); i < n; i++) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 5, this->extra_params(static_cast(i)), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.IndexParam) + return target; +} + +size_t IndexParam::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.IndexParam) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .milvus.grpc.KeyValuePair extra_params = 5; + { + unsigned int count = static_cast(this->extra_params_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + this->extra_params(static_cast(i))); + } + } + + // string collection_name = 2; + if (this->collection_name().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->collection_name()); + } + + // string field_name = 3; + if (this->field_name().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->field_name()); + } + + // string index_name = 4; + if (this->index_name().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->index_name()); + } + + // .milvus.grpc.Status status = 1; + if (this->has_status()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *status_); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void IndexParam::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.IndexParam) + GOOGLE_DCHECK_NE(&from, this); + const IndexParam* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.IndexParam) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.IndexParam) + MergeFrom(*source); + } +} + +void IndexParam::MergeFrom(const IndexParam& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.IndexParam) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + extra_params_.MergeFrom(from.extra_params_); + if (from.collection_name().size() > 0) { + + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); + } + if (from.field_name().size() > 0) { + + field_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.field_name_); + } + if (from.index_name().size() > 0) { + + index_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.index_name_); + } + if (from.has_status()) { + mutable_status()->::milvus::grpc::Status::MergeFrom(from.status()); + } +} + +void IndexParam::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.IndexParam) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void IndexParam::CopyFrom(const IndexParam& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.IndexParam) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool IndexParam::IsInitialized() const { + return true; +} + +void IndexParam::InternalSwap(IndexParam* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + CastToBase(&extra_params_)->InternalSwap(CastToBase(&other->extra_params_)); + collection_name_.Swap(&other->collection_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + field_name_.Swap(&other->field_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + index_name_.Swap(&other->index_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(status_, other->status_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata IndexParam::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void FlushParam::InitAsDefaultInstance() { +} +class FlushParam::_Internal { + public: +}; + +FlushParam::FlushParam() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.FlushParam) +} +FlushParam::FlushParam(const FlushParam& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + collection_name_array_(from.collection_name_array_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:milvus.grpc.FlushParam) +} + +void FlushParam::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_FlushParam_message_2eproto.base); +} + +FlushParam::~FlushParam() { + // @@protoc_insertion_point(destructor:milvus.grpc.FlushParam) + SharedDtor(); +} + +void FlushParam::SharedDtor() { +} + +void FlushParam::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const FlushParam& FlushParam::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_FlushParam_message_2eproto.base); + return *internal_default_instance(); +} + + +void FlushParam::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.FlushParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + collection_name_array_.Clear(); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* FlushParam::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // repeated string collection_name_array = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(add_collection_name_array(), ptr, ctx, "milvus.grpc.FlushParam.collection_name_array"); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 10); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool FlushParam::MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + // @@protoc_insertion_point(parse_start:milvus.grpc.FlushParam) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // repeated string collection_name_array = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->add_collection_name_array())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name_array(this->collection_name_array_size() - 1).data(), + static_cast(this->collection_name_array(this->collection_name_array_size() - 1).length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.FlushParam.collection_name_array")); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:milvus.grpc.FlushParam) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.FlushParam) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void FlushParam::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.FlushParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated string collection_name_array = 1; + for (int i = 0, n = this->collection_name_array_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name_array(i).data(), static_cast(this->collection_name_array(i).length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.FlushParam.collection_name_array"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteString( + 1, this->collection_name_array(i), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:milvus.grpc.FlushParam) +} + +::PROTOBUF_NAMESPACE_ID::uint8* FlushParam::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.FlushParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated string collection_name_array = 1; + for (int i = 0, n = this->collection_name_array_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name_array(i).data(), static_cast(this->collection_name_array(i).length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.FlushParam.collection_name_array"); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + WriteStringToArray(1, this->collection_name_array(i), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.FlushParam) + return target; +} + +size_t FlushParam::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.FlushParam) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated string collection_name_array = 1; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->collection_name_array_size()); + for (int i = 0, n = this->collection_name_array_size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->collection_name_array(i)); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void FlushParam::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.FlushParam) + GOOGLE_DCHECK_NE(&from, this); + const FlushParam* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.FlushParam) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.FlushParam) + MergeFrom(*source); + } +} + +void FlushParam::MergeFrom(const FlushParam& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.FlushParam) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + collection_name_array_.MergeFrom(from.collection_name_array_); +} + +void FlushParam::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.FlushParam) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void FlushParam::CopyFrom(const FlushParam& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.FlushParam) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool FlushParam::IsInitialized() const { + return true; +} + +void FlushParam::InternalSwap(FlushParam* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + collection_name_array_.InternalSwap(CastToBase(&other->collection_name_array_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata FlushParam::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void CompactParam::InitAsDefaultInstance() { +} +class CompactParam::_Internal { + public: +}; + +CompactParam::CompactParam() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.CompactParam) +} +CompactParam::CompactParam(const CompactParam& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.collection_name().empty()) { + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); + } + threshold_ = from.threshold_; + // @@protoc_insertion_point(copy_constructor:milvus.grpc.CompactParam) +} + +void CompactParam::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_CompactParam_message_2eproto.base); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + threshold_ = 0; +} + +CompactParam::~CompactParam() { + // @@protoc_insertion_point(destructor:milvus.grpc.CompactParam) + SharedDtor(); +} + +void CompactParam::SharedDtor() { + collection_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void CompactParam::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const CompactParam& CompactParam::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_CompactParam_message_2eproto.base); + return *internal_default_instance(); +} + + +void CompactParam::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.CompactParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + threshold_ = 0; + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* CompactParam::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // string collection_name = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_collection_name(), ptr, ctx, "milvus.grpc.CompactParam.collection_name"); + CHK_(ptr); + } else goto handle_unusual; + continue; + // double threshold = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 17)) { + threshold_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(double); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool CompactParam::MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + // @@protoc_insertion_point(parse_start:milvus.grpc.CompactParam) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // string collection_name = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_collection_name())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.CompactParam.collection_name")); + } else { + goto handle_unusual; + } + break; + } + + // double threshold = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (17 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + double, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_DOUBLE>( + input, &threshold_))); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:milvus.grpc.CompactParam) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.CompactParam) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void CompactParam::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.CompactParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string collection_name = 1; + if (this->collection_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.CompactParam.collection_name"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->collection_name(), output); + } + + // double threshold = 2; + if (!(this->threshold() <= 0 && this->threshold() >= 0)) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDouble(2, this->threshold(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:milvus.grpc.CompactParam) +} + +::PROTOBUF_NAMESPACE_ID::uint8* CompactParam::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.CompactParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string collection_name = 1; + if (this->collection_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.CompactParam.collection_name"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 1, this->collection_name(), target); + } + + // double threshold = 2; + if (!(this->threshold() <= 0 && this->threshold() >= 0)) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(2, this->threshold(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.CompactParam) + return target; +} + +size_t CompactParam::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.CompactParam) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // string collection_name = 1; + if (this->collection_name().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->collection_name()); + } + + // double threshold = 2; + if (!(this->threshold() <= 0 && this->threshold() >= 0)) { + total_size += 1 + 8; + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void CompactParam::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.CompactParam) + GOOGLE_DCHECK_NE(&from, this); + const CompactParam* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.CompactParam) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.CompactParam) + MergeFrom(*source); + } +} + +void CompactParam::MergeFrom(const CompactParam& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.CompactParam) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.collection_name().size() > 0) { + + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); + } + if (!(from.threshold() <= 0 && from.threshold() >= 0)) { + set_threshold(from.threshold()); + } +} + +void CompactParam::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.CompactParam) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void CompactParam::CopyFrom(const CompactParam& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.CompactParam) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool CompactParam::IsInitialized() const { + return true; +} + +void CompactParam::InternalSwap(CompactParam* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + collection_name_.Swap(&other->collection_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(threshold_, other->threshold_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata CompactParam::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void DeleteByIDParam::InitAsDefaultInstance() { +} +class DeleteByIDParam::_Internal { + public: +}; + +DeleteByIDParam::DeleteByIDParam() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.DeleteByIDParam) +} +DeleteByIDParam::DeleteByIDParam(const DeleteByIDParam& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + id_array_(from.id_array_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.collection_name().empty()) { + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); + } + // @@protoc_insertion_point(copy_constructor:milvus.grpc.DeleteByIDParam) +} + +void DeleteByIDParam::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_DeleteByIDParam_message_2eproto.base); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +DeleteByIDParam::~DeleteByIDParam() { + // @@protoc_insertion_point(destructor:milvus.grpc.DeleteByIDParam) + SharedDtor(); +} + +void DeleteByIDParam::SharedDtor() { + collection_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void DeleteByIDParam::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const DeleteByIDParam& DeleteByIDParam::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_DeleteByIDParam_message_2eproto.base); + return *internal_default_instance(); +} + + +void DeleteByIDParam::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.DeleteByIDParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + id_array_.Clear(); + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* DeleteByIDParam::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // string collection_name = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_collection_name(), ptr, ctx, "milvus.grpc.DeleteByIDParam.collection_name"); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated int64 id_array = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt64Parser(mutable_id_array(), ptr, ctx); + CHK_(ptr); + } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16) { + add_id_array(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr)); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool DeleteByIDParam::MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + // @@protoc_insertion_point(parse_start:milvus.grpc.DeleteByIDParam) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // string collection_name = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_collection_name())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.DeleteByIDParam.collection_name")); + } else { + goto handle_unusual; + } + break; + } + + // repeated int64 id_array = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPackedPrimitive< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + input, this->mutable_id_array()))); + } else if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) { + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + 1, 18u, input, this->mutable_id_array()))); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:milvus.grpc.DeleteByIDParam) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.DeleteByIDParam) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void DeleteByIDParam::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.DeleteByIDParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string collection_name = 1; + if (this->collection_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.DeleteByIDParam.collection_name"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->collection_name(), output); + } + + // repeated int64 id_array = 2; + if (this->id_array_size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTag(2, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(_id_array_cached_byte_size_.load( + std::memory_order_relaxed)); + } + for (int i = 0, n = this->id_array_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64NoTag( + this->id_array(i), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:milvus.grpc.DeleteByIDParam) +} + +::PROTOBUF_NAMESPACE_ID::uint8* DeleteByIDParam::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.DeleteByIDParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string collection_name = 1; + if (this->collection_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.DeleteByIDParam.collection_name"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 1, this->collection_name(), target); + } + + // repeated int64 id_array = 2; + if (this->id_array_size() > 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTagToArray( + 2, + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + target); + target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray( + _id_array_cached_byte_size_.load(std::memory_order_relaxed), + target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + WriteInt64NoTagToArray(this->id_array_, target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.DeleteByIDParam) + return target; +} + +size_t DeleteByIDParam::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.DeleteByIDParam) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated int64 id_array = 2; + { + size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + Int64Size(this->id_array_); + if (data_size > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size)); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size); + _id_array_cached_byte_size_.store(cached_size, + std::memory_order_relaxed); + total_size += data_size; + } + + // string collection_name = 1; + if (this->collection_name().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->collection_name()); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void DeleteByIDParam::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.DeleteByIDParam) + GOOGLE_DCHECK_NE(&from, this); + const DeleteByIDParam* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.DeleteByIDParam) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.DeleteByIDParam) + MergeFrom(*source); + } +} + +void DeleteByIDParam::MergeFrom(const DeleteByIDParam& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.DeleteByIDParam) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + id_array_.MergeFrom(from.id_array_); + if (from.collection_name().size() > 0) { + + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); + } +} + +void DeleteByIDParam::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.DeleteByIDParam) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void DeleteByIDParam::CopyFrom(const DeleteByIDParam& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.DeleteByIDParam) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool DeleteByIDParam::IsInitialized() const { + return true; +} + +void DeleteByIDParam::InternalSwap(DeleteByIDParam* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + id_array_.InternalSwap(&other->id_array_); + collection_name_.Swap(&other->collection_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} + +::PROTOBUF_NAMESPACE_ID::Metadata DeleteByIDParam::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void CollectionInfo::InitAsDefaultInstance() { + ::milvus::grpc::_CollectionInfo_default_instance_._instance.get_mutable()->status_ = const_cast< ::milvus::grpc::Status*>( + ::milvus::grpc::Status::internal_default_instance()); +} +class CollectionInfo::_Internal { + public: + static const ::milvus::grpc::Status& status(const CollectionInfo* msg); +}; + +const ::milvus::grpc::Status& +CollectionInfo::_Internal::status(const CollectionInfo* msg) { + return *msg->status_; +} +CollectionInfo::CollectionInfo() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.CollectionInfo) +} +CollectionInfo::CollectionInfo(const CollectionInfo& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + json_info_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.json_info().empty()) { + json_info_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.json_info_); + } + if (from.has_status()) { + status_ = new ::milvus::grpc::Status(*from.status_); + } else { + status_ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:milvus.grpc.CollectionInfo) +} + +void CollectionInfo::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_CollectionInfo_message_2eproto.base); + json_info_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + status_ = nullptr; +} + +CollectionInfo::~CollectionInfo() { + // @@protoc_insertion_point(destructor:milvus.grpc.CollectionInfo) + SharedDtor(); +} + +void CollectionInfo::SharedDtor() { + json_info_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (this != internal_default_instance()) delete status_; +} + +void CollectionInfo::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const CollectionInfo& CollectionInfo::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_CollectionInfo_message_2eproto.base); + return *internal_default_instance(); +} + + +void CollectionInfo::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.CollectionInfo) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + json_info_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (GetArenaNoVirtual() == nullptr && status_ != nullptr) { + delete status_; + } + status_ = nullptr; + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* CollectionInfo::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // .milvus.grpc.Status status = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(mutable_status(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // string json_info = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_json_info(), ptr, ctx, "milvus.grpc.CollectionInfo.json_info"); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool CollectionInfo::MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + // @@protoc_insertion_point(parse_start:milvus.grpc.CollectionInfo) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // .milvus.grpc.Status status = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, mutable_status())); + } else { + goto handle_unusual; + } + break; + } + + // string json_info = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_json_info())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->json_info().data(), static_cast(this->json_info().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.CollectionInfo.json_info")); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:milvus.grpc.CollectionInfo) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.CollectionInfo) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void CollectionInfo::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.CollectionInfo) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.grpc.Status status = 1; + if (this->has_status()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, _Internal::status(this), output); + } + + // string json_info = 2; + if (this->json_info().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->json_info().data(), static_cast(this->json_info().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.CollectionInfo.json_info"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 2, this->json_info(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:milvus.grpc.CollectionInfo) +} + +::PROTOBUF_NAMESPACE_ID::uint8* CollectionInfo::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.CollectionInfo) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.grpc.Status status = 1; + if (this->has_status()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 1, _Internal::status(this), target); + } + + // string json_info = 2; + if (this->json_info().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->json_info().data(), static_cast(this->json_info().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.CollectionInfo.json_info"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 2, this->json_info(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.CollectionInfo) + return target; +} + +size_t CollectionInfo::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.CollectionInfo) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // string json_info = 2; + if (this->json_info().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->json_info()); + } + + // .milvus.grpc.Status status = 1; + if (this->has_status()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *status_); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void CollectionInfo::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.CollectionInfo) + GOOGLE_DCHECK_NE(&from, this); + const CollectionInfo* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.CollectionInfo) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.CollectionInfo) + MergeFrom(*source); + } +} + +void CollectionInfo::MergeFrom(const CollectionInfo& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.CollectionInfo) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.json_info().size() > 0) { + + json_info_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.json_info_); + } + if (from.has_status()) { + mutable_status()->::milvus::grpc::Status::MergeFrom(from.status()); + } +} + +void CollectionInfo::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.CollectionInfo) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void CollectionInfo::CopyFrom(const CollectionInfo& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.CollectionInfo) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool CollectionInfo::IsInitialized() const { + return true; +} + +void CollectionInfo::InternalSwap(CollectionInfo* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + json_info_.Swap(&other->json_info_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(status_, other->status_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata CollectionInfo::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void GetEntityIDsParam::InitAsDefaultInstance() { +} +class GetEntityIDsParam::_Internal { + public: +}; + +GetEntityIDsParam::GetEntityIDsParam() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.GetEntityIDsParam) +} +GetEntityIDsParam::GetEntityIDsParam(const GetEntityIDsParam& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.collection_name().empty()) { + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); + } + segment_id_ = from.segment_id_; + // @@protoc_insertion_point(copy_constructor:milvus.grpc.GetEntityIDsParam) +} + +void GetEntityIDsParam::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_GetEntityIDsParam_message_2eproto.base); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + segment_id_ = PROTOBUF_LONGLONG(0); +} + +GetEntityIDsParam::~GetEntityIDsParam() { + // @@protoc_insertion_point(destructor:milvus.grpc.GetEntityIDsParam) + SharedDtor(); +} + +void GetEntityIDsParam::SharedDtor() { + collection_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void GetEntityIDsParam::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const GetEntityIDsParam& GetEntityIDsParam::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_GetEntityIDsParam_message_2eproto.base); + return *internal_default_instance(); +} + + +void GetEntityIDsParam::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.GetEntityIDsParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + segment_id_ = PROTOBUF_LONGLONG(0); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* GetEntityIDsParam::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // string collection_name = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_collection_name(), ptr, ctx, "milvus.grpc.GetEntityIDsParam.collection_name"); + CHK_(ptr); + } else goto handle_unusual; + continue; + // int64 segment_id = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + segment_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool GetEntityIDsParam::MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + // @@protoc_insertion_point(parse_start:milvus.grpc.GetEntityIDsParam) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // string collection_name = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_collection_name())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.GetEntityIDsParam.collection_name")); + } else { + goto handle_unusual; + } + break; + } + + // int64 segment_id = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + input, &segment_id_))); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:milvus.grpc.GetEntityIDsParam) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.GetEntityIDsParam) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void GetEntityIDsParam::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.GetEntityIDsParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string collection_name = 1; + if (this->collection_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.GetEntityIDsParam.collection_name"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->collection_name(), output); + } + + // int64 segment_id = 2; + if (this->segment_id() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(2, this->segment_id(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:milvus.grpc.GetEntityIDsParam) +} + +::PROTOBUF_NAMESPACE_ID::uint8* GetEntityIDsParam::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.GetEntityIDsParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string collection_name = 1; + if (this->collection_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.GetEntityIDsParam.collection_name"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 1, this->collection_name(), target); + } + + // int64 segment_id = 2; + if (this->segment_id() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(2, this->segment_id(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.GetEntityIDsParam) + return target; +} + +size_t GetEntityIDsParam::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.GetEntityIDsParam) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // string collection_name = 1; + if (this->collection_name().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->collection_name()); + } + + // int64 segment_id = 2; + if (this->segment_id() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( + this->segment_id()); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void GetEntityIDsParam::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.GetEntityIDsParam) + GOOGLE_DCHECK_NE(&from, this); + const GetEntityIDsParam* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.GetEntityIDsParam) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.GetEntityIDsParam) + MergeFrom(*source); + } +} + +void GetEntityIDsParam::MergeFrom(const GetEntityIDsParam& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.GetEntityIDsParam) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.collection_name().size() > 0) { + + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); + } + if (from.segment_id() != 0) { + set_segment_id(from.segment_id()); + } +} + +void GetEntityIDsParam::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.GetEntityIDsParam) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void GetEntityIDsParam::CopyFrom(const GetEntityIDsParam& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.GetEntityIDsParam) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool GetEntityIDsParam::IsInitialized() const { + return true; +} + +void GetEntityIDsParam::InternalSwap(GetEntityIDsParam* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + collection_name_.Swap(&other->collection_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(segment_id_, other->segment_id_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata GetEntityIDsParam::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void EntityIdentity::InitAsDefaultInstance() { +} +class EntityIdentity::_Internal { + public: +}; + +EntityIdentity::EntityIdentity() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.EntityIdentity) +} +EntityIdentity::EntityIdentity(const EntityIdentity& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + id_array_(from.id_array_), + field_names_(from.field_names_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.collection_name().empty()) { + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); + } + // @@protoc_insertion_point(copy_constructor:milvus.grpc.EntityIdentity) +} + +void EntityIdentity::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_EntityIdentity_message_2eproto.base); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +EntityIdentity::~EntityIdentity() { + // @@protoc_insertion_point(destructor:milvus.grpc.EntityIdentity) + SharedDtor(); +} + +void EntityIdentity::SharedDtor() { + collection_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void EntityIdentity::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const EntityIdentity& EntityIdentity::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_EntityIdentity_message_2eproto.base); + return *internal_default_instance(); +} + + +void EntityIdentity::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.EntityIdentity) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + id_array_.Clear(); + field_names_.Clear(); + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* EntityIdentity::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // string collection_name = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_collection_name(), ptr, ctx, "milvus.grpc.EntityIdentity.collection_name"); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated int64 id_array = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt64Parser(mutable_id_array(), ptr, ctx); + CHK_(ptr); + } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16) { + add_id_array(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr)); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated string field_names = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr -= 1; + do { + ptr += 1; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(add_field_names(), ptr, ctx, "milvus.grpc.EntityIdentity.field_names"); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 26); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool EntityIdentity::MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + // @@protoc_insertion_point(parse_start:milvus.grpc.EntityIdentity) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // string collection_name = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_collection_name())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.EntityIdentity.collection_name")); + } else { + goto handle_unusual; + } + break; + } + + // repeated int64 id_array = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPackedPrimitive< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + input, this->mutable_id_array()))); + } else if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) { + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + 1, 18u, input, this->mutable_id_array()))); + } else { + goto handle_unusual; + } + break; + } + + // repeated string field_names = 3; + case 3: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->add_field_names())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->field_names(this->field_names_size() - 1).data(), + static_cast(this->field_names(this->field_names_size() - 1).length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.EntityIdentity.field_names")); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:milvus.grpc.EntityIdentity) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.EntityIdentity) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void EntityIdentity::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.EntityIdentity) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string collection_name = 1; + if (this->collection_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.EntityIdentity.collection_name"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->collection_name(), output); + } + + // repeated int64 id_array = 2; + if (this->id_array_size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTag(2, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(_id_array_cached_byte_size_.load( + std::memory_order_relaxed)); + } + for (int i = 0, n = this->id_array_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64NoTag( + this->id_array(i), output); + } + + // repeated string field_names = 3; + for (int i = 0, n = this->field_names_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->field_names(i).data(), static_cast(this->field_names(i).length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.EntityIdentity.field_names"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteString( + 3, this->field_names(i), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:milvus.grpc.EntityIdentity) +} + +::PROTOBUF_NAMESPACE_ID::uint8* EntityIdentity::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.EntityIdentity) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string collection_name = 1; + if (this->collection_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.EntityIdentity.collection_name"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 1, this->collection_name(), target); + } + + // repeated int64 id_array = 2; + if (this->id_array_size() > 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTagToArray( + 2, + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + target); + target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray( + _id_array_cached_byte_size_.load(std::memory_order_relaxed), + target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + WriteInt64NoTagToArray(this->id_array_, target); + } + + // repeated string field_names = 3; + for (int i = 0, n = this->field_names_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->field_names(i).data(), static_cast(this->field_names(i).length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.EntityIdentity.field_names"); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + WriteStringToArray(3, this->field_names(i), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.EntityIdentity) + return target; +} + +size_t EntityIdentity::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.EntityIdentity) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated int64 id_array = 2; + { + size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + Int64Size(this->id_array_); + if (data_size > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size)); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size); + _id_array_cached_byte_size_.store(cached_size, + std::memory_order_relaxed); + total_size += data_size; + } + + // repeated string field_names = 3; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->field_names_size()); + for (int i = 0, n = this->field_names_size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->field_names(i)); + } + + // string collection_name = 1; + if (this->collection_name().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->collection_name()); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void EntityIdentity::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.EntityIdentity) + GOOGLE_DCHECK_NE(&from, this); + const EntityIdentity* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.EntityIdentity) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.EntityIdentity) + MergeFrom(*source); + } +} + +void EntityIdentity::MergeFrom(const EntityIdentity& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.EntityIdentity) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + id_array_.MergeFrom(from.id_array_); + field_names_.MergeFrom(from.field_names_); + if (from.collection_name().size() > 0) { + + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); + } +} + +void EntityIdentity::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.EntityIdentity) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void EntityIdentity::CopyFrom(const EntityIdentity& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.EntityIdentity) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool EntityIdentity::IsInitialized() const { + return true; +} + +void EntityIdentity::InternalSwap(EntityIdentity* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + id_array_.InternalSwap(&other->id_array_); + field_names_.InternalSwap(CastToBase(&other->field_names_)); + collection_name_.Swap(&other->collection_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} + +::PROTOBUF_NAMESPACE_ID::Metadata EntityIdentity::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void VectorFieldParam::InitAsDefaultInstance() { +} +class VectorFieldParam::_Internal { + public: +}; + +VectorFieldParam::VectorFieldParam() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.VectorFieldParam) +} +VectorFieldParam::VectorFieldParam(const VectorFieldParam& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + dimension_ = from.dimension_; + // @@protoc_insertion_point(copy_constructor:milvus.grpc.VectorFieldParam) +} + +void VectorFieldParam::SharedCtor() { + dimension_ = PROTOBUF_LONGLONG(0); +} + +VectorFieldParam::~VectorFieldParam() { + // @@protoc_insertion_point(destructor:milvus.grpc.VectorFieldParam) + SharedDtor(); +} + +void VectorFieldParam::SharedDtor() { +} + +void VectorFieldParam::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const VectorFieldParam& VectorFieldParam::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_VectorFieldParam_message_2eproto.base); + return *internal_default_instance(); +} + + +void VectorFieldParam::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.VectorFieldParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + dimension_ = PROTOBUF_LONGLONG(0); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* VectorFieldParam::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // int64 dimension = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + dimension_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool VectorFieldParam::MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + // @@protoc_insertion_point(parse_start:milvus.grpc.VectorFieldParam) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // int64 dimension = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + input, &dimension_))); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:milvus.grpc.VectorFieldParam) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.VectorFieldParam) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void VectorFieldParam::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.VectorFieldParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // int64 dimension = 1; + if (this->dimension() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(1, this->dimension(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:milvus.grpc.VectorFieldParam) +} + +::PROTOBUF_NAMESPACE_ID::uint8* VectorFieldParam::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.VectorFieldParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // int64 dimension = 1; + if (this->dimension() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(1, this->dimension(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.VectorFieldParam) + return target; +} + +size_t VectorFieldParam::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.VectorFieldParam) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // int64 dimension = 1; + if (this->dimension() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( + this->dimension()); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void VectorFieldParam::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.VectorFieldParam) + GOOGLE_DCHECK_NE(&from, this); + const VectorFieldParam* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.VectorFieldParam) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.VectorFieldParam) + MergeFrom(*source); + } +} + +void VectorFieldParam::MergeFrom(const VectorFieldParam& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.VectorFieldParam) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.dimension() != 0) { + set_dimension(from.dimension()); + } +} + +void VectorFieldParam::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.VectorFieldParam) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void VectorFieldParam::CopyFrom(const VectorFieldParam& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.VectorFieldParam) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool VectorFieldParam::IsInitialized() const { + return true; +} + +void VectorFieldParam::InternalSwap(VectorFieldParam* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(dimension_, other->dimension_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata VectorFieldParam::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void FieldType::InitAsDefaultInstance() { + ::milvus::grpc::_FieldType_default_instance_.data_type_ = 0; + ::milvus::grpc::_FieldType_default_instance_.vector_param_ = const_cast< ::milvus::grpc::VectorFieldParam*>( + ::milvus::grpc::VectorFieldParam::internal_default_instance()); +} +class FieldType::_Internal { + public: + static const ::milvus::grpc::VectorFieldParam& vector_param(const FieldType* msg); +}; + +const ::milvus::grpc::VectorFieldParam& +FieldType::_Internal::vector_param(const FieldType* msg) { + return *msg->value_.vector_param_; +} +void FieldType::set_allocated_vector_param(::milvus::grpc::VectorFieldParam* vector_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + clear_value(); + if (vector_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + vector_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, vector_param, submessage_arena); + } + set_has_vector_param(); + value_.vector_param_ = vector_param; + } + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.FieldType.vector_param) +} +FieldType::FieldType() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.FieldType) +} +FieldType::FieldType(const FieldType& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + clear_has_value(); + switch (from.value_case()) { + case kDataType: { + set_data_type(from.data_type()); + break; + } + case kVectorParam: { + mutable_vector_param()->::milvus::grpc::VectorFieldParam::MergeFrom(from.vector_param()); + break; + } + case VALUE_NOT_SET: { + break; + } + } + // @@protoc_insertion_point(copy_constructor:milvus.grpc.FieldType) +} + +void FieldType::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_FieldType_message_2eproto.base); + clear_has_value(); +} + +FieldType::~FieldType() { + // @@protoc_insertion_point(destructor:milvus.grpc.FieldType) + SharedDtor(); +} + +void FieldType::SharedDtor() { + if (has_value()) { + clear_value(); + } +} + +void FieldType::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const FieldType& FieldType::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_FieldType_message_2eproto.base); + return *internal_default_instance(); +} + + +void FieldType::clear_value() { +// @@protoc_insertion_point(one_of_clear_start:milvus.grpc.FieldType) + switch (value_case()) { + case kDataType: { + // No need to clear + break; + } + case kVectorParam: { + delete value_.vector_param_; + break; + } + case VALUE_NOT_SET: { + break; + } + } + _oneof_case_[0] = VALUE_NOT_SET; +} + + +void FieldType::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.FieldType) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + clear_value(); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* FieldType::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // .milvus.grpc.DataType data_type = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + set_data_type(static_cast<::milvus::grpc::DataType>(val)); + } else goto handle_unusual; + continue; + // .milvus.grpc.VectorFieldParam vector_param = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(mutable_vector_param(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool FieldType::MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + // @@protoc_insertion_point(parse_start:milvus.grpc.FieldType) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // .milvus.grpc.DataType data_type = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) { + int value = 0; + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + int, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + set_data_type(static_cast< ::milvus::grpc::DataType >(value)); + } else { + goto handle_unusual; + } + break; + } + + // .milvus.grpc.VectorFieldParam vector_param = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, mutable_vector_param())); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:milvus.grpc.FieldType) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.FieldType) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void FieldType::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.FieldType) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.grpc.DataType data_type = 1; + if (has_data_type()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnum( + 1, this->data_type(), output); + } + + // .milvus.grpc.VectorFieldParam vector_param = 2; + if (has_vector_param()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, _Internal::vector_param(this), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:milvus.grpc.FieldType) +} + +::PROTOBUF_NAMESPACE_ID::uint8* FieldType::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.FieldType) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.grpc.DataType data_type = 1; + if (has_data_type()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 1, this->data_type(), target); + } + + // .milvus.grpc.VectorFieldParam vector_param = 2; + if (has_vector_param()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 2, _Internal::vector_param(this), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.FieldType) + return target; +} + +size_t FieldType::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.FieldType) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + switch (value_case()) { + // .milvus.grpc.DataType data_type = 1; + case kDataType: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->data_type()); + break; + } + // .milvus.grpc.VectorFieldParam vector_param = 2; + case kVectorParam: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *value_.vector_param_); + break; + } + case VALUE_NOT_SET: { + break; + } + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void FieldType::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.FieldType) + GOOGLE_DCHECK_NE(&from, this); + const FieldType* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.FieldType) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.FieldType) + MergeFrom(*source); + } +} + +void FieldType::MergeFrom(const FieldType& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.FieldType) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + switch (from.value_case()) { + case kDataType: { + set_data_type(from.data_type()); + break; + } + case kVectorParam: { + mutable_vector_param()->::milvus::grpc::VectorFieldParam::MergeFrom(from.vector_param()); + break; + } + case VALUE_NOT_SET: { + break; + } + } +} + +void FieldType::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.FieldType) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void FieldType::CopyFrom(const FieldType& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.FieldType) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool FieldType::IsInitialized() const { + return true; +} + +void FieldType::InternalSwap(FieldType* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(value_, other->value_); + swap(_oneof_case_[0], other->_oneof_case_[0]); +} + +::PROTOBUF_NAMESPACE_ID::Metadata FieldType::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void FieldParam::InitAsDefaultInstance() { +} +class FieldParam::_Internal { + public: +}; + +FieldParam::FieldParam() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.FieldParam) +} +FieldParam::FieldParam(const FieldParam& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + index_params_(from.index_params_), + extra_params_(from.extra_params_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.name().empty()) { + name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.name_); + } + ::memcpy(&id_, &from.id_, + static_cast(reinterpret_cast(&type_) - + reinterpret_cast(&id_)) + sizeof(type_)); + // @@protoc_insertion_point(copy_constructor:milvus.grpc.FieldParam) +} + +void FieldParam::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_FieldParam_message_2eproto.base); + name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + ::memset(&id_, 0, static_cast( + reinterpret_cast(&type_) - + reinterpret_cast(&id_)) + sizeof(type_)); +} + +FieldParam::~FieldParam() { + // @@protoc_insertion_point(destructor:milvus.grpc.FieldParam) + SharedDtor(); +} + +void FieldParam::SharedDtor() { + name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void FieldParam::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const FieldParam& FieldParam::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_FieldParam_message_2eproto.base); + return *internal_default_instance(); +} + + +void FieldParam::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.FieldParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + index_params_.Clear(); + extra_params_.Clear(); + name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + ::memset(&id_, 0, static_cast( + reinterpret_cast(&type_) - + reinterpret_cast(&id_)) + sizeof(type_)); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* FieldParam::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // uint64 id = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // string name = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_name(), ptr, ctx, "milvus.grpc.FieldParam.name"); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .milvus.grpc.DataType type = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + set_type(static_cast<::milvus::grpc::DataType>(val)); + } else goto handle_unusual; + continue; + // repeated .milvus.grpc.KeyValuePair index_params = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(add_index_params(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 34); + } else goto handle_unusual; + continue; + // repeated .milvus.grpc.KeyValuePair extra_params = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(add_extra_params(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 42); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool FieldParam::MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + // @@protoc_insertion_point(parse_start:milvus.grpc.FieldParam) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // uint64 id = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>( + input, &id_))); + } else { + goto handle_unusual; + } + break; + } + + // string name = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_name())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->name().data(), static_cast(this->name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.FieldParam.name")); + } else { + goto handle_unusual; + } + break; + } + + // .milvus.grpc.DataType type = 3; + case 3: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (24 & 0xFF)) { + int value = 0; + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + int, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + set_type(static_cast< ::milvus::grpc::DataType >(value)); + } else { + goto handle_unusual; + } + break; + } + + // repeated .milvus.grpc.KeyValuePair index_params = 4; + case 4: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (34 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, add_index_params())); + } else { + goto handle_unusual; + } + break; + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 5; + case 5: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (42 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, add_extra_params())); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:milvus.grpc.FieldParam) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.FieldParam) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void FieldParam::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.FieldParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // uint64 id = 1; + if (this->id() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(1, this->id(), output); + } + + // string name = 2; + if (this->name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->name().data(), static_cast(this->name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.FieldParam.name"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 2, this->name(), output); + } + + // .milvus.grpc.DataType type = 3; + if (this->type() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnum( + 3, this->type(), output); + } + + // repeated .milvus.grpc.KeyValuePair index_params = 4; + for (unsigned int i = 0, + n = static_cast(this->index_params_size()); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 4, + this->index_params(static_cast(i)), + output); + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 5; + for (unsigned int i = 0, + n = static_cast(this->extra_params_size()); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 5, + this->extra_params(static_cast(i)), + output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:milvus.grpc.FieldParam) +} + +::PROTOBUF_NAMESPACE_ID::uint8* FieldParam::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.FieldParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // uint64 id = 1; + if (this->id() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(1, this->id(), target); + } + + // string name = 2; + if (this->name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->name().data(), static_cast(this->name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.FieldParam.name"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 2, this->name(), target); + } + + // .milvus.grpc.DataType type = 3; + if (this->type() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 3, this->type(), target); + } + + // repeated .milvus.grpc.KeyValuePair index_params = 4; + for (unsigned int i = 0, + n = static_cast(this->index_params_size()); i < n; i++) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 4, this->index_params(static_cast(i)), target); + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 5; + for (unsigned int i = 0, + n = static_cast(this->extra_params_size()); i < n; i++) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 5, this->extra_params(static_cast(i)), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.FieldParam) + return target; +} + +size_t FieldParam::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.FieldParam) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .milvus.grpc.KeyValuePair index_params = 4; + { + unsigned int count = static_cast(this->index_params_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + this->index_params(static_cast(i))); + } + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 5; + { + unsigned int count = static_cast(this->extra_params_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + this->extra_params(static_cast(i))); + } + } + + // string name = 2; + if (this->name().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->name()); + } + + // uint64 id = 1; + if (this->id() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size( + this->id()); + } + + // .milvus.grpc.DataType type = 3; + if (this->type() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->type()); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void FieldParam::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.FieldParam) + GOOGLE_DCHECK_NE(&from, this); + const FieldParam* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.FieldParam) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.FieldParam) + MergeFrom(*source); + } +} + +void FieldParam::MergeFrom(const FieldParam& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.FieldParam) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + index_params_.MergeFrom(from.index_params_); + extra_params_.MergeFrom(from.extra_params_); + if (from.name().size() > 0) { + + name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.name_); + } + if (from.id() != 0) { + set_id(from.id()); + } + if (from.type() != 0) { + set_type(from.type()); + } +} + +void FieldParam::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.FieldParam) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void FieldParam::CopyFrom(const FieldParam& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.FieldParam) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool FieldParam::IsInitialized() const { + return true; +} + +void FieldParam::InternalSwap(FieldParam* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + CastToBase(&index_params_)->InternalSwap(CastToBase(&other->index_params_)); + CastToBase(&extra_params_)->InternalSwap(CastToBase(&other->extra_params_)); + name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(id_, other->id_); + swap(type_, other->type_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata FieldParam::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void VectorFieldRecord::InitAsDefaultInstance() { +} +class VectorFieldRecord::_Internal { + public: +}; + +VectorFieldRecord::VectorFieldRecord() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.VectorFieldRecord) +} +VectorFieldRecord::VectorFieldRecord(const VectorFieldRecord& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + value_(from.value_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:milvus.grpc.VectorFieldRecord) +} + +void VectorFieldRecord::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_VectorFieldRecord_message_2eproto.base); +} + +VectorFieldRecord::~VectorFieldRecord() { + // @@protoc_insertion_point(destructor:milvus.grpc.VectorFieldRecord) + SharedDtor(); +} + +void VectorFieldRecord::SharedDtor() { +} + +void VectorFieldRecord::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const VectorFieldRecord& VectorFieldRecord::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_VectorFieldRecord_message_2eproto.base); + return *internal_default_instance(); +} + + +void VectorFieldRecord::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.VectorFieldRecord) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + value_.Clear(); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* VectorFieldRecord::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // repeated .milvus.grpc.VectorRowRecord value = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(add_value(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 10); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool VectorFieldRecord::MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + // @@protoc_insertion_point(parse_start:milvus.grpc.VectorFieldRecord) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // repeated .milvus.grpc.VectorRowRecord value = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, add_value())); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:milvus.grpc.VectorFieldRecord) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.VectorFieldRecord) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void VectorFieldRecord::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.VectorFieldRecord) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated .milvus.grpc.VectorRowRecord value = 1; + for (unsigned int i = 0, + n = static_cast(this->value_size()); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, + this->value(static_cast(i)), + output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:milvus.grpc.VectorFieldRecord) +} + +::PROTOBUF_NAMESPACE_ID::uint8* VectorFieldRecord::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.VectorFieldRecord) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated .milvus.grpc.VectorRowRecord value = 1; + for (unsigned int i = 0, + n = static_cast(this->value_size()); i < n; i++) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 1, this->value(static_cast(i)), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.VectorFieldRecord) + return target; +} + +size_t VectorFieldRecord::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.VectorFieldRecord) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .milvus.grpc.VectorRowRecord value = 1; + { + unsigned int count = static_cast(this->value_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + this->value(static_cast(i))); + } + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void VectorFieldRecord::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.VectorFieldRecord) + GOOGLE_DCHECK_NE(&from, this); + const VectorFieldRecord* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.VectorFieldRecord) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.VectorFieldRecord) + MergeFrom(*source); + } +} + +void VectorFieldRecord::MergeFrom(const VectorFieldRecord& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.VectorFieldRecord) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + value_.MergeFrom(from.value_); +} + +void VectorFieldRecord::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.VectorFieldRecord) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void VectorFieldRecord::CopyFrom(const VectorFieldRecord& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.VectorFieldRecord) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool VectorFieldRecord::IsInitialized() const { + return true; +} + +void VectorFieldRecord::InternalSwap(VectorFieldRecord* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + CastToBase(&value_)->InternalSwap(CastToBase(&other->value_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata VectorFieldRecord::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void TermQuery::InitAsDefaultInstance() { +} +class TermQuery::_Internal { + public: +}; + +TermQuery::TermQuery() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.TermQuery) +} +TermQuery::TermQuery(const TermQuery& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + int_value_(from.int_value_), + double_value_(from.double_value_), + extra_params_(from.extra_params_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + field_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.field_name().empty()) { + field_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.field_name_); + } + ::memcpy(&value_num_, &from.value_num_, + static_cast(reinterpret_cast(&boost_) - + reinterpret_cast(&value_num_)) + sizeof(boost_)); + // @@protoc_insertion_point(copy_constructor:milvus.grpc.TermQuery) +} + +void TermQuery::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_TermQuery_message_2eproto.base); + field_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + ::memset(&value_num_, 0, static_cast( + reinterpret_cast(&boost_) - + reinterpret_cast(&value_num_)) + sizeof(boost_)); +} + +TermQuery::~TermQuery() { + // @@protoc_insertion_point(destructor:milvus.grpc.TermQuery) + SharedDtor(); +} + +void TermQuery::SharedDtor() { + field_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void TermQuery::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const TermQuery& TermQuery::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_TermQuery_message_2eproto.base); + return *internal_default_instance(); +} + + +void TermQuery::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.TermQuery) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + int_value_.Clear(); + double_value_.Clear(); + extra_params_.Clear(); + field_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + ::memset(&value_num_, 0, static_cast( + reinterpret_cast(&boost_) - + reinterpret_cast(&value_num_)) + sizeof(boost_)); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* TermQuery::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // string field_name = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_field_name(), ptr, ctx, "milvus.grpc.TermQuery.field_name"); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated int64 int_value = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt64Parser(mutable_int_value(), ptr, ctx); + CHK_(ptr); + } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16) { + add_int_value(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr)); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated double double_value = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedDoubleParser(mutable_double_value(), ptr, ctx); + CHK_(ptr); + } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 25) { + add_double_value(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); + ptr += sizeof(double); + } else goto handle_unusual; + continue; + // int64 value_num = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) { + value_num_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // float boost = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 45)) { + boost_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else goto handle_unusual; + continue; + // repeated .milvus.grpc.KeyValuePair extra_params = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(add_extra_params(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 50); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool TermQuery::MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + // @@protoc_insertion_point(parse_start:milvus.grpc.TermQuery) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // string field_name = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_field_name())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->field_name().data(), static_cast(this->field_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.TermQuery.field_name")); + } else { + goto handle_unusual; + } + break; + } + + // repeated int64 int_value = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPackedPrimitive< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + input, this->mutable_int_value()))); + } else if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) { + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + 1, 18u, input, this->mutable_int_value()))); + } else { + goto handle_unusual; + } + break; + } + + // repeated double double_value = 3; + case 3: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) { + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPackedPrimitive< + double, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_DOUBLE>( + input, this->mutable_double_value()))); + } else if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (25 & 0xFF)) { + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< + double, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_DOUBLE>( + 1, 26u, input, this->mutable_double_value()))); + } else { + goto handle_unusual; + } + break; + } + + // int64 value_num = 4; + case 4: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (32 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + input, &value_num_))); + } else { + goto handle_unusual; + } + break; + } + + // float boost = 5; + case 5: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (45 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>( + input, &boost_))); + } else { + goto handle_unusual; + } + break; + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 6; + case 6: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (50 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, add_extra_params())); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:milvus.grpc.TermQuery) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.TermQuery) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void TermQuery::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.TermQuery) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string field_name = 1; + if (this->field_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->field_name().data(), static_cast(this->field_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.TermQuery.field_name"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->field_name(), output); + } + + // repeated int64 int_value = 2; + if (this->int_value_size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTag(2, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(_int_value_cached_byte_size_.load( + std::memory_order_relaxed)); + } + for (int i = 0, n = this->int_value_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64NoTag( + this->int_value(i), output); + } + + // repeated double double_value = 3; + if (this->double_value_size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTag(3, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(_double_value_cached_byte_size_.load( + std::memory_order_relaxed)); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleArray( + this->double_value().data(), this->double_value_size(), output); + } + + // int64 value_num = 4; + if (this->value_num() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(4, this->value_num(), output); + } + + // float boost = 5; + if (!(this->boost() <= 0 && this->boost() >= 0)) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloat(5, this->boost(), output); + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 6; + for (unsigned int i = 0, + n = static_cast(this->extra_params_size()); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 6, + this->extra_params(static_cast(i)), + output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:milvus.grpc.TermQuery) +} + +::PROTOBUF_NAMESPACE_ID::uint8* TermQuery::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.TermQuery) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string field_name = 1; + if (this->field_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->field_name().data(), static_cast(this->field_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.TermQuery.field_name"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 1, this->field_name(), target); + } + + // repeated int64 int_value = 2; + if (this->int_value_size() > 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTagToArray( + 2, + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + target); + target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray( + _int_value_cached_byte_size_.load(std::memory_order_relaxed), + target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + WriteInt64NoTagToArray(this->int_value_, target); + } + + // repeated double double_value = 3; + if (this->double_value_size() > 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTagToArray( + 3, + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + target); + target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray( + _double_value_cached_byte_size_.load(std::memory_order_relaxed), + target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + WriteDoubleNoTagToArray(this->double_value_, target); + } + + // int64 value_num = 4; + if (this->value_num() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(4, this->value_num(), target); + } + + // float boost = 5; + if (!(this->boost() <= 0 && this->boost() >= 0)) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(5, this->boost(), target); + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 6; + for (unsigned int i = 0, + n = static_cast(this->extra_params_size()); i < n; i++) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 6, this->extra_params(static_cast(i)), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.TermQuery) + return target; +} + +size_t TermQuery::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.TermQuery) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated int64 int_value = 2; + { + size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + Int64Size(this->int_value_); + if (data_size > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size)); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size); + _int_value_cached_byte_size_.store(cached_size, + std::memory_order_relaxed); + total_size += data_size; + } + + // repeated double double_value = 3; + { + unsigned int count = static_cast(this->double_value_size()); + size_t data_size = 8UL * count; + if (data_size > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size)); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size); + _double_value_cached_byte_size_.store(cached_size, + std::memory_order_relaxed); + total_size += data_size; + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 6; + { + unsigned int count = static_cast(this->extra_params_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + this->extra_params(static_cast(i))); + } + } + + // string field_name = 1; + if (this->field_name().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->field_name()); + } + + // int64 value_num = 4; + if (this->value_num() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( + this->value_num()); + } + + // float boost = 5; + if (!(this->boost() <= 0 && this->boost() >= 0)) { + total_size += 1 + 4; + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void TermQuery::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.TermQuery) + GOOGLE_DCHECK_NE(&from, this); + const TermQuery* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.TermQuery) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.TermQuery) + MergeFrom(*source); + } +} + +void TermQuery::MergeFrom(const TermQuery& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.TermQuery) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + int_value_.MergeFrom(from.int_value_); + double_value_.MergeFrom(from.double_value_); + extra_params_.MergeFrom(from.extra_params_); + if (from.field_name().size() > 0) { + + field_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.field_name_); + } + if (from.value_num() != 0) { + set_value_num(from.value_num()); + } + if (!(from.boost() <= 0 && from.boost() >= 0)) { + set_boost(from.boost()); + } +} + +void TermQuery::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.TermQuery) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void TermQuery::CopyFrom(const TermQuery& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.TermQuery) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool TermQuery::IsInitialized() const { + return true; +} + +void TermQuery::InternalSwap(TermQuery* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + int_value_.InternalSwap(&other->int_value_); + double_value_.InternalSwap(&other->double_value_); + CastToBase(&extra_params_)->InternalSwap(CastToBase(&other->extra_params_)); + field_name_.Swap(&other->field_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(value_num_, other->value_num_); + swap(boost_, other->boost_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata TermQuery::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void CompareExpr::InitAsDefaultInstance() { +} +class CompareExpr::_Internal { + public: +}; + +CompareExpr::CompareExpr() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.CompareExpr) +} +CompareExpr::CompareExpr(const CompareExpr& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + operand_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.operand().empty()) { + operand_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.operand_); + } + operator__ = from.operator__; + // @@protoc_insertion_point(copy_constructor:milvus.grpc.CompareExpr) +} + +void CompareExpr::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_CompareExpr_message_2eproto.base); + operand_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + operator__ = 0; +} + +CompareExpr::~CompareExpr() { + // @@protoc_insertion_point(destructor:milvus.grpc.CompareExpr) + SharedDtor(); +} + +void CompareExpr::SharedDtor() { + operand_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void CompareExpr::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const CompareExpr& CompareExpr::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_CompareExpr_message_2eproto.base); + return *internal_default_instance(); +} + + +void CompareExpr::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.CompareExpr) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + operand_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + operator__ = 0; + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* CompareExpr::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // .milvus.grpc.CompareOperator operator = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + set_operator_(static_cast<::milvus::grpc::CompareOperator>(val)); + } else goto handle_unusual; + continue; + // string operand = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_operand(), ptr, ctx, "milvus.grpc.CompareExpr.operand"); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool CompareExpr::MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + // @@protoc_insertion_point(parse_start:milvus.grpc.CompareExpr) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // .milvus.grpc.CompareOperator operator = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) { + int value = 0; + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + int, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + set_operator_(static_cast< ::milvus::grpc::CompareOperator >(value)); + } else { + goto handle_unusual; + } + break; + } + + // string operand = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_operand())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->operand().data(), static_cast(this->operand().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.CompareExpr.operand")); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:milvus.grpc.CompareExpr) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.CompareExpr) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void CompareExpr::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.CompareExpr) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.grpc.CompareOperator operator = 1; + if (this->operator_() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnum( + 1, this->operator_(), output); + } + + // string operand = 2; + if (this->operand().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->operand().data(), static_cast(this->operand().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.CompareExpr.operand"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 2, this->operand(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:milvus.grpc.CompareExpr) +} + +::PROTOBUF_NAMESPACE_ID::uint8* CompareExpr::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.CompareExpr) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.grpc.CompareOperator operator = 1; + if (this->operator_() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 1, this->operator_(), target); + } + + // string operand = 2; + if (this->operand().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->operand().data(), static_cast(this->operand().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.CompareExpr.operand"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 2, this->operand(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.CompareExpr) + return target; +} + +size_t CompareExpr::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.CompareExpr) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // string operand = 2; + if (this->operand().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->operand()); + } + + // .milvus.grpc.CompareOperator operator = 1; + if (this->operator_() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->operator_()); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void CompareExpr::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.CompareExpr) + GOOGLE_DCHECK_NE(&from, this); + const CompareExpr* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.CompareExpr) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.CompareExpr) + MergeFrom(*source); + } +} + +void CompareExpr::MergeFrom(const CompareExpr& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.CompareExpr) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.operand().size() > 0) { + + operand_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.operand_); + } + if (from.operator_() != 0) { + set_operator_(from.operator_()); + } +} + +void CompareExpr::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.CompareExpr) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void CompareExpr::CopyFrom(const CompareExpr& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.CompareExpr) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool CompareExpr::IsInitialized() const { + return true; +} + +void CompareExpr::InternalSwap(CompareExpr* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + operand_.Swap(&other->operand_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(operator__, other->operator__); +} + +::PROTOBUF_NAMESPACE_ID::Metadata CompareExpr::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void RangeQuery::InitAsDefaultInstance() { +} +class RangeQuery::_Internal { + public: +}; + +RangeQuery::RangeQuery() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.RangeQuery) +} +RangeQuery::RangeQuery(const RangeQuery& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + operand_(from.operand_), + extra_params_(from.extra_params_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + field_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.field_name().empty()) { + field_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.field_name_); + } + boost_ = from.boost_; + // @@protoc_insertion_point(copy_constructor:milvus.grpc.RangeQuery) +} + +void RangeQuery::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_RangeQuery_message_2eproto.base); + field_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + boost_ = 0; +} + +RangeQuery::~RangeQuery() { + // @@protoc_insertion_point(destructor:milvus.grpc.RangeQuery) + SharedDtor(); +} + +void RangeQuery::SharedDtor() { + field_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void RangeQuery::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const RangeQuery& RangeQuery::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_RangeQuery_message_2eproto.base); + return *internal_default_instance(); +} + + +void RangeQuery::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.RangeQuery) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + operand_.Clear(); + extra_params_.Clear(); + field_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + boost_ = 0; + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* RangeQuery::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // string field_name = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_field_name(), ptr, ctx, "milvus.grpc.RangeQuery.field_name"); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated .milvus.grpc.CompareExpr operand = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(add_operand(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 18); + } else goto handle_unusual; + continue; + // float boost = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 29)) { + boost_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else goto handle_unusual; + continue; + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(add_extra_params(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 34); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool RangeQuery::MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + // @@protoc_insertion_point(parse_start:milvus.grpc.RangeQuery) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // string field_name = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_field_name())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->field_name().data(), static_cast(this->field_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.RangeQuery.field_name")); + } else { + goto handle_unusual; + } + break; + } + + // repeated .milvus.grpc.CompareExpr operand = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, add_operand())); + } else { + goto handle_unusual; + } + break; + } + + // float boost = 3; + case 3: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (29 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>( + input, &boost_))); + } else { + goto handle_unusual; + } + break; + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + case 4: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (34 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, add_extra_params())); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:milvus.grpc.RangeQuery) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.RangeQuery) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void RangeQuery::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.RangeQuery) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string field_name = 1; + if (this->field_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->field_name().data(), static_cast(this->field_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.RangeQuery.field_name"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->field_name(), output); + } + + // repeated .milvus.grpc.CompareExpr operand = 2; + for (unsigned int i = 0, + n = static_cast(this->operand_size()); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, + this->operand(static_cast(i)), + output); + } + + // float boost = 3; + if (!(this->boost() <= 0 && this->boost() >= 0)) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloat(3, this->boost(), output); + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + for (unsigned int i = 0, + n = static_cast(this->extra_params_size()); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 4, + this->extra_params(static_cast(i)), + output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:milvus.grpc.RangeQuery) +} + +::PROTOBUF_NAMESPACE_ID::uint8* RangeQuery::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.RangeQuery) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string field_name = 1; + if (this->field_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->field_name().data(), static_cast(this->field_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.RangeQuery.field_name"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 1, this->field_name(), target); + } + + // repeated .milvus.grpc.CompareExpr operand = 2; + for (unsigned int i = 0, + n = static_cast(this->operand_size()); i < n; i++) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 2, this->operand(static_cast(i)), target); + } + + // float boost = 3; + if (!(this->boost() <= 0 && this->boost() >= 0)) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(3, this->boost(), target); + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + for (unsigned int i = 0, + n = static_cast(this->extra_params_size()); i < n; i++) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 4, this->extra_params(static_cast(i)), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.RangeQuery) + return target; +} + +size_t RangeQuery::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.RangeQuery) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .milvus.grpc.CompareExpr operand = 2; + { + unsigned int count = static_cast(this->operand_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + this->operand(static_cast(i))); + } + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + { + unsigned int count = static_cast(this->extra_params_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + this->extra_params(static_cast(i))); + } + } + + // string field_name = 1; + if (this->field_name().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->field_name()); + } + + // float boost = 3; + if (!(this->boost() <= 0 && this->boost() >= 0)) { + total_size += 1 + 4; + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void RangeQuery::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.RangeQuery) + GOOGLE_DCHECK_NE(&from, this); + const RangeQuery* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.RangeQuery) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.RangeQuery) + MergeFrom(*source); + } +} + +void RangeQuery::MergeFrom(const RangeQuery& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.RangeQuery) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + operand_.MergeFrom(from.operand_); + extra_params_.MergeFrom(from.extra_params_); + if (from.field_name().size() > 0) { + + field_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.field_name_); + } + if (!(from.boost() <= 0 && from.boost() >= 0)) { + set_boost(from.boost()); + } +} + +void RangeQuery::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.RangeQuery) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void RangeQuery::CopyFrom(const RangeQuery& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.RangeQuery) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool RangeQuery::IsInitialized() const { + return true; +} + +void RangeQuery::InternalSwap(RangeQuery* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + CastToBase(&operand_)->InternalSwap(CastToBase(&other->operand_)); + CastToBase(&extra_params_)->InternalSwap(CastToBase(&other->extra_params_)); + field_name_.Swap(&other->field_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(boost_, other->boost_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata RangeQuery::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void VectorQuery::InitAsDefaultInstance() { +} +class VectorQuery::_Internal { + public: +}; + +VectorQuery::VectorQuery() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.VectorQuery) +} +VectorQuery::VectorQuery(const VectorQuery& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + records_(from.records_), + extra_params_(from.extra_params_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + field_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.field_name().empty()) { + field_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.field_name_); + } + ::memcpy(&topk_, &from.topk_, + static_cast(reinterpret_cast(&query_boost_) - + reinterpret_cast(&topk_)) + sizeof(query_boost_)); + // @@protoc_insertion_point(copy_constructor:milvus.grpc.VectorQuery) +} + +void VectorQuery::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_VectorQuery_message_2eproto.base); + field_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + ::memset(&topk_, 0, static_cast( + reinterpret_cast(&query_boost_) - + reinterpret_cast(&topk_)) + sizeof(query_boost_)); +} + +VectorQuery::~VectorQuery() { + // @@protoc_insertion_point(destructor:milvus.grpc.VectorQuery) + SharedDtor(); +} + +void VectorQuery::SharedDtor() { + field_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void VectorQuery::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const VectorQuery& VectorQuery::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_VectorQuery_message_2eproto.base); + return *internal_default_instance(); +} + + +void VectorQuery::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.VectorQuery) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + records_.Clear(); + extra_params_.Clear(); + field_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + ::memset(&topk_, 0, static_cast( + reinterpret_cast(&query_boost_) - + reinterpret_cast(&topk_)) + sizeof(query_boost_)); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* VectorQuery::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // string field_name = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_field_name(), ptr, ctx, "milvus.grpc.VectorQuery.field_name"); + CHK_(ptr); + } else goto handle_unusual; + continue; + // float query_boost = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 21)) { + query_boost_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else goto handle_unusual; + continue; + // repeated .milvus.grpc.VectorRowRecord records = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(add_records(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 26); + } else goto handle_unusual; + continue; + // int64 topk = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) { + topk_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated .milvus.grpc.KeyValuePair extra_params = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(add_extra_params(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 42); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool VectorQuery::MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + // @@protoc_insertion_point(parse_start:milvus.grpc.VectorQuery) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // string field_name = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_field_name())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->field_name().data(), static_cast(this->field_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.VectorQuery.field_name")); + } else { + goto handle_unusual; + } + break; + } + + // float query_boost = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (21 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>( + input, &query_boost_))); + } else { + goto handle_unusual; + } + break; + } + + // repeated .milvus.grpc.VectorRowRecord records = 3; + case 3: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, add_records())); + } else { + goto handle_unusual; + } + break; + } + + // int64 topk = 4; + case 4: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (32 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + input, &topk_))); + } else { + goto handle_unusual; + } + break; + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 5; + case 5: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (42 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, add_extra_params())); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:milvus.grpc.VectorQuery) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.VectorQuery) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void VectorQuery::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.VectorQuery) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string field_name = 1; + if (this->field_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->field_name().data(), static_cast(this->field_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.VectorQuery.field_name"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->field_name(), output); + } + + // float query_boost = 2; + if (!(this->query_boost() <= 0 && this->query_boost() >= 0)) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloat(2, this->query_boost(), output); + } + + // repeated .milvus.grpc.VectorRowRecord records = 3; + for (unsigned int i = 0, + n = static_cast(this->records_size()); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 3, + this->records(static_cast(i)), + output); + } + + // int64 topk = 4; + if (this->topk() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(4, this->topk(), output); + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 5; + for (unsigned int i = 0, + n = static_cast(this->extra_params_size()); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 5, + this->extra_params(static_cast(i)), + output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:milvus.grpc.VectorQuery) +} + +::PROTOBUF_NAMESPACE_ID::uint8* VectorQuery::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.VectorQuery) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string field_name = 1; + if (this->field_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->field_name().data(), static_cast(this->field_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.VectorQuery.field_name"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 1, this->field_name(), target); + } + + // float query_boost = 2; + if (!(this->query_boost() <= 0 && this->query_boost() >= 0)) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->query_boost(), target); + } + + // repeated .milvus.grpc.VectorRowRecord records = 3; + for (unsigned int i = 0, + n = static_cast(this->records_size()); i < n; i++) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 3, this->records(static_cast(i)), target); + } + + // int64 topk = 4; + if (this->topk() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(4, this->topk(), target); + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 5; + for (unsigned int i = 0, + n = static_cast(this->extra_params_size()); i < n; i++) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 5, this->extra_params(static_cast(i)), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.VectorQuery) + return target; +} + +size_t VectorQuery::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.VectorQuery) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .milvus.grpc.VectorRowRecord records = 3; + { + unsigned int count = static_cast(this->records_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + this->records(static_cast(i))); + } + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 5; + { + unsigned int count = static_cast(this->extra_params_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + this->extra_params(static_cast(i))); + } + } + + // string field_name = 1; + if (this->field_name().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->field_name()); + } + + // int64 topk = 4; + if (this->topk() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( + this->topk()); + } + + // float query_boost = 2; + if (!(this->query_boost() <= 0 && this->query_boost() >= 0)) { + total_size += 1 + 4; + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void VectorQuery::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.VectorQuery) + GOOGLE_DCHECK_NE(&from, this); + const VectorQuery* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.VectorQuery) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.VectorQuery) + MergeFrom(*source); + } +} + +void VectorQuery::MergeFrom(const VectorQuery& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.VectorQuery) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + records_.MergeFrom(from.records_); + extra_params_.MergeFrom(from.extra_params_); + if (from.field_name().size() > 0) { + + field_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.field_name_); + } + if (from.topk() != 0) { + set_topk(from.topk()); + } + if (!(from.query_boost() <= 0 && from.query_boost() >= 0)) { + set_query_boost(from.query_boost()); + } +} + +void VectorQuery::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.VectorQuery) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void VectorQuery::CopyFrom(const VectorQuery& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.VectorQuery) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool VectorQuery::IsInitialized() const { + return true; +} + +void VectorQuery::InternalSwap(VectorQuery* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + CastToBase(&records_)->InternalSwap(CastToBase(&other->records_)); + CastToBase(&extra_params_)->InternalSwap(CastToBase(&other->extra_params_)); + field_name_.Swap(&other->field_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(topk_, other->topk_); + swap(query_boost_, other->query_boost_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata VectorQuery::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void BooleanQuery::InitAsDefaultInstance() { +} +class BooleanQuery::_Internal { + public: +}; + +BooleanQuery::BooleanQuery() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.BooleanQuery) +} +BooleanQuery::BooleanQuery(const BooleanQuery& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + general_query_(from.general_query_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + occur_ = from.occur_; + // @@protoc_insertion_point(copy_constructor:milvus.grpc.BooleanQuery) +} + +void BooleanQuery::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_BooleanQuery_message_2eproto.base); + occur_ = 0; +} + +BooleanQuery::~BooleanQuery() { + // @@protoc_insertion_point(destructor:milvus.grpc.BooleanQuery) + SharedDtor(); +} + +void BooleanQuery::SharedDtor() { +} + +void BooleanQuery::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const BooleanQuery& BooleanQuery::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_BooleanQuery_message_2eproto.base); + return *internal_default_instance(); +} + + +void BooleanQuery::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.BooleanQuery) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + general_query_.Clear(); + occur_ = 0; + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* BooleanQuery::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // .milvus.grpc.Occur occur = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + set_occur(static_cast<::milvus::grpc::Occur>(val)); + } else goto handle_unusual; + continue; + // repeated .milvus.grpc.GeneralQuery general_query = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(add_general_query(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 18); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool BooleanQuery::MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + // @@protoc_insertion_point(parse_start:milvus.grpc.BooleanQuery) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // .milvus.grpc.Occur occur = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) { + int value = 0; + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + int, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + set_occur(static_cast< ::milvus::grpc::Occur >(value)); + } else { + goto handle_unusual; + } + break; + } + + // repeated .milvus.grpc.GeneralQuery general_query = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, add_general_query())); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:milvus.grpc.BooleanQuery) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.BooleanQuery) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void BooleanQuery::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.BooleanQuery) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.grpc.Occur occur = 1; + if (this->occur() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnum( + 1, this->occur(), output); + } + + // repeated .milvus.grpc.GeneralQuery general_query = 2; + for (unsigned int i = 0, + n = static_cast(this->general_query_size()); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, + this->general_query(static_cast(i)), + output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:milvus.grpc.BooleanQuery) +} + +::PROTOBUF_NAMESPACE_ID::uint8* BooleanQuery::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.BooleanQuery) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.grpc.Occur occur = 1; + if (this->occur() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 1, this->occur(), target); + } + + // repeated .milvus.grpc.GeneralQuery general_query = 2; + for (unsigned int i = 0, + n = static_cast(this->general_query_size()); i < n; i++) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 2, this->general_query(static_cast(i)), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.BooleanQuery) + return target; +} + +size_t BooleanQuery::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.BooleanQuery) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .milvus.grpc.GeneralQuery general_query = 2; + { + unsigned int count = static_cast(this->general_query_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + this->general_query(static_cast(i))); + } + } + + // .milvus.grpc.Occur occur = 1; + if (this->occur() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->occur()); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void BooleanQuery::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.BooleanQuery) + GOOGLE_DCHECK_NE(&from, this); + const BooleanQuery* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.BooleanQuery) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.BooleanQuery) + MergeFrom(*source); + } +} + +void BooleanQuery::MergeFrom(const BooleanQuery& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.BooleanQuery) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + general_query_.MergeFrom(from.general_query_); + if (from.occur() != 0) { + set_occur(from.occur()); + } +} + +void BooleanQuery::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.BooleanQuery) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void BooleanQuery::CopyFrom(const BooleanQuery& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.BooleanQuery) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool BooleanQuery::IsInitialized() const { + return true; +} + +void BooleanQuery::InternalSwap(BooleanQuery* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + CastToBase(&general_query_)->InternalSwap(CastToBase(&other->general_query_)); + swap(occur_, other->occur_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata BooleanQuery::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void GeneralQuery::InitAsDefaultInstance() { + ::milvus::grpc::_GeneralQuery_default_instance_.boolean_query_ = const_cast< ::milvus::grpc::BooleanQuery*>( + ::milvus::grpc::BooleanQuery::internal_default_instance()); + ::milvus::grpc::_GeneralQuery_default_instance_.term_query_ = const_cast< ::milvus::grpc::TermQuery*>( + ::milvus::grpc::TermQuery::internal_default_instance()); + ::milvus::grpc::_GeneralQuery_default_instance_.range_query_ = const_cast< ::milvus::grpc::RangeQuery*>( + ::milvus::grpc::RangeQuery::internal_default_instance()); + ::milvus::grpc::_GeneralQuery_default_instance_.vector_query_ = const_cast< ::milvus::grpc::VectorQuery*>( + ::milvus::grpc::VectorQuery::internal_default_instance()); +} +class GeneralQuery::_Internal { + public: + static const ::milvus::grpc::BooleanQuery& boolean_query(const GeneralQuery* msg); + static const ::milvus::grpc::TermQuery& term_query(const GeneralQuery* msg); + static const ::milvus::grpc::RangeQuery& range_query(const GeneralQuery* msg); + static const ::milvus::grpc::VectorQuery& vector_query(const GeneralQuery* msg); +}; + +const ::milvus::grpc::BooleanQuery& +GeneralQuery::_Internal::boolean_query(const GeneralQuery* msg) { + return *msg->query_.boolean_query_; +} +const ::milvus::grpc::TermQuery& +GeneralQuery::_Internal::term_query(const GeneralQuery* msg) { + return *msg->query_.term_query_; +} +const ::milvus::grpc::RangeQuery& +GeneralQuery::_Internal::range_query(const GeneralQuery* msg) { + return *msg->query_.range_query_; +} +const ::milvus::grpc::VectorQuery& +GeneralQuery::_Internal::vector_query(const GeneralQuery* msg) { + return *msg->query_.vector_query_; +} +void GeneralQuery::set_allocated_boolean_query(::milvus::grpc::BooleanQuery* boolean_query) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + clear_query(); + if (boolean_query) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + boolean_query = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, boolean_query, submessage_arena); + } + set_has_boolean_query(); + query_.boolean_query_ = boolean_query; + } + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.GeneralQuery.boolean_query) +} +void GeneralQuery::set_allocated_term_query(::milvus::grpc::TermQuery* term_query) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + clear_query(); + if (term_query) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + term_query = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, term_query, submessage_arena); + } + set_has_term_query(); + query_.term_query_ = term_query; + } + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.GeneralQuery.term_query) +} +void GeneralQuery::set_allocated_range_query(::milvus::grpc::RangeQuery* range_query) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + clear_query(); + if (range_query) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + range_query = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, range_query, submessage_arena); + } + set_has_range_query(); + query_.range_query_ = range_query; + } + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.GeneralQuery.range_query) +} +void GeneralQuery::set_allocated_vector_query(::milvus::grpc::VectorQuery* vector_query) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + clear_query(); + if (vector_query) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + vector_query = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, vector_query, submessage_arena); + } + set_has_vector_query(); + query_.vector_query_ = vector_query; + } + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.GeneralQuery.vector_query) +} +GeneralQuery::GeneralQuery() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.GeneralQuery) +} +GeneralQuery::GeneralQuery(const GeneralQuery& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + clear_has_query(); + switch (from.query_case()) { + case kBooleanQuery: { + mutable_boolean_query()->::milvus::grpc::BooleanQuery::MergeFrom(from.boolean_query()); + break; + } + case kTermQuery: { + mutable_term_query()->::milvus::grpc::TermQuery::MergeFrom(from.term_query()); + break; + } + case kRangeQuery: { + mutable_range_query()->::milvus::grpc::RangeQuery::MergeFrom(from.range_query()); + break; + } + case kVectorQuery: { + mutable_vector_query()->::milvus::grpc::VectorQuery::MergeFrom(from.vector_query()); + break; + } + case QUERY_NOT_SET: { + break; + } + } + // @@protoc_insertion_point(copy_constructor:milvus.grpc.GeneralQuery) +} + +void GeneralQuery::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_BooleanQuery_message_2eproto.base); + clear_has_query(); +} + +GeneralQuery::~GeneralQuery() { + // @@protoc_insertion_point(destructor:milvus.grpc.GeneralQuery) + SharedDtor(); +} + +void GeneralQuery::SharedDtor() { + if (has_query()) { + clear_query(); + } +} + +void GeneralQuery::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const GeneralQuery& GeneralQuery::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_BooleanQuery_message_2eproto.base); + return *internal_default_instance(); +} + + +void GeneralQuery::clear_query() { +// @@protoc_insertion_point(one_of_clear_start:milvus.grpc.GeneralQuery) + switch (query_case()) { + case kBooleanQuery: { + delete query_.boolean_query_; + break; + } + case kTermQuery: { + delete query_.term_query_; + break; + } + case kRangeQuery: { + delete query_.range_query_; + break; + } + case kVectorQuery: { + delete query_.vector_query_; + break; + } + case QUERY_NOT_SET: { + break; + } + } + _oneof_case_[0] = QUERY_NOT_SET; +} + + +void GeneralQuery::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.GeneralQuery) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + clear_query(); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* GeneralQuery::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // .milvus.grpc.BooleanQuery boolean_query = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(mutable_boolean_query(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .milvus.grpc.TermQuery term_query = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(mutable_term_query(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .milvus.grpc.RangeQuery range_query = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr = ctx->ParseMessage(mutable_range_query(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .milvus.grpc.VectorQuery vector_query = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + ptr = ctx->ParseMessage(mutable_vector_query(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool GeneralQuery::MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + // @@protoc_insertion_point(parse_start:milvus.grpc.GeneralQuery) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // .milvus.grpc.BooleanQuery boolean_query = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, mutable_boolean_query())); + } else { + goto handle_unusual; + } + break; + } + + // .milvus.grpc.TermQuery term_query = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, mutable_term_query())); + } else { + goto handle_unusual; + } + break; + } + + // .milvus.grpc.RangeQuery range_query = 3; + case 3: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, mutable_range_query())); + } else { + goto handle_unusual; + } + break; + } + + // .milvus.grpc.VectorQuery vector_query = 4; + case 4: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (34 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, mutable_vector_query())); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:milvus.grpc.GeneralQuery) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.GeneralQuery) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void GeneralQuery::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.GeneralQuery) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.grpc.BooleanQuery boolean_query = 1; + if (has_boolean_query()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, _Internal::boolean_query(this), output); + } + + // .milvus.grpc.TermQuery term_query = 2; + if (has_term_query()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, _Internal::term_query(this), output); + } + + // .milvus.grpc.RangeQuery range_query = 3; + if (has_range_query()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 3, _Internal::range_query(this), output); + } + + // .milvus.grpc.VectorQuery vector_query = 4; + if (has_vector_query()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 4, _Internal::vector_query(this), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:milvus.grpc.GeneralQuery) +} + +::PROTOBUF_NAMESPACE_ID::uint8* GeneralQuery::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.GeneralQuery) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.grpc.BooleanQuery boolean_query = 1; + if (has_boolean_query()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 1, _Internal::boolean_query(this), target); + } + + // .milvus.grpc.TermQuery term_query = 2; + if (has_term_query()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 2, _Internal::term_query(this), target); + } + + // .milvus.grpc.RangeQuery range_query = 3; + if (has_range_query()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 3, _Internal::range_query(this), target); + } + + // .milvus.grpc.VectorQuery vector_query = 4; + if (has_vector_query()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 4, _Internal::vector_query(this), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.GeneralQuery) + return target; +} + +size_t GeneralQuery::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.GeneralQuery) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + switch (query_case()) { + // .milvus.grpc.BooleanQuery boolean_query = 1; + case kBooleanQuery: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *query_.boolean_query_); + break; + } + // .milvus.grpc.TermQuery term_query = 2; + case kTermQuery: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *query_.term_query_); + break; + } + // .milvus.grpc.RangeQuery range_query = 3; + case kRangeQuery: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *query_.range_query_); + break; + } + // .milvus.grpc.VectorQuery vector_query = 4; + case kVectorQuery: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *query_.vector_query_); + break; + } + case QUERY_NOT_SET: { + break; + } + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void GeneralQuery::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.GeneralQuery) + GOOGLE_DCHECK_NE(&from, this); + const GeneralQuery* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.GeneralQuery) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.GeneralQuery) + MergeFrom(*source); + } +} + +void GeneralQuery::MergeFrom(const GeneralQuery& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.GeneralQuery) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + switch (from.query_case()) { + case kBooleanQuery: { + mutable_boolean_query()->::milvus::grpc::BooleanQuery::MergeFrom(from.boolean_query()); + break; + } + case kTermQuery: { + mutable_term_query()->::milvus::grpc::TermQuery::MergeFrom(from.term_query()); + break; + } + case kRangeQuery: { + mutable_range_query()->::milvus::grpc::RangeQuery::MergeFrom(from.range_query()); + break; + } + case kVectorQuery: { + mutable_vector_query()->::milvus::grpc::VectorQuery::MergeFrom(from.vector_query()); + break; + } + case QUERY_NOT_SET: { + break; + } + } +} + +void GeneralQuery::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.GeneralQuery) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void GeneralQuery::CopyFrom(const GeneralQuery& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.GeneralQuery) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool GeneralQuery::IsInitialized() const { + return true; +} + +void GeneralQuery::InternalSwap(GeneralQuery* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(query_, other->query_); + swap(_oneof_case_[0], other->_oneof_case_[0]); +} + +::PROTOBUF_NAMESPACE_ID::Metadata GeneralQuery::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void SearchParamPB::InitAsDefaultInstance() { + ::milvus::grpc::_SearchParamPB_default_instance_._instance.get_mutable()->general_query_ = const_cast< ::milvus::grpc::GeneralQuery*>( + ::milvus::grpc::GeneralQuery::internal_default_instance()); +} +class SearchParamPB::_Internal { + public: + static const ::milvus::grpc::GeneralQuery& general_query(const SearchParamPB* msg); +}; + +const ::milvus::grpc::GeneralQuery& +SearchParamPB::_Internal::general_query(const SearchParamPB* msg) { + return *msg->general_query_; +} +SearchParamPB::SearchParamPB() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.SearchParamPB) +} +SearchParamPB::SearchParamPB(const SearchParamPB& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + partition_tag_array_(from.partition_tag_array_), + extra_params_(from.extra_params_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.collection_name().empty()) { + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); + } + if (from.has_general_query()) { + general_query_ = new ::milvus::grpc::GeneralQuery(*from.general_query_); + } else { + general_query_ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:milvus.grpc.SearchParamPB) +} + +void SearchParamPB::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_SearchParamPB_message_2eproto.base); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + general_query_ = nullptr; +} + +SearchParamPB::~SearchParamPB() { + // @@protoc_insertion_point(destructor:milvus.grpc.SearchParamPB) + SharedDtor(); +} + +void SearchParamPB::SharedDtor() { + collection_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (this != internal_default_instance()) delete general_query_; +} + +void SearchParamPB::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const SearchParamPB& SearchParamPB::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_SearchParamPB_message_2eproto.base); + return *internal_default_instance(); +} + + +void SearchParamPB::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.SearchParamPB) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + partition_tag_array_.Clear(); + extra_params_.Clear(); + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (GetArenaNoVirtual() == nullptr && general_query_ != nullptr) { + delete general_query_; + } + general_query_ = nullptr; + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* SearchParamPB::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // string collection_name = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_collection_name(), ptr, ctx, "milvus.grpc.SearchParamPB.collection_name"); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated string partition_tag_array = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr -= 1; + do { + ptr += 1; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(add_partition_tag_array(), ptr, ctx, "milvus.grpc.SearchParamPB.partition_tag_array"); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 18); + } else goto handle_unusual; + continue; + // .milvus.grpc.GeneralQuery general_query = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr = ctx->ParseMessage(mutable_general_query(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(add_extra_params(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 34); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool SearchParamPB::MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + // @@protoc_insertion_point(parse_start:milvus.grpc.SearchParamPB) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // string collection_name = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_collection_name())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.SearchParamPB.collection_name")); + } else { + goto handle_unusual; + } + break; + } + + // repeated string partition_tag_array = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->add_partition_tag_array())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->partition_tag_array(this->partition_tag_array_size() - 1).data(), + static_cast(this->partition_tag_array(this->partition_tag_array_size() - 1).length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.SearchParamPB.partition_tag_array")); + } else { + goto handle_unusual; + } + break; + } + + // .milvus.grpc.GeneralQuery general_query = 3; + case 3: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, mutable_general_query())); + } else { + goto handle_unusual; + } + break; + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + case 4: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (34 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, add_extra_params())); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:milvus.grpc.SearchParamPB) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.SearchParamPB) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void SearchParamPB::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.SearchParamPB) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string collection_name = 1; + if (this->collection_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.SearchParamPB.collection_name"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->collection_name(), output); + } + + // repeated string partition_tag_array = 2; + for (int i = 0, n = this->partition_tag_array_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->partition_tag_array(i).data(), static_cast(this->partition_tag_array(i).length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.SearchParamPB.partition_tag_array"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteString( + 2, this->partition_tag_array(i), output); + } + + // .milvus.grpc.GeneralQuery general_query = 3; + if (this->has_general_query()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 3, _Internal::general_query(this), output); + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + for (unsigned int i = 0, + n = static_cast(this->extra_params_size()); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 4, + this->extra_params(static_cast(i)), + output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:milvus.grpc.SearchParamPB) +} + +::PROTOBUF_NAMESPACE_ID::uint8* SearchParamPB::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.SearchParamPB) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string collection_name = 1; + if (this->collection_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.SearchParamPB.collection_name"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 1, this->collection_name(), target); + } + + // repeated string partition_tag_array = 2; + for (int i = 0, n = this->partition_tag_array_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->partition_tag_array(i).data(), static_cast(this->partition_tag_array(i).length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.SearchParamPB.partition_tag_array"); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + WriteStringToArray(2, this->partition_tag_array(i), target); + } + + // .milvus.grpc.GeneralQuery general_query = 3; + if (this->has_general_query()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 3, _Internal::general_query(this), target); + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + for (unsigned int i = 0, + n = static_cast(this->extra_params_size()); i < n; i++) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 4, this->extra_params(static_cast(i)), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.SearchParamPB) + return target; +} + +size_t SearchParamPB::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.SearchParamPB) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated string partition_tag_array = 2; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->partition_tag_array_size()); + for (int i = 0, n = this->partition_tag_array_size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->partition_tag_array(i)); + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + { + unsigned int count = static_cast(this->extra_params_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + this->extra_params(static_cast(i))); + } + } + + // string collection_name = 1; + if (this->collection_name().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->collection_name()); + } + + // .milvus.grpc.GeneralQuery general_query = 3; + if (this->has_general_query()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *general_query_); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void SearchParamPB::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.SearchParamPB) + GOOGLE_DCHECK_NE(&from, this); + const SearchParamPB* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.SearchParamPB) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.SearchParamPB) + MergeFrom(*source); + } +} + +void SearchParamPB::MergeFrom(const SearchParamPB& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.SearchParamPB) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + partition_tag_array_.MergeFrom(from.partition_tag_array_); + extra_params_.MergeFrom(from.extra_params_); + if (from.collection_name().size() > 0) { + + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); + } + if (from.has_general_query()) { + mutable_general_query()->::milvus::grpc::GeneralQuery::MergeFrom(from.general_query()); + } +} + +void SearchParamPB::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.SearchParamPB) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void SearchParamPB::CopyFrom(const SearchParamPB& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.SearchParamPB) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SearchParamPB::IsInitialized() const { + return true; +} + +void SearchParamPB::InternalSwap(SearchParamPB* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + partition_tag_array_.InternalSwap(CastToBase(&other->partition_tag_array_)); + CastToBase(&extra_params_)->InternalSwap(CastToBase(&other->extra_params_)); + collection_name_.Swap(&other->collection_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(general_query_, other->general_query_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SearchParamPB::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void InsertOrDeleteMsg::InitAsDefaultInstance() { + ::milvus::grpc::_InsertOrDeleteMsg_default_instance_._instance.get_mutable()->rows_data_ = const_cast< ::milvus::grpc::RowData*>( + ::milvus::grpc::RowData::internal_default_instance()); +} +class InsertOrDeleteMsg::_Internal { + public: + static const ::milvus::grpc::RowData& rows_data(const InsertOrDeleteMsg* msg); +}; + +const ::milvus::grpc::RowData& +InsertOrDeleteMsg::_Internal::rows_data(const InsertOrDeleteMsg* msg) { + return *msg->rows_data_; +} +InsertOrDeleteMsg::InsertOrDeleteMsg() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.InsertOrDeleteMsg) +} +InsertOrDeleteMsg::InsertOrDeleteMsg(const InsertOrDeleteMsg& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + extra_params_(from.extra_params_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.collection_name().empty()) { + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); + } + partition_tag_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.partition_tag().empty()) { + partition_tag_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.partition_tag_); + } + if (from.has_rows_data()) { + rows_data_ = new ::milvus::grpc::RowData(*from.rows_data_); + } else { + rows_data_ = nullptr; + } + ::memcpy(&uid_, &from.uid_, + static_cast(reinterpret_cast(&op_) - + reinterpret_cast(&uid_)) + sizeof(op_)); + // @@protoc_insertion_point(copy_constructor:milvus.grpc.InsertOrDeleteMsg) +} + +void InsertOrDeleteMsg::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_InsertOrDeleteMsg_message_2eproto.base); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + partition_tag_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + ::memset(&rows_data_, 0, static_cast( + reinterpret_cast(&op_) - + reinterpret_cast(&rows_data_)) + sizeof(op_)); +} + +InsertOrDeleteMsg::~InsertOrDeleteMsg() { + // @@protoc_insertion_point(destructor:milvus.grpc.InsertOrDeleteMsg) + SharedDtor(); +} + +void InsertOrDeleteMsg::SharedDtor() { + collection_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + partition_tag_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (this != internal_default_instance()) delete rows_data_; +} + +void InsertOrDeleteMsg::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const InsertOrDeleteMsg& InsertOrDeleteMsg::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_InsertOrDeleteMsg_message_2eproto.base); + return *internal_default_instance(); +} + + +void InsertOrDeleteMsg::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.InsertOrDeleteMsg) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + extra_params_.Clear(); + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + partition_tag_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (GetArenaNoVirtual() == nullptr && rows_data_ != nullptr) { + delete rows_data_; + } + rows_data_ = nullptr; + ::memset(&uid_, 0, static_cast( + reinterpret_cast(&op_) - + reinterpret_cast(&uid_)) + sizeof(op_)); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* InsertOrDeleteMsg::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // string collection_name = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_collection_name(), ptr, ctx, "milvus.grpc.InsertOrDeleteMsg.collection_name"); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .milvus.grpc.RowData rows_data = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(mutable_rows_data(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // int64 uid = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + uid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // string partition_tag = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_partition_tag(), ptr, ctx, "milvus.grpc.InsertOrDeleteMsg.partition_tag"); + CHK_(ptr); + } else goto handle_unusual; + continue; + // uint64 timestamp = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) { + timestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // int64 segment_id = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 48)) { + segment_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // int64 channel_id = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 56)) { + channel_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .milvus.grpc.OpType op = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 64)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + set_op(static_cast<::milvus::grpc::OpType>(val)); + } else goto handle_unusual; + continue; + // int64 client_id = 9; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 72)) { + client_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated .milvus.grpc.KeyValuePair extra_params = 10; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(add_extra_params(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 82); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool InsertOrDeleteMsg::MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + // @@protoc_insertion_point(parse_start:milvus.grpc.InsertOrDeleteMsg) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // string collection_name = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_collection_name())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.InsertOrDeleteMsg.collection_name")); + } else { + goto handle_unusual; + } + break; + } + + // .milvus.grpc.RowData rows_data = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, mutable_rows_data())); + } else { + goto handle_unusual; + } + break; + } + + // int64 uid = 3; + case 3: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (24 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + input, &uid_))); + } else { + goto handle_unusual; + } + break; + } + + // string partition_tag = 4; + case 4: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (34 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_partition_tag())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->partition_tag().data(), static_cast(this->partition_tag().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.InsertOrDeleteMsg.partition_tag")); + } else { + goto handle_unusual; + } + break; + } + + // uint64 timestamp = 5; + case 5: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (40 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>( + input, ×tamp_))); + } else { + goto handle_unusual; + } + break; + } + + // int64 segment_id = 6; + case 6: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (48 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + input, &segment_id_))); + } else { + goto handle_unusual; + } + break; + } + + // int64 channel_id = 7; + case 7: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (56 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + input, &channel_id_))); + } else { + goto handle_unusual; + } + break; + } + + // .milvus.grpc.OpType op = 8; + case 8: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (64 & 0xFF)) { + int value = 0; + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + int, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + set_op(static_cast< ::milvus::grpc::OpType >(value)); + } else { + goto handle_unusual; + } + break; + } + + // int64 client_id = 9; + case 9: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (72 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + input, &client_id_))); + } else { + goto handle_unusual; + } + break; + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 10; + case 10: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (82 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, add_extra_params())); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:milvus.grpc.InsertOrDeleteMsg) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.InsertOrDeleteMsg) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void InsertOrDeleteMsg::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.InsertOrDeleteMsg) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string collection_name = 1; + if (this->collection_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.InsertOrDeleteMsg.collection_name"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->collection_name(), output); + } + + // .milvus.grpc.RowData rows_data = 2; + if (this->has_rows_data()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, _Internal::rows_data(this), output); + } + + // int64 uid = 3; + if (this->uid() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(3, this->uid(), output); + } + + // string partition_tag = 4; + if (this->partition_tag().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->partition_tag().data(), static_cast(this->partition_tag().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.InsertOrDeleteMsg.partition_tag"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 4, this->partition_tag(), output); + } + + // uint64 timestamp = 5; + if (this->timestamp() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(5, this->timestamp(), output); + } + + // int64 segment_id = 6; + if (this->segment_id() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(6, this->segment_id(), output); + } + + // int64 channel_id = 7; + if (this->channel_id() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(7, this->channel_id(), output); + } + + // .milvus.grpc.OpType op = 8; + if (this->op() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnum( + 8, this->op(), output); + } + + // int64 client_id = 9; + if (this->client_id() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(9, this->client_id(), output); + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 10; + for (unsigned int i = 0, + n = static_cast(this->extra_params_size()); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 10, + this->extra_params(static_cast(i)), + output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:milvus.grpc.InsertOrDeleteMsg) +} + +::PROTOBUF_NAMESPACE_ID::uint8* InsertOrDeleteMsg::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.InsertOrDeleteMsg) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string collection_name = 1; + if (this->collection_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.InsertOrDeleteMsg.collection_name"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 1, this->collection_name(), target); + } + + // .milvus.grpc.RowData rows_data = 2; + if (this->has_rows_data()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 2, _Internal::rows_data(this), target); + } + + // int64 uid = 3; + if (this->uid() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(3, this->uid(), target); + } + + // string partition_tag = 4; + if (this->partition_tag().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->partition_tag().data(), static_cast(this->partition_tag().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.InsertOrDeleteMsg.partition_tag"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 4, this->partition_tag(), target); + } + + // uint64 timestamp = 5; + if (this->timestamp() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(5, this->timestamp(), target); + } + + // int64 segment_id = 6; + if (this->segment_id() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(6, this->segment_id(), target); + } + + // int64 channel_id = 7; + if (this->channel_id() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(7, this->channel_id(), target); + } + + // .milvus.grpc.OpType op = 8; + if (this->op() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 8, this->op(), target); + } + + // int64 client_id = 9; + if (this->client_id() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(9, this->client_id(), target); + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 10; + for (unsigned int i = 0, + n = static_cast(this->extra_params_size()); i < n; i++) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 10, this->extra_params(static_cast(i)), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.InsertOrDeleteMsg) + return target; +} + +size_t InsertOrDeleteMsg::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.InsertOrDeleteMsg) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .milvus.grpc.KeyValuePair extra_params = 10; + { + unsigned int count = static_cast(this->extra_params_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + this->extra_params(static_cast(i))); + } + } + + // string collection_name = 1; + if (this->collection_name().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->collection_name()); + } + + // string partition_tag = 4; + if (this->partition_tag().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->partition_tag()); + } + + // .milvus.grpc.RowData rows_data = 2; + if (this->has_rows_data()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *rows_data_); + } + + // int64 uid = 3; + if (this->uid() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( + this->uid()); + } + + // uint64 timestamp = 5; + if (this->timestamp() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size( + this->timestamp()); + } + + // int64 segment_id = 6; + if (this->segment_id() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( + this->segment_id()); + } + + // int64 channel_id = 7; + if (this->channel_id() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( + this->channel_id()); + } + + // int64 client_id = 9; + if (this->client_id() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( + this->client_id()); + } + + // .milvus.grpc.OpType op = 8; + if (this->op() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->op()); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void InsertOrDeleteMsg::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.InsertOrDeleteMsg) + GOOGLE_DCHECK_NE(&from, this); + const InsertOrDeleteMsg* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.InsertOrDeleteMsg) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.InsertOrDeleteMsg) + MergeFrom(*source); + } +} + +void InsertOrDeleteMsg::MergeFrom(const InsertOrDeleteMsg& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.InsertOrDeleteMsg) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + extra_params_.MergeFrom(from.extra_params_); + if (from.collection_name().size() > 0) { + + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); + } + if (from.partition_tag().size() > 0) { + + partition_tag_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.partition_tag_); + } + if (from.has_rows_data()) { + mutable_rows_data()->::milvus::grpc::RowData::MergeFrom(from.rows_data()); + } + if (from.uid() != 0) { + set_uid(from.uid()); + } + if (from.timestamp() != 0) { + set_timestamp(from.timestamp()); + } + if (from.segment_id() != 0) { + set_segment_id(from.segment_id()); + } + if (from.channel_id() != 0) { + set_channel_id(from.channel_id()); + } + if (from.client_id() != 0) { + set_client_id(from.client_id()); + } + if (from.op() != 0) { + set_op(from.op()); + } +} + +void InsertOrDeleteMsg::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.InsertOrDeleteMsg) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void InsertOrDeleteMsg::CopyFrom(const InsertOrDeleteMsg& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.InsertOrDeleteMsg) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool InsertOrDeleteMsg::IsInitialized() const { + return true; +} + +void InsertOrDeleteMsg::InternalSwap(InsertOrDeleteMsg* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + CastToBase(&extra_params_)->InternalSwap(CastToBase(&other->extra_params_)); + collection_name_.Swap(&other->collection_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + partition_tag_.Swap(&other->partition_tag_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(rows_data_, other->rows_data_); + swap(uid_, other->uid_); + swap(timestamp_, other->timestamp_); + swap(segment_id_, other->segment_id_); + swap(channel_id_, other->channel_id_); + swap(client_id_, other->client_id_); + swap(op_, other->op_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata InsertOrDeleteMsg::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void SearchMsg::InitAsDefaultInstance() { + ::milvus::grpc::_SearchMsg_default_instance_._instance.get_mutable()->records_ = const_cast< ::milvus::grpc::VectorRowRecord*>( + ::milvus::grpc::VectorRowRecord::internal_default_instance()); +} +class SearchMsg::_Internal { + public: + static const ::milvus::grpc::VectorRowRecord& records(const SearchMsg* msg); +}; + +const ::milvus::grpc::VectorRowRecord& +SearchMsg::_Internal::records(const SearchMsg* msg) { + return *msg->records_; +} +SearchMsg::SearchMsg() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.SearchMsg) +} +SearchMsg::SearchMsg(const SearchMsg& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + partition_tag_(from.partition_tag_), + extra_params_(from.extra_params_), + json_(from.json_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.collection_name().empty()) { + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); + } + dsl_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.dsl().empty()) { + dsl_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.dsl_); + } + if (from.has_records()) { + records_ = new ::milvus::grpc::VectorRowRecord(*from.records_); + } else { + records_ = nullptr; + } + ::memcpy(&uid_, &from.uid_, + static_cast(reinterpret_cast(&client_id_) - + reinterpret_cast(&uid_)) + sizeof(client_id_)); + // @@protoc_insertion_point(copy_constructor:milvus.grpc.SearchMsg) +} + +void SearchMsg::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_SearchMsg_message_2eproto.base); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + dsl_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + ::memset(&records_, 0, static_cast( + reinterpret_cast(&client_id_) - + reinterpret_cast(&records_)) + sizeof(client_id_)); +} + +SearchMsg::~SearchMsg() { + // @@protoc_insertion_point(destructor:milvus.grpc.SearchMsg) + SharedDtor(); +} + +void SearchMsg::SharedDtor() { + collection_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + dsl_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (this != internal_default_instance()) delete records_; +} + +void SearchMsg::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const SearchMsg& SearchMsg::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_SearchMsg_message_2eproto.base); + return *internal_default_instance(); +} + + +void SearchMsg::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.SearchMsg) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + partition_tag_.Clear(); + extra_params_.Clear(); + json_.Clear(); + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + dsl_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (GetArenaNoVirtual() == nullptr && records_ != nullptr) { + delete records_; + } + records_ = nullptr; + ::memset(&uid_, 0, static_cast( + reinterpret_cast(&client_id_) - + reinterpret_cast(&uid_)) + sizeof(client_id_)); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* SearchMsg::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // string collection_name = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_collection_name(), ptr, ctx, "milvus.grpc.SearchMsg.collection_name"); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .milvus.grpc.VectorRowRecord records = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(mutable_records(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated string partition_tag = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr -= 1; + do { + ptr += 1; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(add_partition_tag(), ptr, ctx, "milvus.grpc.SearchMsg.partition_tag"); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 26); + } else goto handle_unusual; + continue; + // int64 uid = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) { + uid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // uint64 timestamp = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) { + timestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // int64 client_id = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 48)) { + client_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated .milvus.grpc.KeyValuePair extra_params = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(add_extra_params(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 58); + } else goto handle_unusual; + continue; + // repeated string json = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66)) { + ptr -= 1; + do { + ptr += 1; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(add_json(), ptr, ctx, "milvus.grpc.SearchMsg.json"); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 66); + } else goto handle_unusual; + continue; + // string dsl = 9; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 74)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_dsl(), ptr, ctx, "milvus.grpc.SearchMsg.dsl"); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool SearchMsg::MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + // @@protoc_insertion_point(parse_start:milvus.grpc.SearchMsg) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // string collection_name = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_collection_name())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.SearchMsg.collection_name")); + } else { + goto handle_unusual; + } + break; + } + + // .milvus.grpc.VectorRowRecord records = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, mutable_records())); + } else { + goto handle_unusual; + } + break; + } + + // repeated string partition_tag = 3; + case 3: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->add_partition_tag())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->partition_tag(this->partition_tag_size() - 1).data(), + static_cast(this->partition_tag(this->partition_tag_size() - 1).length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.SearchMsg.partition_tag")); + } else { + goto handle_unusual; + } + break; + } + + // int64 uid = 4; + case 4: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (32 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + input, &uid_))); + } else { + goto handle_unusual; + } + break; + } + + // uint64 timestamp = 5; + case 5: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (40 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>( + input, ×tamp_))); + } else { + goto handle_unusual; + } + break; + } + + // int64 client_id = 6; + case 6: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (48 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + input, &client_id_))); + } else { + goto handle_unusual; + } + break; + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 7; + case 7: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (58 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, add_extra_params())); + } else { + goto handle_unusual; + } + break; + } + + // repeated string json = 8; + case 8: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (66 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->add_json())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->json(this->json_size() - 1).data(), + static_cast(this->json(this->json_size() - 1).length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.SearchMsg.json")); + } else { + goto handle_unusual; + } + break; + } + + // string dsl = 9; + case 9: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (74 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_dsl())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->dsl().data(), static_cast(this->dsl().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.SearchMsg.dsl")); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:milvus.grpc.SearchMsg) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.SearchMsg) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void SearchMsg::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.SearchMsg) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string collection_name = 1; + if (this->collection_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.SearchMsg.collection_name"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->collection_name(), output); + } + + // .milvus.grpc.VectorRowRecord records = 2; + if (this->has_records()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, _Internal::records(this), output); + } + + // repeated string partition_tag = 3; + for (int i = 0, n = this->partition_tag_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->partition_tag(i).data(), static_cast(this->partition_tag(i).length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.SearchMsg.partition_tag"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteString( + 3, this->partition_tag(i), output); + } + + // int64 uid = 4; + if (this->uid() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(4, this->uid(), output); + } + + // uint64 timestamp = 5; + if (this->timestamp() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(5, this->timestamp(), output); + } + + // int64 client_id = 6; + if (this->client_id() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(6, this->client_id(), output); + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 7; + for (unsigned int i = 0, + n = static_cast(this->extra_params_size()); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 7, + this->extra_params(static_cast(i)), + output); + } + + // repeated string json = 8; + for (int i = 0, n = this->json_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->json(i).data(), static_cast(this->json(i).length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.SearchMsg.json"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteString( + 8, this->json(i), output); + } + + // string dsl = 9; + if (this->dsl().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->dsl().data(), static_cast(this->dsl().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.SearchMsg.dsl"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 9, this->dsl(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:milvus.grpc.SearchMsg) +} + +::PROTOBUF_NAMESPACE_ID::uint8* SearchMsg::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.SearchMsg) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string collection_name = 1; + if (this->collection_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.SearchMsg.collection_name"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 1, this->collection_name(), target); + } + + // .milvus.grpc.VectorRowRecord records = 2; + if (this->has_records()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 2, _Internal::records(this), target); + } + + // repeated string partition_tag = 3; + for (int i = 0, n = this->partition_tag_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->partition_tag(i).data(), static_cast(this->partition_tag(i).length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.SearchMsg.partition_tag"); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + WriteStringToArray(3, this->partition_tag(i), target); + } + + // int64 uid = 4; + if (this->uid() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(4, this->uid(), target); + } + + // uint64 timestamp = 5; + if (this->timestamp() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(5, this->timestamp(), target); + } + + // int64 client_id = 6; + if (this->client_id() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(6, this->client_id(), target); + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 7; + for (unsigned int i = 0, + n = static_cast(this->extra_params_size()); i < n; i++) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 7, this->extra_params(static_cast(i)), target); + } + + // repeated string json = 8; + for (int i = 0, n = this->json_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->json(i).data(), static_cast(this->json(i).length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.SearchMsg.json"); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + WriteStringToArray(8, this->json(i), target); + } + + // string dsl = 9; + if (this->dsl().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->dsl().data(), static_cast(this->dsl().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.SearchMsg.dsl"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 9, this->dsl(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.SearchMsg) + return target; +} + +size_t SearchMsg::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.SearchMsg) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated string partition_tag = 3; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->partition_tag_size()); + for (int i = 0, n = this->partition_tag_size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->partition_tag(i)); + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 7; + { + unsigned int count = static_cast(this->extra_params_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + this->extra_params(static_cast(i))); + } + } + + // repeated string json = 8; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->json_size()); + for (int i = 0, n = this->json_size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->json(i)); + } + + // string collection_name = 1; + if (this->collection_name().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->collection_name()); + } + + // string dsl = 9; + if (this->dsl().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->dsl()); + } + + // .milvus.grpc.VectorRowRecord records = 2; + if (this->has_records()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *records_); + } + + // int64 uid = 4; + if (this->uid() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( + this->uid()); + } + + // uint64 timestamp = 5; + if (this->timestamp() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size( + this->timestamp()); + } + + // int64 client_id = 6; + if (this->client_id() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( + this->client_id()); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void SearchMsg::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.SearchMsg) + GOOGLE_DCHECK_NE(&from, this); + const SearchMsg* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.SearchMsg) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.SearchMsg) + MergeFrom(*source); + } +} + +void SearchMsg::MergeFrom(const SearchMsg& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.SearchMsg) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + partition_tag_.MergeFrom(from.partition_tag_); + extra_params_.MergeFrom(from.extra_params_); + json_.MergeFrom(from.json_); + if (from.collection_name().size() > 0) { + + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); + } + if (from.dsl().size() > 0) { + + dsl_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.dsl_); + } + if (from.has_records()) { + mutable_records()->::milvus::grpc::VectorRowRecord::MergeFrom(from.records()); + } + if (from.uid() != 0) { + set_uid(from.uid()); + } + if (from.timestamp() != 0) { + set_timestamp(from.timestamp()); + } + if (from.client_id() != 0) { + set_client_id(from.client_id()); + } +} + +void SearchMsg::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.SearchMsg) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void SearchMsg::CopyFrom(const SearchMsg& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.SearchMsg) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SearchMsg::IsInitialized() const { + return true; +} + +void SearchMsg::InternalSwap(SearchMsg* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + partition_tag_.InternalSwap(CastToBase(&other->partition_tag_)); + CastToBase(&extra_params_)->InternalSwap(CastToBase(&other->extra_params_)); + json_.InternalSwap(CastToBase(&other->json_)); + collection_name_.Swap(&other->collection_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + dsl_.Swap(&other->dsl_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(records_, other->records_); + swap(uid_, other->uid_); + swap(timestamp_, other->timestamp_); + swap(client_id_, other->client_id_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SearchMsg::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void TimeSyncMsg::InitAsDefaultInstance() { +} +class TimeSyncMsg::_Internal { + public: +}; + +TimeSyncMsg::TimeSyncMsg() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.TimeSyncMsg) +} +TimeSyncMsg::TimeSyncMsg(const TimeSyncMsg& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::memcpy(&peer_id_, &from.peer_id_, + static_cast(reinterpret_cast(&sync_type_) - + reinterpret_cast(&peer_id_)) + sizeof(sync_type_)); + // @@protoc_insertion_point(copy_constructor:milvus.grpc.TimeSyncMsg) +} + +void TimeSyncMsg::SharedCtor() { + ::memset(&peer_id_, 0, static_cast( + reinterpret_cast(&sync_type_) - + reinterpret_cast(&peer_id_)) + sizeof(sync_type_)); +} + +TimeSyncMsg::~TimeSyncMsg() { + // @@protoc_insertion_point(destructor:milvus.grpc.TimeSyncMsg) + SharedDtor(); +} + +void TimeSyncMsg::SharedDtor() { +} + +void TimeSyncMsg::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const TimeSyncMsg& TimeSyncMsg::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_TimeSyncMsg_message_2eproto.base); + return *internal_default_instance(); +} + + +void TimeSyncMsg::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.TimeSyncMsg) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + ::memset(&peer_id_, 0, static_cast( + reinterpret_cast(&sync_type_) - + reinterpret_cast(&peer_id_)) + sizeof(sync_type_)); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* TimeSyncMsg::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // int64 peer_Id = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + peer_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // uint64 Timestamp = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + timestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .milvus.grpc.SyncType sync_type = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + set_sync_type(static_cast<::milvus::grpc::SyncType>(val)); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool TimeSyncMsg::MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + // @@protoc_insertion_point(parse_start:milvus.grpc.TimeSyncMsg) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // int64 peer_Id = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + input, &peer_id_))); + } else { + goto handle_unusual; + } + break; + } + + // uint64 Timestamp = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>( + input, ×tamp_))); + } else { + goto handle_unusual; + } + break; + } + + // .milvus.grpc.SyncType sync_type = 3; + case 3: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (24 & 0xFF)) { + int value = 0; + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + int, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + set_sync_type(static_cast< ::milvus::grpc::SyncType >(value)); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:milvus.grpc.TimeSyncMsg) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.TimeSyncMsg) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void TimeSyncMsg::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.TimeSyncMsg) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // int64 peer_Id = 1; + if (this->peer_id() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(1, this->peer_id(), output); + } + + // uint64 Timestamp = 2; + if (this->timestamp() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(2, this->timestamp(), output); + } + + // .milvus.grpc.SyncType sync_type = 3; + if (this->sync_type() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnum( + 3, this->sync_type(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:milvus.grpc.TimeSyncMsg) +} + +::PROTOBUF_NAMESPACE_ID::uint8* TimeSyncMsg::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.TimeSyncMsg) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // int64 peer_Id = 1; + if (this->peer_id() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(1, this->peer_id(), target); + } + + // uint64 Timestamp = 2; + if (this->timestamp() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(2, this->timestamp(), target); + } + + // .milvus.grpc.SyncType sync_type = 3; + if (this->sync_type() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 3, this->sync_type(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.TimeSyncMsg) + return target; +} + +size_t TimeSyncMsg::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.TimeSyncMsg) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // int64 peer_Id = 1; + if (this->peer_id() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( + this->peer_id()); + } + + // uint64 Timestamp = 2; + if (this->timestamp() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size( + this->timestamp()); + } + + // .milvus.grpc.SyncType sync_type = 3; + if (this->sync_type() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->sync_type()); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void TimeSyncMsg::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.TimeSyncMsg) + GOOGLE_DCHECK_NE(&from, this); + const TimeSyncMsg* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.TimeSyncMsg) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.TimeSyncMsg) + MergeFrom(*source); + } +} + +void TimeSyncMsg::MergeFrom(const TimeSyncMsg& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.TimeSyncMsg) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.peer_id() != 0) { + set_peer_id(from.peer_id()); + } + if (from.timestamp() != 0) { + set_timestamp(from.timestamp()); + } + if (from.sync_type() != 0) { + set_sync_type(from.sync_type()); + } +} + +void TimeSyncMsg::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.TimeSyncMsg) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void TimeSyncMsg::CopyFrom(const TimeSyncMsg& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.TimeSyncMsg) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool TimeSyncMsg::IsInitialized() const { + return true; +} + +void TimeSyncMsg::InternalSwap(TimeSyncMsg* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(peer_id_, other->peer_id_); + swap(timestamp_, other->timestamp_); + swap(sync_type_, other->sync_type_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata TimeSyncMsg::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void Key2SegMsg::InitAsDefaultInstance() { +} +class Key2SegMsg::_Internal { + public: +}; + +Key2SegMsg::Key2SegMsg() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.Key2SegMsg) +} +Key2SegMsg::Key2SegMsg(const Key2SegMsg& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + segment_id_(from.segment_id_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::memcpy(&uid_, &from.uid_, + static_cast(reinterpret_cast(×tamp_) - + reinterpret_cast(&uid_)) + sizeof(timestamp_)); + // @@protoc_insertion_point(copy_constructor:milvus.grpc.Key2SegMsg) +} + +void Key2SegMsg::SharedCtor() { + ::memset(&uid_, 0, static_cast( + reinterpret_cast(×tamp_) - + reinterpret_cast(&uid_)) + sizeof(timestamp_)); +} + +Key2SegMsg::~Key2SegMsg() { + // @@protoc_insertion_point(destructor:milvus.grpc.Key2SegMsg) + SharedDtor(); +} + +void Key2SegMsg::SharedDtor() { +} + +void Key2SegMsg::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const Key2SegMsg& Key2SegMsg::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_Key2SegMsg_message_2eproto.base); + return *internal_default_instance(); +} + + +void Key2SegMsg::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.Key2SegMsg) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + segment_id_.Clear(); + ::memset(&uid_, 0, static_cast( + reinterpret_cast(×tamp_) - + reinterpret_cast(&uid_)) + sizeof(timestamp_)); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* Key2SegMsg::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // int64 uid = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + uid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // uint64 timestamp = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + timestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated int64 segment_id = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt64Parser(mutable_segment_id(), ptr, ctx); + CHK_(ptr); + } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24) { + add_segment_id(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr)); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool Key2SegMsg::MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + // @@protoc_insertion_point(parse_start:milvus.grpc.Key2SegMsg) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // int64 uid = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + input, &uid_))); + } else { + goto handle_unusual; + } + break; + } + + // uint64 timestamp = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>( + input, ×tamp_))); + } else { + goto handle_unusual; + } + break; + } + + // repeated int64 segment_id = 3; + case 3: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) { + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPackedPrimitive< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + input, this->mutable_segment_id()))); + } else if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (24 & 0xFF)) { + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + 1, 26u, input, this->mutable_segment_id()))); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:milvus.grpc.Key2SegMsg) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.Key2SegMsg) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void Key2SegMsg::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.Key2SegMsg) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // int64 uid = 1; + if (this->uid() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(1, this->uid(), output); + } + + // uint64 timestamp = 2; + if (this->timestamp() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(2, this->timestamp(), output); + } + + // repeated int64 segment_id = 3; + if (this->segment_id_size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTag(3, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(_segment_id_cached_byte_size_.load( + std::memory_order_relaxed)); + } + for (int i = 0, n = this->segment_id_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64NoTag( + this->segment_id(i), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:milvus.grpc.Key2SegMsg) +} + +::PROTOBUF_NAMESPACE_ID::uint8* Key2SegMsg::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.Key2SegMsg) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // int64 uid = 1; + if (this->uid() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(1, this->uid(), target); + } + + // uint64 timestamp = 2; + if (this->timestamp() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(2, this->timestamp(), target); + } + + // repeated int64 segment_id = 3; + if (this->segment_id_size() > 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTagToArray( + 3, + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + target); + target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray( + _segment_id_cached_byte_size_.load(std::memory_order_relaxed), + target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + WriteInt64NoTagToArray(this->segment_id_, target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.Key2SegMsg) + return target; +} + +size_t Key2SegMsg::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.Key2SegMsg) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated int64 segment_id = 3; + { + size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + Int64Size(this->segment_id_); + if (data_size > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size)); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size); + _segment_id_cached_byte_size_.store(cached_size, + std::memory_order_relaxed); + total_size += data_size; + } + + // int64 uid = 1; + if (this->uid() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( + this->uid()); + } + + // uint64 timestamp = 2; + if (this->timestamp() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size( + this->timestamp()); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Key2SegMsg::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.Key2SegMsg) + GOOGLE_DCHECK_NE(&from, this); + const Key2SegMsg* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.Key2SegMsg) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.Key2SegMsg) + MergeFrom(*source); + } +} + +void Key2SegMsg::MergeFrom(const Key2SegMsg& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.Key2SegMsg) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + segment_id_.MergeFrom(from.segment_id_); + if (from.uid() != 0) { + set_uid(from.uid()); + } + if (from.timestamp() != 0) { + set_timestamp(from.timestamp()); + } +} + +void Key2SegMsg::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.Key2SegMsg) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Key2SegMsg::CopyFrom(const Key2SegMsg& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.Key2SegMsg) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Key2SegMsg::IsInitialized() const { + return true; +} + +void Key2SegMsg::InternalSwap(Key2SegMsg* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + segment_id_.InternalSwap(&other->segment_id_); + swap(uid_, other->uid_); + swap(timestamp_, other->timestamp_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Key2SegMsg::GetMetadata() const { + return GetMetadataStatic(); +} + + +// @@protoc_insertion_point(namespace_scope) +} // namespace grpc +} // namespace milvus +PROTOBUF_NAMESPACE_OPEN +template<> PROTOBUF_NOINLINE ::milvus::grpc::Status* Arena::CreateMaybeMessage< ::milvus::grpc::Status >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::Status >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::KeyValuePair* Arena::CreateMaybeMessage< ::milvus::grpc::KeyValuePair >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::KeyValuePair >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::CollectionName* Arena::CreateMaybeMessage< ::milvus::grpc::CollectionName >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::CollectionName >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::CollectionNameList* Arena::CreateMaybeMessage< ::milvus::grpc::CollectionNameList >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::CollectionNameList >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::FieldName* Arena::CreateMaybeMessage< ::milvus::grpc::FieldName >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::FieldName >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::Mapping* Arena::CreateMaybeMessage< ::milvus::grpc::Mapping >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::Mapping >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::MappingList* Arena::CreateMaybeMessage< ::milvus::grpc::MappingList >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::MappingList >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::PartitionParam* Arena::CreateMaybeMessage< ::milvus::grpc::PartitionParam >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::PartitionParam >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::PartitionList* Arena::CreateMaybeMessage< ::milvus::grpc::PartitionList >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::PartitionList >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::VectorRowRecord* Arena::CreateMaybeMessage< ::milvus::grpc::VectorRowRecord >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::VectorRowRecord >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::EntityIds* Arena::CreateMaybeMessage< ::milvus::grpc::EntityIds >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::EntityIds >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::VectorRecord* Arena::CreateMaybeMessage< ::milvus::grpc::VectorRecord >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::VectorRecord >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::VectorParam* Arena::CreateMaybeMessage< ::milvus::grpc::VectorParam >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::VectorParam >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::FieldMeta* Arena::CreateMaybeMessage< ::milvus::grpc::FieldMeta >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::FieldMeta >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::Schema* Arena::CreateMaybeMessage< ::milvus::grpc::Schema >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::Schema >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::RowData* Arena::CreateMaybeMessage< ::milvus::grpc::RowData >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::RowData >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::InsertParam* Arena::CreateMaybeMessage< ::milvus::grpc::InsertParam >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::InsertParam >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::SearchParam* Arena::CreateMaybeMessage< ::milvus::grpc::SearchParam >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::SearchParam >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::SearchInSegmentParam* Arena::CreateMaybeMessage< ::milvus::grpc::SearchInSegmentParam >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::SearchInSegmentParam >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::Entities* Arena::CreateMaybeMessage< ::milvus::grpc::Entities >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::Entities >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::QueryResult* Arena::CreateMaybeMessage< ::milvus::grpc::QueryResult >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::QueryResult >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::StringReply* Arena::CreateMaybeMessage< ::milvus::grpc::StringReply >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::StringReply >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::BoolReply* Arena::CreateMaybeMessage< ::milvus::grpc::BoolReply >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::BoolReply >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::CollectionRowCount* Arena::CreateMaybeMessage< ::milvus::grpc::CollectionRowCount >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::CollectionRowCount >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::Command* Arena::CreateMaybeMessage< ::milvus::grpc::Command >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::Command >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::IndexParam* Arena::CreateMaybeMessage< ::milvus::grpc::IndexParam >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::IndexParam >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::FlushParam* Arena::CreateMaybeMessage< ::milvus::grpc::FlushParam >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::FlushParam >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::CompactParam* Arena::CreateMaybeMessage< ::milvus::grpc::CompactParam >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::CompactParam >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::DeleteByIDParam* Arena::CreateMaybeMessage< ::milvus::grpc::DeleteByIDParam >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::DeleteByIDParam >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::CollectionInfo* Arena::CreateMaybeMessage< ::milvus::grpc::CollectionInfo >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::CollectionInfo >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::GetEntityIDsParam* Arena::CreateMaybeMessage< ::milvus::grpc::GetEntityIDsParam >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::GetEntityIDsParam >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::EntityIdentity* Arena::CreateMaybeMessage< ::milvus::grpc::EntityIdentity >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::EntityIdentity >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::VectorFieldParam* Arena::CreateMaybeMessage< ::milvus::grpc::VectorFieldParam >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::VectorFieldParam >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::FieldType* Arena::CreateMaybeMessage< ::milvus::grpc::FieldType >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::FieldType >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::FieldParam* Arena::CreateMaybeMessage< ::milvus::grpc::FieldParam >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::FieldParam >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::VectorFieldRecord* Arena::CreateMaybeMessage< ::milvus::grpc::VectorFieldRecord >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::VectorFieldRecord >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::TermQuery* Arena::CreateMaybeMessage< ::milvus::grpc::TermQuery >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::TermQuery >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::CompareExpr* Arena::CreateMaybeMessage< ::milvus::grpc::CompareExpr >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::CompareExpr >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::RangeQuery* Arena::CreateMaybeMessage< ::milvus::grpc::RangeQuery >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::RangeQuery >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::VectorQuery* Arena::CreateMaybeMessage< ::milvus::grpc::VectorQuery >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::VectorQuery >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::BooleanQuery* Arena::CreateMaybeMessage< ::milvus::grpc::BooleanQuery >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::BooleanQuery >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::GeneralQuery* Arena::CreateMaybeMessage< ::milvus::grpc::GeneralQuery >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::GeneralQuery >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::SearchParamPB* Arena::CreateMaybeMessage< ::milvus::grpc::SearchParamPB >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::SearchParamPB >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::InsertOrDeleteMsg* Arena::CreateMaybeMessage< ::milvus::grpc::InsertOrDeleteMsg >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::InsertOrDeleteMsg >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::SearchMsg* Arena::CreateMaybeMessage< ::milvus::grpc::SearchMsg >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::SearchMsg >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::TimeSyncMsg* Arena::CreateMaybeMessage< ::milvus::grpc::TimeSyncMsg >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::TimeSyncMsg >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::Key2SegMsg* Arena::CreateMaybeMessage< ::milvus::grpc::Key2SegMsg >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::Key2SegMsg >(arena); +} +PROTOBUF_NAMESPACE_CLOSE + +// @@protoc_insertion_point(global_scope) +#include diff --git a/core/src/pb/message.pb.h b/core/src/pb/message.pb.h new file mode 100644 index 0000000000..bbe90573a1 --- /dev/null +++ b/core/src/pb/message.pb.h @@ -0,0 +1,13531 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: message.proto + +#ifndef GOOGLE_PROTOBUF_INCLUDED_message_2eproto +#define GOOGLE_PROTOBUF_INCLUDED_message_2eproto + +#include +#include + +#include +#if PROTOBUF_VERSION < 3009000 +#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 3009000 < 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include // IWYU pragma: export +#include // IWYU pragma: export +#include +#include +// @@protoc_insertion_point(includes) +#include +#define PROTOBUF_INTERNAL_EXPORT_message_2eproto +PROTOBUF_NAMESPACE_OPEN +namespace internal { +class AnyMetadata; +} // namespace internal +PROTOBUF_NAMESPACE_CLOSE + +// Internal implementation detail -- do not use these members. +struct TableStruct_message_2eproto { + static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[] + PROTOBUF_SECTION_VARIABLE(protodesc_cold); + static const ::PROTOBUF_NAMESPACE_ID::internal::AuxillaryParseTableField aux[] + PROTOBUF_SECTION_VARIABLE(protodesc_cold); + static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[47] + PROTOBUF_SECTION_VARIABLE(protodesc_cold); + static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[]; + static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[]; + static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[]; +}; +extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_message_2eproto; +namespace milvus { +namespace grpc { +class BoolReply; +class BoolReplyDefaultTypeInternal; +extern BoolReplyDefaultTypeInternal _BoolReply_default_instance_; +class BooleanQuery; +class BooleanQueryDefaultTypeInternal; +extern BooleanQueryDefaultTypeInternal _BooleanQuery_default_instance_; +class CollectionInfo; +class CollectionInfoDefaultTypeInternal; +extern CollectionInfoDefaultTypeInternal _CollectionInfo_default_instance_; +class CollectionName; +class CollectionNameDefaultTypeInternal; +extern CollectionNameDefaultTypeInternal _CollectionName_default_instance_; +class CollectionNameList; +class CollectionNameListDefaultTypeInternal; +extern CollectionNameListDefaultTypeInternal _CollectionNameList_default_instance_; +class CollectionRowCount; +class CollectionRowCountDefaultTypeInternal; +extern CollectionRowCountDefaultTypeInternal _CollectionRowCount_default_instance_; +class Command; +class CommandDefaultTypeInternal; +extern CommandDefaultTypeInternal _Command_default_instance_; +class CompactParam; +class CompactParamDefaultTypeInternal; +extern CompactParamDefaultTypeInternal _CompactParam_default_instance_; +class CompareExpr; +class CompareExprDefaultTypeInternal; +extern CompareExprDefaultTypeInternal _CompareExpr_default_instance_; +class DeleteByIDParam; +class DeleteByIDParamDefaultTypeInternal; +extern DeleteByIDParamDefaultTypeInternal _DeleteByIDParam_default_instance_; +class Entities; +class EntitiesDefaultTypeInternal; +extern EntitiesDefaultTypeInternal _Entities_default_instance_; +class EntityIdentity; +class EntityIdentityDefaultTypeInternal; +extern EntityIdentityDefaultTypeInternal _EntityIdentity_default_instance_; +class EntityIds; +class EntityIdsDefaultTypeInternal; +extern EntityIdsDefaultTypeInternal _EntityIds_default_instance_; +class FieldMeta; +class FieldMetaDefaultTypeInternal; +extern FieldMetaDefaultTypeInternal _FieldMeta_default_instance_; +class FieldName; +class FieldNameDefaultTypeInternal; +extern FieldNameDefaultTypeInternal _FieldName_default_instance_; +class FieldParam; +class FieldParamDefaultTypeInternal; +extern FieldParamDefaultTypeInternal _FieldParam_default_instance_; +class FieldType; +class FieldTypeDefaultTypeInternal; +extern FieldTypeDefaultTypeInternal _FieldType_default_instance_; +class FlushParam; +class FlushParamDefaultTypeInternal; +extern FlushParamDefaultTypeInternal _FlushParam_default_instance_; +class GeneralQuery; +class GeneralQueryDefaultTypeInternal; +extern GeneralQueryDefaultTypeInternal _GeneralQuery_default_instance_; +class GetEntityIDsParam; +class GetEntityIDsParamDefaultTypeInternal; +extern GetEntityIDsParamDefaultTypeInternal _GetEntityIDsParam_default_instance_; +class IndexParam; +class IndexParamDefaultTypeInternal; +extern IndexParamDefaultTypeInternal _IndexParam_default_instance_; +class InsertOrDeleteMsg; +class InsertOrDeleteMsgDefaultTypeInternal; +extern InsertOrDeleteMsgDefaultTypeInternal _InsertOrDeleteMsg_default_instance_; +class InsertParam; +class InsertParamDefaultTypeInternal; +extern InsertParamDefaultTypeInternal _InsertParam_default_instance_; +class Key2SegMsg; +class Key2SegMsgDefaultTypeInternal; +extern Key2SegMsgDefaultTypeInternal _Key2SegMsg_default_instance_; +class KeyValuePair; +class KeyValuePairDefaultTypeInternal; +extern KeyValuePairDefaultTypeInternal _KeyValuePair_default_instance_; +class Mapping; +class MappingDefaultTypeInternal; +extern MappingDefaultTypeInternal _Mapping_default_instance_; +class MappingList; +class MappingListDefaultTypeInternal; +extern MappingListDefaultTypeInternal _MappingList_default_instance_; +class PartitionList; +class PartitionListDefaultTypeInternal; +extern PartitionListDefaultTypeInternal _PartitionList_default_instance_; +class PartitionParam; +class PartitionParamDefaultTypeInternal; +extern PartitionParamDefaultTypeInternal _PartitionParam_default_instance_; +class QueryResult; +class QueryResultDefaultTypeInternal; +extern QueryResultDefaultTypeInternal _QueryResult_default_instance_; +class RangeQuery; +class RangeQueryDefaultTypeInternal; +extern RangeQueryDefaultTypeInternal _RangeQuery_default_instance_; +class RowData; +class RowDataDefaultTypeInternal; +extern RowDataDefaultTypeInternal _RowData_default_instance_; +class Schema; +class SchemaDefaultTypeInternal; +extern SchemaDefaultTypeInternal _Schema_default_instance_; +class SearchInSegmentParam; +class SearchInSegmentParamDefaultTypeInternal; +extern SearchInSegmentParamDefaultTypeInternal _SearchInSegmentParam_default_instance_; +class SearchMsg; +class SearchMsgDefaultTypeInternal; +extern SearchMsgDefaultTypeInternal _SearchMsg_default_instance_; +class SearchParam; +class SearchParamDefaultTypeInternal; +extern SearchParamDefaultTypeInternal _SearchParam_default_instance_; +class SearchParamPB; +class SearchParamPBDefaultTypeInternal; +extern SearchParamPBDefaultTypeInternal _SearchParamPB_default_instance_; +class Status; +class StatusDefaultTypeInternal; +extern StatusDefaultTypeInternal _Status_default_instance_; +class StringReply; +class StringReplyDefaultTypeInternal; +extern StringReplyDefaultTypeInternal _StringReply_default_instance_; +class TermQuery; +class TermQueryDefaultTypeInternal; +extern TermQueryDefaultTypeInternal _TermQuery_default_instance_; +class TimeSyncMsg; +class TimeSyncMsgDefaultTypeInternal; +extern TimeSyncMsgDefaultTypeInternal _TimeSyncMsg_default_instance_; +class VectorFieldParam; +class VectorFieldParamDefaultTypeInternal; +extern VectorFieldParamDefaultTypeInternal _VectorFieldParam_default_instance_; +class VectorFieldRecord; +class VectorFieldRecordDefaultTypeInternal; +extern VectorFieldRecordDefaultTypeInternal _VectorFieldRecord_default_instance_; +class VectorParam; +class VectorParamDefaultTypeInternal; +extern VectorParamDefaultTypeInternal _VectorParam_default_instance_; +class VectorQuery; +class VectorQueryDefaultTypeInternal; +extern VectorQueryDefaultTypeInternal _VectorQuery_default_instance_; +class VectorRecord; +class VectorRecordDefaultTypeInternal; +extern VectorRecordDefaultTypeInternal _VectorRecord_default_instance_; +class VectorRowRecord; +class VectorRowRecordDefaultTypeInternal; +extern VectorRowRecordDefaultTypeInternal _VectorRowRecord_default_instance_; +} // namespace grpc +} // namespace milvus +PROTOBUF_NAMESPACE_OPEN +template<> ::milvus::grpc::BoolReply* Arena::CreateMaybeMessage<::milvus::grpc::BoolReply>(Arena*); +template<> ::milvus::grpc::BooleanQuery* Arena::CreateMaybeMessage<::milvus::grpc::BooleanQuery>(Arena*); +template<> ::milvus::grpc::CollectionInfo* Arena::CreateMaybeMessage<::milvus::grpc::CollectionInfo>(Arena*); +template<> ::milvus::grpc::CollectionName* Arena::CreateMaybeMessage<::milvus::grpc::CollectionName>(Arena*); +template<> ::milvus::grpc::CollectionNameList* Arena::CreateMaybeMessage<::milvus::grpc::CollectionNameList>(Arena*); +template<> ::milvus::grpc::CollectionRowCount* Arena::CreateMaybeMessage<::milvus::grpc::CollectionRowCount>(Arena*); +template<> ::milvus::grpc::Command* Arena::CreateMaybeMessage<::milvus::grpc::Command>(Arena*); +template<> ::milvus::grpc::CompactParam* Arena::CreateMaybeMessage<::milvus::grpc::CompactParam>(Arena*); +template<> ::milvus::grpc::CompareExpr* Arena::CreateMaybeMessage<::milvus::grpc::CompareExpr>(Arena*); +template<> ::milvus::grpc::DeleteByIDParam* Arena::CreateMaybeMessage<::milvus::grpc::DeleteByIDParam>(Arena*); +template<> ::milvus::grpc::Entities* Arena::CreateMaybeMessage<::milvus::grpc::Entities>(Arena*); +template<> ::milvus::grpc::EntityIdentity* Arena::CreateMaybeMessage<::milvus::grpc::EntityIdentity>(Arena*); +template<> ::milvus::grpc::EntityIds* Arena::CreateMaybeMessage<::milvus::grpc::EntityIds>(Arena*); +template<> ::milvus::grpc::FieldMeta* Arena::CreateMaybeMessage<::milvus::grpc::FieldMeta>(Arena*); +template<> ::milvus::grpc::FieldName* Arena::CreateMaybeMessage<::milvus::grpc::FieldName>(Arena*); +template<> ::milvus::grpc::FieldParam* Arena::CreateMaybeMessage<::milvus::grpc::FieldParam>(Arena*); +template<> ::milvus::grpc::FieldType* Arena::CreateMaybeMessage<::milvus::grpc::FieldType>(Arena*); +template<> ::milvus::grpc::FlushParam* Arena::CreateMaybeMessage<::milvus::grpc::FlushParam>(Arena*); +template<> ::milvus::grpc::GeneralQuery* Arena::CreateMaybeMessage<::milvus::grpc::GeneralQuery>(Arena*); +template<> ::milvus::grpc::GetEntityIDsParam* Arena::CreateMaybeMessage<::milvus::grpc::GetEntityIDsParam>(Arena*); +template<> ::milvus::grpc::IndexParam* Arena::CreateMaybeMessage<::milvus::grpc::IndexParam>(Arena*); +template<> ::milvus::grpc::InsertOrDeleteMsg* Arena::CreateMaybeMessage<::milvus::grpc::InsertOrDeleteMsg>(Arena*); +template<> ::milvus::grpc::InsertParam* Arena::CreateMaybeMessage<::milvus::grpc::InsertParam>(Arena*); +template<> ::milvus::grpc::Key2SegMsg* Arena::CreateMaybeMessage<::milvus::grpc::Key2SegMsg>(Arena*); +template<> ::milvus::grpc::KeyValuePair* Arena::CreateMaybeMessage<::milvus::grpc::KeyValuePair>(Arena*); +template<> ::milvus::grpc::Mapping* Arena::CreateMaybeMessage<::milvus::grpc::Mapping>(Arena*); +template<> ::milvus::grpc::MappingList* Arena::CreateMaybeMessage<::milvus::grpc::MappingList>(Arena*); +template<> ::milvus::grpc::PartitionList* Arena::CreateMaybeMessage<::milvus::grpc::PartitionList>(Arena*); +template<> ::milvus::grpc::PartitionParam* Arena::CreateMaybeMessage<::milvus::grpc::PartitionParam>(Arena*); +template<> ::milvus::grpc::QueryResult* Arena::CreateMaybeMessage<::milvus::grpc::QueryResult>(Arena*); +template<> ::milvus::grpc::RangeQuery* Arena::CreateMaybeMessage<::milvus::grpc::RangeQuery>(Arena*); +template<> ::milvus::grpc::RowData* Arena::CreateMaybeMessage<::milvus::grpc::RowData>(Arena*); +template<> ::milvus::grpc::Schema* Arena::CreateMaybeMessage<::milvus::grpc::Schema>(Arena*); +template<> ::milvus::grpc::SearchInSegmentParam* Arena::CreateMaybeMessage<::milvus::grpc::SearchInSegmentParam>(Arena*); +template<> ::milvus::grpc::SearchMsg* Arena::CreateMaybeMessage<::milvus::grpc::SearchMsg>(Arena*); +template<> ::milvus::grpc::SearchParam* Arena::CreateMaybeMessage<::milvus::grpc::SearchParam>(Arena*); +template<> ::milvus::grpc::SearchParamPB* Arena::CreateMaybeMessage<::milvus::grpc::SearchParamPB>(Arena*); +template<> ::milvus::grpc::Status* Arena::CreateMaybeMessage<::milvus::grpc::Status>(Arena*); +template<> ::milvus::grpc::StringReply* Arena::CreateMaybeMessage<::milvus::grpc::StringReply>(Arena*); +template<> ::milvus::grpc::TermQuery* Arena::CreateMaybeMessage<::milvus::grpc::TermQuery>(Arena*); +template<> ::milvus::grpc::TimeSyncMsg* Arena::CreateMaybeMessage<::milvus::grpc::TimeSyncMsg>(Arena*); +template<> ::milvus::grpc::VectorFieldParam* Arena::CreateMaybeMessage<::milvus::grpc::VectorFieldParam>(Arena*); +template<> ::milvus::grpc::VectorFieldRecord* Arena::CreateMaybeMessage<::milvus::grpc::VectorFieldRecord>(Arena*); +template<> ::milvus::grpc::VectorParam* Arena::CreateMaybeMessage<::milvus::grpc::VectorParam>(Arena*); +template<> ::milvus::grpc::VectorQuery* Arena::CreateMaybeMessage<::milvus::grpc::VectorQuery>(Arena*); +template<> ::milvus::grpc::VectorRecord* Arena::CreateMaybeMessage<::milvus::grpc::VectorRecord>(Arena*); +template<> ::milvus::grpc::VectorRowRecord* Arena::CreateMaybeMessage<::milvus::grpc::VectorRowRecord>(Arena*); +PROTOBUF_NAMESPACE_CLOSE +namespace milvus { +namespace grpc { + +enum ErrorCode : int { + SUCCESS = 0, + UNEXPECTED_ERROR = 1, + CONNECT_FAILED = 2, + PERMISSION_DENIED = 3, + COLLECTION_NOT_EXISTS = 4, + ILLEGAL_ARGUMENT = 5, + ILLEGAL_DIMENSION = 7, + ILLEGAL_INDEX_TYPE = 8, + ILLEGAL_COLLECTION_NAME = 9, + ILLEGAL_TOPK = 10, + ILLEGAL_ROWRECORD = 11, + ILLEGAL_VECTOR_ID = 12, + ILLEGAL_SEARCH_RESULT = 13, + FILE_NOT_FOUND = 14, + META_FAILED = 15, + CACHE_FAILED = 16, + CANNOT_CREATE_FOLDER = 17, + CANNOT_CREATE_FILE = 18, + CANNOT_DELETE_FOLDER = 19, + CANNOT_DELETE_FILE = 20, + BUILD_INDEX_ERROR = 21, + ILLEGAL_NLIST = 22, + ILLEGAL_METRIC_TYPE = 23, + OUT_OF_MEMORY = 24, + ErrorCode_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(), + ErrorCode_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max() +}; +bool ErrorCode_IsValid(int value); +constexpr ErrorCode ErrorCode_MIN = SUCCESS; +constexpr ErrorCode ErrorCode_MAX = OUT_OF_MEMORY; +constexpr int ErrorCode_ARRAYSIZE = ErrorCode_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ErrorCode_descriptor(); +template +inline const std::string& ErrorCode_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function ErrorCode_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + ErrorCode_descriptor(), enum_t_value); +} +inline bool ErrorCode_Parse( + const std::string& name, ErrorCode* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + ErrorCode_descriptor(), name, value); +} +enum DataType : int { + NONE = 0, + BOOL = 1, + INT8 = 2, + INT16 = 3, + INT32 = 4, + INT64 = 5, + FLOAT = 10, + DOUBLE = 11, + STRING = 20, + VECTOR_BINARY = 100, + VECTOR_FLOAT = 101, + DataType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(), + DataType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max() +}; +bool DataType_IsValid(int value); +constexpr DataType DataType_MIN = NONE; +constexpr DataType DataType_MAX = VECTOR_FLOAT; +constexpr int DataType_ARRAYSIZE = DataType_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DataType_descriptor(); +template +inline const std::string& DataType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function DataType_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + DataType_descriptor(), enum_t_value); +} +inline bool DataType_Parse( + const std::string& name, DataType* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + DataType_descriptor(), name, value); +} +enum CompareOperator : int { + LT = 0, + LTE = 1, + EQ = 2, + GT = 3, + GTE = 4, + NE = 5, + CompareOperator_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(), + CompareOperator_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max() +}; +bool CompareOperator_IsValid(int value); +constexpr CompareOperator CompareOperator_MIN = LT; +constexpr CompareOperator CompareOperator_MAX = NE; +constexpr int CompareOperator_ARRAYSIZE = CompareOperator_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* CompareOperator_descriptor(); +template +inline const std::string& CompareOperator_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function CompareOperator_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + CompareOperator_descriptor(), enum_t_value); +} +inline bool CompareOperator_Parse( + const std::string& name, CompareOperator* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + CompareOperator_descriptor(), name, value); +} +enum Occur : int { + INVALID = 0, + MUST = 1, + SHOULD = 2, + MUST_NOT = 3, + Occur_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(), + Occur_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max() +}; +bool Occur_IsValid(int value); +constexpr Occur Occur_MIN = INVALID; +constexpr Occur Occur_MAX = MUST_NOT; +constexpr int Occur_ARRAYSIZE = Occur_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Occur_descriptor(); +template +inline const std::string& Occur_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function Occur_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + Occur_descriptor(), enum_t_value); +} +inline bool Occur_Parse( + const std::string& name, Occur* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + Occur_descriptor(), name, value); +} +enum OpType : int { + INSERT = 0, + DELETE = 1, + OpType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(), + OpType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max() +}; +bool OpType_IsValid(int value); +constexpr OpType OpType_MIN = INSERT; +constexpr OpType OpType_MAX = DELETE; +constexpr int OpType_ARRAYSIZE = OpType_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* OpType_descriptor(); +template +inline const std::string& OpType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function OpType_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + OpType_descriptor(), enum_t_value); +} +inline bool OpType_Parse( + const std::string& name, OpType* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + OpType_descriptor(), name, value); +} +enum SyncType : int { + READ = 0, + WRITE = 1, + SyncType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(), + SyncType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max() +}; +bool SyncType_IsValid(int value); +constexpr SyncType SyncType_MIN = READ; +constexpr SyncType SyncType_MAX = WRITE; +constexpr int SyncType_ARRAYSIZE = SyncType_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SyncType_descriptor(); +template +inline const std::string& SyncType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function SyncType_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + SyncType_descriptor(), enum_t_value); +} +inline bool SyncType_Parse( + const std::string& name, SyncType* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + SyncType_descriptor(), name, value); +} +// =================================================================== + +class Status : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.Status) */ { + public: + Status(); + virtual ~Status(); + + Status(const Status& from); + Status(Status&& from) noexcept + : Status() { + *this = ::std::move(from); + } + + inline Status& operator=(const Status& from) { + CopyFrom(from); + return *this; + } + inline Status& operator=(Status&& from) noexcept { + if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const Status& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const Status* internal_default_instance() { + return reinterpret_cast( + &_Status_default_instance_); + } + static constexpr int kIndexInFileMessages = + 0; + + friend void swap(Status& a, Status& b) { + a.Swap(&b); + } + inline void Swap(Status* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Status* New() const final { + return CreateMaybeMessage(nullptr); + } + + Status* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Status& from); + void MergeFrom(const Status& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + #else + bool MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final; + #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + void SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final; + ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Status* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.Status"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_message_2eproto); + return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kReasonFieldNumber = 2, + kErrorCodeFieldNumber = 1, + }; + // string reason = 2; + void clear_reason(); + const std::string& reason() const; + void set_reason(const std::string& value); + void set_reason(std::string&& value); + void set_reason(const char* value); + void set_reason(const char* value, size_t size); + std::string* mutable_reason(); + std::string* release_reason(); + void set_allocated_reason(std::string* reason); + + // .milvus.grpc.ErrorCode error_code = 1; + void clear_error_code(); + ::milvus::grpc::ErrorCode error_code() const; + void set_error_code(::milvus::grpc::ErrorCode value); + + // @@protoc_insertion_point(class_scope:milvus.grpc.Status) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr reason_; + int error_code_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_message_2eproto; +}; +// ------------------------------------------------------------------- + +class KeyValuePair : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.KeyValuePair) */ { + public: + KeyValuePair(); + virtual ~KeyValuePair(); + + KeyValuePair(const KeyValuePair& from); + KeyValuePair(KeyValuePair&& from) noexcept + : KeyValuePair() { + *this = ::std::move(from); + } + + inline KeyValuePair& operator=(const KeyValuePair& from) { + CopyFrom(from); + return *this; + } + inline KeyValuePair& operator=(KeyValuePair&& from) noexcept { + if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const KeyValuePair& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const KeyValuePair* internal_default_instance() { + return reinterpret_cast( + &_KeyValuePair_default_instance_); + } + static constexpr int kIndexInFileMessages = + 1; + + friend void swap(KeyValuePair& a, KeyValuePair& b) { + a.Swap(&b); + } + inline void Swap(KeyValuePair* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline KeyValuePair* New() const final { + return CreateMaybeMessage(nullptr); + } + + KeyValuePair* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const KeyValuePair& from); + void MergeFrom(const KeyValuePair& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + #else + bool MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final; + #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + void SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final; + ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(KeyValuePair* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.KeyValuePair"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_message_2eproto); + return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kKeyFieldNumber = 1, + kValueFieldNumber = 2, + }; + // string key = 1; + void clear_key(); + const std::string& key() const; + void set_key(const std::string& value); + void set_key(std::string&& value); + void set_key(const char* value); + void set_key(const char* value, size_t size); + std::string* mutable_key(); + std::string* release_key(); + void set_allocated_key(std::string* key); + + // string value = 2; + void clear_value(); + const std::string& value() const; + void set_value(const std::string& value); + void set_value(std::string&& value); + void set_value(const char* value); + void set_value(const char* value, size_t size); + std::string* mutable_value(); + std::string* release_value(); + void set_allocated_value(std::string* value); + + // @@protoc_insertion_point(class_scope:milvus.grpc.KeyValuePair) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_message_2eproto; +}; +// ------------------------------------------------------------------- + +class CollectionName : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.CollectionName) */ { + public: + CollectionName(); + virtual ~CollectionName(); + + CollectionName(const CollectionName& from); + CollectionName(CollectionName&& from) noexcept + : CollectionName() { + *this = ::std::move(from); + } + + inline CollectionName& operator=(const CollectionName& from) { + CopyFrom(from); + return *this; + } + inline CollectionName& operator=(CollectionName&& from) noexcept { + if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const CollectionName& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const CollectionName* internal_default_instance() { + return reinterpret_cast( + &_CollectionName_default_instance_); + } + static constexpr int kIndexInFileMessages = + 2; + + friend void swap(CollectionName& a, CollectionName& b) { + a.Swap(&b); + } + inline void Swap(CollectionName* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline CollectionName* New() const final { + return CreateMaybeMessage(nullptr); + } + + CollectionName* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const CollectionName& from); + void MergeFrom(const CollectionName& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + #else + bool MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final; + #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + void SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final; + ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(CollectionName* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.CollectionName"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_message_2eproto); + return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kCollectionNameFieldNumber = 1, + }; + // string collection_name = 1; + void clear_collection_name(); + const std::string& collection_name() const; + void set_collection_name(const std::string& value); + void set_collection_name(std::string&& value); + void set_collection_name(const char* value); + void set_collection_name(const char* value, size_t size); + std::string* mutable_collection_name(); + std::string* release_collection_name(); + void set_allocated_collection_name(std::string* collection_name); + + // @@protoc_insertion_point(class_scope:milvus.grpc.CollectionName) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collection_name_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_message_2eproto; +}; +// ------------------------------------------------------------------- + +class CollectionNameList : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.CollectionNameList) */ { + public: + CollectionNameList(); + virtual ~CollectionNameList(); + + CollectionNameList(const CollectionNameList& from); + CollectionNameList(CollectionNameList&& from) noexcept + : CollectionNameList() { + *this = ::std::move(from); + } + + inline CollectionNameList& operator=(const CollectionNameList& from) { + CopyFrom(from); + return *this; + } + inline CollectionNameList& operator=(CollectionNameList&& from) noexcept { + if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const CollectionNameList& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const CollectionNameList* internal_default_instance() { + return reinterpret_cast( + &_CollectionNameList_default_instance_); + } + static constexpr int kIndexInFileMessages = + 3; + + friend void swap(CollectionNameList& a, CollectionNameList& b) { + a.Swap(&b); + } + inline void Swap(CollectionNameList* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline CollectionNameList* New() const final { + return CreateMaybeMessage(nullptr); + } + + CollectionNameList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const CollectionNameList& from); + void MergeFrom(const CollectionNameList& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + #else + bool MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final; + #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + void SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final; + ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(CollectionNameList* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.CollectionNameList"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_message_2eproto); + return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kCollectionNamesFieldNumber = 2, + kStatusFieldNumber = 1, + }; + // repeated string collection_names = 2; + int collection_names_size() const; + void clear_collection_names(); + const std::string& collection_names(int index) const; + std::string* mutable_collection_names(int index); + void set_collection_names(int index, const std::string& value); + void set_collection_names(int index, std::string&& value); + void set_collection_names(int index, const char* value); + void set_collection_names(int index, const char* value, size_t size); + std::string* add_collection_names(); + void add_collection_names(const std::string& value); + void add_collection_names(std::string&& value); + void add_collection_names(const char* value); + void add_collection_names(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& collection_names() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_collection_names(); + + // .milvus.grpc.Status status = 1; + bool has_status() const; + void clear_status(); + const ::milvus::grpc::Status& status() const; + ::milvus::grpc::Status* release_status(); + ::milvus::grpc::Status* mutable_status(); + void set_allocated_status(::milvus::grpc::Status* status); + + // @@protoc_insertion_point(class_scope:milvus.grpc.CollectionNameList) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField collection_names_; + ::milvus::grpc::Status* status_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_message_2eproto; +}; +// ------------------------------------------------------------------- + +class FieldName : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.FieldName) */ { + public: + FieldName(); + virtual ~FieldName(); + + FieldName(const FieldName& from); + FieldName(FieldName&& from) noexcept + : FieldName() { + *this = ::std::move(from); + } + + inline FieldName& operator=(const FieldName& from) { + CopyFrom(from); + return *this; + } + inline FieldName& operator=(FieldName&& from) noexcept { + if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const FieldName& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const FieldName* internal_default_instance() { + return reinterpret_cast( + &_FieldName_default_instance_); + } + static constexpr int kIndexInFileMessages = + 4; + + friend void swap(FieldName& a, FieldName& b) { + a.Swap(&b); + } + inline void Swap(FieldName* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline FieldName* New() const final { + return CreateMaybeMessage(nullptr); + } + + FieldName* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const FieldName& from); + void MergeFrom(const FieldName& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + #else + bool MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final; + #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + void SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final; + ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(FieldName* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.FieldName"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_message_2eproto); + return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kCollectionNameFieldNumber = 1, + kFieldNameFieldNumber = 2, + }; + // string collection_name = 1; + void clear_collection_name(); + const std::string& collection_name() const; + void set_collection_name(const std::string& value); + void set_collection_name(std::string&& value); + void set_collection_name(const char* value); + void set_collection_name(const char* value, size_t size); + std::string* mutable_collection_name(); + std::string* release_collection_name(); + void set_allocated_collection_name(std::string* collection_name); + + // string field_name = 2; + void clear_field_name(); + const std::string& field_name() const; + void set_field_name(const std::string& value); + void set_field_name(std::string&& value); + void set_field_name(const char* value); + void set_field_name(const char* value, size_t size); + std::string* mutable_field_name(); + std::string* release_field_name(); + void set_allocated_field_name(std::string* field_name); + + // @@protoc_insertion_point(class_scope:milvus.grpc.FieldName) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collection_name_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr field_name_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_message_2eproto; +}; +// ------------------------------------------------------------------- + +class Mapping : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.Mapping) */ { + public: + Mapping(); + virtual ~Mapping(); + + Mapping(const Mapping& from); + Mapping(Mapping&& from) noexcept + : Mapping() { + *this = ::std::move(from); + } + + inline Mapping& operator=(const Mapping& from) { + CopyFrom(from); + return *this; + } + inline Mapping& operator=(Mapping&& from) noexcept { + if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const Mapping& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const Mapping* internal_default_instance() { + return reinterpret_cast( + &_Mapping_default_instance_); + } + static constexpr int kIndexInFileMessages = + 5; + + friend void swap(Mapping& a, Mapping& b) { + a.Swap(&b); + } + inline void Swap(Mapping* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Mapping* New() const final { + return CreateMaybeMessage(nullptr); + } + + Mapping* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Mapping& from); + void MergeFrom(const Mapping& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + #else + bool MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final; + #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + void SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final; + ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Mapping* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.Mapping"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_message_2eproto); + return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kExtraParamsFieldNumber = 4, + kCollectionNameFieldNumber = 2, + kStatusFieldNumber = 1, + kSchemaFieldNumber = 3, + }; + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + int extra_params_size() const; + void clear_extra_params(); + ::milvus::grpc::KeyValuePair* mutable_extra_params(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >* + mutable_extra_params(); + const ::milvus::grpc::KeyValuePair& extra_params(int index) const; + ::milvus::grpc::KeyValuePair* add_extra_params(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >& + extra_params() const; + + // string collection_name = 2; + void clear_collection_name(); + const std::string& collection_name() const; + void set_collection_name(const std::string& value); + void set_collection_name(std::string&& value); + void set_collection_name(const char* value); + void set_collection_name(const char* value, size_t size); + std::string* mutable_collection_name(); + std::string* release_collection_name(); + void set_allocated_collection_name(std::string* collection_name); + + // .milvus.grpc.Status status = 1; + bool has_status() const; + void clear_status(); + const ::milvus::grpc::Status& status() const; + ::milvus::grpc::Status* release_status(); + ::milvus::grpc::Status* mutable_status(); + void set_allocated_status(::milvus::grpc::Status* status); + + // .milvus.grpc.Schema schema = 3; + bool has_schema() const; + void clear_schema(); + const ::milvus::grpc::Schema& schema() const; + ::milvus::grpc::Schema* release_schema(); + ::milvus::grpc::Schema* mutable_schema(); + void set_allocated_schema(::milvus::grpc::Schema* schema); + + // @@protoc_insertion_point(class_scope:milvus.grpc.Mapping) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair > extra_params_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collection_name_; + ::milvus::grpc::Status* status_; + ::milvus::grpc::Schema* schema_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_message_2eproto; +}; +// ------------------------------------------------------------------- + +class MappingList : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.MappingList) */ { + public: + MappingList(); + virtual ~MappingList(); + + MappingList(const MappingList& from); + MappingList(MappingList&& from) noexcept + : MappingList() { + *this = ::std::move(from); + } + + inline MappingList& operator=(const MappingList& from) { + CopyFrom(from); + return *this; + } + inline MappingList& operator=(MappingList&& from) noexcept { + if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const MappingList& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const MappingList* internal_default_instance() { + return reinterpret_cast( + &_MappingList_default_instance_); + } + static constexpr int kIndexInFileMessages = + 6; + + friend void swap(MappingList& a, MappingList& b) { + a.Swap(&b); + } + inline void Swap(MappingList* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline MappingList* New() const final { + return CreateMaybeMessage(nullptr); + } + + MappingList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const MappingList& from); + void MergeFrom(const MappingList& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + #else + bool MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final; + #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + void SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final; + ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(MappingList* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.MappingList"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_message_2eproto); + return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kMappingListFieldNumber = 2, + kStatusFieldNumber = 1, + }; + // repeated .milvus.grpc.Mapping mapping_list = 2; + int mapping_list_size() const; + void clear_mapping_list(); + ::milvus::grpc::Mapping* mutable_mapping_list(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::Mapping >* + mutable_mapping_list(); + const ::milvus::grpc::Mapping& mapping_list(int index) const; + ::milvus::grpc::Mapping* add_mapping_list(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::Mapping >& + mapping_list() const; + + // .milvus.grpc.Status status = 1; + bool has_status() const; + void clear_status(); + const ::milvus::grpc::Status& status() const; + ::milvus::grpc::Status* release_status(); + ::milvus::grpc::Status* mutable_status(); + void set_allocated_status(::milvus::grpc::Status* status); + + // @@protoc_insertion_point(class_scope:milvus.grpc.MappingList) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::Mapping > mapping_list_; + ::milvus::grpc::Status* status_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_message_2eproto; +}; +// ------------------------------------------------------------------- + +class PartitionParam : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.PartitionParam) */ { + public: + PartitionParam(); + virtual ~PartitionParam(); + + PartitionParam(const PartitionParam& from); + PartitionParam(PartitionParam&& from) noexcept + : PartitionParam() { + *this = ::std::move(from); + } + + inline PartitionParam& operator=(const PartitionParam& from) { + CopyFrom(from); + return *this; + } + inline PartitionParam& operator=(PartitionParam&& from) noexcept { + if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const PartitionParam& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const PartitionParam* internal_default_instance() { + return reinterpret_cast( + &_PartitionParam_default_instance_); + } + static constexpr int kIndexInFileMessages = + 7; + + friend void swap(PartitionParam& a, PartitionParam& b) { + a.Swap(&b); + } + inline void Swap(PartitionParam* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline PartitionParam* New() const final { + return CreateMaybeMessage(nullptr); + } + + PartitionParam* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const PartitionParam& from); + void MergeFrom(const PartitionParam& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + #else + bool MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final; + #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + void SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final; + ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(PartitionParam* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.PartitionParam"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_message_2eproto); + return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kCollectionNameFieldNumber = 1, + kTagFieldNumber = 2, + }; + // string collection_name = 1; + void clear_collection_name(); + const std::string& collection_name() const; + void set_collection_name(const std::string& value); + void set_collection_name(std::string&& value); + void set_collection_name(const char* value); + void set_collection_name(const char* value, size_t size); + std::string* mutable_collection_name(); + std::string* release_collection_name(); + void set_allocated_collection_name(std::string* collection_name); + + // string tag = 2; + void clear_tag(); + const std::string& tag() const; + void set_tag(const std::string& value); + void set_tag(std::string&& value); + void set_tag(const char* value); + void set_tag(const char* value, size_t size); + std::string* mutable_tag(); + std::string* release_tag(); + void set_allocated_tag(std::string* tag); + + // @@protoc_insertion_point(class_scope:milvus.grpc.PartitionParam) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collection_name_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr tag_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_message_2eproto; +}; +// ------------------------------------------------------------------- + +class PartitionList : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.PartitionList) */ { + public: + PartitionList(); + virtual ~PartitionList(); + + PartitionList(const PartitionList& from); + PartitionList(PartitionList&& from) noexcept + : PartitionList() { + *this = ::std::move(from); + } + + inline PartitionList& operator=(const PartitionList& from) { + CopyFrom(from); + return *this; + } + inline PartitionList& operator=(PartitionList&& from) noexcept { + if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const PartitionList& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const PartitionList* internal_default_instance() { + return reinterpret_cast( + &_PartitionList_default_instance_); + } + static constexpr int kIndexInFileMessages = + 8; + + friend void swap(PartitionList& a, PartitionList& b) { + a.Swap(&b); + } + inline void Swap(PartitionList* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline PartitionList* New() const final { + return CreateMaybeMessage(nullptr); + } + + PartitionList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const PartitionList& from); + void MergeFrom(const PartitionList& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + #else + bool MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final; + #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + void SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final; + ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(PartitionList* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.PartitionList"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_message_2eproto); + return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kPartitionTagArrayFieldNumber = 2, + kStatusFieldNumber = 1, + }; + // repeated string partition_tag_array = 2; + int partition_tag_array_size() const; + void clear_partition_tag_array(); + const std::string& partition_tag_array(int index) const; + std::string* mutable_partition_tag_array(int index); + void set_partition_tag_array(int index, const std::string& value); + void set_partition_tag_array(int index, std::string&& value); + void set_partition_tag_array(int index, const char* value); + void set_partition_tag_array(int index, const char* value, size_t size); + std::string* add_partition_tag_array(); + void add_partition_tag_array(const std::string& value); + void add_partition_tag_array(std::string&& value); + void add_partition_tag_array(const char* value); + void add_partition_tag_array(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& partition_tag_array() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_partition_tag_array(); + + // .milvus.grpc.Status status = 1; + bool has_status() const; + void clear_status(); + const ::milvus::grpc::Status& status() const; + ::milvus::grpc::Status* release_status(); + ::milvus::grpc::Status* mutable_status(); + void set_allocated_status(::milvus::grpc::Status* status); + + // @@protoc_insertion_point(class_scope:milvus.grpc.PartitionList) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField partition_tag_array_; + ::milvus::grpc::Status* status_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_message_2eproto; +}; +// ------------------------------------------------------------------- + +class VectorRowRecord : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.VectorRowRecord) */ { + public: + VectorRowRecord(); + virtual ~VectorRowRecord(); + + VectorRowRecord(const VectorRowRecord& from); + VectorRowRecord(VectorRowRecord&& from) noexcept + : VectorRowRecord() { + *this = ::std::move(from); + } + + inline VectorRowRecord& operator=(const VectorRowRecord& from) { + CopyFrom(from); + return *this; + } + inline VectorRowRecord& operator=(VectorRowRecord&& from) noexcept { + if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const VectorRowRecord& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const VectorRowRecord* internal_default_instance() { + return reinterpret_cast( + &_VectorRowRecord_default_instance_); + } + static constexpr int kIndexInFileMessages = + 9; + + friend void swap(VectorRowRecord& a, VectorRowRecord& b) { + a.Swap(&b); + } + inline void Swap(VectorRowRecord* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline VectorRowRecord* New() const final { + return CreateMaybeMessage(nullptr); + } + + VectorRowRecord* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const VectorRowRecord& from); + void MergeFrom(const VectorRowRecord& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + #else + bool MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final; + #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + void SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final; + ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(VectorRowRecord* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.VectorRowRecord"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_message_2eproto); + return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kFloatDataFieldNumber = 1, + kBinaryDataFieldNumber = 2, + }; + // repeated float float_data = 1; + int float_data_size() const; + void clear_float_data(); + float float_data(int index) const; + void set_float_data(int index, float value); + void add_float_data(float value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& + float_data() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* + mutable_float_data(); + + // bytes binary_data = 2; + void clear_binary_data(); + const std::string& binary_data() const; + void set_binary_data(const std::string& value); + void set_binary_data(std::string&& value); + void set_binary_data(const char* value); + void set_binary_data(const void* value, size_t size); + std::string* mutable_binary_data(); + std::string* release_binary_data(); + void set_allocated_binary_data(std::string* binary_data); + + // @@protoc_insertion_point(class_scope:milvus.grpc.VectorRowRecord) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > float_data_; + mutable std::atomic _float_data_cached_byte_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr binary_data_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_message_2eproto; +}; +// ------------------------------------------------------------------- + +class EntityIds : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.EntityIds) */ { + public: + EntityIds(); + virtual ~EntityIds(); + + EntityIds(const EntityIds& from); + EntityIds(EntityIds&& from) noexcept + : EntityIds() { + *this = ::std::move(from); + } + + inline EntityIds& operator=(const EntityIds& from) { + CopyFrom(from); + return *this; + } + inline EntityIds& operator=(EntityIds&& from) noexcept { + if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const EntityIds& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const EntityIds* internal_default_instance() { + return reinterpret_cast( + &_EntityIds_default_instance_); + } + static constexpr int kIndexInFileMessages = + 10; + + friend void swap(EntityIds& a, EntityIds& b) { + a.Swap(&b); + } + inline void Swap(EntityIds* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline EntityIds* New() const final { + return CreateMaybeMessage(nullptr); + } + + EntityIds* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const EntityIds& from); + void MergeFrom(const EntityIds& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + #else + bool MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final; + #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + void SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final; + ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(EntityIds* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.EntityIds"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_message_2eproto); + return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kEntityIdArrayFieldNumber = 2, + kStatusFieldNumber = 1, + }; + // repeated int64 entity_id_array = 2; + int entity_id_array_size() const; + void clear_entity_id_array(); + ::PROTOBUF_NAMESPACE_ID::int64 entity_id_array(int index) const; + void set_entity_id_array(int index, ::PROTOBUF_NAMESPACE_ID::int64 value); + void add_entity_id_array(::PROTOBUF_NAMESPACE_ID::int64 value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >& + entity_id_array() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >* + mutable_entity_id_array(); + + // .milvus.grpc.Status status = 1; + bool has_status() const; + void clear_status(); + const ::milvus::grpc::Status& status() const; + ::milvus::grpc::Status* release_status(); + ::milvus::grpc::Status* mutable_status(); + void set_allocated_status(::milvus::grpc::Status* status); + + // @@protoc_insertion_point(class_scope:milvus.grpc.EntityIds) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > entity_id_array_; + mutable std::atomic _entity_id_array_cached_byte_size_; + ::milvus::grpc::Status* status_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_message_2eproto; +}; +// ------------------------------------------------------------------- + +class VectorRecord : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.VectorRecord) */ { + public: + VectorRecord(); + virtual ~VectorRecord(); + + VectorRecord(const VectorRecord& from); + VectorRecord(VectorRecord&& from) noexcept + : VectorRecord() { + *this = ::std::move(from); + } + + inline VectorRecord& operator=(const VectorRecord& from) { + CopyFrom(from); + return *this; + } + inline VectorRecord& operator=(VectorRecord&& from) noexcept { + if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const VectorRecord& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const VectorRecord* internal_default_instance() { + return reinterpret_cast( + &_VectorRecord_default_instance_); + } + static constexpr int kIndexInFileMessages = + 11; + + friend void swap(VectorRecord& a, VectorRecord& b) { + a.Swap(&b); + } + inline void Swap(VectorRecord* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline VectorRecord* New() const final { + return CreateMaybeMessage(nullptr); + } + + VectorRecord* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const VectorRecord& from); + void MergeFrom(const VectorRecord& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + #else + bool MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final; + #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + void SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final; + ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(VectorRecord* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.VectorRecord"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_message_2eproto); + return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kRecordsFieldNumber = 1, + }; + // repeated .milvus.grpc.VectorRowRecord records = 1; + int records_size() const; + void clear_records(); + ::milvus::grpc::VectorRowRecord* mutable_records(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::VectorRowRecord >* + mutable_records(); + const ::milvus::grpc::VectorRowRecord& records(int index) const; + ::milvus::grpc::VectorRowRecord* add_records(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::VectorRowRecord >& + records() const; + + // @@protoc_insertion_point(class_scope:milvus.grpc.VectorRecord) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::VectorRowRecord > records_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_message_2eproto; +}; +// ------------------------------------------------------------------- + +class VectorParam : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.VectorParam) */ { + public: + VectorParam(); + virtual ~VectorParam(); + + VectorParam(const VectorParam& from); + VectorParam(VectorParam&& from) noexcept + : VectorParam() { + *this = ::std::move(from); + } + + inline VectorParam& operator=(const VectorParam& from) { + CopyFrom(from); + return *this; + } + inline VectorParam& operator=(VectorParam&& from) noexcept { + if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const VectorParam& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const VectorParam* internal_default_instance() { + return reinterpret_cast( + &_VectorParam_default_instance_); + } + static constexpr int kIndexInFileMessages = + 12; + + friend void swap(VectorParam& a, VectorParam& b) { + a.Swap(&b); + } + inline void Swap(VectorParam* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline VectorParam* New() const final { + return CreateMaybeMessage(nullptr); + } + + VectorParam* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const VectorParam& from); + void MergeFrom(const VectorParam& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + #else + bool MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final; + #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + void SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final; + ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(VectorParam* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.VectorParam"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_message_2eproto); + return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kJsonFieldNumber = 1, + kRowRecordFieldNumber = 2, + }; + // string json = 1; + void clear_json(); + const std::string& json() const; + void set_json(const std::string& value); + void set_json(std::string&& value); + void set_json(const char* value); + void set_json(const char* value, size_t size); + std::string* mutable_json(); + std::string* release_json(); + void set_allocated_json(std::string* json); + + // .milvus.grpc.VectorRecord row_record = 2; + bool has_row_record() const; + void clear_row_record(); + const ::milvus::grpc::VectorRecord& row_record() const; + ::milvus::grpc::VectorRecord* release_row_record(); + ::milvus::grpc::VectorRecord* mutable_row_record(); + void set_allocated_row_record(::milvus::grpc::VectorRecord* row_record); + + // @@protoc_insertion_point(class_scope:milvus.grpc.VectorParam) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr json_; + ::milvus::grpc::VectorRecord* row_record_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_message_2eproto; +}; +// ------------------------------------------------------------------- + +class FieldMeta : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.FieldMeta) */ { + public: + FieldMeta(); + virtual ~FieldMeta(); + + FieldMeta(const FieldMeta& from); + FieldMeta(FieldMeta&& from) noexcept + : FieldMeta() { + *this = ::std::move(from); + } + + inline FieldMeta& operator=(const FieldMeta& from) { + CopyFrom(from); + return *this; + } + inline FieldMeta& operator=(FieldMeta&& from) noexcept { + if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const FieldMeta& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const FieldMeta* internal_default_instance() { + return reinterpret_cast( + &_FieldMeta_default_instance_); + } + static constexpr int kIndexInFileMessages = + 13; + + friend void swap(FieldMeta& a, FieldMeta& b) { + a.Swap(&b); + } + inline void Swap(FieldMeta* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline FieldMeta* New() const final { + return CreateMaybeMessage(nullptr); + } + + FieldMeta* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const FieldMeta& from); + void MergeFrom(const FieldMeta& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + #else + bool MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final; + #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + void SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final; + ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(FieldMeta* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.FieldMeta"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_message_2eproto); + return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kFieldNameFieldNumber = 1, + kDimFieldNumber = 3, + kTypeFieldNumber = 2, + }; + // string field_name = 1; + void clear_field_name(); + const std::string& field_name() const; + void set_field_name(const std::string& value); + void set_field_name(std::string&& value); + void set_field_name(const char* value); + void set_field_name(const char* value, size_t size); + std::string* mutable_field_name(); + std::string* release_field_name(); + void set_allocated_field_name(std::string* field_name); + + // int64 dim = 3; + void clear_dim(); + ::PROTOBUF_NAMESPACE_ID::int64 dim() const; + void set_dim(::PROTOBUF_NAMESPACE_ID::int64 value); + + // .milvus.grpc.DataType type = 2; + void clear_type(); + ::milvus::grpc::DataType type() const; + void set_type(::milvus::grpc::DataType value); + + // @@protoc_insertion_point(class_scope:milvus.grpc.FieldMeta) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr field_name_; + ::PROTOBUF_NAMESPACE_ID::int64 dim_; + int type_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_message_2eproto; +}; +// ------------------------------------------------------------------- + +class Schema : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.Schema) */ { + public: + Schema(); + virtual ~Schema(); + + Schema(const Schema& from); + Schema(Schema&& from) noexcept + : Schema() { + *this = ::std::move(from); + } + + inline Schema& operator=(const Schema& from) { + CopyFrom(from); + return *this; + } + inline Schema& operator=(Schema&& from) noexcept { + if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const Schema& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const Schema* internal_default_instance() { + return reinterpret_cast( + &_Schema_default_instance_); + } + static constexpr int kIndexInFileMessages = + 14; + + friend void swap(Schema& a, Schema& b) { + a.Swap(&b); + } + inline void Swap(Schema* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Schema* New() const final { + return CreateMaybeMessage(nullptr); + } + + Schema* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Schema& from); + void MergeFrom(const Schema& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + #else + bool MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final; + #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + void SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final; + ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Schema* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.Schema"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_message_2eproto); + return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kFieldMetasFieldNumber = 1, + }; + // repeated .milvus.grpc.FieldMeta field_metas = 1; + int field_metas_size() const; + void clear_field_metas(); + ::milvus::grpc::FieldMeta* mutable_field_metas(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::FieldMeta >* + mutable_field_metas(); + const ::milvus::grpc::FieldMeta& field_metas(int index) const; + ::milvus::grpc::FieldMeta* add_field_metas(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::FieldMeta >& + field_metas() const; + + // @@protoc_insertion_point(class_scope:milvus.grpc.Schema) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::FieldMeta > field_metas_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_message_2eproto; +}; +// ------------------------------------------------------------------- + +class RowData : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.RowData) */ { + public: + RowData(); + virtual ~RowData(); + + RowData(const RowData& from); + RowData(RowData&& from) noexcept + : RowData() { + *this = ::std::move(from); + } + + inline RowData& operator=(const RowData& from) { + CopyFrom(from); + return *this; + } + inline RowData& operator=(RowData&& from) noexcept { + if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const RowData& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const RowData* internal_default_instance() { + return reinterpret_cast( + &_RowData_default_instance_); + } + static constexpr int kIndexInFileMessages = + 15; + + friend void swap(RowData& a, RowData& b) { + a.Swap(&b); + } + inline void Swap(RowData* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline RowData* New() const final { + return CreateMaybeMessage(nullptr); + } + + RowData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const RowData& from); + void MergeFrom(const RowData& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + #else + bool MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final; + #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + void SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final; + ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(RowData* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.RowData"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_message_2eproto); + return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kBlobFieldNumber = 1, + }; + // bytes blob = 1; + void clear_blob(); + const std::string& blob() const; + void set_blob(const std::string& value); + void set_blob(std::string&& value); + void set_blob(const char* value); + void set_blob(const void* value, size_t size); + std::string* mutable_blob(); + std::string* release_blob(); + void set_allocated_blob(std::string* blob); + + // @@protoc_insertion_point(class_scope:milvus.grpc.RowData) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr blob_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_message_2eproto; +}; +// ------------------------------------------------------------------- + +class InsertParam : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.InsertParam) */ { + public: + InsertParam(); + virtual ~InsertParam(); + + InsertParam(const InsertParam& from); + InsertParam(InsertParam&& from) noexcept + : InsertParam() { + *this = ::std::move(from); + } + + inline InsertParam& operator=(const InsertParam& from) { + CopyFrom(from); + return *this; + } + inline InsertParam& operator=(InsertParam&& from) noexcept { + if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const InsertParam& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const InsertParam* internal_default_instance() { + return reinterpret_cast( + &_InsertParam_default_instance_); + } + static constexpr int kIndexInFileMessages = + 16; + + friend void swap(InsertParam& a, InsertParam& b) { + a.Swap(&b); + } + inline void Swap(InsertParam* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline InsertParam* New() const final { + return CreateMaybeMessage(nullptr); + } + + InsertParam* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const InsertParam& from); + void MergeFrom(const InsertParam& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + #else + bool MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final; + #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + void SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final; + ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(InsertParam* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.InsertParam"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_message_2eproto); + return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kRowsDataFieldNumber = 3, + kEntityIdArrayFieldNumber = 4, + kExtraParamsFieldNumber = 6, + kCollectionNameFieldNumber = 1, + kPartitionTagFieldNumber = 5, + kSchemaFieldNumber = 2, + }; + // repeated .milvus.grpc.RowData rows_data = 3; + int rows_data_size() const; + void clear_rows_data(); + ::milvus::grpc::RowData* mutable_rows_data(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::RowData >* + mutable_rows_data(); + const ::milvus::grpc::RowData& rows_data(int index) const; + ::milvus::grpc::RowData* add_rows_data(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::RowData >& + rows_data() const; + + // repeated int64 entity_id_array = 4; + int entity_id_array_size() const; + void clear_entity_id_array(); + ::PROTOBUF_NAMESPACE_ID::int64 entity_id_array(int index) const; + void set_entity_id_array(int index, ::PROTOBUF_NAMESPACE_ID::int64 value); + void add_entity_id_array(::PROTOBUF_NAMESPACE_ID::int64 value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >& + entity_id_array() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >* + mutable_entity_id_array(); + + // repeated .milvus.grpc.KeyValuePair extra_params = 6; + int extra_params_size() const; + void clear_extra_params(); + ::milvus::grpc::KeyValuePair* mutable_extra_params(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >* + mutable_extra_params(); + const ::milvus::grpc::KeyValuePair& extra_params(int index) const; + ::milvus::grpc::KeyValuePair* add_extra_params(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >& + extra_params() const; + + // string collection_name = 1; + void clear_collection_name(); + const std::string& collection_name() const; + void set_collection_name(const std::string& value); + void set_collection_name(std::string&& value); + void set_collection_name(const char* value); + void set_collection_name(const char* value, size_t size); + std::string* mutable_collection_name(); + std::string* release_collection_name(); + void set_allocated_collection_name(std::string* collection_name); + + // string partition_tag = 5; + void clear_partition_tag(); + const std::string& partition_tag() const; + void set_partition_tag(const std::string& value); + void set_partition_tag(std::string&& value); + void set_partition_tag(const char* value); + void set_partition_tag(const char* value, size_t size); + std::string* mutable_partition_tag(); + std::string* release_partition_tag(); + void set_allocated_partition_tag(std::string* partition_tag); + + // .milvus.grpc.Schema schema = 2; + bool has_schema() const; + void clear_schema(); + const ::milvus::grpc::Schema& schema() const; + ::milvus::grpc::Schema* release_schema(); + ::milvus::grpc::Schema* mutable_schema(); + void set_allocated_schema(::milvus::grpc::Schema* schema); + + // @@protoc_insertion_point(class_scope:milvus.grpc.InsertParam) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::RowData > rows_data_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > entity_id_array_; + mutable std::atomic _entity_id_array_cached_byte_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair > extra_params_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collection_name_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr partition_tag_; + ::milvus::grpc::Schema* schema_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_message_2eproto; +}; +// ------------------------------------------------------------------- + +class SearchParam : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.SearchParam) */ { + public: + SearchParam(); + virtual ~SearchParam(); + + SearchParam(const SearchParam& from); + SearchParam(SearchParam&& from) noexcept + : SearchParam() { + *this = ::std::move(from); + } + + inline SearchParam& operator=(const SearchParam& from) { + CopyFrom(from); + return *this; + } + inline SearchParam& operator=(SearchParam&& from) noexcept { + if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const SearchParam& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const SearchParam* internal_default_instance() { + return reinterpret_cast( + &_SearchParam_default_instance_); + } + static constexpr int kIndexInFileMessages = + 17; + + friend void swap(SearchParam& a, SearchParam& b) { + a.Swap(&b); + } + inline void Swap(SearchParam* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline SearchParam* New() const final { + return CreateMaybeMessage(nullptr); + } + + SearchParam* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const SearchParam& from); + void MergeFrom(const SearchParam& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + #else + bool MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final; + #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + void SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final; + ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(SearchParam* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.SearchParam"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_message_2eproto); + return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kVectorParamFieldNumber = 2, + kPartitionTagFieldNumber = 4, + kExtraParamsFieldNumber = 5, + kCollectionNameFieldNumber = 1, + kDslFieldNumber = 3, + }; + // repeated .milvus.grpc.VectorParam vector_param = 2; + int vector_param_size() const; + void clear_vector_param(); + ::milvus::grpc::VectorParam* mutable_vector_param(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::VectorParam >* + mutable_vector_param(); + const ::milvus::grpc::VectorParam& vector_param(int index) const; + ::milvus::grpc::VectorParam* add_vector_param(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::VectorParam >& + vector_param() const; + + // repeated string partition_tag = 4; + int partition_tag_size() const; + void clear_partition_tag(); + const std::string& partition_tag(int index) const; + std::string* mutable_partition_tag(int index); + void set_partition_tag(int index, const std::string& value); + void set_partition_tag(int index, std::string&& value); + void set_partition_tag(int index, const char* value); + void set_partition_tag(int index, const char* value, size_t size); + std::string* add_partition_tag(); + void add_partition_tag(const std::string& value); + void add_partition_tag(std::string&& value); + void add_partition_tag(const char* value); + void add_partition_tag(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& partition_tag() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_partition_tag(); + + // repeated .milvus.grpc.KeyValuePair extra_params = 5; + int extra_params_size() const; + void clear_extra_params(); + ::milvus::grpc::KeyValuePair* mutable_extra_params(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >* + mutable_extra_params(); + const ::milvus::grpc::KeyValuePair& extra_params(int index) const; + ::milvus::grpc::KeyValuePair* add_extra_params(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >& + extra_params() const; + + // string collection_name = 1; + void clear_collection_name(); + const std::string& collection_name() const; + void set_collection_name(const std::string& value); + void set_collection_name(std::string&& value); + void set_collection_name(const char* value); + void set_collection_name(const char* value, size_t size); + std::string* mutable_collection_name(); + std::string* release_collection_name(); + void set_allocated_collection_name(std::string* collection_name); + + // string dsl = 3; + void clear_dsl(); + const std::string& dsl() const; + void set_dsl(const std::string& value); + void set_dsl(std::string&& value); + void set_dsl(const char* value); + void set_dsl(const char* value, size_t size); + std::string* mutable_dsl(); + std::string* release_dsl(); + void set_allocated_dsl(std::string* dsl); + + // @@protoc_insertion_point(class_scope:milvus.grpc.SearchParam) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::VectorParam > vector_param_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField partition_tag_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair > extra_params_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collection_name_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr dsl_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_message_2eproto; +}; +// ------------------------------------------------------------------- + +class SearchInSegmentParam : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.SearchInSegmentParam) */ { + public: + SearchInSegmentParam(); + virtual ~SearchInSegmentParam(); + + SearchInSegmentParam(const SearchInSegmentParam& from); + SearchInSegmentParam(SearchInSegmentParam&& from) noexcept + : SearchInSegmentParam() { + *this = ::std::move(from); + } + + inline SearchInSegmentParam& operator=(const SearchInSegmentParam& from) { + CopyFrom(from); + return *this; + } + inline SearchInSegmentParam& operator=(SearchInSegmentParam&& from) noexcept { + if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const SearchInSegmentParam& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const SearchInSegmentParam* internal_default_instance() { + return reinterpret_cast( + &_SearchInSegmentParam_default_instance_); + } + static constexpr int kIndexInFileMessages = + 18; + + friend void swap(SearchInSegmentParam& a, SearchInSegmentParam& b) { + a.Swap(&b); + } + inline void Swap(SearchInSegmentParam* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline SearchInSegmentParam* New() const final { + return CreateMaybeMessage(nullptr); + } + + SearchInSegmentParam* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const SearchInSegmentParam& from); + void MergeFrom(const SearchInSegmentParam& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + #else + bool MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final; + #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + void SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final; + ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(SearchInSegmentParam* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.SearchInSegmentParam"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_message_2eproto); + return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kFileIdArrayFieldNumber = 1, + kSearchParamFieldNumber = 2, + }; + // repeated string file_id_array = 1; + int file_id_array_size() const; + void clear_file_id_array(); + const std::string& file_id_array(int index) const; + std::string* mutable_file_id_array(int index); + void set_file_id_array(int index, const std::string& value); + void set_file_id_array(int index, std::string&& value); + void set_file_id_array(int index, const char* value); + void set_file_id_array(int index, const char* value, size_t size); + std::string* add_file_id_array(); + void add_file_id_array(const std::string& value); + void add_file_id_array(std::string&& value); + void add_file_id_array(const char* value); + void add_file_id_array(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& file_id_array() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_file_id_array(); + + // .milvus.grpc.SearchParam search_param = 2; + bool has_search_param() const; + void clear_search_param(); + const ::milvus::grpc::SearchParam& search_param() const; + ::milvus::grpc::SearchParam* release_search_param(); + ::milvus::grpc::SearchParam* mutable_search_param(); + void set_allocated_search_param(::milvus::grpc::SearchParam* search_param); + + // @@protoc_insertion_point(class_scope:milvus.grpc.SearchInSegmentParam) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField file_id_array_; + ::milvus::grpc::SearchParam* search_param_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_message_2eproto; +}; +// ------------------------------------------------------------------- + +class Entities : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.Entities) */ { + public: + Entities(); + virtual ~Entities(); + + Entities(const Entities& from); + Entities(Entities&& from) noexcept + : Entities() { + *this = ::std::move(from); + } + + inline Entities& operator=(const Entities& from) { + CopyFrom(from); + return *this; + } + inline Entities& operator=(Entities&& from) noexcept { + if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const Entities& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const Entities* internal_default_instance() { + return reinterpret_cast( + &_Entities_default_instance_); + } + static constexpr int kIndexInFileMessages = + 19; + + friend void swap(Entities& a, Entities& b) { + a.Swap(&b); + } + inline void Swap(Entities* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Entities* New() const final { + return CreateMaybeMessage(nullptr); + } + + Entities* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Entities& from); + void MergeFrom(const Entities& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + #else + bool MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final; + #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + void SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final; + ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Entities* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.Entities"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_message_2eproto); + return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kIdsFieldNumber = 2, + kValidRowFieldNumber = 3, + kRowsDataFieldNumber = 4, + kStatusFieldNumber = 1, + }; + // repeated int64 ids = 2; + int ids_size() const; + void clear_ids(); + ::PROTOBUF_NAMESPACE_ID::int64 ids(int index) const; + void set_ids(int index, ::PROTOBUF_NAMESPACE_ID::int64 value); + void add_ids(::PROTOBUF_NAMESPACE_ID::int64 value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >& + ids() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >* + mutable_ids(); + + // repeated bool valid_row = 3; + int valid_row_size() const; + void clear_valid_row(); + bool valid_row(int index) const; + void set_valid_row(int index, bool value); + void add_valid_row(bool value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >& + valid_row() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >* + mutable_valid_row(); + + // repeated .milvus.grpc.RowData rows_data = 4; + int rows_data_size() const; + void clear_rows_data(); + ::milvus::grpc::RowData* mutable_rows_data(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::RowData >* + mutable_rows_data(); + const ::milvus::grpc::RowData& rows_data(int index) const; + ::milvus::grpc::RowData* add_rows_data(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::RowData >& + rows_data() const; + + // .milvus.grpc.Status status = 1; + bool has_status() const; + void clear_status(); + const ::milvus::grpc::Status& status() const; + ::milvus::grpc::Status* release_status(); + ::milvus::grpc::Status* mutable_status(); + void set_allocated_status(::milvus::grpc::Status* status); + + // @@protoc_insertion_point(class_scope:milvus.grpc.Entities) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > ids_; + mutable std::atomic _ids_cached_byte_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool > valid_row_; + mutable std::atomic _valid_row_cached_byte_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::RowData > rows_data_; + ::milvus::grpc::Status* status_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_message_2eproto; +}; +// ------------------------------------------------------------------- + +class QueryResult : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.QueryResult) */ { + public: + QueryResult(); + virtual ~QueryResult(); + + QueryResult(const QueryResult& from); + QueryResult(QueryResult&& from) noexcept + : QueryResult() { + *this = ::std::move(from); + } + + inline QueryResult& operator=(const QueryResult& from) { + CopyFrom(from); + return *this; + } + inline QueryResult& operator=(QueryResult&& from) noexcept { + if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const QueryResult& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const QueryResult* internal_default_instance() { + return reinterpret_cast( + &_QueryResult_default_instance_); + } + static constexpr int kIndexInFileMessages = + 20; + + friend void swap(QueryResult& a, QueryResult& b) { + a.Swap(&b); + } + inline void Swap(QueryResult* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline QueryResult* New() const final { + return CreateMaybeMessage(nullptr); + } + + QueryResult* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const QueryResult& from); + void MergeFrom(const QueryResult& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + #else + bool MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final; + #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + void SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final; + ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(QueryResult* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.QueryResult"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_message_2eproto); + return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kScoresFieldNumber = 4, + kDistancesFieldNumber = 5, + kExtraParamsFieldNumber = 6, + kStatusFieldNumber = 1, + kEntitiesFieldNumber = 2, + kRowNumFieldNumber = 3, + kQueryIdFieldNumber = 7, + kClientIdFieldNumber = 8, + }; + // repeated float scores = 4; + int scores_size() const; + void clear_scores(); + float scores(int index) const; + void set_scores(int index, float value); + void add_scores(float value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& + scores() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* + mutable_scores(); + + // repeated float distances = 5; + int distances_size() const; + void clear_distances(); + float distances(int index) const; + void set_distances(int index, float value); + void add_distances(float value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& + distances() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* + mutable_distances(); + + // repeated .milvus.grpc.KeyValuePair extra_params = 6; + int extra_params_size() const; + void clear_extra_params(); + ::milvus::grpc::KeyValuePair* mutable_extra_params(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >* + mutable_extra_params(); + const ::milvus::grpc::KeyValuePair& extra_params(int index) const; + ::milvus::grpc::KeyValuePair* add_extra_params(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >& + extra_params() const; + + // .milvus.grpc.Status status = 1; + bool has_status() const; + void clear_status(); + const ::milvus::grpc::Status& status() const; + ::milvus::grpc::Status* release_status(); + ::milvus::grpc::Status* mutable_status(); + void set_allocated_status(::milvus::grpc::Status* status); + + // .milvus.grpc.Entities entities = 2; + bool has_entities() const; + void clear_entities(); + const ::milvus::grpc::Entities& entities() const; + ::milvus::grpc::Entities* release_entities(); + ::milvus::grpc::Entities* mutable_entities(); + void set_allocated_entities(::milvus::grpc::Entities* entities); + + // int64 row_num = 3; + void clear_row_num(); + ::PROTOBUF_NAMESPACE_ID::int64 row_num() const; + void set_row_num(::PROTOBUF_NAMESPACE_ID::int64 value); + + // int64 query_id = 7; + void clear_query_id(); + ::PROTOBUF_NAMESPACE_ID::int64 query_id() const; + void set_query_id(::PROTOBUF_NAMESPACE_ID::int64 value); + + // int64 client_id = 8; + void clear_client_id(); + ::PROTOBUF_NAMESPACE_ID::int64 client_id() const; + void set_client_id(::PROTOBUF_NAMESPACE_ID::int64 value); + + // @@protoc_insertion_point(class_scope:milvus.grpc.QueryResult) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > scores_; + mutable std::atomic _scores_cached_byte_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > distances_; + mutable std::atomic _distances_cached_byte_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair > extra_params_; + ::milvus::grpc::Status* status_; + ::milvus::grpc::Entities* entities_; + ::PROTOBUF_NAMESPACE_ID::int64 row_num_; + ::PROTOBUF_NAMESPACE_ID::int64 query_id_; + ::PROTOBUF_NAMESPACE_ID::int64 client_id_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_message_2eproto; +}; +// ------------------------------------------------------------------- + +class StringReply : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.StringReply) */ { + public: + StringReply(); + virtual ~StringReply(); + + StringReply(const StringReply& from); + StringReply(StringReply&& from) noexcept + : StringReply() { + *this = ::std::move(from); + } + + inline StringReply& operator=(const StringReply& from) { + CopyFrom(from); + return *this; + } + inline StringReply& operator=(StringReply&& from) noexcept { + if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const StringReply& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const StringReply* internal_default_instance() { + return reinterpret_cast( + &_StringReply_default_instance_); + } + static constexpr int kIndexInFileMessages = + 21; + + friend void swap(StringReply& a, StringReply& b) { + a.Swap(&b); + } + inline void Swap(StringReply* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline StringReply* New() const final { + return CreateMaybeMessage(nullptr); + } + + StringReply* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const StringReply& from); + void MergeFrom(const StringReply& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + #else + bool MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final; + #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + void SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final; + ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(StringReply* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.StringReply"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_message_2eproto); + return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kStringReplyFieldNumber = 2, + kStatusFieldNumber = 1, + }; + // string string_reply = 2; + void clear_string_reply(); + const std::string& string_reply() const; + void set_string_reply(const std::string& value); + void set_string_reply(std::string&& value); + void set_string_reply(const char* value); + void set_string_reply(const char* value, size_t size); + std::string* mutable_string_reply(); + std::string* release_string_reply(); + void set_allocated_string_reply(std::string* string_reply); + + // .milvus.grpc.Status status = 1; + bool has_status() const; + void clear_status(); + const ::milvus::grpc::Status& status() const; + ::milvus::grpc::Status* release_status(); + ::milvus::grpc::Status* mutable_status(); + void set_allocated_status(::milvus::grpc::Status* status); + + // @@protoc_insertion_point(class_scope:milvus.grpc.StringReply) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr string_reply_; + ::milvus::grpc::Status* status_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_message_2eproto; +}; +// ------------------------------------------------------------------- + +class BoolReply : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.BoolReply) */ { + public: + BoolReply(); + virtual ~BoolReply(); + + BoolReply(const BoolReply& from); + BoolReply(BoolReply&& from) noexcept + : BoolReply() { + *this = ::std::move(from); + } + + inline BoolReply& operator=(const BoolReply& from) { + CopyFrom(from); + return *this; + } + inline BoolReply& operator=(BoolReply&& from) noexcept { + if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const BoolReply& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const BoolReply* internal_default_instance() { + return reinterpret_cast( + &_BoolReply_default_instance_); + } + static constexpr int kIndexInFileMessages = + 22; + + friend void swap(BoolReply& a, BoolReply& b) { + a.Swap(&b); + } + inline void Swap(BoolReply* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline BoolReply* New() const final { + return CreateMaybeMessage(nullptr); + } + + BoolReply* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const BoolReply& from); + void MergeFrom(const BoolReply& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + #else + bool MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final; + #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + void SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final; + ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(BoolReply* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.BoolReply"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_message_2eproto); + return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kStatusFieldNumber = 1, + kBoolReplyFieldNumber = 2, + }; + // .milvus.grpc.Status status = 1; + bool has_status() const; + void clear_status(); + const ::milvus::grpc::Status& status() const; + ::milvus::grpc::Status* release_status(); + ::milvus::grpc::Status* mutable_status(); + void set_allocated_status(::milvus::grpc::Status* status); + + // bool bool_reply = 2; + void clear_bool_reply(); + bool bool_reply() const; + void set_bool_reply(bool value); + + // @@protoc_insertion_point(class_scope:milvus.grpc.BoolReply) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::milvus::grpc::Status* status_; + bool bool_reply_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_message_2eproto; +}; +// ------------------------------------------------------------------- + +class CollectionRowCount : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.CollectionRowCount) */ { + public: + CollectionRowCount(); + virtual ~CollectionRowCount(); + + CollectionRowCount(const CollectionRowCount& from); + CollectionRowCount(CollectionRowCount&& from) noexcept + : CollectionRowCount() { + *this = ::std::move(from); + } + + inline CollectionRowCount& operator=(const CollectionRowCount& from) { + CopyFrom(from); + return *this; + } + inline CollectionRowCount& operator=(CollectionRowCount&& from) noexcept { + if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const CollectionRowCount& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const CollectionRowCount* internal_default_instance() { + return reinterpret_cast( + &_CollectionRowCount_default_instance_); + } + static constexpr int kIndexInFileMessages = + 23; + + friend void swap(CollectionRowCount& a, CollectionRowCount& b) { + a.Swap(&b); + } + inline void Swap(CollectionRowCount* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline CollectionRowCount* New() const final { + return CreateMaybeMessage(nullptr); + } + + CollectionRowCount* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const CollectionRowCount& from); + void MergeFrom(const CollectionRowCount& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + #else + bool MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final; + #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + void SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final; + ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(CollectionRowCount* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.CollectionRowCount"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_message_2eproto); + return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kStatusFieldNumber = 1, + kCollectionRowCountFieldNumber = 2, + }; + // .milvus.grpc.Status status = 1; + bool has_status() const; + void clear_status(); + const ::milvus::grpc::Status& status() const; + ::milvus::grpc::Status* release_status(); + ::milvus::grpc::Status* mutable_status(); + void set_allocated_status(::milvus::grpc::Status* status); + + // int64 collection_row_count = 2; + void clear_collection_row_count(); + ::PROTOBUF_NAMESPACE_ID::int64 collection_row_count() const; + void set_collection_row_count(::PROTOBUF_NAMESPACE_ID::int64 value); + + // @@protoc_insertion_point(class_scope:milvus.grpc.CollectionRowCount) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::milvus::grpc::Status* status_; + ::PROTOBUF_NAMESPACE_ID::int64 collection_row_count_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_message_2eproto; +}; +// ------------------------------------------------------------------- + +class Command : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.Command) */ { + public: + Command(); + virtual ~Command(); + + Command(const Command& from); + Command(Command&& from) noexcept + : Command() { + *this = ::std::move(from); + } + + inline Command& operator=(const Command& from) { + CopyFrom(from); + return *this; + } + inline Command& operator=(Command&& from) noexcept { + if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const Command& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const Command* internal_default_instance() { + return reinterpret_cast( + &_Command_default_instance_); + } + static constexpr int kIndexInFileMessages = + 24; + + friend void swap(Command& a, Command& b) { + a.Swap(&b); + } + inline void Swap(Command* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Command* New() const final { + return CreateMaybeMessage(nullptr); + } + + Command* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Command& from); + void MergeFrom(const Command& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + #else + bool MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final; + #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + void SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final; + ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Command* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.Command"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_message_2eproto); + return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kCmdFieldNumber = 1, + }; + // string cmd = 1; + void clear_cmd(); + const std::string& cmd() const; + void set_cmd(const std::string& value); + void set_cmd(std::string&& value); + void set_cmd(const char* value); + void set_cmd(const char* value, size_t size); + std::string* mutable_cmd(); + std::string* release_cmd(); + void set_allocated_cmd(std::string* cmd); + + // @@protoc_insertion_point(class_scope:milvus.grpc.Command) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr cmd_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_message_2eproto; +}; +// ------------------------------------------------------------------- + +class IndexParam : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.IndexParam) */ { + public: + IndexParam(); + virtual ~IndexParam(); + + IndexParam(const IndexParam& from); + IndexParam(IndexParam&& from) noexcept + : IndexParam() { + *this = ::std::move(from); + } + + inline IndexParam& operator=(const IndexParam& from) { + CopyFrom(from); + return *this; + } + inline IndexParam& operator=(IndexParam&& from) noexcept { + if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const IndexParam& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const IndexParam* internal_default_instance() { + return reinterpret_cast( + &_IndexParam_default_instance_); + } + static constexpr int kIndexInFileMessages = + 25; + + friend void swap(IndexParam& a, IndexParam& b) { + a.Swap(&b); + } + inline void Swap(IndexParam* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline IndexParam* New() const final { + return CreateMaybeMessage(nullptr); + } + + IndexParam* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const IndexParam& from); + void MergeFrom(const IndexParam& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + #else + bool MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final; + #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + void SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final; + ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(IndexParam* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.IndexParam"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_message_2eproto); + return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kExtraParamsFieldNumber = 5, + kCollectionNameFieldNumber = 2, + kFieldNameFieldNumber = 3, + kIndexNameFieldNumber = 4, + kStatusFieldNumber = 1, + }; + // repeated .milvus.grpc.KeyValuePair extra_params = 5; + int extra_params_size() const; + void clear_extra_params(); + ::milvus::grpc::KeyValuePair* mutable_extra_params(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >* + mutable_extra_params(); + const ::milvus::grpc::KeyValuePair& extra_params(int index) const; + ::milvus::grpc::KeyValuePair* add_extra_params(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >& + extra_params() const; + + // string collection_name = 2; + void clear_collection_name(); + const std::string& collection_name() const; + void set_collection_name(const std::string& value); + void set_collection_name(std::string&& value); + void set_collection_name(const char* value); + void set_collection_name(const char* value, size_t size); + std::string* mutable_collection_name(); + std::string* release_collection_name(); + void set_allocated_collection_name(std::string* collection_name); + + // string field_name = 3; + void clear_field_name(); + const std::string& field_name() const; + void set_field_name(const std::string& value); + void set_field_name(std::string&& value); + void set_field_name(const char* value); + void set_field_name(const char* value, size_t size); + std::string* mutable_field_name(); + std::string* release_field_name(); + void set_allocated_field_name(std::string* field_name); + + // string index_name = 4; + void clear_index_name(); + const std::string& index_name() const; + void set_index_name(const std::string& value); + void set_index_name(std::string&& value); + void set_index_name(const char* value); + void set_index_name(const char* value, size_t size); + std::string* mutable_index_name(); + std::string* release_index_name(); + void set_allocated_index_name(std::string* index_name); + + // .milvus.grpc.Status status = 1; + bool has_status() const; + void clear_status(); + const ::milvus::grpc::Status& status() const; + ::milvus::grpc::Status* release_status(); + ::milvus::grpc::Status* mutable_status(); + void set_allocated_status(::milvus::grpc::Status* status); + + // @@protoc_insertion_point(class_scope:milvus.grpc.IndexParam) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair > extra_params_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collection_name_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr field_name_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr index_name_; + ::milvus::grpc::Status* status_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_message_2eproto; +}; +// ------------------------------------------------------------------- + +class FlushParam : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.FlushParam) */ { + public: + FlushParam(); + virtual ~FlushParam(); + + FlushParam(const FlushParam& from); + FlushParam(FlushParam&& from) noexcept + : FlushParam() { + *this = ::std::move(from); + } + + inline FlushParam& operator=(const FlushParam& from) { + CopyFrom(from); + return *this; + } + inline FlushParam& operator=(FlushParam&& from) noexcept { + if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const FlushParam& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const FlushParam* internal_default_instance() { + return reinterpret_cast( + &_FlushParam_default_instance_); + } + static constexpr int kIndexInFileMessages = + 26; + + friend void swap(FlushParam& a, FlushParam& b) { + a.Swap(&b); + } + inline void Swap(FlushParam* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline FlushParam* New() const final { + return CreateMaybeMessage(nullptr); + } + + FlushParam* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const FlushParam& from); + void MergeFrom(const FlushParam& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + #else + bool MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final; + #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + void SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final; + ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(FlushParam* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.FlushParam"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_message_2eproto); + return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kCollectionNameArrayFieldNumber = 1, + }; + // repeated string collection_name_array = 1; + int collection_name_array_size() const; + void clear_collection_name_array(); + const std::string& collection_name_array(int index) const; + std::string* mutable_collection_name_array(int index); + void set_collection_name_array(int index, const std::string& value); + void set_collection_name_array(int index, std::string&& value); + void set_collection_name_array(int index, const char* value); + void set_collection_name_array(int index, const char* value, size_t size); + std::string* add_collection_name_array(); + void add_collection_name_array(const std::string& value); + void add_collection_name_array(std::string&& value); + void add_collection_name_array(const char* value); + void add_collection_name_array(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& collection_name_array() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_collection_name_array(); + + // @@protoc_insertion_point(class_scope:milvus.grpc.FlushParam) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField collection_name_array_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_message_2eproto; +}; +// ------------------------------------------------------------------- + +class CompactParam : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.CompactParam) */ { + public: + CompactParam(); + virtual ~CompactParam(); + + CompactParam(const CompactParam& from); + CompactParam(CompactParam&& from) noexcept + : CompactParam() { + *this = ::std::move(from); + } + + inline CompactParam& operator=(const CompactParam& from) { + CopyFrom(from); + return *this; + } + inline CompactParam& operator=(CompactParam&& from) noexcept { + if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const CompactParam& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const CompactParam* internal_default_instance() { + return reinterpret_cast( + &_CompactParam_default_instance_); + } + static constexpr int kIndexInFileMessages = + 27; + + friend void swap(CompactParam& a, CompactParam& b) { + a.Swap(&b); + } + inline void Swap(CompactParam* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline CompactParam* New() const final { + return CreateMaybeMessage(nullptr); + } + + CompactParam* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const CompactParam& from); + void MergeFrom(const CompactParam& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + #else + bool MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final; + #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + void SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final; + ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(CompactParam* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.CompactParam"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_message_2eproto); + return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kCollectionNameFieldNumber = 1, + kThresholdFieldNumber = 2, + }; + // string collection_name = 1; + void clear_collection_name(); + const std::string& collection_name() const; + void set_collection_name(const std::string& value); + void set_collection_name(std::string&& value); + void set_collection_name(const char* value); + void set_collection_name(const char* value, size_t size); + std::string* mutable_collection_name(); + std::string* release_collection_name(); + void set_allocated_collection_name(std::string* collection_name); + + // double threshold = 2; + void clear_threshold(); + double threshold() const; + void set_threshold(double value); + + // @@protoc_insertion_point(class_scope:milvus.grpc.CompactParam) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collection_name_; + double threshold_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_message_2eproto; +}; +// ------------------------------------------------------------------- + +class DeleteByIDParam : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.DeleteByIDParam) */ { + public: + DeleteByIDParam(); + virtual ~DeleteByIDParam(); + + DeleteByIDParam(const DeleteByIDParam& from); + DeleteByIDParam(DeleteByIDParam&& from) noexcept + : DeleteByIDParam() { + *this = ::std::move(from); + } + + inline DeleteByIDParam& operator=(const DeleteByIDParam& from) { + CopyFrom(from); + return *this; + } + inline DeleteByIDParam& operator=(DeleteByIDParam&& from) noexcept { + if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const DeleteByIDParam& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const DeleteByIDParam* internal_default_instance() { + return reinterpret_cast( + &_DeleteByIDParam_default_instance_); + } + static constexpr int kIndexInFileMessages = + 28; + + friend void swap(DeleteByIDParam& a, DeleteByIDParam& b) { + a.Swap(&b); + } + inline void Swap(DeleteByIDParam* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline DeleteByIDParam* New() const final { + return CreateMaybeMessage(nullptr); + } + + DeleteByIDParam* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const DeleteByIDParam& from); + void MergeFrom(const DeleteByIDParam& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + #else + bool MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final; + #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + void SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final; + ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(DeleteByIDParam* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.DeleteByIDParam"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_message_2eproto); + return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kIdArrayFieldNumber = 2, + kCollectionNameFieldNumber = 1, + }; + // repeated int64 id_array = 2; + int id_array_size() const; + void clear_id_array(); + ::PROTOBUF_NAMESPACE_ID::int64 id_array(int index) const; + void set_id_array(int index, ::PROTOBUF_NAMESPACE_ID::int64 value); + void add_id_array(::PROTOBUF_NAMESPACE_ID::int64 value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >& + id_array() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >* + mutable_id_array(); + + // string collection_name = 1; + void clear_collection_name(); + const std::string& collection_name() const; + void set_collection_name(const std::string& value); + void set_collection_name(std::string&& value); + void set_collection_name(const char* value); + void set_collection_name(const char* value, size_t size); + std::string* mutable_collection_name(); + std::string* release_collection_name(); + void set_allocated_collection_name(std::string* collection_name); + + // @@protoc_insertion_point(class_scope:milvus.grpc.DeleteByIDParam) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > id_array_; + mutable std::atomic _id_array_cached_byte_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collection_name_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_message_2eproto; +}; +// ------------------------------------------------------------------- + +class CollectionInfo : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.CollectionInfo) */ { + public: + CollectionInfo(); + virtual ~CollectionInfo(); + + CollectionInfo(const CollectionInfo& from); + CollectionInfo(CollectionInfo&& from) noexcept + : CollectionInfo() { + *this = ::std::move(from); + } + + inline CollectionInfo& operator=(const CollectionInfo& from) { + CopyFrom(from); + return *this; + } + inline CollectionInfo& operator=(CollectionInfo&& from) noexcept { + if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const CollectionInfo& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const CollectionInfo* internal_default_instance() { + return reinterpret_cast( + &_CollectionInfo_default_instance_); + } + static constexpr int kIndexInFileMessages = + 29; + + friend void swap(CollectionInfo& a, CollectionInfo& b) { + a.Swap(&b); + } + inline void Swap(CollectionInfo* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline CollectionInfo* New() const final { + return CreateMaybeMessage(nullptr); + } + + CollectionInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const CollectionInfo& from); + void MergeFrom(const CollectionInfo& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + #else + bool MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final; + #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + void SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final; + ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(CollectionInfo* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.CollectionInfo"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_message_2eproto); + return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kJsonInfoFieldNumber = 2, + kStatusFieldNumber = 1, + }; + // string json_info = 2; + void clear_json_info(); + const std::string& json_info() const; + void set_json_info(const std::string& value); + void set_json_info(std::string&& value); + void set_json_info(const char* value); + void set_json_info(const char* value, size_t size); + std::string* mutable_json_info(); + std::string* release_json_info(); + void set_allocated_json_info(std::string* json_info); + + // .milvus.grpc.Status status = 1; + bool has_status() const; + void clear_status(); + const ::milvus::grpc::Status& status() const; + ::milvus::grpc::Status* release_status(); + ::milvus::grpc::Status* mutable_status(); + void set_allocated_status(::milvus::grpc::Status* status); + + // @@protoc_insertion_point(class_scope:milvus.grpc.CollectionInfo) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr json_info_; + ::milvus::grpc::Status* status_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_message_2eproto; +}; +// ------------------------------------------------------------------- + +class GetEntityIDsParam : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.GetEntityIDsParam) */ { + public: + GetEntityIDsParam(); + virtual ~GetEntityIDsParam(); + + GetEntityIDsParam(const GetEntityIDsParam& from); + GetEntityIDsParam(GetEntityIDsParam&& from) noexcept + : GetEntityIDsParam() { + *this = ::std::move(from); + } + + inline GetEntityIDsParam& operator=(const GetEntityIDsParam& from) { + CopyFrom(from); + return *this; + } + inline GetEntityIDsParam& operator=(GetEntityIDsParam&& from) noexcept { + if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const GetEntityIDsParam& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const GetEntityIDsParam* internal_default_instance() { + return reinterpret_cast( + &_GetEntityIDsParam_default_instance_); + } + static constexpr int kIndexInFileMessages = + 30; + + friend void swap(GetEntityIDsParam& a, GetEntityIDsParam& b) { + a.Swap(&b); + } + inline void Swap(GetEntityIDsParam* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline GetEntityIDsParam* New() const final { + return CreateMaybeMessage(nullptr); + } + + GetEntityIDsParam* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const GetEntityIDsParam& from); + void MergeFrom(const GetEntityIDsParam& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + #else + bool MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final; + #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + void SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final; + ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(GetEntityIDsParam* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.GetEntityIDsParam"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_message_2eproto); + return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kCollectionNameFieldNumber = 1, + kSegmentIdFieldNumber = 2, + }; + // string collection_name = 1; + void clear_collection_name(); + const std::string& collection_name() const; + void set_collection_name(const std::string& value); + void set_collection_name(std::string&& value); + void set_collection_name(const char* value); + void set_collection_name(const char* value, size_t size); + std::string* mutable_collection_name(); + std::string* release_collection_name(); + void set_allocated_collection_name(std::string* collection_name); + + // int64 segment_id = 2; + void clear_segment_id(); + ::PROTOBUF_NAMESPACE_ID::int64 segment_id() const; + void set_segment_id(::PROTOBUF_NAMESPACE_ID::int64 value); + + // @@protoc_insertion_point(class_scope:milvus.grpc.GetEntityIDsParam) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collection_name_; + ::PROTOBUF_NAMESPACE_ID::int64 segment_id_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_message_2eproto; +}; +// ------------------------------------------------------------------- + +class EntityIdentity : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.EntityIdentity) */ { + public: + EntityIdentity(); + virtual ~EntityIdentity(); + + EntityIdentity(const EntityIdentity& from); + EntityIdentity(EntityIdentity&& from) noexcept + : EntityIdentity() { + *this = ::std::move(from); + } + + inline EntityIdentity& operator=(const EntityIdentity& from) { + CopyFrom(from); + return *this; + } + inline EntityIdentity& operator=(EntityIdentity&& from) noexcept { + if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const EntityIdentity& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const EntityIdentity* internal_default_instance() { + return reinterpret_cast( + &_EntityIdentity_default_instance_); + } + static constexpr int kIndexInFileMessages = + 31; + + friend void swap(EntityIdentity& a, EntityIdentity& b) { + a.Swap(&b); + } + inline void Swap(EntityIdentity* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline EntityIdentity* New() const final { + return CreateMaybeMessage(nullptr); + } + + EntityIdentity* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const EntityIdentity& from); + void MergeFrom(const EntityIdentity& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + #else + bool MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final; + #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + void SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final; + ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(EntityIdentity* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.EntityIdentity"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_message_2eproto); + return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kIdArrayFieldNumber = 2, + kFieldNamesFieldNumber = 3, + kCollectionNameFieldNumber = 1, + }; + // repeated int64 id_array = 2; + int id_array_size() const; + void clear_id_array(); + ::PROTOBUF_NAMESPACE_ID::int64 id_array(int index) const; + void set_id_array(int index, ::PROTOBUF_NAMESPACE_ID::int64 value); + void add_id_array(::PROTOBUF_NAMESPACE_ID::int64 value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >& + id_array() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >* + mutable_id_array(); + + // repeated string field_names = 3; + int field_names_size() const; + void clear_field_names(); + const std::string& field_names(int index) const; + std::string* mutable_field_names(int index); + void set_field_names(int index, const std::string& value); + void set_field_names(int index, std::string&& value); + void set_field_names(int index, const char* value); + void set_field_names(int index, const char* value, size_t size); + std::string* add_field_names(); + void add_field_names(const std::string& value); + void add_field_names(std::string&& value); + void add_field_names(const char* value); + void add_field_names(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& field_names() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_field_names(); + + // string collection_name = 1; + void clear_collection_name(); + const std::string& collection_name() const; + void set_collection_name(const std::string& value); + void set_collection_name(std::string&& value); + void set_collection_name(const char* value); + void set_collection_name(const char* value, size_t size); + std::string* mutable_collection_name(); + std::string* release_collection_name(); + void set_allocated_collection_name(std::string* collection_name); + + // @@protoc_insertion_point(class_scope:milvus.grpc.EntityIdentity) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > id_array_; + mutable std::atomic _id_array_cached_byte_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField field_names_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collection_name_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_message_2eproto; +}; +// ------------------------------------------------------------------- + +class VectorFieldParam : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.VectorFieldParam) */ { + public: + VectorFieldParam(); + virtual ~VectorFieldParam(); + + VectorFieldParam(const VectorFieldParam& from); + VectorFieldParam(VectorFieldParam&& from) noexcept + : VectorFieldParam() { + *this = ::std::move(from); + } + + inline VectorFieldParam& operator=(const VectorFieldParam& from) { + CopyFrom(from); + return *this; + } + inline VectorFieldParam& operator=(VectorFieldParam&& from) noexcept { + if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const VectorFieldParam& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const VectorFieldParam* internal_default_instance() { + return reinterpret_cast( + &_VectorFieldParam_default_instance_); + } + static constexpr int kIndexInFileMessages = + 32; + + friend void swap(VectorFieldParam& a, VectorFieldParam& b) { + a.Swap(&b); + } + inline void Swap(VectorFieldParam* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline VectorFieldParam* New() const final { + return CreateMaybeMessage(nullptr); + } + + VectorFieldParam* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const VectorFieldParam& from); + void MergeFrom(const VectorFieldParam& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + #else + bool MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final; + #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + void SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final; + ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(VectorFieldParam* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.VectorFieldParam"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_message_2eproto); + return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kDimensionFieldNumber = 1, + }; + // int64 dimension = 1; + void clear_dimension(); + ::PROTOBUF_NAMESPACE_ID::int64 dimension() const; + void set_dimension(::PROTOBUF_NAMESPACE_ID::int64 value); + + // @@protoc_insertion_point(class_scope:milvus.grpc.VectorFieldParam) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::int64 dimension_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_message_2eproto; +}; +// ------------------------------------------------------------------- + +class FieldType : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.FieldType) */ { + public: + FieldType(); + virtual ~FieldType(); + + FieldType(const FieldType& from); + FieldType(FieldType&& from) noexcept + : FieldType() { + *this = ::std::move(from); + } + + inline FieldType& operator=(const FieldType& from) { + CopyFrom(from); + return *this; + } + inline FieldType& operator=(FieldType&& from) noexcept { + if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const FieldType& default_instance(); + + enum ValueCase { + kDataType = 1, + kVectorParam = 2, + VALUE_NOT_SET = 0, + }; + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const FieldType* internal_default_instance() { + return reinterpret_cast( + &_FieldType_default_instance_); + } + static constexpr int kIndexInFileMessages = + 33; + + friend void swap(FieldType& a, FieldType& b) { + a.Swap(&b); + } + inline void Swap(FieldType* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline FieldType* New() const final { + return CreateMaybeMessage(nullptr); + } + + FieldType* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const FieldType& from); + void MergeFrom(const FieldType& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + #else + bool MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final; + #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + void SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final; + ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(FieldType* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.FieldType"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_message_2eproto); + return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kDataTypeFieldNumber = 1, + kVectorParamFieldNumber = 2, + }; + // .milvus.grpc.DataType data_type = 1; + private: + bool has_data_type() const; + public: + void clear_data_type(); + ::milvus::grpc::DataType data_type() const; + void set_data_type(::milvus::grpc::DataType value); + + // .milvus.grpc.VectorFieldParam vector_param = 2; + bool has_vector_param() const; + void clear_vector_param(); + const ::milvus::grpc::VectorFieldParam& vector_param() const; + ::milvus::grpc::VectorFieldParam* release_vector_param(); + ::milvus::grpc::VectorFieldParam* mutable_vector_param(); + void set_allocated_vector_param(::milvus::grpc::VectorFieldParam* vector_param); + + void clear_value(); + ValueCase value_case() const; + // @@protoc_insertion_point(class_scope:milvus.grpc.FieldType) + private: + class _Internal; + void set_has_data_type(); + void set_has_vector_param(); + + inline bool has_value() const; + inline void clear_has_value(); + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + union ValueUnion { + ValueUnion() {} + int data_type_; + ::milvus::grpc::VectorFieldParam* vector_param_; + } value_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + + friend struct ::TableStruct_message_2eproto; +}; +// ------------------------------------------------------------------- + +class FieldParam : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.FieldParam) */ { + public: + FieldParam(); + virtual ~FieldParam(); + + FieldParam(const FieldParam& from); + FieldParam(FieldParam&& from) noexcept + : FieldParam() { + *this = ::std::move(from); + } + + inline FieldParam& operator=(const FieldParam& from) { + CopyFrom(from); + return *this; + } + inline FieldParam& operator=(FieldParam&& from) noexcept { + if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const FieldParam& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const FieldParam* internal_default_instance() { + return reinterpret_cast( + &_FieldParam_default_instance_); + } + static constexpr int kIndexInFileMessages = + 34; + + friend void swap(FieldParam& a, FieldParam& b) { + a.Swap(&b); + } + inline void Swap(FieldParam* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline FieldParam* New() const final { + return CreateMaybeMessage(nullptr); + } + + FieldParam* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const FieldParam& from); + void MergeFrom(const FieldParam& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + #else + bool MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final; + #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + void SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final; + ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(FieldParam* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.FieldParam"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_message_2eproto); + return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kIndexParamsFieldNumber = 4, + kExtraParamsFieldNumber = 5, + kNameFieldNumber = 2, + kIdFieldNumber = 1, + kTypeFieldNumber = 3, + }; + // repeated .milvus.grpc.KeyValuePair index_params = 4; + int index_params_size() const; + void clear_index_params(); + ::milvus::grpc::KeyValuePair* mutable_index_params(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >* + mutable_index_params(); + const ::milvus::grpc::KeyValuePair& index_params(int index) const; + ::milvus::grpc::KeyValuePair* add_index_params(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >& + index_params() const; + + // repeated .milvus.grpc.KeyValuePair extra_params = 5; + int extra_params_size() const; + void clear_extra_params(); + ::milvus::grpc::KeyValuePair* mutable_extra_params(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >* + mutable_extra_params(); + const ::milvus::grpc::KeyValuePair& extra_params(int index) const; + ::milvus::grpc::KeyValuePair* add_extra_params(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >& + extra_params() const; + + // string name = 2; + void clear_name(); + const std::string& name() const; + void set_name(const std::string& value); + void set_name(std::string&& value); + void set_name(const char* value); + void set_name(const char* value, size_t size); + std::string* mutable_name(); + std::string* release_name(); + void set_allocated_name(std::string* name); + + // uint64 id = 1; + void clear_id(); + ::PROTOBUF_NAMESPACE_ID::uint64 id() const; + void set_id(::PROTOBUF_NAMESPACE_ID::uint64 value); + + // .milvus.grpc.DataType type = 3; + void clear_type(); + ::milvus::grpc::DataType type() const; + void set_type(::milvus::grpc::DataType value); + + // @@protoc_insertion_point(class_scope:milvus.grpc.FieldParam) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair > index_params_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair > extra_params_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; + ::PROTOBUF_NAMESPACE_ID::uint64 id_; + int type_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_message_2eproto; +}; +// ------------------------------------------------------------------- + +class VectorFieldRecord : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.VectorFieldRecord) */ { + public: + VectorFieldRecord(); + virtual ~VectorFieldRecord(); + + VectorFieldRecord(const VectorFieldRecord& from); + VectorFieldRecord(VectorFieldRecord&& from) noexcept + : VectorFieldRecord() { + *this = ::std::move(from); + } + + inline VectorFieldRecord& operator=(const VectorFieldRecord& from) { + CopyFrom(from); + return *this; + } + inline VectorFieldRecord& operator=(VectorFieldRecord&& from) noexcept { + if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const VectorFieldRecord& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const VectorFieldRecord* internal_default_instance() { + return reinterpret_cast( + &_VectorFieldRecord_default_instance_); + } + static constexpr int kIndexInFileMessages = + 35; + + friend void swap(VectorFieldRecord& a, VectorFieldRecord& b) { + a.Swap(&b); + } + inline void Swap(VectorFieldRecord* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline VectorFieldRecord* New() const final { + return CreateMaybeMessage(nullptr); + } + + VectorFieldRecord* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const VectorFieldRecord& from); + void MergeFrom(const VectorFieldRecord& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + #else + bool MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final; + #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + void SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final; + ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(VectorFieldRecord* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.VectorFieldRecord"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_message_2eproto); + return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kValueFieldNumber = 1, + }; + // repeated .milvus.grpc.VectorRowRecord value = 1; + int value_size() const; + void clear_value(); + ::milvus::grpc::VectorRowRecord* mutable_value(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::VectorRowRecord >* + mutable_value(); + const ::milvus::grpc::VectorRowRecord& value(int index) const; + ::milvus::grpc::VectorRowRecord* add_value(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::VectorRowRecord >& + value() const; + + // @@protoc_insertion_point(class_scope:milvus.grpc.VectorFieldRecord) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::VectorRowRecord > value_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_message_2eproto; +}; +// ------------------------------------------------------------------- + +class TermQuery : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.TermQuery) */ { + public: + TermQuery(); + virtual ~TermQuery(); + + TermQuery(const TermQuery& from); + TermQuery(TermQuery&& from) noexcept + : TermQuery() { + *this = ::std::move(from); + } + + inline TermQuery& operator=(const TermQuery& from) { + CopyFrom(from); + return *this; + } + inline TermQuery& operator=(TermQuery&& from) noexcept { + if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const TermQuery& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const TermQuery* internal_default_instance() { + return reinterpret_cast( + &_TermQuery_default_instance_); + } + static constexpr int kIndexInFileMessages = + 36; + + friend void swap(TermQuery& a, TermQuery& b) { + a.Swap(&b); + } + inline void Swap(TermQuery* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline TermQuery* New() const final { + return CreateMaybeMessage(nullptr); + } + + TermQuery* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const TermQuery& from); + void MergeFrom(const TermQuery& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + #else + bool MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final; + #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + void SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final; + ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(TermQuery* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.TermQuery"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_message_2eproto); + return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kIntValueFieldNumber = 2, + kDoubleValueFieldNumber = 3, + kExtraParamsFieldNumber = 6, + kFieldNameFieldNumber = 1, + kValueNumFieldNumber = 4, + kBoostFieldNumber = 5, + }; + // repeated int64 int_value = 2; + int int_value_size() const; + void clear_int_value(); + ::PROTOBUF_NAMESPACE_ID::int64 int_value(int index) const; + void set_int_value(int index, ::PROTOBUF_NAMESPACE_ID::int64 value); + void add_int_value(::PROTOBUF_NAMESPACE_ID::int64 value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >& + int_value() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >* + mutable_int_value(); + + // repeated double double_value = 3; + int double_value_size() const; + void clear_double_value(); + double double_value(int index) const; + void set_double_value(int index, double value); + void add_double_value(double value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >& + double_value() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >* + mutable_double_value(); + + // repeated .milvus.grpc.KeyValuePair extra_params = 6; + int extra_params_size() const; + void clear_extra_params(); + ::milvus::grpc::KeyValuePair* mutable_extra_params(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >* + mutable_extra_params(); + const ::milvus::grpc::KeyValuePair& extra_params(int index) const; + ::milvus::grpc::KeyValuePair* add_extra_params(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >& + extra_params() const; + + // string field_name = 1; + void clear_field_name(); + const std::string& field_name() const; + void set_field_name(const std::string& value); + void set_field_name(std::string&& value); + void set_field_name(const char* value); + void set_field_name(const char* value, size_t size); + std::string* mutable_field_name(); + std::string* release_field_name(); + void set_allocated_field_name(std::string* field_name); + + // int64 value_num = 4; + void clear_value_num(); + ::PROTOBUF_NAMESPACE_ID::int64 value_num() const; + void set_value_num(::PROTOBUF_NAMESPACE_ID::int64 value); + + // float boost = 5; + void clear_boost(); + float boost() const; + void set_boost(float value); + + // @@protoc_insertion_point(class_scope:milvus.grpc.TermQuery) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > int_value_; + mutable std::atomic _int_value_cached_byte_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< double > double_value_; + mutable std::atomic _double_value_cached_byte_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair > extra_params_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr field_name_; + ::PROTOBUF_NAMESPACE_ID::int64 value_num_; + float boost_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_message_2eproto; +}; +// ------------------------------------------------------------------- + +class CompareExpr : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.CompareExpr) */ { + public: + CompareExpr(); + virtual ~CompareExpr(); + + CompareExpr(const CompareExpr& from); + CompareExpr(CompareExpr&& from) noexcept + : CompareExpr() { + *this = ::std::move(from); + } + + inline CompareExpr& operator=(const CompareExpr& from) { + CopyFrom(from); + return *this; + } + inline CompareExpr& operator=(CompareExpr&& from) noexcept { + if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const CompareExpr& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const CompareExpr* internal_default_instance() { + return reinterpret_cast( + &_CompareExpr_default_instance_); + } + static constexpr int kIndexInFileMessages = + 37; + + friend void swap(CompareExpr& a, CompareExpr& b) { + a.Swap(&b); + } + inline void Swap(CompareExpr* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline CompareExpr* New() const final { + return CreateMaybeMessage(nullptr); + } + + CompareExpr* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const CompareExpr& from); + void MergeFrom(const CompareExpr& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + #else + bool MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final; + #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + void SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final; + ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(CompareExpr* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.CompareExpr"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_message_2eproto); + return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kOperandFieldNumber = 2, + kOperatorFieldNumber = 1, + }; + // string operand = 2; + void clear_operand(); + const std::string& operand() const; + void set_operand(const std::string& value); + void set_operand(std::string&& value); + void set_operand(const char* value); + void set_operand(const char* value, size_t size); + std::string* mutable_operand(); + std::string* release_operand(); + void set_allocated_operand(std::string* operand); + + // .milvus.grpc.CompareOperator operator = 1; + void clear_operator_(); + ::milvus::grpc::CompareOperator operator_() const; + void set_operator_(::milvus::grpc::CompareOperator value); + + // @@protoc_insertion_point(class_scope:milvus.grpc.CompareExpr) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr operand_; + int operator__; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_message_2eproto; +}; +// ------------------------------------------------------------------- + +class RangeQuery : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.RangeQuery) */ { + public: + RangeQuery(); + virtual ~RangeQuery(); + + RangeQuery(const RangeQuery& from); + RangeQuery(RangeQuery&& from) noexcept + : RangeQuery() { + *this = ::std::move(from); + } + + inline RangeQuery& operator=(const RangeQuery& from) { + CopyFrom(from); + return *this; + } + inline RangeQuery& operator=(RangeQuery&& from) noexcept { + if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const RangeQuery& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const RangeQuery* internal_default_instance() { + return reinterpret_cast( + &_RangeQuery_default_instance_); + } + static constexpr int kIndexInFileMessages = + 38; + + friend void swap(RangeQuery& a, RangeQuery& b) { + a.Swap(&b); + } + inline void Swap(RangeQuery* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline RangeQuery* New() const final { + return CreateMaybeMessage(nullptr); + } + + RangeQuery* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const RangeQuery& from); + void MergeFrom(const RangeQuery& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + #else + bool MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final; + #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + void SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final; + ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(RangeQuery* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.RangeQuery"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_message_2eproto); + return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kOperandFieldNumber = 2, + kExtraParamsFieldNumber = 4, + kFieldNameFieldNumber = 1, + kBoostFieldNumber = 3, + }; + // repeated .milvus.grpc.CompareExpr operand = 2; + int operand_size() const; + void clear_operand(); + ::milvus::grpc::CompareExpr* mutable_operand(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::CompareExpr >* + mutable_operand(); + const ::milvus::grpc::CompareExpr& operand(int index) const; + ::milvus::grpc::CompareExpr* add_operand(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::CompareExpr >& + operand() const; + + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + int extra_params_size() const; + void clear_extra_params(); + ::milvus::grpc::KeyValuePair* mutable_extra_params(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >* + mutable_extra_params(); + const ::milvus::grpc::KeyValuePair& extra_params(int index) const; + ::milvus::grpc::KeyValuePair* add_extra_params(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >& + extra_params() const; + + // string field_name = 1; + void clear_field_name(); + const std::string& field_name() const; + void set_field_name(const std::string& value); + void set_field_name(std::string&& value); + void set_field_name(const char* value); + void set_field_name(const char* value, size_t size); + std::string* mutable_field_name(); + std::string* release_field_name(); + void set_allocated_field_name(std::string* field_name); + + // float boost = 3; + void clear_boost(); + float boost() const; + void set_boost(float value); + + // @@protoc_insertion_point(class_scope:milvus.grpc.RangeQuery) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::CompareExpr > operand_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair > extra_params_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr field_name_; + float boost_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_message_2eproto; +}; +// ------------------------------------------------------------------- + +class VectorQuery : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.VectorQuery) */ { + public: + VectorQuery(); + virtual ~VectorQuery(); + + VectorQuery(const VectorQuery& from); + VectorQuery(VectorQuery&& from) noexcept + : VectorQuery() { + *this = ::std::move(from); + } + + inline VectorQuery& operator=(const VectorQuery& from) { + CopyFrom(from); + return *this; + } + inline VectorQuery& operator=(VectorQuery&& from) noexcept { + if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const VectorQuery& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const VectorQuery* internal_default_instance() { + return reinterpret_cast( + &_VectorQuery_default_instance_); + } + static constexpr int kIndexInFileMessages = + 39; + + friend void swap(VectorQuery& a, VectorQuery& b) { + a.Swap(&b); + } + inline void Swap(VectorQuery* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline VectorQuery* New() const final { + return CreateMaybeMessage(nullptr); + } + + VectorQuery* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const VectorQuery& from); + void MergeFrom(const VectorQuery& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + #else + bool MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final; + #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + void SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final; + ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(VectorQuery* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.VectorQuery"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_message_2eproto); + return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kRecordsFieldNumber = 3, + kExtraParamsFieldNumber = 5, + kFieldNameFieldNumber = 1, + kTopkFieldNumber = 4, + kQueryBoostFieldNumber = 2, + }; + // repeated .milvus.grpc.VectorRowRecord records = 3; + int records_size() const; + void clear_records(); + ::milvus::grpc::VectorRowRecord* mutable_records(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::VectorRowRecord >* + mutable_records(); + const ::milvus::grpc::VectorRowRecord& records(int index) const; + ::milvus::grpc::VectorRowRecord* add_records(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::VectorRowRecord >& + records() const; + + // repeated .milvus.grpc.KeyValuePair extra_params = 5; + int extra_params_size() const; + void clear_extra_params(); + ::milvus::grpc::KeyValuePair* mutable_extra_params(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >* + mutable_extra_params(); + const ::milvus::grpc::KeyValuePair& extra_params(int index) const; + ::milvus::grpc::KeyValuePair* add_extra_params(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >& + extra_params() const; + + // string field_name = 1; + void clear_field_name(); + const std::string& field_name() const; + void set_field_name(const std::string& value); + void set_field_name(std::string&& value); + void set_field_name(const char* value); + void set_field_name(const char* value, size_t size); + std::string* mutable_field_name(); + std::string* release_field_name(); + void set_allocated_field_name(std::string* field_name); + + // int64 topk = 4; + void clear_topk(); + ::PROTOBUF_NAMESPACE_ID::int64 topk() const; + void set_topk(::PROTOBUF_NAMESPACE_ID::int64 value); + + // float query_boost = 2; + void clear_query_boost(); + float query_boost() const; + void set_query_boost(float value); + + // @@protoc_insertion_point(class_scope:milvus.grpc.VectorQuery) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::VectorRowRecord > records_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair > extra_params_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr field_name_; + ::PROTOBUF_NAMESPACE_ID::int64 topk_; + float query_boost_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_message_2eproto; +}; +// ------------------------------------------------------------------- + +class BooleanQuery : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.BooleanQuery) */ { + public: + BooleanQuery(); + virtual ~BooleanQuery(); + + BooleanQuery(const BooleanQuery& from); + BooleanQuery(BooleanQuery&& from) noexcept + : BooleanQuery() { + *this = ::std::move(from); + } + + inline BooleanQuery& operator=(const BooleanQuery& from) { + CopyFrom(from); + return *this; + } + inline BooleanQuery& operator=(BooleanQuery&& from) noexcept { + if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const BooleanQuery& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const BooleanQuery* internal_default_instance() { + return reinterpret_cast( + &_BooleanQuery_default_instance_); + } + static constexpr int kIndexInFileMessages = + 40; + + friend void swap(BooleanQuery& a, BooleanQuery& b) { + a.Swap(&b); + } + inline void Swap(BooleanQuery* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline BooleanQuery* New() const final { + return CreateMaybeMessage(nullptr); + } + + BooleanQuery* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const BooleanQuery& from); + void MergeFrom(const BooleanQuery& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + #else + bool MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final; + #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + void SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final; + ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(BooleanQuery* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.BooleanQuery"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_message_2eproto); + return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kGeneralQueryFieldNumber = 2, + kOccurFieldNumber = 1, + }; + // repeated .milvus.grpc.GeneralQuery general_query = 2; + int general_query_size() const; + void clear_general_query(); + ::milvus::grpc::GeneralQuery* mutable_general_query(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::GeneralQuery >* + mutable_general_query(); + const ::milvus::grpc::GeneralQuery& general_query(int index) const; + ::milvus::grpc::GeneralQuery* add_general_query(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::GeneralQuery >& + general_query() const; + + // .milvus.grpc.Occur occur = 1; + void clear_occur(); + ::milvus::grpc::Occur occur() const; + void set_occur(::milvus::grpc::Occur value); + + // @@protoc_insertion_point(class_scope:milvus.grpc.BooleanQuery) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::GeneralQuery > general_query_; + int occur_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_message_2eproto; +}; +// ------------------------------------------------------------------- + +class GeneralQuery : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.GeneralQuery) */ { + public: + GeneralQuery(); + virtual ~GeneralQuery(); + + GeneralQuery(const GeneralQuery& from); + GeneralQuery(GeneralQuery&& from) noexcept + : GeneralQuery() { + *this = ::std::move(from); + } + + inline GeneralQuery& operator=(const GeneralQuery& from) { + CopyFrom(from); + return *this; + } + inline GeneralQuery& operator=(GeneralQuery&& from) noexcept { + if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const GeneralQuery& default_instance(); + + enum QueryCase { + kBooleanQuery = 1, + kTermQuery = 2, + kRangeQuery = 3, + kVectorQuery = 4, + QUERY_NOT_SET = 0, + }; + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const GeneralQuery* internal_default_instance() { + return reinterpret_cast( + &_GeneralQuery_default_instance_); + } + static constexpr int kIndexInFileMessages = + 41; + + friend void swap(GeneralQuery& a, GeneralQuery& b) { + a.Swap(&b); + } + inline void Swap(GeneralQuery* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline GeneralQuery* New() const final { + return CreateMaybeMessage(nullptr); + } + + GeneralQuery* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const GeneralQuery& from); + void MergeFrom(const GeneralQuery& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + #else + bool MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final; + #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + void SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final; + ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(GeneralQuery* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.GeneralQuery"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_message_2eproto); + return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kBooleanQueryFieldNumber = 1, + kTermQueryFieldNumber = 2, + kRangeQueryFieldNumber = 3, + kVectorQueryFieldNumber = 4, + }; + // .milvus.grpc.BooleanQuery boolean_query = 1; + bool has_boolean_query() const; + void clear_boolean_query(); + const ::milvus::grpc::BooleanQuery& boolean_query() const; + ::milvus::grpc::BooleanQuery* release_boolean_query(); + ::milvus::grpc::BooleanQuery* mutable_boolean_query(); + void set_allocated_boolean_query(::milvus::grpc::BooleanQuery* boolean_query); + + // .milvus.grpc.TermQuery term_query = 2; + bool has_term_query() const; + void clear_term_query(); + const ::milvus::grpc::TermQuery& term_query() const; + ::milvus::grpc::TermQuery* release_term_query(); + ::milvus::grpc::TermQuery* mutable_term_query(); + void set_allocated_term_query(::milvus::grpc::TermQuery* term_query); + + // .milvus.grpc.RangeQuery range_query = 3; + bool has_range_query() const; + void clear_range_query(); + const ::milvus::grpc::RangeQuery& range_query() const; + ::milvus::grpc::RangeQuery* release_range_query(); + ::milvus::grpc::RangeQuery* mutable_range_query(); + void set_allocated_range_query(::milvus::grpc::RangeQuery* range_query); + + // .milvus.grpc.VectorQuery vector_query = 4; + bool has_vector_query() const; + void clear_vector_query(); + const ::milvus::grpc::VectorQuery& vector_query() const; + ::milvus::grpc::VectorQuery* release_vector_query(); + ::milvus::grpc::VectorQuery* mutable_vector_query(); + void set_allocated_vector_query(::milvus::grpc::VectorQuery* vector_query); + + void clear_query(); + QueryCase query_case() const; + // @@protoc_insertion_point(class_scope:milvus.grpc.GeneralQuery) + private: + class _Internal; + void set_has_boolean_query(); + void set_has_term_query(); + void set_has_range_query(); + void set_has_vector_query(); + + inline bool has_query() const; + inline void clear_has_query(); + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + union QueryUnion { + QueryUnion() {} + ::milvus::grpc::BooleanQuery* boolean_query_; + ::milvus::grpc::TermQuery* term_query_; + ::milvus::grpc::RangeQuery* range_query_; + ::milvus::grpc::VectorQuery* vector_query_; + } query_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + + friend struct ::TableStruct_message_2eproto; +}; +// ------------------------------------------------------------------- + +class SearchParamPB : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.SearchParamPB) */ { + public: + SearchParamPB(); + virtual ~SearchParamPB(); + + SearchParamPB(const SearchParamPB& from); + SearchParamPB(SearchParamPB&& from) noexcept + : SearchParamPB() { + *this = ::std::move(from); + } + + inline SearchParamPB& operator=(const SearchParamPB& from) { + CopyFrom(from); + return *this; + } + inline SearchParamPB& operator=(SearchParamPB&& from) noexcept { + if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const SearchParamPB& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const SearchParamPB* internal_default_instance() { + return reinterpret_cast( + &_SearchParamPB_default_instance_); + } + static constexpr int kIndexInFileMessages = + 42; + + friend void swap(SearchParamPB& a, SearchParamPB& b) { + a.Swap(&b); + } + inline void Swap(SearchParamPB* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline SearchParamPB* New() const final { + return CreateMaybeMessage(nullptr); + } + + SearchParamPB* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const SearchParamPB& from); + void MergeFrom(const SearchParamPB& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + #else + bool MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final; + #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + void SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final; + ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(SearchParamPB* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.SearchParamPB"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_message_2eproto); + return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kPartitionTagArrayFieldNumber = 2, + kExtraParamsFieldNumber = 4, + kCollectionNameFieldNumber = 1, + kGeneralQueryFieldNumber = 3, + }; + // repeated string partition_tag_array = 2; + int partition_tag_array_size() const; + void clear_partition_tag_array(); + const std::string& partition_tag_array(int index) const; + std::string* mutable_partition_tag_array(int index); + void set_partition_tag_array(int index, const std::string& value); + void set_partition_tag_array(int index, std::string&& value); + void set_partition_tag_array(int index, const char* value); + void set_partition_tag_array(int index, const char* value, size_t size); + std::string* add_partition_tag_array(); + void add_partition_tag_array(const std::string& value); + void add_partition_tag_array(std::string&& value); + void add_partition_tag_array(const char* value); + void add_partition_tag_array(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& partition_tag_array() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_partition_tag_array(); + + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + int extra_params_size() const; + void clear_extra_params(); + ::milvus::grpc::KeyValuePair* mutable_extra_params(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >* + mutable_extra_params(); + const ::milvus::grpc::KeyValuePair& extra_params(int index) const; + ::milvus::grpc::KeyValuePair* add_extra_params(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >& + extra_params() const; + + // string collection_name = 1; + void clear_collection_name(); + const std::string& collection_name() const; + void set_collection_name(const std::string& value); + void set_collection_name(std::string&& value); + void set_collection_name(const char* value); + void set_collection_name(const char* value, size_t size); + std::string* mutable_collection_name(); + std::string* release_collection_name(); + void set_allocated_collection_name(std::string* collection_name); + + // .milvus.grpc.GeneralQuery general_query = 3; + bool has_general_query() const; + void clear_general_query(); + const ::milvus::grpc::GeneralQuery& general_query() const; + ::milvus::grpc::GeneralQuery* release_general_query(); + ::milvus::grpc::GeneralQuery* mutable_general_query(); + void set_allocated_general_query(::milvus::grpc::GeneralQuery* general_query); + + // @@protoc_insertion_point(class_scope:milvus.grpc.SearchParamPB) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField partition_tag_array_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair > extra_params_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collection_name_; + ::milvus::grpc::GeneralQuery* general_query_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_message_2eproto; +}; +// ------------------------------------------------------------------- + +class InsertOrDeleteMsg : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.InsertOrDeleteMsg) */ { + public: + InsertOrDeleteMsg(); + virtual ~InsertOrDeleteMsg(); + + InsertOrDeleteMsg(const InsertOrDeleteMsg& from); + InsertOrDeleteMsg(InsertOrDeleteMsg&& from) noexcept + : InsertOrDeleteMsg() { + *this = ::std::move(from); + } + + inline InsertOrDeleteMsg& operator=(const InsertOrDeleteMsg& from) { + CopyFrom(from); + return *this; + } + inline InsertOrDeleteMsg& operator=(InsertOrDeleteMsg&& from) noexcept { + if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const InsertOrDeleteMsg& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const InsertOrDeleteMsg* internal_default_instance() { + return reinterpret_cast( + &_InsertOrDeleteMsg_default_instance_); + } + static constexpr int kIndexInFileMessages = + 43; + + friend void swap(InsertOrDeleteMsg& a, InsertOrDeleteMsg& b) { + a.Swap(&b); + } + inline void Swap(InsertOrDeleteMsg* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline InsertOrDeleteMsg* New() const final { + return CreateMaybeMessage(nullptr); + } + + InsertOrDeleteMsg* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const InsertOrDeleteMsg& from); + void MergeFrom(const InsertOrDeleteMsg& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + #else + bool MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final; + #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + void SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final; + ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(InsertOrDeleteMsg* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.InsertOrDeleteMsg"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_message_2eproto); + return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kExtraParamsFieldNumber = 10, + kCollectionNameFieldNumber = 1, + kPartitionTagFieldNumber = 4, + kRowsDataFieldNumber = 2, + kUidFieldNumber = 3, + kTimestampFieldNumber = 5, + kSegmentIdFieldNumber = 6, + kChannelIdFieldNumber = 7, + kClientIdFieldNumber = 9, + kOpFieldNumber = 8, + }; + // repeated .milvus.grpc.KeyValuePair extra_params = 10; + int extra_params_size() const; + void clear_extra_params(); + ::milvus::grpc::KeyValuePair* mutable_extra_params(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >* + mutable_extra_params(); + const ::milvus::grpc::KeyValuePair& extra_params(int index) const; + ::milvus::grpc::KeyValuePair* add_extra_params(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >& + extra_params() const; + + // string collection_name = 1; + void clear_collection_name(); + const std::string& collection_name() const; + void set_collection_name(const std::string& value); + void set_collection_name(std::string&& value); + void set_collection_name(const char* value); + void set_collection_name(const char* value, size_t size); + std::string* mutable_collection_name(); + std::string* release_collection_name(); + void set_allocated_collection_name(std::string* collection_name); + + // string partition_tag = 4; + void clear_partition_tag(); + const std::string& partition_tag() const; + void set_partition_tag(const std::string& value); + void set_partition_tag(std::string&& value); + void set_partition_tag(const char* value); + void set_partition_tag(const char* value, size_t size); + std::string* mutable_partition_tag(); + std::string* release_partition_tag(); + void set_allocated_partition_tag(std::string* partition_tag); + + // .milvus.grpc.RowData rows_data = 2; + bool has_rows_data() const; + void clear_rows_data(); + const ::milvus::grpc::RowData& rows_data() const; + ::milvus::grpc::RowData* release_rows_data(); + ::milvus::grpc::RowData* mutable_rows_data(); + void set_allocated_rows_data(::milvus::grpc::RowData* rows_data); + + // int64 uid = 3; + void clear_uid(); + ::PROTOBUF_NAMESPACE_ID::int64 uid() const; + void set_uid(::PROTOBUF_NAMESPACE_ID::int64 value); + + // uint64 timestamp = 5; + void clear_timestamp(); + ::PROTOBUF_NAMESPACE_ID::uint64 timestamp() const; + void set_timestamp(::PROTOBUF_NAMESPACE_ID::uint64 value); + + // int64 segment_id = 6; + void clear_segment_id(); + ::PROTOBUF_NAMESPACE_ID::int64 segment_id() const; + void set_segment_id(::PROTOBUF_NAMESPACE_ID::int64 value); + + // int64 channel_id = 7; + void clear_channel_id(); + ::PROTOBUF_NAMESPACE_ID::int64 channel_id() const; + void set_channel_id(::PROTOBUF_NAMESPACE_ID::int64 value); + + // int64 client_id = 9; + void clear_client_id(); + ::PROTOBUF_NAMESPACE_ID::int64 client_id() const; + void set_client_id(::PROTOBUF_NAMESPACE_ID::int64 value); + + // .milvus.grpc.OpType op = 8; + void clear_op(); + ::milvus::grpc::OpType op() const; + void set_op(::milvus::grpc::OpType value); + + // @@protoc_insertion_point(class_scope:milvus.grpc.InsertOrDeleteMsg) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair > extra_params_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collection_name_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr partition_tag_; + ::milvus::grpc::RowData* rows_data_; + ::PROTOBUF_NAMESPACE_ID::int64 uid_; + ::PROTOBUF_NAMESPACE_ID::uint64 timestamp_; + ::PROTOBUF_NAMESPACE_ID::int64 segment_id_; + ::PROTOBUF_NAMESPACE_ID::int64 channel_id_; + ::PROTOBUF_NAMESPACE_ID::int64 client_id_; + int op_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_message_2eproto; +}; +// ------------------------------------------------------------------- + +class SearchMsg : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.SearchMsg) */ { + public: + SearchMsg(); + virtual ~SearchMsg(); + + SearchMsg(const SearchMsg& from); + SearchMsg(SearchMsg&& from) noexcept + : SearchMsg() { + *this = ::std::move(from); + } + + inline SearchMsg& operator=(const SearchMsg& from) { + CopyFrom(from); + return *this; + } + inline SearchMsg& operator=(SearchMsg&& from) noexcept { + if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const SearchMsg& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const SearchMsg* internal_default_instance() { + return reinterpret_cast( + &_SearchMsg_default_instance_); + } + static constexpr int kIndexInFileMessages = + 44; + + friend void swap(SearchMsg& a, SearchMsg& b) { + a.Swap(&b); + } + inline void Swap(SearchMsg* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline SearchMsg* New() const final { + return CreateMaybeMessage(nullptr); + } + + SearchMsg* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const SearchMsg& from); + void MergeFrom(const SearchMsg& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + #else + bool MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final; + #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + void SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final; + ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(SearchMsg* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.SearchMsg"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_message_2eproto); + return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kPartitionTagFieldNumber = 3, + kExtraParamsFieldNumber = 7, + kJsonFieldNumber = 8, + kCollectionNameFieldNumber = 1, + kDslFieldNumber = 9, + kRecordsFieldNumber = 2, + kUidFieldNumber = 4, + kTimestampFieldNumber = 5, + kClientIdFieldNumber = 6, + }; + // repeated string partition_tag = 3; + int partition_tag_size() const; + void clear_partition_tag(); + const std::string& partition_tag(int index) const; + std::string* mutable_partition_tag(int index); + void set_partition_tag(int index, const std::string& value); + void set_partition_tag(int index, std::string&& value); + void set_partition_tag(int index, const char* value); + void set_partition_tag(int index, const char* value, size_t size); + std::string* add_partition_tag(); + void add_partition_tag(const std::string& value); + void add_partition_tag(std::string&& value); + void add_partition_tag(const char* value); + void add_partition_tag(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& partition_tag() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_partition_tag(); + + // repeated .milvus.grpc.KeyValuePair extra_params = 7; + int extra_params_size() const; + void clear_extra_params(); + ::milvus::grpc::KeyValuePair* mutable_extra_params(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >* + mutable_extra_params(); + const ::milvus::grpc::KeyValuePair& extra_params(int index) const; + ::milvus::grpc::KeyValuePair* add_extra_params(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >& + extra_params() const; + + // repeated string json = 8; + int json_size() const; + void clear_json(); + const std::string& json(int index) const; + std::string* mutable_json(int index); + void set_json(int index, const std::string& value); + void set_json(int index, std::string&& value); + void set_json(int index, const char* value); + void set_json(int index, const char* value, size_t size); + std::string* add_json(); + void add_json(const std::string& value); + void add_json(std::string&& value); + void add_json(const char* value); + void add_json(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& json() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_json(); + + // string collection_name = 1; + void clear_collection_name(); + const std::string& collection_name() const; + void set_collection_name(const std::string& value); + void set_collection_name(std::string&& value); + void set_collection_name(const char* value); + void set_collection_name(const char* value, size_t size); + std::string* mutable_collection_name(); + std::string* release_collection_name(); + void set_allocated_collection_name(std::string* collection_name); + + // string dsl = 9; + void clear_dsl(); + const std::string& dsl() const; + void set_dsl(const std::string& value); + void set_dsl(std::string&& value); + void set_dsl(const char* value); + void set_dsl(const char* value, size_t size); + std::string* mutable_dsl(); + std::string* release_dsl(); + void set_allocated_dsl(std::string* dsl); + + // .milvus.grpc.VectorRowRecord records = 2; + bool has_records() const; + void clear_records(); + const ::milvus::grpc::VectorRowRecord& records() const; + ::milvus::grpc::VectorRowRecord* release_records(); + ::milvus::grpc::VectorRowRecord* mutable_records(); + void set_allocated_records(::milvus::grpc::VectorRowRecord* records); + + // int64 uid = 4; + void clear_uid(); + ::PROTOBUF_NAMESPACE_ID::int64 uid() const; + void set_uid(::PROTOBUF_NAMESPACE_ID::int64 value); + + // uint64 timestamp = 5; + void clear_timestamp(); + ::PROTOBUF_NAMESPACE_ID::uint64 timestamp() const; + void set_timestamp(::PROTOBUF_NAMESPACE_ID::uint64 value); + + // int64 client_id = 6; + void clear_client_id(); + ::PROTOBUF_NAMESPACE_ID::int64 client_id() const; + void set_client_id(::PROTOBUF_NAMESPACE_ID::int64 value); + + // @@protoc_insertion_point(class_scope:milvus.grpc.SearchMsg) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField partition_tag_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair > extra_params_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField json_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collection_name_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr dsl_; + ::milvus::grpc::VectorRowRecord* records_; + ::PROTOBUF_NAMESPACE_ID::int64 uid_; + ::PROTOBUF_NAMESPACE_ID::uint64 timestamp_; + ::PROTOBUF_NAMESPACE_ID::int64 client_id_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_message_2eproto; +}; +// ------------------------------------------------------------------- + +class TimeSyncMsg : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.TimeSyncMsg) */ { + public: + TimeSyncMsg(); + virtual ~TimeSyncMsg(); + + TimeSyncMsg(const TimeSyncMsg& from); + TimeSyncMsg(TimeSyncMsg&& from) noexcept + : TimeSyncMsg() { + *this = ::std::move(from); + } + + inline TimeSyncMsg& operator=(const TimeSyncMsg& from) { + CopyFrom(from); + return *this; + } + inline TimeSyncMsg& operator=(TimeSyncMsg&& from) noexcept { + if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const TimeSyncMsg& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const TimeSyncMsg* internal_default_instance() { + return reinterpret_cast( + &_TimeSyncMsg_default_instance_); + } + static constexpr int kIndexInFileMessages = + 45; + + friend void swap(TimeSyncMsg& a, TimeSyncMsg& b) { + a.Swap(&b); + } + inline void Swap(TimeSyncMsg* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline TimeSyncMsg* New() const final { + return CreateMaybeMessage(nullptr); + } + + TimeSyncMsg* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const TimeSyncMsg& from); + void MergeFrom(const TimeSyncMsg& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + #else + bool MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final; + #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + void SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final; + ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(TimeSyncMsg* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.TimeSyncMsg"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_message_2eproto); + return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kPeerIdFieldNumber = 1, + kTimestampFieldNumber = 2, + kSyncTypeFieldNumber = 3, + }; + // int64 peer_Id = 1; + void clear_peer_id(); + ::PROTOBUF_NAMESPACE_ID::int64 peer_id() const; + void set_peer_id(::PROTOBUF_NAMESPACE_ID::int64 value); + + // uint64 Timestamp = 2; + void clear_timestamp(); + ::PROTOBUF_NAMESPACE_ID::uint64 timestamp() const; + void set_timestamp(::PROTOBUF_NAMESPACE_ID::uint64 value); + + // .milvus.grpc.SyncType sync_type = 3; + void clear_sync_type(); + ::milvus::grpc::SyncType sync_type() const; + void set_sync_type(::milvus::grpc::SyncType value); + + // @@protoc_insertion_point(class_scope:milvus.grpc.TimeSyncMsg) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::int64 peer_id_; + ::PROTOBUF_NAMESPACE_ID::uint64 timestamp_; + int sync_type_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_message_2eproto; +}; +// ------------------------------------------------------------------- + +class Key2SegMsg : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.Key2SegMsg) */ { + public: + Key2SegMsg(); + virtual ~Key2SegMsg(); + + Key2SegMsg(const Key2SegMsg& from); + Key2SegMsg(Key2SegMsg&& from) noexcept + : Key2SegMsg() { + *this = ::std::move(from); + } + + inline Key2SegMsg& operator=(const Key2SegMsg& from) { + CopyFrom(from); + return *this; + } + inline Key2SegMsg& operator=(Key2SegMsg&& from) noexcept { + if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const Key2SegMsg& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const Key2SegMsg* internal_default_instance() { + return reinterpret_cast( + &_Key2SegMsg_default_instance_); + } + static constexpr int kIndexInFileMessages = + 46; + + friend void swap(Key2SegMsg& a, Key2SegMsg& b) { + a.Swap(&b); + } + inline void Swap(Key2SegMsg* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Key2SegMsg* New() const final { + return CreateMaybeMessage(nullptr); + } + + Key2SegMsg* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Key2SegMsg& from); + void MergeFrom(const Key2SegMsg& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + #else + bool MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final; + #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + void SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final; + ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Key2SegMsg* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.Key2SegMsg"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_message_2eproto); + return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kSegmentIdFieldNumber = 3, + kUidFieldNumber = 1, + kTimestampFieldNumber = 2, + }; + // repeated int64 segment_id = 3; + int segment_id_size() const; + void clear_segment_id(); + ::PROTOBUF_NAMESPACE_ID::int64 segment_id(int index) const; + void set_segment_id(int index, ::PROTOBUF_NAMESPACE_ID::int64 value); + void add_segment_id(::PROTOBUF_NAMESPACE_ID::int64 value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >& + segment_id() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >* + mutable_segment_id(); + + // int64 uid = 1; + void clear_uid(); + ::PROTOBUF_NAMESPACE_ID::int64 uid() const; + void set_uid(::PROTOBUF_NAMESPACE_ID::int64 value); + + // uint64 timestamp = 2; + void clear_timestamp(); + ::PROTOBUF_NAMESPACE_ID::uint64 timestamp() const; + void set_timestamp(::PROTOBUF_NAMESPACE_ID::uint64 value); + + // @@protoc_insertion_point(class_scope:milvus.grpc.Key2SegMsg) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > segment_id_; + mutable std::atomic _segment_id_cached_byte_size_; + ::PROTOBUF_NAMESPACE_ID::int64 uid_; + ::PROTOBUF_NAMESPACE_ID::uint64 timestamp_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_message_2eproto; +}; +// =================================================================== + + +// =================================================================== + +#ifdef __GNUC__ + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wstrict-aliasing" +#endif // __GNUC__ +// Status + +// .milvus.grpc.ErrorCode error_code = 1; +inline void Status::clear_error_code() { + error_code_ = 0; +} +inline ::milvus::grpc::ErrorCode Status::error_code() const { + // @@protoc_insertion_point(field_get:milvus.grpc.Status.error_code) + return static_cast< ::milvus::grpc::ErrorCode >(error_code_); +} +inline void Status::set_error_code(::milvus::grpc::ErrorCode value) { + + error_code_ = value; + // @@protoc_insertion_point(field_set:milvus.grpc.Status.error_code) +} + +// string reason = 2; +inline void Status::clear_reason() { + reason_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& Status::reason() const { + // @@protoc_insertion_point(field_get:milvus.grpc.Status.reason) + return reason_.GetNoArena(); +} +inline void Status::set_reason(const std::string& value) { + + reason_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.Status.reason) +} +inline void Status::set_reason(std::string&& value) { + + reason_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.Status.reason) +} +inline void Status::set_reason(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + reason_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.Status.reason) +} +inline void Status::set_reason(const char* value, size_t size) { + + reason_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.Status.reason) +} +inline std::string* Status::mutable_reason() { + + // @@protoc_insertion_point(field_mutable:milvus.grpc.Status.reason) + return reason_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* Status::release_reason() { + // @@protoc_insertion_point(field_release:milvus.grpc.Status.reason) + + return reason_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void Status::set_allocated_reason(std::string* reason) { + if (reason != nullptr) { + + } else { + + } + reason_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), reason); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.Status.reason) +} + +// ------------------------------------------------------------------- + +// KeyValuePair + +// string key = 1; +inline void KeyValuePair::clear_key() { + key_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& KeyValuePair::key() const { + // @@protoc_insertion_point(field_get:milvus.grpc.KeyValuePair.key) + return key_.GetNoArena(); +} +inline void KeyValuePair::set_key(const std::string& value) { + + key_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.KeyValuePair.key) +} +inline void KeyValuePair::set_key(std::string&& value) { + + key_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.KeyValuePair.key) +} +inline void KeyValuePair::set_key(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + key_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.KeyValuePair.key) +} +inline void KeyValuePair::set_key(const char* value, size_t size) { + + key_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.KeyValuePair.key) +} +inline std::string* KeyValuePair::mutable_key() { + + // @@protoc_insertion_point(field_mutable:milvus.grpc.KeyValuePair.key) + return key_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* KeyValuePair::release_key() { + // @@protoc_insertion_point(field_release:milvus.grpc.KeyValuePair.key) + + return key_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void KeyValuePair::set_allocated_key(std::string* key) { + if (key != nullptr) { + + } else { + + } + key_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), key); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.KeyValuePair.key) +} + +// string value = 2; +inline void KeyValuePair::clear_value() { + value_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& KeyValuePair::value() const { + // @@protoc_insertion_point(field_get:milvus.grpc.KeyValuePair.value) + return value_.GetNoArena(); +} +inline void KeyValuePair::set_value(const std::string& value) { + + value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.KeyValuePair.value) +} +inline void KeyValuePair::set_value(std::string&& value) { + + value_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.KeyValuePair.value) +} +inline void KeyValuePair::set_value(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.KeyValuePair.value) +} +inline void KeyValuePair::set_value(const char* value, size_t size) { + + value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.KeyValuePair.value) +} +inline std::string* KeyValuePair::mutable_value() { + + // @@protoc_insertion_point(field_mutable:milvus.grpc.KeyValuePair.value) + return value_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* KeyValuePair::release_value() { + // @@protoc_insertion_point(field_release:milvus.grpc.KeyValuePair.value) + + return value_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void KeyValuePair::set_allocated_value(std::string* value) { + if (value != nullptr) { + + } else { + + } + value_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.KeyValuePair.value) +} + +// ------------------------------------------------------------------- + +// CollectionName + +// string collection_name = 1; +inline void CollectionName::clear_collection_name() { + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& CollectionName::collection_name() const { + // @@protoc_insertion_point(field_get:milvus.grpc.CollectionName.collection_name) + return collection_name_.GetNoArena(); +} +inline void CollectionName::set_collection_name(const std::string& value) { + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.CollectionName.collection_name) +} +inline void CollectionName::set_collection_name(std::string&& value) { + + collection_name_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.CollectionName.collection_name) +} +inline void CollectionName::set_collection_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.CollectionName.collection_name) +} +inline void CollectionName::set_collection_name(const char* value, size_t size) { + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.CollectionName.collection_name) +} +inline std::string* CollectionName::mutable_collection_name() { + + // @@protoc_insertion_point(field_mutable:milvus.grpc.CollectionName.collection_name) + return collection_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* CollectionName::release_collection_name() { + // @@protoc_insertion_point(field_release:milvus.grpc.CollectionName.collection_name) + + return collection_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void CollectionName::set_allocated_collection_name(std::string* collection_name) { + if (collection_name != nullptr) { + + } else { + + } + collection_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), collection_name); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.CollectionName.collection_name) +} + +// ------------------------------------------------------------------- + +// CollectionNameList + +// .milvus.grpc.Status status = 1; +inline bool CollectionNameList::has_status() const { + return this != internal_default_instance() && status_ != nullptr; +} +inline void CollectionNameList::clear_status() { + if (GetArenaNoVirtual() == nullptr && status_ != nullptr) { + delete status_; + } + status_ = nullptr; +} +inline const ::milvus::grpc::Status& CollectionNameList::status() const { + const ::milvus::grpc::Status* p = status_; + // @@protoc_insertion_point(field_get:milvus.grpc.CollectionNameList.status) + return p != nullptr ? *p : *reinterpret_cast( + &::milvus::grpc::_Status_default_instance_); +} +inline ::milvus::grpc::Status* CollectionNameList::release_status() { + // @@protoc_insertion_point(field_release:milvus.grpc.CollectionNameList.status) + + ::milvus::grpc::Status* temp = status_; + status_ = nullptr; + return temp; +} +inline ::milvus::grpc::Status* CollectionNameList::mutable_status() { + + if (status_ == nullptr) { + auto* p = CreateMaybeMessage<::milvus::grpc::Status>(GetArenaNoVirtual()); + status_ = p; + } + // @@protoc_insertion_point(field_mutable:milvus.grpc.CollectionNameList.status) + return status_; +} +inline void CollectionNameList::set_allocated_status(::milvus::grpc::Status* status) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete status_; + } + if (status) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + status = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, status, submessage_arena); + } + + } else { + + } + status_ = status; + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.CollectionNameList.status) +} + +// repeated string collection_names = 2; +inline int CollectionNameList::collection_names_size() const { + return collection_names_.size(); +} +inline void CollectionNameList::clear_collection_names() { + collection_names_.Clear(); +} +inline const std::string& CollectionNameList::collection_names(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.CollectionNameList.collection_names) + return collection_names_.Get(index); +} +inline std::string* CollectionNameList::mutable_collection_names(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.CollectionNameList.collection_names) + return collection_names_.Mutable(index); +} +inline void CollectionNameList::set_collection_names(int index, const std::string& value) { + // @@protoc_insertion_point(field_set:milvus.grpc.CollectionNameList.collection_names) + collection_names_.Mutable(index)->assign(value); +} +inline void CollectionNameList::set_collection_names(int index, std::string&& value) { + // @@protoc_insertion_point(field_set:milvus.grpc.CollectionNameList.collection_names) + collection_names_.Mutable(index)->assign(std::move(value)); +} +inline void CollectionNameList::set_collection_names(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + collection_names_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:milvus.grpc.CollectionNameList.collection_names) +} +inline void CollectionNameList::set_collection_names(int index, const char* value, size_t size) { + collection_names_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.CollectionNameList.collection_names) +} +inline std::string* CollectionNameList::add_collection_names() { + // @@protoc_insertion_point(field_add_mutable:milvus.grpc.CollectionNameList.collection_names) + return collection_names_.Add(); +} +inline void CollectionNameList::add_collection_names(const std::string& value) { + collection_names_.Add()->assign(value); + // @@protoc_insertion_point(field_add:milvus.grpc.CollectionNameList.collection_names) +} +inline void CollectionNameList::add_collection_names(std::string&& value) { + collection_names_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:milvus.grpc.CollectionNameList.collection_names) +} +inline void CollectionNameList::add_collection_names(const char* value) { + GOOGLE_DCHECK(value != nullptr); + collection_names_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:milvus.grpc.CollectionNameList.collection_names) +} +inline void CollectionNameList::add_collection_names(const char* value, size_t size) { + collection_names_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:milvus.grpc.CollectionNameList.collection_names) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +CollectionNameList::collection_names() const { + // @@protoc_insertion_point(field_list:milvus.grpc.CollectionNameList.collection_names) + return collection_names_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +CollectionNameList::mutable_collection_names() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.CollectionNameList.collection_names) + return &collection_names_; +} + +// ------------------------------------------------------------------- + +// FieldName + +// string collection_name = 1; +inline void FieldName::clear_collection_name() { + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& FieldName::collection_name() const { + // @@protoc_insertion_point(field_get:milvus.grpc.FieldName.collection_name) + return collection_name_.GetNoArena(); +} +inline void FieldName::set_collection_name(const std::string& value) { + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.FieldName.collection_name) +} +inline void FieldName::set_collection_name(std::string&& value) { + + collection_name_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.FieldName.collection_name) +} +inline void FieldName::set_collection_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.FieldName.collection_name) +} +inline void FieldName::set_collection_name(const char* value, size_t size) { + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.FieldName.collection_name) +} +inline std::string* FieldName::mutable_collection_name() { + + // @@protoc_insertion_point(field_mutable:milvus.grpc.FieldName.collection_name) + return collection_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* FieldName::release_collection_name() { + // @@protoc_insertion_point(field_release:milvus.grpc.FieldName.collection_name) + + return collection_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void FieldName::set_allocated_collection_name(std::string* collection_name) { + if (collection_name != nullptr) { + + } else { + + } + collection_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), collection_name); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.FieldName.collection_name) +} + +// string field_name = 2; +inline void FieldName::clear_field_name() { + field_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& FieldName::field_name() const { + // @@protoc_insertion_point(field_get:milvus.grpc.FieldName.field_name) + return field_name_.GetNoArena(); +} +inline void FieldName::set_field_name(const std::string& value) { + + field_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.FieldName.field_name) +} +inline void FieldName::set_field_name(std::string&& value) { + + field_name_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.FieldName.field_name) +} +inline void FieldName::set_field_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + field_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.FieldName.field_name) +} +inline void FieldName::set_field_name(const char* value, size_t size) { + + field_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.FieldName.field_name) +} +inline std::string* FieldName::mutable_field_name() { + + // @@protoc_insertion_point(field_mutable:milvus.grpc.FieldName.field_name) + return field_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* FieldName::release_field_name() { + // @@protoc_insertion_point(field_release:milvus.grpc.FieldName.field_name) + + return field_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void FieldName::set_allocated_field_name(std::string* field_name) { + if (field_name != nullptr) { + + } else { + + } + field_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), field_name); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.FieldName.field_name) +} + +// ------------------------------------------------------------------- + +// Mapping + +// .milvus.grpc.Status status = 1; +inline bool Mapping::has_status() const { + return this != internal_default_instance() && status_ != nullptr; +} +inline void Mapping::clear_status() { + if (GetArenaNoVirtual() == nullptr && status_ != nullptr) { + delete status_; + } + status_ = nullptr; +} +inline const ::milvus::grpc::Status& Mapping::status() const { + const ::milvus::grpc::Status* p = status_; + // @@protoc_insertion_point(field_get:milvus.grpc.Mapping.status) + return p != nullptr ? *p : *reinterpret_cast( + &::milvus::grpc::_Status_default_instance_); +} +inline ::milvus::grpc::Status* Mapping::release_status() { + // @@protoc_insertion_point(field_release:milvus.grpc.Mapping.status) + + ::milvus::grpc::Status* temp = status_; + status_ = nullptr; + return temp; +} +inline ::milvus::grpc::Status* Mapping::mutable_status() { + + if (status_ == nullptr) { + auto* p = CreateMaybeMessage<::milvus::grpc::Status>(GetArenaNoVirtual()); + status_ = p; + } + // @@protoc_insertion_point(field_mutable:milvus.grpc.Mapping.status) + return status_; +} +inline void Mapping::set_allocated_status(::milvus::grpc::Status* status) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete status_; + } + if (status) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + status = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, status, submessage_arena); + } + + } else { + + } + status_ = status; + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.Mapping.status) +} + +// string collection_name = 2; +inline void Mapping::clear_collection_name() { + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& Mapping::collection_name() const { + // @@protoc_insertion_point(field_get:milvus.grpc.Mapping.collection_name) + return collection_name_.GetNoArena(); +} +inline void Mapping::set_collection_name(const std::string& value) { + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.Mapping.collection_name) +} +inline void Mapping::set_collection_name(std::string&& value) { + + collection_name_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.Mapping.collection_name) +} +inline void Mapping::set_collection_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.Mapping.collection_name) +} +inline void Mapping::set_collection_name(const char* value, size_t size) { + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.Mapping.collection_name) +} +inline std::string* Mapping::mutable_collection_name() { + + // @@protoc_insertion_point(field_mutable:milvus.grpc.Mapping.collection_name) + return collection_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* Mapping::release_collection_name() { + // @@protoc_insertion_point(field_release:milvus.grpc.Mapping.collection_name) + + return collection_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void Mapping::set_allocated_collection_name(std::string* collection_name) { + if (collection_name != nullptr) { + + } else { + + } + collection_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), collection_name); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.Mapping.collection_name) +} + +// .milvus.grpc.Schema schema = 3; +inline bool Mapping::has_schema() const { + return this != internal_default_instance() && schema_ != nullptr; +} +inline void Mapping::clear_schema() { + if (GetArenaNoVirtual() == nullptr && schema_ != nullptr) { + delete schema_; + } + schema_ = nullptr; +} +inline const ::milvus::grpc::Schema& Mapping::schema() const { + const ::milvus::grpc::Schema* p = schema_; + // @@protoc_insertion_point(field_get:milvus.grpc.Mapping.schema) + return p != nullptr ? *p : *reinterpret_cast( + &::milvus::grpc::_Schema_default_instance_); +} +inline ::milvus::grpc::Schema* Mapping::release_schema() { + // @@protoc_insertion_point(field_release:milvus.grpc.Mapping.schema) + + ::milvus::grpc::Schema* temp = schema_; + schema_ = nullptr; + return temp; +} +inline ::milvus::grpc::Schema* Mapping::mutable_schema() { + + if (schema_ == nullptr) { + auto* p = CreateMaybeMessage<::milvus::grpc::Schema>(GetArenaNoVirtual()); + schema_ = p; + } + // @@protoc_insertion_point(field_mutable:milvus.grpc.Mapping.schema) + return schema_; +} +inline void Mapping::set_allocated_schema(::milvus::grpc::Schema* schema) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete schema_; + } + if (schema) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + schema = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, schema, submessage_arena); + } + + } else { + + } + schema_ = schema; + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.Mapping.schema) +} + +// repeated .milvus.grpc.KeyValuePair extra_params = 4; +inline int Mapping::extra_params_size() const { + return extra_params_.size(); +} +inline void Mapping::clear_extra_params() { + extra_params_.Clear(); +} +inline ::milvus::grpc::KeyValuePair* Mapping::mutable_extra_params(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.Mapping.extra_params) + return extra_params_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >* +Mapping::mutable_extra_params() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.Mapping.extra_params) + return &extra_params_; +} +inline const ::milvus::grpc::KeyValuePair& Mapping::extra_params(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.Mapping.extra_params) + return extra_params_.Get(index); +} +inline ::milvus::grpc::KeyValuePair* Mapping::add_extra_params() { + // @@protoc_insertion_point(field_add:milvus.grpc.Mapping.extra_params) + return extra_params_.Add(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >& +Mapping::extra_params() const { + // @@protoc_insertion_point(field_list:milvus.grpc.Mapping.extra_params) + return extra_params_; +} + +// ------------------------------------------------------------------- + +// MappingList + +// .milvus.grpc.Status status = 1; +inline bool MappingList::has_status() const { + return this != internal_default_instance() && status_ != nullptr; +} +inline void MappingList::clear_status() { + if (GetArenaNoVirtual() == nullptr && status_ != nullptr) { + delete status_; + } + status_ = nullptr; +} +inline const ::milvus::grpc::Status& MappingList::status() const { + const ::milvus::grpc::Status* p = status_; + // @@protoc_insertion_point(field_get:milvus.grpc.MappingList.status) + return p != nullptr ? *p : *reinterpret_cast( + &::milvus::grpc::_Status_default_instance_); +} +inline ::milvus::grpc::Status* MappingList::release_status() { + // @@protoc_insertion_point(field_release:milvus.grpc.MappingList.status) + + ::milvus::grpc::Status* temp = status_; + status_ = nullptr; + return temp; +} +inline ::milvus::grpc::Status* MappingList::mutable_status() { + + if (status_ == nullptr) { + auto* p = CreateMaybeMessage<::milvus::grpc::Status>(GetArenaNoVirtual()); + status_ = p; + } + // @@protoc_insertion_point(field_mutable:milvus.grpc.MappingList.status) + return status_; +} +inline void MappingList::set_allocated_status(::milvus::grpc::Status* status) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete status_; + } + if (status) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + status = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, status, submessage_arena); + } + + } else { + + } + status_ = status; + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.MappingList.status) +} + +// repeated .milvus.grpc.Mapping mapping_list = 2; +inline int MappingList::mapping_list_size() const { + return mapping_list_.size(); +} +inline void MappingList::clear_mapping_list() { + mapping_list_.Clear(); +} +inline ::milvus::grpc::Mapping* MappingList::mutable_mapping_list(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.MappingList.mapping_list) + return mapping_list_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::Mapping >* +MappingList::mutable_mapping_list() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.MappingList.mapping_list) + return &mapping_list_; +} +inline const ::milvus::grpc::Mapping& MappingList::mapping_list(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.MappingList.mapping_list) + return mapping_list_.Get(index); +} +inline ::milvus::grpc::Mapping* MappingList::add_mapping_list() { + // @@protoc_insertion_point(field_add:milvus.grpc.MappingList.mapping_list) + return mapping_list_.Add(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::Mapping >& +MappingList::mapping_list() const { + // @@protoc_insertion_point(field_list:milvus.grpc.MappingList.mapping_list) + return mapping_list_; +} + +// ------------------------------------------------------------------- + +// PartitionParam + +// string collection_name = 1; +inline void PartitionParam::clear_collection_name() { + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& PartitionParam::collection_name() const { + // @@protoc_insertion_point(field_get:milvus.grpc.PartitionParam.collection_name) + return collection_name_.GetNoArena(); +} +inline void PartitionParam::set_collection_name(const std::string& value) { + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.PartitionParam.collection_name) +} +inline void PartitionParam::set_collection_name(std::string&& value) { + + collection_name_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.PartitionParam.collection_name) +} +inline void PartitionParam::set_collection_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.PartitionParam.collection_name) +} +inline void PartitionParam::set_collection_name(const char* value, size_t size) { + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.PartitionParam.collection_name) +} +inline std::string* PartitionParam::mutable_collection_name() { + + // @@protoc_insertion_point(field_mutable:milvus.grpc.PartitionParam.collection_name) + return collection_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* PartitionParam::release_collection_name() { + // @@protoc_insertion_point(field_release:milvus.grpc.PartitionParam.collection_name) + + return collection_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void PartitionParam::set_allocated_collection_name(std::string* collection_name) { + if (collection_name != nullptr) { + + } else { + + } + collection_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), collection_name); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.PartitionParam.collection_name) +} + +// string tag = 2; +inline void PartitionParam::clear_tag() { + tag_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& PartitionParam::tag() const { + // @@protoc_insertion_point(field_get:milvus.grpc.PartitionParam.tag) + return tag_.GetNoArena(); +} +inline void PartitionParam::set_tag(const std::string& value) { + + tag_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.PartitionParam.tag) +} +inline void PartitionParam::set_tag(std::string&& value) { + + tag_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.PartitionParam.tag) +} +inline void PartitionParam::set_tag(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + tag_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.PartitionParam.tag) +} +inline void PartitionParam::set_tag(const char* value, size_t size) { + + tag_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.PartitionParam.tag) +} +inline std::string* PartitionParam::mutable_tag() { + + // @@protoc_insertion_point(field_mutable:milvus.grpc.PartitionParam.tag) + return tag_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* PartitionParam::release_tag() { + // @@protoc_insertion_point(field_release:milvus.grpc.PartitionParam.tag) + + return tag_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void PartitionParam::set_allocated_tag(std::string* tag) { + if (tag != nullptr) { + + } else { + + } + tag_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), tag); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.PartitionParam.tag) +} + +// ------------------------------------------------------------------- + +// PartitionList + +// .milvus.grpc.Status status = 1; +inline bool PartitionList::has_status() const { + return this != internal_default_instance() && status_ != nullptr; +} +inline void PartitionList::clear_status() { + if (GetArenaNoVirtual() == nullptr && status_ != nullptr) { + delete status_; + } + status_ = nullptr; +} +inline const ::milvus::grpc::Status& PartitionList::status() const { + const ::milvus::grpc::Status* p = status_; + // @@protoc_insertion_point(field_get:milvus.grpc.PartitionList.status) + return p != nullptr ? *p : *reinterpret_cast( + &::milvus::grpc::_Status_default_instance_); +} +inline ::milvus::grpc::Status* PartitionList::release_status() { + // @@protoc_insertion_point(field_release:milvus.grpc.PartitionList.status) + + ::milvus::grpc::Status* temp = status_; + status_ = nullptr; + return temp; +} +inline ::milvus::grpc::Status* PartitionList::mutable_status() { + + if (status_ == nullptr) { + auto* p = CreateMaybeMessage<::milvus::grpc::Status>(GetArenaNoVirtual()); + status_ = p; + } + // @@protoc_insertion_point(field_mutable:milvus.grpc.PartitionList.status) + return status_; +} +inline void PartitionList::set_allocated_status(::milvus::grpc::Status* status) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete status_; + } + if (status) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + status = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, status, submessage_arena); + } + + } else { + + } + status_ = status; + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.PartitionList.status) +} + +// repeated string partition_tag_array = 2; +inline int PartitionList::partition_tag_array_size() const { + return partition_tag_array_.size(); +} +inline void PartitionList::clear_partition_tag_array() { + partition_tag_array_.Clear(); +} +inline const std::string& PartitionList::partition_tag_array(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.PartitionList.partition_tag_array) + return partition_tag_array_.Get(index); +} +inline std::string* PartitionList::mutable_partition_tag_array(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.PartitionList.partition_tag_array) + return partition_tag_array_.Mutable(index); +} +inline void PartitionList::set_partition_tag_array(int index, const std::string& value) { + // @@protoc_insertion_point(field_set:milvus.grpc.PartitionList.partition_tag_array) + partition_tag_array_.Mutable(index)->assign(value); +} +inline void PartitionList::set_partition_tag_array(int index, std::string&& value) { + // @@protoc_insertion_point(field_set:milvus.grpc.PartitionList.partition_tag_array) + partition_tag_array_.Mutable(index)->assign(std::move(value)); +} +inline void PartitionList::set_partition_tag_array(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + partition_tag_array_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:milvus.grpc.PartitionList.partition_tag_array) +} +inline void PartitionList::set_partition_tag_array(int index, const char* value, size_t size) { + partition_tag_array_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.PartitionList.partition_tag_array) +} +inline std::string* PartitionList::add_partition_tag_array() { + // @@protoc_insertion_point(field_add_mutable:milvus.grpc.PartitionList.partition_tag_array) + return partition_tag_array_.Add(); +} +inline void PartitionList::add_partition_tag_array(const std::string& value) { + partition_tag_array_.Add()->assign(value); + // @@protoc_insertion_point(field_add:milvus.grpc.PartitionList.partition_tag_array) +} +inline void PartitionList::add_partition_tag_array(std::string&& value) { + partition_tag_array_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:milvus.grpc.PartitionList.partition_tag_array) +} +inline void PartitionList::add_partition_tag_array(const char* value) { + GOOGLE_DCHECK(value != nullptr); + partition_tag_array_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:milvus.grpc.PartitionList.partition_tag_array) +} +inline void PartitionList::add_partition_tag_array(const char* value, size_t size) { + partition_tag_array_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:milvus.grpc.PartitionList.partition_tag_array) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +PartitionList::partition_tag_array() const { + // @@protoc_insertion_point(field_list:milvus.grpc.PartitionList.partition_tag_array) + return partition_tag_array_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +PartitionList::mutable_partition_tag_array() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.PartitionList.partition_tag_array) + return &partition_tag_array_; +} + +// ------------------------------------------------------------------- + +// VectorRowRecord + +// repeated float float_data = 1; +inline int VectorRowRecord::float_data_size() const { + return float_data_.size(); +} +inline void VectorRowRecord::clear_float_data() { + float_data_.Clear(); +} +inline float VectorRowRecord::float_data(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.VectorRowRecord.float_data) + return float_data_.Get(index); +} +inline void VectorRowRecord::set_float_data(int index, float value) { + float_data_.Set(index, value); + // @@protoc_insertion_point(field_set:milvus.grpc.VectorRowRecord.float_data) +} +inline void VectorRowRecord::add_float_data(float value) { + float_data_.Add(value); + // @@protoc_insertion_point(field_add:milvus.grpc.VectorRowRecord.float_data) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& +VectorRowRecord::float_data() const { + // @@protoc_insertion_point(field_list:milvus.grpc.VectorRowRecord.float_data) + return float_data_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* +VectorRowRecord::mutable_float_data() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.VectorRowRecord.float_data) + return &float_data_; +} + +// bytes binary_data = 2; +inline void VectorRowRecord::clear_binary_data() { + binary_data_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& VectorRowRecord::binary_data() const { + // @@protoc_insertion_point(field_get:milvus.grpc.VectorRowRecord.binary_data) + return binary_data_.GetNoArena(); +} +inline void VectorRowRecord::set_binary_data(const std::string& value) { + + binary_data_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.VectorRowRecord.binary_data) +} +inline void VectorRowRecord::set_binary_data(std::string&& value) { + + binary_data_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.VectorRowRecord.binary_data) +} +inline void VectorRowRecord::set_binary_data(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + binary_data_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.VectorRowRecord.binary_data) +} +inline void VectorRowRecord::set_binary_data(const void* value, size_t size) { + + binary_data_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.VectorRowRecord.binary_data) +} +inline std::string* VectorRowRecord::mutable_binary_data() { + + // @@protoc_insertion_point(field_mutable:milvus.grpc.VectorRowRecord.binary_data) + return binary_data_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* VectorRowRecord::release_binary_data() { + // @@protoc_insertion_point(field_release:milvus.grpc.VectorRowRecord.binary_data) + + return binary_data_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void VectorRowRecord::set_allocated_binary_data(std::string* binary_data) { + if (binary_data != nullptr) { + + } else { + + } + binary_data_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), binary_data); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.VectorRowRecord.binary_data) +} + +// ------------------------------------------------------------------- + +// EntityIds + +// .milvus.grpc.Status status = 1; +inline bool EntityIds::has_status() const { + return this != internal_default_instance() && status_ != nullptr; +} +inline void EntityIds::clear_status() { + if (GetArenaNoVirtual() == nullptr && status_ != nullptr) { + delete status_; + } + status_ = nullptr; +} +inline const ::milvus::grpc::Status& EntityIds::status() const { + const ::milvus::grpc::Status* p = status_; + // @@protoc_insertion_point(field_get:milvus.grpc.EntityIds.status) + return p != nullptr ? *p : *reinterpret_cast( + &::milvus::grpc::_Status_default_instance_); +} +inline ::milvus::grpc::Status* EntityIds::release_status() { + // @@protoc_insertion_point(field_release:milvus.grpc.EntityIds.status) + + ::milvus::grpc::Status* temp = status_; + status_ = nullptr; + return temp; +} +inline ::milvus::grpc::Status* EntityIds::mutable_status() { + + if (status_ == nullptr) { + auto* p = CreateMaybeMessage<::milvus::grpc::Status>(GetArenaNoVirtual()); + status_ = p; + } + // @@protoc_insertion_point(field_mutable:milvus.grpc.EntityIds.status) + return status_; +} +inline void EntityIds::set_allocated_status(::milvus::grpc::Status* status) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete status_; + } + if (status) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + status = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, status, submessage_arena); + } + + } else { + + } + status_ = status; + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.EntityIds.status) +} + +// repeated int64 entity_id_array = 2; +inline int EntityIds::entity_id_array_size() const { + return entity_id_array_.size(); +} +inline void EntityIds::clear_entity_id_array() { + entity_id_array_.Clear(); +} +inline ::PROTOBUF_NAMESPACE_ID::int64 EntityIds::entity_id_array(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.EntityIds.entity_id_array) + return entity_id_array_.Get(index); +} +inline void EntityIds::set_entity_id_array(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) { + entity_id_array_.Set(index, value); + // @@protoc_insertion_point(field_set:milvus.grpc.EntityIds.entity_id_array) +} +inline void EntityIds::add_entity_id_array(::PROTOBUF_NAMESPACE_ID::int64 value) { + entity_id_array_.Add(value); + // @@protoc_insertion_point(field_add:milvus.grpc.EntityIds.entity_id_array) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >& +EntityIds::entity_id_array() const { + // @@protoc_insertion_point(field_list:milvus.grpc.EntityIds.entity_id_array) + return entity_id_array_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >* +EntityIds::mutable_entity_id_array() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.EntityIds.entity_id_array) + return &entity_id_array_; +} + +// ------------------------------------------------------------------- + +// VectorRecord + +// repeated .milvus.grpc.VectorRowRecord records = 1; +inline int VectorRecord::records_size() const { + return records_.size(); +} +inline void VectorRecord::clear_records() { + records_.Clear(); +} +inline ::milvus::grpc::VectorRowRecord* VectorRecord::mutable_records(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.VectorRecord.records) + return records_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::VectorRowRecord >* +VectorRecord::mutable_records() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.VectorRecord.records) + return &records_; +} +inline const ::milvus::grpc::VectorRowRecord& VectorRecord::records(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.VectorRecord.records) + return records_.Get(index); +} +inline ::milvus::grpc::VectorRowRecord* VectorRecord::add_records() { + // @@protoc_insertion_point(field_add:milvus.grpc.VectorRecord.records) + return records_.Add(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::VectorRowRecord >& +VectorRecord::records() const { + // @@protoc_insertion_point(field_list:milvus.grpc.VectorRecord.records) + return records_; +} + +// ------------------------------------------------------------------- + +// VectorParam + +// string json = 1; +inline void VectorParam::clear_json() { + json_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& VectorParam::json() const { + // @@protoc_insertion_point(field_get:milvus.grpc.VectorParam.json) + return json_.GetNoArena(); +} +inline void VectorParam::set_json(const std::string& value) { + + json_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.VectorParam.json) +} +inline void VectorParam::set_json(std::string&& value) { + + json_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.VectorParam.json) +} +inline void VectorParam::set_json(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + json_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.VectorParam.json) +} +inline void VectorParam::set_json(const char* value, size_t size) { + + json_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.VectorParam.json) +} +inline std::string* VectorParam::mutable_json() { + + // @@protoc_insertion_point(field_mutable:milvus.grpc.VectorParam.json) + return json_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* VectorParam::release_json() { + // @@protoc_insertion_point(field_release:milvus.grpc.VectorParam.json) + + return json_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void VectorParam::set_allocated_json(std::string* json) { + if (json != nullptr) { + + } else { + + } + json_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), json); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.VectorParam.json) +} + +// .milvus.grpc.VectorRecord row_record = 2; +inline bool VectorParam::has_row_record() const { + return this != internal_default_instance() && row_record_ != nullptr; +} +inline void VectorParam::clear_row_record() { + if (GetArenaNoVirtual() == nullptr && row_record_ != nullptr) { + delete row_record_; + } + row_record_ = nullptr; +} +inline const ::milvus::grpc::VectorRecord& VectorParam::row_record() const { + const ::milvus::grpc::VectorRecord* p = row_record_; + // @@protoc_insertion_point(field_get:milvus.grpc.VectorParam.row_record) + return p != nullptr ? *p : *reinterpret_cast( + &::milvus::grpc::_VectorRecord_default_instance_); +} +inline ::milvus::grpc::VectorRecord* VectorParam::release_row_record() { + // @@protoc_insertion_point(field_release:milvus.grpc.VectorParam.row_record) + + ::milvus::grpc::VectorRecord* temp = row_record_; + row_record_ = nullptr; + return temp; +} +inline ::milvus::grpc::VectorRecord* VectorParam::mutable_row_record() { + + if (row_record_ == nullptr) { + auto* p = CreateMaybeMessage<::milvus::grpc::VectorRecord>(GetArenaNoVirtual()); + row_record_ = p; + } + // @@protoc_insertion_point(field_mutable:milvus.grpc.VectorParam.row_record) + return row_record_; +} +inline void VectorParam::set_allocated_row_record(::milvus::grpc::VectorRecord* row_record) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete row_record_; + } + if (row_record) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + row_record = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, row_record, submessage_arena); + } + + } else { + + } + row_record_ = row_record; + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.VectorParam.row_record) +} + +// ------------------------------------------------------------------- + +// FieldMeta + +// string field_name = 1; +inline void FieldMeta::clear_field_name() { + field_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& FieldMeta::field_name() const { + // @@protoc_insertion_point(field_get:milvus.grpc.FieldMeta.field_name) + return field_name_.GetNoArena(); +} +inline void FieldMeta::set_field_name(const std::string& value) { + + field_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.FieldMeta.field_name) +} +inline void FieldMeta::set_field_name(std::string&& value) { + + field_name_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.FieldMeta.field_name) +} +inline void FieldMeta::set_field_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + field_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.FieldMeta.field_name) +} +inline void FieldMeta::set_field_name(const char* value, size_t size) { + + field_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.FieldMeta.field_name) +} +inline std::string* FieldMeta::mutable_field_name() { + + // @@protoc_insertion_point(field_mutable:milvus.grpc.FieldMeta.field_name) + return field_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* FieldMeta::release_field_name() { + // @@protoc_insertion_point(field_release:milvus.grpc.FieldMeta.field_name) + + return field_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void FieldMeta::set_allocated_field_name(std::string* field_name) { + if (field_name != nullptr) { + + } else { + + } + field_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), field_name); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.FieldMeta.field_name) +} + +// .milvus.grpc.DataType type = 2; +inline void FieldMeta::clear_type() { + type_ = 0; +} +inline ::milvus::grpc::DataType FieldMeta::type() const { + // @@protoc_insertion_point(field_get:milvus.grpc.FieldMeta.type) + return static_cast< ::milvus::grpc::DataType >(type_); +} +inline void FieldMeta::set_type(::milvus::grpc::DataType value) { + + type_ = value; + // @@protoc_insertion_point(field_set:milvus.grpc.FieldMeta.type) +} + +// int64 dim = 3; +inline void FieldMeta::clear_dim() { + dim_ = PROTOBUF_LONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::int64 FieldMeta::dim() const { + // @@protoc_insertion_point(field_get:milvus.grpc.FieldMeta.dim) + return dim_; +} +inline void FieldMeta::set_dim(::PROTOBUF_NAMESPACE_ID::int64 value) { + + dim_ = value; + // @@protoc_insertion_point(field_set:milvus.grpc.FieldMeta.dim) +} + +// ------------------------------------------------------------------- + +// Schema + +// repeated .milvus.grpc.FieldMeta field_metas = 1; +inline int Schema::field_metas_size() const { + return field_metas_.size(); +} +inline void Schema::clear_field_metas() { + field_metas_.Clear(); +} +inline ::milvus::grpc::FieldMeta* Schema::mutable_field_metas(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.Schema.field_metas) + return field_metas_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::FieldMeta >* +Schema::mutable_field_metas() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.Schema.field_metas) + return &field_metas_; +} +inline const ::milvus::grpc::FieldMeta& Schema::field_metas(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.Schema.field_metas) + return field_metas_.Get(index); +} +inline ::milvus::grpc::FieldMeta* Schema::add_field_metas() { + // @@protoc_insertion_point(field_add:milvus.grpc.Schema.field_metas) + return field_metas_.Add(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::FieldMeta >& +Schema::field_metas() const { + // @@protoc_insertion_point(field_list:milvus.grpc.Schema.field_metas) + return field_metas_; +} + +// ------------------------------------------------------------------- + +// RowData + +// bytes blob = 1; +inline void RowData::clear_blob() { + blob_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& RowData::blob() const { + // @@protoc_insertion_point(field_get:milvus.grpc.RowData.blob) + return blob_.GetNoArena(); +} +inline void RowData::set_blob(const std::string& value) { + + blob_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.RowData.blob) +} +inline void RowData::set_blob(std::string&& value) { + + blob_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.RowData.blob) +} +inline void RowData::set_blob(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + blob_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.RowData.blob) +} +inline void RowData::set_blob(const void* value, size_t size) { + + blob_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.RowData.blob) +} +inline std::string* RowData::mutable_blob() { + + // @@protoc_insertion_point(field_mutable:milvus.grpc.RowData.blob) + return blob_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* RowData::release_blob() { + // @@protoc_insertion_point(field_release:milvus.grpc.RowData.blob) + + return blob_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void RowData::set_allocated_blob(std::string* blob) { + if (blob != nullptr) { + + } else { + + } + blob_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), blob); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.RowData.blob) +} + +// ------------------------------------------------------------------- + +// InsertParam + +// string collection_name = 1; +inline void InsertParam::clear_collection_name() { + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& InsertParam::collection_name() const { + // @@protoc_insertion_point(field_get:milvus.grpc.InsertParam.collection_name) + return collection_name_.GetNoArena(); +} +inline void InsertParam::set_collection_name(const std::string& value) { + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.InsertParam.collection_name) +} +inline void InsertParam::set_collection_name(std::string&& value) { + + collection_name_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.InsertParam.collection_name) +} +inline void InsertParam::set_collection_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.InsertParam.collection_name) +} +inline void InsertParam::set_collection_name(const char* value, size_t size) { + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.InsertParam.collection_name) +} +inline std::string* InsertParam::mutable_collection_name() { + + // @@protoc_insertion_point(field_mutable:milvus.grpc.InsertParam.collection_name) + return collection_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* InsertParam::release_collection_name() { + // @@protoc_insertion_point(field_release:milvus.grpc.InsertParam.collection_name) + + return collection_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void InsertParam::set_allocated_collection_name(std::string* collection_name) { + if (collection_name != nullptr) { + + } else { + + } + collection_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), collection_name); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.InsertParam.collection_name) +} + +// .milvus.grpc.Schema schema = 2; +inline bool InsertParam::has_schema() const { + return this != internal_default_instance() && schema_ != nullptr; +} +inline void InsertParam::clear_schema() { + if (GetArenaNoVirtual() == nullptr && schema_ != nullptr) { + delete schema_; + } + schema_ = nullptr; +} +inline const ::milvus::grpc::Schema& InsertParam::schema() const { + const ::milvus::grpc::Schema* p = schema_; + // @@protoc_insertion_point(field_get:milvus.grpc.InsertParam.schema) + return p != nullptr ? *p : *reinterpret_cast( + &::milvus::grpc::_Schema_default_instance_); +} +inline ::milvus::grpc::Schema* InsertParam::release_schema() { + // @@protoc_insertion_point(field_release:milvus.grpc.InsertParam.schema) + + ::milvus::grpc::Schema* temp = schema_; + schema_ = nullptr; + return temp; +} +inline ::milvus::grpc::Schema* InsertParam::mutable_schema() { + + if (schema_ == nullptr) { + auto* p = CreateMaybeMessage<::milvus::grpc::Schema>(GetArenaNoVirtual()); + schema_ = p; + } + // @@protoc_insertion_point(field_mutable:milvus.grpc.InsertParam.schema) + return schema_; +} +inline void InsertParam::set_allocated_schema(::milvus::grpc::Schema* schema) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete schema_; + } + if (schema) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + schema = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, schema, submessage_arena); + } + + } else { + + } + schema_ = schema; + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.InsertParam.schema) +} + +// repeated .milvus.grpc.RowData rows_data = 3; +inline int InsertParam::rows_data_size() const { + return rows_data_.size(); +} +inline void InsertParam::clear_rows_data() { + rows_data_.Clear(); +} +inline ::milvus::grpc::RowData* InsertParam::mutable_rows_data(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.InsertParam.rows_data) + return rows_data_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::RowData >* +InsertParam::mutable_rows_data() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.InsertParam.rows_data) + return &rows_data_; +} +inline const ::milvus::grpc::RowData& InsertParam::rows_data(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.InsertParam.rows_data) + return rows_data_.Get(index); +} +inline ::milvus::grpc::RowData* InsertParam::add_rows_data() { + // @@protoc_insertion_point(field_add:milvus.grpc.InsertParam.rows_data) + return rows_data_.Add(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::RowData >& +InsertParam::rows_data() const { + // @@protoc_insertion_point(field_list:milvus.grpc.InsertParam.rows_data) + return rows_data_; +} + +// repeated int64 entity_id_array = 4; +inline int InsertParam::entity_id_array_size() const { + return entity_id_array_.size(); +} +inline void InsertParam::clear_entity_id_array() { + entity_id_array_.Clear(); +} +inline ::PROTOBUF_NAMESPACE_ID::int64 InsertParam::entity_id_array(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.InsertParam.entity_id_array) + return entity_id_array_.Get(index); +} +inline void InsertParam::set_entity_id_array(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) { + entity_id_array_.Set(index, value); + // @@protoc_insertion_point(field_set:milvus.grpc.InsertParam.entity_id_array) +} +inline void InsertParam::add_entity_id_array(::PROTOBUF_NAMESPACE_ID::int64 value) { + entity_id_array_.Add(value); + // @@protoc_insertion_point(field_add:milvus.grpc.InsertParam.entity_id_array) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >& +InsertParam::entity_id_array() const { + // @@protoc_insertion_point(field_list:milvus.grpc.InsertParam.entity_id_array) + return entity_id_array_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >* +InsertParam::mutable_entity_id_array() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.InsertParam.entity_id_array) + return &entity_id_array_; +} + +// string partition_tag = 5; +inline void InsertParam::clear_partition_tag() { + partition_tag_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& InsertParam::partition_tag() const { + // @@protoc_insertion_point(field_get:milvus.grpc.InsertParam.partition_tag) + return partition_tag_.GetNoArena(); +} +inline void InsertParam::set_partition_tag(const std::string& value) { + + partition_tag_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.InsertParam.partition_tag) +} +inline void InsertParam::set_partition_tag(std::string&& value) { + + partition_tag_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.InsertParam.partition_tag) +} +inline void InsertParam::set_partition_tag(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + partition_tag_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.InsertParam.partition_tag) +} +inline void InsertParam::set_partition_tag(const char* value, size_t size) { + + partition_tag_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.InsertParam.partition_tag) +} +inline std::string* InsertParam::mutable_partition_tag() { + + // @@protoc_insertion_point(field_mutable:milvus.grpc.InsertParam.partition_tag) + return partition_tag_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* InsertParam::release_partition_tag() { + // @@protoc_insertion_point(field_release:milvus.grpc.InsertParam.partition_tag) + + return partition_tag_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void InsertParam::set_allocated_partition_tag(std::string* partition_tag) { + if (partition_tag != nullptr) { + + } else { + + } + partition_tag_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), partition_tag); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.InsertParam.partition_tag) +} + +// repeated .milvus.grpc.KeyValuePair extra_params = 6; +inline int InsertParam::extra_params_size() const { + return extra_params_.size(); +} +inline void InsertParam::clear_extra_params() { + extra_params_.Clear(); +} +inline ::milvus::grpc::KeyValuePair* InsertParam::mutable_extra_params(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.InsertParam.extra_params) + return extra_params_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >* +InsertParam::mutable_extra_params() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.InsertParam.extra_params) + return &extra_params_; +} +inline const ::milvus::grpc::KeyValuePair& InsertParam::extra_params(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.InsertParam.extra_params) + return extra_params_.Get(index); +} +inline ::milvus::grpc::KeyValuePair* InsertParam::add_extra_params() { + // @@protoc_insertion_point(field_add:milvus.grpc.InsertParam.extra_params) + return extra_params_.Add(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >& +InsertParam::extra_params() const { + // @@protoc_insertion_point(field_list:milvus.grpc.InsertParam.extra_params) + return extra_params_; +} + +// ------------------------------------------------------------------- + +// SearchParam + +// string collection_name = 1; +inline void SearchParam::clear_collection_name() { + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& SearchParam::collection_name() const { + // @@protoc_insertion_point(field_get:milvus.grpc.SearchParam.collection_name) + return collection_name_.GetNoArena(); +} +inline void SearchParam::set_collection_name(const std::string& value) { + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.SearchParam.collection_name) +} +inline void SearchParam::set_collection_name(std::string&& value) { + + collection_name_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.SearchParam.collection_name) +} +inline void SearchParam::set_collection_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.SearchParam.collection_name) +} +inline void SearchParam::set_collection_name(const char* value, size_t size) { + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.SearchParam.collection_name) +} +inline std::string* SearchParam::mutable_collection_name() { + + // @@protoc_insertion_point(field_mutable:milvus.grpc.SearchParam.collection_name) + return collection_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* SearchParam::release_collection_name() { + // @@protoc_insertion_point(field_release:milvus.grpc.SearchParam.collection_name) + + return collection_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void SearchParam::set_allocated_collection_name(std::string* collection_name) { + if (collection_name != nullptr) { + + } else { + + } + collection_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), collection_name); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.SearchParam.collection_name) +} + +// repeated .milvus.grpc.VectorParam vector_param = 2; +inline int SearchParam::vector_param_size() const { + return vector_param_.size(); +} +inline void SearchParam::clear_vector_param() { + vector_param_.Clear(); +} +inline ::milvus::grpc::VectorParam* SearchParam::mutable_vector_param(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.SearchParam.vector_param) + return vector_param_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::VectorParam >* +SearchParam::mutable_vector_param() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.SearchParam.vector_param) + return &vector_param_; +} +inline const ::milvus::grpc::VectorParam& SearchParam::vector_param(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.SearchParam.vector_param) + return vector_param_.Get(index); +} +inline ::milvus::grpc::VectorParam* SearchParam::add_vector_param() { + // @@protoc_insertion_point(field_add:milvus.grpc.SearchParam.vector_param) + return vector_param_.Add(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::VectorParam >& +SearchParam::vector_param() const { + // @@protoc_insertion_point(field_list:milvus.grpc.SearchParam.vector_param) + return vector_param_; +} + +// string dsl = 3; +inline void SearchParam::clear_dsl() { + dsl_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& SearchParam::dsl() const { + // @@protoc_insertion_point(field_get:milvus.grpc.SearchParam.dsl) + return dsl_.GetNoArena(); +} +inline void SearchParam::set_dsl(const std::string& value) { + + dsl_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.SearchParam.dsl) +} +inline void SearchParam::set_dsl(std::string&& value) { + + dsl_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.SearchParam.dsl) +} +inline void SearchParam::set_dsl(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + dsl_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.SearchParam.dsl) +} +inline void SearchParam::set_dsl(const char* value, size_t size) { + + dsl_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.SearchParam.dsl) +} +inline std::string* SearchParam::mutable_dsl() { + + // @@protoc_insertion_point(field_mutable:milvus.grpc.SearchParam.dsl) + return dsl_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* SearchParam::release_dsl() { + // @@protoc_insertion_point(field_release:milvus.grpc.SearchParam.dsl) + + return dsl_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void SearchParam::set_allocated_dsl(std::string* dsl) { + if (dsl != nullptr) { + + } else { + + } + dsl_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), dsl); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.SearchParam.dsl) +} + +// repeated string partition_tag = 4; +inline int SearchParam::partition_tag_size() const { + return partition_tag_.size(); +} +inline void SearchParam::clear_partition_tag() { + partition_tag_.Clear(); +} +inline const std::string& SearchParam::partition_tag(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.SearchParam.partition_tag) + return partition_tag_.Get(index); +} +inline std::string* SearchParam::mutable_partition_tag(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.SearchParam.partition_tag) + return partition_tag_.Mutable(index); +} +inline void SearchParam::set_partition_tag(int index, const std::string& value) { + // @@protoc_insertion_point(field_set:milvus.grpc.SearchParam.partition_tag) + partition_tag_.Mutable(index)->assign(value); +} +inline void SearchParam::set_partition_tag(int index, std::string&& value) { + // @@protoc_insertion_point(field_set:milvus.grpc.SearchParam.partition_tag) + partition_tag_.Mutable(index)->assign(std::move(value)); +} +inline void SearchParam::set_partition_tag(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + partition_tag_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:milvus.grpc.SearchParam.partition_tag) +} +inline void SearchParam::set_partition_tag(int index, const char* value, size_t size) { + partition_tag_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.SearchParam.partition_tag) +} +inline std::string* SearchParam::add_partition_tag() { + // @@protoc_insertion_point(field_add_mutable:milvus.grpc.SearchParam.partition_tag) + return partition_tag_.Add(); +} +inline void SearchParam::add_partition_tag(const std::string& value) { + partition_tag_.Add()->assign(value); + // @@protoc_insertion_point(field_add:milvus.grpc.SearchParam.partition_tag) +} +inline void SearchParam::add_partition_tag(std::string&& value) { + partition_tag_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:milvus.grpc.SearchParam.partition_tag) +} +inline void SearchParam::add_partition_tag(const char* value) { + GOOGLE_DCHECK(value != nullptr); + partition_tag_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:milvus.grpc.SearchParam.partition_tag) +} +inline void SearchParam::add_partition_tag(const char* value, size_t size) { + partition_tag_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:milvus.grpc.SearchParam.partition_tag) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +SearchParam::partition_tag() const { + // @@protoc_insertion_point(field_list:milvus.grpc.SearchParam.partition_tag) + return partition_tag_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +SearchParam::mutable_partition_tag() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.SearchParam.partition_tag) + return &partition_tag_; +} + +// repeated .milvus.grpc.KeyValuePair extra_params = 5; +inline int SearchParam::extra_params_size() const { + return extra_params_.size(); +} +inline void SearchParam::clear_extra_params() { + extra_params_.Clear(); +} +inline ::milvus::grpc::KeyValuePair* SearchParam::mutable_extra_params(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.SearchParam.extra_params) + return extra_params_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >* +SearchParam::mutable_extra_params() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.SearchParam.extra_params) + return &extra_params_; +} +inline const ::milvus::grpc::KeyValuePair& SearchParam::extra_params(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.SearchParam.extra_params) + return extra_params_.Get(index); +} +inline ::milvus::grpc::KeyValuePair* SearchParam::add_extra_params() { + // @@protoc_insertion_point(field_add:milvus.grpc.SearchParam.extra_params) + return extra_params_.Add(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >& +SearchParam::extra_params() const { + // @@protoc_insertion_point(field_list:milvus.grpc.SearchParam.extra_params) + return extra_params_; +} + +// ------------------------------------------------------------------- + +// SearchInSegmentParam + +// repeated string file_id_array = 1; +inline int SearchInSegmentParam::file_id_array_size() const { + return file_id_array_.size(); +} +inline void SearchInSegmentParam::clear_file_id_array() { + file_id_array_.Clear(); +} +inline const std::string& SearchInSegmentParam::file_id_array(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.SearchInSegmentParam.file_id_array) + return file_id_array_.Get(index); +} +inline std::string* SearchInSegmentParam::mutable_file_id_array(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.SearchInSegmentParam.file_id_array) + return file_id_array_.Mutable(index); +} +inline void SearchInSegmentParam::set_file_id_array(int index, const std::string& value) { + // @@protoc_insertion_point(field_set:milvus.grpc.SearchInSegmentParam.file_id_array) + file_id_array_.Mutable(index)->assign(value); +} +inline void SearchInSegmentParam::set_file_id_array(int index, std::string&& value) { + // @@protoc_insertion_point(field_set:milvus.grpc.SearchInSegmentParam.file_id_array) + file_id_array_.Mutable(index)->assign(std::move(value)); +} +inline void SearchInSegmentParam::set_file_id_array(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + file_id_array_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:milvus.grpc.SearchInSegmentParam.file_id_array) +} +inline void SearchInSegmentParam::set_file_id_array(int index, const char* value, size_t size) { + file_id_array_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.SearchInSegmentParam.file_id_array) +} +inline std::string* SearchInSegmentParam::add_file_id_array() { + // @@protoc_insertion_point(field_add_mutable:milvus.grpc.SearchInSegmentParam.file_id_array) + return file_id_array_.Add(); +} +inline void SearchInSegmentParam::add_file_id_array(const std::string& value) { + file_id_array_.Add()->assign(value); + // @@protoc_insertion_point(field_add:milvus.grpc.SearchInSegmentParam.file_id_array) +} +inline void SearchInSegmentParam::add_file_id_array(std::string&& value) { + file_id_array_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:milvus.grpc.SearchInSegmentParam.file_id_array) +} +inline void SearchInSegmentParam::add_file_id_array(const char* value) { + GOOGLE_DCHECK(value != nullptr); + file_id_array_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:milvus.grpc.SearchInSegmentParam.file_id_array) +} +inline void SearchInSegmentParam::add_file_id_array(const char* value, size_t size) { + file_id_array_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:milvus.grpc.SearchInSegmentParam.file_id_array) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +SearchInSegmentParam::file_id_array() const { + // @@protoc_insertion_point(field_list:milvus.grpc.SearchInSegmentParam.file_id_array) + return file_id_array_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +SearchInSegmentParam::mutable_file_id_array() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.SearchInSegmentParam.file_id_array) + return &file_id_array_; +} + +// .milvus.grpc.SearchParam search_param = 2; +inline bool SearchInSegmentParam::has_search_param() const { + return this != internal_default_instance() && search_param_ != nullptr; +} +inline void SearchInSegmentParam::clear_search_param() { + if (GetArenaNoVirtual() == nullptr && search_param_ != nullptr) { + delete search_param_; + } + search_param_ = nullptr; +} +inline const ::milvus::grpc::SearchParam& SearchInSegmentParam::search_param() const { + const ::milvus::grpc::SearchParam* p = search_param_; + // @@protoc_insertion_point(field_get:milvus.grpc.SearchInSegmentParam.search_param) + return p != nullptr ? *p : *reinterpret_cast( + &::milvus::grpc::_SearchParam_default_instance_); +} +inline ::milvus::grpc::SearchParam* SearchInSegmentParam::release_search_param() { + // @@protoc_insertion_point(field_release:milvus.grpc.SearchInSegmentParam.search_param) + + ::milvus::grpc::SearchParam* temp = search_param_; + search_param_ = nullptr; + return temp; +} +inline ::milvus::grpc::SearchParam* SearchInSegmentParam::mutable_search_param() { + + if (search_param_ == nullptr) { + auto* p = CreateMaybeMessage<::milvus::grpc::SearchParam>(GetArenaNoVirtual()); + search_param_ = p; + } + // @@protoc_insertion_point(field_mutable:milvus.grpc.SearchInSegmentParam.search_param) + return search_param_; +} +inline void SearchInSegmentParam::set_allocated_search_param(::milvus::grpc::SearchParam* search_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete search_param_; + } + if (search_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + search_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, search_param, submessage_arena); + } + + } else { + + } + search_param_ = search_param; + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.SearchInSegmentParam.search_param) +} + +// ------------------------------------------------------------------- + +// Entities + +// .milvus.grpc.Status status = 1; +inline bool Entities::has_status() const { + return this != internal_default_instance() && status_ != nullptr; +} +inline void Entities::clear_status() { + if (GetArenaNoVirtual() == nullptr && status_ != nullptr) { + delete status_; + } + status_ = nullptr; +} +inline const ::milvus::grpc::Status& Entities::status() const { + const ::milvus::grpc::Status* p = status_; + // @@protoc_insertion_point(field_get:milvus.grpc.Entities.status) + return p != nullptr ? *p : *reinterpret_cast( + &::milvus::grpc::_Status_default_instance_); +} +inline ::milvus::grpc::Status* Entities::release_status() { + // @@protoc_insertion_point(field_release:milvus.grpc.Entities.status) + + ::milvus::grpc::Status* temp = status_; + status_ = nullptr; + return temp; +} +inline ::milvus::grpc::Status* Entities::mutable_status() { + + if (status_ == nullptr) { + auto* p = CreateMaybeMessage<::milvus::grpc::Status>(GetArenaNoVirtual()); + status_ = p; + } + // @@protoc_insertion_point(field_mutable:milvus.grpc.Entities.status) + return status_; +} +inline void Entities::set_allocated_status(::milvus::grpc::Status* status) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete status_; + } + if (status) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + status = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, status, submessage_arena); + } + + } else { + + } + status_ = status; + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.Entities.status) +} + +// repeated int64 ids = 2; +inline int Entities::ids_size() const { + return ids_.size(); +} +inline void Entities::clear_ids() { + ids_.Clear(); +} +inline ::PROTOBUF_NAMESPACE_ID::int64 Entities::ids(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.Entities.ids) + return ids_.Get(index); +} +inline void Entities::set_ids(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) { + ids_.Set(index, value); + // @@protoc_insertion_point(field_set:milvus.grpc.Entities.ids) +} +inline void Entities::add_ids(::PROTOBUF_NAMESPACE_ID::int64 value) { + ids_.Add(value); + // @@protoc_insertion_point(field_add:milvus.grpc.Entities.ids) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >& +Entities::ids() const { + // @@protoc_insertion_point(field_list:milvus.grpc.Entities.ids) + return ids_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >* +Entities::mutable_ids() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.Entities.ids) + return &ids_; +} + +// repeated bool valid_row = 3; +inline int Entities::valid_row_size() const { + return valid_row_.size(); +} +inline void Entities::clear_valid_row() { + valid_row_.Clear(); +} +inline bool Entities::valid_row(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.Entities.valid_row) + return valid_row_.Get(index); +} +inline void Entities::set_valid_row(int index, bool value) { + valid_row_.Set(index, value); + // @@protoc_insertion_point(field_set:milvus.grpc.Entities.valid_row) +} +inline void Entities::add_valid_row(bool value) { + valid_row_.Add(value); + // @@protoc_insertion_point(field_add:milvus.grpc.Entities.valid_row) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >& +Entities::valid_row() const { + // @@protoc_insertion_point(field_list:milvus.grpc.Entities.valid_row) + return valid_row_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >* +Entities::mutable_valid_row() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.Entities.valid_row) + return &valid_row_; +} + +// repeated .milvus.grpc.RowData rows_data = 4; +inline int Entities::rows_data_size() const { + return rows_data_.size(); +} +inline void Entities::clear_rows_data() { + rows_data_.Clear(); +} +inline ::milvus::grpc::RowData* Entities::mutable_rows_data(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.Entities.rows_data) + return rows_data_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::RowData >* +Entities::mutable_rows_data() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.Entities.rows_data) + return &rows_data_; +} +inline const ::milvus::grpc::RowData& Entities::rows_data(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.Entities.rows_data) + return rows_data_.Get(index); +} +inline ::milvus::grpc::RowData* Entities::add_rows_data() { + // @@protoc_insertion_point(field_add:milvus.grpc.Entities.rows_data) + return rows_data_.Add(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::RowData >& +Entities::rows_data() const { + // @@protoc_insertion_point(field_list:milvus.grpc.Entities.rows_data) + return rows_data_; +} + +// ------------------------------------------------------------------- + +// QueryResult + +// .milvus.grpc.Status status = 1; +inline bool QueryResult::has_status() const { + return this != internal_default_instance() && status_ != nullptr; +} +inline void QueryResult::clear_status() { + if (GetArenaNoVirtual() == nullptr && status_ != nullptr) { + delete status_; + } + status_ = nullptr; +} +inline const ::milvus::grpc::Status& QueryResult::status() const { + const ::milvus::grpc::Status* p = status_; + // @@protoc_insertion_point(field_get:milvus.grpc.QueryResult.status) + return p != nullptr ? *p : *reinterpret_cast( + &::milvus::grpc::_Status_default_instance_); +} +inline ::milvus::grpc::Status* QueryResult::release_status() { + // @@protoc_insertion_point(field_release:milvus.grpc.QueryResult.status) + + ::milvus::grpc::Status* temp = status_; + status_ = nullptr; + return temp; +} +inline ::milvus::grpc::Status* QueryResult::mutable_status() { + + if (status_ == nullptr) { + auto* p = CreateMaybeMessage<::milvus::grpc::Status>(GetArenaNoVirtual()); + status_ = p; + } + // @@protoc_insertion_point(field_mutable:milvus.grpc.QueryResult.status) + return status_; +} +inline void QueryResult::set_allocated_status(::milvus::grpc::Status* status) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete status_; + } + if (status) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + status = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, status, submessage_arena); + } + + } else { + + } + status_ = status; + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.QueryResult.status) +} + +// .milvus.grpc.Entities entities = 2; +inline bool QueryResult::has_entities() const { + return this != internal_default_instance() && entities_ != nullptr; +} +inline void QueryResult::clear_entities() { + if (GetArenaNoVirtual() == nullptr && entities_ != nullptr) { + delete entities_; + } + entities_ = nullptr; +} +inline const ::milvus::grpc::Entities& QueryResult::entities() const { + const ::milvus::grpc::Entities* p = entities_; + // @@protoc_insertion_point(field_get:milvus.grpc.QueryResult.entities) + return p != nullptr ? *p : *reinterpret_cast( + &::milvus::grpc::_Entities_default_instance_); +} +inline ::milvus::grpc::Entities* QueryResult::release_entities() { + // @@protoc_insertion_point(field_release:milvus.grpc.QueryResult.entities) + + ::milvus::grpc::Entities* temp = entities_; + entities_ = nullptr; + return temp; +} +inline ::milvus::grpc::Entities* QueryResult::mutable_entities() { + + if (entities_ == nullptr) { + auto* p = CreateMaybeMessage<::milvus::grpc::Entities>(GetArenaNoVirtual()); + entities_ = p; + } + // @@protoc_insertion_point(field_mutable:milvus.grpc.QueryResult.entities) + return entities_; +} +inline void QueryResult::set_allocated_entities(::milvus::grpc::Entities* entities) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete entities_; + } + if (entities) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + entities = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, entities, submessage_arena); + } + + } else { + + } + entities_ = entities; + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.QueryResult.entities) +} + +// int64 row_num = 3; +inline void QueryResult::clear_row_num() { + row_num_ = PROTOBUF_LONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::int64 QueryResult::row_num() const { + // @@protoc_insertion_point(field_get:milvus.grpc.QueryResult.row_num) + return row_num_; +} +inline void QueryResult::set_row_num(::PROTOBUF_NAMESPACE_ID::int64 value) { + + row_num_ = value; + // @@protoc_insertion_point(field_set:milvus.grpc.QueryResult.row_num) +} + +// repeated float scores = 4; +inline int QueryResult::scores_size() const { + return scores_.size(); +} +inline void QueryResult::clear_scores() { + scores_.Clear(); +} +inline float QueryResult::scores(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.QueryResult.scores) + return scores_.Get(index); +} +inline void QueryResult::set_scores(int index, float value) { + scores_.Set(index, value); + // @@protoc_insertion_point(field_set:milvus.grpc.QueryResult.scores) +} +inline void QueryResult::add_scores(float value) { + scores_.Add(value); + // @@protoc_insertion_point(field_add:milvus.grpc.QueryResult.scores) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& +QueryResult::scores() const { + // @@protoc_insertion_point(field_list:milvus.grpc.QueryResult.scores) + return scores_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* +QueryResult::mutable_scores() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.QueryResult.scores) + return &scores_; +} + +// repeated float distances = 5; +inline int QueryResult::distances_size() const { + return distances_.size(); +} +inline void QueryResult::clear_distances() { + distances_.Clear(); +} +inline float QueryResult::distances(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.QueryResult.distances) + return distances_.Get(index); +} +inline void QueryResult::set_distances(int index, float value) { + distances_.Set(index, value); + // @@protoc_insertion_point(field_set:milvus.grpc.QueryResult.distances) +} +inline void QueryResult::add_distances(float value) { + distances_.Add(value); + // @@protoc_insertion_point(field_add:milvus.grpc.QueryResult.distances) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& +QueryResult::distances() const { + // @@protoc_insertion_point(field_list:milvus.grpc.QueryResult.distances) + return distances_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* +QueryResult::mutable_distances() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.QueryResult.distances) + return &distances_; +} + +// repeated .milvus.grpc.KeyValuePair extra_params = 6; +inline int QueryResult::extra_params_size() const { + return extra_params_.size(); +} +inline void QueryResult::clear_extra_params() { + extra_params_.Clear(); +} +inline ::milvus::grpc::KeyValuePair* QueryResult::mutable_extra_params(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.QueryResult.extra_params) + return extra_params_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >* +QueryResult::mutable_extra_params() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.QueryResult.extra_params) + return &extra_params_; +} +inline const ::milvus::grpc::KeyValuePair& QueryResult::extra_params(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.QueryResult.extra_params) + return extra_params_.Get(index); +} +inline ::milvus::grpc::KeyValuePair* QueryResult::add_extra_params() { + // @@protoc_insertion_point(field_add:milvus.grpc.QueryResult.extra_params) + return extra_params_.Add(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >& +QueryResult::extra_params() const { + // @@protoc_insertion_point(field_list:milvus.grpc.QueryResult.extra_params) + return extra_params_; +} + +// int64 query_id = 7; +inline void QueryResult::clear_query_id() { + query_id_ = PROTOBUF_LONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::int64 QueryResult::query_id() const { + // @@protoc_insertion_point(field_get:milvus.grpc.QueryResult.query_id) + return query_id_; +} +inline void QueryResult::set_query_id(::PROTOBUF_NAMESPACE_ID::int64 value) { + + query_id_ = value; + // @@protoc_insertion_point(field_set:milvus.grpc.QueryResult.query_id) +} + +// int64 client_id = 8; +inline void QueryResult::clear_client_id() { + client_id_ = PROTOBUF_LONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::int64 QueryResult::client_id() const { + // @@protoc_insertion_point(field_get:milvus.grpc.QueryResult.client_id) + return client_id_; +} +inline void QueryResult::set_client_id(::PROTOBUF_NAMESPACE_ID::int64 value) { + + client_id_ = value; + // @@protoc_insertion_point(field_set:milvus.grpc.QueryResult.client_id) +} + +// ------------------------------------------------------------------- + +// StringReply + +// .milvus.grpc.Status status = 1; +inline bool StringReply::has_status() const { + return this != internal_default_instance() && status_ != nullptr; +} +inline void StringReply::clear_status() { + if (GetArenaNoVirtual() == nullptr && status_ != nullptr) { + delete status_; + } + status_ = nullptr; +} +inline const ::milvus::grpc::Status& StringReply::status() const { + const ::milvus::grpc::Status* p = status_; + // @@protoc_insertion_point(field_get:milvus.grpc.StringReply.status) + return p != nullptr ? *p : *reinterpret_cast( + &::milvus::grpc::_Status_default_instance_); +} +inline ::milvus::grpc::Status* StringReply::release_status() { + // @@protoc_insertion_point(field_release:milvus.grpc.StringReply.status) + + ::milvus::grpc::Status* temp = status_; + status_ = nullptr; + return temp; +} +inline ::milvus::grpc::Status* StringReply::mutable_status() { + + if (status_ == nullptr) { + auto* p = CreateMaybeMessage<::milvus::grpc::Status>(GetArenaNoVirtual()); + status_ = p; + } + // @@protoc_insertion_point(field_mutable:milvus.grpc.StringReply.status) + return status_; +} +inline void StringReply::set_allocated_status(::milvus::grpc::Status* status) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete status_; + } + if (status) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + status = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, status, submessage_arena); + } + + } else { + + } + status_ = status; + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.StringReply.status) +} + +// string string_reply = 2; +inline void StringReply::clear_string_reply() { + string_reply_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& StringReply::string_reply() const { + // @@protoc_insertion_point(field_get:milvus.grpc.StringReply.string_reply) + return string_reply_.GetNoArena(); +} +inline void StringReply::set_string_reply(const std::string& value) { + + string_reply_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.StringReply.string_reply) +} +inline void StringReply::set_string_reply(std::string&& value) { + + string_reply_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.StringReply.string_reply) +} +inline void StringReply::set_string_reply(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + string_reply_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.StringReply.string_reply) +} +inline void StringReply::set_string_reply(const char* value, size_t size) { + + string_reply_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.StringReply.string_reply) +} +inline std::string* StringReply::mutable_string_reply() { + + // @@protoc_insertion_point(field_mutable:milvus.grpc.StringReply.string_reply) + return string_reply_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* StringReply::release_string_reply() { + // @@protoc_insertion_point(field_release:milvus.grpc.StringReply.string_reply) + + return string_reply_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void StringReply::set_allocated_string_reply(std::string* string_reply) { + if (string_reply != nullptr) { + + } else { + + } + string_reply_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), string_reply); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.StringReply.string_reply) +} + +// ------------------------------------------------------------------- + +// BoolReply + +// .milvus.grpc.Status status = 1; +inline bool BoolReply::has_status() const { + return this != internal_default_instance() && status_ != nullptr; +} +inline void BoolReply::clear_status() { + if (GetArenaNoVirtual() == nullptr && status_ != nullptr) { + delete status_; + } + status_ = nullptr; +} +inline const ::milvus::grpc::Status& BoolReply::status() const { + const ::milvus::grpc::Status* p = status_; + // @@protoc_insertion_point(field_get:milvus.grpc.BoolReply.status) + return p != nullptr ? *p : *reinterpret_cast( + &::milvus::grpc::_Status_default_instance_); +} +inline ::milvus::grpc::Status* BoolReply::release_status() { + // @@protoc_insertion_point(field_release:milvus.grpc.BoolReply.status) + + ::milvus::grpc::Status* temp = status_; + status_ = nullptr; + return temp; +} +inline ::milvus::grpc::Status* BoolReply::mutable_status() { + + if (status_ == nullptr) { + auto* p = CreateMaybeMessage<::milvus::grpc::Status>(GetArenaNoVirtual()); + status_ = p; + } + // @@protoc_insertion_point(field_mutable:milvus.grpc.BoolReply.status) + return status_; +} +inline void BoolReply::set_allocated_status(::milvus::grpc::Status* status) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete status_; + } + if (status) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + status = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, status, submessage_arena); + } + + } else { + + } + status_ = status; + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.BoolReply.status) +} + +// bool bool_reply = 2; +inline void BoolReply::clear_bool_reply() { + bool_reply_ = false; +} +inline bool BoolReply::bool_reply() const { + // @@protoc_insertion_point(field_get:milvus.grpc.BoolReply.bool_reply) + return bool_reply_; +} +inline void BoolReply::set_bool_reply(bool value) { + + bool_reply_ = value; + // @@protoc_insertion_point(field_set:milvus.grpc.BoolReply.bool_reply) +} + +// ------------------------------------------------------------------- + +// CollectionRowCount + +// .milvus.grpc.Status status = 1; +inline bool CollectionRowCount::has_status() const { + return this != internal_default_instance() && status_ != nullptr; +} +inline void CollectionRowCount::clear_status() { + if (GetArenaNoVirtual() == nullptr && status_ != nullptr) { + delete status_; + } + status_ = nullptr; +} +inline const ::milvus::grpc::Status& CollectionRowCount::status() const { + const ::milvus::grpc::Status* p = status_; + // @@protoc_insertion_point(field_get:milvus.grpc.CollectionRowCount.status) + return p != nullptr ? *p : *reinterpret_cast( + &::milvus::grpc::_Status_default_instance_); +} +inline ::milvus::grpc::Status* CollectionRowCount::release_status() { + // @@protoc_insertion_point(field_release:milvus.grpc.CollectionRowCount.status) + + ::milvus::grpc::Status* temp = status_; + status_ = nullptr; + return temp; +} +inline ::milvus::grpc::Status* CollectionRowCount::mutable_status() { + + if (status_ == nullptr) { + auto* p = CreateMaybeMessage<::milvus::grpc::Status>(GetArenaNoVirtual()); + status_ = p; + } + // @@protoc_insertion_point(field_mutable:milvus.grpc.CollectionRowCount.status) + return status_; +} +inline void CollectionRowCount::set_allocated_status(::milvus::grpc::Status* status) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete status_; + } + if (status) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + status = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, status, submessage_arena); + } + + } else { + + } + status_ = status; + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.CollectionRowCount.status) +} + +// int64 collection_row_count = 2; +inline void CollectionRowCount::clear_collection_row_count() { + collection_row_count_ = PROTOBUF_LONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::int64 CollectionRowCount::collection_row_count() const { + // @@protoc_insertion_point(field_get:milvus.grpc.CollectionRowCount.collection_row_count) + return collection_row_count_; +} +inline void CollectionRowCount::set_collection_row_count(::PROTOBUF_NAMESPACE_ID::int64 value) { + + collection_row_count_ = value; + // @@protoc_insertion_point(field_set:milvus.grpc.CollectionRowCount.collection_row_count) +} + +// ------------------------------------------------------------------- + +// Command + +// string cmd = 1; +inline void Command::clear_cmd() { + cmd_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& Command::cmd() const { + // @@protoc_insertion_point(field_get:milvus.grpc.Command.cmd) + return cmd_.GetNoArena(); +} +inline void Command::set_cmd(const std::string& value) { + + cmd_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.Command.cmd) +} +inline void Command::set_cmd(std::string&& value) { + + cmd_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.Command.cmd) +} +inline void Command::set_cmd(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + cmd_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.Command.cmd) +} +inline void Command::set_cmd(const char* value, size_t size) { + + cmd_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.Command.cmd) +} +inline std::string* Command::mutable_cmd() { + + // @@protoc_insertion_point(field_mutable:milvus.grpc.Command.cmd) + return cmd_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* Command::release_cmd() { + // @@protoc_insertion_point(field_release:milvus.grpc.Command.cmd) + + return cmd_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void Command::set_allocated_cmd(std::string* cmd) { + if (cmd != nullptr) { + + } else { + + } + cmd_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), cmd); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.Command.cmd) +} + +// ------------------------------------------------------------------- + +// IndexParam + +// .milvus.grpc.Status status = 1; +inline bool IndexParam::has_status() const { + return this != internal_default_instance() && status_ != nullptr; +} +inline void IndexParam::clear_status() { + if (GetArenaNoVirtual() == nullptr && status_ != nullptr) { + delete status_; + } + status_ = nullptr; +} +inline const ::milvus::grpc::Status& IndexParam::status() const { + const ::milvus::grpc::Status* p = status_; + // @@protoc_insertion_point(field_get:milvus.grpc.IndexParam.status) + return p != nullptr ? *p : *reinterpret_cast( + &::milvus::grpc::_Status_default_instance_); +} +inline ::milvus::grpc::Status* IndexParam::release_status() { + // @@protoc_insertion_point(field_release:milvus.grpc.IndexParam.status) + + ::milvus::grpc::Status* temp = status_; + status_ = nullptr; + return temp; +} +inline ::milvus::grpc::Status* IndexParam::mutable_status() { + + if (status_ == nullptr) { + auto* p = CreateMaybeMessage<::milvus::grpc::Status>(GetArenaNoVirtual()); + status_ = p; + } + // @@protoc_insertion_point(field_mutable:milvus.grpc.IndexParam.status) + return status_; +} +inline void IndexParam::set_allocated_status(::milvus::grpc::Status* status) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete status_; + } + if (status) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + status = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, status, submessage_arena); + } + + } else { + + } + status_ = status; + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.IndexParam.status) +} + +// string collection_name = 2; +inline void IndexParam::clear_collection_name() { + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& IndexParam::collection_name() const { + // @@protoc_insertion_point(field_get:milvus.grpc.IndexParam.collection_name) + return collection_name_.GetNoArena(); +} +inline void IndexParam::set_collection_name(const std::string& value) { + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.IndexParam.collection_name) +} +inline void IndexParam::set_collection_name(std::string&& value) { + + collection_name_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.IndexParam.collection_name) +} +inline void IndexParam::set_collection_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.IndexParam.collection_name) +} +inline void IndexParam::set_collection_name(const char* value, size_t size) { + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.IndexParam.collection_name) +} +inline std::string* IndexParam::mutable_collection_name() { + + // @@protoc_insertion_point(field_mutable:milvus.grpc.IndexParam.collection_name) + return collection_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* IndexParam::release_collection_name() { + // @@protoc_insertion_point(field_release:milvus.grpc.IndexParam.collection_name) + + return collection_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void IndexParam::set_allocated_collection_name(std::string* collection_name) { + if (collection_name != nullptr) { + + } else { + + } + collection_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), collection_name); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.IndexParam.collection_name) +} + +// string field_name = 3; +inline void IndexParam::clear_field_name() { + field_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& IndexParam::field_name() const { + // @@protoc_insertion_point(field_get:milvus.grpc.IndexParam.field_name) + return field_name_.GetNoArena(); +} +inline void IndexParam::set_field_name(const std::string& value) { + + field_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.IndexParam.field_name) +} +inline void IndexParam::set_field_name(std::string&& value) { + + field_name_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.IndexParam.field_name) +} +inline void IndexParam::set_field_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + field_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.IndexParam.field_name) +} +inline void IndexParam::set_field_name(const char* value, size_t size) { + + field_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.IndexParam.field_name) +} +inline std::string* IndexParam::mutable_field_name() { + + // @@protoc_insertion_point(field_mutable:milvus.grpc.IndexParam.field_name) + return field_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* IndexParam::release_field_name() { + // @@protoc_insertion_point(field_release:milvus.grpc.IndexParam.field_name) + + return field_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void IndexParam::set_allocated_field_name(std::string* field_name) { + if (field_name != nullptr) { + + } else { + + } + field_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), field_name); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.IndexParam.field_name) +} + +// string index_name = 4; +inline void IndexParam::clear_index_name() { + index_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& IndexParam::index_name() const { + // @@protoc_insertion_point(field_get:milvus.grpc.IndexParam.index_name) + return index_name_.GetNoArena(); +} +inline void IndexParam::set_index_name(const std::string& value) { + + index_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.IndexParam.index_name) +} +inline void IndexParam::set_index_name(std::string&& value) { + + index_name_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.IndexParam.index_name) +} +inline void IndexParam::set_index_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + index_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.IndexParam.index_name) +} +inline void IndexParam::set_index_name(const char* value, size_t size) { + + index_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.IndexParam.index_name) +} +inline std::string* IndexParam::mutable_index_name() { + + // @@protoc_insertion_point(field_mutable:milvus.grpc.IndexParam.index_name) + return index_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* IndexParam::release_index_name() { + // @@protoc_insertion_point(field_release:milvus.grpc.IndexParam.index_name) + + return index_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void IndexParam::set_allocated_index_name(std::string* index_name) { + if (index_name != nullptr) { + + } else { + + } + index_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), index_name); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.IndexParam.index_name) +} + +// repeated .milvus.grpc.KeyValuePair extra_params = 5; +inline int IndexParam::extra_params_size() const { + return extra_params_.size(); +} +inline void IndexParam::clear_extra_params() { + extra_params_.Clear(); +} +inline ::milvus::grpc::KeyValuePair* IndexParam::mutable_extra_params(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.IndexParam.extra_params) + return extra_params_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >* +IndexParam::mutable_extra_params() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.IndexParam.extra_params) + return &extra_params_; +} +inline const ::milvus::grpc::KeyValuePair& IndexParam::extra_params(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.IndexParam.extra_params) + return extra_params_.Get(index); +} +inline ::milvus::grpc::KeyValuePair* IndexParam::add_extra_params() { + // @@protoc_insertion_point(field_add:milvus.grpc.IndexParam.extra_params) + return extra_params_.Add(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >& +IndexParam::extra_params() const { + // @@protoc_insertion_point(field_list:milvus.grpc.IndexParam.extra_params) + return extra_params_; +} + +// ------------------------------------------------------------------- + +// FlushParam + +// repeated string collection_name_array = 1; +inline int FlushParam::collection_name_array_size() const { + return collection_name_array_.size(); +} +inline void FlushParam::clear_collection_name_array() { + collection_name_array_.Clear(); +} +inline const std::string& FlushParam::collection_name_array(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.FlushParam.collection_name_array) + return collection_name_array_.Get(index); +} +inline std::string* FlushParam::mutable_collection_name_array(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.FlushParam.collection_name_array) + return collection_name_array_.Mutable(index); +} +inline void FlushParam::set_collection_name_array(int index, const std::string& value) { + // @@protoc_insertion_point(field_set:milvus.grpc.FlushParam.collection_name_array) + collection_name_array_.Mutable(index)->assign(value); +} +inline void FlushParam::set_collection_name_array(int index, std::string&& value) { + // @@protoc_insertion_point(field_set:milvus.grpc.FlushParam.collection_name_array) + collection_name_array_.Mutable(index)->assign(std::move(value)); +} +inline void FlushParam::set_collection_name_array(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + collection_name_array_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:milvus.grpc.FlushParam.collection_name_array) +} +inline void FlushParam::set_collection_name_array(int index, const char* value, size_t size) { + collection_name_array_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.FlushParam.collection_name_array) +} +inline std::string* FlushParam::add_collection_name_array() { + // @@protoc_insertion_point(field_add_mutable:milvus.grpc.FlushParam.collection_name_array) + return collection_name_array_.Add(); +} +inline void FlushParam::add_collection_name_array(const std::string& value) { + collection_name_array_.Add()->assign(value); + // @@protoc_insertion_point(field_add:milvus.grpc.FlushParam.collection_name_array) +} +inline void FlushParam::add_collection_name_array(std::string&& value) { + collection_name_array_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:milvus.grpc.FlushParam.collection_name_array) +} +inline void FlushParam::add_collection_name_array(const char* value) { + GOOGLE_DCHECK(value != nullptr); + collection_name_array_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:milvus.grpc.FlushParam.collection_name_array) +} +inline void FlushParam::add_collection_name_array(const char* value, size_t size) { + collection_name_array_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:milvus.grpc.FlushParam.collection_name_array) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +FlushParam::collection_name_array() const { + // @@protoc_insertion_point(field_list:milvus.grpc.FlushParam.collection_name_array) + return collection_name_array_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +FlushParam::mutable_collection_name_array() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.FlushParam.collection_name_array) + return &collection_name_array_; +} + +// ------------------------------------------------------------------- + +// CompactParam + +// string collection_name = 1; +inline void CompactParam::clear_collection_name() { + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& CompactParam::collection_name() const { + // @@protoc_insertion_point(field_get:milvus.grpc.CompactParam.collection_name) + return collection_name_.GetNoArena(); +} +inline void CompactParam::set_collection_name(const std::string& value) { + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.CompactParam.collection_name) +} +inline void CompactParam::set_collection_name(std::string&& value) { + + collection_name_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.CompactParam.collection_name) +} +inline void CompactParam::set_collection_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.CompactParam.collection_name) +} +inline void CompactParam::set_collection_name(const char* value, size_t size) { + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.CompactParam.collection_name) +} +inline std::string* CompactParam::mutable_collection_name() { + + // @@protoc_insertion_point(field_mutable:milvus.grpc.CompactParam.collection_name) + return collection_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* CompactParam::release_collection_name() { + // @@protoc_insertion_point(field_release:milvus.grpc.CompactParam.collection_name) + + return collection_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void CompactParam::set_allocated_collection_name(std::string* collection_name) { + if (collection_name != nullptr) { + + } else { + + } + collection_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), collection_name); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.CompactParam.collection_name) +} + +// double threshold = 2; +inline void CompactParam::clear_threshold() { + threshold_ = 0; +} +inline double CompactParam::threshold() const { + // @@protoc_insertion_point(field_get:milvus.grpc.CompactParam.threshold) + return threshold_; +} +inline void CompactParam::set_threshold(double value) { + + threshold_ = value; + // @@protoc_insertion_point(field_set:milvus.grpc.CompactParam.threshold) +} + +// ------------------------------------------------------------------- + +// DeleteByIDParam + +// string collection_name = 1; +inline void DeleteByIDParam::clear_collection_name() { + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& DeleteByIDParam::collection_name() const { + // @@protoc_insertion_point(field_get:milvus.grpc.DeleteByIDParam.collection_name) + return collection_name_.GetNoArena(); +} +inline void DeleteByIDParam::set_collection_name(const std::string& value) { + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.DeleteByIDParam.collection_name) +} +inline void DeleteByIDParam::set_collection_name(std::string&& value) { + + collection_name_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.DeleteByIDParam.collection_name) +} +inline void DeleteByIDParam::set_collection_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.DeleteByIDParam.collection_name) +} +inline void DeleteByIDParam::set_collection_name(const char* value, size_t size) { + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.DeleteByIDParam.collection_name) +} +inline std::string* DeleteByIDParam::mutable_collection_name() { + + // @@protoc_insertion_point(field_mutable:milvus.grpc.DeleteByIDParam.collection_name) + return collection_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* DeleteByIDParam::release_collection_name() { + // @@protoc_insertion_point(field_release:milvus.grpc.DeleteByIDParam.collection_name) + + return collection_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void DeleteByIDParam::set_allocated_collection_name(std::string* collection_name) { + if (collection_name != nullptr) { + + } else { + + } + collection_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), collection_name); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.DeleteByIDParam.collection_name) +} + +// repeated int64 id_array = 2; +inline int DeleteByIDParam::id_array_size() const { + return id_array_.size(); +} +inline void DeleteByIDParam::clear_id_array() { + id_array_.Clear(); +} +inline ::PROTOBUF_NAMESPACE_ID::int64 DeleteByIDParam::id_array(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.DeleteByIDParam.id_array) + return id_array_.Get(index); +} +inline void DeleteByIDParam::set_id_array(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) { + id_array_.Set(index, value); + // @@protoc_insertion_point(field_set:milvus.grpc.DeleteByIDParam.id_array) +} +inline void DeleteByIDParam::add_id_array(::PROTOBUF_NAMESPACE_ID::int64 value) { + id_array_.Add(value); + // @@protoc_insertion_point(field_add:milvus.grpc.DeleteByIDParam.id_array) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >& +DeleteByIDParam::id_array() const { + // @@protoc_insertion_point(field_list:milvus.grpc.DeleteByIDParam.id_array) + return id_array_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >* +DeleteByIDParam::mutable_id_array() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.DeleteByIDParam.id_array) + return &id_array_; +} + +// ------------------------------------------------------------------- + +// CollectionInfo + +// .milvus.grpc.Status status = 1; +inline bool CollectionInfo::has_status() const { + return this != internal_default_instance() && status_ != nullptr; +} +inline void CollectionInfo::clear_status() { + if (GetArenaNoVirtual() == nullptr && status_ != nullptr) { + delete status_; + } + status_ = nullptr; +} +inline const ::milvus::grpc::Status& CollectionInfo::status() const { + const ::milvus::grpc::Status* p = status_; + // @@protoc_insertion_point(field_get:milvus.grpc.CollectionInfo.status) + return p != nullptr ? *p : *reinterpret_cast( + &::milvus::grpc::_Status_default_instance_); +} +inline ::milvus::grpc::Status* CollectionInfo::release_status() { + // @@protoc_insertion_point(field_release:milvus.grpc.CollectionInfo.status) + + ::milvus::grpc::Status* temp = status_; + status_ = nullptr; + return temp; +} +inline ::milvus::grpc::Status* CollectionInfo::mutable_status() { + + if (status_ == nullptr) { + auto* p = CreateMaybeMessage<::milvus::grpc::Status>(GetArenaNoVirtual()); + status_ = p; + } + // @@protoc_insertion_point(field_mutable:milvus.grpc.CollectionInfo.status) + return status_; +} +inline void CollectionInfo::set_allocated_status(::milvus::grpc::Status* status) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete status_; + } + if (status) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + status = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, status, submessage_arena); + } + + } else { + + } + status_ = status; + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.CollectionInfo.status) +} + +// string json_info = 2; +inline void CollectionInfo::clear_json_info() { + json_info_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& CollectionInfo::json_info() const { + // @@protoc_insertion_point(field_get:milvus.grpc.CollectionInfo.json_info) + return json_info_.GetNoArena(); +} +inline void CollectionInfo::set_json_info(const std::string& value) { + + json_info_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.CollectionInfo.json_info) +} +inline void CollectionInfo::set_json_info(std::string&& value) { + + json_info_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.CollectionInfo.json_info) +} +inline void CollectionInfo::set_json_info(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + json_info_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.CollectionInfo.json_info) +} +inline void CollectionInfo::set_json_info(const char* value, size_t size) { + + json_info_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.CollectionInfo.json_info) +} +inline std::string* CollectionInfo::mutable_json_info() { + + // @@protoc_insertion_point(field_mutable:milvus.grpc.CollectionInfo.json_info) + return json_info_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* CollectionInfo::release_json_info() { + // @@protoc_insertion_point(field_release:milvus.grpc.CollectionInfo.json_info) + + return json_info_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void CollectionInfo::set_allocated_json_info(std::string* json_info) { + if (json_info != nullptr) { + + } else { + + } + json_info_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), json_info); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.CollectionInfo.json_info) +} + +// ------------------------------------------------------------------- + +// GetEntityIDsParam + +// string collection_name = 1; +inline void GetEntityIDsParam::clear_collection_name() { + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& GetEntityIDsParam::collection_name() const { + // @@protoc_insertion_point(field_get:milvus.grpc.GetEntityIDsParam.collection_name) + return collection_name_.GetNoArena(); +} +inline void GetEntityIDsParam::set_collection_name(const std::string& value) { + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.GetEntityIDsParam.collection_name) +} +inline void GetEntityIDsParam::set_collection_name(std::string&& value) { + + collection_name_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.GetEntityIDsParam.collection_name) +} +inline void GetEntityIDsParam::set_collection_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.GetEntityIDsParam.collection_name) +} +inline void GetEntityIDsParam::set_collection_name(const char* value, size_t size) { + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.GetEntityIDsParam.collection_name) +} +inline std::string* GetEntityIDsParam::mutable_collection_name() { + + // @@protoc_insertion_point(field_mutable:milvus.grpc.GetEntityIDsParam.collection_name) + return collection_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* GetEntityIDsParam::release_collection_name() { + // @@protoc_insertion_point(field_release:milvus.grpc.GetEntityIDsParam.collection_name) + + return collection_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void GetEntityIDsParam::set_allocated_collection_name(std::string* collection_name) { + if (collection_name != nullptr) { + + } else { + + } + collection_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), collection_name); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.GetEntityIDsParam.collection_name) +} + +// int64 segment_id = 2; +inline void GetEntityIDsParam::clear_segment_id() { + segment_id_ = PROTOBUF_LONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::int64 GetEntityIDsParam::segment_id() const { + // @@protoc_insertion_point(field_get:milvus.grpc.GetEntityIDsParam.segment_id) + return segment_id_; +} +inline void GetEntityIDsParam::set_segment_id(::PROTOBUF_NAMESPACE_ID::int64 value) { + + segment_id_ = value; + // @@protoc_insertion_point(field_set:milvus.grpc.GetEntityIDsParam.segment_id) +} + +// ------------------------------------------------------------------- + +// EntityIdentity + +// string collection_name = 1; +inline void EntityIdentity::clear_collection_name() { + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& EntityIdentity::collection_name() const { + // @@protoc_insertion_point(field_get:milvus.grpc.EntityIdentity.collection_name) + return collection_name_.GetNoArena(); +} +inline void EntityIdentity::set_collection_name(const std::string& value) { + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.EntityIdentity.collection_name) +} +inline void EntityIdentity::set_collection_name(std::string&& value) { + + collection_name_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.EntityIdentity.collection_name) +} +inline void EntityIdentity::set_collection_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.EntityIdentity.collection_name) +} +inline void EntityIdentity::set_collection_name(const char* value, size_t size) { + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.EntityIdentity.collection_name) +} +inline std::string* EntityIdentity::mutable_collection_name() { + + // @@protoc_insertion_point(field_mutable:milvus.grpc.EntityIdentity.collection_name) + return collection_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* EntityIdentity::release_collection_name() { + // @@protoc_insertion_point(field_release:milvus.grpc.EntityIdentity.collection_name) + + return collection_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void EntityIdentity::set_allocated_collection_name(std::string* collection_name) { + if (collection_name != nullptr) { + + } else { + + } + collection_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), collection_name); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.EntityIdentity.collection_name) +} + +// repeated int64 id_array = 2; +inline int EntityIdentity::id_array_size() const { + return id_array_.size(); +} +inline void EntityIdentity::clear_id_array() { + id_array_.Clear(); +} +inline ::PROTOBUF_NAMESPACE_ID::int64 EntityIdentity::id_array(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.EntityIdentity.id_array) + return id_array_.Get(index); +} +inline void EntityIdentity::set_id_array(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) { + id_array_.Set(index, value); + // @@protoc_insertion_point(field_set:milvus.grpc.EntityIdentity.id_array) +} +inline void EntityIdentity::add_id_array(::PROTOBUF_NAMESPACE_ID::int64 value) { + id_array_.Add(value); + // @@protoc_insertion_point(field_add:milvus.grpc.EntityIdentity.id_array) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >& +EntityIdentity::id_array() const { + // @@protoc_insertion_point(field_list:milvus.grpc.EntityIdentity.id_array) + return id_array_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >* +EntityIdentity::mutable_id_array() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.EntityIdentity.id_array) + return &id_array_; +} + +// repeated string field_names = 3; +inline int EntityIdentity::field_names_size() const { + return field_names_.size(); +} +inline void EntityIdentity::clear_field_names() { + field_names_.Clear(); +} +inline const std::string& EntityIdentity::field_names(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.EntityIdentity.field_names) + return field_names_.Get(index); +} +inline std::string* EntityIdentity::mutable_field_names(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.EntityIdentity.field_names) + return field_names_.Mutable(index); +} +inline void EntityIdentity::set_field_names(int index, const std::string& value) { + // @@protoc_insertion_point(field_set:milvus.grpc.EntityIdentity.field_names) + field_names_.Mutable(index)->assign(value); +} +inline void EntityIdentity::set_field_names(int index, std::string&& value) { + // @@protoc_insertion_point(field_set:milvus.grpc.EntityIdentity.field_names) + field_names_.Mutable(index)->assign(std::move(value)); +} +inline void EntityIdentity::set_field_names(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + field_names_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:milvus.grpc.EntityIdentity.field_names) +} +inline void EntityIdentity::set_field_names(int index, const char* value, size_t size) { + field_names_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.EntityIdentity.field_names) +} +inline std::string* EntityIdentity::add_field_names() { + // @@protoc_insertion_point(field_add_mutable:milvus.grpc.EntityIdentity.field_names) + return field_names_.Add(); +} +inline void EntityIdentity::add_field_names(const std::string& value) { + field_names_.Add()->assign(value); + // @@protoc_insertion_point(field_add:milvus.grpc.EntityIdentity.field_names) +} +inline void EntityIdentity::add_field_names(std::string&& value) { + field_names_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:milvus.grpc.EntityIdentity.field_names) +} +inline void EntityIdentity::add_field_names(const char* value) { + GOOGLE_DCHECK(value != nullptr); + field_names_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:milvus.grpc.EntityIdentity.field_names) +} +inline void EntityIdentity::add_field_names(const char* value, size_t size) { + field_names_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:milvus.grpc.EntityIdentity.field_names) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +EntityIdentity::field_names() const { + // @@protoc_insertion_point(field_list:milvus.grpc.EntityIdentity.field_names) + return field_names_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +EntityIdentity::mutable_field_names() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.EntityIdentity.field_names) + return &field_names_; +} + +// ------------------------------------------------------------------- + +// VectorFieldParam + +// int64 dimension = 1; +inline void VectorFieldParam::clear_dimension() { + dimension_ = PROTOBUF_LONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::int64 VectorFieldParam::dimension() const { + // @@protoc_insertion_point(field_get:milvus.grpc.VectorFieldParam.dimension) + return dimension_; +} +inline void VectorFieldParam::set_dimension(::PROTOBUF_NAMESPACE_ID::int64 value) { + + dimension_ = value; + // @@protoc_insertion_point(field_set:milvus.grpc.VectorFieldParam.dimension) +} + +// ------------------------------------------------------------------- + +// FieldType + +// .milvus.grpc.DataType data_type = 1; +inline bool FieldType::has_data_type() const { + return value_case() == kDataType; +} +inline void FieldType::set_has_data_type() { + _oneof_case_[0] = kDataType; +} +inline void FieldType::clear_data_type() { + if (has_data_type()) { + value_.data_type_ = 0; + clear_has_value(); + } +} +inline ::milvus::grpc::DataType FieldType::data_type() const { + // @@protoc_insertion_point(field_get:milvus.grpc.FieldType.data_type) + if (has_data_type()) { + return static_cast< ::milvus::grpc::DataType >(value_.data_type_); + } + return static_cast< ::milvus::grpc::DataType >(0); +} +inline void FieldType::set_data_type(::milvus::grpc::DataType value) { + if (!has_data_type()) { + clear_value(); + set_has_data_type(); + } + value_.data_type_ = value; + // @@protoc_insertion_point(field_set:milvus.grpc.FieldType.data_type) +} + +// .milvus.grpc.VectorFieldParam vector_param = 2; +inline bool FieldType::has_vector_param() const { + return value_case() == kVectorParam; +} +inline void FieldType::set_has_vector_param() { + _oneof_case_[0] = kVectorParam; +} +inline void FieldType::clear_vector_param() { + if (has_vector_param()) { + delete value_.vector_param_; + clear_has_value(); + } +} +inline ::milvus::grpc::VectorFieldParam* FieldType::release_vector_param() { + // @@protoc_insertion_point(field_release:milvus.grpc.FieldType.vector_param) + if (has_vector_param()) { + clear_has_value(); + ::milvus::grpc::VectorFieldParam* temp = value_.vector_param_; + value_.vector_param_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::milvus::grpc::VectorFieldParam& FieldType::vector_param() const { + // @@protoc_insertion_point(field_get:milvus.grpc.FieldType.vector_param) + return has_vector_param() + ? *value_.vector_param_ + : *reinterpret_cast< ::milvus::grpc::VectorFieldParam*>(&::milvus::grpc::_VectorFieldParam_default_instance_); +} +inline ::milvus::grpc::VectorFieldParam* FieldType::mutable_vector_param() { + if (!has_vector_param()) { + clear_value(); + set_has_vector_param(); + value_.vector_param_ = CreateMaybeMessage< ::milvus::grpc::VectorFieldParam >( + GetArenaNoVirtual()); + } + // @@protoc_insertion_point(field_mutable:milvus.grpc.FieldType.vector_param) + return value_.vector_param_; +} + +inline bool FieldType::has_value() const { + return value_case() != VALUE_NOT_SET; +} +inline void FieldType::clear_has_value() { + _oneof_case_[0] = VALUE_NOT_SET; +} +inline FieldType::ValueCase FieldType::value_case() const { + return FieldType::ValueCase(_oneof_case_[0]); +} +// ------------------------------------------------------------------- + +// FieldParam + +// uint64 id = 1; +inline void FieldParam::clear_id() { + id_ = PROTOBUF_ULONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::uint64 FieldParam::id() const { + // @@protoc_insertion_point(field_get:milvus.grpc.FieldParam.id) + return id_; +} +inline void FieldParam::set_id(::PROTOBUF_NAMESPACE_ID::uint64 value) { + + id_ = value; + // @@protoc_insertion_point(field_set:milvus.grpc.FieldParam.id) +} + +// string name = 2; +inline void FieldParam::clear_name() { + name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& FieldParam::name() const { + // @@protoc_insertion_point(field_get:milvus.grpc.FieldParam.name) + return name_.GetNoArena(); +} +inline void FieldParam::set_name(const std::string& value) { + + name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.FieldParam.name) +} +inline void FieldParam::set_name(std::string&& value) { + + name_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.FieldParam.name) +} +inline void FieldParam::set_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.FieldParam.name) +} +inline void FieldParam::set_name(const char* value, size_t size) { + + name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.FieldParam.name) +} +inline std::string* FieldParam::mutable_name() { + + // @@protoc_insertion_point(field_mutable:milvus.grpc.FieldParam.name) + return name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* FieldParam::release_name() { + // @@protoc_insertion_point(field_release:milvus.grpc.FieldParam.name) + + return name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void FieldParam::set_allocated_name(std::string* name) { + if (name != nullptr) { + + } else { + + } + name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.FieldParam.name) +} + +// .milvus.grpc.DataType type = 3; +inline void FieldParam::clear_type() { + type_ = 0; +} +inline ::milvus::grpc::DataType FieldParam::type() const { + // @@protoc_insertion_point(field_get:milvus.grpc.FieldParam.type) + return static_cast< ::milvus::grpc::DataType >(type_); +} +inline void FieldParam::set_type(::milvus::grpc::DataType value) { + + type_ = value; + // @@protoc_insertion_point(field_set:milvus.grpc.FieldParam.type) +} + +// repeated .milvus.grpc.KeyValuePair index_params = 4; +inline int FieldParam::index_params_size() const { + return index_params_.size(); +} +inline void FieldParam::clear_index_params() { + index_params_.Clear(); +} +inline ::milvus::grpc::KeyValuePair* FieldParam::mutable_index_params(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.FieldParam.index_params) + return index_params_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >* +FieldParam::mutable_index_params() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.FieldParam.index_params) + return &index_params_; +} +inline const ::milvus::grpc::KeyValuePair& FieldParam::index_params(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.FieldParam.index_params) + return index_params_.Get(index); +} +inline ::milvus::grpc::KeyValuePair* FieldParam::add_index_params() { + // @@protoc_insertion_point(field_add:milvus.grpc.FieldParam.index_params) + return index_params_.Add(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >& +FieldParam::index_params() const { + // @@protoc_insertion_point(field_list:milvus.grpc.FieldParam.index_params) + return index_params_; +} + +// repeated .milvus.grpc.KeyValuePair extra_params = 5; +inline int FieldParam::extra_params_size() const { + return extra_params_.size(); +} +inline void FieldParam::clear_extra_params() { + extra_params_.Clear(); +} +inline ::milvus::grpc::KeyValuePair* FieldParam::mutable_extra_params(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.FieldParam.extra_params) + return extra_params_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >* +FieldParam::mutable_extra_params() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.FieldParam.extra_params) + return &extra_params_; +} +inline const ::milvus::grpc::KeyValuePair& FieldParam::extra_params(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.FieldParam.extra_params) + return extra_params_.Get(index); +} +inline ::milvus::grpc::KeyValuePair* FieldParam::add_extra_params() { + // @@protoc_insertion_point(field_add:milvus.grpc.FieldParam.extra_params) + return extra_params_.Add(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >& +FieldParam::extra_params() const { + // @@protoc_insertion_point(field_list:milvus.grpc.FieldParam.extra_params) + return extra_params_; +} + +// ------------------------------------------------------------------- + +// VectorFieldRecord + +// repeated .milvus.grpc.VectorRowRecord value = 1; +inline int VectorFieldRecord::value_size() const { + return value_.size(); +} +inline void VectorFieldRecord::clear_value() { + value_.Clear(); +} +inline ::milvus::grpc::VectorRowRecord* VectorFieldRecord::mutable_value(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.VectorFieldRecord.value) + return value_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::VectorRowRecord >* +VectorFieldRecord::mutable_value() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.VectorFieldRecord.value) + return &value_; +} +inline const ::milvus::grpc::VectorRowRecord& VectorFieldRecord::value(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.VectorFieldRecord.value) + return value_.Get(index); +} +inline ::milvus::grpc::VectorRowRecord* VectorFieldRecord::add_value() { + // @@protoc_insertion_point(field_add:milvus.grpc.VectorFieldRecord.value) + return value_.Add(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::VectorRowRecord >& +VectorFieldRecord::value() const { + // @@protoc_insertion_point(field_list:milvus.grpc.VectorFieldRecord.value) + return value_; +} + +// ------------------------------------------------------------------- + +// TermQuery + +// string field_name = 1; +inline void TermQuery::clear_field_name() { + field_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& TermQuery::field_name() const { + // @@protoc_insertion_point(field_get:milvus.grpc.TermQuery.field_name) + return field_name_.GetNoArena(); +} +inline void TermQuery::set_field_name(const std::string& value) { + + field_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.TermQuery.field_name) +} +inline void TermQuery::set_field_name(std::string&& value) { + + field_name_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.TermQuery.field_name) +} +inline void TermQuery::set_field_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + field_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.TermQuery.field_name) +} +inline void TermQuery::set_field_name(const char* value, size_t size) { + + field_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.TermQuery.field_name) +} +inline std::string* TermQuery::mutable_field_name() { + + // @@protoc_insertion_point(field_mutable:milvus.grpc.TermQuery.field_name) + return field_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* TermQuery::release_field_name() { + // @@protoc_insertion_point(field_release:milvus.grpc.TermQuery.field_name) + + return field_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void TermQuery::set_allocated_field_name(std::string* field_name) { + if (field_name != nullptr) { + + } else { + + } + field_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), field_name); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.TermQuery.field_name) +} + +// repeated int64 int_value = 2; +inline int TermQuery::int_value_size() const { + return int_value_.size(); +} +inline void TermQuery::clear_int_value() { + int_value_.Clear(); +} +inline ::PROTOBUF_NAMESPACE_ID::int64 TermQuery::int_value(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.TermQuery.int_value) + return int_value_.Get(index); +} +inline void TermQuery::set_int_value(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) { + int_value_.Set(index, value); + // @@protoc_insertion_point(field_set:milvus.grpc.TermQuery.int_value) +} +inline void TermQuery::add_int_value(::PROTOBUF_NAMESPACE_ID::int64 value) { + int_value_.Add(value); + // @@protoc_insertion_point(field_add:milvus.grpc.TermQuery.int_value) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >& +TermQuery::int_value() const { + // @@protoc_insertion_point(field_list:milvus.grpc.TermQuery.int_value) + return int_value_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >* +TermQuery::mutable_int_value() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.TermQuery.int_value) + return &int_value_; +} + +// repeated double double_value = 3; +inline int TermQuery::double_value_size() const { + return double_value_.size(); +} +inline void TermQuery::clear_double_value() { + double_value_.Clear(); +} +inline double TermQuery::double_value(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.TermQuery.double_value) + return double_value_.Get(index); +} +inline void TermQuery::set_double_value(int index, double value) { + double_value_.Set(index, value); + // @@protoc_insertion_point(field_set:milvus.grpc.TermQuery.double_value) +} +inline void TermQuery::add_double_value(double value) { + double_value_.Add(value); + // @@protoc_insertion_point(field_add:milvus.grpc.TermQuery.double_value) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >& +TermQuery::double_value() const { + // @@protoc_insertion_point(field_list:milvus.grpc.TermQuery.double_value) + return double_value_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >* +TermQuery::mutable_double_value() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.TermQuery.double_value) + return &double_value_; +} + +// int64 value_num = 4; +inline void TermQuery::clear_value_num() { + value_num_ = PROTOBUF_LONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::int64 TermQuery::value_num() const { + // @@protoc_insertion_point(field_get:milvus.grpc.TermQuery.value_num) + return value_num_; +} +inline void TermQuery::set_value_num(::PROTOBUF_NAMESPACE_ID::int64 value) { + + value_num_ = value; + // @@protoc_insertion_point(field_set:milvus.grpc.TermQuery.value_num) +} + +// float boost = 5; +inline void TermQuery::clear_boost() { + boost_ = 0; +} +inline float TermQuery::boost() const { + // @@protoc_insertion_point(field_get:milvus.grpc.TermQuery.boost) + return boost_; +} +inline void TermQuery::set_boost(float value) { + + boost_ = value; + // @@protoc_insertion_point(field_set:milvus.grpc.TermQuery.boost) +} + +// repeated .milvus.grpc.KeyValuePair extra_params = 6; +inline int TermQuery::extra_params_size() const { + return extra_params_.size(); +} +inline void TermQuery::clear_extra_params() { + extra_params_.Clear(); +} +inline ::milvus::grpc::KeyValuePair* TermQuery::mutable_extra_params(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.TermQuery.extra_params) + return extra_params_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >* +TermQuery::mutable_extra_params() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.TermQuery.extra_params) + return &extra_params_; +} +inline const ::milvus::grpc::KeyValuePair& TermQuery::extra_params(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.TermQuery.extra_params) + return extra_params_.Get(index); +} +inline ::milvus::grpc::KeyValuePair* TermQuery::add_extra_params() { + // @@protoc_insertion_point(field_add:milvus.grpc.TermQuery.extra_params) + return extra_params_.Add(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >& +TermQuery::extra_params() const { + // @@protoc_insertion_point(field_list:milvus.grpc.TermQuery.extra_params) + return extra_params_; +} + +// ------------------------------------------------------------------- + +// CompareExpr + +// .milvus.grpc.CompareOperator operator = 1; +inline void CompareExpr::clear_operator_() { + operator__ = 0; +} +inline ::milvus::grpc::CompareOperator CompareExpr::operator_() const { + // @@protoc_insertion_point(field_get:milvus.grpc.CompareExpr.operator) + return static_cast< ::milvus::grpc::CompareOperator >(operator__); +} +inline void CompareExpr::set_operator_(::milvus::grpc::CompareOperator value) { + + operator__ = value; + // @@protoc_insertion_point(field_set:milvus.grpc.CompareExpr.operator) +} + +// string operand = 2; +inline void CompareExpr::clear_operand() { + operand_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& CompareExpr::operand() const { + // @@protoc_insertion_point(field_get:milvus.grpc.CompareExpr.operand) + return operand_.GetNoArena(); +} +inline void CompareExpr::set_operand(const std::string& value) { + + operand_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.CompareExpr.operand) +} +inline void CompareExpr::set_operand(std::string&& value) { + + operand_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.CompareExpr.operand) +} +inline void CompareExpr::set_operand(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + operand_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.CompareExpr.operand) +} +inline void CompareExpr::set_operand(const char* value, size_t size) { + + operand_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.CompareExpr.operand) +} +inline std::string* CompareExpr::mutable_operand() { + + // @@protoc_insertion_point(field_mutable:milvus.grpc.CompareExpr.operand) + return operand_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* CompareExpr::release_operand() { + // @@protoc_insertion_point(field_release:milvus.grpc.CompareExpr.operand) + + return operand_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void CompareExpr::set_allocated_operand(std::string* operand) { + if (operand != nullptr) { + + } else { + + } + operand_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), operand); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.CompareExpr.operand) +} + +// ------------------------------------------------------------------- + +// RangeQuery + +// string field_name = 1; +inline void RangeQuery::clear_field_name() { + field_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& RangeQuery::field_name() const { + // @@protoc_insertion_point(field_get:milvus.grpc.RangeQuery.field_name) + return field_name_.GetNoArena(); +} +inline void RangeQuery::set_field_name(const std::string& value) { + + field_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.RangeQuery.field_name) +} +inline void RangeQuery::set_field_name(std::string&& value) { + + field_name_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.RangeQuery.field_name) +} +inline void RangeQuery::set_field_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + field_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.RangeQuery.field_name) +} +inline void RangeQuery::set_field_name(const char* value, size_t size) { + + field_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.RangeQuery.field_name) +} +inline std::string* RangeQuery::mutable_field_name() { + + // @@protoc_insertion_point(field_mutable:milvus.grpc.RangeQuery.field_name) + return field_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* RangeQuery::release_field_name() { + // @@protoc_insertion_point(field_release:milvus.grpc.RangeQuery.field_name) + + return field_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void RangeQuery::set_allocated_field_name(std::string* field_name) { + if (field_name != nullptr) { + + } else { + + } + field_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), field_name); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.RangeQuery.field_name) +} + +// repeated .milvus.grpc.CompareExpr operand = 2; +inline int RangeQuery::operand_size() const { + return operand_.size(); +} +inline void RangeQuery::clear_operand() { + operand_.Clear(); +} +inline ::milvus::grpc::CompareExpr* RangeQuery::mutable_operand(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.RangeQuery.operand) + return operand_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::CompareExpr >* +RangeQuery::mutable_operand() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.RangeQuery.operand) + return &operand_; +} +inline const ::milvus::grpc::CompareExpr& RangeQuery::operand(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.RangeQuery.operand) + return operand_.Get(index); +} +inline ::milvus::grpc::CompareExpr* RangeQuery::add_operand() { + // @@protoc_insertion_point(field_add:milvus.grpc.RangeQuery.operand) + return operand_.Add(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::CompareExpr >& +RangeQuery::operand() const { + // @@protoc_insertion_point(field_list:milvus.grpc.RangeQuery.operand) + return operand_; +} + +// float boost = 3; +inline void RangeQuery::clear_boost() { + boost_ = 0; +} +inline float RangeQuery::boost() const { + // @@protoc_insertion_point(field_get:milvus.grpc.RangeQuery.boost) + return boost_; +} +inline void RangeQuery::set_boost(float value) { + + boost_ = value; + // @@protoc_insertion_point(field_set:milvus.grpc.RangeQuery.boost) +} + +// repeated .milvus.grpc.KeyValuePair extra_params = 4; +inline int RangeQuery::extra_params_size() const { + return extra_params_.size(); +} +inline void RangeQuery::clear_extra_params() { + extra_params_.Clear(); +} +inline ::milvus::grpc::KeyValuePair* RangeQuery::mutable_extra_params(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.RangeQuery.extra_params) + return extra_params_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >* +RangeQuery::mutable_extra_params() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.RangeQuery.extra_params) + return &extra_params_; +} +inline const ::milvus::grpc::KeyValuePair& RangeQuery::extra_params(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.RangeQuery.extra_params) + return extra_params_.Get(index); +} +inline ::milvus::grpc::KeyValuePair* RangeQuery::add_extra_params() { + // @@protoc_insertion_point(field_add:milvus.grpc.RangeQuery.extra_params) + return extra_params_.Add(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >& +RangeQuery::extra_params() const { + // @@protoc_insertion_point(field_list:milvus.grpc.RangeQuery.extra_params) + return extra_params_; +} + +// ------------------------------------------------------------------- + +// VectorQuery + +// string field_name = 1; +inline void VectorQuery::clear_field_name() { + field_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& VectorQuery::field_name() const { + // @@protoc_insertion_point(field_get:milvus.grpc.VectorQuery.field_name) + return field_name_.GetNoArena(); +} +inline void VectorQuery::set_field_name(const std::string& value) { + + field_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.VectorQuery.field_name) +} +inline void VectorQuery::set_field_name(std::string&& value) { + + field_name_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.VectorQuery.field_name) +} +inline void VectorQuery::set_field_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + field_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.VectorQuery.field_name) +} +inline void VectorQuery::set_field_name(const char* value, size_t size) { + + field_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.VectorQuery.field_name) +} +inline std::string* VectorQuery::mutable_field_name() { + + // @@protoc_insertion_point(field_mutable:milvus.grpc.VectorQuery.field_name) + return field_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* VectorQuery::release_field_name() { + // @@protoc_insertion_point(field_release:milvus.grpc.VectorQuery.field_name) + + return field_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void VectorQuery::set_allocated_field_name(std::string* field_name) { + if (field_name != nullptr) { + + } else { + + } + field_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), field_name); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.VectorQuery.field_name) +} + +// float query_boost = 2; +inline void VectorQuery::clear_query_boost() { + query_boost_ = 0; +} +inline float VectorQuery::query_boost() const { + // @@protoc_insertion_point(field_get:milvus.grpc.VectorQuery.query_boost) + return query_boost_; +} +inline void VectorQuery::set_query_boost(float value) { + + query_boost_ = value; + // @@protoc_insertion_point(field_set:milvus.grpc.VectorQuery.query_boost) +} + +// repeated .milvus.grpc.VectorRowRecord records = 3; +inline int VectorQuery::records_size() const { + return records_.size(); +} +inline void VectorQuery::clear_records() { + records_.Clear(); +} +inline ::milvus::grpc::VectorRowRecord* VectorQuery::mutable_records(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.VectorQuery.records) + return records_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::VectorRowRecord >* +VectorQuery::mutable_records() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.VectorQuery.records) + return &records_; +} +inline const ::milvus::grpc::VectorRowRecord& VectorQuery::records(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.VectorQuery.records) + return records_.Get(index); +} +inline ::milvus::grpc::VectorRowRecord* VectorQuery::add_records() { + // @@protoc_insertion_point(field_add:milvus.grpc.VectorQuery.records) + return records_.Add(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::VectorRowRecord >& +VectorQuery::records() const { + // @@protoc_insertion_point(field_list:milvus.grpc.VectorQuery.records) + return records_; +} + +// int64 topk = 4; +inline void VectorQuery::clear_topk() { + topk_ = PROTOBUF_LONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::int64 VectorQuery::topk() const { + // @@protoc_insertion_point(field_get:milvus.grpc.VectorQuery.topk) + return topk_; +} +inline void VectorQuery::set_topk(::PROTOBUF_NAMESPACE_ID::int64 value) { + + topk_ = value; + // @@protoc_insertion_point(field_set:milvus.grpc.VectorQuery.topk) +} + +// repeated .milvus.grpc.KeyValuePair extra_params = 5; +inline int VectorQuery::extra_params_size() const { + return extra_params_.size(); +} +inline void VectorQuery::clear_extra_params() { + extra_params_.Clear(); +} +inline ::milvus::grpc::KeyValuePair* VectorQuery::mutable_extra_params(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.VectorQuery.extra_params) + return extra_params_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >* +VectorQuery::mutable_extra_params() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.VectorQuery.extra_params) + return &extra_params_; +} +inline const ::milvus::grpc::KeyValuePair& VectorQuery::extra_params(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.VectorQuery.extra_params) + return extra_params_.Get(index); +} +inline ::milvus::grpc::KeyValuePair* VectorQuery::add_extra_params() { + // @@protoc_insertion_point(field_add:milvus.grpc.VectorQuery.extra_params) + return extra_params_.Add(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >& +VectorQuery::extra_params() const { + // @@protoc_insertion_point(field_list:milvus.grpc.VectorQuery.extra_params) + return extra_params_; +} + +// ------------------------------------------------------------------- + +// BooleanQuery + +// .milvus.grpc.Occur occur = 1; +inline void BooleanQuery::clear_occur() { + occur_ = 0; +} +inline ::milvus::grpc::Occur BooleanQuery::occur() const { + // @@protoc_insertion_point(field_get:milvus.grpc.BooleanQuery.occur) + return static_cast< ::milvus::grpc::Occur >(occur_); +} +inline void BooleanQuery::set_occur(::milvus::grpc::Occur value) { + + occur_ = value; + // @@protoc_insertion_point(field_set:milvus.grpc.BooleanQuery.occur) +} + +// repeated .milvus.grpc.GeneralQuery general_query = 2; +inline int BooleanQuery::general_query_size() const { + return general_query_.size(); +} +inline void BooleanQuery::clear_general_query() { + general_query_.Clear(); +} +inline ::milvus::grpc::GeneralQuery* BooleanQuery::mutable_general_query(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.BooleanQuery.general_query) + return general_query_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::GeneralQuery >* +BooleanQuery::mutable_general_query() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.BooleanQuery.general_query) + return &general_query_; +} +inline const ::milvus::grpc::GeneralQuery& BooleanQuery::general_query(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.BooleanQuery.general_query) + return general_query_.Get(index); +} +inline ::milvus::grpc::GeneralQuery* BooleanQuery::add_general_query() { + // @@protoc_insertion_point(field_add:milvus.grpc.BooleanQuery.general_query) + return general_query_.Add(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::GeneralQuery >& +BooleanQuery::general_query() const { + // @@protoc_insertion_point(field_list:milvus.grpc.BooleanQuery.general_query) + return general_query_; +} + +// ------------------------------------------------------------------- + +// GeneralQuery + +// .milvus.grpc.BooleanQuery boolean_query = 1; +inline bool GeneralQuery::has_boolean_query() const { + return query_case() == kBooleanQuery; +} +inline void GeneralQuery::set_has_boolean_query() { + _oneof_case_[0] = kBooleanQuery; +} +inline void GeneralQuery::clear_boolean_query() { + if (has_boolean_query()) { + delete query_.boolean_query_; + clear_has_query(); + } +} +inline ::milvus::grpc::BooleanQuery* GeneralQuery::release_boolean_query() { + // @@protoc_insertion_point(field_release:milvus.grpc.GeneralQuery.boolean_query) + if (has_boolean_query()) { + clear_has_query(); + ::milvus::grpc::BooleanQuery* temp = query_.boolean_query_; + query_.boolean_query_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::milvus::grpc::BooleanQuery& GeneralQuery::boolean_query() const { + // @@protoc_insertion_point(field_get:milvus.grpc.GeneralQuery.boolean_query) + return has_boolean_query() + ? *query_.boolean_query_ + : *reinterpret_cast< ::milvus::grpc::BooleanQuery*>(&::milvus::grpc::_BooleanQuery_default_instance_); +} +inline ::milvus::grpc::BooleanQuery* GeneralQuery::mutable_boolean_query() { + if (!has_boolean_query()) { + clear_query(); + set_has_boolean_query(); + query_.boolean_query_ = CreateMaybeMessage< ::milvus::grpc::BooleanQuery >( + GetArenaNoVirtual()); + } + // @@protoc_insertion_point(field_mutable:milvus.grpc.GeneralQuery.boolean_query) + return query_.boolean_query_; +} + +// .milvus.grpc.TermQuery term_query = 2; +inline bool GeneralQuery::has_term_query() const { + return query_case() == kTermQuery; +} +inline void GeneralQuery::set_has_term_query() { + _oneof_case_[0] = kTermQuery; +} +inline void GeneralQuery::clear_term_query() { + if (has_term_query()) { + delete query_.term_query_; + clear_has_query(); + } +} +inline ::milvus::grpc::TermQuery* GeneralQuery::release_term_query() { + // @@protoc_insertion_point(field_release:milvus.grpc.GeneralQuery.term_query) + if (has_term_query()) { + clear_has_query(); + ::milvus::grpc::TermQuery* temp = query_.term_query_; + query_.term_query_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::milvus::grpc::TermQuery& GeneralQuery::term_query() const { + // @@protoc_insertion_point(field_get:milvus.grpc.GeneralQuery.term_query) + return has_term_query() + ? *query_.term_query_ + : *reinterpret_cast< ::milvus::grpc::TermQuery*>(&::milvus::grpc::_TermQuery_default_instance_); +} +inline ::milvus::grpc::TermQuery* GeneralQuery::mutable_term_query() { + if (!has_term_query()) { + clear_query(); + set_has_term_query(); + query_.term_query_ = CreateMaybeMessage< ::milvus::grpc::TermQuery >( + GetArenaNoVirtual()); + } + // @@protoc_insertion_point(field_mutable:milvus.grpc.GeneralQuery.term_query) + return query_.term_query_; +} + +// .milvus.grpc.RangeQuery range_query = 3; +inline bool GeneralQuery::has_range_query() const { + return query_case() == kRangeQuery; +} +inline void GeneralQuery::set_has_range_query() { + _oneof_case_[0] = kRangeQuery; +} +inline void GeneralQuery::clear_range_query() { + if (has_range_query()) { + delete query_.range_query_; + clear_has_query(); + } +} +inline ::milvus::grpc::RangeQuery* GeneralQuery::release_range_query() { + // @@protoc_insertion_point(field_release:milvus.grpc.GeneralQuery.range_query) + if (has_range_query()) { + clear_has_query(); + ::milvus::grpc::RangeQuery* temp = query_.range_query_; + query_.range_query_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::milvus::grpc::RangeQuery& GeneralQuery::range_query() const { + // @@protoc_insertion_point(field_get:milvus.grpc.GeneralQuery.range_query) + return has_range_query() + ? *query_.range_query_ + : *reinterpret_cast< ::milvus::grpc::RangeQuery*>(&::milvus::grpc::_RangeQuery_default_instance_); +} +inline ::milvus::grpc::RangeQuery* GeneralQuery::mutable_range_query() { + if (!has_range_query()) { + clear_query(); + set_has_range_query(); + query_.range_query_ = CreateMaybeMessage< ::milvus::grpc::RangeQuery >( + GetArenaNoVirtual()); + } + // @@protoc_insertion_point(field_mutable:milvus.grpc.GeneralQuery.range_query) + return query_.range_query_; +} + +// .milvus.grpc.VectorQuery vector_query = 4; +inline bool GeneralQuery::has_vector_query() const { + return query_case() == kVectorQuery; +} +inline void GeneralQuery::set_has_vector_query() { + _oneof_case_[0] = kVectorQuery; +} +inline void GeneralQuery::clear_vector_query() { + if (has_vector_query()) { + delete query_.vector_query_; + clear_has_query(); + } +} +inline ::milvus::grpc::VectorQuery* GeneralQuery::release_vector_query() { + // @@protoc_insertion_point(field_release:milvus.grpc.GeneralQuery.vector_query) + if (has_vector_query()) { + clear_has_query(); + ::milvus::grpc::VectorQuery* temp = query_.vector_query_; + query_.vector_query_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::milvus::grpc::VectorQuery& GeneralQuery::vector_query() const { + // @@protoc_insertion_point(field_get:milvus.grpc.GeneralQuery.vector_query) + return has_vector_query() + ? *query_.vector_query_ + : *reinterpret_cast< ::milvus::grpc::VectorQuery*>(&::milvus::grpc::_VectorQuery_default_instance_); +} +inline ::milvus::grpc::VectorQuery* GeneralQuery::mutable_vector_query() { + if (!has_vector_query()) { + clear_query(); + set_has_vector_query(); + query_.vector_query_ = CreateMaybeMessage< ::milvus::grpc::VectorQuery >( + GetArenaNoVirtual()); + } + // @@protoc_insertion_point(field_mutable:milvus.grpc.GeneralQuery.vector_query) + return query_.vector_query_; +} + +inline bool GeneralQuery::has_query() const { + return query_case() != QUERY_NOT_SET; +} +inline void GeneralQuery::clear_has_query() { + _oneof_case_[0] = QUERY_NOT_SET; +} +inline GeneralQuery::QueryCase GeneralQuery::query_case() const { + return GeneralQuery::QueryCase(_oneof_case_[0]); +} +// ------------------------------------------------------------------- + +// SearchParamPB + +// string collection_name = 1; +inline void SearchParamPB::clear_collection_name() { + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& SearchParamPB::collection_name() const { + // @@protoc_insertion_point(field_get:milvus.grpc.SearchParamPB.collection_name) + return collection_name_.GetNoArena(); +} +inline void SearchParamPB::set_collection_name(const std::string& value) { + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.SearchParamPB.collection_name) +} +inline void SearchParamPB::set_collection_name(std::string&& value) { + + collection_name_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.SearchParamPB.collection_name) +} +inline void SearchParamPB::set_collection_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.SearchParamPB.collection_name) +} +inline void SearchParamPB::set_collection_name(const char* value, size_t size) { + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.SearchParamPB.collection_name) +} +inline std::string* SearchParamPB::mutable_collection_name() { + + // @@protoc_insertion_point(field_mutable:milvus.grpc.SearchParamPB.collection_name) + return collection_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* SearchParamPB::release_collection_name() { + // @@protoc_insertion_point(field_release:milvus.grpc.SearchParamPB.collection_name) + + return collection_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void SearchParamPB::set_allocated_collection_name(std::string* collection_name) { + if (collection_name != nullptr) { + + } else { + + } + collection_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), collection_name); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.SearchParamPB.collection_name) +} + +// repeated string partition_tag_array = 2; +inline int SearchParamPB::partition_tag_array_size() const { + return partition_tag_array_.size(); +} +inline void SearchParamPB::clear_partition_tag_array() { + partition_tag_array_.Clear(); +} +inline const std::string& SearchParamPB::partition_tag_array(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.SearchParamPB.partition_tag_array) + return partition_tag_array_.Get(index); +} +inline std::string* SearchParamPB::mutable_partition_tag_array(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.SearchParamPB.partition_tag_array) + return partition_tag_array_.Mutable(index); +} +inline void SearchParamPB::set_partition_tag_array(int index, const std::string& value) { + // @@protoc_insertion_point(field_set:milvus.grpc.SearchParamPB.partition_tag_array) + partition_tag_array_.Mutable(index)->assign(value); +} +inline void SearchParamPB::set_partition_tag_array(int index, std::string&& value) { + // @@protoc_insertion_point(field_set:milvus.grpc.SearchParamPB.partition_tag_array) + partition_tag_array_.Mutable(index)->assign(std::move(value)); +} +inline void SearchParamPB::set_partition_tag_array(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + partition_tag_array_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:milvus.grpc.SearchParamPB.partition_tag_array) +} +inline void SearchParamPB::set_partition_tag_array(int index, const char* value, size_t size) { + partition_tag_array_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.SearchParamPB.partition_tag_array) +} +inline std::string* SearchParamPB::add_partition_tag_array() { + // @@protoc_insertion_point(field_add_mutable:milvus.grpc.SearchParamPB.partition_tag_array) + return partition_tag_array_.Add(); +} +inline void SearchParamPB::add_partition_tag_array(const std::string& value) { + partition_tag_array_.Add()->assign(value); + // @@protoc_insertion_point(field_add:milvus.grpc.SearchParamPB.partition_tag_array) +} +inline void SearchParamPB::add_partition_tag_array(std::string&& value) { + partition_tag_array_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:milvus.grpc.SearchParamPB.partition_tag_array) +} +inline void SearchParamPB::add_partition_tag_array(const char* value) { + GOOGLE_DCHECK(value != nullptr); + partition_tag_array_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:milvus.grpc.SearchParamPB.partition_tag_array) +} +inline void SearchParamPB::add_partition_tag_array(const char* value, size_t size) { + partition_tag_array_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:milvus.grpc.SearchParamPB.partition_tag_array) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +SearchParamPB::partition_tag_array() const { + // @@protoc_insertion_point(field_list:milvus.grpc.SearchParamPB.partition_tag_array) + return partition_tag_array_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +SearchParamPB::mutable_partition_tag_array() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.SearchParamPB.partition_tag_array) + return &partition_tag_array_; +} + +// .milvus.grpc.GeneralQuery general_query = 3; +inline bool SearchParamPB::has_general_query() const { + return this != internal_default_instance() && general_query_ != nullptr; +} +inline void SearchParamPB::clear_general_query() { + if (GetArenaNoVirtual() == nullptr && general_query_ != nullptr) { + delete general_query_; + } + general_query_ = nullptr; +} +inline const ::milvus::grpc::GeneralQuery& SearchParamPB::general_query() const { + const ::milvus::grpc::GeneralQuery* p = general_query_; + // @@protoc_insertion_point(field_get:milvus.grpc.SearchParamPB.general_query) + return p != nullptr ? *p : *reinterpret_cast( + &::milvus::grpc::_GeneralQuery_default_instance_); +} +inline ::milvus::grpc::GeneralQuery* SearchParamPB::release_general_query() { + // @@protoc_insertion_point(field_release:milvus.grpc.SearchParamPB.general_query) + + ::milvus::grpc::GeneralQuery* temp = general_query_; + general_query_ = nullptr; + return temp; +} +inline ::milvus::grpc::GeneralQuery* SearchParamPB::mutable_general_query() { + + if (general_query_ == nullptr) { + auto* p = CreateMaybeMessage<::milvus::grpc::GeneralQuery>(GetArenaNoVirtual()); + general_query_ = p; + } + // @@protoc_insertion_point(field_mutable:milvus.grpc.SearchParamPB.general_query) + return general_query_; +} +inline void SearchParamPB::set_allocated_general_query(::milvus::grpc::GeneralQuery* general_query) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete general_query_; + } + if (general_query) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + general_query = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, general_query, submessage_arena); + } + + } else { + + } + general_query_ = general_query; + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.SearchParamPB.general_query) +} + +// repeated .milvus.grpc.KeyValuePair extra_params = 4; +inline int SearchParamPB::extra_params_size() const { + return extra_params_.size(); +} +inline void SearchParamPB::clear_extra_params() { + extra_params_.Clear(); +} +inline ::milvus::grpc::KeyValuePair* SearchParamPB::mutable_extra_params(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.SearchParamPB.extra_params) + return extra_params_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >* +SearchParamPB::mutable_extra_params() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.SearchParamPB.extra_params) + return &extra_params_; +} +inline const ::milvus::grpc::KeyValuePair& SearchParamPB::extra_params(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.SearchParamPB.extra_params) + return extra_params_.Get(index); +} +inline ::milvus::grpc::KeyValuePair* SearchParamPB::add_extra_params() { + // @@protoc_insertion_point(field_add:milvus.grpc.SearchParamPB.extra_params) + return extra_params_.Add(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >& +SearchParamPB::extra_params() const { + // @@protoc_insertion_point(field_list:milvus.grpc.SearchParamPB.extra_params) + return extra_params_; +} + +// ------------------------------------------------------------------- + +// InsertOrDeleteMsg + +// string collection_name = 1; +inline void InsertOrDeleteMsg::clear_collection_name() { + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& InsertOrDeleteMsg::collection_name() const { + // @@protoc_insertion_point(field_get:milvus.grpc.InsertOrDeleteMsg.collection_name) + return collection_name_.GetNoArena(); +} +inline void InsertOrDeleteMsg::set_collection_name(const std::string& value) { + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.InsertOrDeleteMsg.collection_name) +} +inline void InsertOrDeleteMsg::set_collection_name(std::string&& value) { + + collection_name_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.InsertOrDeleteMsg.collection_name) +} +inline void InsertOrDeleteMsg::set_collection_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.InsertOrDeleteMsg.collection_name) +} +inline void InsertOrDeleteMsg::set_collection_name(const char* value, size_t size) { + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.InsertOrDeleteMsg.collection_name) +} +inline std::string* InsertOrDeleteMsg::mutable_collection_name() { + + // @@protoc_insertion_point(field_mutable:milvus.grpc.InsertOrDeleteMsg.collection_name) + return collection_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* InsertOrDeleteMsg::release_collection_name() { + // @@protoc_insertion_point(field_release:milvus.grpc.InsertOrDeleteMsg.collection_name) + + return collection_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void InsertOrDeleteMsg::set_allocated_collection_name(std::string* collection_name) { + if (collection_name != nullptr) { + + } else { + + } + collection_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), collection_name); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.InsertOrDeleteMsg.collection_name) +} + +// .milvus.grpc.RowData rows_data = 2; +inline bool InsertOrDeleteMsg::has_rows_data() const { + return this != internal_default_instance() && rows_data_ != nullptr; +} +inline void InsertOrDeleteMsg::clear_rows_data() { + if (GetArenaNoVirtual() == nullptr && rows_data_ != nullptr) { + delete rows_data_; + } + rows_data_ = nullptr; +} +inline const ::milvus::grpc::RowData& InsertOrDeleteMsg::rows_data() const { + const ::milvus::grpc::RowData* p = rows_data_; + // @@protoc_insertion_point(field_get:milvus.grpc.InsertOrDeleteMsg.rows_data) + return p != nullptr ? *p : *reinterpret_cast( + &::milvus::grpc::_RowData_default_instance_); +} +inline ::milvus::grpc::RowData* InsertOrDeleteMsg::release_rows_data() { + // @@protoc_insertion_point(field_release:milvus.grpc.InsertOrDeleteMsg.rows_data) + + ::milvus::grpc::RowData* temp = rows_data_; + rows_data_ = nullptr; + return temp; +} +inline ::milvus::grpc::RowData* InsertOrDeleteMsg::mutable_rows_data() { + + if (rows_data_ == nullptr) { + auto* p = CreateMaybeMessage<::milvus::grpc::RowData>(GetArenaNoVirtual()); + rows_data_ = p; + } + // @@protoc_insertion_point(field_mutable:milvus.grpc.InsertOrDeleteMsg.rows_data) + return rows_data_; +} +inline void InsertOrDeleteMsg::set_allocated_rows_data(::milvus::grpc::RowData* rows_data) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete rows_data_; + } + if (rows_data) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + rows_data = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, rows_data, submessage_arena); + } + + } else { + + } + rows_data_ = rows_data; + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.InsertOrDeleteMsg.rows_data) +} + +// int64 uid = 3; +inline void InsertOrDeleteMsg::clear_uid() { + uid_ = PROTOBUF_LONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::int64 InsertOrDeleteMsg::uid() const { + // @@protoc_insertion_point(field_get:milvus.grpc.InsertOrDeleteMsg.uid) + return uid_; +} +inline void InsertOrDeleteMsg::set_uid(::PROTOBUF_NAMESPACE_ID::int64 value) { + + uid_ = value; + // @@protoc_insertion_point(field_set:milvus.grpc.InsertOrDeleteMsg.uid) +} + +// string partition_tag = 4; +inline void InsertOrDeleteMsg::clear_partition_tag() { + partition_tag_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& InsertOrDeleteMsg::partition_tag() const { + // @@protoc_insertion_point(field_get:milvus.grpc.InsertOrDeleteMsg.partition_tag) + return partition_tag_.GetNoArena(); +} +inline void InsertOrDeleteMsg::set_partition_tag(const std::string& value) { + + partition_tag_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.InsertOrDeleteMsg.partition_tag) +} +inline void InsertOrDeleteMsg::set_partition_tag(std::string&& value) { + + partition_tag_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.InsertOrDeleteMsg.partition_tag) +} +inline void InsertOrDeleteMsg::set_partition_tag(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + partition_tag_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.InsertOrDeleteMsg.partition_tag) +} +inline void InsertOrDeleteMsg::set_partition_tag(const char* value, size_t size) { + + partition_tag_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.InsertOrDeleteMsg.partition_tag) +} +inline std::string* InsertOrDeleteMsg::mutable_partition_tag() { + + // @@protoc_insertion_point(field_mutable:milvus.grpc.InsertOrDeleteMsg.partition_tag) + return partition_tag_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* InsertOrDeleteMsg::release_partition_tag() { + // @@protoc_insertion_point(field_release:milvus.grpc.InsertOrDeleteMsg.partition_tag) + + return partition_tag_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void InsertOrDeleteMsg::set_allocated_partition_tag(std::string* partition_tag) { + if (partition_tag != nullptr) { + + } else { + + } + partition_tag_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), partition_tag); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.InsertOrDeleteMsg.partition_tag) +} + +// uint64 timestamp = 5; +inline void InsertOrDeleteMsg::clear_timestamp() { + timestamp_ = PROTOBUF_ULONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::uint64 InsertOrDeleteMsg::timestamp() const { + // @@protoc_insertion_point(field_get:milvus.grpc.InsertOrDeleteMsg.timestamp) + return timestamp_; +} +inline void InsertOrDeleteMsg::set_timestamp(::PROTOBUF_NAMESPACE_ID::uint64 value) { + + timestamp_ = value; + // @@protoc_insertion_point(field_set:milvus.grpc.InsertOrDeleteMsg.timestamp) +} + +// int64 segment_id = 6; +inline void InsertOrDeleteMsg::clear_segment_id() { + segment_id_ = PROTOBUF_LONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::int64 InsertOrDeleteMsg::segment_id() const { + // @@protoc_insertion_point(field_get:milvus.grpc.InsertOrDeleteMsg.segment_id) + return segment_id_; +} +inline void InsertOrDeleteMsg::set_segment_id(::PROTOBUF_NAMESPACE_ID::int64 value) { + + segment_id_ = value; + // @@protoc_insertion_point(field_set:milvus.grpc.InsertOrDeleteMsg.segment_id) +} + +// int64 channel_id = 7; +inline void InsertOrDeleteMsg::clear_channel_id() { + channel_id_ = PROTOBUF_LONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::int64 InsertOrDeleteMsg::channel_id() const { + // @@protoc_insertion_point(field_get:milvus.grpc.InsertOrDeleteMsg.channel_id) + return channel_id_; +} +inline void InsertOrDeleteMsg::set_channel_id(::PROTOBUF_NAMESPACE_ID::int64 value) { + + channel_id_ = value; + // @@protoc_insertion_point(field_set:milvus.grpc.InsertOrDeleteMsg.channel_id) +} + +// .milvus.grpc.OpType op = 8; +inline void InsertOrDeleteMsg::clear_op() { + op_ = 0; +} +inline ::milvus::grpc::OpType InsertOrDeleteMsg::op() const { + // @@protoc_insertion_point(field_get:milvus.grpc.InsertOrDeleteMsg.op) + return static_cast< ::milvus::grpc::OpType >(op_); +} +inline void InsertOrDeleteMsg::set_op(::milvus::grpc::OpType value) { + + op_ = value; + // @@protoc_insertion_point(field_set:milvus.grpc.InsertOrDeleteMsg.op) +} + +// int64 client_id = 9; +inline void InsertOrDeleteMsg::clear_client_id() { + client_id_ = PROTOBUF_LONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::int64 InsertOrDeleteMsg::client_id() const { + // @@protoc_insertion_point(field_get:milvus.grpc.InsertOrDeleteMsg.client_id) + return client_id_; +} +inline void InsertOrDeleteMsg::set_client_id(::PROTOBUF_NAMESPACE_ID::int64 value) { + + client_id_ = value; + // @@protoc_insertion_point(field_set:milvus.grpc.InsertOrDeleteMsg.client_id) +} + +// repeated .milvus.grpc.KeyValuePair extra_params = 10; +inline int InsertOrDeleteMsg::extra_params_size() const { + return extra_params_.size(); +} +inline void InsertOrDeleteMsg::clear_extra_params() { + extra_params_.Clear(); +} +inline ::milvus::grpc::KeyValuePair* InsertOrDeleteMsg::mutable_extra_params(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.InsertOrDeleteMsg.extra_params) + return extra_params_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >* +InsertOrDeleteMsg::mutable_extra_params() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.InsertOrDeleteMsg.extra_params) + return &extra_params_; +} +inline const ::milvus::grpc::KeyValuePair& InsertOrDeleteMsg::extra_params(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.InsertOrDeleteMsg.extra_params) + return extra_params_.Get(index); +} +inline ::milvus::grpc::KeyValuePair* InsertOrDeleteMsg::add_extra_params() { + // @@protoc_insertion_point(field_add:milvus.grpc.InsertOrDeleteMsg.extra_params) + return extra_params_.Add(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >& +InsertOrDeleteMsg::extra_params() const { + // @@protoc_insertion_point(field_list:milvus.grpc.InsertOrDeleteMsg.extra_params) + return extra_params_; +} + +// ------------------------------------------------------------------- + +// SearchMsg + +// string collection_name = 1; +inline void SearchMsg::clear_collection_name() { + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& SearchMsg::collection_name() const { + // @@protoc_insertion_point(field_get:milvus.grpc.SearchMsg.collection_name) + return collection_name_.GetNoArena(); +} +inline void SearchMsg::set_collection_name(const std::string& value) { + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.SearchMsg.collection_name) +} +inline void SearchMsg::set_collection_name(std::string&& value) { + + collection_name_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.SearchMsg.collection_name) +} +inline void SearchMsg::set_collection_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.SearchMsg.collection_name) +} +inline void SearchMsg::set_collection_name(const char* value, size_t size) { + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.SearchMsg.collection_name) +} +inline std::string* SearchMsg::mutable_collection_name() { + + // @@protoc_insertion_point(field_mutable:milvus.grpc.SearchMsg.collection_name) + return collection_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* SearchMsg::release_collection_name() { + // @@protoc_insertion_point(field_release:milvus.grpc.SearchMsg.collection_name) + + return collection_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void SearchMsg::set_allocated_collection_name(std::string* collection_name) { + if (collection_name != nullptr) { + + } else { + + } + collection_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), collection_name); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.SearchMsg.collection_name) +} + +// .milvus.grpc.VectorRowRecord records = 2; +inline bool SearchMsg::has_records() const { + return this != internal_default_instance() && records_ != nullptr; +} +inline void SearchMsg::clear_records() { + if (GetArenaNoVirtual() == nullptr && records_ != nullptr) { + delete records_; + } + records_ = nullptr; +} +inline const ::milvus::grpc::VectorRowRecord& SearchMsg::records() const { + const ::milvus::grpc::VectorRowRecord* p = records_; + // @@protoc_insertion_point(field_get:milvus.grpc.SearchMsg.records) + return p != nullptr ? *p : *reinterpret_cast( + &::milvus::grpc::_VectorRowRecord_default_instance_); +} +inline ::milvus::grpc::VectorRowRecord* SearchMsg::release_records() { + // @@protoc_insertion_point(field_release:milvus.grpc.SearchMsg.records) + + ::milvus::grpc::VectorRowRecord* temp = records_; + records_ = nullptr; + return temp; +} +inline ::milvus::grpc::VectorRowRecord* SearchMsg::mutable_records() { + + if (records_ == nullptr) { + auto* p = CreateMaybeMessage<::milvus::grpc::VectorRowRecord>(GetArenaNoVirtual()); + records_ = p; + } + // @@protoc_insertion_point(field_mutable:milvus.grpc.SearchMsg.records) + return records_; +} +inline void SearchMsg::set_allocated_records(::milvus::grpc::VectorRowRecord* records) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete records_; + } + if (records) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + records = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, records, submessage_arena); + } + + } else { + + } + records_ = records; + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.SearchMsg.records) +} + +// repeated string partition_tag = 3; +inline int SearchMsg::partition_tag_size() const { + return partition_tag_.size(); +} +inline void SearchMsg::clear_partition_tag() { + partition_tag_.Clear(); +} +inline const std::string& SearchMsg::partition_tag(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.SearchMsg.partition_tag) + return partition_tag_.Get(index); +} +inline std::string* SearchMsg::mutable_partition_tag(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.SearchMsg.partition_tag) + return partition_tag_.Mutable(index); +} +inline void SearchMsg::set_partition_tag(int index, const std::string& value) { + // @@protoc_insertion_point(field_set:milvus.grpc.SearchMsg.partition_tag) + partition_tag_.Mutable(index)->assign(value); +} +inline void SearchMsg::set_partition_tag(int index, std::string&& value) { + // @@protoc_insertion_point(field_set:milvus.grpc.SearchMsg.partition_tag) + partition_tag_.Mutable(index)->assign(std::move(value)); +} +inline void SearchMsg::set_partition_tag(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + partition_tag_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:milvus.grpc.SearchMsg.partition_tag) +} +inline void SearchMsg::set_partition_tag(int index, const char* value, size_t size) { + partition_tag_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.SearchMsg.partition_tag) +} +inline std::string* SearchMsg::add_partition_tag() { + // @@protoc_insertion_point(field_add_mutable:milvus.grpc.SearchMsg.partition_tag) + return partition_tag_.Add(); +} +inline void SearchMsg::add_partition_tag(const std::string& value) { + partition_tag_.Add()->assign(value); + // @@protoc_insertion_point(field_add:milvus.grpc.SearchMsg.partition_tag) +} +inline void SearchMsg::add_partition_tag(std::string&& value) { + partition_tag_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:milvus.grpc.SearchMsg.partition_tag) +} +inline void SearchMsg::add_partition_tag(const char* value) { + GOOGLE_DCHECK(value != nullptr); + partition_tag_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:milvus.grpc.SearchMsg.partition_tag) +} +inline void SearchMsg::add_partition_tag(const char* value, size_t size) { + partition_tag_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:milvus.grpc.SearchMsg.partition_tag) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +SearchMsg::partition_tag() const { + // @@protoc_insertion_point(field_list:milvus.grpc.SearchMsg.partition_tag) + return partition_tag_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +SearchMsg::mutable_partition_tag() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.SearchMsg.partition_tag) + return &partition_tag_; +} + +// int64 uid = 4; +inline void SearchMsg::clear_uid() { + uid_ = PROTOBUF_LONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::int64 SearchMsg::uid() const { + // @@protoc_insertion_point(field_get:milvus.grpc.SearchMsg.uid) + return uid_; +} +inline void SearchMsg::set_uid(::PROTOBUF_NAMESPACE_ID::int64 value) { + + uid_ = value; + // @@protoc_insertion_point(field_set:milvus.grpc.SearchMsg.uid) +} + +// uint64 timestamp = 5; +inline void SearchMsg::clear_timestamp() { + timestamp_ = PROTOBUF_ULONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::uint64 SearchMsg::timestamp() const { + // @@protoc_insertion_point(field_get:milvus.grpc.SearchMsg.timestamp) + return timestamp_; +} +inline void SearchMsg::set_timestamp(::PROTOBUF_NAMESPACE_ID::uint64 value) { + + timestamp_ = value; + // @@protoc_insertion_point(field_set:milvus.grpc.SearchMsg.timestamp) +} + +// int64 client_id = 6; +inline void SearchMsg::clear_client_id() { + client_id_ = PROTOBUF_LONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::int64 SearchMsg::client_id() const { + // @@protoc_insertion_point(field_get:milvus.grpc.SearchMsg.client_id) + return client_id_; +} +inline void SearchMsg::set_client_id(::PROTOBUF_NAMESPACE_ID::int64 value) { + + client_id_ = value; + // @@protoc_insertion_point(field_set:milvus.grpc.SearchMsg.client_id) +} + +// repeated .milvus.grpc.KeyValuePair extra_params = 7; +inline int SearchMsg::extra_params_size() const { + return extra_params_.size(); +} +inline void SearchMsg::clear_extra_params() { + extra_params_.Clear(); +} +inline ::milvus::grpc::KeyValuePair* SearchMsg::mutable_extra_params(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.SearchMsg.extra_params) + return extra_params_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >* +SearchMsg::mutable_extra_params() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.SearchMsg.extra_params) + return &extra_params_; +} +inline const ::milvus::grpc::KeyValuePair& SearchMsg::extra_params(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.SearchMsg.extra_params) + return extra_params_.Get(index); +} +inline ::milvus::grpc::KeyValuePair* SearchMsg::add_extra_params() { + // @@protoc_insertion_point(field_add:milvus.grpc.SearchMsg.extra_params) + return extra_params_.Add(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >& +SearchMsg::extra_params() const { + // @@protoc_insertion_point(field_list:milvus.grpc.SearchMsg.extra_params) + return extra_params_; +} + +// repeated string json = 8; +inline int SearchMsg::json_size() const { + return json_.size(); +} +inline void SearchMsg::clear_json() { + json_.Clear(); +} +inline const std::string& SearchMsg::json(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.SearchMsg.json) + return json_.Get(index); +} +inline std::string* SearchMsg::mutable_json(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.SearchMsg.json) + return json_.Mutable(index); +} +inline void SearchMsg::set_json(int index, const std::string& value) { + // @@protoc_insertion_point(field_set:milvus.grpc.SearchMsg.json) + json_.Mutable(index)->assign(value); +} +inline void SearchMsg::set_json(int index, std::string&& value) { + // @@protoc_insertion_point(field_set:milvus.grpc.SearchMsg.json) + json_.Mutable(index)->assign(std::move(value)); +} +inline void SearchMsg::set_json(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + json_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:milvus.grpc.SearchMsg.json) +} +inline void SearchMsg::set_json(int index, const char* value, size_t size) { + json_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.SearchMsg.json) +} +inline std::string* SearchMsg::add_json() { + // @@protoc_insertion_point(field_add_mutable:milvus.grpc.SearchMsg.json) + return json_.Add(); +} +inline void SearchMsg::add_json(const std::string& value) { + json_.Add()->assign(value); + // @@protoc_insertion_point(field_add:milvus.grpc.SearchMsg.json) +} +inline void SearchMsg::add_json(std::string&& value) { + json_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:milvus.grpc.SearchMsg.json) +} +inline void SearchMsg::add_json(const char* value) { + GOOGLE_DCHECK(value != nullptr); + json_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:milvus.grpc.SearchMsg.json) +} +inline void SearchMsg::add_json(const char* value, size_t size) { + json_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:milvus.grpc.SearchMsg.json) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +SearchMsg::json() const { + // @@protoc_insertion_point(field_list:milvus.grpc.SearchMsg.json) + return json_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +SearchMsg::mutable_json() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.SearchMsg.json) + return &json_; +} + +// string dsl = 9; +inline void SearchMsg::clear_dsl() { + dsl_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& SearchMsg::dsl() const { + // @@protoc_insertion_point(field_get:milvus.grpc.SearchMsg.dsl) + return dsl_.GetNoArena(); +} +inline void SearchMsg::set_dsl(const std::string& value) { + + dsl_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.SearchMsg.dsl) +} +inline void SearchMsg::set_dsl(std::string&& value) { + + dsl_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.SearchMsg.dsl) +} +inline void SearchMsg::set_dsl(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + dsl_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.SearchMsg.dsl) +} +inline void SearchMsg::set_dsl(const char* value, size_t size) { + + dsl_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.SearchMsg.dsl) +} +inline std::string* SearchMsg::mutable_dsl() { + + // @@protoc_insertion_point(field_mutable:milvus.grpc.SearchMsg.dsl) + return dsl_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* SearchMsg::release_dsl() { + // @@protoc_insertion_point(field_release:milvus.grpc.SearchMsg.dsl) + + return dsl_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void SearchMsg::set_allocated_dsl(std::string* dsl) { + if (dsl != nullptr) { + + } else { + + } + dsl_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), dsl); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.SearchMsg.dsl) +} + +// ------------------------------------------------------------------- + +// TimeSyncMsg + +// int64 peer_Id = 1; +inline void TimeSyncMsg::clear_peer_id() { + peer_id_ = PROTOBUF_LONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::int64 TimeSyncMsg::peer_id() const { + // @@protoc_insertion_point(field_get:milvus.grpc.TimeSyncMsg.peer_Id) + return peer_id_; +} +inline void TimeSyncMsg::set_peer_id(::PROTOBUF_NAMESPACE_ID::int64 value) { + + peer_id_ = value; + // @@protoc_insertion_point(field_set:milvus.grpc.TimeSyncMsg.peer_Id) +} + +// uint64 Timestamp = 2; +inline void TimeSyncMsg::clear_timestamp() { + timestamp_ = PROTOBUF_ULONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::uint64 TimeSyncMsg::timestamp() const { + // @@protoc_insertion_point(field_get:milvus.grpc.TimeSyncMsg.Timestamp) + return timestamp_; +} +inline void TimeSyncMsg::set_timestamp(::PROTOBUF_NAMESPACE_ID::uint64 value) { + + timestamp_ = value; + // @@protoc_insertion_point(field_set:milvus.grpc.TimeSyncMsg.Timestamp) +} + +// .milvus.grpc.SyncType sync_type = 3; +inline void TimeSyncMsg::clear_sync_type() { + sync_type_ = 0; +} +inline ::milvus::grpc::SyncType TimeSyncMsg::sync_type() const { + // @@protoc_insertion_point(field_get:milvus.grpc.TimeSyncMsg.sync_type) + return static_cast< ::milvus::grpc::SyncType >(sync_type_); +} +inline void TimeSyncMsg::set_sync_type(::milvus::grpc::SyncType value) { + + sync_type_ = value; + // @@protoc_insertion_point(field_set:milvus.grpc.TimeSyncMsg.sync_type) +} + +// ------------------------------------------------------------------- + +// Key2SegMsg + +// int64 uid = 1; +inline void Key2SegMsg::clear_uid() { + uid_ = PROTOBUF_LONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::int64 Key2SegMsg::uid() const { + // @@protoc_insertion_point(field_get:milvus.grpc.Key2SegMsg.uid) + return uid_; +} +inline void Key2SegMsg::set_uid(::PROTOBUF_NAMESPACE_ID::int64 value) { + + uid_ = value; + // @@protoc_insertion_point(field_set:milvus.grpc.Key2SegMsg.uid) +} + +// uint64 timestamp = 2; +inline void Key2SegMsg::clear_timestamp() { + timestamp_ = PROTOBUF_ULONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::uint64 Key2SegMsg::timestamp() const { + // @@protoc_insertion_point(field_get:milvus.grpc.Key2SegMsg.timestamp) + return timestamp_; +} +inline void Key2SegMsg::set_timestamp(::PROTOBUF_NAMESPACE_ID::uint64 value) { + + timestamp_ = value; + // @@protoc_insertion_point(field_set:milvus.grpc.Key2SegMsg.timestamp) +} + +// repeated int64 segment_id = 3; +inline int Key2SegMsg::segment_id_size() const { + return segment_id_.size(); +} +inline void Key2SegMsg::clear_segment_id() { + segment_id_.Clear(); +} +inline ::PROTOBUF_NAMESPACE_ID::int64 Key2SegMsg::segment_id(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.Key2SegMsg.segment_id) + return segment_id_.Get(index); +} +inline void Key2SegMsg::set_segment_id(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) { + segment_id_.Set(index, value); + // @@protoc_insertion_point(field_set:milvus.grpc.Key2SegMsg.segment_id) +} +inline void Key2SegMsg::add_segment_id(::PROTOBUF_NAMESPACE_ID::int64 value) { + segment_id_.Add(value); + // @@protoc_insertion_point(field_add:milvus.grpc.Key2SegMsg.segment_id) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >& +Key2SegMsg::segment_id() const { + // @@protoc_insertion_point(field_list:milvus.grpc.Key2SegMsg.segment_id) + return segment_id_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >* +Key2SegMsg::mutable_segment_id() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.Key2SegMsg.segment_id) + return &segment_id_; +} + +#ifdef __GNUC__ + #pragma GCC diagnostic pop +#endif // __GNUC__ +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace grpc +} // namespace milvus + +PROTOBUF_NAMESPACE_OPEN + +template <> struct is_proto_enum< ::milvus::grpc::ErrorCode> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::milvus::grpc::ErrorCode>() { + return ::milvus::grpc::ErrorCode_descriptor(); +} +template <> struct is_proto_enum< ::milvus::grpc::DataType> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::milvus::grpc::DataType>() { + return ::milvus::grpc::DataType_descriptor(); +} +template <> struct is_proto_enum< ::milvus::grpc::CompareOperator> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::milvus::grpc::CompareOperator>() { + return ::milvus::grpc::CompareOperator_descriptor(); +} +template <> struct is_proto_enum< ::milvus::grpc::Occur> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::milvus::grpc::Occur>() { + return ::milvus::grpc::Occur_descriptor(); +} +template <> struct is_proto_enum< ::milvus::grpc::OpType> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::milvus::grpc::OpType>() { + return ::milvus::grpc::OpType_descriptor(); +} +template <> struct is_proto_enum< ::milvus::grpc::SyncType> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::milvus::grpc::SyncType>() { + return ::milvus::grpc::SyncType_descriptor(); +} + +PROTOBUF_NAMESPACE_CLOSE + +// @@protoc_insertion_point(global_scope) + +#include +#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_message_2eproto diff --git a/core/src/utils/Types.h b/core/src/utils/Types.h index f394e5b23d..7cecae6ac0 100644 --- a/core/src/utils/Types.h +++ b/core/src/utils/Types.h @@ -41,6 +41,7 @@ using ResultIds = std::vector; using ResultDistances = std::vector; /////////////////////////////////////////////////////////////////////////////////////////////////// + enum class DataType { NONE = 0, BOOL = 1, diff --git a/core/thirdparty/CMakeLists.txt b/core/thirdparty/CMakeLists.txt index 233140a68a..0d0c4f6bd5 100644 --- a/core/thirdparty/CMakeLists.txt +++ b/core/thirdparty/CMakeLists.txt @@ -45,4 +45,6 @@ endif() # ****************************** Thirdparty opentracing *************************************** if ( MILVUS_WITH_OPENTRACING ) add_subdirectory( opentracing ) -endif() \ No newline at end of file +endif() + +add_subdirectory( protobuf ) diff --git a/core/thirdparty/protobuf/CMakeLists.txt b/core/thirdparty/protobuf/CMakeLists.txt new file mode 100644 index 0000000000..373a114d32 --- /dev/null +++ b/core/thirdparty/protobuf/CMakeLists.txt @@ -0,0 +1,66 @@ +# Copyright 2017 gRPC authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +if ( DEFINED ENV{MILVUS_GTEST_URL} ) + set( GTEST_SOURCE_URL "$ENV{MILVUS_GTEST_URL}" ) +else() + set( GTEST_SOURCE_URL + "https://github.com/protocolbuffers/protobuf/releases/download/v3.9.0/protobuf-cpp-3.9.0.zip") +endif() + +message( STATUS "Building protobuf-cpp-3.9.0 from source" ) + +FetchContent_Declare( + protobuf + URL ${GTEST_SOURCE_URL} + URL_MD5 "9562b27cc6ac5ebd087f201f1310c885" + DOWNLOAD_DIR ${MILVUS_BINARY_DIR}/3rdparty_download/download + SOURCE_DIR ${CMAKE_CURRENT_BINARY_DIR}/protobuf-src + BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR}/protobuf-build + +) + + +if ( NOT protobuf_POPULATED ) + FetchContent_Populate( protobuf ) + + add_subdirectory(${protobuf_SOURCE_DIR}/cmake + ${protobuf_BINARY_DIR} + EXCLUDE_FROM_ALL) + +endif() + + +set(_PROTOBUF_LIBRARY_NAME "libprotobuf") +set(gRPC_PROTOBUF_PROVIDER "module" CACHE STRING "Provider of protobuf library") +set_property(CACHE gRPC_PROTOBUF_PROVIDER PROPERTY STRINGS "module" "package") + +# Building the protobuf tests require gmock what is not part of a standard protobuf checkout. +# Disable them unless they are explicitly requested from the cmake command line (when we assume +# gmock is downloaded to the right location inside protobuf). +if(NOT protobuf_BUILD_TESTS) +set(protobuf_BUILD_TESTS OFF CACHE BOOL "Build protobuf tests") +endif() + +# Disable building protobuf with zlib. Building protobuf with zlib breaks +# the build if zlib is not installed on the system. +if(NOT protobuf_WITH_ZLIB) +set(protobuf_WITH_ZLIB OFF CACHE BOOL "Build protobuf with zlib.") +endif() + +if(NOT PROTOBUF_ROOT_DIR) + #set(PROTOBUF_ROOT_DIR ${CMAKE_CURRENT_SOURCE_DIR}/third_party/protobuf) + set(PROTOBUF_ROOT_DIR ${protobuf_SOURCE_DIR}) +endif() + diff --git a/core/thirdparty/versions.txt b/core/thirdparty/versions.txt index 47a2c01301..f4862e989e 100644 --- a/core/thirdparty/versions.txt +++ b/core/thirdparty/versions.txt @@ -3,4 +3,5 @@ GTEST_VERSION=1.8.1 YAMLCPP_VERSION=0.6.3 ZLIB_VERSION=v1.2.11 OPENTRACING_VERSION=v1.5.1 +PROTOBUF_VERSION=3.9.0 # vim: set filetype=sh: diff --git a/core/unittest/test_c_api.cpp b/core/unittest/test_c_api.cpp index 6aaf05e494..e349885330 100644 --- a/core/unittest/test_c_api.cpp +++ b/core/unittest/test_c_api.cpp @@ -247,6 +247,50 @@ TEST(CApiTest, CloseTest) { } +TEST(CApiTest, GetMemoryUsageInBytesTest) { + auto collection_name = "collection0"; + auto schema_tmp_conf = "null_schema"; + auto collection = NewCollection(collection_name, schema_tmp_conf); + auto partition_name = "partition0"; + auto partition = NewPartition(collection, partition_name); + auto segment = NewSegment(partition, 0); + + std::vector raw_data; + std::vector timestamps; + std::vector uids; + int N = 10000; + std::default_random_engine e(67); + for (int i = 0; i < N; ++i) { + uids.push_back(100000 + i); + timestamps.push_back(0); + // append vec + float vec[16]; + for (auto &x: vec) { + x = e() % 2000 * 0.001 - 1.0; + } + raw_data.insert(raw_data.end(), (const char *) std::begin(vec), (const char *) std::end(vec)); + int age = e() % 100; + raw_data.insert(raw_data.end(), (const char *) &age, ((const char *) &age) + sizeof(age)); + } + + auto line_sizeof = (sizeof(int) + sizeof(float) * 16); + + auto offset = PreInsert(segment, N); + + auto res = Insert(segment, offset, N, uids.data(), timestamps.data(), raw_data.data(), (int) line_sizeof, N); + + assert(res == 0); + + auto memory_usage_size = GetMemoryUsageInBytes(segment); + + assert(memory_usage_size == 1898459); + + DeleteCollection(collection); + DeletePartition(partition); + DeleteSegment(segment); +} + + namespace { auto generate_data(int N) { std::vector raw_data; diff --git a/pkg/master/common/config.go b/pkg/master/common/config.go index 219d561d4c..fa77ddfaff 100644 --- a/pkg/master/common/config.go +++ b/pkg/master/common/config.go @@ -3,7 +3,7 @@ package common import "time" const ( - PULSAR_URL = "pulsar://localhost:16650" + PULSAR_URL = "pulsar://localhost:6650" PULSAR_MONITER_INTERVAL = 1 * time.Second PULSAR_TOPIC = "monitor-topic" ETCD_ROOT_PATH = "by-dev" diff --git a/pkg/master/kv/etcd_kv.go b/pkg/master/kv/etcd_kv.go index dcdd065dd5..081cc8b35f 100644 --- a/pkg/master/kv/etcd_kv.go +++ b/pkg/master/kv/etcd_kv.go @@ -34,6 +34,11 @@ func NewEtcdKVBase(client *clientv3.Client, rootPath string) *EtcdKVBase { } } +func (kv *EtcdKVBase) Close(){ + kv.client.Close() +} + + func (kv *EtcdKVBase) LoadWithPrefix(key string) ( []string, []string) { key = path.Join(kv.rootPath, key) println("in loadWithPrefix,", key) diff --git a/pkg/master/server.go b/pkg/master/server.go index c563de14ba..c893967785 100644 --- a/pkg/master/server.go +++ b/pkg/master/server.go @@ -184,7 +184,6 @@ func CollectionController(ch chan *messagepb.Mapping) { if err != nil { log.Fatal(err) } - } } diff --git a/proxy/src/CMakeLists.txt b/proxy/src/CMakeLists.txt index 96ac10c691..f17aa341da 100644 --- a/proxy/src/CMakeLists.txt +++ b/proxy/src/CMakeLists.txt @@ -80,7 +80,7 @@ set( SERVER_LIBS server ) add_executable( milvus_server ${CMAKE_CURRENT_SOURCE_DIR}/main.cpp ) -target_include_directories(server PUBLIC ${PROJECT_BINARY_DIR}/thirdparty/pulsar-client-cpp/pulsar-client-cpp-src/pulsar-client-cpp/include) +target_include_directories(server PRIVATE ${PROJECT_BINARY_DIR}/thirdparty) target_link_libraries( milvus_server PRIVATE ${SERVER_LIBS} ) diff --git a/proxy/src/config/ConfigMgr.cpp b/proxy/src/config/ConfigMgr.cpp index d19aa7cd7a..8d05793abf 100644 --- a/proxy/src/config/ConfigMgr.cpp +++ b/proxy/src/config/ConfigMgr.cpp @@ -82,7 +82,7 @@ ConfigMgr::ConfigMgr() { {"network.port", CreateIntegerConfig("network.port", false, 0, 65535, &config.network.port.value, 19530, nullptr, nullptr)}, - + /* pulsar */ {"pulsar.address", CreateStringConfig("pulsar.address", false, &config.pulsar.address.value, "localhost", nullptr, nullptr)}, @@ -94,6 +94,17 @@ ConfigMgr::ConfigMgr() { {"master.port", CreateIntegerConfig("master.port", false, 0, 65535, &config.master.port.value, 6000, nullptr, nullptr)}, + /* etcd */ + {"etcd.address", CreateStringConfig("etcd.address", false, &config.etcd.address.value, "localhost", nullptr, + nullptr)}, + {"etcd.port", CreateIntegerConfig("etcd.port", false, 0, 65535, &config.etcd.port.value, + 6000,nullptr, nullptr)}, + {"etcd.rootpath", CreateStringConfig("etcd.rootpath", false, &config.etcd.rootpath.value, "by-dev", nullptr, + nullptr)}, + + /* time sync */ + {"timesync.interval", CreateIntegerConfig("timesync.interval", false, 0, std::numeric_limits::max(), &config.timesync.interval.value, 10, + nullptr, nullptr)}, /* log */ {"logs.level", CreateStringConfig("logs.level", false, &config.logs.level.value, "debug", nullptr, nullptr)}, @@ -146,6 +157,9 @@ ConfigMgr::Load(const std::string& path) { // auto proxy_yaml = yaml["porxy"]; auto other_yaml = YAML::Node{}; other_yaml["pulsar"] = yaml["pulsar"]; + other_yaml["master"] = yaml["master"]; + other_yaml["etcd"] = yaml["etcd"]; + other_yaml["timesync"] = yaml["timesync"]; Flatten(yaml["proxy"], flattened, ""); Flatten(other_yaml, flattened, ""); // Flatten(yaml["proxy"], flattened, ""); diff --git a/proxy/src/config/ServerConfig.h b/proxy/src/config/ServerConfig.h index e7a9a2480a..321e9f9631 100644 --- a/proxy/src/config/ServerConfig.h +++ b/proxy/src/config/ServerConfig.h @@ -82,6 +82,15 @@ struct ServerConfig { Integer port{6000}; }master; + struct Etcd{ + String address{"localhost"}; + Integer port{2379}; + String rootpath{"by-dev"}; + }etcd; + + struct TimeSync{ + Integer interval{10}; + }timesync; struct Engine { Integer build_index_threshold{4096}; diff --git a/proxy/src/grpc/etcd.grpc.pb.cc b/proxy/src/grpc/etcd.grpc.pb.cc index d9a717cfc8..c4aaef0efa 100644 --- a/proxy/src/grpc/etcd.grpc.pb.cc +++ b/proxy/src/grpc/etcd.grpc.pb.cc @@ -66,5 +66,66 @@ Watch::Service::~Service() { } +static const char* KV_method_names[] = { + "/etcdserverpb.KV/Range", +}; + +std::unique_ptr< KV::Stub> KV::NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options) { + (void)options; + std::unique_ptr< KV::Stub> stub(new KV::Stub(channel)); + return stub; +} + +KV::Stub::Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel) + : channel_(channel), rpcmethod_Range_(KV_method_names[0], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + {} + +::grpc::Status KV::Stub::Range(::grpc::ClientContext* context, const ::etcdserverpb::RangeRequest& request, ::etcdserverpb::RangeResponse* response) { + return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_Range_, context, request, response); +} + +void KV::Stub::experimental_async::Range(::grpc::ClientContext* context, const ::etcdserverpb::RangeRequest* request, ::etcdserverpb::RangeResponse* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_Range_, context, request, response, std::move(f)); +} + +void KV::Stub::experimental_async::Range(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::etcdserverpb::RangeResponse* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_Range_, context, request, response, std::move(f)); +} + +void KV::Stub::experimental_async::Range(::grpc::ClientContext* context, const ::etcdserverpb::RangeRequest* request, ::etcdserverpb::RangeResponse* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_Range_, context, request, response, reactor); +} + +void KV::Stub::experimental_async::Range(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::etcdserverpb::RangeResponse* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_Range_, context, request, response, reactor); +} + +::grpc::ClientAsyncResponseReader< ::etcdserverpb::RangeResponse>* KV::Stub::AsyncRangeRaw(::grpc::ClientContext* context, const ::etcdserverpb::RangeRequest& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::etcdserverpb::RangeResponse>::Create(channel_.get(), cq, rpcmethod_Range_, context, request, true); +} + +::grpc::ClientAsyncResponseReader< ::etcdserverpb::RangeResponse>* KV::Stub::PrepareAsyncRangeRaw(::grpc::ClientContext* context, const ::etcdserverpb::RangeRequest& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::etcdserverpb::RangeResponse>::Create(channel_.get(), cq, rpcmethod_Range_, context, request, false); +} + +KV::Service::Service() { + AddMethod(new ::grpc::internal::RpcServiceMethod( + KV_method_names[0], + ::grpc::internal::RpcMethod::NORMAL_RPC, + new ::grpc::internal::RpcMethodHandler< KV::Service, ::etcdserverpb::RangeRequest, ::etcdserverpb::RangeResponse>( + std::mem_fn(&KV::Service::Range), this))); +} + +KV::Service::~Service() { +} + +::grpc::Status KV::Service::Range(::grpc::ServerContext* context, const ::etcdserverpb::RangeRequest* request, ::etcdserverpb::RangeResponse* response) { + (void) context; + (void) request; + (void) response; + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + + } // namespace etcdserverpb diff --git a/proxy/src/grpc/etcd.grpc.pb.h b/proxy/src/grpc/etcd.grpc.pb.h index 53ebd1aeba..9634666f43 100644 --- a/proxy/src/grpc/etcd.grpc.pb.h +++ b/proxy/src/grpc/etcd.grpc.pb.h @@ -229,6 +229,217 @@ class Watch final { typedef Service StreamedService; }; +class KV final { + public: + static constexpr char const* service_full_name() { + return "etcdserverpb.KV"; + } + class StubInterface { + public: + virtual ~StubInterface() {} + // Range gets the keys in the range from the key-value store. + virtual ::grpc::Status Range(::grpc::ClientContext* context, const ::etcdserverpb::RangeRequest& request, ::etcdserverpb::RangeResponse* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::etcdserverpb::RangeResponse>> AsyncRange(::grpc::ClientContext* context, const ::etcdserverpb::RangeRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::etcdserverpb::RangeResponse>>(AsyncRangeRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::etcdserverpb::RangeResponse>> PrepareAsyncRange(::grpc::ClientContext* context, const ::etcdserverpb::RangeRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::etcdserverpb::RangeResponse>>(PrepareAsyncRangeRaw(context, request, cq)); + } + class experimental_async_interface { + public: + virtual ~experimental_async_interface() {} + // Range gets the keys in the range from the key-value store. + virtual void Range(::grpc::ClientContext* context, const ::etcdserverpb::RangeRequest* request, ::etcdserverpb::RangeResponse* response, std::function) = 0; + virtual void Range(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::etcdserverpb::RangeResponse* response, std::function) = 0; + virtual void Range(::grpc::ClientContext* context, const ::etcdserverpb::RangeRequest* request, ::etcdserverpb::RangeResponse* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void Range(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::etcdserverpb::RangeResponse* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + }; + virtual class experimental_async_interface* experimental_async() { return nullptr; } + private: + virtual ::grpc::ClientAsyncResponseReaderInterface< ::etcdserverpb::RangeResponse>* AsyncRangeRaw(::grpc::ClientContext* context, const ::etcdserverpb::RangeRequest& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::etcdserverpb::RangeResponse>* PrepareAsyncRangeRaw(::grpc::ClientContext* context, const ::etcdserverpb::RangeRequest& request, ::grpc::CompletionQueue* cq) = 0; + }; + class Stub final : public StubInterface { + public: + Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel); + ::grpc::Status Range(::grpc::ClientContext* context, const ::etcdserverpb::RangeRequest& request, ::etcdserverpb::RangeResponse* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::etcdserverpb::RangeResponse>> AsyncRange(::grpc::ClientContext* context, const ::etcdserverpb::RangeRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::etcdserverpb::RangeResponse>>(AsyncRangeRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::etcdserverpb::RangeResponse>> PrepareAsyncRange(::grpc::ClientContext* context, const ::etcdserverpb::RangeRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::etcdserverpb::RangeResponse>>(PrepareAsyncRangeRaw(context, request, cq)); + } + class experimental_async final : + public StubInterface::experimental_async_interface { + public: + void Range(::grpc::ClientContext* context, const ::etcdserverpb::RangeRequest* request, ::etcdserverpb::RangeResponse* response, std::function) override; + void Range(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::etcdserverpb::RangeResponse* response, std::function) override; + void Range(::grpc::ClientContext* context, const ::etcdserverpb::RangeRequest* request, ::etcdserverpb::RangeResponse* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void Range(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::etcdserverpb::RangeResponse* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + private: + friend class Stub; + explicit experimental_async(Stub* stub): stub_(stub) { } + Stub* stub() { return stub_; } + Stub* stub_; + }; + class experimental_async_interface* experimental_async() override { return &async_stub_; } + + private: + std::shared_ptr< ::grpc::ChannelInterface> channel_; + class experimental_async async_stub_{this}; + ::grpc::ClientAsyncResponseReader< ::etcdserverpb::RangeResponse>* AsyncRangeRaw(::grpc::ClientContext* context, const ::etcdserverpb::RangeRequest& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::etcdserverpb::RangeResponse>* PrepareAsyncRangeRaw(::grpc::ClientContext* context, const ::etcdserverpb::RangeRequest& request, ::grpc::CompletionQueue* cq) override; + const ::grpc::internal::RpcMethod rpcmethod_Range_; + }; + static std::unique_ptr NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions()); + + class Service : public ::grpc::Service { + public: + Service(); + virtual ~Service(); + // Range gets the keys in the range from the key-value store. + virtual ::grpc::Status Range(::grpc::ServerContext* context, const ::etcdserverpb::RangeRequest* request, ::etcdserverpb::RangeResponse* response); + }; + template + class WithAsyncMethod_Range : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithAsyncMethod_Range() { + ::grpc::Service::MarkMethodAsync(0); + } + ~WithAsyncMethod_Range() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status Range(::grpc::ServerContext* /*context*/, const ::etcdserverpb::RangeRequest* /*request*/, ::etcdserverpb::RangeResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestRange(::grpc::ServerContext* context, ::etcdserverpb::RangeRequest* request, ::grpc::ServerAsyncResponseWriter< ::etcdserverpb::RangeResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag); + } + }; + typedef WithAsyncMethod_Range AsyncService; + template + class ExperimentalWithCallbackMethod_Range : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + ExperimentalWithCallbackMethod_Range() { + ::grpc::Service::experimental().MarkMethodCallback(0, + new ::grpc_impl::internal::CallbackUnaryHandler< ::etcdserverpb::RangeRequest, ::etcdserverpb::RangeResponse>( + [this](::grpc::ServerContext* context, + const ::etcdserverpb::RangeRequest* request, + ::etcdserverpb::RangeResponse* response, + ::grpc::experimental::ServerCallbackRpcController* controller) { + return this->Range(context, request, response, controller); + })); + } + void SetMessageAllocatorFor_Range( + ::grpc::experimental::MessageAllocator< ::etcdserverpb::RangeRequest, ::etcdserverpb::RangeResponse>* allocator) { + static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::etcdserverpb::RangeRequest, ::etcdserverpb::RangeResponse>*>( + ::grpc::Service::experimental().GetHandler(0)) + ->SetMessageAllocator(allocator); + } + ~ExperimentalWithCallbackMethod_Range() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status Range(::grpc::ServerContext* /*context*/, const ::etcdserverpb::RangeRequest* /*request*/, ::etcdserverpb::RangeResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual void Range(::grpc::ServerContext* /*context*/, const ::etcdserverpb::RangeRequest* /*request*/, ::etcdserverpb::RangeResponse* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + }; + typedef ExperimentalWithCallbackMethod_Range ExperimentalCallbackService; + template + class WithGenericMethod_Range : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithGenericMethod_Range() { + ::grpc::Service::MarkMethodGeneric(0); + } + ~WithGenericMethod_Range() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status Range(::grpc::ServerContext* /*context*/, const ::etcdserverpb::RangeRequest* /*request*/, ::etcdserverpb::RangeResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithRawMethod_Range : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawMethod_Range() { + ::grpc::Service::MarkMethodRaw(0); + } + ~WithRawMethod_Range() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status Range(::grpc::ServerContext* /*context*/, const ::etcdserverpb::RangeRequest* /*request*/, ::etcdserverpb::RangeResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestRange(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class ExperimentalWithRawCallbackMethod_Range : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + ExperimentalWithRawCallbackMethod_Range() { + ::grpc::Service::experimental().MarkMethodRawCallback(0, + new ::grpc_impl::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( + [this](::grpc::ServerContext* context, + const ::grpc::ByteBuffer* request, + ::grpc::ByteBuffer* response, + ::grpc::experimental::ServerCallbackRpcController* controller) { + this->Range(context, request, response, controller); + })); + } + ~ExperimentalWithRawCallbackMethod_Range() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status Range(::grpc::ServerContext* /*context*/, const ::etcdserverpb::RangeRequest* /*request*/, ::etcdserverpb::RangeResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual void Range(::grpc::ServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + }; + template + class WithStreamedUnaryMethod_Range : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithStreamedUnaryMethod_Range() { + ::grpc::Service::MarkMethodStreamed(0, + new ::grpc::internal::StreamedUnaryHandler< ::etcdserverpb::RangeRequest, ::etcdserverpb::RangeResponse>(std::bind(&WithStreamedUnaryMethod_Range::StreamedRange, this, std::placeholders::_1, std::placeholders::_2))); + } + ~WithStreamedUnaryMethod_Range() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status Range(::grpc::ServerContext* /*context*/, const ::etcdserverpb::RangeRequest* /*request*/, ::etcdserverpb::RangeResponse* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedRange(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::etcdserverpb::RangeRequest,::etcdserverpb::RangeResponse>* server_unary_streamer) = 0; + }; + typedef WithStreamedUnaryMethod_Range StreamedUnaryService; + typedef Service SplitStreamedService; + typedef WithStreamedUnaryMethod_Range StreamedService; +}; + } // namespace etcdserverpb diff --git a/proxy/src/grpc/etcd.pb.cc b/proxy/src/grpc/etcd.pb.cc index 489eda74c2..a3cc7e3c96 100644 --- a/proxy/src/grpc/etcd.pb.cc +++ b/proxy/src/grpc/etcd.pb.cc @@ -22,6 +22,14 @@ extern PROTOBUF_INTERNAL_EXPORT_etcd_2eproto ::PROTOBUF_NAMESPACE_ID::internal:: extern PROTOBUF_INTERNAL_EXPORT_etcd_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_WatchCreateRequest_etcd_2eproto; extern PROTOBUF_INTERNAL_EXPORT_etcd_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_WatchProgressRequest_etcd_2eproto; namespace etcdserverpb { +class RangeRequestDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _RangeRequest_default_instance_; +class RangeResponseDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _RangeResponse_default_instance_; class WatchRequestDefaultTypeInternal { public: ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; @@ -87,6 +95,36 @@ static void InitDefaultsscc_info_KeyValue_etcd_2eproto() { ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_KeyValue_etcd_2eproto = {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_KeyValue_etcd_2eproto}, {}}; +static void InitDefaultsscc_info_RangeRequest_etcd_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::etcdserverpb::_RangeRequest_default_instance_; + new (ptr) ::etcdserverpb::RangeRequest(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::etcdserverpb::RangeRequest::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_RangeRequest_etcd_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_RangeRequest_etcd_2eproto}, {}}; + +static void InitDefaultsscc_info_RangeResponse_etcd_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::etcdserverpb::_RangeResponse_default_instance_; + new (ptr) ::etcdserverpb::RangeResponse(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::etcdserverpb::RangeResponse::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_RangeResponse_etcd_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, InitDefaultsscc_info_RangeResponse_etcd_2eproto}, { + &scc_info_ResponseHeader_etcd_2eproto.base, + &scc_info_KeyValue_etcd_2eproto.base,}}; + static void InitDefaultsscc_info_ResponseHeader_etcd_2eproto() { GOOGLE_PROTOBUF_VERIFY_VERSION; @@ -176,11 +214,38 @@ static void InitDefaultsscc_info_WatchResponse_etcd_2eproto() { &scc_info_ResponseHeader_etcd_2eproto.base, &scc_info_Event_etcd_2eproto.base,}}; -static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_etcd_2eproto[8]; -static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_etcd_2eproto[2]; +static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_etcd_2eproto[10]; +static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_etcd_2eproto[4]; static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_etcd_2eproto = nullptr; const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_etcd_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::etcdserverpb::RangeRequest, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::etcdserverpb::RangeRequest, key_), + PROTOBUF_FIELD_OFFSET(::etcdserverpb::RangeRequest, range_end_), + PROTOBUF_FIELD_OFFSET(::etcdserverpb::RangeRequest, limit_), + PROTOBUF_FIELD_OFFSET(::etcdserverpb::RangeRequest, revision_), + PROTOBUF_FIELD_OFFSET(::etcdserverpb::RangeRequest, sort_order_), + PROTOBUF_FIELD_OFFSET(::etcdserverpb::RangeRequest, sort_target_), + PROTOBUF_FIELD_OFFSET(::etcdserverpb::RangeRequest, serializable_), + PROTOBUF_FIELD_OFFSET(::etcdserverpb::RangeRequest, keys_only_), + PROTOBUF_FIELD_OFFSET(::etcdserverpb::RangeRequest, count_only_), + PROTOBUF_FIELD_OFFSET(::etcdserverpb::RangeRequest, min_mod_revision_), + PROTOBUF_FIELD_OFFSET(::etcdserverpb::RangeRequest, max_mod_revision_), + PROTOBUF_FIELD_OFFSET(::etcdserverpb::RangeRequest, min_create_revision_), + PROTOBUF_FIELD_OFFSET(::etcdserverpb::RangeRequest, max_create_revision_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::etcdserverpb::RangeResponse, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::etcdserverpb::RangeResponse, header_), + PROTOBUF_FIELD_OFFSET(::etcdserverpb::RangeResponse, kvs_), + PROTOBUF_FIELD_OFFSET(::etcdserverpb::RangeResponse, more_), + PROTOBUF_FIELD_OFFSET(::etcdserverpb::RangeResponse, count_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::etcdserverpb::WatchRequest, _internal_metadata_), ~0u, // no _extensions_ @@ -257,17 +322,21 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_etcd_2eproto::offsets[] PROTOB PROTOBUF_FIELD_OFFSET(::etcdserverpb::Event, prev_kv_), }; static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { - { 0, -1, sizeof(::etcdserverpb::WatchRequest)}, - { 9, -1, sizeof(::etcdserverpb::WatchCreateRequest)}, - { 22, -1, sizeof(::etcdserverpb::WatchCancelRequest)}, - { 28, -1, sizeof(::etcdserverpb::WatchProgressRequest)}, - { 33, -1, sizeof(::etcdserverpb::WatchResponse)}, - { 46, -1, sizeof(::etcdserverpb::ResponseHeader)}, - { 55, -1, sizeof(::etcdserverpb::KeyValue)}, - { 66, -1, sizeof(::etcdserverpb::Event)}, + { 0, -1, sizeof(::etcdserverpb::RangeRequest)}, + { 18, -1, sizeof(::etcdserverpb::RangeResponse)}, + { 27, -1, sizeof(::etcdserverpb::WatchRequest)}, + { 36, -1, sizeof(::etcdserverpb::WatchCreateRequest)}, + { 49, -1, sizeof(::etcdserverpb::WatchCancelRequest)}, + { 55, -1, sizeof(::etcdserverpb::WatchProgressRequest)}, + { 60, -1, sizeof(::etcdserverpb::WatchResponse)}, + { 73, -1, sizeof(::etcdserverpb::ResponseHeader)}, + { 82, -1, sizeof(::etcdserverpb::KeyValue)}, + { 93, -1, sizeof(::etcdserverpb::Event)}, }; static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { + reinterpret_cast(&::etcdserverpb::_RangeRequest_default_instance_), + reinterpret_cast(&::etcdserverpb::_RangeResponse_default_instance_), reinterpret_cast(&::etcdserverpb::_WatchRequest_default_instance_), reinterpret_cast(&::etcdserverpb::_WatchCreateRequest_default_instance_), reinterpret_cast(&::etcdserverpb::_WatchCancelRequest_default_instance_), @@ -279,44 +348,63 @@ static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = }; const char descriptor_table_protodef_etcd_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = - "\n\netcd.proto\022\014etcdserverpb\"\327\001\n\014WatchRequ" - "est\022:\n\016create_request\030\001 \001(\0132 .etcdserver" - "pb.WatchCreateRequestH\000\022:\n\016cancel_reques" - "t\030\002 \001(\0132 .etcdserverpb.WatchCancelReques" - "tH\000\022>\n\020progress_request\030\003 \001(\0132\".etcdserv" - "erpb.WatchProgressRequestH\000B\017\n\rrequest_u" - "nion\"\377\001\n\022WatchCreateRequest\022\013\n\003key\030\001 \001(\014" - "\022\021\n\trange_end\030\002 \001(\014\022\026\n\016start_revision\030\003 " - "\001(\003\022\027\n\017progress_notify\030\004 \001(\010\022<\n\007filters\030" - "\005 \003(\0162+.etcdserverpb.WatchCreateRequest." - "FilterType\022\017\n\007prev_kv\030\006 \001(\010\022\020\n\010watch_id\030" - "\007 \001(\003\022\020\n\010fragment\030\010 \001(\010\"%\n\nFilterType\022\t\n" - "\005NOPUT\020\000\022\014\n\010NODELETE\020\001\"&\n\022WatchCancelReq" - "uest\022\020\n\010watch_id\030\001 \001(\003\"\026\n\024WatchProgressR" - "equest\"\332\001\n\rWatchResponse\022,\n\006header\030\001 \001(\013" - "2\034.etcdserverpb.ResponseHeader\022\020\n\010watch_" - "id\030\002 \001(\003\022\017\n\007created\030\003 \001(\010\022\020\n\010canceled\030\004 " - "\001(\010\022\030\n\020compact_revision\030\005 \001(\003\022\025\n\rcancel_" - "reason\030\006 \001(\t\022\020\n\010fragment\030\007 \001(\010\022#\n\006events" - "\030\013 \003(\0132\023.etcdserverpb.Event\"\\\n\016ResponseH" - "eader\022\022\n\ncluster_id\030\001 \001(\004\022\021\n\tmember_id\030\002" - " \001(\004\022\020\n\010revision\030\003 \001(\003\022\021\n\traft_term\030\004 \001(" - "\004\"u\n\010KeyValue\022\013\n\003key\030\001 \001(\014\022\027\n\017create_rev" - "ision\030\002 \001(\003\022\024\n\014mod_revision\030\003 \001(\003\022\017\n\007ver" - "sion\030\004 \001(\003\022\r\n\005value\030\005 \001(\014\022\r\n\005lease\030\006 \001(\003" - "\"\243\001\n\005Event\022+\n\004type\030\001 \001(\0162\035.etcdserverpb." - "Event.EventType\022\"\n\002kv\030\002 \001(\0132\026.etcdserver" - "pb.KeyValue\022\'\n\007prev_kv\030\003 \001(\0132\026.etcdserve" - "rpb.KeyValue\" \n\tEventType\022\007\n\003PUT\020\000\022\n\n\006DE" - "LETE\020\0012O\n\005Watch\022F\n\005Watch\022\032.etcdserverpb." - "WatchRequest\032\033.etcdserverpb.WatchRespons" - "e\"\000(\0010\001b\006proto3" + "\n\netcd.proto\022\014etcdserverpb\"\344\003\n\014RangeRequ" + "est\022\013\n\003key\030\001 \001(\014\022\021\n\trange_end\030\002 \001(\014\022\r\n\005l" + "imit\030\003 \001(\003\022\020\n\010revision\030\004 \001(\003\0228\n\nsort_ord" + "er\030\005 \001(\0162$.etcdserverpb.RangeRequest.Sor" + "tOrder\022:\n\013sort_target\030\006 \001(\0162%.etcdserver" + "pb.RangeRequest.SortTarget\022\024\n\014serializab" + "le\030\007 \001(\010\022\021\n\tkeys_only\030\010 \001(\010\022\022\n\ncount_onl" + "y\030\t \001(\010\022\030\n\020min_mod_revision\030\n \001(\003\022\030\n\020max" + "_mod_revision\030\013 \001(\003\022\033\n\023min_create_revisi" + "on\030\014 \001(\003\022\033\n\023max_create_revision\030\r \001(\003\".\n" + "\tSortOrder\022\010\n\004NONE\020\000\022\n\n\006ASCEND\020\001\022\013\n\007DESC" + "END\020\002\"B\n\nSortTarget\022\007\n\003KEY\020\000\022\013\n\007VERSION\020" + "\001\022\n\n\006CREATE\020\002\022\007\n\003MOD\020\003\022\t\n\005VALUE\020\004\"\177\n\rRan" + "geResponse\022,\n\006header\030\001 \001(\0132\034.etcdserverp" + "b.ResponseHeader\022#\n\003kvs\030\002 \003(\0132\026.etcdserv" + "erpb.KeyValue\022\014\n\004more\030\003 \001(\010\022\r\n\005count\030\004 \001" + "(\003\"\327\001\n\014WatchRequest\022:\n\016create_request\030\001 " + "\001(\0132 .etcdserverpb.WatchCreateRequestH\000\022" + ":\n\016cancel_request\030\002 \001(\0132 .etcdserverpb.W" + "atchCancelRequestH\000\022>\n\020progress_request\030" + "\003 \001(\0132\".etcdserverpb.WatchProgressReques" + "tH\000B\017\n\rrequest_union\"\377\001\n\022WatchCreateRequ" + "est\022\013\n\003key\030\001 \001(\014\022\021\n\trange_end\030\002 \001(\014\022\026\n\016s" + "tart_revision\030\003 \001(\003\022\027\n\017progress_notify\030\004" + " \001(\010\022<\n\007filters\030\005 \003(\0162+.etcdserverpb.Wat" + "chCreateRequest.FilterType\022\017\n\007prev_kv\030\006 " + "\001(\010\022\020\n\010watch_id\030\007 \001(\003\022\020\n\010fragment\030\010 \001(\010\"" + "%\n\nFilterType\022\t\n\005NOPUT\020\000\022\014\n\010NODELETE\020\001\"&" + "\n\022WatchCancelRequest\022\020\n\010watch_id\030\001 \001(\003\"\026" + "\n\024WatchProgressRequest\"\332\001\n\rWatchResponse" + "\022,\n\006header\030\001 \001(\0132\034.etcdserverpb.Response" + "Header\022\020\n\010watch_id\030\002 \001(\003\022\017\n\007created\030\003 \001(" + "\010\022\020\n\010canceled\030\004 \001(\010\022\030\n\020compact_revision\030" + "\005 \001(\003\022\025\n\rcancel_reason\030\006 \001(\t\022\020\n\010fragment" + "\030\007 \001(\010\022#\n\006events\030\013 \003(\0132\023.etcdserverpb.Ev" + "ent\"\\\n\016ResponseHeader\022\022\n\ncluster_id\030\001 \001(" + "\004\022\021\n\tmember_id\030\002 \001(\004\022\020\n\010revision\030\003 \001(\003\022\021" + "\n\traft_term\030\004 \001(\004\"u\n\010KeyValue\022\013\n\003key\030\001 \001" + "(\014\022\027\n\017create_revision\030\002 \001(\003\022\024\n\014mod_revis" + "ion\030\003 \001(\003\022\017\n\007version\030\004 \001(\003\022\r\n\005value\030\005 \001(" + "\014\022\r\n\005lease\030\006 \001(\003\"\243\001\n\005Event\022+\n\004type\030\001 \001(\016" + "2\035.etcdserverpb.Event.EventType\022\"\n\002kv\030\002 " + "\001(\0132\026.etcdserverpb.KeyValue\022\'\n\007prev_kv\030\003" + " \001(\0132\026.etcdserverpb.KeyValue\" \n\tEventTyp" + "e\022\007\n\003PUT\020\000\022\n\n\006DELETE\020\0012O\n\005Watch\022F\n\005Watch" + "\022\032.etcdserverpb.WatchRequest\032\033.etcdserve" + "rpb.WatchResponse\"\000(\0010\0012H\n\002KV\022B\n\005Range\022\032" + ".etcdserverpb.RangeRequest\032\033.etcdserverp" + "b.RangeResponse\"\000b\006proto3" ; static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_etcd_2eproto_deps[1] = { }; -static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_etcd_2eproto_sccs[8] = { +static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_etcd_2eproto_sccs[10] = { &scc_info_Event_etcd_2eproto.base, &scc_info_KeyValue_etcd_2eproto.base, + &scc_info_RangeRequest_etcd_2eproto.base, + &scc_info_RangeResponse_etcd_2eproto.base, &scc_info_ResponseHeader_etcd_2eproto.base, &scc_info_WatchCancelRequest_etcd_2eproto.base, &scc_info_WatchCreateRequest_etcd_2eproto.base, @@ -327,19 +415,69 @@ static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_etc static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_etcd_2eproto_once; static bool descriptor_table_etcd_2eproto_initialized = false; const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_etcd_2eproto = { - &descriptor_table_etcd_2eproto_initialized, descriptor_table_protodef_etcd_2eproto, "etcd.proto", 1255, - &descriptor_table_etcd_2eproto_once, descriptor_table_etcd_2eproto_sccs, descriptor_table_etcd_2eproto_deps, 8, 0, + &descriptor_table_etcd_2eproto_initialized, descriptor_table_protodef_etcd_2eproto, "etcd.proto", 1945, + &descriptor_table_etcd_2eproto_once, descriptor_table_etcd_2eproto_sccs, descriptor_table_etcd_2eproto_deps, 10, 0, schemas, file_default_instances, TableStruct_etcd_2eproto::offsets, - file_level_metadata_etcd_2eproto, 8, file_level_enum_descriptors_etcd_2eproto, file_level_service_descriptors_etcd_2eproto, + file_level_metadata_etcd_2eproto, 10, file_level_enum_descriptors_etcd_2eproto, file_level_service_descriptors_etcd_2eproto, }; // Force running AddDescriptors() at dynamic initialization time. static bool dynamic_init_dummy_etcd_2eproto = ( ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptors(&descriptor_table_etcd_2eproto), true); namespace etcdserverpb { -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* WatchCreateRequest_FilterType_descriptor() { +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* RangeRequest_SortOrder_descriptor() { ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_etcd_2eproto); return file_level_enum_descriptors_etcd_2eproto[0]; } +bool RangeRequest_SortOrder_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) +constexpr RangeRequest_SortOrder RangeRequest::NONE; +constexpr RangeRequest_SortOrder RangeRequest::ASCEND; +constexpr RangeRequest_SortOrder RangeRequest::DESCEND; +constexpr RangeRequest_SortOrder RangeRequest::SortOrder_MIN; +constexpr RangeRequest_SortOrder RangeRequest::SortOrder_MAX; +constexpr int RangeRequest::SortOrder_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* RangeRequest_SortTarget_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_etcd_2eproto); + return file_level_enum_descriptors_etcd_2eproto[1]; +} +bool RangeRequest_SortTarget_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + case 4: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) +constexpr RangeRequest_SortTarget RangeRequest::KEY; +constexpr RangeRequest_SortTarget RangeRequest::VERSION; +constexpr RangeRequest_SortTarget RangeRequest::CREATE; +constexpr RangeRequest_SortTarget RangeRequest::MOD; +constexpr RangeRequest_SortTarget RangeRequest::VALUE; +constexpr RangeRequest_SortTarget RangeRequest::SortTarget_MIN; +constexpr RangeRequest_SortTarget RangeRequest::SortTarget_MAX; +constexpr int RangeRequest::SortTarget_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* WatchCreateRequest_FilterType_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_etcd_2eproto); + return file_level_enum_descriptors_etcd_2eproto[2]; +} bool WatchCreateRequest_FilterType_IsValid(int value) { switch (value) { case 0: @@ -359,7 +497,7 @@ constexpr int WatchCreateRequest::FilterType_ARRAYSIZE; #endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Event_EventType_descriptor() { ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_etcd_2eproto); - return file_level_enum_descriptors_etcd_2eproto[1]; + return file_level_enum_descriptors_etcd_2eproto[3]; } bool Event_EventType_IsValid(int value) { switch (value) { @@ -379,6 +517,1183 @@ constexpr Event_EventType Event::EventType_MAX; constexpr int Event::EventType_ARRAYSIZE; #endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) +// =================================================================== + +void RangeRequest::InitAsDefaultInstance() { +} +class RangeRequest::_Internal { + public: +}; + +RangeRequest::RangeRequest() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:etcdserverpb.RangeRequest) +} +RangeRequest::RangeRequest(const RangeRequest& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + key_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.key().empty()) { + key_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.key_); + } + range_end_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.range_end().empty()) { + range_end_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.range_end_); + } + ::memcpy(&limit_, &from.limit_, + static_cast(reinterpret_cast(&count_only_) - + reinterpret_cast(&limit_)) + sizeof(count_only_)); + // @@protoc_insertion_point(copy_constructor:etcdserverpb.RangeRequest) +} + +void RangeRequest::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_RangeRequest_etcd_2eproto.base); + key_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + range_end_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + ::memset(&limit_, 0, static_cast( + reinterpret_cast(&count_only_) - + reinterpret_cast(&limit_)) + sizeof(count_only_)); +} + +RangeRequest::~RangeRequest() { + // @@protoc_insertion_point(destructor:etcdserverpb.RangeRequest) + SharedDtor(); +} + +void RangeRequest::SharedDtor() { + key_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + range_end_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void RangeRequest::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const RangeRequest& RangeRequest::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_RangeRequest_etcd_2eproto.base); + return *internal_default_instance(); +} + + +void RangeRequest::Clear() { +// @@protoc_insertion_point(message_clear_start:etcdserverpb.RangeRequest) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + key_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + range_end_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + ::memset(&limit_, 0, static_cast( + reinterpret_cast(&count_only_) - + reinterpret_cast(&limit_)) + sizeof(count_only_)); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* RangeRequest::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // bytes key = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(mutable_key(), ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // bytes range_end = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(mutable_range_end(), ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // int64 limit = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + limit_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // int64 revision = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) { + revision_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .etcdserverpb.RangeRequest.SortOrder sort_order = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + set_sort_order(static_cast<::etcdserverpb::RangeRequest_SortOrder>(val)); + } else goto handle_unusual; + continue; + // .etcdserverpb.RangeRequest.SortTarget sort_target = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 48)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + set_sort_target(static_cast<::etcdserverpb::RangeRequest_SortTarget>(val)); + } else goto handle_unusual; + continue; + // bool serializable = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 56)) { + serializable_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // bool keys_only = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 64)) { + keys_only_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // bool count_only = 9; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 72)) { + count_only_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // int64 min_mod_revision = 10; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 80)) { + min_mod_revision_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // int64 max_mod_revision = 11; + case 11: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 88)) { + max_mod_revision_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // int64 min_create_revision = 12; + case 12: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 96)) { + min_create_revision_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // int64 max_create_revision = 13; + case 13: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 104)) { + max_create_revision_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool RangeRequest::MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + // @@protoc_insertion_point(parse_start:etcdserverpb.RangeRequest) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // bytes key = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadBytes( + input, this->mutable_key())); + } else { + goto handle_unusual; + } + break; + } + + // bytes range_end = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadBytes( + input, this->mutable_range_end())); + } else { + goto handle_unusual; + } + break; + } + + // int64 limit = 3; + case 3: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (24 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + input, &limit_))); + } else { + goto handle_unusual; + } + break; + } + + // int64 revision = 4; + case 4: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (32 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + input, &revision_))); + } else { + goto handle_unusual; + } + break; + } + + // .etcdserverpb.RangeRequest.SortOrder sort_order = 5; + case 5: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (40 & 0xFF)) { + int value = 0; + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + int, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + set_sort_order(static_cast< ::etcdserverpb::RangeRequest_SortOrder >(value)); + } else { + goto handle_unusual; + } + break; + } + + // .etcdserverpb.RangeRequest.SortTarget sort_target = 6; + case 6: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (48 & 0xFF)) { + int value = 0; + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + int, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + set_sort_target(static_cast< ::etcdserverpb::RangeRequest_SortTarget >(value)); + } else { + goto handle_unusual; + } + break; + } + + // bool serializable = 7; + case 7: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (56 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>( + input, &serializable_))); + } else { + goto handle_unusual; + } + break; + } + + // bool keys_only = 8; + case 8: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (64 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>( + input, &keys_only_))); + } else { + goto handle_unusual; + } + break; + } + + // bool count_only = 9; + case 9: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (72 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>( + input, &count_only_))); + } else { + goto handle_unusual; + } + break; + } + + // int64 min_mod_revision = 10; + case 10: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (80 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + input, &min_mod_revision_))); + } else { + goto handle_unusual; + } + break; + } + + // int64 max_mod_revision = 11; + case 11: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (88 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + input, &max_mod_revision_))); + } else { + goto handle_unusual; + } + break; + } + + // int64 min_create_revision = 12; + case 12: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (96 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + input, &min_create_revision_))); + } else { + goto handle_unusual; + } + break; + } + + // int64 max_create_revision = 13; + case 13: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (104 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + input, &max_create_revision_))); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:etcdserverpb.RangeRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:etcdserverpb.RangeRequest) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void RangeRequest::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:etcdserverpb.RangeRequest) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // bytes key = 1; + if (this->key().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesMaybeAliased( + 1, this->key(), output); + } + + // bytes range_end = 2; + if (this->range_end().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesMaybeAliased( + 2, this->range_end(), output); + } + + // int64 limit = 3; + if (this->limit() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(3, this->limit(), output); + } + + // int64 revision = 4; + if (this->revision() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(4, this->revision(), output); + } + + // .etcdserverpb.RangeRequest.SortOrder sort_order = 5; + if (this->sort_order() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnum( + 5, this->sort_order(), output); + } + + // .etcdserverpb.RangeRequest.SortTarget sort_target = 6; + if (this->sort_target() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnum( + 6, this->sort_target(), output); + } + + // bool serializable = 7; + if (this->serializable() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBool(7, this->serializable(), output); + } + + // bool keys_only = 8; + if (this->keys_only() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBool(8, this->keys_only(), output); + } + + // bool count_only = 9; + if (this->count_only() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBool(9, this->count_only(), output); + } + + // int64 min_mod_revision = 10; + if (this->min_mod_revision() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(10, this->min_mod_revision(), output); + } + + // int64 max_mod_revision = 11; + if (this->max_mod_revision() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(11, this->max_mod_revision(), output); + } + + // int64 min_create_revision = 12; + if (this->min_create_revision() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(12, this->min_create_revision(), output); + } + + // int64 max_create_revision = 13; + if (this->max_create_revision() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(13, this->max_create_revision(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:etcdserverpb.RangeRequest) +} + +::PROTOBUF_NAMESPACE_ID::uint8* RangeRequest::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:etcdserverpb.RangeRequest) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // bytes key = 1; + if (this->key().size() > 0) { + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesToArray( + 1, this->key(), target); + } + + // bytes range_end = 2; + if (this->range_end().size() > 0) { + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesToArray( + 2, this->range_end(), target); + } + + // int64 limit = 3; + if (this->limit() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(3, this->limit(), target); + } + + // int64 revision = 4; + if (this->revision() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(4, this->revision(), target); + } + + // .etcdserverpb.RangeRequest.SortOrder sort_order = 5; + if (this->sort_order() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 5, this->sort_order(), target); + } + + // .etcdserverpb.RangeRequest.SortTarget sort_target = 6; + if (this->sort_target() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 6, this->sort_target(), target); + } + + // bool serializable = 7; + if (this->serializable() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(7, this->serializable(), target); + } + + // bool keys_only = 8; + if (this->keys_only() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(8, this->keys_only(), target); + } + + // bool count_only = 9; + if (this->count_only() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(9, this->count_only(), target); + } + + // int64 min_mod_revision = 10; + if (this->min_mod_revision() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(10, this->min_mod_revision(), target); + } + + // int64 max_mod_revision = 11; + if (this->max_mod_revision() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(11, this->max_mod_revision(), target); + } + + // int64 min_create_revision = 12; + if (this->min_create_revision() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(12, this->min_create_revision(), target); + } + + // int64 max_create_revision = 13; + if (this->max_create_revision() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(13, this->max_create_revision(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:etcdserverpb.RangeRequest) + return target; +} + +size_t RangeRequest::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:etcdserverpb.RangeRequest) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // bytes key = 1; + if (this->key().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->key()); + } + + // bytes range_end = 2; + if (this->range_end().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->range_end()); + } + + // int64 limit = 3; + if (this->limit() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( + this->limit()); + } + + // int64 revision = 4; + if (this->revision() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( + this->revision()); + } + + // .etcdserverpb.RangeRequest.SortOrder sort_order = 5; + if (this->sort_order() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->sort_order()); + } + + // .etcdserverpb.RangeRequest.SortTarget sort_target = 6; + if (this->sort_target() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->sort_target()); + } + + // int64 min_mod_revision = 10; + if (this->min_mod_revision() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( + this->min_mod_revision()); + } + + // int64 max_mod_revision = 11; + if (this->max_mod_revision() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( + this->max_mod_revision()); + } + + // int64 min_create_revision = 12; + if (this->min_create_revision() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( + this->min_create_revision()); + } + + // int64 max_create_revision = 13; + if (this->max_create_revision() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( + this->max_create_revision()); + } + + // bool serializable = 7; + if (this->serializable() != 0) { + total_size += 1 + 1; + } + + // bool keys_only = 8; + if (this->keys_only() != 0) { + total_size += 1 + 1; + } + + // bool count_only = 9; + if (this->count_only() != 0) { + total_size += 1 + 1; + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void RangeRequest::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:etcdserverpb.RangeRequest) + GOOGLE_DCHECK_NE(&from, this); + const RangeRequest* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:etcdserverpb.RangeRequest) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:etcdserverpb.RangeRequest) + MergeFrom(*source); + } +} + +void RangeRequest::MergeFrom(const RangeRequest& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:etcdserverpb.RangeRequest) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.key().size() > 0) { + + key_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.key_); + } + if (from.range_end().size() > 0) { + + range_end_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.range_end_); + } + if (from.limit() != 0) { + set_limit(from.limit()); + } + if (from.revision() != 0) { + set_revision(from.revision()); + } + if (from.sort_order() != 0) { + set_sort_order(from.sort_order()); + } + if (from.sort_target() != 0) { + set_sort_target(from.sort_target()); + } + if (from.min_mod_revision() != 0) { + set_min_mod_revision(from.min_mod_revision()); + } + if (from.max_mod_revision() != 0) { + set_max_mod_revision(from.max_mod_revision()); + } + if (from.min_create_revision() != 0) { + set_min_create_revision(from.min_create_revision()); + } + if (from.max_create_revision() != 0) { + set_max_create_revision(from.max_create_revision()); + } + if (from.serializable() != 0) { + set_serializable(from.serializable()); + } + if (from.keys_only() != 0) { + set_keys_only(from.keys_only()); + } + if (from.count_only() != 0) { + set_count_only(from.count_only()); + } +} + +void RangeRequest::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:etcdserverpb.RangeRequest) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void RangeRequest::CopyFrom(const RangeRequest& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:etcdserverpb.RangeRequest) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool RangeRequest::IsInitialized() const { + return true; +} + +void RangeRequest::InternalSwap(RangeRequest* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + key_.Swap(&other->key_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + range_end_.Swap(&other->range_end_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(limit_, other->limit_); + swap(revision_, other->revision_); + swap(sort_order_, other->sort_order_); + swap(sort_target_, other->sort_target_); + swap(min_mod_revision_, other->min_mod_revision_); + swap(max_mod_revision_, other->max_mod_revision_); + swap(min_create_revision_, other->min_create_revision_); + swap(max_create_revision_, other->max_create_revision_); + swap(serializable_, other->serializable_); + swap(keys_only_, other->keys_only_); + swap(count_only_, other->count_only_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata RangeRequest::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void RangeResponse::InitAsDefaultInstance() { + ::etcdserverpb::_RangeResponse_default_instance_._instance.get_mutable()->header_ = const_cast< ::etcdserverpb::ResponseHeader*>( + ::etcdserverpb::ResponseHeader::internal_default_instance()); +} +class RangeResponse::_Internal { + public: + static const ::etcdserverpb::ResponseHeader& header(const RangeResponse* msg); +}; + +const ::etcdserverpb::ResponseHeader& +RangeResponse::_Internal::header(const RangeResponse* msg) { + return *msg->header_; +} +RangeResponse::RangeResponse() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:etcdserverpb.RangeResponse) +} +RangeResponse::RangeResponse(const RangeResponse& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + kvs_(from.kvs_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + if (from.has_header()) { + header_ = new ::etcdserverpb::ResponseHeader(*from.header_); + } else { + header_ = nullptr; + } + ::memcpy(&count_, &from.count_, + static_cast(reinterpret_cast(&more_) - + reinterpret_cast(&count_)) + sizeof(more_)); + // @@protoc_insertion_point(copy_constructor:etcdserverpb.RangeResponse) +} + +void RangeResponse::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_RangeResponse_etcd_2eproto.base); + ::memset(&header_, 0, static_cast( + reinterpret_cast(&more_) - + reinterpret_cast(&header_)) + sizeof(more_)); +} + +RangeResponse::~RangeResponse() { + // @@protoc_insertion_point(destructor:etcdserverpb.RangeResponse) + SharedDtor(); +} + +void RangeResponse::SharedDtor() { + if (this != internal_default_instance()) delete header_; +} + +void RangeResponse::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const RangeResponse& RangeResponse::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_RangeResponse_etcd_2eproto.base); + return *internal_default_instance(); +} + + +void RangeResponse::Clear() { +// @@protoc_insertion_point(message_clear_start:etcdserverpb.RangeResponse) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + kvs_.Clear(); + if (GetArenaNoVirtual() == nullptr && header_ != nullptr) { + delete header_; + } + header_ = nullptr; + ::memset(&count_, 0, static_cast( + reinterpret_cast(&more_) - + reinterpret_cast(&count_)) + sizeof(more_)); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* RangeResponse::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // .etcdserverpb.ResponseHeader header = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(mutable_header(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated .etcdserverpb.KeyValue kvs = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(add_kvs(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 18); + } else goto handle_unusual; + continue; + // bool more = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + more_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // int64 count = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) { + count_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool RangeResponse::MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + // @@protoc_insertion_point(parse_start:etcdserverpb.RangeResponse) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // .etcdserverpb.ResponseHeader header = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, mutable_header())); + } else { + goto handle_unusual; + } + break; + } + + // repeated .etcdserverpb.KeyValue kvs = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, add_kvs())); + } else { + goto handle_unusual; + } + break; + } + + // bool more = 3; + case 3: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (24 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>( + input, &more_))); + } else { + goto handle_unusual; + } + break; + } + + // int64 count = 4; + case 4: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (32 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + input, &count_))); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:etcdserverpb.RangeResponse) + return true; +failure: + // @@protoc_insertion_point(parse_failure:etcdserverpb.RangeResponse) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void RangeResponse::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:etcdserverpb.RangeResponse) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .etcdserverpb.ResponseHeader header = 1; + if (this->has_header()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, _Internal::header(this), output); + } + + // repeated .etcdserverpb.KeyValue kvs = 2; + for (unsigned int i = 0, + n = static_cast(this->kvs_size()); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, + this->kvs(static_cast(i)), + output); + } + + // bool more = 3; + if (this->more() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBool(3, this->more(), output); + } + + // int64 count = 4; + if (this->count() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(4, this->count(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:etcdserverpb.RangeResponse) +} + +::PROTOBUF_NAMESPACE_ID::uint8* RangeResponse::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:etcdserverpb.RangeResponse) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .etcdserverpb.ResponseHeader header = 1; + if (this->has_header()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 1, _Internal::header(this), target); + } + + // repeated .etcdserverpb.KeyValue kvs = 2; + for (unsigned int i = 0, + n = static_cast(this->kvs_size()); i < n; i++) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 2, this->kvs(static_cast(i)), target); + } + + // bool more = 3; + if (this->more() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(3, this->more(), target); + } + + // int64 count = 4; + if (this->count() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(4, this->count(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:etcdserverpb.RangeResponse) + return target; +} + +size_t RangeResponse::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:etcdserverpb.RangeResponse) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .etcdserverpb.KeyValue kvs = 2; + { + unsigned int count = static_cast(this->kvs_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + this->kvs(static_cast(i))); + } + } + + // .etcdserverpb.ResponseHeader header = 1; + if (this->has_header()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *header_); + } + + // int64 count = 4; + if (this->count() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( + this->count()); + } + + // bool more = 3; + if (this->more() != 0) { + total_size += 1 + 1; + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void RangeResponse::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:etcdserverpb.RangeResponse) + GOOGLE_DCHECK_NE(&from, this); + const RangeResponse* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:etcdserverpb.RangeResponse) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:etcdserverpb.RangeResponse) + MergeFrom(*source); + } +} + +void RangeResponse::MergeFrom(const RangeResponse& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:etcdserverpb.RangeResponse) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + kvs_.MergeFrom(from.kvs_); + if (from.has_header()) { + mutable_header()->::etcdserverpb::ResponseHeader::MergeFrom(from.header()); + } + if (from.count() != 0) { + set_count(from.count()); + } + if (from.more() != 0) { + set_more(from.more()); + } +} + +void RangeResponse::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:etcdserverpb.RangeResponse) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void RangeResponse::CopyFrom(const RangeResponse& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:etcdserverpb.RangeResponse) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool RangeResponse::IsInitialized() const { + return true; +} + +void RangeResponse::InternalSwap(RangeResponse* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + CastToBase(&kvs_)->InternalSwap(CastToBase(&other->kvs_)); + swap(header_, other->header_); + swap(count_, other->count_); + swap(more_, other->more_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata RangeResponse::GetMetadata() const { + return GetMetadataStatic(); +} + + // =================================================================== void WatchRequest::InitAsDefaultInstance() { @@ -3707,6 +5022,12 @@ void Event::InternalSwap(Event* other) { // @@protoc_insertion_point(namespace_scope) } // namespace etcdserverpb PROTOBUF_NAMESPACE_OPEN +template<> PROTOBUF_NOINLINE ::etcdserverpb::RangeRequest* Arena::CreateMaybeMessage< ::etcdserverpb::RangeRequest >(Arena* arena) { + return Arena::CreateInternal< ::etcdserverpb::RangeRequest >(arena); +} +template<> PROTOBUF_NOINLINE ::etcdserverpb::RangeResponse* Arena::CreateMaybeMessage< ::etcdserverpb::RangeResponse >(Arena* arena) { + return Arena::CreateInternal< ::etcdserverpb::RangeResponse >(arena); +} template<> PROTOBUF_NOINLINE ::etcdserverpb::WatchRequest* Arena::CreateMaybeMessage< ::etcdserverpb::WatchRequest >(Arena* arena) { return Arena::CreateInternal< ::etcdserverpb::WatchRequest >(arena); } diff --git a/proxy/src/grpc/etcd.pb.h b/proxy/src/grpc/etcd.pb.h index c42ab01847..eba865a348 100644 --- a/proxy/src/grpc/etcd.pb.h +++ b/proxy/src/grpc/etcd.pb.h @@ -48,7 +48,7 @@ struct TableStruct_etcd_2eproto { PROTOBUF_SECTION_VARIABLE(protodesc_cold); static const ::PROTOBUF_NAMESPACE_ID::internal::AuxillaryParseTableField aux[] PROTOBUF_SECTION_VARIABLE(protodesc_cold); - static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[8] + static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[10] PROTOBUF_SECTION_VARIABLE(protodesc_cold); static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[]; static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[]; @@ -62,6 +62,12 @@ extern EventDefaultTypeInternal _Event_default_instance_; class KeyValue; class KeyValueDefaultTypeInternal; extern KeyValueDefaultTypeInternal _KeyValue_default_instance_; +class RangeRequest; +class RangeRequestDefaultTypeInternal; +extern RangeRequestDefaultTypeInternal _RangeRequest_default_instance_; +class RangeResponse; +class RangeResponseDefaultTypeInternal; +extern RangeResponseDefaultTypeInternal _RangeResponse_default_instance_; class ResponseHeader; class ResponseHeaderDefaultTypeInternal; extern ResponseHeaderDefaultTypeInternal _ResponseHeader_default_instance_; @@ -84,6 +90,8 @@ extern WatchResponseDefaultTypeInternal _WatchResponse_default_instance_; PROTOBUF_NAMESPACE_OPEN template<> ::etcdserverpb::Event* Arena::CreateMaybeMessage<::etcdserverpb::Event>(Arena*); template<> ::etcdserverpb::KeyValue* Arena::CreateMaybeMessage<::etcdserverpb::KeyValue>(Arena*); +template<> ::etcdserverpb::RangeRequest* Arena::CreateMaybeMessage<::etcdserverpb::RangeRequest>(Arena*); +template<> ::etcdserverpb::RangeResponse* Arena::CreateMaybeMessage<::etcdserverpb::RangeResponse>(Arena*); template<> ::etcdserverpb::ResponseHeader* Arena::CreateMaybeMessage<::etcdserverpb::ResponseHeader>(Arena*); template<> ::etcdserverpb::WatchCancelRequest* Arena::CreateMaybeMessage<::etcdserverpb::WatchCancelRequest>(Arena*); template<> ::etcdserverpb::WatchCreateRequest* Arena::CreateMaybeMessage<::etcdserverpb::WatchCreateRequest>(Arena*); @@ -93,6 +101,60 @@ template<> ::etcdserverpb::WatchResponse* Arena::CreateMaybeMessage<::etcdserver PROTOBUF_NAMESPACE_CLOSE namespace etcdserverpb { +enum RangeRequest_SortOrder : int { + RangeRequest_SortOrder_NONE = 0, + RangeRequest_SortOrder_ASCEND = 1, + RangeRequest_SortOrder_DESCEND = 2, + RangeRequest_SortOrder_RangeRequest_SortOrder_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(), + RangeRequest_SortOrder_RangeRequest_SortOrder_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max() +}; +bool RangeRequest_SortOrder_IsValid(int value); +constexpr RangeRequest_SortOrder RangeRequest_SortOrder_SortOrder_MIN = RangeRequest_SortOrder_NONE; +constexpr RangeRequest_SortOrder RangeRequest_SortOrder_SortOrder_MAX = RangeRequest_SortOrder_DESCEND; +constexpr int RangeRequest_SortOrder_SortOrder_ARRAYSIZE = RangeRequest_SortOrder_SortOrder_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* RangeRequest_SortOrder_descriptor(); +template +inline const std::string& RangeRequest_SortOrder_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function RangeRequest_SortOrder_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + RangeRequest_SortOrder_descriptor(), enum_t_value); +} +inline bool RangeRequest_SortOrder_Parse( + const std::string& name, RangeRequest_SortOrder* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + RangeRequest_SortOrder_descriptor(), name, value); +} +enum RangeRequest_SortTarget : int { + RangeRequest_SortTarget_KEY = 0, + RangeRequest_SortTarget_VERSION = 1, + RangeRequest_SortTarget_CREATE = 2, + RangeRequest_SortTarget_MOD = 3, + RangeRequest_SortTarget_VALUE = 4, + RangeRequest_SortTarget_RangeRequest_SortTarget_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(), + RangeRequest_SortTarget_RangeRequest_SortTarget_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max() +}; +bool RangeRequest_SortTarget_IsValid(int value); +constexpr RangeRequest_SortTarget RangeRequest_SortTarget_SortTarget_MIN = RangeRequest_SortTarget_KEY; +constexpr RangeRequest_SortTarget RangeRequest_SortTarget_SortTarget_MAX = RangeRequest_SortTarget_VALUE; +constexpr int RangeRequest_SortTarget_SortTarget_ARRAYSIZE = RangeRequest_SortTarget_SortTarget_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* RangeRequest_SortTarget_descriptor(); +template +inline const std::string& RangeRequest_SortTarget_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function RangeRequest_SortTarget_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + RangeRequest_SortTarget_descriptor(), enum_t_value); +} +inline bool RangeRequest_SortTarget_Parse( + const std::string& name, RangeRequest_SortTarget* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + RangeRequest_SortTarget_descriptor(), name, value); +} enum WatchCreateRequest_FilterType : int { WatchCreateRequest_FilterType_NOPUT = 0, WatchCreateRequest_FilterType_NODELETE = 1, @@ -145,6 +207,462 @@ inline bool Event_EventType_Parse( } // =================================================================== +class RangeRequest : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:etcdserverpb.RangeRequest) */ { + public: + RangeRequest(); + virtual ~RangeRequest(); + + RangeRequest(const RangeRequest& from); + RangeRequest(RangeRequest&& from) noexcept + : RangeRequest() { + *this = ::std::move(from); + } + + inline RangeRequest& operator=(const RangeRequest& from) { + CopyFrom(from); + return *this; + } + inline RangeRequest& operator=(RangeRequest&& from) noexcept { + if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const RangeRequest& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const RangeRequest* internal_default_instance() { + return reinterpret_cast( + &_RangeRequest_default_instance_); + } + static constexpr int kIndexInFileMessages = + 0; + + friend void swap(RangeRequest& a, RangeRequest& b) { + a.Swap(&b); + } + inline void Swap(RangeRequest* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline RangeRequest* New() const final { + return CreateMaybeMessage(nullptr); + } + + RangeRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const RangeRequest& from); + void MergeFrom(const RangeRequest& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + #else + bool MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final; + #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + void SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final; + ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(RangeRequest* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "etcdserverpb.RangeRequest"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_etcd_2eproto); + return ::descriptor_table_etcd_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + typedef RangeRequest_SortOrder SortOrder; + static constexpr SortOrder NONE = + RangeRequest_SortOrder_NONE; + static constexpr SortOrder ASCEND = + RangeRequest_SortOrder_ASCEND; + static constexpr SortOrder DESCEND = + RangeRequest_SortOrder_DESCEND; + static inline bool SortOrder_IsValid(int value) { + return RangeRequest_SortOrder_IsValid(value); + } + static constexpr SortOrder SortOrder_MIN = + RangeRequest_SortOrder_SortOrder_MIN; + static constexpr SortOrder SortOrder_MAX = + RangeRequest_SortOrder_SortOrder_MAX; + static constexpr int SortOrder_ARRAYSIZE = + RangeRequest_SortOrder_SortOrder_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + SortOrder_descriptor() { + return RangeRequest_SortOrder_descriptor(); + } + template + static inline const std::string& SortOrder_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function SortOrder_Name."); + return RangeRequest_SortOrder_Name(enum_t_value); + } + static inline bool SortOrder_Parse(const std::string& name, + SortOrder* value) { + return RangeRequest_SortOrder_Parse(name, value); + } + + typedef RangeRequest_SortTarget SortTarget; + static constexpr SortTarget KEY = + RangeRequest_SortTarget_KEY; + static constexpr SortTarget VERSION = + RangeRequest_SortTarget_VERSION; + static constexpr SortTarget CREATE = + RangeRequest_SortTarget_CREATE; + static constexpr SortTarget MOD = + RangeRequest_SortTarget_MOD; + static constexpr SortTarget VALUE = + RangeRequest_SortTarget_VALUE; + static inline bool SortTarget_IsValid(int value) { + return RangeRequest_SortTarget_IsValid(value); + } + static constexpr SortTarget SortTarget_MIN = + RangeRequest_SortTarget_SortTarget_MIN; + static constexpr SortTarget SortTarget_MAX = + RangeRequest_SortTarget_SortTarget_MAX; + static constexpr int SortTarget_ARRAYSIZE = + RangeRequest_SortTarget_SortTarget_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + SortTarget_descriptor() { + return RangeRequest_SortTarget_descriptor(); + } + template + static inline const std::string& SortTarget_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function SortTarget_Name."); + return RangeRequest_SortTarget_Name(enum_t_value); + } + static inline bool SortTarget_Parse(const std::string& name, + SortTarget* value) { + return RangeRequest_SortTarget_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kKeyFieldNumber = 1, + kRangeEndFieldNumber = 2, + kLimitFieldNumber = 3, + kRevisionFieldNumber = 4, + kSortOrderFieldNumber = 5, + kSortTargetFieldNumber = 6, + kMinModRevisionFieldNumber = 10, + kMaxModRevisionFieldNumber = 11, + kMinCreateRevisionFieldNumber = 12, + kMaxCreateRevisionFieldNumber = 13, + kSerializableFieldNumber = 7, + kKeysOnlyFieldNumber = 8, + kCountOnlyFieldNumber = 9, + }; + // bytes key = 1; + void clear_key(); + const std::string& key() const; + void set_key(const std::string& value); + void set_key(std::string&& value); + void set_key(const char* value); + void set_key(const void* value, size_t size); + std::string* mutable_key(); + std::string* release_key(); + void set_allocated_key(std::string* key); + + // bytes range_end = 2; + void clear_range_end(); + const std::string& range_end() const; + void set_range_end(const std::string& value); + void set_range_end(std::string&& value); + void set_range_end(const char* value); + void set_range_end(const void* value, size_t size); + std::string* mutable_range_end(); + std::string* release_range_end(); + void set_allocated_range_end(std::string* range_end); + + // int64 limit = 3; + void clear_limit(); + ::PROTOBUF_NAMESPACE_ID::int64 limit() const; + void set_limit(::PROTOBUF_NAMESPACE_ID::int64 value); + + // int64 revision = 4; + void clear_revision(); + ::PROTOBUF_NAMESPACE_ID::int64 revision() const; + void set_revision(::PROTOBUF_NAMESPACE_ID::int64 value); + + // .etcdserverpb.RangeRequest.SortOrder sort_order = 5; + void clear_sort_order(); + ::etcdserverpb::RangeRequest_SortOrder sort_order() const; + void set_sort_order(::etcdserverpb::RangeRequest_SortOrder value); + + // .etcdserverpb.RangeRequest.SortTarget sort_target = 6; + void clear_sort_target(); + ::etcdserverpb::RangeRequest_SortTarget sort_target() const; + void set_sort_target(::etcdserverpb::RangeRequest_SortTarget value); + + // int64 min_mod_revision = 10; + void clear_min_mod_revision(); + ::PROTOBUF_NAMESPACE_ID::int64 min_mod_revision() const; + void set_min_mod_revision(::PROTOBUF_NAMESPACE_ID::int64 value); + + // int64 max_mod_revision = 11; + void clear_max_mod_revision(); + ::PROTOBUF_NAMESPACE_ID::int64 max_mod_revision() const; + void set_max_mod_revision(::PROTOBUF_NAMESPACE_ID::int64 value); + + // int64 min_create_revision = 12; + void clear_min_create_revision(); + ::PROTOBUF_NAMESPACE_ID::int64 min_create_revision() const; + void set_min_create_revision(::PROTOBUF_NAMESPACE_ID::int64 value); + + // int64 max_create_revision = 13; + void clear_max_create_revision(); + ::PROTOBUF_NAMESPACE_ID::int64 max_create_revision() const; + void set_max_create_revision(::PROTOBUF_NAMESPACE_ID::int64 value); + + // bool serializable = 7; + void clear_serializable(); + bool serializable() const; + void set_serializable(bool value); + + // bool keys_only = 8; + void clear_keys_only(); + bool keys_only() const; + void set_keys_only(bool value); + + // bool count_only = 9; + void clear_count_only(); + bool count_only() const; + void set_count_only(bool value); + + // @@protoc_insertion_point(class_scope:etcdserverpb.RangeRequest) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr range_end_; + ::PROTOBUF_NAMESPACE_ID::int64 limit_; + ::PROTOBUF_NAMESPACE_ID::int64 revision_; + int sort_order_; + int sort_target_; + ::PROTOBUF_NAMESPACE_ID::int64 min_mod_revision_; + ::PROTOBUF_NAMESPACE_ID::int64 max_mod_revision_; + ::PROTOBUF_NAMESPACE_ID::int64 min_create_revision_; + ::PROTOBUF_NAMESPACE_ID::int64 max_create_revision_; + bool serializable_; + bool keys_only_; + bool count_only_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_etcd_2eproto; +}; +// ------------------------------------------------------------------- + +class RangeResponse : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:etcdserverpb.RangeResponse) */ { + public: + RangeResponse(); + virtual ~RangeResponse(); + + RangeResponse(const RangeResponse& from); + RangeResponse(RangeResponse&& from) noexcept + : RangeResponse() { + *this = ::std::move(from); + } + + inline RangeResponse& operator=(const RangeResponse& from) { + CopyFrom(from); + return *this; + } + inline RangeResponse& operator=(RangeResponse&& from) noexcept { + if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const RangeResponse& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const RangeResponse* internal_default_instance() { + return reinterpret_cast( + &_RangeResponse_default_instance_); + } + static constexpr int kIndexInFileMessages = + 1; + + friend void swap(RangeResponse& a, RangeResponse& b) { + a.Swap(&b); + } + inline void Swap(RangeResponse* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline RangeResponse* New() const final { + return CreateMaybeMessage(nullptr); + } + + RangeResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const RangeResponse& from); + void MergeFrom(const RangeResponse& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + #else + bool MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final; + #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + void SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final; + ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(RangeResponse* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "etcdserverpb.RangeResponse"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_etcd_2eproto); + return ::descriptor_table_etcd_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kKvsFieldNumber = 2, + kHeaderFieldNumber = 1, + kCountFieldNumber = 4, + kMoreFieldNumber = 3, + }; + // repeated .etcdserverpb.KeyValue kvs = 2; + int kvs_size() const; + void clear_kvs(); + ::etcdserverpb::KeyValue* mutable_kvs(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::etcdserverpb::KeyValue >* + mutable_kvs(); + const ::etcdserverpb::KeyValue& kvs(int index) const; + ::etcdserverpb::KeyValue* add_kvs(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::etcdserverpb::KeyValue >& + kvs() const; + + // .etcdserverpb.ResponseHeader header = 1; + bool has_header() const; + void clear_header(); + const ::etcdserverpb::ResponseHeader& header() const; + ::etcdserverpb::ResponseHeader* release_header(); + ::etcdserverpb::ResponseHeader* mutable_header(); + void set_allocated_header(::etcdserverpb::ResponseHeader* header); + + // int64 count = 4; + void clear_count(); + ::PROTOBUF_NAMESPACE_ID::int64 count() const; + void set_count(::PROTOBUF_NAMESPACE_ID::int64 value); + + // bool more = 3; + void clear_more(); + bool more() const; + void set_more(bool value); + + // @@protoc_insertion_point(class_scope:etcdserverpb.RangeResponse) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::etcdserverpb::KeyValue > kvs_; + ::etcdserverpb::ResponseHeader* header_; + ::PROTOBUF_NAMESPACE_ID::int64 count_; + bool more_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_etcd_2eproto; +}; +// ------------------------------------------------------------------- + class WatchRequest : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:etcdserverpb.WatchRequest) */ { public: @@ -194,7 +712,7 @@ class WatchRequest : &_WatchRequest_default_instance_); } static constexpr int kIndexInFileMessages = - 0; + 2; friend void swap(WatchRequest& a, WatchRequest& b) { a.Swap(&b); @@ -361,7 +879,7 @@ class WatchCreateRequest : &_WatchCreateRequest_default_instance_); } static constexpr int kIndexInFileMessages = - 1; + 3; friend void swap(WatchCreateRequest& a, WatchCreateRequest& b) { a.Swap(&b); @@ -588,7 +1106,7 @@ class WatchCancelRequest : &_WatchCancelRequest_default_instance_); } static constexpr int kIndexInFileMessages = - 2; + 4; friend void swap(WatchCancelRequest& a, WatchCancelRequest& b) { a.Swap(&b); @@ -719,7 +1237,7 @@ class WatchProgressRequest : &_WatchProgressRequest_default_instance_); } static constexpr int kIndexInFileMessages = - 3; + 5; friend void swap(WatchProgressRequest& a, WatchProgressRequest& b) { a.Swap(&b); @@ -841,7 +1359,7 @@ class WatchResponse : &_WatchResponse_default_instance_); } static constexpr int kIndexInFileMessages = - 4; + 6; friend void swap(WatchResponse& a, WatchResponse& b) { a.Swap(&b); @@ -1036,7 +1554,7 @@ class ResponseHeader : &_ResponseHeader_default_instance_); } static constexpr int kIndexInFileMessages = - 5; + 7; friend void swap(ResponseHeader& a, ResponseHeader& b) { a.Swap(&b); @@ -1188,7 +1706,7 @@ class KeyValue : &_KeyValue_default_instance_); } static constexpr int kIndexInFileMessages = - 6; + 8; friend void swap(KeyValue& a, KeyValue& b) { a.Swap(&b); @@ -1366,7 +1884,7 @@ class Event : &_Event_default_instance_); } static constexpr int kIndexInFileMessages = - 7; + 9; friend void swap(Event& a, Event& b) { a.Swap(&b); @@ -1512,6 +2030,379 @@ class Event : #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wstrict-aliasing" #endif // __GNUC__ +// RangeRequest + +// bytes key = 1; +inline void RangeRequest::clear_key() { + key_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& RangeRequest::key() const { + // @@protoc_insertion_point(field_get:etcdserverpb.RangeRequest.key) + return key_.GetNoArena(); +} +inline void RangeRequest::set_key(const std::string& value) { + + key_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:etcdserverpb.RangeRequest.key) +} +inline void RangeRequest::set_key(std::string&& value) { + + key_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:etcdserverpb.RangeRequest.key) +} +inline void RangeRequest::set_key(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + key_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:etcdserverpb.RangeRequest.key) +} +inline void RangeRequest::set_key(const void* value, size_t size) { + + key_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:etcdserverpb.RangeRequest.key) +} +inline std::string* RangeRequest::mutable_key() { + + // @@protoc_insertion_point(field_mutable:etcdserverpb.RangeRequest.key) + return key_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* RangeRequest::release_key() { + // @@protoc_insertion_point(field_release:etcdserverpb.RangeRequest.key) + + return key_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void RangeRequest::set_allocated_key(std::string* key) { + if (key != nullptr) { + + } else { + + } + key_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), key); + // @@protoc_insertion_point(field_set_allocated:etcdserverpb.RangeRequest.key) +} + +// bytes range_end = 2; +inline void RangeRequest::clear_range_end() { + range_end_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& RangeRequest::range_end() const { + // @@protoc_insertion_point(field_get:etcdserverpb.RangeRequest.range_end) + return range_end_.GetNoArena(); +} +inline void RangeRequest::set_range_end(const std::string& value) { + + range_end_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:etcdserverpb.RangeRequest.range_end) +} +inline void RangeRequest::set_range_end(std::string&& value) { + + range_end_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:etcdserverpb.RangeRequest.range_end) +} +inline void RangeRequest::set_range_end(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + range_end_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:etcdserverpb.RangeRequest.range_end) +} +inline void RangeRequest::set_range_end(const void* value, size_t size) { + + range_end_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:etcdserverpb.RangeRequest.range_end) +} +inline std::string* RangeRequest::mutable_range_end() { + + // @@protoc_insertion_point(field_mutable:etcdserverpb.RangeRequest.range_end) + return range_end_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* RangeRequest::release_range_end() { + // @@protoc_insertion_point(field_release:etcdserverpb.RangeRequest.range_end) + + return range_end_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void RangeRequest::set_allocated_range_end(std::string* range_end) { + if (range_end != nullptr) { + + } else { + + } + range_end_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), range_end); + // @@protoc_insertion_point(field_set_allocated:etcdserverpb.RangeRequest.range_end) +} + +// int64 limit = 3; +inline void RangeRequest::clear_limit() { + limit_ = PROTOBUF_LONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::int64 RangeRequest::limit() const { + // @@protoc_insertion_point(field_get:etcdserverpb.RangeRequest.limit) + return limit_; +} +inline void RangeRequest::set_limit(::PROTOBUF_NAMESPACE_ID::int64 value) { + + limit_ = value; + // @@protoc_insertion_point(field_set:etcdserverpb.RangeRequest.limit) +} + +// int64 revision = 4; +inline void RangeRequest::clear_revision() { + revision_ = PROTOBUF_LONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::int64 RangeRequest::revision() const { + // @@protoc_insertion_point(field_get:etcdserverpb.RangeRequest.revision) + return revision_; +} +inline void RangeRequest::set_revision(::PROTOBUF_NAMESPACE_ID::int64 value) { + + revision_ = value; + // @@protoc_insertion_point(field_set:etcdserverpb.RangeRequest.revision) +} + +// .etcdserverpb.RangeRequest.SortOrder sort_order = 5; +inline void RangeRequest::clear_sort_order() { + sort_order_ = 0; +} +inline ::etcdserverpb::RangeRequest_SortOrder RangeRequest::sort_order() const { + // @@protoc_insertion_point(field_get:etcdserverpb.RangeRequest.sort_order) + return static_cast< ::etcdserverpb::RangeRequest_SortOrder >(sort_order_); +} +inline void RangeRequest::set_sort_order(::etcdserverpb::RangeRequest_SortOrder value) { + + sort_order_ = value; + // @@protoc_insertion_point(field_set:etcdserverpb.RangeRequest.sort_order) +} + +// .etcdserverpb.RangeRequest.SortTarget sort_target = 6; +inline void RangeRequest::clear_sort_target() { + sort_target_ = 0; +} +inline ::etcdserverpb::RangeRequest_SortTarget RangeRequest::sort_target() const { + // @@protoc_insertion_point(field_get:etcdserverpb.RangeRequest.sort_target) + return static_cast< ::etcdserverpb::RangeRequest_SortTarget >(sort_target_); +} +inline void RangeRequest::set_sort_target(::etcdserverpb::RangeRequest_SortTarget value) { + + sort_target_ = value; + // @@protoc_insertion_point(field_set:etcdserverpb.RangeRequest.sort_target) +} + +// bool serializable = 7; +inline void RangeRequest::clear_serializable() { + serializable_ = false; +} +inline bool RangeRequest::serializable() const { + // @@protoc_insertion_point(field_get:etcdserverpb.RangeRequest.serializable) + return serializable_; +} +inline void RangeRequest::set_serializable(bool value) { + + serializable_ = value; + // @@protoc_insertion_point(field_set:etcdserverpb.RangeRequest.serializable) +} + +// bool keys_only = 8; +inline void RangeRequest::clear_keys_only() { + keys_only_ = false; +} +inline bool RangeRequest::keys_only() const { + // @@protoc_insertion_point(field_get:etcdserverpb.RangeRequest.keys_only) + return keys_only_; +} +inline void RangeRequest::set_keys_only(bool value) { + + keys_only_ = value; + // @@protoc_insertion_point(field_set:etcdserverpb.RangeRequest.keys_only) +} + +// bool count_only = 9; +inline void RangeRequest::clear_count_only() { + count_only_ = false; +} +inline bool RangeRequest::count_only() const { + // @@protoc_insertion_point(field_get:etcdserverpb.RangeRequest.count_only) + return count_only_; +} +inline void RangeRequest::set_count_only(bool value) { + + count_only_ = value; + // @@protoc_insertion_point(field_set:etcdserverpb.RangeRequest.count_only) +} + +// int64 min_mod_revision = 10; +inline void RangeRequest::clear_min_mod_revision() { + min_mod_revision_ = PROTOBUF_LONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::int64 RangeRequest::min_mod_revision() const { + // @@protoc_insertion_point(field_get:etcdserverpb.RangeRequest.min_mod_revision) + return min_mod_revision_; +} +inline void RangeRequest::set_min_mod_revision(::PROTOBUF_NAMESPACE_ID::int64 value) { + + min_mod_revision_ = value; + // @@protoc_insertion_point(field_set:etcdserverpb.RangeRequest.min_mod_revision) +} + +// int64 max_mod_revision = 11; +inline void RangeRequest::clear_max_mod_revision() { + max_mod_revision_ = PROTOBUF_LONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::int64 RangeRequest::max_mod_revision() const { + // @@protoc_insertion_point(field_get:etcdserverpb.RangeRequest.max_mod_revision) + return max_mod_revision_; +} +inline void RangeRequest::set_max_mod_revision(::PROTOBUF_NAMESPACE_ID::int64 value) { + + max_mod_revision_ = value; + // @@protoc_insertion_point(field_set:etcdserverpb.RangeRequest.max_mod_revision) +} + +// int64 min_create_revision = 12; +inline void RangeRequest::clear_min_create_revision() { + min_create_revision_ = PROTOBUF_LONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::int64 RangeRequest::min_create_revision() const { + // @@protoc_insertion_point(field_get:etcdserverpb.RangeRequest.min_create_revision) + return min_create_revision_; +} +inline void RangeRequest::set_min_create_revision(::PROTOBUF_NAMESPACE_ID::int64 value) { + + min_create_revision_ = value; + // @@protoc_insertion_point(field_set:etcdserverpb.RangeRequest.min_create_revision) +} + +// int64 max_create_revision = 13; +inline void RangeRequest::clear_max_create_revision() { + max_create_revision_ = PROTOBUF_LONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::int64 RangeRequest::max_create_revision() const { + // @@protoc_insertion_point(field_get:etcdserverpb.RangeRequest.max_create_revision) + return max_create_revision_; +} +inline void RangeRequest::set_max_create_revision(::PROTOBUF_NAMESPACE_ID::int64 value) { + + max_create_revision_ = value; + // @@protoc_insertion_point(field_set:etcdserverpb.RangeRequest.max_create_revision) +} + +// ------------------------------------------------------------------- + +// RangeResponse + +// .etcdserverpb.ResponseHeader header = 1; +inline bool RangeResponse::has_header() const { + return this != internal_default_instance() && header_ != nullptr; +} +inline void RangeResponse::clear_header() { + if (GetArenaNoVirtual() == nullptr && header_ != nullptr) { + delete header_; + } + header_ = nullptr; +} +inline const ::etcdserverpb::ResponseHeader& RangeResponse::header() const { + const ::etcdserverpb::ResponseHeader* p = header_; + // @@protoc_insertion_point(field_get:etcdserverpb.RangeResponse.header) + return p != nullptr ? *p : *reinterpret_cast( + &::etcdserverpb::_ResponseHeader_default_instance_); +} +inline ::etcdserverpb::ResponseHeader* RangeResponse::release_header() { + // @@protoc_insertion_point(field_release:etcdserverpb.RangeResponse.header) + + ::etcdserverpb::ResponseHeader* temp = header_; + header_ = nullptr; + return temp; +} +inline ::etcdserverpb::ResponseHeader* RangeResponse::mutable_header() { + + if (header_ == nullptr) { + auto* p = CreateMaybeMessage<::etcdserverpb::ResponseHeader>(GetArenaNoVirtual()); + header_ = p; + } + // @@protoc_insertion_point(field_mutable:etcdserverpb.RangeResponse.header) + return header_; +} +inline void RangeResponse::set_allocated_header(::etcdserverpb::ResponseHeader* header) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete header_; + } + if (header) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + header = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, header, submessage_arena); + } + + } else { + + } + header_ = header; + // @@protoc_insertion_point(field_set_allocated:etcdserverpb.RangeResponse.header) +} + +// repeated .etcdserverpb.KeyValue kvs = 2; +inline int RangeResponse::kvs_size() const { + return kvs_.size(); +} +inline void RangeResponse::clear_kvs() { + kvs_.Clear(); +} +inline ::etcdserverpb::KeyValue* RangeResponse::mutable_kvs(int index) { + // @@protoc_insertion_point(field_mutable:etcdserverpb.RangeResponse.kvs) + return kvs_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::etcdserverpb::KeyValue >* +RangeResponse::mutable_kvs() { + // @@protoc_insertion_point(field_mutable_list:etcdserverpb.RangeResponse.kvs) + return &kvs_; +} +inline const ::etcdserverpb::KeyValue& RangeResponse::kvs(int index) const { + // @@protoc_insertion_point(field_get:etcdserverpb.RangeResponse.kvs) + return kvs_.Get(index); +} +inline ::etcdserverpb::KeyValue* RangeResponse::add_kvs() { + // @@protoc_insertion_point(field_add:etcdserverpb.RangeResponse.kvs) + return kvs_.Add(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::etcdserverpb::KeyValue >& +RangeResponse::kvs() const { + // @@protoc_insertion_point(field_list:etcdserverpb.RangeResponse.kvs) + return kvs_; +} + +// bool more = 3; +inline void RangeResponse::clear_more() { + more_ = false; +} +inline bool RangeResponse::more() const { + // @@protoc_insertion_point(field_get:etcdserverpb.RangeResponse.more) + return more_; +} +inline void RangeResponse::set_more(bool value) { + + more_ = value; + // @@protoc_insertion_point(field_set:etcdserverpb.RangeResponse.more) +} + +// int64 count = 4; +inline void RangeResponse::clear_count() { + count_ = PROTOBUF_LONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::int64 RangeResponse::count() const { + // @@protoc_insertion_point(field_get:etcdserverpb.RangeResponse.count) + return count_; +} +inline void RangeResponse::set_count(::PROTOBUF_NAMESPACE_ID::int64 value) { + + count_ = value; + // @@protoc_insertion_point(field_set:etcdserverpb.RangeResponse.count) +} + +// ------------------------------------------------------------------- + // WatchRequest // .etcdserverpb.WatchCreateRequest create_request = 1; @@ -2439,6 +3330,10 @@ inline void Event::set_allocated_prev_kv(::etcdserverpb::KeyValue* prev_kv) { // ------------------------------------------------------------------- +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + // @@protoc_insertion_point(namespace_scope) @@ -2446,6 +3341,16 @@ inline void Event::set_allocated_prev_kv(::etcdserverpb::KeyValue* prev_kv) { PROTOBUF_NAMESPACE_OPEN +template <> struct is_proto_enum< ::etcdserverpb::RangeRequest_SortOrder> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::etcdserverpb::RangeRequest_SortOrder>() { + return ::etcdserverpb::RangeRequest_SortOrder_descriptor(); +} +template <> struct is_proto_enum< ::etcdserverpb::RangeRequest_SortTarget> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::etcdserverpb::RangeRequest_SortTarget>() { + return ::etcdserverpb::RangeRequest_SortTarget_descriptor(); +} template <> struct is_proto_enum< ::etcdserverpb::WatchCreateRequest_FilterType> : ::std::true_type {}; template <> inline const EnumDescriptor* GetEnumDescriptor< ::etcdserverpb::WatchCreateRequest_FilterType>() { diff --git a/proxy/src/grpc/master.pb.cc b/proxy/src/grpc/master.pb.cc index 1535ed7de2..513ffd860b 100644 --- a/proxy/src/grpc/master.pb.cc +++ b/proxy/src/grpc/master.pb.cc @@ -101,6 +101,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_master_2eproto::offsets[] PROT PROTOBUF_FIELD_OFFSET(::masterpb::Segment, channel_end_), PROTOBUF_FIELD_OFFSET(::masterpb::Segment, open_timestamp_), PROTOBUF_FIELD_OFFSET(::masterpb::Segment, close_timestamp_), + PROTOBUF_FIELD_OFFSET(::masterpb::Segment, collection_name_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::masterpb::SegmentStat, _internal_metadata_), ~0u, // no _extensions_ @@ -113,7 +114,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_master_2eproto::offsets[] PROT static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { { 0, -1, sizeof(::masterpb::Collection)}, { 11, -1, sizeof(::masterpb::Segment)}, - { 23, -1, sizeof(::masterpb::SegmentStat)}, + { 24, -1, sizeof(::masterpb::SegmentStat)}, }; static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { @@ -127,16 +128,16 @@ const char descriptor_table_protodef_master_2eproto[] PROTOBUF_SECTION_VARIABLE( "\215\001\n\nCollection\022\n\n\002id\030\001 \001(\004\022\014\n\004name\030\002 \001(\t" "\022#\n\006schema\030\003 \001(\0132\023.milvus.grpc.Schema\022\023\n" "\013create_time\030\004 \001(\004\022\023\n\013segment_ids\030\005 \003(\004\022" - "\026\n\016partition_tags\030\006 \003(\t\"\250\001\n\007Segment\022\022\n\ns" + "\026\n\016partition_tags\030\006 \003(\t\"\301\001\n\007Segment\022\022\n\ns" "egment_id\030\001 \001(\004\022\025\n\rcollection_id\030\002 \001(\004\022\025" "\n\rpartition_tag\030\003 \001(\t\022\025\n\rchannel_start\030\004" " \001(\005\022\023\n\013channel_end\030\005 \001(\005\022\026\n\016open_timest" - "amp\030\006 \001(\004\022\027\n\017close_timestamp\030\007 \001(\004\"K\n\013Se" - "gmentStat\022\022\n\nsegment_id\030\001 \001(\004\022\023\n\013memory_" - "size\030\002 \001(\004\022\023\n\013memory_rate\030\003 \001(\0022I\n\006Maste" - "r\022\?\n\020CreateCollection\022\024.milvus.grpc.Mapp" - "ing\032\023.milvus.grpc.Status\"\000B\010Z\006masterb\006pr" - "oto3" + "amp\030\006 \001(\004\022\027\n\017close_timestamp\030\007 \001(\004\022\027\n\017co" + "llection_name\030\010 \001(\t\"K\n\013SegmentStat\022\022\n\nse" + "gment_id\030\001 \001(\004\022\023\n\013memory_size\030\002 \001(\004\022\023\n\013m" + "emory_rate\030\003 \001(\0022I\n\006Master\022\?\n\020CreateColl" + "ection\022\024.milvus.grpc.Mapping\032\023.milvus.gr" + "pc.Status\"\000B\010Z\006masterb\006proto3" ; static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_master_2eproto_deps[1] = { &::descriptor_table_message_2eproto, @@ -149,7 +150,7 @@ static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_mas static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_master_2eproto_once; static bool descriptor_table_master_2eproto_initialized = false; const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_master_2eproto = { - &descriptor_table_master_2eproto_initialized, descriptor_table_protodef_master_2eproto, "master.proto", 524, + &descriptor_table_master_2eproto_initialized, descriptor_table_protodef_master_2eproto, "master.proto", 549, &descriptor_table_master_2eproto_once, descriptor_table_master_2eproto_sccs, descriptor_table_master_2eproto_deps, 3, 1, schemas, file_default_instances, TableStruct_master_2eproto::offsets, file_level_metadata_master_2eproto, 3, file_level_enum_descriptors_master_2eproto, file_level_service_descriptors_master_2eproto, @@ -734,6 +735,10 @@ Segment::Segment(const Segment& from) if (!from.partition_tag().empty()) { partition_tag_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.partition_tag_); } + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.collection_name().empty()) { + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); + } ::memcpy(&segment_id_, &from.segment_id_, static_cast(reinterpret_cast(&close_timestamp_) - reinterpret_cast(&segment_id_)) + sizeof(close_timestamp_)); @@ -743,6 +748,7 @@ Segment::Segment(const Segment& from) void Segment::SharedCtor() { ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Segment_master_2eproto.base); partition_tag_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); ::memset(&segment_id_, 0, static_cast( reinterpret_cast(&close_timestamp_) - reinterpret_cast(&segment_id_)) + sizeof(close_timestamp_)); @@ -755,6 +761,7 @@ Segment::~Segment() { void Segment::SharedDtor() { partition_tag_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + collection_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } void Segment::SetCachedSize(int size) const { @@ -773,6 +780,7 @@ void Segment::Clear() { (void) cached_has_bits; partition_tag_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); ::memset(&segment_id_, 0, static_cast( reinterpret_cast(&close_timestamp_) - reinterpret_cast(&segment_id_)) + sizeof(close_timestamp_)); @@ -836,6 +844,13 @@ const char* Segment::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::in CHK_(ptr); } else goto handle_unusual; continue; + // string collection_name = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_collection_name(), ptr, ctx, "masterpb.Segment.collection_name"); + CHK_(ptr); + } else goto handle_unusual; + continue; default: { handle_unusual: if ((tag & 7) == 4 || tag == 0) { @@ -959,6 +974,21 @@ bool Segment::MergePartialFromCodedStream( break; } + // string collection_name = 8; + case 8: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (66 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_collection_name())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "masterpb.Segment.collection_name")); + } else { + goto handle_unusual; + } + break; + } + default: { handle_unusual: if (tag == 0) { @@ -1026,6 +1056,16 @@ void Segment::SerializeWithCachedSizes( ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(7, this->close_timestamp(), output); } + // string collection_name = 8; + if (this->collection_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "masterpb.Segment.collection_name"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 8, this->collection_name(), output); + } + if (_internal_metadata_.have_unknown_fields()) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( _internal_metadata_.unknown_fields(), output); @@ -1080,6 +1120,17 @@ void Segment::SerializeWithCachedSizes( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(7, this->close_timestamp(), target); } + // string collection_name = 8; + if (this->collection_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "masterpb.Segment.collection_name"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 8, this->collection_name(), target); + } + if (_internal_metadata_.have_unknown_fields()) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields(), target); @@ -1108,6 +1159,13 @@ size_t Segment::ByteSizeLong() const { this->partition_tag()); } + // string collection_name = 8; + if (this->collection_name().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->collection_name()); + } + // uint64 segment_id = 1; if (this->segment_id() != 0) { total_size += 1 + @@ -1181,6 +1239,10 @@ void Segment::MergeFrom(const Segment& from) { partition_tag_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.partition_tag_); } + if (from.collection_name().size() > 0) { + + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); + } if (from.segment_id() != 0) { set_segment_id(from.segment_id()); } @@ -1224,6 +1286,8 @@ void Segment::InternalSwap(Segment* other) { _internal_metadata_.Swap(&other->_internal_metadata_); partition_tag_.Swap(&other->partition_tag_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); + collection_name_.Swap(&other->collection_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); swap(segment_id_, other->segment_id_); swap(collection_id_, other->collection_id_); swap(channel_start_, other->channel_start_); diff --git a/proxy/src/grpc/master.pb.h b/proxy/src/grpc/master.pb.h index 18e134696f..89f3eeb8cc 100644 --- a/proxy/src/grpc/master.pb.h +++ b/proxy/src/grpc/master.pb.h @@ -383,6 +383,7 @@ class Segment : enum : int { kPartitionTagFieldNumber = 3, + kCollectionNameFieldNumber = 8, kSegmentIdFieldNumber = 1, kCollectionIdFieldNumber = 2, kChannelStartFieldNumber = 4, @@ -401,6 +402,17 @@ class Segment : std::string* release_partition_tag(); void set_allocated_partition_tag(std::string* partition_tag); + // string collection_name = 8; + void clear_collection_name(); + const std::string& collection_name() const; + void set_collection_name(const std::string& value); + void set_collection_name(std::string&& value); + void set_collection_name(const char* value); + void set_collection_name(const char* value, size_t size); + std::string* mutable_collection_name(); + std::string* release_collection_name(); + void set_allocated_collection_name(std::string* collection_name); + // uint64 segment_id = 1; void clear_segment_id(); ::PROTOBUF_NAMESPACE_ID::uint64 segment_id() const; @@ -437,6 +449,7 @@ class Segment : ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr partition_tag_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collection_name_; ::PROTOBUF_NAMESPACE_ID::uint64 segment_id_; ::PROTOBUF_NAMESPACE_ID::uint64 collection_id_; ::PROTOBUF_NAMESPACE_ID::int32 channel_start_; @@ -960,6 +973,57 @@ inline void Segment::set_close_timestamp(::PROTOBUF_NAMESPACE_ID::uint64 value) // @@protoc_insertion_point(field_set:masterpb.Segment.close_timestamp) } +// string collection_name = 8; +inline void Segment::clear_collection_name() { + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& Segment::collection_name() const { + // @@protoc_insertion_point(field_get:masterpb.Segment.collection_name) + return collection_name_.GetNoArena(); +} +inline void Segment::set_collection_name(const std::string& value) { + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:masterpb.Segment.collection_name) +} +inline void Segment::set_collection_name(std::string&& value) { + + collection_name_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:masterpb.Segment.collection_name) +} +inline void Segment::set_collection_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:masterpb.Segment.collection_name) +} +inline void Segment::set_collection_name(const char* value, size_t size) { + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:masterpb.Segment.collection_name) +} +inline std::string* Segment::mutable_collection_name() { + + // @@protoc_insertion_point(field_mutable:masterpb.Segment.collection_name) + return collection_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* Segment::release_collection_name() { + // @@protoc_insertion_point(field_release:masterpb.Segment.collection_name) + + return collection_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void Segment::set_allocated_collection_name(std::string* collection_name) { + if (collection_name != nullptr) { + + } else { + + } + collection_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), collection_name); + // @@protoc_insertion_point(field_set_allocated:masterpb.Segment.collection_name) +} + // ------------------------------------------------------------------- // SegmentStat diff --git a/proxy/src/grpc/proto/etcd.proto b/proxy/src/grpc/proto/etcd.proto index 73215ee4a5..fb8f06700b 100644 --- a/proxy/src/grpc/proto/etcd.proto +++ b/proxy/src/grpc/proto/etcd.proto @@ -11,6 +11,90 @@ service Watch { } } +service KV { + // Range gets the keys in the range from the key-value store. + rpc Range(RangeRequest) returns (RangeResponse) { + } +} + +message RangeRequest { + enum SortOrder { + NONE = 0; // default, no sorting + ASCEND = 1; // lowest target value first + DESCEND = 2; // highest target value first + } + enum SortTarget { + KEY = 0; + VERSION = 1; + CREATE = 2; + MOD = 3; + VALUE = 4; + } + + // key is the first key for the range. If range_end is not given, the request only looks up key. + bytes key = 1; + // range_end is the upper bound on the requested range [key, range_end). + // If range_end is '\0', the range is all keys >= key. + // If range_end is key plus one (e.g., "aa"+1 == "ab", "a\xff"+1 == "b"), + // then the range request gets all keys prefixed with key. + // If both key and range_end are '\0', then the range request returns all keys. + bytes range_end = 2; + // limit is a limit on the number of keys returned for the request. When limit is set to 0, + // it is treated as no limit. + int64 limit = 3; + // revision is the point-in-time of the key-value store to use for the range. + // If revision is less or equal to zero, the range is over the newest key-value store. + // If the revision has been compacted, ErrCompacted is returned as a response. + int64 revision = 4; + + // sort_order is the order for returned sorted results. + SortOrder sort_order = 5; + + // sort_target is the key-value field to use for sorting. + SortTarget sort_target = 6; + + // serializable sets the range request to use serializable member-local reads. + // Range requests are linearizable by default; linearizable requests have higher + // latency and lower throughput than serializable requests but reflect the current + // consensus of the cluster. For better performance, in exchange for possible stale reads, + // a serializable range request is served locally without needing to reach consensus + // with other nodes in the cluster. + bool serializable = 7; + + // keys_only when set returns only the keys and not the values. + bool keys_only = 8; + + // count_only when set returns only the count of the keys in the range. + bool count_only = 9; + + // min_mod_revision is the lower bound for returned key mod revisions; all keys with + // lesser mod revisions will be filtered away. + int64 min_mod_revision = 10; + + // max_mod_revision is the upper bound for returned key mod revisions; all keys with + // greater mod revisions will be filtered away. + int64 max_mod_revision = 11; + + // min_create_revision is the lower bound for returned key create revisions; all keys with + // lesser create revisions will be filtered away. + int64 min_create_revision = 12; + + // max_create_revision is the upper bound for returned key create revisions; all keys with + // greater create revisions will be filtered away. + int64 max_create_revision = 13; +} + +message RangeResponse { + ResponseHeader header = 1; + // kvs is the list of key-value pairs matched by the range request. + // kvs is empty when count is requested. + repeated KeyValue kvs = 2; + // more indicates if there are more keys to return in the requested range. + bool more = 3; + // count is set to the number of keys within the range when requested. + int64 count = 4; +} + message WatchRequest { // request_union is a request to either create a new watcher or cancel an existing watcher. oneof request_union { diff --git a/proxy/src/message_client/ClientV2.cpp b/proxy/src/message_client/ClientV2.cpp index ae795e7955..826c213231 100644 --- a/proxy/src/message_client/ClientV2.cpp +++ b/proxy/src/message_client/ClientV2.cpp @@ -2,6 +2,7 @@ #include "pulsar/Result.h" #include "PartitionPolicy.h" #include "utils/CommonUtil.h" +#include "M3_hash.h" #include "config/ServerConfig.h" #include #include @@ -11,7 +12,10 @@ namespace milvus::message_client { std::map>> total_results; -MsgClientV2::MsgClientV2(int64_t client_id, const std::string &service_url, const uint32_t mut_parallelism, const pulsar::ClientConfiguration &config) +MsgClientV2::MsgClientV2(int64_t client_id, + const std::string &service_url, + const uint32_t mut_parallelism, + const pulsar::ClientConfiguration &config) : client_id_(client_id), service_url_(service_url), mut_parallelism_(mut_parallelism) {} Status MsgClientV2::Init(const std::string &insert_delete, @@ -48,13 +52,13 @@ Status MsgClientV2::Init(const std::string &insert_delete, } int64_t GetQueryNodeNum() { - return config.query_node_num(); + return config.query_node_num(); } Status -Aggregation(std::vector> results, milvus::grpc::QueryResult* result) { +Aggregation(std::vector> results, milvus::grpc::QueryResult *result) { if (results.empty()) { - return Status(DB_ERROR, "The result is null!"); + return Status(DB_ERROR, "The result is null!"); } std::vector all_scores; @@ -64,99 +68,101 @@ Aggregation(std::vector> results, milvus::grp std::vector all_row_data; std::vector all_kv_pairs; - grpc::Status status; - int row_num = 0; + grpc::Status status; + int row_num = 0; - for (auto & result_per_node : results) { - if (result_per_node->status().error_code() != grpc::ErrorCode::SUCCESS){ + for (auto &result_per_node : results) { + if (result_per_node->status().error_code() != grpc::ErrorCode::SUCCESS) { // if (one_node_res->status().error_code() != grpc::ErrorCode::SUCCESS || // one_node_res->entities().status().error_code() != grpc::ErrorCode::SUCCESS) { - return Status(DB_ERROR, "QueryNode return wrong status!"); - } - for (int j = 0; j < result_per_node->distances_size(); j++) { - all_scores.push_back(result_per_node->scores()[j]); - all_distance.push_back(result_per_node->distances()[j]); + return Status(DB_ERROR, "QueryNode return wrong status!"); + } + for (int j = 0; j < result_per_node->distances_size(); j++) { + all_scores.push_back(result_per_node->scores()[j]); + all_distance.push_back(result_per_node->distances()[j]); // all_kv_pairs.push_back(result_per_node->extra_params()[j]); - } - for (int k = 0; k < result_per_node->entities().ids_size(); ++k) { - all_entities_ids.push_back(result_per_node->entities().ids(k)); + } + for (int k = 0; k < result_per_node->entities().ids_size(); ++k) { + all_entities_ids.push_back(result_per_node->entities().ids(k)); // all_valid_row.push_back(result_per_node->entities().valid_row(k)); // all_row_data.push_back(result_per_node->entities().rows_data(k)); - } - if (result_per_node->row_num() > row_num){ - row_num = result_per_node->row_num(); - } - status = result_per_node->status(); + } + if (result_per_node->row_num() > row_num) { + row_num = result_per_node->row_num(); + } + status = result_per_node->status(); } - std::vector index(all_distance.size()); + std::vector index(all_distance.size()); - iota(index.begin(), index.end(), 0); + iota(index.begin(), index.end(), 0); - std::stable_sort(index.begin(), index.end(), - [&all_distance](size_t i1, size_t i2) {return all_distance[i1] > all_distance[i2];}); + std::stable_sort(index.begin(), index.end(), + [&all_distance](size_t i1, size_t i2) { return all_distance[i1] > all_distance[i2]; }); - grpc::Entities result_entities; + grpc::Entities result_entities; - for (int m = 0; m < result->row_num(); ++m) { - result->add_scores(all_scores[index[m]]); - result->add_distances(all_distance[index[m]]); + for (int m = 0; m < result->row_num(); ++m) { + result->add_scores(all_scores[index[m]]); + result->add_distances(all_distance[index[m]]); // result->add_extra_params(); // result->mutable_extra_params(m)->CopyFrom(all_kv_pairs[index[m]]); - result_entities.add_ids(all_entities_ids[index[m]]); + result_entities.add_ids(all_entities_ids[index[m]]); // result_entities.add_valid_row(all_valid_row[index[m]]); // result_entities.add_rows_data(); // result_entities.mutable_rows_data(m)->CopyFrom(all_row_data[index[m]]); - } + } - result_entities.mutable_status()->CopyFrom(status); + result_entities.mutable_status()->CopyFrom(status); - result->set_row_num(row_num); - result->mutable_entities()->CopyFrom(result_entities); - result->set_query_id(results[0]->query_id()); + result->set_row_num(row_num); + result->mutable_entities()->CopyFrom(result_entities); + result->set_query_id(results[0]->query_id()); // result->set_client_id(results[0]->client_id()); return Status::OK(); } -Status MsgClientV2::GetQueryResult(int64_t query_id, milvus::grpc::QueryResult* result) { +Status MsgClientV2::GetQueryResult(int64_t query_id, milvus::grpc::QueryResult *result) { - int64_t query_node_num = GetQueryNodeNum(); + int64_t query_node_num = GetQueryNodeNum(); - auto t1 = std::chrono::high_resolution_clock::now(); + auto t1 = std::chrono::high_resolution_clock::now(); - while (true) { - auto received_result = total_results[query_id]; - if (received_result.size() == query_node_num) { - break; - } - Message msg; - consumer_->receive(msg); - - grpc::QueryResult search_res_msg; - auto status = search_res_msg.ParseFromString(msg.getDataAsString()); - if (status) { - auto message = std::make_shared(search_res_msg); - total_results[message->query_id()].push_back(message); - consumer_->acknowledge(msg); - } else { - return Status(DB_ERROR, "can't parse message which from pulsar!"); - } + while (true) { + auto received_result = total_results[query_id]; + if (received_result.size() == query_node_num) { + break; } - auto status = Aggregation(total_results[query_id], result); + Message msg; + consumer_->receive(msg); - return status; + grpc::QueryResult search_res_msg; + auto status = search_res_msg.ParseFromString(msg.getDataAsString()); + if (status) { + auto message = std::make_shared(search_res_msg); + total_results[message->query_id()].push_back(message); + consumer_->acknowledge(msg); + } else { + return Status(DB_ERROR, "can't parse message which from pulsar!"); + } + } + auto status = Aggregation(total_results[query_id], result); + + return status; } -Status MsgClientV2::SendMutMessage(const milvus::grpc::InsertParam &request, uint64_t timestamp) { +Status MsgClientV2::SendMutMessage(const milvus::grpc::InsertParam &request, + uint64_t timestamp, + const std::function &segment_id) { // may have retry policy? auto row_count = request.rows_data_size(); - // TODO: Get the segment from master - int64_t segment = 0; - auto stats = std::vector(ParallelNum); + auto stats = std::vector(ParallelNum); -#pragma omp parallel for default(none), shared(row_count, request, timestamp, segment, stats), num_threads(ParallelNum) +#pragma omp parallel for default(none), shared(row_count, request, timestamp, stats, segment_id), num_threads(ParallelNum) for (auto i = 0; i < row_count; i++) { milvus::grpc::InsertOrDeleteMsg mut_msg; int this_thread = omp_get_thread_num(); @@ -166,34 +172,48 @@ Status MsgClientV2::SendMutMessage(const milvus::grpc::InsertParam &request, uin mut_msg.set_timestamp(timestamp); mut_msg.set_collection_name(request.collection_name()); mut_msg.set_partition_tag(request.partition_tag()); - mut_msg.set_segment_id(segment); - mut_msg.mutable_rows_data()->CopyFrom(request.rows_data(i)); - mut_msg.mutable_extra_params()->CopyFrom(request.extra_params()); + uint64_t uid = request.entity_id_array(i); + auto channel_id = makeHash(&uid, sizeof(uint64_t)); + try { + mut_msg.set_segment_id(segment_id(request.collection_name(), channel_id, timestamp)); + printf("%ld \n", mut_msg.segment_id()); + mut_msg.mutable_rows_data()->CopyFrom(request.rows_data(i)); + mut_msg.mutable_extra_params()->CopyFrom(request.extra_params()); - auto result = paralle_mut_producers_[this_thread]->send(mut_msg); - if (result != pulsar::ResultOk) { - stats[this_thread] = result; + auto result = paralle_mut_producers_[this_thread]->send(mut_msg); + if (result != pulsar::ResultOk) { + stats[this_thread] = Status(DB_ERROR, pulsar::strResult(result)); + } + } + catch (const std::exception &e) { + stats[this_thread] = Status(DB_ERROR, "Meta error"); } } for (auto &stat : stats) { - if (stat != pulsar::ResultOk) { - return Status(DB_ERROR, pulsar::strResult(stat)); + if (!stat.ok()) { + return stat; } } return Status::OK(); } -Status MsgClientV2::SendMutMessage(const milvus::grpc::DeleteByIDParam &request, uint64_t timestamp) { +Status MsgClientV2::SendMutMessage(const milvus::grpc::DeleteByIDParam &request, + uint64_t timestamp, + const std::function &segment_id) { auto stats = std::vector(ParallelNum); -#pragma omp parallel for default(none), shared( request, timestamp, stats), num_threads(ParallelNum) +#pragma omp parallel for default(none), shared( request, timestamp, stats, segment_id), num_threads(ParallelNum) for (auto i = 0; i < request.id_array_size(); i++) { milvus::grpc::InsertOrDeleteMsg mut_msg; mut_msg.set_op(milvus::grpc::OpType::DELETE); - mut_msg.set_uid(GetUniqueQId()); mut_msg.set_client_id(client_id_); mut_msg.set_uid(request.id_array(i)); mut_msg.set_collection_name(request.collection_name()); mut_msg.set_timestamp(timestamp); + uint64_t uid = request.id_array(i); + auto channel_id = makeHash(&uid, sizeof(uint64_t)); + mut_msg.set_segment_id(segment_id(request.collection_name(), channel_id, timestamp)); int this_thread = omp_get_thread_num(); auto result = paralle_mut_producers_[this_thread]->send(mut_msg); @@ -210,51 +230,51 @@ Status MsgClientV2::SendMutMessage(const milvus::grpc::DeleteByIDParam &request, } Status MsgClientV2::SendQueryMessage(const milvus::grpc::SearchParam &request, uint64_t timestamp, int64_t &query_id) { - milvus::grpc::SearchMsg search_msg; + milvus::grpc::SearchMsg search_msg; - query_id = GetUniqueQId(); - search_msg.set_collection_name(request.collection_name()); - search_msg.set_uid(query_id); - //TODO: get client id from master - search_msg.set_client_id(1); - search_msg.set_timestamp(timestamp); - search_msg.set_dsl(request.dsl()); + query_id = GetUniqueQId(); + search_msg.set_collection_name(request.collection_name()); + search_msg.set_uid(query_id); + //TODO: get client id from master + search_msg.set_client_id(1); + search_msg.set_timestamp(timestamp); + search_msg.set_dsl(request.dsl()); - milvus::grpc::VectorRowRecord vector_row_recode; - std::vector vectors_records; - std::string binary_data; - for (int i = 0; i < request.vector_param_size(); ++i) { - search_msg.add_json(request.vector_param(i).json()); - for (int j = 0; j < request.vector_param(i).row_record().records_size(); ++j) { - for (int k = 0; k < request.vector_param(i).row_record().records(j).float_data_size(); ++k) { - vector_row_recode.add_float_data(request.vector_param(i).row_record().records(j).float_data(k)); - } - binary_data.append(request.vector_param(i).row_record().records(j).binary_data()); - } + milvus::grpc::VectorRowRecord vector_row_recode; + std::vector vectors_records; + std::string binary_data; + for (int i = 0; i < request.vector_param_size(); ++i) { + search_msg.add_json(request.vector_param(i).json()); + for (int j = 0; j < request.vector_param(i).row_record().records_size(); ++j) { + for (int k = 0; k < request.vector_param(i).row_record().records(j).float_data_size(); ++k) { + vector_row_recode.add_float_data(request.vector_param(i).row_record().records(j).float_data(k)); + } + binary_data.append(request.vector_param(i).row_record().records(j).binary_data()); } - vector_row_recode.set_binary_data(binary_data); + } + vector_row_recode.set_binary_data(binary_data); - search_msg.mutable_records()->CopyFrom(vector_row_recode); + search_msg.mutable_records()->CopyFrom(vector_row_recode); - for (int m = 0; m < request.partition_tag_size(); ++m) { - search_msg.add_partition_tag(request.partition_tag(m)); - } + for (int m = 0; m < request.partition_tag_size(); ++m) { + search_msg.add_partition_tag(request.partition_tag(m)); + } - for (int l = 0; l < request.extra_params_size(); ++l) { - search_msg.mutable_extra_params(l)->CopyFrom(request.extra_params(l)); - } + for (int l = 0; l < request.extra_params_size(); ++l) { + search_msg.mutable_extra_params(l)->CopyFrom(request.extra_params(l)); + } - auto result = search_producer_->send(search_msg); - if (result != pulsar::Result::ResultOk) { - return Status(DB_ERROR, pulsar::strResult(result)); - } + auto result = search_producer_->send(search_msg); + if (result != pulsar::Result::ResultOk) { + return Status(DB_ERROR, pulsar::strResult(result)); + } - return Status::OK(); + return Status::OK(); } MsgClientV2::~MsgClientV2() { // insert_delete_producer_->close(); - for (auto& producer: paralle_mut_producers_){ + for (auto &producer: paralle_mut_producers_) { producer->close(); } search_producer_->close(); diff --git a/proxy/src/message_client/ClientV2.h b/proxy/src/message_client/ClientV2.h index 7f4404216b..d3dff0ff8e 100644 --- a/proxy/src/message_client/ClientV2.h +++ b/proxy/src/message_client/ClientV2.h @@ -24,9 +24,13 @@ class MsgClientV2 { const std::string &search_result); // unpackage batch insert or delete request, and delivery message to pulsar per row - Status SendMutMessage(const milvus::grpc::InsertParam &request, uint64_t timestamp); + Status SendMutMessage(const milvus::grpc::InsertParam &request, uint64_t timestamp, const std::function&); - Status SendMutMessage(const milvus::grpc::DeleteByIDParam &request, uint64_t timestamp); + Status SendMutMessage(const milvus::grpc::DeleteByIDParam &request, uint64_t timestamp, const std::function&); // Status SendQueryMessage(const milvus::grpc::SearchParam &request, uint64_t timestamp, int64_t &query_id); diff --git a/proxy/src/meta/CMakeLists.txt b/proxy/src/meta/CMakeLists.txt index 69748ecd0a..30b21b9364 100644 --- a/proxy/src/meta/CMakeLists.txt +++ b/proxy/src/meta/CMakeLists.txt @@ -2,8 +2,11 @@ include_directories(${PROJECT_BINARY_DIR}/thirdparty/grpc/grpc-src/third_party/p include_directories(${PROJECT_BINARY_DIR}/thirdparty/grpc/grpc-src/include) add_subdirectory( etcd_watcher ) -aux_source_directory( ./master master_src) -add_library(meta ${master_src} +aux_source_directory( ./master master_src) +aux_source_directory(./etcd_client etcd_src) +add_library(meta + ${master_src} + ${etcd_src} ./etcd_watcher/Watcher.cpp ${PROJECT_SOURCE_DIR}/src/grpc/etcd.pb.cc ${PROJECT_SOURCE_DIR}/src/grpc/etcd.grpc.pb.cc diff --git a/proxy/src/meta/etcd_client/Etcd_client.cpp b/proxy/src/meta/etcd_client/Etcd_client.cpp new file mode 100644 index 0000000000..320885dc35 --- /dev/null +++ b/proxy/src/meta/etcd_client/Etcd_client.cpp @@ -0,0 +1,23 @@ +#include "Etcd_client.h" +#include "grpc++/grpc++.h" + +namespace milvus{ +namespace master{ + +EtcdClient::EtcdClient(const std::string &addr) { + auto channel = grpc::CreateChannel(addr, grpc::InsecureChannelCredentials()); + stub_ = etcdserverpb::KV::NewStub(channel); +} + +Status +EtcdClient::Range(const etcdserverpb::RangeRequest& request, etcdserverpb::RangeResponse& response){ + ::grpc::ClientContext context; + auto status = stub_->Range(&context, request, &response); + if (!status.ok()){ + return Status(DB_ERROR, status.error_message()); + } + return Status::OK(); +} + +} +} \ No newline at end of file diff --git a/proxy/src/meta/etcd_client/Etcd_client.h b/proxy/src/meta/etcd_client/Etcd_client.h new file mode 100644 index 0000000000..363884e6f4 --- /dev/null +++ b/proxy/src/meta/etcd_client/Etcd_client.h @@ -0,0 +1,18 @@ +#include "grpc/etcd.grpc.pb.h" +#include "utils/Status.h" + +namespace milvus { +namespace master { + +class EtcdClient { + public: + explicit EtcdClient(const std::string &addr); + Status + Range(const etcdserverpb::RangeRequest& request, etcdserverpb::RangeResponse& response); + + private: + std::unique_ptr stub_; +}; + +} +} diff --git a/proxy/src/meta/etcd_watcher/Watcher.h b/proxy/src/meta/etcd_watcher/Watcher.h index 657a0ea913..da94d49ad5 100644 --- a/proxy/src/meta/etcd_watcher/Watcher.h +++ b/proxy/src/meta/etcd_watcher/Watcher.h @@ -30,10 +30,10 @@ class AsyncWatchAction { void CancelWatch(); private: // Status status; - grpc::ClientContext context_; - grpc::CompletionQueue cq_; + ::grpc::ClientContext context_; + ::grpc::CompletionQueue cq_; etcdserverpb::WatchResponse reply_; - std::unique_ptr> stream_; + std::unique_ptr<::grpc::ClientAsyncReaderWriter> stream_; std::atomic cancled_ = false; }; } diff --git a/proxy/src/meta/master/GrpcClient.cpp b/proxy/src/meta/master/GrpcClient.cpp index 2e116178fe..54f55bc738 100644 --- a/proxy/src/meta/master/GrpcClient.cpp +++ b/proxy/src/meta/master/GrpcClient.cpp @@ -20,7 +20,7 @@ Status GrpcClient::CreateCollection(const milvus::grpc::Mapping &mapping) { ::grpc::Status grpc_status = stub_->CreateCollection(&context, mapping, &response); if (!grpc_status.ok()) { - std::cerr << "CreateHybridCollection gRPC failed!" << std::endl; + std::cerr << "CreateHybridCollection gRPC failed!" << grpc_status.error_message() << std::endl; return Status(grpc_status.error_code(), grpc_status.error_message()); } diff --git a/proxy/src/server/MetaWrapper.cpp b/proxy/src/server/MetaWrapper.cpp index b2073810e7..7c1ea3e937 100644 --- a/proxy/src/server/MetaWrapper.cpp +++ b/proxy/src/server/MetaWrapper.cpp @@ -1,20 +1,159 @@ #include "MetaWrapper.h" #include "config/ServerConfig.h" -namespace milvus{ +#include "nlohmann/json.hpp" +#include +#include + +using Collection = masterpb::Collection; +using Schema = milvus::grpc::Schema; +using SegmentInfo = masterpb::Segment; +using JSON = nlohmann::json; + +namespace milvus { namespace server { -MetaWrapper& MetaWrapper::GetInstance() { +namespace { +void ParseSegmentInfo(const std::string &json_str, SegmentInfo &segment_info) { + auto json = JSON::parse(json_str); + segment_info.set_segment_id(json["segment_id"].get()); + segment_info.set_partition_tag(json["partition_tag"].get()); + segment_info.set_channel_start(json["channel_start"].get()); + segment_info.set_channel_end(json["channel_end"].get()); + segment_info.set_open_timestamp(json["open_timestamp"].get()); + segment_info.set_close_timestamp(json["close_timestamp"].get()); + segment_info.set_collection_id(json["collection_id"].get()); + segment_info.set_collection_name(json["collection_name"].get()); +} + +void ParseCollectionSchema(const std::string &json_str, Collection &collection) { + auto json = JSON::parse(json_str); + auto proto_str = json["grpc_marshal_string"].get(); + auto suc = google::protobuf::TextFormat::ParseFromString(proto_str, &collection); + if (!suc) { + std::cerr << "unmarshal failed" << std::endl; + } +} +} + +bool MetaWrapper::IsCollectionMetaKey(const std::string &key) { + return key.rfind(collection_path_, 0) == 0; +} + +bool MetaWrapper::IsSegmentMetaKey(const std::string &key) { + return key.rfind(segment_path_, 0) == 0; +} + +MetaWrapper &MetaWrapper::GetInstance() { static MetaWrapper wrapper; return wrapper; } Status MetaWrapper::Init() { - auto addr = config.master.address() + ":" + std::to_string(config.master.port()); - client_ = std::make_shared(addr); + etcd_root_path_ = config.etcd.rootpath(); + segment_path_ = etcd_root_path_ + "segment/"; + collection_path_ = etcd_root_path_ + "collection/"; + + auto master_addr = config.master.address() + ":" + std::to_string(config.master.port()); + master_client_ = std::make_shared(master_addr); + + auto etcd_addr = config.etcd.address() + ":" + std::to_string(config.etcd.port()); + etcd_client_ = std::make_shared(etcd_addr); + + // init etcd watcher + auto f = [&](const etcdserverpb::WatchResponse &res) { + UpdateMeta(res); + }; + watcher_ = std::make_shared(etcd_addr, segment_path_, f, true); + + SyncMeta(); } std::shared_ptr MetaWrapper::MetaClient() { - return client_; + return master_client_; +} + +void MetaWrapper::UpdateMeta(const etcdserverpb::WatchResponse &res) { + for (auto &event: res.events()) { + auto &event_key = event.kv().key(); + auto &event_value = event.kv().value(); + + if (event.type() == etcdserverpb::Event_EventType::Event_EventType_PUT) { + if (event_key.rfind(segment_path_, 0) == 0) { + // segment info + SegmentInfo segment_info; + ParseSegmentInfo(event_value, segment_info); + std::unique_lock lock(mutex_); + segment_infos_[segment_info.segment_id()] = segment_info; + lock.unlock(); + } else { + // table scheme + Collection collection; + ParseCollectionSchema(event_value, collection); + std::unique_lock lock(mutex_); + schemas_[collection.name()] = collection; + lock.unlock(); + } + } + // TODO: Delete event type + } +} + +uint64_t MetaWrapper::AskSegmentId(const std::string &collection_name, uint64_t channel_id, uint64_t timestamp) { + // TODO: may using some multi index data structure to speed up search + // index timestamp: no-unique, seems close timestamp is enough + // index collection_name: no-unique + // index channel_id: must satisfy channel_start <= channel_id < channel_end + std::shared_lock lock(mutex_); + for (auto &item: segment_infos_) { + auto &segment_info = item.second; + uint64_t open_ts = segment_info.open_timestamp(); + uint64_t close_ts = segment_info.close_timestamp(); + if (channel_id >= segment_info.channel_start() && channel_id < segment_info.channel_end() + && timestamp >= open_ts << 18 && timestamp < close_ts << 18 + && segment_info.collection_name() == collection_name) { + return segment_info.segment_id(); + } + } + throw std::runtime_error("Can't find eligible segment"); +} + +const Schema &MetaWrapper::AskCollectionSchema(const std::string &collection_name) { + std::shared_lock lock(mutex_); + if (schemas_.find(collection_name) != schemas_.end()) { + return schemas_[collection_name].schema(); + } + throw std::runtime_error("Collection " + collection_name + " not existed"); +} + +Status MetaWrapper::SyncMeta() { + ::etcdserverpb::RangeRequest request; + request.set_key(etcd_root_path_); + std::string range_end(etcd_root_path_); + int ascii = (int) range_end[range_end.length() - 1]; + range_end.back() = ascii + 1; + request.set_range_end(range_end); + + ::etcdserverpb::RangeResponse response; + auto status = etcd_client_->Range(request, response); + if (status.ok()) { + for (auto &kv : response.kvs()) { + if (IsCollectionMetaKey(kv.key())) { + Collection collection; + ParseCollectionSchema(kv.value(), collection); + std::unique_lock lock(mutex_); + schemas_[collection.name()] = collection; + lock.unlock(); + } else { + assert(IsSegmentMetaKey(kv.key())); + SegmentInfo segment_info; + ParseSegmentInfo(kv.value(), segment_info); + std::unique_lock lock(mutex_); + segment_infos_[segment_info.segment_id()] = segment_info; + lock.unlock(); + } + } + } + return status; } } diff --git a/proxy/src/server/MetaWrapper.h b/proxy/src/server/MetaWrapper.h index bf5c264b08..ecd9667b1e 100644 --- a/proxy/src/server/MetaWrapper.h +++ b/proxy/src/server/MetaWrapper.h @@ -1,12 +1,19 @@ #include "utils/Status.h" #include "meta/master/GrpcClient.h" +#include "grpc/message.pb.h" +#include "grpc/master.pb.h" +#include "meta/etcd_watcher/Watcher.h" +#include "meta/etcd_client/Etcd_client.h" +#include "config/ServerConfig.h" -namespace milvus{ -namespace server{ +#include + +namespace milvus { +namespace server { class MetaWrapper { public: - static MetaWrapper& + static MetaWrapper & GetInstance(); Status @@ -15,10 +22,34 @@ class MetaWrapper { std::shared_ptr MetaClient(); + uint64_t + AskSegmentId(const std::string &collection_name, uint64_t channel_id, uint64_t timestamp); + + const milvus::grpc::Schema & + AskCollectionSchema(const std::string &collection_name); + + Status + SyncMeta(); + private: - std::shared_ptr client_; + bool IsCollectionMetaKey(const std::string &key); + + bool IsSegmentMetaKey(const std::string &key); + + void UpdateMeta(const etcdserverpb::WatchResponse &res); + + private: + std::shared_ptr master_client_; + std::shared_ptr etcd_client_; + std::unordered_map schemas_; + std::unordered_map segment_infos_; + std::shared_ptr watcher_; + std::shared_mutex mutex_; + + std::string etcd_root_path_; + std::string segment_path_; + std::string collection_path_; }; - } } diff --git a/proxy/src/server/delivery/ReqHandler.cpp b/proxy/src/server/delivery/ReqHandler.cpp index 4df402c5da..17b504709f 100644 --- a/proxy/src/server/delivery/ReqHandler.cpp +++ b/proxy/src/server/delivery/ReqHandler.cpp @@ -43,9 +43,8 @@ namespace milvus { namespace server { Status -ReqHandler::CreateCollection(const ContextPtr& context, const std::string& collection_name, FieldsType& fields, - milvus::json& json_param) { - BaseReqPtr req_ptr = CreateCollectionReq::Create(context, collection_name, fields, json_param); +ReqHandler::CreateCollection(const ContextPtr& context, const ::milvus::grpc::Mapping *request) { + BaseReqPtr req_ptr = CreateCollectionReq::Create(context, request); ReqScheduler::ExecReq(req_ptr); return req_ptr->status(); } @@ -72,9 +71,8 @@ ReqHandler::ListCollections(const ContextPtr& context, std::vector& } Status -ReqHandler::GetCollectionInfo(const ContextPtr& context, const std::string& collection_name, - CollectionSchema& collection_schema) { - BaseReqPtr req_ptr = GetCollectionInfoReq::Create(context, collection_name, collection_schema); +ReqHandler::GetCollectionInfo(const ContextPtr& context, const ::milvus::grpc::CollectionName *request, ::milvus::grpc::Mapping& response) { + BaseReqPtr req_ptr = GetCollectionInfoReq::Create(context, request, response); ReqScheduler::ExecReq(req_ptr); return req_ptr->status(); } diff --git a/proxy/src/server/delivery/ReqHandler.h b/proxy/src/server/delivery/ReqHandler.h index f21273f608..df97bcaf4e 100644 --- a/proxy/src/server/delivery/ReqHandler.h +++ b/proxy/src/server/delivery/ReqHandler.h @@ -31,8 +31,7 @@ class ReqHandler { ReqHandler() = default; Status - CreateCollection(const ContextPtr& context, const std::string& collection_name, FieldsType& fields, - milvus::json& json_params); + CreateCollection(const ContextPtr& context, const ::milvus::grpc::Mapping *request); Status DropCollection(const ContextPtr& context, const std::string& collection_name); @@ -44,8 +43,7 @@ class ReqHandler { ListCollections(const ContextPtr& context, std::vector& collections); Status - GetCollectionInfo(const ContextPtr& context, const std::string& collection_name, - CollectionSchema& collection_schema); + GetCollectionInfo(const ContextPtr& context, const ::milvus::grpc::CollectionName *request, ::milvus::grpc::Mapping& respons); Status GetCollectionStats(const ContextPtr& context, const std::string& collection_name, std::string& collection_stats); diff --git a/proxy/src/server/delivery/ReqScheduler.cpp b/proxy/src/server/delivery/ReqScheduler.cpp index e65279cecb..ddeaea006a 100644 --- a/proxy/src/server/delivery/ReqScheduler.cpp +++ b/proxy/src/server/delivery/ReqScheduler.cpp @@ -160,13 +160,10 @@ ReqScheduler::PutToQueue(const BaseReqPtr& req_ptr) { int64_t ReqScheduler::GetLatestDeliveredReqTime() { std::lock_guard lock(time_syc_mtx_); - if (sending_){ - return latest_req_time_; + if (!sending_){ + latest_req_time_ = TSOracle::GetInstance().GetTimeStamp(); } - auto ts = TSOracle::GetInstance().GetTimeStamp(); - latest_req_time_ = ts; - assert(ts != 0); - return ts; + return latest_req_time_; } void ReqScheduler::UpdateLatestDeliveredReqTime(int64_t time) { diff --git a/proxy/src/server/delivery/request/CreateCollectionReq.cpp b/proxy/src/server/delivery/request/CreateCollectionReq.cpp index 8a3b45729b..5b704e02d4 100644 --- a/proxy/src/server/delivery/request/CreateCollectionReq.cpp +++ b/proxy/src/server/delivery/request/CreateCollectionReq.cpp @@ -13,32 +13,30 @@ // #include "db/Utils.h" #include "server/ValidationUtil.h" #include "utils/Log.h" -#include "utils/TimeRecorder.h" +#include "server/MetaWrapper.h" #include namespace milvus { namespace server { -CreateCollectionReq::CreateCollectionReq(const ContextPtr& context, const std::string& collection_name, - FieldsType& fields, milvus::json& extra_params) +CreateCollectionReq::CreateCollectionReq(const ContextPtr &context, const ::milvus::grpc::Mapping *request) : BaseReq(context, ReqType::kCreateCollection), - collection_name_(collection_name), - fields_(fields), - extra_params_(extra_params) { + request_(request) { } BaseReqPtr -CreateCollectionReq::Create(const ContextPtr& context, const std::string& collection_name, FieldsType& fields, - milvus::json& extra_params) { - return std::shared_ptr(new CreateCollectionReq(context, collection_name, fields, extra_params)); +CreateCollectionReq::Create(const ContextPtr &context, const ::milvus::grpc::Mapping *request) { + return std::shared_ptr(new CreateCollectionReq(context, request)); } Status CreateCollectionReq::OnExecute() { - - - return Status::OK(); + auto status = MetaWrapper::GetInstance().MetaClient()->CreateCollection(*request_); + if (status.ok()){ + status = MetaWrapper::GetInstance().SyncMeta(); + } + return status; } } // namespace server diff --git a/proxy/src/server/delivery/request/CreateCollectionReq.h b/proxy/src/server/delivery/request/CreateCollectionReq.h index 368bba3634..31366b37a5 100644 --- a/proxy/src/server/delivery/request/CreateCollectionReq.h +++ b/proxy/src/server/delivery/request/CreateCollectionReq.h @@ -22,21 +22,18 @@ namespace server { class CreateCollectionReq : public BaseReq { public: - static BaseReqPtr - Create(const ContextPtr& context, const std::string& collection_name, FieldsType& fields, - milvus::json& extra_params); + static BaseReqPtr + Create(const ContextPtr &context, const ::milvus::grpc::Mapping *request); protected: - CreateCollectionReq(const ContextPtr& context, const std::string& collection_name, FieldsType& fields, - milvus::json& extra_params); + CreateCollectionReq(const ContextPtr &context, const ::milvus::grpc::Mapping *request); - Status - OnExecute() override; + Status + OnExecute() override; private: - const std::string collection_name_; - std::unordered_map fields_; - milvus::json extra_params_; + const std::string collection_name_; + const ::milvus::grpc::Mapping *request_; }; } // namespace server diff --git a/proxy/src/server/delivery/request/DeleteEntityByIDReq.cpp b/proxy/src/server/delivery/request/DeleteEntityByIDReq.cpp index fd36d5b14d..5e7be296d4 100644 --- a/proxy/src/server/delivery/request/DeleteEntityByIDReq.cpp +++ b/proxy/src/server/delivery/request/DeleteEntityByIDReq.cpp @@ -18,6 +18,7 @@ #include "server/delivery/request/DeleteEntityByIDReq.h" #include "src/server/delivery/ReqScheduler.h" #include "server/MessageWrapper.h" +#include "server/MetaWrapper.h" #include #include @@ -43,7 +44,12 @@ DeleteEntityByIDReq::Create(const ContextPtr& context, const ::milvus::grpc::Del Status DeleteEntityByIDReq::OnExecute() { auto &msg_client = MessageWrapper::GetInstance().MessageClient(); - Status status = msg_client->SendMutMessage(*request_, timestamp_); + auto segment_id = [](const std::string &collection_name, + uint64_t channel_id, + uint64_t timestamp) { + return MetaWrapper::GetInstance().AskSegmentId(collection_name, channel_id, timestamp); + }; + Status status = msg_client->SendMutMessage(*request_, timestamp_, segment_id); return status; } diff --git a/proxy/src/server/delivery/request/GetCollectionInfoReq.cpp b/proxy/src/server/delivery/request/GetCollectionInfoReq.cpp index e2d2fd7155..5ba1a7304b 100644 --- a/proxy/src/server/delivery/request/GetCollectionInfoReq.cpp +++ b/proxy/src/server/delivery/request/GetCollectionInfoReq.cpp @@ -16,30 +16,36 @@ // #include "server/web_impl/Constants.h" #include "utils/Log.h" #include "utils/TimeRecorder.h" +#include "server/MetaWrapper.h" #include namespace milvus { namespace server { -GetCollectionInfoReq::GetCollectionInfoReq(const ContextPtr& context, const std::string& collection_name, - CollectionSchema& collection_schema) +GetCollectionInfoReq::GetCollectionInfoReq(const ContextPtr& context, const ::milvus::grpc::CollectionName *request, ::milvus::grpc::Mapping& response) : BaseReq(context, ReqType::kGetCollectionInfo), - collection_name_(collection_name), - collection_schema_(collection_schema) { + collection_name_(request->collection_name()), + collection_schema_(response) { } BaseReqPtr -GetCollectionInfoReq::Create(const ContextPtr& context, const std::string& collection_name, - CollectionSchema& collection_schema) { - return std::shared_ptr(new GetCollectionInfoReq(context, collection_name, collection_schema)); +GetCollectionInfoReq::Create(const ContextPtr& context, const ::milvus::grpc::CollectionName *request, ::milvus::grpc::Mapping& response) { + return std::shared_ptr(new GetCollectionInfoReq(context, request, response)); } Status GetCollectionInfoReq::OnExecute() { - - + try { + auto schema = MetaWrapper::GetInstance().AskCollectionSchema(collection_name_); + collection_schema_.mutable_schema()->CopyFrom(schema); + collection_schema_.set_collection_name(collection_schema_.collection_name()); return Status::OK(); + } + catch (const std::exception& e){ + return Status{DB_ERROR, e.what()}; + } + } } // namespace server diff --git a/proxy/src/server/delivery/request/GetCollectionInfoReq.h b/proxy/src/server/delivery/request/GetCollectionInfoReq.h index ab3103780e..78b99bc56b 100644 --- a/proxy/src/server/delivery/request/GetCollectionInfoReq.h +++ b/proxy/src/server/delivery/request/GetCollectionInfoReq.h @@ -21,19 +21,18 @@ namespace server { class GetCollectionInfoReq : public BaseReq { public: - static BaseReqPtr - Create(const ContextPtr& context, const std::string& collection_name, CollectionSchema& collection_schema); + static BaseReqPtr + Create(const ContextPtr& context, const ::milvus::grpc::CollectionName *request, ::milvus::grpc::Mapping& response); protected: - GetCollectionInfoReq(const ContextPtr& context, const std::string& collection_name, - CollectionSchema& collection_schema); + GetCollectionInfoReq(const ContextPtr& context, const ::milvus::grpc::CollectionName *request, ::milvus::grpc::Mapping& response); - Status - OnExecute() override; + Status + OnExecute() override; private: - const std::string collection_name_; - CollectionSchema& collection_schema_; + const std::string collection_name_; + ::milvus::grpc::Mapping &collection_schema_; }; } // namespace server diff --git a/proxy/src/server/delivery/request/InsertReq.cpp b/proxy/src/server/delivery/request/InsertReq.cpp index 3b7ce7fe97..3aaebb86d2 100644 --- a/proxy/src/server/delivery/request/InsertReq.cpp +++ b/proxy/src/server/delivery/request/InsertReq.cpp @@ -16,6 +16,7 @@ #include "utils/TimeRecorder.h" #include "server/delivery/ReqScheduler.h" #include "server/MessageWrapper.h" +#include "server/MetaWrapper.h" #include #include @@ -44,7 +45,13 @@ Status InsertReq::OnExecute() { LOG_SERVER_INFO_ << LogOut("[%s][%ld] ", "insert", 0) << "Execute InsertReq."; auto &msg_client = MessageWrapper::GetInstance().MessageClient(); - Status status = msg_client->SendMutMessage(*insert_param_, timestamp_); + auto segment_id = [](const std::string &collection_name, + uint64_t channel_id, + uint64_t timestamp) { + return MetaWrapper::GetInstance().AskSegmentId(collection_name, channel_id, timestamp); + }; + Status status; + status = msg_client->SendMutMessage(*insert_param_, timestamp_, segment_id); return status; } diff --git a/proxy/src/server/delivery/request/InsertReq.h b/proxy/src/server/delivery/request/InsertReq.h index 1cc8103c26..1481a37bb9 100644 --- a/proxy/src/server/delivery/request/InsertReq.h +++ b/proxy/src/server/delivery/request/InsertReq.h @@ -36,7 +36,7 @@ class InsertReq : public BaseReq { OnPostExecute() override ; private: - const ::milvus::grpc::InsertParam *insert_param_; + const grpc::InsertParam *insert_param_; }; } // namespace server diff --git a/proxy/src/server/grpc_impl/GrpcRequestHandler.cpp b/proxy/src/server/grpc_impl/GrpcRequestHandler.cpp index 2b5a91f8a7..2fb869a052 100644 --- a/proxy/src/server/grpc_impl/GrpcRequestHandler.cpp +++ b/proxy/src/server/grpc_impl/GrpcRequestHandler.cpp @@ -341,7 +341,7 @@ GrpcRequestHandler::CreateCollection(::grpc::ServerContext *context, const ::mil CHECK_NULLPTR_RETURN(request); LOG_SERVER_INFO_ << LogOut("Request [%s] %s begin.", GetContext(context)->ReqID().c_str(), __func__); - Status status = MetaWrapper::GetInstance().MetaClient()->CreateCollection(*request); + Status status = req_handler_.CreateCollection(GetContext(context), request); LOG_SERVER_INFO_ << LogOut("Request [%s] %s end.", GetContext(context)->ReqID().c_str(), __func__); SET_RESPONSE(response, status, context) @@ -468,6 +468,9 @@ GrpcRequestHandler::DescribeCollection(::grpc::ServerContext *context, const ::m ::milvus::grpc::Mapping *response) { LOG_SERVER_INFO_ << LogOut("Request [%s] %s begin.", GetContext(context)->ReqID().c_str(), __func__); CHECK_NULLPTR_RETURN(request); + + Status status = req_handler_.GetCollectionInfo(GetContext(context), request, *response); + SET_RESPONSE(response->mutable_status(), status, context) return ::grpc::Status::OK; } @@ -697,6 +700,17 @@ GrpcRequestHandler::Insert(::grpc::ServerContext *context, const ::milvus::grpc: return ::grpc::Status::OK; } + // check if collection exist, using `HasCollection` after. + try { + MetaWrapper::GetInstance().AskCollectionSchema(request->collection_name()); + } + catch (const std::exception& e){ + // means collection not exit + SET_RESPONSE(response->mutable_status(), Status(SERVER_COLLECTION_NOT_EXIST, "Collection not exist " + request->collection_name()), context) + return ::grpc::Status::OK; + } + + // generate uid for entities //if (request->entity_id_array_size() == 0) { // auto ids = std::vector(request->rows_data_size()); @@ -858,8 +872,8 @@ GrpcRequestHandler::Search(::grpc::ServerContext *context, const ::milvus::grpc: //TODO: check if the request is legal - BaseReqPtr req_ptr = SearchReq::Create(GetContext(context), request, response); - ReqScheduler::ExecReq(req_ptr); + BaseReqPtr req_ptr = SearchReq::Create(GetContext(context), request, response); + ReqScheduler::ExecReq(req_ptr); return ::grpc::Status::OK; } diff --git a/proxy/src/server/grpc_impl/GrpcServer.cpp b/proxy/src/server/grpc_impl/GrpcServer.cpp index 1474e5432e..67cba3eb1a 100644 --- a/proxy/src/server/grpc_impl/GrpcServer.cpp +++ b/proxy/src/server/grpc_impl/GrpcServer.cpp @@ -105,7 +105,7 @@ GrpcServer::StartService() { int client_id = 0; std::string pulsar_server_addr (std::string{"pulsar://"} + config.pulsar.address() + ":" + std::to_string(config.pulsar.port())); - timesync::TimeSync syc(client_id,GetMessageTimeSyncTime, 400, pulsar_server_addr, "TimeSync"); + timesync::TimeSync syc(client_id,GetMessageTimeSyncTime, config.timesync.interval(), pulsar_server_addr, "TimeSync"); // Add gRPC interceptor diff --git a/proxy/thirdparty/grpc/CMakeLists.txt b/proxy/thirdparty/grpc/CMakeLists.txt index b39512ff57..9bb76a43de 100644 --- a/proxy/thirdparty/grpc/CMakeLists.txt +++ b/proxy/thirdparty/grpc/CMakeLists.txt @@ -64,7 +64,7 @@ add_custom_target(generate_suvlim_pb_grpc ALL DEPENDS protoc grpc_cpp_plugin) add_custom_command(TARGET generate_suvlim_pb_grpc POST_BUILD COMMAND echo "${PROTOC_EXCUTABLE}" - COMMAND bash "${PROTO_GEN_SCRIPTS_DIR}/generate_go.sh" -p "${PROTOC_EXCUTABLE}" +# COMMAND bash "${PROTO_GEN_SCRIPTS_DIR}/generate_go.sh" -p "${PROTOC_EXCUTABLE}" COMMAND bash "${PROTO_GEN_SCRIPTS_DIR}/generate_cpp.sh" -p "${PROTOC_EXCUTABLE}" -g "${GRPC_CPP_PLUGIN_EXCUTABLE}" COMMAND ${PROTOC_EXCUTABLE} -I "${PROTO_PATH}/proto" --grpc_out "${PROTO_PATH}" --cpp_out "${PROTO_PATH}" --plugin=protoc-gen-grpc="${GRPC_CPP_PLUGIN_EXCUTABLE}" diff --git a/proxy/thirdparty/pulsar/CMakeLists.txt b/proxy/thirdparty/pulsar/CMakeLists.txt index 9904cc1e9f..aa92a4b2d0 100644 --- a/proxy/thirdparty/pulsar/CMakeLists.txt +++ b/proxy/thirdparty/pulsar/CMakeLists.txt @@ -20,20 +20,6 @@ endif () message(STATUS "Building pulsar-client-cpp-${PULSAR_CLIENT_CPP_VERSION} from source") - -#include(ExternalProject) -#ExternalProject_Add( -# pulsar -# URL ${PULSAR_URL} -# PREFIX ${pulsar_ROOT} -# CONFIGURE_COMMAND cd ${pulsar_ROOT}/src/pulsar/pulsar-client-cpp && cmake -DBUILD_TESTS=OFF -DCMAKE_INSTALL_PREFIX=${pulsar_ROOT}/build . -# BUILD_COMMAND cd ${pulsar_ROOT}/src/pulsar/pulsar-client-cpp && cmake . -# BUILD_IN_SOURCE true -# INSTALL_COMMAND cd ${pulsar_ROOT}/src/pulsar/pulsar-client-cpp && make install -#) - - - FetchContent_Declare( pulsar URL ${PULSAR_URL} diff --git a/reader/main.go b/reader/main.go index 14dabbe2a2..9f1ae8c535 100644 --- a/reader/main.go +++ b/reader/main.go @@ -23,4 +23,4 @@ func main2() { wg.Add(1) reader.StartQueryNode2() wg.Wait() -} \ No newline at end of file +} diff --git a/reader/read_node/collection.go b/reader/read_node/collection.go index 2d74a6cde0..cb1d59922d 100644 --- a/reader/read_node/collection.go +++ b/reader/read_node/collection.go @@ -14,10 +14,10 @@ package reader import "C" type Collection struct { - CollectionPtr C.CCollection + CollectionPtr C.CCollection CollectionName string - CollectionID uint64 - Partitions []*Partition + CollectionID uint64 + Partitions []*Partition } func (c *Collection) NewPartition(partitionName string) *Partition { diff --git a/reader/read_node/index_test.go b/reader/read_node/index_test.go index cd7f25e559..d90d6c477c 100644 --- a/reader/read_node/index_test.go +++ b/reader/read_node/index_test.go @@ -3,16 +3,17 @@ package reader import ( "encoding/binary" "fmt" - msgPb "github.com/czs007/suvlim/pkg/master/grpc/message" - "github.com/stretchr/testify/assert" "math" "testing" + + msgPb "github.com/czs007/suvlim/pkg/master/grpc/message" + "github.com/stretchr/testify/assert" ) func TestIndex_BuildIndex(t *testing.T) { // 1. Construct node, collection, partition and segment node := NewQueryNode(0, 0) - var collection = node.NewCollection("collection0", "fake schema") + var collection = node.NewCollection(0, "collection0", "fake schema") var partition = collection.NewPartition("partition0") var segment = partition.NewSegment(0) diff --git a/reader/read_node/meta.go b/reader/read_node/meta.go index ace763020a..8fc1b6519e 100644 --- a/reader/read_node/meta.go +++ b/reader/read_node/meta.go @@ -3,36 +3,36 @@ package reader import ( "context" "fmt" - "github.com/czs007/suvlim/pkg/master/mock" "reflect" "strconv" "strings" "sync" "time" + "github.com/czs007/suvlim/conf" "github.com/czs007/suvlim/pkg/master/kv" + "github.com/czs007/suvlim/pkg/master/mock" "go.etcd.io/etcd/clientv3" "go.etcd.io/etcd/mvcc/mvccpb" ) const ( CollectonPrefix = "/collection/" - SegmentPrefix = "/segment/" + SegmentPrefix = "/segment/" ) - func GetCollectionObjId(key string) string { - prefix := conf.Config.Etcd.Rootpath + CollectonPrefix + prefix := conf.Config.Etcd.Rootpath + CollectonPrefix return strings.TrimPrefix(key, prefix) } func GetSegmentObjId(key string) string { - prefix := conf.Config.Etcd.Rootpath + SegmentPrefix + prefix := conf.Config.Etcd.Rootpath + SegmentPrefix return strings.TrimPrefix(key, prefix) } func isCollectionObj(key string) bool { - prefix := conf.Config.Etcd.Rootpath + CollectonPrefix + prefix := conf.Config.Etcd.Rootpath + CollectonPrefix prefix = strings.TrimSpace(prefix) println("prefix is :$", prefix) index := strings.Index(key, prefix) @@ -41,31 +41,31 @@ func isCollectionObj(key string) bool { } func isSegmentObj(key string) bool { - prefix := conf.Config.Etcd.Rootpath + SegmentPrefix + prefix := conf.Config.Etcd.Rootpath + SegmentPrefix prefix = strings.TrimSpace(prefix) index := strings.Index(key, prefix) return index == 0 } -func printCollectionStruct(obj *mock.Collection){ +func printCollectionStruct(obj *mock.Collection) { v := reflect.ValueOf(obj) v = reflect.Indirect(v) typeOfS := v.Type() - for i := 0; i< v.NumField(); i++ { - if typeOfS.Field(i).Name == "GrpcMarshalString"{ + for i := 0; i < v.NumField(); i++ { + if typeOfS.Field(i).Name == "GrpcMarshalString" { continue } fmt.Printf("Field: %s\tValue: %v\n", typeOfS.Field(i).Name, v.Field(i).Interface()) } } -func printSegmentStruct(obj *mock.Segment){ +func printSegmentStruct(obj *mock.Segment) { v := reflect.ValueOf(obj) v = reflect.Indirect(v) typeOfS := v.Type() - for i := 0; i< v.NumField(); i++ { + for i := 0; i < v.NumField(); i++ { fmt.Printf("Field: %s\tValue: %v\n", typeOfS.Field(i).Name, v.Field(i).Interface()) } } @@ -78,6 +78,10 @@ func (node *QueryNode) processCollectionCreate(id string, value string) { println(err.Error()) } printCollectionStruct(collection) + newCollection := node.NewCollection(collection.ID, collection.Name, collection.GrpcMarshalString) + for _, partitionTag := range collection.PartitionTags { + newCollection.NewPartition(partitionTag) + } } func (node *QueryNode) processSegmentCreate(id string, value string) { @@ -88,17 +92,25 @@ func (node *QueryNode) processSegmentCreate(id string, value string) { println(err.Error()) } printSegmentStruct(segment) + collection := node.GetCollectionByID(segment.CollectionID) + if collection != nil { + partition := collection.GetPartitionByName(segment.PartitionTag) + if partition != nil { + partition.NewSegment(int64(segment.SegmentID)) // todo change all to uint64 + } + } + // segment.CollectionName } func (node *QueryNode) processCreate(key string, msg string) { println("process create", key, ":", msg) - if isCollectionObj(key){ + if isCollectionObj(key) { objID := GetCollectionObjId(key) node.processCollectionCreate(objID, msg) - }else if isSegmentObj(key){ + } else if isSegmentObj(key) { objID := GetSegmentObjId(key) node.processSegmentCreate(objID, msg) - }else { + } else { println("can not process create msg:", key) } } @@ -112,6 +124,10 @@ func (node *QueryNode) processSegmentModify(id string, value string) { println(err.Error()) } printSegmentStruct(segment) + seg, err := node.GetSegmentBySegmentID(int64(segment.SegmentID)) // todo change to uint64 + if seg != nil { + seg.SegmentCloseTime = segment.CloseTimeStamp + } } func (node *QueryNode) processCollectionModify(id string, value string) { @@ -124,37 +140,37 @@ func (node *QueryNode) processCollectionModify(id string, value string) { printCollectionStruct(collection) } -func (node *QueryNode) processModify(key string, msg string){ +func (node *QueryNode) processModify(key string, msg string) { println("process modify") - if isCollectionObj(key){ + if isCollectionObj(key) { objID := GetCollectionObjId(key) node.processCollectionModify(objID, msg) - }else if isSegmentObj(key){ + } else if isSegmentObj(key) { objID := GetSegmentObjId(key) node.processSegmentModify(objID, msg) - }else { + } else { println("can not process modify msg:", key) } } - -func (node *QueryNode) processSegmentDelete(id string){ +func (node *QueryNode) processSegmentDelete(id string) { println("Delete segment: ", id) } -func (node *QueryNode) processCollectionDelete(id string){ + +func (node *QueryNode) processCollectionDelete(id string) { println("Delete collection: ", id) } -func (node *QueryNode) processDelete(key string){ +func (node *QueryNode) processDelete(key string) { println("process delete") - if isCollectionObj(key){ + if isCollectionObj(key) { objID := GetCollectionObjId(key) node.processCollectionDelete(objID) - }else if isSegmentObj(key){ + } else if isSegmentObj(key) { objID := GetSegmentObjId(key) node.processSegmentDelete(objID) - }else { + } else { println("can not process delete msg:", key) } } @@ -164,6 +180,8 @@ func (node *QueryNode) processResp(resp clientv3.WatchResponse) error { if err != nil { return err } + println("processResp!!!!!\n") + for _, ev := range resp.Events { if ev.IsCreate() { key := string(ev.Kv.Key) @@ -185,7 +203,7 @@ func (node *QueryNode) processResp(resp clientv3.WatchResponse) error { func (node *QueryNode) loadCollections() error { keys, values := node.kvBase.LoadWithPrefix(CollectonPrefix) - for i:= range keys{ + for i := range keys { objID := GetCollectionObjId(keys[i]) node.processCollectionCreate(objID, values[i]) } @@ -193,7 +211,7 @@ func (node *QueryNode) loadCollections() error { } func (node *QueryNode) loadSegments() error { keys, values := node.kvBase.LoadWithPrefix(SegmentPrefix) - for i:= range keys{ + for i := range keys { objID := GetSegmentObjId(keys[i]) node.processSegmentCreate(objID, values[i]) } @@ -210,7 +228,7 @@ func (node *QueryNode) InitFromMeta() error { Endpoints: []string{etcdAddr}, DialTimeout: 5 * time.Second, }) - defer cli.Close() + //defer cli.Close() node.kvBase = kv.NewEtcdKVBase(cli, conf.Config.Etcd.Rootpath) node.loadCollections() node.loadSegments() @@ -230,4 +248,4 @@ func (node *QueryNode) RunMetaService(ctx context.Context, wg *sync.WaitGroup) { node.processResp(resp) } } -} \ No newline at end of file +} diff --git a/reader/read_node/partition.go b/reader/read_node/partition.go index b887c1b5f1..b250375e2d 100644 --- a/reader/read_node/partition.go +++ b/reader/read_node/partition.go @@ -14,8 +14,8 @@ package reader import "C" type Partition struct { - PartitionPtr C.CPartition - PartitionName string + PartitionPtr C.CPartition + PartitionName string OpenedSegments []*Segment ClosedSegments []*Segment } diff --git a/reader/read_node/query_node.go b/reader/read_node/query_node.go index 7c09f641cd..ee5c9d7327 100644 --- a/reader/read_node/query_node.go +++ b/reader/read_node/query_node.go @@ -102,6 +102,7 @@ func NewQueryNode(queryNodeId uint64, timeSync uint64) *QueryNode { func (node *QueryNode) Close() { node.messageClient.Close() + node.kvBase.Close() } func CreateQueryNode(queryNodeId uint64, timeSync uint64, mc *message_client.MessageClient) *QueryNode { @@ -156,12 +157,12 @@ func (node *QueryNode) QueryNodeDataInit() { node.insertData = insertData } -func (node *QueryNode) NewCollection(collectionName string, schemaConfig string) *Collection { +func (node *QueryNode) NewCollection(collectionID uint64, collectionName string, schemaConfig string) *Collection { cName := C.CString(collectionName) cSchema := C.CString(schemaConfig) collection := C.NewCollection(cName, cSchema) - var newCollection = &Collection{CollectionPtr: collection, CollectionName: collectionName} + var newCollection = &Collection{CollectionPtr: collection, CollectionName: collectionName, CollectionID: collectionID} node.Collections = append(node.Collections, newCollection) return newCollection @@ -184,7 +185,7 @@ func (node *QueryNode) PrepareBatchMsg() []int { func (node *QueryNode) InitQueryNodeCollection() { // TODO: remove hard code, add collection creation request // TODO: error handle - var newCollection = node.NewCollection("collection1", "fakeSchema") + var newCollection = node.NewCollection(0, "collection1", "fakeSchema") var newPartition = newCollection.NewPartition("partition1") // TODO: add segment id var segment = newPartition.NewSegment(0) diff --git a/reader/read_node/result_test.go b/reader/read_node/result_test.go index 700e7497b1..e93676df9f 100644 --- a/reader/read_node/result_test.go +++ b/reader/read_node/result_test.go @@ -1,26 +1,27 @@ package reader import ( + "testing" + masterPb "github.com/czs007/suvlim/pkg/master/grpc/master" msgPb "github.com/czs007/suvlim/pkg/master/grpc/message" - "testing" ) func TestResult_PublishSearchResult(t *testing.T) { // Construct node, collection, partition and segment node := NewQueryNode(0, 0) - var collection = node.NewCollection("collection0", "fake schema") + var collection = node.NewCollection(0, "collection0", "fake schema") var partition = collection.NewPartition("partition0") var segment = partition.NewSegment(0) node.SegmentsMap[0] = segment // TODO: start pulsar server const N = 10 - var entityIDs = msgPb.Entities { + var entityIDs = msgPb.Entities{ Ids: make([]int64, N), } - var result = msgPb.QueryResult { - Entities: &entityIDs, + var result = msgPb.QueryResult{ + Entities: &entityIDs, Distances: make([]float32, N), } for i := 0; i < N; i++ { @@ -33,7 +34,7 @@ func TestResult_PublishSearchResult(t *testing.T) { func TestResult_PublishFailedSearchResult(t *testing.T) { // Construct node, collection, partition and segment node := NewQueryNode(0, 0) - var collection = node.NewCollection("collection0", "fake schema") + var collection = node.NewCollection(0, "collection0", "fake schema") var partition = collection.NewPartition("partition0") var segment = partition.NewSegment(0) node.SegmentsMap[0] = segment @@ -45,7 +46,7 @@ func TestResult_PublishFailedSearchResult(t *testing.T) { func TestResult_PublicStatistic(t *testing.T) { // Construct node, collection, partition and segment node := NewQueryNode(0, 0) - var collection = node.NewCollection("collection0", "fake schema") + var collection = node.NewCollection(0, "collection0", "fake schema") var partition = collection.NewPartition("partition0") var segment = partition.NewSegment(0) node.SegmentsMap[0] = segment diff --git a/reader/read_node/segment.go b/reader/read_node/segment.go index cfbbd2f4da..9bd85bd942 100644 --- a/reader/read_node/segment.go +++ b/reader/read_node/segment.go @@ -77,12 +77,18 @@ func (s *Segment) Close() error { } // Build index after closing segment - s.buildIndex() + go s.buildIndex() return nil } func (s *Segment) GetMemSize() uint64 { - return 100000 + /*C.GetMemoryUsageInBytes + long int + GetMemoryUsageInBytes(CSegmentBase c_segment); + */ + var memoryUsageInBytes = C.GetMemoryUsageInBytes(s.SegmentPtr) + + return uint64(memoryUsageInBytes) } //////////////////////////////////////////////////////////////////////////// diff --git a/reader/read_node/segment_service_test.go b/reader/read_node/segment_service_test.go index a16e34497f..6acfed663d 100644 --- a/reader/read_node/segment_service_test.go +++ b/reader/read_node/segment_service_test.go @@ -7,7 +7,7 @@ import ( func TestSegmentManagement_SegmentsManagement(t *testing.T) { // Construct node, collection, partition and segment node := NewQueryNode(0, 0) - var collection = node.NewCollection("collection0", "fake schema") + var collection = node.NewCollection(0, "collection0", "fake schema") var partition = collection.NewPartition("partition0") var segment = partition.NewSegment(0) node.SegmentsMap[0] = segment @@ -19,7 +19,7 @@ func TestSegmentManagement_SegmentsManagement(t *testing.T) { func TestSegmentManagement_SegmentService(t *testing.T) { // Construct node, collection, partition and segment node := NewQueryNode(0, 0) - var collection = node.NewCollection("collection0", "fake schema") + var collection = node.NewCollection(0, "collection0", "fake schema") var partition = collection.NewPartition("partition0") var segment = partition.NewSegment(0) node.SegmentsMap[0] = segment @@ -31,7 +31,7 @@ func TestSegmentManagement_SegmentService(t *testing.T) { func TestSegmentManagement_SegmentStatistic(t *testing.T) { // Construct node, collection, partition and segment node := NewQueryNode(0, 0) - var collection = node.NewCollection("collection0", "fake schema") + var collection = node.NewCollection(0, "collection0", "fake schema") var partition = collection.NewPartition("partition0") var segment = partition.NewSegment(0) node.SegmentsMap[0] = segment @@ -43,7 +43,7 @@ func TestSegmentManagement_SegmentStatistic(t *testing.T) { func TestSegmentManagement_SegmentStatisticService(t *testing.T) { // Construct node, collection, partition and segment node := NewQueryNode(0, 0) - var collection = node.NewCollection("collection0", "fake schema") + var collection = node.NewCollection(0, "collection0", "fake schema") var partition = collection.NewPartition("partition0") var segment = partition.NewSegment(0) node.SegmentsMap[0] = segment diff --git a/reader/read_node/segment_test.go b/reader/read_node/segment_test.go index 7b312a1aa3..e06d3a85c5 100644 --- a/reader/read_node/segment_test.go +++ b/reader/read_node/segment_test.go @@ -3,16 +3,17 @@ package reader import ( "encoding/binary" "fmt" - msgPb "github.com/czs007/suvlim/pkg/master/grpc/message" - "github.com/stretchr/testify/assert" "math" "testing" + + msgPb "github.com/czs007/suvlim/pkg/master/grpc/message" + "github.com/stretchr/testify/assert" ) func TestSegment_ConstructorAndDestructor(t *testing.T) { // 1. Construct node, collection, partition and segment node := NewQueryNode(0, 0) - var collection = node.NewCollection("collection0", "fake schema") + var collection = node.NewCollection(0, "collection0", "fake schema") var partition = collection.NewPartition("partition0") var segment = partition.NewSegment(0) @@ -25,7 +26,7 @@ func TestSegment_ConstructorAndDestructor(t *testing.T) { func TestSegment_SegmentInsert(t *testing.T) { // 1. Construct node, collection, partition and segment node := NewQueryNode(0, 0) - var collection = node.NewCollection("collection0", "fake schema") + var collection = node.NewCollection(0, "collection0", "fake schema") var partition = collection.NewPartition("partition0") var segment = partition.NewSegment(0) @@ -70,7 +71,7 @@ func TestSegment_SegmentInsert(t *testing.T) { func TestSegment_SegmentDelete(t *testing.T) { // 1. Construct node, collection, partition and segment node := NewQueryNode(0, 0) - var collection = node.NewCollection("collection0", "fake schema") + var collection = node.NewCollection(0, "collection0", "fake schema") var partition = collection.NewPartition("partition0") var segment = partition.NewSegment(0) @@ -95,7 +96,7 @@ func TestSegment_SegmentDelete(t *testing.T) { func TestSegment_SegmentSearch(t *testing.T) { // 1. Construct node, collection, partition and segment node := NewQueryNode(0, 0) - var collection = node.NewCollection("collection0", "fake schema") + var collection = node.NewCollection(0, "collection0", "fake schema") var partition = collection.NewPartition("partition0") var segment = partition.NewSegment(0) @@ -121,7 +122,7 @@ func TestSegment_SegmentSearch(t *testing.T) { var records [][]byte for i := 0; i < N; i++ { ids = append(ids, int64(i)) - timestamps = append(timestamps, uint64(i + 1)) + timestamps = append(timestamps, uint64(i+1)) records = append(records, rawData) } @@ -136,10 +137,10 @@ func TestSegment_SegmentSearch(t *testing.T) { // 6. Do search var queryJson = "{\"field_name\":\"fakevec\",\"num_queries\":1,\"topK\":10}" var queryRawData = make([]float32, 0) - for i := 0; i < 16; i ++ { + for i := 0; i < 16; i++ { queryRawData = append(queryRawData, float32(i)) } - var vectorRecord = msgPb.VectorRowRecord { + var vectorRecord = msgPb.VectorRowRecord{ FloatData: queryRawData, } var searchRes, searchErr = segment.SegmentSearch(queryJson, timestamps[N/2], &vectorRecord) @@ -155,7 +156,7 @@ func TestSegment_SegmentSearch(t *testing.T) { func TestSegment_SegmentPreInsert(t *testing.T) { // 1. Construct node, collection, partition and segment node := NewQueryNode(0, 0) - var collection = node.NewCollection("collection0", "fake schema") + var collection = node.NewCollection(0, "collection0", "fake schema") var partition = collection.NewPartition("partition0") var segment = partition.NewSegment(0) @@ -172,7 +173,7 @@ func TestSegment_SegmentPreInsert(t *testing.T) { func TestSegment_SegmentPreDelete(t *testing.T) { // 1. Construct node, collection, partition and segment node := NewQueryNode(0, 0) - var collection = node.NewCollection("collection0", "fake schema") + var collection = node.NewCollection(0, "collection0", "fake schema") var partition = collection.NewPartition("partition0") var segment = partition.NewSegment(0) @@ -191,7 +192,7 @@ func TestSegment_SegmentPreDelete(t *testing.T) { func TestSegment_GetStatus(t *testing.T) { // 1. Construct node, collection, partition and segment node := NewQueryNode(0, 0) - var collection = node.NewCollection("collection0", "fake schema") + var collection = node.NewCollection(0, "collection0", "fake schema") var partition = collection.NewPartition("partition0") var segment = partition.NewSegment(0) @@ -208,7 +209,7 @@ func TestSegment_GetStatus(t *testing.T) { func TestSegment_Close(t *testing.T) { // 1. Construct node, collection, partition and segment node := NewQueryNode(0, 0) - var collection = node.NewCollection("collection0", "fake schema") + var collection = node.NewCollection(0, "collection0", "fake schema") var partition = collection.NewPartition("partition0") var segment = partition.NewSegment(0) @@ -225,7 +226,7 @@ func TestSegment_Close(t *testing.T) { func TestSegment_GetRowCount(t *testing.T) { // 1. Construct node, collection, partition and segment node := NewQueryNode(0, 0) - var collection = node.NewCollection("collection0", "fake schema") + var collection = node.NewCollection(0, "collection0", "fake schema") var partition = collection.NewPartition("partition0") var segment = partition.NewSegment(0) @@ -274,7 +275,7 @@ func TestSegment_GetRowCount(t *testing.T) { func TestSegment_GetDeletedCount(t *testing.T) { // 1. Construct node, collection, partition and segment node := NewQueryNode(0, 0) - var collection = node.NewCollection("collection0", "fake schema") + var collection = node.NewCollection(0, "collection0", "fake schema") var partition = collection.NewPartition("partition0") var segment = partition.NewSegment(0) @@ -300,3 +301,52 @@ func TestSegment_GetDeletedCount(t *testing.T) { collection.DeletePartition(partition) node.DeleteCollection(collection) } + +func TestSegment_GetMemSize(t *testing.T) { + // 1. Construct node, collection, partition and segment + node := NewQueryNode(0, 0) + var collection = node.NewCollection(0, "collection0", "fake schema") + var partition = collection.NewPartition("partition0") + var segment = partition.NewSegment(0) + + // 2. Create ids and timestamps + ids := []int64{1, 2, 3} + timestamps := []uint64{0, 0, 0} + + // 3. Create records, use schema below: + // schema_tmp->AddField("fakeVec", DataType::VECTOR_FLOAT, 16); + // schema_tmp->AddField("age", DataType::INT32); + const DIM = 16 + const N = 3 + var vec = [DIM]float32{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16} + var rawData []byte + for _, ele := range vec { + buf := make([]byte, 4) + binary.LittleEndian.PutUint32(buf, math.Float32bits(ele)) + rawData = append(rawData, buf...) + } + bs := make([]byte, 4) + binary.LittleEndian.PutUint32(bs, 1) + rawData = append(rawData, bs...) + var records [][]byte + for i := 0; i < N; i++ { + records = append(records, rawData) + } + + // 4. Do PreInsert + var offset = segment.SegmentPreInsert(N) + assert.GreaterOrEqual(t, offset, int64(0)) + + // 5. Do Insert + var err = segment.SegmentInsert(offset, &ids, ×tamps, &records) + assert.NoError(t, err) + + // 6. Get memory usage in bytes + var memSize = segment.GetMemSize() + assert.Equal(t, memSize, uint64(1048714)) + + // 7. Destruct node, collection, and segment + partition.DeleteSegment(segment) + collection.DeletePartition(partition) + node.DeleteCollection(collection) +} diff --git a/reader/read_node/util_functions.go b/reader/read_node/util_functions.go index 5c32a178bb..c9071d4e04 100644 --- a/reader/read_node/util_functions.go +++ b/reader/read_node/util_functions.go @@ -29,6 +29,16 @@ func (node *QueryNode) GetKey2Segments() (*[]int64, *[]uint64, *[]int64) { return &entityIDs, ×tamps, &segmentIDs } +func (node *QueryNode) GetCollectionByID(collectionID uint64) *Collection { + for _, collection := range node.Collections { + if collection.CollectionID == collectionID { + return collection + } + } + + return nil +} + func (node *QueryNode) GetCollectionByCollectionName(collectionName string) (*Collection, error) { for _, collection := range node.Collections { if collection.CollectionName == collectionName { @@ -48,3 +58,13 @@ func (node *QueryNode) GetSegmentBySegmentID(segmentID int64) (*Segment, error) return targetSegment, nil } + +func (c *Collection) GetPartitionByName(partitionName string) (partition *Partition) { + for _, partition := range c.Partitions { + if partition.PartitionName == partitionName { + return partition + } + } + return nil + // TODO: remove from c.Partitions +} diff --git a/reader/read_node/util_functions_test.go b/reader/read_node/util_functions_test.go index b8ddefc6ed..cc98e0a1a3 100644 --- a/reader/read_node/util_functions_test.go +++ b/reader/read_node/util_functions_test.go @@ -1,8 +1,9 @@ package reader import ( - "github.com/stretchr/testify/assert" "testing" + + "github.com/stretchr/testify/assert" ) func TestUtilFunctions_GetKey2Segments(t *testing.T) { @@ -12,18 +13,21 @@ func TestUtilFunctions_GetKey2Segments(t *testing.T) { func TestUtilFunctions_GetCollectionByCollectionName(t *testing.T) { // 1. Construct node, and collections node := NewQueryNode(0, 0) - var _ = node.NewCollection("collection0", "fake schema") + var _ = node.NewCollection(0, "collection0", "fake schema") // 2. Get collection by collectionName var c0, err = node.GetCollectionByCollectionName("collection0") assert.NoError(t, err) assert.Equal(t, c0.CollectionName, "collection0") + c0 = node.GetCollectionByID(0) + assert.NotNil(t, c0) + assert.Equal(t, c0.CollectionID, 0) } func TestUtilFunctions_GetSegmentBySegmentID(t *testing.T) { // 1. Construct node, collection, partition and segment node := NewQueryNode(0, 0) - var collection = node.NewCollection("collection0", "fake schema") + var collection = node.NewCollection(0, "collection0", "fake schema") var partition = collection.NewPartition("partition0") var segment = partition.NewSegment(0) node.SegmentsMap[0] = segment diff --git a/sdk/examples/simple/CMakeLists.txt b/sdk/examples/simple/CMakeLists.txt index 1d2345f6e5..09307e1904 100644 --- a/sdk/examples/simple/CMakeLists.txt +++ b/sdk/examples/simple/CMakeLists.txt @@ -14,4 +14,8 @@ install(TARGETS insert DESTINATION test) add_executable(delete delete.cpp) target_link_libraries(delete milvus_sdk pthread) -install(TARGETS delete DESTINATION test) \ No newline at end of file +install(TARGETS delete DESTINATION test) + +add_executable(create CreateCollection.cpp) +target_link_libraries(create milvus_sdk pthread) +install(TARGETS create DESTINATION test) \ No newline at end of file diff --git a/sdk/examples/simple/CreateCollection.cpp b/sdk/examples/simple/CreateCollection.cpp new file mode 100644 index 0000000000..f66a2ee1d0 --- /dev/null +++ b/sdk/examples/simple/CreateCollection.cpp @@ -0,0 +1,46 @@ + +#include +#include +#include +#include + +int main() { + auto client = milvus::ConnectionImpl(); + milvus::ConnectParam connect_param; + connect_param.ip_address = "localhost"; + connect_param.port = "19530"; + client.Connect(connect_param); + + milvus::Status stat; + const std::string collectin_name = "collection0"; + + // Create + milvus::FieldPtr field_ptr1 = std::make_shared(); + milvus::FieldPtr field_ptr2 = std::make_shared(); + milvus::FieldPtr field_ptr3 = std::make_shared(); + milvus::FieldPtr field_ptr4 = std::make_shared(); + + field_ptr1->field_name = "field_1"; + field_ptr1->field_type = milvus::DataType::INT64; + + field_ptr2->field_name = "field_2"; + field_ptr2->field_type = milvus::DataType::FLOAT; + + field_ptr3->field_name = "field_3"; + field_ptr3->field_type = milvus::DataType::INT32; + + field_ptr4->field_name = "field_vec"; + field_ptr4->field_type = milvus::DataType::VECTOR_FLOAT; + + milvus::Mapping mapping = {collectin_name, {field_ptr1, field_ptr2, field_ptr3, field_ptr4}}; + + stat = client.CreateCollection(mapping, "test_extra_params"); + + + // Get Collection info + milvus::Mapping map; + client.GetCollectionInfo(collectin_name, map); + for (auto &f : map.fields) { + std::cout << f->field_name << ":" << int(f->field_type) << ":" << f->dim << "DIM" << std::endl; + } +} \ No newline at end of file