From d023c1afbad42ff4edb5c7d3d3afbbdfb3c0ad00 Mon Sep 17 00:00:00 2001 From: dragondriver Date: Mon, 21 Dec 2020 16:36:07 +0800 Subject: [PATCH] Refactor index wrapper, use protobuf instead of json to pass data Signed-off-by: dragondriver --- .../core/src/indexbuilder/IndexWrapper.cpp | 77 +- internal/core/src/indexbuilder/IndexWrapper.h | 11 +- internal/core/src/indexbuilder/index_c.cpp | 17 +- internal/core/src/indexbuilder/index_c.h | 10 +- internal/core/src/pb/CMakeLists.txt | 2 +- internal/core/src/pb/index_cgo_msg.pb.cc | 1311 +++++++++++++++++ internal/core/src/pb/index_cgo_msg.pb.h | 875 +++++++++++ internal/indexbuilder/index.go | 81 +- internal/proto/index_cgo_msg.proto | 23 + internal/proto/indexcgopb/index_cgo_msg.pb.go | 216 +++ scripts/proto_gen_go.sh | 2 + 11 files changed, 2582 insertions(+), 43 deletions(-) create mode 100644 internal/core/src/pb/index_cgo_msg.pb.cc create mode 100644 internal/core/src/pb/index_cgo_msg.pb.h create mode 100644 internal/proto/index_cgo_msg.proto create mode 100644 internal/proto/indexcgopb/index_cgo_msg.pb.go diff --git a/internal/core/src/indexbuilder/IndexWrapper.cpp b/internal/core/src/indexbuilder/IndexWrapper.cpp index 20855d4413..cb53d66bfd 100644 --- a/internal/core/src/indexbuilder/IndexWrapper.cpp +++ b/internal/core/src/indexbuilder/IndexWrapper.cpp @@ -9,16 +9,19 @@ // 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 +#include "pb/index_cgo_msg.pb.h" #include "knowhere/index/vector_index/VecIndexFactory.h" #include "knowhere/index/vector_index/helpers/IndexParameter.h" +#include "utils/EasyAssert.h" #include "IndexWrapper.h" namespace milvus { namespace indexbuilder { -IndexWrapper::IndexWrapper(const char* type_params_str, const char* index_params_str) { - type_params_ = std::string(type_params_str); - index_params_ = std::string(index_params_str); +IndexWrapper::IndexWrapper(const char* serialized_type_params, const char* serialized_index_params) { + type_params_ = std::string(serialized_type_params); + index_params_ = std::string(serialized_index_params); + parse(); auto index_type = index_config_["index_type"].get(); @@ -30,8 +33,26 @@ IndexWrapper::IndexWrapper(const char* type_params_str, const char* index_params void IndexWrapper::parse() { - type_config_ = milvus::json::parse(type_params_); - index_config_ = milvus::json::parse(index_params_); + namespace indexcgo = milvus::proto::indexcgo; + bool serialized_success; + + indexcgo::BinarySet type_config; + serialized_success = type_config.ParseFromString(type_params_); + Assert(serialized_success); + + indexcgo::BinarySet index_config; + serialized_success = index_config.ParseFromString(index_params_); + Assert(serialized_success); + + for (auto i = 0; i < type_config.datas_size(); ++i) { + auto binary = type_config.datas(i); + type_config_[binary.key()] = binary.value(); + } + + for (auto i = 0; i < index_config.datas_size(); ++i) { + auto binary = index_config.datas(i); + index_config_[binary.key()] = binary.value(); + } // TODO: parse from type_params & index_params auto dim = 128; @@ -55,14 +76,52 @@ IndexWrapper::BuildWithoutIds(const knowhere::DatasetPtr& dataset) { index_->AddWithoutIds(dataset, config_); } -char* +/* + * brief Return serialized binary set + */ +milvus::indexbuilder::IndexWrapper::Binary IndexWrapper::Serialize() { - return (char*)malloc(1); + namespace indexcgo = milvus::proto::indexcgo; + auto binarySet = index_->Serialize(config_); + indexcgo::BinarySet ret; + + for (auto [key, value] : binarySet.binary_map_) { + auto binary = ret.add_datas(); + binary->set_key(key); + binary->set_value(reinterpret_cast(value->data.get())); + } + + std::string serialized_data; + auto ok = ret.SerializeToString(&serialized_data); + Assert(ok); + + auto data = new char[serialized_data.length() + 1]; + memcpy(data, serialized_data.c_str(), serialized_data.length()); + data[serialized_data.length()] = 0; + + return {data, static_cast(serialized_data.length() + 1)}; } void -IndexWrapper::Load(const char* dumped_blob_buffer) { - return; +IndexWrapper::Load(const char* serialized_sliced_blob_buffer) { + namespace indexcgo = milvus::proto::indexcgo; + auto data = std::string(serialized_sliced_blob_buffer); + indexcgo::BinarySet blob_buffer; + + auto ok = blob_buffer.ParseFromString(data); + Assert(ok); + + milvus::knowhere::BinarySet binarySet; + for (auto i = 0; i < blob_buffer.datas_size(); i++) { + auto binary = blob_buffer.datas(i); + std::shared_ptr binary_data(new uint8_t[binary.value().length() + 1], + std::default_delete()); + memcpy(binary_data.get(), binary.value().c_str(), binary.value().length()); + binary_data[binary.value().length()] = 0; + binarySet.Append(binary.key(), binary_data, binary.value().length() + 1); + } + + index_->Load(binarySet); } } // namespace indexbuilder diff --git a/internal/core/src/indexbuilder/IndexWrapper.h b/internal/core/src/indexbuilder/IndexWrapper.h index 18506fe8fe..ab326fc2ea 100644 --- a/internal/core/src/indexbuilder/IndexWrapper.h +++ b/internal/core/src/indexbuilder/IndexWrapper.h @@ -17,7 +17,7 @@ namespace indexbuilder { class IndexWrapper { public: - explicit IndexWrapper(const char* type_params_str, const char* index_params_str); + explicit IndexWrapper(const char* serialized_type_params, const char* serialized_index_params); int64_t dim(); @@ -25,11 +25,16 @@ class IndexWrapper { void BuildWithoutIds(const knowhere::DatasetPtr& dataset); - char* + struct Binary { + char* data; + int32_t size; + }; + + Binary Serialize(); void - Load(const char* dumped_blob_buffer); + Load(const char* serialized_sliced_blob_buffer); private: void diff --git a/internal/core/src/indexbuilder/index_c.cpp b/internal/core/src/indexbuilder/index_c.cpp index 23a38f0925..29a5252629 100644 --- a/internal/core/src/indexbuilder/index_c.cpp +++ b/internal/core/src/indexbuilder/index_c.cpp @@ -15,8 +15,8 @@ #include "indexbuilder/index_c.h" CIndex -CreateIndex(const char* type_params_str, const char* index_params_str) { - auto index = std::make_unique(type_params_str, index_params_str); +CreateIndex(const char* serialized_type_params, const char* serialized_index_params) { + auto index = std::make_unique(serialized_type_params, serialized_index_params); return (void*)(index.release()); } @@ -28,21 +28,24 @@ DeleteIndex(CIndex index) { } void -BuildFloatVecIndex(CIndex index, int64_t row_nums, const float* vectors) { +BuildFloatVecIndex(CIndex index, int64_t float_value_num, const float* vectors) { auto cIndex = (milvus::indexbuilder::IndexWrapper*)index; auto dim = cIndex->dim(); + auto row_nums = float_value_num / dim; auto ds = milvus::knowhere::GenDataset(row_nums, dim, vectors); cIndex->BuildWithoutIds(ds); } char* -SerializeToSlicedBuffer(CIndex index) { +SerializeToSlicedBuffer(CIndex index, int32_t* buffer_size) { auto cIndex = (milvus::indexbuilder::IndexWrapper*)index; - return cIndex->Serialize(); + auto binary = cIndex->Serialize(); + *buffer_size = binary.size; + return binary.data; } void -LoadFromSlicedBuffer(CIndex index, const char* dumped_blob_buffer) { +LoadFromSlicedBuffer(CIndex index, const char* serialized_sliced_blob_buffer) { auto cIndex = (milvus::indexbuilder::IndexWrapper*)index; - cIndex->Load(dumped_blob_buffer); + cIndex->Load(serialized_sliced_blob_buffer); } diff --git a/internal/core/src/indexbuilder/index_c.h b/internal/core/src/indexbuilder/index_c.h index 5bdf800029..6918c8743a 100644 --- a/internal/core/src/indexbuilder/index_c.h +++ b/internal/core/src/indexbuilder/index_c.h @@ -32,20 +32,22 @@ extern "C" { typedef void* CIndex; // TODO: how could we pass map between go and c++ more efficiently? +// Solution: using protobuf instead of json, this way significantly increase programming efficiency + CIndex -CreateIndex(const char* type_params_str, const char* index_params_str); +CreateIndex(const char* serialized_type_params, const char* serialized_index_params); void DeleteIndex(CIndex index); void -BuildFloatVecIndex(CIndex index, const float* vectors); +BuildFloatVecIndex(CIndex index, int64_t float_value_num, const float* vectors); char* -SerializeToSlicedBuffer(CIndex index); +SerializeToSlicedBuffer(CIndex index, int32_t* buffer_size); void -LoadFromSlicedBuffer(CIndex index, const char* dumped_blob_buffer); +LoadFromSlicedBuffer(CIndex index, const char* serialized_sliced_blob_buffer); #ifdef __cplusplus }; diff --git a/internal/core/src/pb/CMakeLists.txt b/internal/core/src/pb/CMakeLists.txt index 0ae4e9abcc..36d2903358 100644 --- a/internal/core/src/pb/CMakeLists.txt +++ b/internal/core/src/pb/CMakeLists.txt @@ -1,7 +1,7 @@ get_property(PROTOC_EXCUTABLE GLOBAL PROPERTY PROTOC_EXCUTABLE ) -set(proto_file_names common.proto etcd_meta.proto schema.proto service_msg.proto) +set(proto_file_names common.proto etcd_meta.proto schema.proto service_msg.proto index_cgo_msg.proto) set( PROTO_PATH "${MILVUS_SOURCE_DIR}/../proto/" ) diff --git a/internal/core/src/pb/index_cgo_msg.pb.cc b/internal/core/src/pb/index_cgo_msg.pb.cc new file mode 100644 index 0000000000..f79da963e1 --- /dev/null +++ b/internal/core/src/pb/index_cgo_msg.pb.cc @@ -0,0 +1,1311 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: index_cgo_msg.proto + +#include "index_cgo_msg.pb.h" + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +// @@protoc_insertion_point(includes) +#include +extern PROTOBUF_INTERNAL_EXPORT_common_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_KeyValuePair_common_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_index_5fcgo_5fmsg_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_Binary_index_5fcgo_5fmsg_2eproto; +namespace milvus { +namespace proto { +namespace indexcgo { +class TypeParamsDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _TypeParams_default_instance_; +class IndexParamsDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _IndexParams_default_instance_; +class BinaryDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _Binary_default_instance_; +class BinarySetDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _BinarySet_default_instance_; +} // namespace indexcgo +} // namespace proto +} // namespace milvus +static void InitDefaultsscc_info_Binary_index_5fcgo_5fmsg_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::proto::indexcgo::_Binary_default_instance_; + new (ptr) ::milvus::proto::indexcgo::Binary(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::proto::indexcgo::Binary::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_Binary_index_5fcgo_5fmsg_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_Binary_index_5fcgo_5fmsg_2eproto}, {}}; + +static void InitDefaultsscc_info_BinarySet_index_5fcgo_5fmsg_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::proto::indexcgo::_BinarySet_default_instance_; + new (ptr) ::milvus::proto::indexcgo::BinarySet(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::proto::indexcgo::BinarySet::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_BinarySet_index_5fcgo_5fmsg_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_BinarySet_index_5fcgo_5fmsg_2eproto}, { + &scc_info_Binary_index_5fcgo_5fmsg_2eproto.base,}}; + +static void InitDefaultsscc_info_IndexParams_index_5fcgo_5fmsg_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::proto::indexcgo::_IndexParams_default_instance_; + new (ptr) ::milvus::proto::indexcgo::IndexParams(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::proto::indexcgo::IndexParams::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_IndexParams_index_5fcgo_5fmsg_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_IndexParams_index_5fcgo_5fmsg_2eproto}, { + &scc_info_KeyValuePair_common_2eproto.base,}}; + +static void InitDefaultsscc_info_TypeParams_index_5fcgo_5fmsg_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::proto::indexcgo::_TypeParams_default_instance_; + new (ptr) ::milvus::proto::indexcgo::TypeParams(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::proto::indexcgo::TypeParams::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_TypeParams_index_5fcgo_5fmsg_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_TypeParams_index_5fcgo_5fmsg_2eproto}, { + &scc_info_KeyValuePair_common_2eproto.base,}}; + +static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_index_5fcgo_5fmsg_2eproto[4]; +static constexpr ::PROTOBUF_NAMESPACE_ID::EnumDescriptor const** file_level_enum_descriptors_index_5fcgo_5fmsg_2eproto = nullptr; +static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_index_5fcgo_5fmsg_2eproto = nullptr; + +const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_index_5fcgo_5fmsg_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::proto::indexcgo::TypeParams, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::proto::indexcgo::TypeParams, params_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::proto::indexcgo::IndexParams, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::proto::indexcgo::IndexParams, params_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::proto::indexcgo::Binary, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::proto::indexcgo::Binary, key_), + PROTOBUF_FIELD_OFFSET(::milvus::proto::indexcgo::Binary, value_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::proto::indexcgo::BinarySet, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::proto::indexcgo::BinarySet, datas_), +}; +static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { + { 0, -1, sizeof(::milvus::proto::indexcgo::TypeParams)}, + { 6, -1, sizeof(::milvus::proto::indexcgo::IndexParams)}, + { 12, -1, sizeof(::milvus::proto::indexcgo::Binary)}, + { 19, -1, sizeof(::milvus::proto::indexcgo::BinarySet)}, +}; + +static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { + reinterpret_cast(&::milvus::proto::indexcgo::_TypeParams_default_instance_), + reinterpret_cast(&::milvus::proto::indexcgo::_IndexParams_default_instance_), + reinterpret_cast(&::milvus::proto::indexcgo::_Binary_default_instance_), + reinterpret_cast(&::milvus::proto::indexcgo::_BinarySet_default_instance_), +}; + +const char descriptor_table_protodef_index_5fcgo_5fmsg_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = + "\n\023index_cgo_msg.proto\022\025milvus.proto.inde" + "xcgo\032\014common.proto\"\?\n\nTypeParams\0221\n\006para" + "ms\030\001 \003(\0132!.milvus.proto.common.KeyValueP" + "air\"@\n\013IndexParams\0221\n\006params\030\001 \003(\0132!.mil" + "vus.proto.common.KeyValuePair\"$\n\006Binary\022" + "\013\n\003key\030\001 \001(\t\022\r\n\005value\030\002 \001(\014\"9\n\tBinarySet" + "\022,\n\005datas\030\001 \003(\0132\035.milvus.proto.indexcgo." + "BinaryBDZBgithub.com/zilliztech/milvus-d" + "istributed/internal/proto/indexcgopbb\006pr" + "oto3" + ; +static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_index_5fcgo_5fmsg_2eproto_deps[1] = { + &::descriptor_table_common_2eproto, +}; +static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_index_5fcgo_5fmsg_2eproto_sccs[4] = { + &scc_info_Binary_index_5fcgo_5fmsg_2eproto.base, + &scc_info_BinarySet_index_5fcgo_5fmsg_2eproto.base, + &scc_info_IndexParams_index_5fcgo_5fmsg_2eproto.base, + &scc_info_TypeParams_index_5fcgo_5fmsg_2eproto.base, +}; +static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_index_5fcgo_5fmsg_2eproto_once; +static bool descriptor_table_index_5fcgo_5fmsg_2eproto_initialized = false; +const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_index_5fcgo_5fmsg_2eproto = { + &descriptor_table_index_5fcgo_5fmsg_2eproto_initialized, descriptor_table_protodef_index_5fcgo_5fmsg_2eproto, "index_cgo_msg.proto", 364, + &descriptor_table_index_5fcgo_5fmsg_2eproto_once, descriptor_table_index_5fcgo_5fmsg_2eproto_sccs, descriptor_table_index_5fcgo_5fmsg_2eproto_deps, 4, 1, + schemas, file_default_instances, TableStruct_index_5fcgo_5fmsg_2eproto::offsets, + file_level_metadata_index_5fcgo_5fmsg_2eproto, 4, file_level_enum_descriptors_index_5fcgo_5fmsg_2eproto, file_level_service_descriptors_index_5fcgo_5fmsg_2eproto, +}; + +// Force running AddDescriptors() at dynamic initialization time. +static bool dynamic_init_dummy_index_5fcgo_5fmsg_2eproto = ( ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptors(&descriptor_table_index_5fcgo_5fmsg_2eproto), true); +namespace milvus { +namespace proto { +namespace indexcgo { + +// =================================================================== + +void TypeParams::InitAsDefaultInstance() { +} +class TypeParams::_Internal { + public: +}; + +void TypeParams::clear_params() { + params_.Clear(); +} +TypeParams::TypeParams() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.proto.indexcgo.TypeParams) +} +TypeParams::TypeParams(const TypeParams& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + params_(from.params_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:milvus.proto.indexcgo.TypeParams) +} + +void TypeParams::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_TypeParams_index_5fcgo_5fmsg_2eproto.base); +} + +TypeParams::~TypeParams() { + // @@protoc_insertion_point(destructor:milvus.proto.indexcgo.TypeParams) + SharedDtor(); +} + +void TypeParams::SharedDtor() { +} + +void TypeParams::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const TypeParams& TypeParams::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_TypeParams_index_5fcgo_5fmsg_2eproto.base); + return *internal_default_instance(); +} + + +void TypeParams::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.proto.indexcgo.TypeParams) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + params_.Clear(); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* TypeParams::_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.proto.common.KeyValuePair params = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(add_params(), 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 TypeParams::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.proto.indexcgo.TypeParams) + 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.proto.common.KeyValuePair params = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, add_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.proto.indexcgo.TypeParams) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.proto.indexcgo.TypeParams) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void TypeParams::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.proto.indexcgo.TypeParams) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated .milvus.proto.common.KeyValuePair params = 1; + for (unsigned int i = 0, + n = static_cast(this->params_size()); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, + this->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.proto.indexcgo.TypeParams) +} + +::PROTOBUF_NAMESPACE_ID::uint8* TypeParams::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.proto.indexcgo.TypeParams) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated .milvus.proto.common.KeyValuePair params = 1; + for (unsigned int i = 0, + n = static_cast(this->params_size()); i < n; i++) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 1, this->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.proto.indexcgo.TypeParams) + return target; +} + +size_t TypeParams::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.proto.indexcgo.TypeParams) + 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.proto.common.KeyValuePair params = 1; + { + unsigned int count = static_cast(this->params_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + this->params(static_cast(i))); + } + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void TypeParams::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.proto.indexcgo.TypeParams) + GOOGLE_DCHECK_NE(&from, this); + const TypeParams* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.proto.indexcgo.TypeParams) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.proto.indexcgo.TypeParams) + MergeFrom(*source); + } +} + +void TypeParams::MergeFrom(const TypeParams& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.proto.indexcgo.TypeParams) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + params_.MergeFrom(from.params_); +} + +void TypeParams::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.proto.indexcgo.TypeParams) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void TypeParams::CopyFrom(const TypeParams& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.proto.indexcgo.TypeParams) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool TypeParams::IsInitialized() const { + return true; +} + +void TypeParams::InternalSwap(TypeParams* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + CastToBase(¶ms_)->InternalSwap(CastToBase(&other->params_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata TypeParams::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void IndexParams::InitAsDefaultInstance() { +} +class IndexParams::_Internal { + public: +}; + +void IndexParams::clear_params() { + params_.Clear(); +} +IndexParams::IndexParams() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.proto.indexcgo.IndexParams) +} +IndexParams::IndexParams(const IndexParams& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + params_(from.params_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:milvus.proto.indexcgo.IndexParams) +} + +void IndexParams::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_IndexParams_index_5fcgo_5fmsg_2eproto.base); +} + +IndexParams::~IndexParams() { + // @@protoc_insertion_point(destructor:milvus.proto.indexcgo.IndexParams) + SharedDtor(); +} + +void IndexParams::SharedDtor() { +} + +void IndexParams::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const IndexParams& IndexParams::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_IndexParams_index_5fcgo_5fmsg_2eproto.base); + return *internal_default_instance(); +} + + +void IndexParams::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.proto.indexcgo.IndexParams) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + params_.Clear(); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* IndexParams::_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.proto.common.KeyValuePair params = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(add_params(), 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 IndexParams::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.proto.indexcgo.IndexParams) + 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.proto.common.KeyValuePair params = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, add_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.proto.indexcgo.IndexParams) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.proto.indexcgo.IndexParams) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void IndexParams::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.proto.indexcgo.IndexParams) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated .milvus.proto.common.KeyValuePair params = 1; + for (unsigned int i = 0, + n = static_cast(this->params_size()); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, + this->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.proto.indexcgo.IndexParams) +} + +::PROTOBUF_NAMESPACE_ID::uint8* IndexParams::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.proto.indexcgo.IndexParams) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated .milvus.proto.common.KeyValuePair params = 1; + for (unsigned int i = 0, + n = static_cast(this->params_size()); i < n; i++) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 1, this->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.proto.indexcgo.IndexParams) + return target; +} + +size_t IndexParams::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.proto.indexcgo.IndexParams) + 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.proto.common.KeyValuePair params = 1; + { + unsigned int count = static_cast(this->params_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + this->params(static_cast(i))); + } + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void IndexParams::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.proto.indexcgo.IndexParams) + GOOGLE_DCHECK_NE(&from, this); + const IndexParams* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.proto.indexcgo.IndexParams) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.proto.indexcgo.IndexParams) + MergeFrom(*source); + } +} + +void IndexParams::MergeFrom(const IndexParams& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.proto.indexcgo.IndexParams) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + params_.MergeFrom(from.params_); +} + +void IndexParams::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.proto.indexcgo.IndexParams) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void IndexParams::CopyFrom(const IndexParams& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.proto.indexcgo.IndexParams) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool IndexParams::IsInitialized() const { + return true; +} + +void IndexParams::InternalSwap(IndexParams* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + CastToBase(¶ms_)->InternalSwap(CastToBase(&other->params_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata IndexParams::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void Binary::InitAsDefaultInstance() { +} +class Binary::_Internal { + public: +}; + +Binary::Binary() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.proto.indexcgo.Binary) +} +Binary::Binary(const Binary& 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.proto.indexcgo.Binary) +} + +void Binary::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Binary_index_5fcgo_5fmsg_2eproto.base); + key_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +Binary::~Binary() { + // @@protoc_insertion_point(destructor:milvus.proto.indexcgo.Binary) + SharedDtor(); +} + +void Binary::SharedDtor() { + key_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + value_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void Binary::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const Binary& Binary::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_Binary_index_5fcgo_5fmsg_2eproto.base); + return *internal_default_instance(); +} + + +void Binary::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.proto.indexcgo.Binary) + ::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* Binary::_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.proto.indexcgo.Binary.key"); + CHK_(ptr); + } else goto handle_unusual; + continue; + // bytes value = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(mutable_value(), 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 Binary::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.proto.indexcgo.Binary) + 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.proto.indexcgo.Binary.key")); + } else { + goto handle_unusual; + } + break; + } + + // bytes value = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadBytes( + input, this->mutable_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.proto.indexcgo.Binary) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.proto.indexcgo.Binary) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void Binary::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.proto.indexcgo.Binary) + ::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.proto.indexcgo.Binary.key"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->key(), output); + } + + // bytes value = 2; + if (this->value().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesMaybeAliased( + 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.proto.indexcgo.Binary) +} + +::PROTOBUF_NAMESPACE_ID::uint8* Binary::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.proto.indexcgo.Binary) + ::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.proto.indexcgo.Binary.key"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 1, this->key(), target); + } + + // bytes value = 2; + if (this->value().size() > 0) { + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesToArray( + 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.proto.indexcgo.Binary) + return target; +} + +size_t Binary::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.proto.indexcgo.Binary) + 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()); + } + + // bytes value = 2; + if (this->value().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->value()); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Binary::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.proto.indexcgo.Binary) + GOOGLE_DCHECK_NE(&from, this); + const Binary* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.proto.indexcgo.Binary) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.proto.indexcgo.Binary) + MergeFrom(*source); + } +} + +void Binary::MergeFrom(const Binary& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.proto.indexcgo.Binary) + 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 Binary::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.proto.indexcgo.Binary) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Binary::CopyFrom(const Binary& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.proto.indexcgo.Binary) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Binary::IsInitialized() const { + return true; +} + +void Binary::InternalSwap(Binary* 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 Binary::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void BinarySet::InitAsDefaultInstance() { +} +class BinarySet::_Internal { + public: +}; + +BinarySet::BinarySet() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.proto.indexcgo.BinarySet) +} +BinarySet::BinarySet(const BinarySet& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + datas_(from.datas_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:milvus.proto.indexcgo.BinarySet) +} + +void BinarySet::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_BinarySet_index_5fcgo_5fmsg_2eproto.base); +} + +BinarySet::~BinarySet() { + // @@protoc_insertion_point(destructor:milvus.proto.indexcgo.BinarySet) + SharedDtor(); +} + +void BinarySet::SharedDtor() { +} + +void BinarySet::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const BinarySet& BinarySet::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_BinarySet_index_5fcgo_5fmsg_2eproto.base); + return *internal_default_instance(); +} + + +void BinarySet::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.proto.indexcgo.BinarySet) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + datas_.Clear(); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* BinarySet::_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.proto.indexcgo.Binary datas = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(add_datas(), 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 BinarySet::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.proto.indexcgo.BinarySet) + 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.proto.indexcgo.Binary datas = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, add_datas())); + } 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.proto.indexcgo.BinarySet) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.proto.indexcgo.BinarySet) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void BinarySet::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.proto.indexcgo.BinarySet) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated .milvus.proto.indexcgo.Binary datas = 1; + for (unsigned int i = 0, + n = static_cast(this->datas_size()); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, + this->datas(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.proto.indexcgo.BinarySet) +} + +::PROTOBUF_NAMESPACE_ID::uint8* BinarySet::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.proto.indexcgo.BinarySet) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated .milvus.proto.indexcgo.Binary datas = 1; + for (unsigned int i = 0, + n = static_cast(this->datas_size()); i < n; i++) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 1, this->datas(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.proto.indexcgo.BinarySet) + return target; +} + +size_t BinarySet::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.proto.indexcgo.BinarySet) + 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.proto.indexcgo.Binary datas = 1; + { + unsigned int count = static_cast(this->datas_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + this->datas(static_cast(i))); + } + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void BinarySet::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.proto.indexcgo.BinarySet) + GOOGLE_DCHECK_NE(&from, this); + const BinarySet* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.proto.indexcgo.BinarySet) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.proto.indexcgo.BinarySet) + MergeFrom(*source); + } +} + +void BinarySet::MergeFrom(const BinarySet& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.proto.indexcgo.BinarySet) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + datas_.MergeFrom(from.datas_); +} + +void BinarySet::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.proto.indexcgo.BinarySet) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void BinarySet::CopyFrom(const BinarySet& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.proto.indexcgo.BinarySet) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool BinarySet::IsInitialized() const { + return true; +} + +void BinarySet::InternalSwap(BinarySet* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + CastToBase(&datas_)->InternalSwap(CastToBase(&other->datas_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata BinarySet::GetMetadata() const { + return GetMetadataStatic(); +} + + +// @@protoc_insertion_point(namespace_scope) +} // namespace indexcgo +} // namespace proto +} // namespace milvus +PROTOBUF_NAMESPACE_OPEN +template<> PROTOBUF_NOINLINE ::milvus::proto::indexcgo::TypeParams* Arena::CreateMaybeMessage< ::milvus::proto::indexcgo::TypeParams >(Arena* arena) { + return Arena::CreateInternal< ::milvus::proto::indexcgo::TypeParams >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::proto::indexcgo::IndexParams* Arena::CreateMaybeMessage< ::milvus::proto::indexcgo::IndexParams >(Arena* arena) { + return Arena::CreateInternal< ::milvus::proto::indexcgo::IndexParams >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::proto::indexcgo::Binary* Arena::CreateMaybeMessage< ::milvus::proto::indexcgo::Binary >(Arena* arena) { + return Arena::CreateInternal< ::milvus::proto::indexcgo::Binary >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::proto::indexcgo::BinarySet* Arena::CreateMaybeMessage< ::milvus::proto::indexcgo::BinarySet >(Arena* arena) { + return Arena::CreateInternal< ::milvus::proto::indexcgo::BinarySet >(arena); +} +PROTOBUF_NAMESPACE_CLOSE + +// @@protoc_insertion_point(global_scope) +#include diff --git a/internal/core/src/pb/index_cgo_msg.pb.h b/internal/core/src/pb/index_cgo_msg.pb.h new file mode 100644 index 0000000000..c741f2a9c1 --- /dev/null +++ b/internal/core/src/pb/index_cgo_msg.pb.h @@ -0,0 +1,875 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: index_cgo_msg.proto + +#ifndef GOOGLE_PROTOBUF_INCLUDED_index_5fcgo_5fmsg_2eproto +#define GOOGLE_PROTOBUF_INCLUDED_index_5fcgo_5fmsg_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 "common.pb.h" +// @@protoc_insertion_point(includes) +#include +#define PROTOBUF_INTERNAL_EXPORT_index_5fcgo_5fmsg_2eproto +PROTOBUF_NAMESPACE_OPEN +namespace internal { +class AnyMetadata; +} // namespace internal +PROTOBUF_NAMESPACE_CLOSE + +// Internal implementation detail -- do not use these members. +struct TableStruct_index_5fcgo_5fmsg_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[4] + 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_index_5fcgo_5fmsg_2eproto; +namespace milvus { +namespace proto { +namespace indexcgo { +class Binary; +class BinaryDefaultTypeInternal; +extern BinaryDefaultTypeInternal _Binary_default_instance_; +class BinarySet; +class BinarySetDefaultTypeInternal; +extern BinarySetDefaultTypeInternal _BinarySet_default_instance_; +class IndexParams; +class IndexParamsDefaultTypeInternal; +extern IndexParamsDefaultTypeInternal _IndexParams_default_instance_; +class TypeParams; +class TypeParamsDefaultTypeInternal; +extern TypeParamsDefaultTypeInternal _TypeParams_default_instance_; +} // namespace indexcgo +} // namespace proto +} // namespace milvus +PROTOBUF_NAMESPACE_OPEN +template<> ::milvus::proto::indexcgo::Binary* Arena::CreateMaybeMessage<::milvus::proto::indexcgo::Binary>(Arena*); +template<> ::milvus::proto::indexcgo::BinarySet* Arena::CreateMaybeMessage<::milvus::proto::indexcgo::BinarySet>(Arena*); +template<> ::milvus::proto::indexcgo::IndexParams* Arena::CreateMaybeMessage<::milvus::proto::indexcgo::IndexParams>(Arena*); +template<> ::milvus::proto::indexcgo::TypeParams* Arena::CreateMaybeMessage<::milvus::proto::indexcgo::TypeParams>(Arena*); +PROTOBUF_NAMESPACE_CLOSE +namespace milvus { +namespace proto { +namespace indexcgo { + +// =================================================================== + +class TypeParams : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.indexcgo.TypeParams) */ { + public: + TypeParams(); + virtual ~TypeParams(); + + TypeParams(const TypeParams& from); + TypeParams(TypeParams&& from) noexcept + : TypeParams() { + *this = ::std::move(from); + } + + inline TypeParams& operator=(const TypeParams& from) { + CopyFrom(from); + return *this; + } + inline TypeParams& operator=(TypeParams&& 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 TypeParams& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const TypeParams* internal_default_instance() { + return reinterpret_cast( + &_TypeParams_default_instance_); + } + static constexpr int kIndexInFileMessages = + 0; + + friend void swap(TypeParams& a, TypeParams& b) { + a.Swap(&b); + } + inline void Swap(TypeParams* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline TypeParams* New() const final { + return CreateMaybeMessage(nullptr); + } + + TypeParams* 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 TypeParams& from); + void MergeFrom(const TypeParams& 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(TypeParams* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.proto.indexcgo.TypeParams"; + } + 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_index_5fcgo_5fmsg_2eproto); + return ::descriptor_table_index_5fcgo_5fmsg_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kParamsFieldNumber = 1, + }; + // repeated .milvus.proto.common.KeyValuePair params = 1; + int params_size() const; + void clear_params(); + ::milvus::proto::common::KeyValuePair* mutable_params(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::common::KeyValuePair >* + mutable_params(); + const ::milvus::proto::common::KeyValuePair& params(int index) const; + ::milvus::proto::common::KeyValuePair* add_params(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::common::KeyValuePair >& + params() const; + + // @@protoc_insertion_point(class_scope:milvus.proto.indexcgo.TypeParams) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::common::KeyValuePair > params_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_index_5fcgo_5fmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class IndexParams : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.indexcgo.IndexParams) */ { + public: + IndexParams(); + virtual ~IndexParams(); + + IndexParams(const IndexParams& from); + IndexParams(IndexParams&& from) noexcept + : IndexParams() { + *this = ::std::move(from); + } + + inline IndexParams& operator=(const IndexParams& from) { + CopyFrom(from); + return *this; + } + inline IndexParams& operator=(IndexParams&& 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 IndexParams& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const IndexParams* internal_default_instance() { + return reinterpret_cast( + &_IndexParams_default_instance_); + } + static constexpr int kIndexInFileMessages = + 1; + + friend void swap(IndexParams& a, IndexParams& b) { + a.Swap(&b); + } + inline void Swap(IndexParams* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline IndexParams* New() const final { + return CreateMaybeMessage(nullptr); + } + + IndexParams* 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 IndexParams& from); + void MergeFrom(const IndexParams& 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(IndexParams* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.proto.indexcgo.IndexParams"; + } + 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_index_5fcgo_5fmsg_2eproto); + return ::descriptor_table_index_5fcgo_5fmsg_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kParamsFieldNumber = 1, + }; + // repeated .milvus.proto.common.KeyValuePair params = 1; + int params_size() const; + void clear_params(); + ::milvus::proto::common::KeyValuePair* mutable_params(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::common::KeyValuePair >* + mutable_params(); + const ::milvus::proto::common::KeyValuePair& params(int index) const; + ::milvus::proto::common::KeyValuePair* add_params(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::common::KeyValuePair >& + params() const; + + // @@protoc_insertion_point(class_scope:milvus.proto.indexcgo.IndexParams) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::common::KeyValuePair > params_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_index_5fcgo_5fmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Binary : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.indexcgo.Binary) */ { + public: + Binary(); + virtual ~Binary(); + + Binary(const Binary& from); + Binary(Binary&& from) noexcept + : Binary() { + *this = ::std::move(from); + } + + inline Binary& operator=(const Binary& from) { + CopyFrom(from); + return *this; + } + inline Binary& operator=(Binary&& 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 Binary& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const Binary* internal_default_instance() { + return reinterpret_cast( + &_Binary_default_instance_); + } + static constexpr int kIndexInFileMessages = + 2; + + friend void swap(Binary& a, Binary& b) { + a.Swap(&b); + } + inline void Swap(Binary* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Binary* New() const final { + return CreateMaybeMessage(nullptr); + } + + Binary* 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 Binary& from); + void MergeFrom(const Binary& 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(Binary* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.proto.indexcgo.Binary"; + } + 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_index_5fcgo_5fmsg_2eproto); + return ::descriptor_table_index_5fcgo_5fmsg_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); + + // bytes 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 void* 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.proto.indexcgo.Binary) + 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_index_5fcgo_5fmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class BinarySet : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.indexcgo.BinarySet) */ { + public: + BinarySet(); + virtual ~BinarySet(); + + BinarySet(const BinarySet& from); + BinarySet(BinarySet&& from) noexcept + : BinarySet() { + *this = ::std::move(from); + } + + inline BinarySet& operator=(const BinarySet& from) { + CopyFrom(from); + return *this; + } + inline BinarySet& operator=(BinarySet&& 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 BinarySet& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const BinarySet* internal_default_instance() { + return reinterpret_cast( + &_BinarySet_default_instance_); + } + static constexpr int kIndexInFileMessages = + 3; + + friend void swap(BinarySet& a, BinarySet& b) { + a.Swap(&b); + } + inline void Swap(BinarySet* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline BinarySet* New() const final { + return CreateMaybeMessage(nullptr); + } + + BinarySet* 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 BinarySet& from); + void MergeFrom(const BinarySet& 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(BinarySet* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.proto.indexcgo.BinarySet"; + } + 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_index_5fcgo_5fmsg_2eproto); + return ::descriptor_table_index_5fcgo_5fmsg_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kDatasFieldNumber = 1, + }; + // repeated .milvus.proto.indexcgo.Binary datas = 1; + int datas_size() const; + void clear_datas(); + ::milvus::proto::indexcgo::Binary* mutable_datas(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::indexcgo::Binary >* + mutable_datas(); + const ::milvus::proto::indexcgo::Binary& datas(int index) const; + ::milvus::proto::indexcgo::Binary* add_datas(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::indexcgo::Binary >& + datas() const; + + // @@protoc_insertion_point(class_scope:milvus.proto.indexcgo.BinarySet) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::indexcgo::Binary > datas_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_index_5fcgo_5fmsg_2eproto; +}; +// =================================================================== + + +// =================================================================== + +#ifdef __GNUC__ + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wstrict-aliasing" +#endif // __GNUC__ +// TypeParams + +// repeated .milvus.proto.common.KeyValuePair params = 1; +inline int TypeParams::params_size() const { + return params_.size(); +} +inline ::milvus::proto::common::KeyValuePair* TypeParams::mutable_params(int index) { + // @@protoc_insertion_point(field_mutable:milvus.proto.indexcgo.TypeParams.params) + return params_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::common::KeyValuePair >* +TypeParams::mutable_params() { + // @@protoc_insertion_point(field_mutable_list:milvus.proto.indexcgo.TypeParams.params) + return ¶ms_; +} +inline const ::milvus::proto::common::KeyValuePair& TypeParams::params(int index) const { + // @@protoc_insertion_point(field_get:milvus.proto.indexcgo.TypeParams.params) + return params_.Get(index); +} +inline ::milvus::proto::common::KeyValuePair* TypeParams::add_params() { + // @@protoc_insertion_point(field_add:milvus.proto.indexcgo.TypeParams.params) + return params_.Add(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::common::KeyValuePair >& +TypeParams::params() const { + // @@protoc_insertion_point(field_list:milvus.proto.indexcgo.TypeParams.params) + return params_; +} + +// ------------------------------------------------------------------- + +// IndexParams + +// repeated .milvus.proto.common.KeyValuePair params = 1; +inline int IndexParams::params_size() const { + return params_.size(); +} +inline ::milvus::proto::common::KeyValuePair* IndexParams::mutable_params(int index) { + // @@protoc_insertion_point(field_mutable:milvus.proto.indexcgo.IndexParams.params) + return params_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::common::KeyValuePair >* +IndexParams::mutable_params() { + // @@protoc_insertion_point(field_mutable_list:milvus.proto.indexcgo.IndexParams.params) + return ¶ms_; +} +inline const ::milvus::proto::common::KeyValuePair& IndexParams::params(int index) const { + // @@protoc_insertion_point(field_get:milvus.proto.indexcgo.IndexParams.params) + return params_.Get(index); +} +inline ::milvus::proto::common::KeyValuePair* IndexParams::add_params() { + // @@protoc_insertion_point(field_add:milvus.proto.indexcgo.IndexParams.params) + return params_.Add(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::common::KeyValuePair >& +IndexParams::params() const { + // @@protoc_insertion_point(field_list:milvus.proto.indexcgo.IndexParams.params) + return params_; +} + +// ------------------------------------------------------------------- + +// Binary + +// string key = 1; +inline void Binary::clear_key() { + key_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& Binary::key() const { + // @@protoc_insertion_point(field_get:milvus.proto.indexcgo.Binary.key) + return key_.GetNoArena(); +} +inline void Binary::set_key(const std::string& value) { + + key_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.proto.indexcgo.Binary.key) +} +inline void Binary::set_key(std::string&& value) { + + key_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:milvus.proto.indexcgo.Binary.key) +} +inline void Binary::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.proto.indexcgo.Binary.key) +} +inline void Binary::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.proto.indexcgo.Binary.key) +} +inline std::string* Binary::mutable_key() { + + // @@protoc_insertion_point(field_mutable:milvus.proto.indexcgo.Binary.key) + return key_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* Binary::release_key() { + // @@protoc_insertion_point(field_release:milvus.proto.indexcgo.Binary.key) + + return key_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void Binary::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.proto.indexcgo.Binary.key) +} + +// bytes value = 2; +inline void Binary::clear_value() { + value_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& Binary::value() const { + // @@protoc_insertion_point(field_get:milvus.proto.indexcgo.Binary.value) + return value_.GetNoArena(); +} +inline void Binary::set_value(const std::string& value) { + + value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.proto.indexcgo.Binary.value) +} +inline void Binary::set_value(std::string&& value) { + + value_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:milvus.proto.indexcgo.Binary.value) +} +inline void Binary::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.proto.indexcgo.Binary.value) +} +inline void Binary::set_value(const void* value, size_t size) { + + value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:milvus.proto.indexcgo.Binary.value) +} +inline std::string* Binary::mutable_value() { + + // @@protoc_insertion_point(field_mutable:milvus.proto.indexcgo.Binary.value) + return value_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* Binary::release_value() { + // @@protoc_insertion_point(field_release:milvus.proto.indexcgo.Binary.value) + + return value_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void Binary::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.proto.indexcgo.Binary.value) +} + +// ------------------------------------------------------------------- + +// BinarySet + +// repeated .milvus.proto.indexcgo.Binary datas = 1; +inline int BinarySet::datas_size() const { + return datas_.size(); +} +inline void BinarySet::clear_datas() { + datas_.Clear(); +} +inline ::milvus::proto::indexcgo::Binary* BinarySet::mutable_datas(int index) { + // @@protoc_insertion_point(field_mutable:milvus.proto.indexcgo.BinarySet.datas) + return datas_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::indexcgo::Binary >* +BinarySet::mutable_datas() { + // @@protoc_insertion_point(field_mutable_list:milvus.proto.indexcgo.BinarySet.datas) + return &datas_; +} +inline const ::milvus::proto::indexcgo::Binary& BinarySet::datas(int index) const { + // @@protoc_insertion_point(field_get:milvus.proto.indexcgo.BinarySet.datas) + return datas_.Get(index); +} +inline ::milvus::proto::indexcgo::Binary* BinarySet::add_datas() { + // @@protoc_insertion_point(field_add:milvus.proto.indexcgo.BinarySet.datas) + return datas_.Add(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::indexcgo::Binary >& +BinarySet::datas() const { + // @@protoc_insertion_point(field_list:milvus.proto.indexcgo.BinarySet.datas) + return datas_; +} + +#ifdef __GNUC__ + #pragma GCC diagnostic pop +#endif // __GNUC__ +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace indexcgo +} // namespace proto +} // namespace milvus + +// @@protoc_insertion_point(global_scope) + +#include +#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_index_5fcgo_5fmsg_2eproto diff --git a/internal/indexbuilder/index.go b/internal/indexbuilder/index.go index c82d582e7b..278677ec45 100644 --- a/internal/indexbuilder/index.go +++ b/internal/indexbuilder/index.go @@ -6,15 +6,18 @@ package indexbuilder #cgo LDFLAGS: -L${SRCDIR}/../core/output/lib -lmilvus_indexbuilder -Wl,-rpath=${SRCDIR}/../core/output/lib +#include // free #include "segcore/collection_c.h" #include "indexbuilder/index_c.h" */ import "C" import ( - "encoding/json" + "unsafe" - "github.com/zilliztech/milvus-distributed/internal/errors" + "github.com/golang/protobuf/proto" + "github.com/zilliztech/milvus-distributed/internal/proto/commonpb" + "github.com/zilliztech/milvus-distributed/internal/proto/indexcgopb" ) // TODO: use storage.Blob instead later @@ -36,54 +39,94 @@ type CIndex struct { } func (index *CIndex) Serialize() ([]*Blob, error) { - var cDumpedSlicedBuffer *C.char = C.SerializeToSlicedBuffer(index.indexPtr) - var dumpedSlicedBuffer string = C.GoString(cDumpedSlicedBuffer) + /* + char* + SerializeToSlicedBuffer(CIndex index, int32_t* buffer_size); + */ + var bufferSize int32 + var cDumpedSlicedBuffer *C.char = C.SerializeToSlicedBuffer(index.indexPtr, (*C.int32_t)(unsafe.Pointer(&bufferSize))) + defer C.free(unsafe.Pointer(cDumpedSlicedBuffer)) - var data map[string]interface{} - err := json.Unmarshal([]byte(dumpedSlicedBuffer), &data) + dumpedSlicedBuffer := C.GoBytes(unsafe.Pointer(cDumpedSlicedBuffer), (C.int32_t)(bufferSize)) + var blobs indexcgopb.BinarySet + err := proto.Unmarshal(dumpedSlicedBuffer, &blobs) if err != nil { - return nil, errors.New("unmarshal sliced buffer failed") + return nil, err } ret := make([]*Blob, 0) - for key, value := range data { - valueString, ok := value.(string) - if !ok { - return nil, errors.New("unexpected data type of dumped sliced buffer") - } - ret = append(ret, &Blob{key, []byte(valueString)}) + for _, data := range blobs.Datas { + ret = append(ret, &Blob{Key: data.Key, Value: data.Value}) } return ret, nil } -func (index *CIndex) Load([]*Blob) error { +func (index *CIndex) Load(blobs []*Blob) error { + binarySet := &indexcgopb.BinarySet{Datas: make([]*indexcgopb.Binary, 0)} + for _, blob := range blobs { + binarySet.Datas = append(binarySet.Datas, &indexcgopb.Binary{Key: blob.Key, Value: blob.Value}) + } + + datas, err := proto.Marshal(binarySet) + if err != nil { + return err + } + + /* + void + LoadFromSlicedBuffer(CIndex index, const char* serialized_sliced_blob_buffer); + */ + C.LoadFromSlicedBuffer(index.indexPtr, (*C.char)(unsafe.Pointer(&datas[0]))) return nil } func (index *CIndex) BuildFloatVecIndex(vectors []float32) error { + /* + void + BuildFloatVecIndex(CIndex index, int64_t float_value_num, const float* vectors); + */ + C.BuildFloatVecIndex(index.indexPtr, (C.int64_t)(len(vectors)), (*C.float)(&vectors[0])) return nil } func (index *CIndex) Delete() error { + /* + void + DeleteIndex(CIndex index); + */ C.DeleteIndex(index.indexPtr) return nil } func NewCIndex(typeParams, indexParams map[string]string) (Index, error) { - dumpedTypeParamsStr, err := json.Marshal(typeParams) + protoTypeParams := &indexcgopb.TypeParams{ + Params: make([]*commonpb.KeyValuePair, 0), + } + for key, value := range typeParams { + protoTypeParams.Params = append(protoTypeParams.Params, &commonpb.KeyValuePair{Key: key, Value: value}) + } + typeParamsStr, err := proto.Marshal(protoTypeParams) if err != nil { return nil, err } - dumpedIndexParamsStr, err := json.Marshal(indexParams) + protoIndexParams := &indexcgopb.IndexParams{ + Params: make([]*commonpb.KeyValuePair, 0), + } + for key, value := range indexParams { + protoIndexParams.Params = append(protoIndexParams.Params, &commonpb.KeyValuePair{Key: key, Value: value}) + } + indexParamsStr, err := proto.Marshal(protoIndexParams) if err != nil { return nil, err } - cDumpedTypeParamsStr := C.CString(string(dumpedTypeParamsStr)) - cDumpedIndexParamsStr := C.CString(string(dumpedIndexParamsStr)) + /* + CIndex + CreateIndex(const char* serialized_type_params, const char* serialized_index_params); + */ return &CIndex{ - indexPtr: C.CreateIndex(cDumpedTypeParamsStr, cDumpedIndexParamsStr), + indexPtr: C.CreateIndex((*C.char)(unsafe.Pointer(&typeParamsStr[0])), (*C.char)(unsafe.Pointer(&indexParamsStr[0]))), }, nil } diff --git a/internal/proto/index_cgo_msg.proto b/internal/proto/index_cgo_msg.proto new file mode 100644 index 0000000000..5c37844dac --- /dev/null +++ b/internal/proto/index_cgo_msg.proto @@ -0,0 +1,23 @@ +syntax = "proto3"; + +package milvus.proto.indexcgo; +option go_package="github.com/zilliztech/milvus-distributed/internal/proto/indexcgopb"; + +import "common.proto"; + +message TypeParams { + repeated common.KeyValuePair params = 1; +} + +message IndexParams { + repeated common.KeyValuePair params = 1; +} + +message Binary { + string key = 1; + bytes value = 2; +} + +message BinarySet { + repeated Binary datas = 1; +} diff --git a/internal/proto/indexcgopb/index_cgo_msg.pb.go b/internal/proto/indexcgopb/index_cgo_msg.pb.go new file mode 100644 index 0000000000..f49d4ae293 --- /dev/null +++ b/internal/proto/indexcgopb/index_cgo_msg.pb.go @@ -0,0 +1,216 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// source: index_cgo_msg.proto + +package indexcgopb + +import ( + fmt "fmt" + proto "github.com/golang/protobuf/proto" + commonpb "github.com/zilliztech/milvus-distributed/internal/proto/commonpb" + math "math" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package + +type TypeParams struct { + Params []*commonpb.KeyValuePair `protobuf:"bytes,1,rep,name=params,proto3" json:"params,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *TypeParams) Reset() { *m = TypeParams{} } +func (m *TypeParams) String() string { return proto.CompactTextString(m) } +func (*TypeParams) ProtoMessage() {} +func (*TypeParams) Descriptor() ([]byte, []int) { + return fileDescriptor_c009bd9544a7343c, []int{0} +} + +func (m *TypeParams) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_TypeParams.Unmarshal(m, b) +} +func (m *TypeParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_TypeParams.Marshal(b, m, deterministic) +} +func (m *TypeParams) XXX_Merge(src proto.Message) { + xxx_messageInfo_TypeParams.Merge(m, src) +} +func (m *TypeParams) XXX_Size() int { + return xxx_messageInfo_TypeParams.Size(m) +} +func (m *TypeParams) XXX_DiscardUnknown() { + xxx_messageInfo_TypeParams.DiscardUnknown(m) +} + +var xxx_messageInfo_TypeParams proto.InternalMessageInfo + +func (m *TypeParams) GetParams() []*commonpb.KeyValuePair { + if m != nil { + return m.Params + } + return nil +} + +type IndexParams struct { + Params []*commonpb.KeyValuePair `protobuf:"bytes,1,rep,name=params,proto3" json:"params,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *IndexParams) Reset() { *m = IndexParams{} } +func (m *IndexParams) String() string { return proto.CompactTextString(m) } +func (*IndexParams) ProtoMessage() {} +func (*IndexParams) Descriptor() ([]byte, []int) { + return fileDescriptor_c009bd9544a7343c, []int{1} +} + +func (m *IndexParams) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_IndexParams.Unmarshal(m, b) +} +func (m *IndexParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_IndexParams.Marshal(b, m, deterministic) +} +func (m *IndexParams) XXX_Merge(src proto.Message) { + xxx_messageInfo_IndexParams.Merge(m, src) +} +func (m *IndexParams) XXX_Size() int { + return xxx_messageInfo_IndexParams.Size(m) +} +func (m *IndexParams) XXX_DiscardUnknown() { + xxx_messageInfo_IndexParams.DiscardUnknown(m) +} + +var xxx_messageInfo_IndexParams proto.InternalMessageInfo + +func (m *IndexParams) GetParams() []*commonpb.KeyValuePair { + if m != nil { + return m.Params + } + return nil +} + +type Binary struct { + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *Binary) Reset() { *m = Binary{} } +func (m *Binary) String() string { return proto.CompactTextString(m) } +func (*Binary) ProtoMessage() {} +func (*Binary) Descriptor() ([]byte, []int) { + return fileDescriptor_c009bd9544a7343c, []int{2} +} + +func (m *Binary) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_Binary.Unmarshal(m, b) +} +func (m *Binary) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_Binary.Marshal(b, m, deterministic) +} +func (m *Binary) XXX_Merge(src proto.Message) { + xxx_messageInfo_Binary.Merge(m, src) +} +func (m *Binary) XXX_Size() int { + return xxx_messageInfo_Binary.Size(m) +} +func (m *Binary) XXX_DiscardUnknown() { + xxx_messageInfo_Binary.DiscardUnknown(m) +} + +var xxx_messageInfo_Binary proto.InternalMessageInfo + +func (m *Binary) GetKey() string { + if m != nil { + return m.Key + } + return "" +} + +func (m *Binary) GetValue() []byte { + if m != nil { + return m.Value + } + return nil +} + +type BinarySet struct { + Datas []*Binary `protobuf:"bytes,1,rep,name=datas,proto3" json:"datas,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *BinarySet) Reset() { *m = BinarySet{} } +func (m *BinarySet) String() string { return proto.CompactTextString(m) } +func (*BinarySet) ProtoMessage() {} +func (*BinarySet) Descriptor() ([]byte, []int) { + return fileDescriptor_c009bd9544a7343c, []int{3} +} + +func (m *BinarySet) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_BinarySet.Unmarshal(m, b) +} +func (m *BinarySet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_BinarySet.Marshal(b, m, deterministic) +} +func (m *BinarySet) XXX_Merge(src proto.Message) { + xxx_messageInfo_BinarySet.Merge(m, src) +} +func (m *BinarySet) XXX_Size() int { + return xxx_messageInfo_BinarySet.Size(m) +} +func (m *BinarySet) XXX_DiscardUnknown() { + xxx_messageInfo_BinarySet.DiscardUnknown(m) +} + +var xxx_messageInfo_BinarySet proto.InternalMessageInfo + +func (m *BinarySet) GetDatas() []*Binary { + if m != nil { + return m.Datas + } + return nil +} + +func init() { + proto.RegisterType((*TypeParams)(nil), "milvus.proto.indexcgo.TypeParams") + proto.RegisterType((*IndexParams)(nil), "milvus.proto.indexcgo.IndexParams") + proto.RegisterType((*Binary)(nil), "milvus.proto.indexcgo.Binary") + proto.RegisterType((*BinarySet)(nil), "milvus.proto.indexcgo.BinarySet") +} + +func init() { proto.RegisterFile("index_cgo_msg.proto", fileDescriptor_c009bd9544a7343c) } + +var fileDescriptor_c009bd9544a7343c = []byte{ + // 257 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x90, 0xbf, 0x4b, 0xc3, 0x40, + 0x14, 0xc7, 0x89, 0xa5, 0x81, 0xbe, 0x76, 0x90, 0x53, 0x21, 0x08, 0x42, 0xcc, 0x94, 0xc5, 0x3b, + 0xb1, 0x93, 0x9b, 0x04, 0x41, 0xc5, 0xa5, 0x44, 0x71, 0x70, 0x29, 0x97, 0xe4, 0x48, 0x1f, 0xde, + 0x8f, 0x70, 0xb9, 0x14, 0xd3, 0xbf, 0x5e, 0x92, 0x6b, 0x06, 0xc1, 0xcd, 0xed, 0xbd, 0xc7, 0xf7, + 0xf3, 0xf9, 0x1e, 0x07, 0x67, 0xa8, 0x2b, 0xf1, 0xbd, 0x2d, 0x6b, 0xb3, 0x55, 0x6d, 0x4d, 0x1b, + 0x6b, 0x9c, 0x21, 0x17, 0x0a, 0xe5, 0xbe, 0x6b, 0xfd, 0x46, 0xc7, 0x44, 0x59, 0x9b, 0xcb, 0x55, + 0x69, 0x94, 0x32, 0xda, 0x9f, 0x93, 0x27, 0x80, 0xf7, 0xbe, 0x11, 0x1b, 0x6e, 0xb9, 0x6a, 0xc9, + 0x3d, 0x84, 0xcd, 0x38, 0x45, 0x41, 0x3c, 0x4b, 0x97, 0x77, 0xd7, 0xf4, 0x97, 0xe3, 0x48, 0xbe, + 0x8a, 0xfe, 0x83, 0xcb, 0x4e, 0x6c, 0x38, 0xda, 0xfc, 0x08, 0x24, 0xcf, 0xb0, 0x7c, 0x19, 0x2a, + 0xfe, 0x6f, 0xba, 0x85, 0x30, 0x43, 0xcd, 0x6d, 0x4f, 0x4e, 0x61, 0xf6, 0x25, 0xfa, 0x28, 0x88, + 0x83, 0x74, 0x91, 0x0f, 0x23, 0x39, 0x87, 0xf9, 0x7e, 0x00, 0xa2, 0x93, 0x38, 0x48, 0x57, 0xb9, + 0x5f, 0x92, 0x07, 0x58, 0x78, 0xe2, 0x4d, 0x38, 0xb2, 0x86, 0x79, 0xc5, 0x1d, 0x9f, 0x8a, 0xaf, + 0xe8, 0x9f, 0xdf, 0x40, 0x3d, 0x90, 0xfb, 0x6c, 0xf6, 0xf8, 0x99, 0xd5, 0xe8, 0x76, 0x5d, 0x31, + 0xbc, 0x8c, 0x1d, 0x50, 0x4a, 0x3c, 0x38, 0x51, 0xee, 0x98, 0x87, 0x6f, 0x2a, 0x6c, 0x9d, 0xc5, + 0xa2, 0x73, 0xa2, 0x62, 0xa8, 0x9d, 0xb0, 0x9a, 0x4b, 0x36, 0x1a, 0xd9, 0x64, 0x6c, 0x8a, 0x22, + 0x1c, 0x2f, 0xeb, 0x9f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xb4, 0xb0, 0x70, 0x01, 0x8f, 0x01, 0x00, + 0x00, +} diff --git a/scripts/proto_gen_go.sh b/scripts/proto_gen_go.sh index 9610d10a8f..3daa743a04 100755 --- a/scripts/proto_gen_go.sh +++ b/scripts/proto_gen_go.sh @@ -24,6 +24,7 @@ mkdir -p internalpb mkdir -p servicepb mkdir -p masterpb mkdir -p indexbuilderpb +mkdir -p indexcgopb mkdir -p writerpb ${protoc} --go_out=plugins=grpc,paths=source_relative:./commonpb common.proto @@ -34,6 +35,7 @@ ${protoc} --go_out=plugins=grpc,paths=source_relative:./servicepb service_msg.pr ${protoc} --go_out=plugins=grpc,paths=source_relative:./servicepb service.proto ${protoc} --go_out=plugins=grpc,paths=source_relative:./masterpb master.proto ${protoc} --go_out=plugins=grpc,paths=source_relative:./indexbuilderpb index_builder.proto +${protoc} --go_out=plugins=grpc,paths=source_relative:./indexcgopb index_cgo_msg.proto ${protoc} --go_out=plugins=grpc,paths=source_relative:./writerpb write_node.proto popd