From 18a56c9b5d43ef4f9ed597315bf250ac8be2ec60 Mon Sep 17 00:00:00 2001 From: neza2017 Date: Wed, 2 Sep 2020 20:05:02 +0800 Subject: [PATCH] Add build.sh for core Signed-off-by: neza2017 --- core/build.sh | 6 +- proxy/src/CMakeLists.txt | 1 + proxy/src/main.cpp | 3 +- proxy/src/pulsar/CMakeLists.txt | 2 + .../src/pulsar/message_client/CMakeLists.txt | 15 + proxy/src/pulsar/message_client/Client.cpp | 11 + proxy/src/pulsar/message_client/Client.h | 24 + proxy/src/pulsar/message_client/Consumer.cpp | 66 + proxy/src/pulsar/message_client/Consumer.h | 41 + proxy/src/pulsar/message_client/Producer.cpp | 27 + proxy/src/pulsar/message_client/Producer.h | 29 + proxy/src/pulsar/message_client/pb/build.sh | 3 + .../src/pulsar/message_client/pb/milvus.proto | 744 ++ .../src/pulsar/message_client/pb/pulsar.pb.cc | 5961 +++++++++++++++++ .../src/pulsar/message_client/pb/pulsar.pb.h | 4013 +++++++++++ .../src/pulsar/message_client/pb/pulsar.proto | 157 + proxy/src/pulsar/unittest/CMakeLists.txt | 14 + proxy/src/pulsar/unittest/consumer_test.cpp | 14 + proxy/src/pulsar/unittest/producer_test.cpp | 15 + proxy/src/pulsar/unittest/unittest_entry.cpp | 6 + proxy/src/test/CMakeLists.txt | 26 + proxy/src/test/test_pulsar.cpp | 71 + proxy/thirdparty/avro/CMakeLists.txt | 56 + proxy/thirdparty/pulsar/CMakeLists.txt | 7 +- 24 files changed, 11306 insertions(+), 6 deletions(-) create mode 100644 proxy/src/pulsar/CMakeLists.txt create mode 100644 proxy/src/pulsar/message_client/CMakeLists.txt create mode 100644 proxy/src/pulsar/message_client/Client.cpp create mode 100644 proxy/src/pulsar/message_client/Client.h create mode 100644 proxy/src/pulsar/message_client/Consumer.cpp create mode 100644 proxy/src/pulsar/message_client/Consumer.h create mode 100644 proxy/src/pulsar/message_client/Producer.cpp create mode 100644 proxy/src/pulsar/message_client/Producer.h create mode 100755 proxy/src/pulsar/message_client/pb/build.sh create mode 100644 proxy/src/pulsar/message_client/pb/milvus.proto create mode 100644 proxy/src/pulsar/message_client/pb/pulsar.pb.cc create mode 100644 proxy/src/pulsar/message_client/pb/pulsar.pb.h create mode 100644 proxy/src/pulsar/message_client/pb/pulsar.proto create mode 100644 proxy/src/pulsar/unittest/CMakeLists.txt create mode 100644 proxy/src/pulsar/unittest/consumer_test.cpp create mode 100644 proxy/src/pulsar/unittest/producer_test.cpp create mode 100644 proxy/src/pulsar/unittest/unittest_entry.cpp create mode 100644 proxy/src/test/CMakeLists.txt create mode 100644 proxy/src/test/test_pulsar.cpp create mode 100644 proxy/thirdparty/avro/CMakeLists.txt diff --git a/core/build.sh b/core/build.sh index 376c65efe1..c731f07a03 100755 --- a/core/build.sh +++ b/core/build.sh @@ -1,8 +1,8 @@ -if [[ -d "./build" ]] -then +#!/bin/bash +if [[ -d "./build" ]]; then rm -rf build fi mkdir build && cd build cmake .. -make -j8 && make install \ No newline at end of file +make -j8 && make install diff --git a/proxy/src/CMakeLists.txt b/proxy/src/CMakeLists.txt index 4df65b52dc..d7b49b93ee 100644 --- a/proxy/src/CMakeLists.txt +++ b/proxy/src/CMakeLists.txt @@ -25,6 +25,7 @@ add_subdirectory( query ) add_subdirectory( db ) # target milvus_engine add_subdirectory( log ) add_subdirectory( server ) +add_subdirectory( pulsar ) set(link_lib milvus_engine diff --git a/proxy/src/main.cpp b/proxy/src/main.cpp index d231d80563..f609ebaf89 100644 --- a/proxy/src/main.cpp +++ b/proxy/src/main.cpp @@ -21,11 +21,10 @@ #include "src/version.h" #include "utils/SignalHandler.h" #include "utils/Status.h" -#include "pulsar/Client.h" +#include "pulsar/message_client/Client.h" INITIALIZE_EASYLOGGINGPP -auto c = pulsar::Client("12"); void print_help(const std::string& app_name) { diff --git a/proxy/src/pulsar/CMakeLists.txt b/proxy/src/pulsar/CMakeLists.txt new file mode 100644 index 0000000000..2f3c0cf761 --- /dev/null +++ b/proxy/src/pulsar/CMakeLists.txt @@ -0,0 +1,2 @@ +add_subdirectory(message_client) +#add_subdirectory(unittest) diff --git a/proxy/src/pulsar/message_client/CMakeLists.txt b/proxy/src/pulsar/message_client/CMakeLists.txt new file mode 100644 index 0000000000..38909784b8 --- /dev/null +++ b/proxy/src/pulsar/message_client/CMakeLists.txt @@ -0,0 +1,15 @@ +set(src-cpp + Client.cpp + Consumer.cpp + Producer.cpp + pb/pulsar.pb.cc) + +add_library(message_client_cpp SHARED + ${src-cpp} + ) +target_include_directories(message_client_cpp PUBLIC ${PROJECT_BINARY_DIR}/thirdparty/pulsar/pulsar-src/pulsar-client-cpp/include) + +target_link_libraries(message_client_cpp pulsarStatic libprotobuf) + +#install(TARGETS message_client_cpp +# DESTINATION lib) \ No newline at end of file diff --git a/proxy/src/pulsar/message_client/Client.cpp b/proxy/src/pulsar/message_client/Client.cpp new file mode 100644 index 0000000000..5aec7bba1c --- /dev/null +++ b/proxy/src/pulsar/message_client/Client.cpp @@ -0,0 +1,11 @@ + +#include "Client.h" + +namespace message_client { + +MsgClient::MsgClient(const std::string &serviceUrl) : pulsar::Client(serviceUrl) {} + +MsgClient::MsgClient(const std::string &serviceUrl, const pulsar::ClientConfiguration& clientConfiguration) + : pulsar::Client(serviceUrl, clientConfiguration) {} + +} \ No newline at end of file diff --git a/proxy/src/pulsar/message_client/Client.h b/proxy/src/pulsar/message_client/Client.h new file mode 100644 index 0000000000..ef51dbf4c4 --- /dev/null +++ b/proxy/src/pulsar/message_client/Client.h @@ -0,0 +1,24 @@ +#pragma once + +#include "pulsar/Client.h" +#include "pulsar/ClientConfiguration.h" + +namespace message_client { + +using Result = pulsar::Result; +using Message = pulsar::Message; + +class MsgClient : public pulsar::Client{ +public: + MsgClient(const std::string& serviceUrl); + MsgClient(const std::string& serviceUrl, const pulsar::ClientConfiguration& clientConfiguration); + + void set_client_id(int64_t id) { client_id_ = id; } + + int64_t get_client_id() { return client_id_; } + +private: + int64_t client_id_; +}; + +} diff --git a/proxy/src/pulsar/message_client/Consumer.cpp b/proxy/src/pulsar/message_client/Consumer.cpp new file mode 100644 index 0000000000..651a816423 --- /dev/null +++ b/proxy/src/pulsar/message_client/Consumer.cpp @@ -0,0 +1,66 @@ + +#include "Consumer.h" +#include "pb/pulsar.pb.h" + +namespace message_client { + +MsgConsumer::MsgConsumer(std::shared_ptr &client, std::string subscription_name, const ConsumerConfiguration conf) + :client_(client), config_(conf), subscription_name_(subscription_name){} + +Result MsgConsumer::subscribe(const std::string &topic) { + return client_->subscribe(topic, subscription_name_, config_, consumer_); +} + +Result MsgConsumer::subscribe(const std::vector &topics) { + return client_->subscribe(topics, subscription_name_, config_, consumer_); +} + +Result MsgConsumer::unsubscribe() { + return consumer_.unsubscribe(); +} + +Result MsgConsumer::receive(Message &msg) { + return consumer_.receive(msg); +} + +std::shared_ptr MsgConsumer::receive_proto(ConsumerType consumer_type) { + Message msg; + receive(msg); + acknowledge(msg); + switch (consumer_type) { + case INSERT: { + pb::InsertMsg insert_msg; + insert_msg.ParseFromString(msg.getDataAsString()); + auto message = std::make_shared(insert_msg); + return std::shared_ptr(message); + } + case DELETE: { + pb::DeleteMsg delete_msg; + delete_msg.ParseFromString(msg.getDataAsString()); + auto message = std::make_shared(delete_msg); + return std::shared_ptr(message); + } + case SEARCH_RESULT: { + pb::SearchResultMsg search_res_msg; + search_res_msg.ParseFromString(msg.getDataAsString()); + auto message = std::make_shared(search_res_msg); + return std::shared_ptr(message); + } + case TEST: + pb::TestData test_msg; + test_msg.ParseFromString(msg.getDataAsString()); + auto message = std::make_shared(test_msg); + return std::shared_ptr(message); + } + return nullptr; +} + +Result MsgConsumer::close() { + return consumer_.close(); +} + +Result MsgConsumer::acknowledge(const Message &message) { + return consumer_.acknowledge(message); +} + +} diff --git a/proxy/src/pulsar/message_client/Consumer.h b/proxy/src/pulsar/message_client/Consumer.h new file mode 100644 index 0000000000..0c1ecbf477 --- /dev/null +++ b/proxy/src/pulsar/message_client/Consumer.h @@ -0,0 +1,41 @@ +#pragma once + +#include "pulsar/Consumer.h" +#include "Client.h" + +namespace message_client { + +enum ConsumerType { + INSERT = 0, + DELETE = 1, + SEARCH_RESULT = 2, + TEST = 3, +}; + +using Consumer = pulsar::Consumer; +using ConsumerConfiguration = pulsar::ConsumerConfiguration; + +class MsgConsumer{ +public: + MsgConsumer(std::shared_ptr &client, std::string consumer_name, + const pulsar::ConsumerConfiguration conf = ConsumerConfiguration()); + + Result subscribe(const std::string& topic); + Result subscribe(const std::vector& topics); + Result unsubscribe(); + Result receive(Message& msg); + std::shared_ptr receive_proto(ConsumerType consumer_type); + Result acknowledge(const Message& message); + Result close(); + + const Consumer& + consumer() const {return consumer_; } + +private: + Consumer consumer_; + std::shared_ptr client_; + ConsumerConfiguration config_; + std::string subscription_name_; +}; + +} \ No newline at end of file diff --git a/proxy/src/pulsar/message_client/Producer.cpp b/proxy/src/pulsar/message_client/Producer.cpp new file mode 100644 index 0000000000..a4c6275bfc --- /dev/null +++ b/proxy/src/pulsar/message_client/Producer.cpp @@ -0,0 +1,27 @@ + +#include "Producer.h" + +namespace message_client { + +MsgProducer::MsgProducer(std::shared_ptr &client, const std::string &topic, const ProducerConfiguration conf) : client_(client), config_(conf){ + createProducer(topic); +} + +Result MsgProducer::createProducer(const std::string &topic) { + return client_->createProducer(topic, producer_); +} + +Result MsgProducer::send(const Message &msg) { + return producer_.send(msg); +} + +Result MsgProducer::send(const std::string &msg) { + auto pulsar_msg = pulsar::MessageBuilder().setContent(msg).build(); + return send(pulsar_msg); +} + +Result MsgProducer::close() { + return producer_.close(); +} + +} \ No newline at end of file diff --git a/proxy/src/pulsar/message_client/Producer.h b/proxy/src/pulsar/message_client/Producer.h new file mode 100644 index 0000000000..8d3f4d21af --- /dev/null +++ b/proxy/src/pulsar/message_client/Producer.h @@ -0,0 +1,29 @@ +#pragma once + +#include "pulsar/Producer.h" +#include "Client.h" + +namespace message_client { + +using Producer = pulsar::Producer; +using ProducerConfiguration = pulsar::ProducerConfiguration; + +class MsgProducer{ +public: + MsgProducer(std::shared_ptr &client, const std::string &topic, const ProducerConfiguration conf = ProducerConfiguration()); + + Result createProducer(const std::string& topic); + Result send(const Message& msg); + Result send(const std::string& msg); + Result close(); + + const Producer& + producer() const { return producer_; } + +private: + Producer producer_; + std::shared_ptr client_; + ProducerConfiguration config_; +}; + +} \ No newline at end of file diff --git a/proxy/src/pulsar/message_client/pb/build.sh b/proxy/src/pulsar/message_client/pb/build.sh new file mode 100755 index 0000000000..1f52491d1a --- /dev/null +++ b/proxy/src/pulsar/message_client/pb/build.sh @@ -0,0 +1,3 @@ +#!/usr/bin/env bash + +../../../../cmake-build-debug/thirdparty/grpc/grpc-build/third_party/protobuf/protoc -I=./ --cpp_out=./ pulsar.proto \ No newline at end of file diff --git a/proxy/src/pulsar/message_client/pb/milvus.proto b/proxy/src/pulsar/message_client/pb/milvus.proto new file mode 100644 index 0000000000..6f58ae1fae --- /dev/null +++ b/proxy/src/pulsar/message_client/pb/milvus.proto @@ -0,0 +1,744 @@ +syntax = "proto3"; + +package pb; + +enum ErrorCode { + SUCCESS = 0; + UNEXPECTED_ERROR = 1; + CONNECT_FAILED = 2; + PERMISSION_DENIED = 3; + COLLECTION_NOT_EXISTS = 4; + ILLEGAL_ARGUMENT = 5; + ILLEGAL_DIMENSION = 7; + ILLEGAL_INDEX_TYPE = 8; + ILLEGAL_COLLECTION_NAME = 9; + ILLEGAL_TOPK = 10; + ILLEGAL_ROWRECORD = 11; + ILLEGAL_VECTOR_ID = 12; + ILLEGAL_SEARCH_RESULT = 13; + FILE_NOT_FOUND = 14; + META_FAILED = 15; + CACHE_FAILED = 16; + CANNOT_CREATE_FOLDER = 17; + CANNOT_CREATE_FILE = 18; + CANNOT_DELETE_FOLDER = 19; + CANNOT_DELETE_FILE = 20; + BUILD_INDEX_ERROR = 21; + ILLEGAL_NLIST = 22; + ILLEGAL_METRIC_TYPE = 23; + OUT_OF_MEMORY = 24; +} + +message Status { + ErrorCode error_code = 1; + string reason = 2; +} + +/** + * @brief Field data type + */ +enum DataType { + NONE = 0; + BOOL = 1; + INT8 = 2; + INT16 = 3; + INT32 = 4; + INT64 = 5; + + FLOAT = 10; + DOUBLE = 11; + + STRING = 20; + + VECTOR_BINARY = 100; + VECTOR_FLOAT = 101; +} + +/** + * @brief General usage + */ +message KeyValuePair { + string key = 1; + string value = 2; +} + +/** + * @brief Collection name + */ +message CollectionName { + string collection_name = 1; +} + +/** + * @brief Collection name list + */ +message CollectionNameList { + Status status = 1; + repeated string collection_names = 2; +} + +/** + * @brief Field name + */ +message FieldName { + string collection_name = 1; + string field_name = 2; +} + +/** + * @brief Collection mapping + * @extra_params: key-value pair for extra parameters of the collection + * typically usage: + * extra_params["params"] = {segment_row_count: 1000000, auto_id: true} + * Note: + * the segment_row_count specify segment row count limit for merging + * the auto_id = true means entity id is auto-generated by milvus + */ +message Mapping { + Status status = 1; + string collection_name = 2; + repeated FieldParam fields = 3; + repeated KeyValuePair extra_params = 4; +} + +/** + * @brief Collection mapping list + */ +message MappingList { + Status status = 1; + repeated Mapping mapping_list = 2; +} + +/** + * @brief Parameters of partition + */ +message PartitionParam { + string collection_name = 1; + string tag = 2; +} + +/** + * @brief Partition list + */ +message PartitionList { + Status status = 1; + repeated string partition_tag_array = 2; +} + +/** + * @brief Vector row record + */ +message VectorRowRecord { + repeated float float_data = 1; //float vector data + bytes binary_data = 2; //binary vector data +} + +/** + * @brief Attribute record + */ +message AttrRecord { + repeated int32 int32_value = 1; + repeated int64 int64_value = 2; + repeated float float_value = 3; + repeated double double_value = 4; +} + +/** + * @brief Vector records + */ +message VectorRecord { + repeated VectorRowRecord records = 1; +} + +/** + * @brief Field values + */ +message FieldValue { + string field_name = 1; + DataType type = 2; + AttrRecord attr_record = 3; + VectorRecord vector_record = 4; +} + +/** + * @brief Parameters for insert action + */ +message InsertParam { + string collection_name = 1; + repeated FieldValue fields = 2; + repeated int64 entity_id_array = 3; //optional + string partition_tag = 4; + repeated KeyValuePair extra_params = 5; +} + +/** + * @brief Entity ids + */ +message EntityIds { + Status status = 1; + repeated int64 entity_id_array = 2; +} + +/** + * @brief Search vector parameters + */ +message VectorParam { + string json = 1; + VectorRecord row_record = 2; +} + +/** + * @brief Parameters for search action + * @dsl example: + * { + * "query": { + * "bool": { + * "must": [ + * { + * "must":[ + * { + * "should": [ + * { + * "term": { + * "gender": ["male"] + * } + * }, + * { + * "range": { + * "height": {"gte": "170.0", "lte": "180.0"} + * } + * } + * ] + * }, + * { + * "must_not": [ + * { + * "term": { + * "age": [20, 21, 22, 23, 24, 25] + * } + * }, + * { + * "Range": { + * "weight": {"lte": "100"} + * } + * } + * ] + * } + * ] + * }, + * { + * "must": [ + * { + * "vector": { + * "face_img": { + * "topk": 10, + * "metric_type": "L2", + * "query": [], + * "params": { + * "nprobe": 10 + * } + * } + * } + * } + * ] + * } + * ] + * } + * }, + * "fields": ["age", "face_img"] + * } + */ +message SearchParam { + string collection_name = 1; + repeated string partition_tag_array = 2; + repeated VectorParam vector_param = 3; + string dsl = 4; + repeated KeyValuePair extra_params = 5; +} + +/** + * @brief Parameters for searching in segments + */ +message SearchInSegmentParam { + repeated string file_id_array = 1; + SearchParam search_param = 2; +} + +/** + * @brief Entities + */ +message Entities { + Status status = 1; + repeated int64 ids = 2; + repeated bool valid_row = 3; + repeated FieldValue fields = 4; +} + +/** + * @brief Query result + */ +message QueryResult { + Status status = 1; + Entities entities = 2; + int64 row_num = 3; + repeated float scores = 4; + repeated float distances = 5; + repeated KeyValuePair extra_params = 6; +} + +/** + * @brief Server string Reply + */ +message StringReply { + Status status = 1; + string string_reply = 2; +} + +/** + * @brief Server bool Reply + */ +message BoolReply { + Status status = 1; + bool bool_reply = 2; +} + +/** + * @brief Return collection row count + */ +message CollectionRowCount { + Status status = 1; + int64 collection_row_count = 2; +} + +/** + * @brief Server command parameters + */ +message Command { + string cmd = 1; +} + +/** + * @brief Index params + * @collection_name: target collection + * @field_name: target field + * @index_name: a name for index provided by user, unique within this field + * @extra_params: index parameters in json format + * for vector field: + * extra_params["index_type"] = one of the values: FLAT, IVF_LAT, IVF_SQ8, NSGMIX, IVFSQ8H, + * PQ, HNSW, HNSW_SQ8NM, ANNOY + * extra_params["metric_type"] = one of the values: L2, IP, HAMMING, JACCARD, TANIMOTO + * SUBSTRUCTURE, SUPERSTRUCTURE + * extra_params["params"] = extra parameters for index, for example ivflat: {nlist: 2048} + * for structured field: + * extra_params["index_type"] = one of the values: SORTED + */ +message IndexParam { + Status status = 1; + string collection_name = 2; + string field_name = 3; + string index_name = 4; + repeated KeyValuePair extra_params = 5; +} + +/** + * @brief Parameters for flush action + */ +message FlushParam { + repeated string collection_name_array = 1; +} + +/** + * @brief Parameters for flush action + */ +message CompactParam { + string collection_name = 1; + double threshold = 2; +} + +/** + * @brief Parameters for deleting entities by id + */ +message DeleteByIDParam { + string collection_name = 1; + repeated int64 id_array = 2; +} + +/** + * @brief Return collection stats + * @json_info: collection stats in json format, typically, the format is like: + * { + * row_count: xxx, + * data_size: xxx, + * partitions: [ + * { + * tag: xxx, + * id: xxx, + * row_count: xxx, + * data_size: xxx, + * segments: [ + * { + * id: xxx, + * row_count: xxx, + * data_size: xxx, + * files: [ + * { + * field: xxx, + * name: xxx, + * index_type: xxx, + * path: xxx, + * data_size: xxx, + * } + * ] + * } + * ] + * } + * ] + * } + */ +message CollectionInfo { + Status status = 1; + string json_info = 2; +} + +/** + * @brief Parameters for returning entities id of a segment + */ +message GetEntityIDsParam { + string collection_name = 1; + int64 segment_id = 2; +} + +/** + * @brief Entities identity + */ +message EntityIdentity { + string collection_name = 1; + repeated int64 id_array = 2; + repeated string field_names = 3; +} + +/********************************************SearchPB interface***************************************************/ +/** + * @brief Vector field parameters + */ +message VectorFieldParam { + int64 dimension = 1; +} + +/** + * @brief Field type + */ +message FieldType { + oneof value { + DataType data_type = 1; + VectorFieldParam vector_param = 2; + } +} + +/** + * @brief Field parameters + */ +message FieldParam { + uint64 id = 1; + string name = 2; + DataType type = 3; + repeated KeyValuePair index_params = 4; + repeated KeyValuePair extra_params = 5; +} + +/** + * @brief Vector field record + */ +message VectorFieldRecord { + repeated VectorRowRecord value = 1; +} + +/////////////////////////////////////////////////////////////////// + +message TermQuery { + string field_name = 1; + repeated int64 int_value = 2; + repeated double double_value = 3; + int64 value_num = 4; + float boost = 5; + repeated KeyValuePair extra_params = 6; +} + +enum CompareOperator { + LT = 0; + LTE = 1; + EQ = 2; + GT = 3; + GTE = 4; + NE = 5; +} + +message CompareExpr { + CompareOperator operator = 1; + string operand = 2; +} + +message RangeQuery { + string field_name = 1; + repeated CompareExpr operand = 2; + float boost = 3; + repeated KeyValuePair extra_params = 4; +} + +message VectorQuery { + string field_name = 1; + float query_boost = 2; + repeated VectorRowRecord records = 3; + int64 topk = 4; + repeated KeyValuePair extra_params = 5; +} + +enum Occur { + INVALID = 0; + MUST = 1; + SHOULD = 2; + MUST_NOT = 3; +} + +message BooleanQuery { + Occur occur = 1; + repeated GeneralQuery general_query = 2; +} + +message GeneralQuery { + oneof query { + BooleanQuery boolean_query = 1; + TermQuery term_query = 2; + RangeQuery range_query = 3; + VectorQuery vector_query = 4; + } +} + +message SearchParamPB { + string collection_name = 1; + repeated string partition_tag_array = 2; + GeneralQuery general_query = 3; + repeated KeyValuePair extra_params = 4; +} + +service MilvusService { + /** + * @brief This method is used to create collection + * + * @param CollectionSchema, use to provide collection information to be created. + * + * @return Status + */ + rpc CreateCollection(Mapping) returns (Status){} + + /** + * @brief This method is used to test collection existence. + * + * @param CollectionName, collection name is going to be tested. + * + * @return BoolReply + */ + rpc HasCollection(CollectionName) returns (BoolReply) {} + + /** + * @brief This method is used to get collection schema. + * + * @param CollectionName, target collection name. + * + * @return CollectionSchema + */ + rpc DescribeCollection(CollectionName) returns (Mapping) {} + + /** + * @brief This method is used to get collection schema. + * + * @param CollectionName, target collection name. + * + * @return CollectionRowCount + */ + rpc CountCollection(CollectionName) returns (CollectionRowCount) {} + + /** + * @brief This method is used to list all collections. + * + * @param Command, dummy parameter. + * + * @return CollectionNameList + */ + rpc ShowCollections(Command) returns (CollectionNameList) {} + + /** + * @brief This method is used to get collection detail information. + * + * @param CollectionName, target collection name. + * + * @return CollectionInfo + */ + rpc ShowCollectionInfo(CollectionName) returns (CollectionInfo) {} + + /** + * @brief This method is used to delete collection. + * + * @param CollectionName, collection name is going to be deleted. + * + * @return Status + */ + rpc DropCollection(CollectionName) returns (Status) {} + + /** + * @brief This method is used to build index by collection in sync mode. + * + * @param IndexParam, index paramters. + * + * @return Status + */ + rpc CreateIndex(IndexParam) returns (Status) {} + + /** + * @brief This method is used to describe index + * + * @param IndexParam, target index. + * + * @return IndexParam + */ + rpc DescribeIndex(IndexParam) returns (IndexParam) {} + + /** + * @brief This method is used to drop index + * + * @param IndexParam, target field. if the IndexParam.field_name is empty, will drop all index of the collection + * + * @return Status + */ + rpc DropIndex(IndexParam) returns (Status) {} + + /** + * @brief This method is used to create partition + * + * @param PartitionParam, partition parameters. + * + * @return Status + */ + rpc CreatePartition(PartitionParam) returns (Status) {} + + /** + * @brief This method is used to test partition existence. + * + * @param PartitionParam, target partition. + * + * @return BoolReply + */ + rpc HasPartition(PartitionParam) returns (BoolReply) {} + + /** + * @brief This method is used to show partition information + * + * @param CollectionName, target collection name. + * + * @return PartitionList + */ + rpc ShowPartitions(CollectionName) returns (PartitionList) {} + + /** + * @brief This method is used to drop partition + * + * @param PartitionParam, target partition. + * + * @return Status + */ + rpc DropPartition(PartitionParam) returns (Status) {} + + /** + * @brief This method is used to add vector array to collection. + * + * @param InsertParam, insert parameters. + * + * @return VectorIds + */ + rpc Insert(InsertParam) returns (EntityIds) {} + + /** + * @brief This method is used to get entities data by id array. + * + * @param EntitiesIdentity, target entity id array. + * + * @return EntitiesData + */ + rpc GetEntityByID(EntityIdentity) returns (Entities) {} + + /** + * @brief This method is used to get vector ids from a segment + * + * @param GetVectorIDsParam, target collection and segment + * + * @return VectorIds + */ + rpc GetEntityIDs(GetEntityIDsParam) returns (EntityIds) {} + + /** + * @brief This method is used to query vector in collection. + * + * @param SearchParam, search parameters. + * + * @return KQueryResult + */ + rpc Search(SearchParam) returns (QueryResult) {} + + /** + * @brief This method is used to query vector in specified files. + * + * @param SearchInSegmentParam, target segments to search. + * + * @return TopKQueryResult + */ + rpc SearchInSegment(SearchInSegmentParam) returns (QueryResult) {} + + /** + * @brief This method is used to give the server status. + * + * @param Command, command string + * + * @return StringReply + */ + rpc Cmd(Command) returns (StringReply) {} + + /** + * @brief This method is used to delete vector by id + * + * @param DeleteByIDParam, delete parameters. + * + * @return status + */ + rpc DeleteByID(DeleteByIDParam) returns (Status) {} + + /** + * @brief This method is used to preload collection + * + * @param CollectionName, target collection name. + * + * @return Status + */ + rpc PreloadCollection(CollectionName) returns (Status) {} + + /** + * @brief This method is used to flush buffer into storage. + * + * @param FlushParam, flush parameters + * + * @return Status + */ + rpc Flush(FlushParam) returns (Status) {} + + /** + * @brief This method is used to compact collection + * + * @param CompactParam, compact parameters + * + * @return Status + */ + rpc Compact(CompactParam) returns (Status) {} + + /********************************New Interface********************************************/ + + rpc SearchPB(SearchParamPB) returns (QueryResult) {} +} diff --git a/proxy/src/pulsar/message_client/pb/pulsar.pb.cc b/proxy/src/pulsar/message_client/pb/pulsar.pb.cc new file mode 100644 index 0000000000..bc31f78853 --- /dev/null +++ b/proxy/src/pulsar/message_client/pb/pulsar.pb.cc @@ -0,0 +1,5961 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: pulsar.proto + +#include "pulsar.pb.h" + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +// @@protoc_insertion_point(includes) +#include +extern PROTOBUF_INTERNAL_EXPORT_pulsar_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_AttrRecord_pulsar_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_pulsar_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_Cell_pulsar_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_pulsar_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_FieldValue_pulsar_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_pulsar_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_SegmentRecord_pulsar_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_pulsar_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_VectorParam_pulsar_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_pulsar_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_VectorRecord_pulsar_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_pulsar_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_VectorRowRecord_pulsar_2eproto; +namespace pb { +class StatusDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _Status_default_instance_; +class SegmentRecordDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _SegmentRecord_default_instance_; +class VectorRowRecordDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _VectorRowRecord_default_instance_; +class AttrRecordDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _AttrRecord_default_instance_; +class VectorRecordDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _VectorRecord_default_instance_; +class VectorParamDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _VectorParam_default_instance_; +class FieldValueDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _FieldValue_default_instance_; +class CellDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; + ::PROTOBUF_NAMESPACE_ID::int32 int32_value_; + ::PROTOBUF_NAMESPACE_ID::int64 int64_value_; + float float_value_; + double double_value_; +} _Cell_default_instance_; +class RowValueDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _RowValue_default_instance_; +class PulsarMessageDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _PulsarMessage_default_instance_; +class TestDataDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _TestData_default_instance_; +class InsertMsgDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _InsertMsg_default_instance_; +class DeleteMsgDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _DeleteMsg_default_instance_; +class SearchMsgDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _SearchMsg_default_instance_; +class SearchResultMsgDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _SearchResultMsg_default_instance_; +} // namespace pb +static void InitDefaultsscc_info_AttrRecord_pulsar_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::pb::_AttrRecord_default_instance_; + new (ptr) ::pb::AttrRecord(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::pb::AttrRecord::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_AttrRecord_pulsar_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_AttrRecord_pulsar_2eproto}, {}}; + +static void InitDefaultsscc_info_Cell_pulsar_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::pb::_Cell_default_instance_; + new (ptr) ::pb::Cell(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::pb::Cell::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_Cell_pulsar_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_Cell_pulsar_2eproto}, {}}; + +static void InitDefaultsscc_info_DeleteMsg_pulsar_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::pb::_DeleteMsg_default_instance_; + new (ptr) ::pb::DeleteMsg(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::pb::DeleteMsg::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_DeleteMsg_pulsar_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_DeleteMsg_pulsar_2eproto}, {}}; + +static void InitDefaultsscc_info_FieldValue_pulsar_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::pb::_FieldValue_default_instance_; + new (ptr) ::pb::FieldValue(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::pb::FieldValue::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_FieldValue_pulsar_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, InitDefaultsscc_info_FieldValue_pulsar_2eproto}, { + &scc_info_AttrRecord_pulsar_2eproto.base, + &scc_info_VectorRecord_pulsar_2eproto.base,}}; + +static void InitDefaultsscc_info_InsertMsg_pulsar_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::pb::_InsertMsg_default_instance_; + new (ptr) ::pb::InsertMsg(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::pb::InsertMsg::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_InsertMsg_pulsar_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_InsertMsg_pulsar_2eproto}, {}}; + +static void InitDefaultsscc_info_PulsarMessage_pulsar_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::pb::_PulsarMessage_default_instance_; + new (ptr) ::pb::PulsarMessage(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::pb::PulsarMessage::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<3> scc_info_PulsarMessage_pulsar_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 3, InitDefaultsscc_info_PulsarMessage_pulsar_2eproto}, { + &scc_info_FieldValue_pulsar_2eproto.base, + &scc_info_VectorParam_pulsar_2eproto.base, + &scc_info_SegmentRecord_pulsar_2eproto.base,}}; + +static void InitDefaultsscc_info_RowValue_pulsar_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::pb::_RowValue_default_instance_; + new (ptr) ::pb::RowValue(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::pb::RowValue::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_RowValue_pulsar_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, InitDefaultsscc_info_RowValue_pulsar_2eproto}, { + &scc_info_VectorRowRecord_pulsar_2eproto.base, + &scc_info_Cell_pulsar_2eproto.base,}}; + +static void InitDefaultsscc_info_SearchMsg_pulsar_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::pb::_SearchMsg_default_instance_; + new (ptr) ::pb::SearchMsg(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::pb::SearchMsg::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_SearchMsg_pulsar_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_SearchMsg_pulsar_2eproto}, {}}; + +static void InitDefaultsscc_info_SearchResultMsg_pulsar_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::pb::_SearchResultMsg_default_instance_; + new (ptr) ::pb::SearchResultMsg(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::pb::SearchResultMsg::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_SearchResultMsg_pulsar_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_SearchResultMsg_pulsar_2eproto}, {}}; + +static void InitDefaultsscc_info_SegmentRecord_pulsar_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::pb::_SegmentRecord_default_instance_; + new (ptr) ::pb::SegmentRecord(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::pb::SegmentRecord::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_SegmentRecord_pulsar_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_SegmentRecord_pulsar_2eproto}, {}}; + +static void InitDefaultsscc_info_Status_pulsar_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::pb::_Status_default_instance_; + new (ptr) ::pb::Status(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::pb::Status::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_Status_pulsar_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_Status_pulsar_2eproto}, {}}; + +static void InitDefaultsscc_info_TestData_pulsar_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::pb::_TestData_default_instance_; + new (ptr) ::pb::TestData(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::pb::TestData::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_TestData_pulsar_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_TestData_pulsar_2eproto}, {}}; + +static void InitDefaultsscc_info_VectorParam_pulsar_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::pb::_VectorParam_default_instance_; + new (ptr) ::pb::VectorParam(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::pb::VectorParam::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_VectorParam_pulsar_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_VectorParam_pulsar_2eproto}, { + &scc_info_VectorRecord_pulsar_2eproto.base,}}; + +static void InitDefaultsscc_info_VectorRecord_pulsar_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::pb::_VectorRecord_default_instance_; + new (ptr) ::pb::VectorRecord(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::pb::VectorRecord::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_VectorRecord_pulsar_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_VectorRecord_pulsar_2eproto}, { + &scc_info_VectorRowRecord_pulsar_2eproto.base,}}; + +static void InitDefaultsscc_info_VectorRowRecord_pulsar_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::pb::_VectorRowRecord_default_instance_; + new (ptr) ::pb::VectorRowRecord(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::pb::VectorRowRecord::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_VectorRowRecord_pulsar_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_VectorRowRecord_pulsar_2eproto}, {}}; + +static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_pulsar_2eproto[15]; +static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_pulsar_2eproto[3]; +static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_pulsar_2eproto = nullptr; + +const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_pulsar_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::pb::Status, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::pb::Status, error_code_), + PROTOBUF_FIELD_OFFSET(::pb::Status, reason_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::pb::SegmentRecord, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::pb::SegmentRecord, seg_info_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::pb::VectorRowRecord, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::pb::VectorRowRecord, float_data_), + PROTOBUF_FIELD_OFFSET(::pb::VectorRowRecord, binary_data_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::pb::AttrRecord, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::pb::AttrRecord, int32_value_), + PROTOBUF_FIELD_OFFSET(::pb::AttrRecord, int64_value_), + PROTOBUF_FIELD_OFFSET(::pb::AttrRecord, float_value_), + PROTOBUF_FIELD_OFFSET(::pb::AttrRecord, double_value_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::pb::VectorRecord, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::pb::VectorRecord, records_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::pb::VectorParam, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::pb::VectorParam, json_), + PROTOBUF_FIELD_OFFSET(::pb::VectorParam, row_record_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::pb::FieldValue, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::pb::FieldValue, field_name_), + PROTOBUF_FIELD_OFFSET(::pb::FieldValue, type_), + PROTOBUF_FIELD_OFFSET(::pb::FieldValue, attr_record_), + PROTOBUF_FIELD_OFFSET(::pb::FieldValue, vector_record_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::pb::Cell, _internal_metadata_), + ~0u, // no _extensions_ + PROTOBUF_FIELD_OFFSET(::pb::Cell, _oneof_case_[0]), + ~0u, // no _weak_field_map_ + offsetof(::pb::CellDefaultTypeInternal, int32_value_), + offsetof(::pb::CellDefaultTypeInternal, int64_value_), + offsetof(::pb::CellDefaultTypeInternal, float_value_), + offsetof(::pb::CellDefaultTypeInternal, double_value_), + PROTOBUF_FIELD_OFFSET(::pb::Cell, value_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::pb::RowValue, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::pb::RowValue, vec_), + PROTOBUF_FIELD_OFFSET(::pb::RowValue, cell_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::pb::PulsarMessage, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::pb::PulsarMessage, collection_name_), + PROTOBUF_FIELD_OFFSET(::pb::PulsarMessage, fields_), + PROTOBUF_FIELD_OFFSET(::pb::PulsarMessage, entity_id_), + PROTOBUF_FIELD_OFFSET(::pb::PulsarMessage, partition_tag_), + PROTOBUF_FIELD_OFFSET(::pb::PulsarMessage, vector_param_), + PROTOBUF_FIELD_OFFSET(::pb::PulsarMessage, segments_), + PROTOBUF_FIELD_OFFSET(::pb::PulsarMessage, timestamp_), + PROTOBUF_FIELD_OFFSET(::pb::PulsarMessage, client_id_), + PROTOBUF_FIELD_OFFSET(::pb::PulsarMessage, msg_type_), + PROTOBUF_FIELD_OFFSET(::pb::PulsarMessage, topic_name_), + PROTOBUF_FIELD_OFFSET(::pb::PulsarMessage, partition_id_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::pb::TestData, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::pb::TestData, id_), + PROTOBUF_FIELD_OFFSET(::pb::TestData, name_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::pb::InsertMsg, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::pb::InsertMsg, client_id_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::pb::DeleteMsg, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::pb::DeleteMsg, client_id_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::pb::SearchMsg, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::pb::SearchMsg, client_id_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::pb::SearchResultMsg, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::pb::SearchResultMsg, client_id_), +}; +static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { + { 0, -1, sizeof(::pb::Status)}, + { 7, -1, sizeof(::pb::SegmentRecord)}, + { 13, -1, sizeof(::pb::VectorRowRecord)}, + { 20, -1, sizeof(::pb::AttrRecord)}, + { 29, -1, sizeof(::pb::VectorRecord)}, + { 35, -1, sizeof(::pb::VectorParam)}, + { 42, -1, sizeof(::pb::FieldValue)}, + { 51, -1, sizeof(::pb::Cell)}, + { 61, -1, sizeof(::pb::RowValue)}, + { 68, -1, sizeof(::pb::PulsarMessage)}, + { 84, -1, sizeof(::pb::TestData)}, + { 91, -1, sizeof(::pb::InsertMsg)}, + { 97, -1, sizeof(::pb::DeleteMsg)}, + { 103, -1, sizeof(::pb::SearchMsg)}, + { 109, -1, sizeof(::pb::SearchResultMsg)}, +}; + +static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { + reinterpret_cast(&::pb::_Status_default_instance_), + reinterpret_cast(&::pb::_SegmentRecord_default_instance_), + reinterpret_cast(&::pb::_VectorRowRecord_default_instance_), + reinterpret_cast(&::pb::_AttrRecord_default_instance_), + reinterpret_cast(&::pb::_VectorRecord_default_instance_), + reinterpret_cast(&::pb::_VectorParam_default_instance_), + reinterpret_cast(&::pb::_FieldValue_default_instance_), + reinterpret_cast(&::pb::_Cell_default_instance_), + reinterpret_cast(&::pb::_RowValue_default_instance_), + reinterpret_cast(&::pb::_PulsarMessage_default_instance_), + reinterpret_cast(&::pb::_TestData_default_instance_), + reinterpret_cast(&::pb::_InsertMsg_default_instance_), + reinterpret_cast(&::pb::_DeleteMsg_default_instance_), + reinterpret_cast(&::pb::_SearchMsg_default_instance_), + reinterpret_cast(&::pb::_SearchResultMsg_default_instance_), +}; + +const char descriptor_table_protodef_pulsar_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = + "\n\014pulsar.proto\022\002pb\";\n\006Status\022!\n\nerror_co" + "de\030\001 \001(\0162\r.pb.ErrorCode\022\016\n\006reason\030\002 \001(\t\"" + "!\n\rSegmentRecord\022\020\n\010seg_info\030\001 \003(\t\":\n\017Ve" + "ctorRowRecord\022\022\n\nfloat_data\030\001 \003(\002\022\023\n\013bin" + "ary_data\030\002 \001(\014\"a\n\nAttrRecord\022\023\n\013int32_va" + "lue\030\001 \003(\005\022\023\n\013int64_value\030\002 \003(\003\022\023\n\013float_" + "value\030\003 \003(\002\022\024\n\014double_value\030\004 \003(\001\"4\n\014Vec" + "torRecord\022$\n\007records\030\001 \003(\0132\023.pb.VectorRo" + "wRecord\"A\n\013VectorParam\022\014\n\004json\030\001 \001(\t\022$\n\n" + "row_record\030\002 \001(\0132\020.pb.VectorRecord\"\212\001\n\nF" + "ieldValue\022\022\n\nfield_name\030\001 \001(\t\022\032\n\004type\030\002 " + "\001(\0162\014.pb.DataType\022#\n\013attr_record\030\003 \001(\0132\016" + ".pb.AttrRecord\022\'\n\rvector_record\030\004 \001(\0132\020." + "pb.VectorRecord\"l\n\004Cell\022\025\n\013int32_value\030\001" + " \001(\005H\000\022\025\n\013int64_value\030\002 \001(\003H\000\022\025\n\013float_v" + "alue\030\003 \001(\002H\000\022\026\n\014double_value\030\004 \001(\001H\000B\007\n\005" + "value\"D\n\010RowValue\022 \n\003vec\030\001 \001(\0132\023.pb.Vect" + "orRowRecord\022\026\n\004cell\030\002 \003(\0132\010.pb.Cell\"\254\002\n\r" + "PulsarMessage\022\027\n\017collection_name\030\001 \001(\t\022\036" + "\n\006fields\030\002 \003(\0132\016.pb.FieldValue\022\021\n\tentity" + "_id\030\003 \001(\003\022\025\n\rpartition_tag\030\004 \001(\t\022%\n\014vect" + "or_param\030\005 \001(\0132\017.pb.VectorParam\022#\n\010segme" + "nts\030\006 \001(\0132\021.pb.SegmentRecord\022\021\n\ttimestam" + "p\030\007 \001(\003\022\021\n\tclient_id\030\010 \001(\003\022\034\n\010msg_type\030\t" + " \001(\0162\n.pb.OpType\022\022\n\ntopic_name\030\n \001(\t\022\024\n\014" + "partition_id\030\013 \001(\003\"$\n\010TestData\022\n\n\002id\030\001 \001" + "(\t\022\014\n\004name\030\002 \001(\t\"\036\n\tInsertMsg\022\021\n\tclient_" + "id\030\001 \001(\003\"\036\n\tDeleteMsg\022\021\n\tclient_id\030\001 \001(\003" + "\"\036\n\tSearchMsg\022\021\n\tclient_id\030\001 \001(\003\"$\n\017Sear" + "chResultMsg\022\021\n\tclient_id\030\001 \001(\003*\242\004\n\tError" + "Code\022\013\n\007SUCCESS\020\000\022\024\n\020UNEXPECTED_ERROR\020\001\022" + "\022\n\016CONNECT_FAILED\020\002\022\025\n\021PERMISSION_DENIED" + "\020\003\022\031\n\025COLLECTION_NOT_EXISTS\020\004\022\024\n\020ILLEGAL" + "_ARGUMENT\020\005\022\025\n\021ILLEGAL_DIMENSION\020\007\022\026\n\022IL" + "LEGAL_INDEX_TYPE\020\010\022\033\n\027ILLEGAL_COLLECTION" + "_NAME\020\t\022\020\n\014ILLEGAL_TOPK\020\n\022\025\n\021ILLEGAL_ROW" + "RECORD\020\013\022\025\n\021ILLEGAL_VECTOR_ID\020\014\022\031\n\025ILLEG" + "AL_SEARCH_RESULT\020\r\022\022\n\016FILE_NOT_FOUND\020\016\022\017" + "\n\013META_FAILED\020\017\022\020\n\014CACHE_FAILED\020\020\022\030\n\024CAN" + "NOT_CREATE_FOLDER\020\021\022\026\n\022CANNOT_CREATE_FIL" + "E\020\022\022\030\n\024CANNOT_DELETE_FOLDER\020\023\022\026\n\022CANNOT_" + "DELETE_FILE\020\024\022\025\n\021BUILD_INDEX_ERROR\020\025\022\021\n\r" + "ILLEGAL_NLIST\020\026\022\027\n\023ILLEGAL_METRIC_TYPE\020\027" + "\022\021\n\rOUT_OF_MEMORY\020\030*\221\001\n\010DataType\022\010\n\004NONE" + "\020\000\022\010\n\004BOOL\020\001\022\010\n\004INT8\020\002\022\t\n\005INT16\020\003\022\t\n\005INT" + "32\020\004\022\t\n\005INT64\020\005\022\t\n\005FLOAT\020\n\022\n\n\006DOUBLE\020\013\022\n" + "\n\006STRING\020\024\022\021\n\rVECTOR_BINARY\020d\022\020\n\014VECTOR_" + "FLOAT\020e*W\n\006OpType\022\n\n\006Insert\020\000\022\n\n\006Delete\020" + "\001\022\n\n\006Search\020\002\022\014\n\010TimeSync\020\003\022\013\n\007Key2Seg\020\004" + "\022\016\n\nStatistics\020\005b\006proto3" + ; +static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_pulsar_2eproto_deps[1] = { +}; +static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_pulsar_2eproto_sccs[15] = { + &scc_info_AttrRecord_pulsar_2eproto.base, + &scc_info_Cell_pulsar_2eproto.base, + &scc_info_DeleteMsg_pulsar_2eproto.base, + &scc_info_FieldValue_pulsar_2eproto.base, + &scc_info_InsertMsg_pulsar_2eproto.base, + &scc_info_PulsarMessage_pulsar_2eproto.base, + &scc_info_RowValue_pulsar_2eproto.base, + &scc_info_SearchMsg_pulsar_2eproto.base, + &scc_info_SearchResultMsg_pulsar_2eproto.base, + &scc_info_SegmentRecord_pulsar_2eproto.base, + &scc_info_Status_pulsar_2eproto.base, + &scc_info_TestData_pulsar_2eproto.base, + &scc_info_VectorParam_pulsar_2eproto.base, + &scc_info_VectorRecord_pulsar_2eproto.base, + &scc_info_VectorRowRecord_pulsar_2eproto.base, +}; +static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_pulsar_2eproto_once; +static bool descriptor_table_pulsar_2eproto_initialized = false; +const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_pulsar_2eproto = { + &descriptor_table_pulsar_2eproto_initialized, descriptor_table_protodef_pulsar_2eproto, "pulsar.proto", 1984, + &descriptor_table_pulsar_2eproto_once, descriptor_table_pulsar_2eproto_sccs, descriptor_table_pulsar_2eproto_deps, 15, 0, + schemas, file_default_instances, TableStruct_pulsar_2eproto::offsets, + file_level_metadata_pulsar_2eproto, 15, file_level_enum_descriptors_pulsar_2eproto, file_level_service_descriptors_pulsar_2eproto, +}; + +// Force running AddDescriptors() at dynamic initialization time. +static bool dynamic_init_dummy_pulsar_2eproto = ( ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptors(&descriptor_table_pulsar_2eproto), true); +namespace pb { +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ErrorCode_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pulsar_2eproto); + return file_level_enum_descriptors_pulsar_2eproto[0]; +} +bool ErrorCode_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + case 4: + case 5: + case 7: + case 8: + case 9: + case 10: + case 11: + case 12: + case 13: + case 14: + case 15: + case 16: + case 17: + case 18: + case 19: + case 20: + case 21: + case 22: + case 23: + case 24: + return true; + default: + return false; + } +} + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DataType_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pulsar_2eproto); + return file_level_enum_descriptors_pulsar_2eproto[1]; +} +bool DataType_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + case 4: + case 5: + case 10: + case 11: + case 20: + case 100: + case 101: + return true; + default: + return false; + } +} + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* OpType_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pulsar_2eproto); + return file_level_enum_descriptors_pulsar_2eproto[2]; +} +bool OpType_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + case 4: + case 5: + return true; + default: + return false; + } +} + + +// =================================================================== + +void Status::InitAsDefaultInstance() { +} +class Status::_Internal { + public: +}; + +Status::Status() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:pb.Status) +} +Status::Status(const Status& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + reason_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.reason().empty()) { + reason_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.reason_); + } + error_code_ = from.error_code_; + // @@protoc_insertion_point(copy_constructor:pb.Status) +} + +void Status::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Status_pulsar_2eproto.base); + reason_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + error_code_ = 0; +} + +Status::~Status() { + // @@protoc_insertion_point(destructor:pb.Status) + SharedDtor(); +} + +void Status::SharedDtor() { + reason_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void Status::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const Status& Status::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_Status_pulsar_2eproto.base); + return *internal_default_instance(); +} + + +void Status::Clear() { +// @@protoc_insertion_point(message_clear_start:pb.Status) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + reason_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + error_code_ = 0; + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* Status::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // .pb.ErrorCode error_code = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + set_error_code(static_cast<::pb::ErrorCode>(val)); + } else goto handle_unusual; + continue; + // string reason = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_reason(), ptr, ctx, "pb.Status.reason"); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool Status::MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + // @@protoc_insertion_point(parse_start:pb.Status) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // .pb.ErrorCode error_code = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) { + int value = 0; + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + int, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + set_error_code(static_cast< ::pb::ErrorCode >(value)); + } else { + goto handle_unusual; + } + break; + } + + // string reason = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_reason())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->reason().data(), static_cast(this->reason().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "pb.Status.reason")); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:pb.Status) + return true; +failure: + // @@protoc_insertion_point(parse_failure:pb.Status) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void Status::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:pb.Status) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .pb.ErrorCode error_code = 1; + if (this->error_code() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnum( + 1, this->error_code(), output); + } + + // string reason = 2; + if (this->reason().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->reason().data(), static_cast(this->reason().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "pb.Status.reason"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 2, this->reason(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:pb.Status) +} + +::PROTOBUF_NAMESPACE_ID::uint8* Status::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:pb.Status) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .pb.ErrorCode error_code = 1; + if (this->error_code() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 1, this->error_code(), target); + } + + // string reason = 2; + if (this->reason().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->reason().data(), static_cast(this->reason().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "pb.Status.reason"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 2, this->reason(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:pb.Status) + return target; +} + +size_t Status::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:pb.Status) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // string reason = 2; + if (this->reason().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->reason()); + } + + // .pb.ErrorCode error_code = 1; + if (this->error_code() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->error_code()); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Status::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:pb.Status) + GOOGLE_DCHECK_NE(&from, this); + const Status* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.Status) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.Status) + MergeFrom(*source); + } +} + +void Status::MergeFrom(const Status& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:pb.Status) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.reason().size() > 0) { + + reason_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.reason_); + } + if (from.error_code() != 0) { + set_error_code(from.error_code()); + } +} + +void Status::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:pb.Status) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Status::CopyFrom(const Status& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:pb.Status) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Status::IsInitialized() const { + return true; +} + +void Status::InternalSwap(Status* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + reason_.Swap(&other->reason_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(error_code_, other->error_code_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Status::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void SegmentRecord::InitAsDefaultInstance() { +} +class SegmentRecord::_Internal { + public: +}; + +SegmentRecord::SegmentRecord() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:pb.SegmentRecord) +} +SegmentRecord::SegmentRecord(const SegmentRecord& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + seg_info_(from.seg_info_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:pb.SegmentRecord) +} + +void SegmentRecord::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_SegmentRecord_pulsar_2eproto.base); +} + +SegmentRecord::~SegmentRecord() { + // @@protoc_insertion_point(destructor:pb.SegmentRecord) + SharedDtor(); +} + +void SegmentRecord::SharedDtor() { +} + +void SegmentRecord::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const SegmentRecord& SegmentRecord::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_SegmentRecord_pulsar_2eproto.base); + return *internal_default_instance(); +} + + +void SegmentRecord::Clear() { +// @@protoc_insertion_point(message_clear_start:pb.SegmentRecord) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + seg_info_.Clear(); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* SegmentRecord::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // repeated string seg_info = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(add_seg_info(), ptr, ctx, "pb.SegmentRecord.seg_info"); + 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 SegmentRecord::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:pb.SegmentRecord) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // repeated string seg_info = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->add_seg_info())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->seg_info(this->seg_info_size() - 1).data(), + static_cast(this->seg_info(this->seg_info_size() - 1).length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "pb.SegmentRecord.seg_info")); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:pb.SegmentRecord) + return true; +failure: + // @@protoc_insertion_point(parse_failure:pb.SegmentRecord) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void SegmentRecord::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:pb.SegmentRecord) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated string seg_info = 1; + for (int i = 0, n = this->seg_info_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->seg_info(i).data(), static_cast(this->seg_info(i).length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "pb.SegmentRecord.seg_info"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteString( + 1, this->seg_info(i), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:pb.SegmentRecord) +} + +::PROTOBUF_NAMESPACE_ID::uint8* SegmentRecord::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:pb.SegmentRecord) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated string seg_info = 1; + for (int i = 0, n = this->seg_info_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->seg_info(i).data(), static_cast(this->seg_info(i).length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "pb.SegmentRecord.seg_info"); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + WriteStringToArray(1, this->seg_info(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:pb.SegmentRecord) + return target; +} + +size_t SegmentRecord::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:pb.SegmentRecord) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated string seg_info = 1; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->seg_info_size()); + for (int i = 0, n = this->seg_info_size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->seg_info(i)); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void SegmentRecord::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:pb.SegmentRecord) + GOOGLE_DCHECK_NE(&from, this); + const SegmentRecord* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.SegmentRecord) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.SegmentRecord) + MergeFrom(*source); + } +} + +void SegmentRecord::MergeFrom(const SegmentRecord& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:pb.SegmentRecord) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + seg_info_.MergeFrom(from.seg_info_); +} + +void SegmentRecord::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:pb.SegmentRecord) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void SegmentRecord::CopyFrom(const SegmentRecord& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:pb.SegmentRecord) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SegmentRecord::IsInitialized() const { + return true; +} + +void SegmentRecord::InternalSwap(SegmentRecord* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + seg_info_.InternalSwap(CastToBase(&other->seg_info_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SegmentRecord::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void VectorRowRecord::InitAsDefaultInstance() { +} +class VectorRowRecord::_Internal { + public: +}; + +VectorRowRecord::VectorRowRecord() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:pb.VectorRowRecord) +} +VectorRowRecord::VectorRowRecord(const VectorRowRecord& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + float_data_(from.float_data_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + binary_data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.binary_data().empty()) { + binary_data_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.binary_data_); + } + // @@protoc_insertion_point(copy_constructor:pb.VectorRowRecord) +} + +void VectorRowRecord::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_VectorRowRecord_pulsar_2eproto.base); + binary_data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +VectorRowRecord::~VectorRowRecord() { + // @@protoc_insertion_point(destructor:pb.VectorRowRecord) + SharedDtor(); +} + +void VectorRowRecord::SharedDtor() { + binary_data_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void VectorRowRecord::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const VectorRowRecord& VectorRowRecord::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_VectorRowRecord_pulsar_2eproto.base); + return *internal_default_instance(); +} + + +void VectorRowRecord::Clear() { +// @@protoc_insertion_point(message_clear_start:pb.VectorRowRecord) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + float_data_.Clear(); + binary_data_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* VectorRowRecord::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // repeated float float_data = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser(mutable_float_data(), ptr, ctx); + CHK_(ptr); + } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 13) { + add_float_data(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); + ptr += sizeof(float); + } else goto handle_unusual; + continue; + // bytes binary_data = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(mutable_binary_data(), ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool VectorRowRecord::MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + // @@protoc_insertion_point(parse_start:pb.VectorRowRecord) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // repeated float float_data = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPackedPrimitive< + float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>( + input, this->mutable_float_data()))); + } else if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (13 & 0xFF)) { + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< + float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>( + 1, 10u, input, this->mutable_float_data()))); + } else { + goto handle_unusual; + } + break; + } + + // bytes binary_data = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadBytes( + input, this->mutable_binary_data())); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:pb.VectorRowRecord) + return true; +failure: + // @@protoc_insertion_point(parse_failure:pb.VectorRowRecord) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void VectorRowRecord::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:pb.VectorRowRecord) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated float float_data = 1; + if (this->float_data_size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTag(1, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(_float_data_cached_byte_size_.load( + std::memory_order_relaxed)); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatArray( + this->float_data().data(), this->float_data_size(), output); + } + + // bytes binary_data = 2; + if (this->binary_data().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesMaybeAliased( + 2, this->binary_data(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:pb.VectorRowRecord) +} + +::PROTOBUF_NAMESPACE_ID::uint8* VectorRowRecord::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:pb.VectorRowRecord) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated float float_data = 1; + if (this->float_data_size() > 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTagToArray( + 1, + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + target); + target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray( + _float_data_cached_byte_size_.load(std::memory_order_relaxed), + target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + WriteFloatNoTagToArray(this->float_data_, target); + } + + // bytes binary_data = 2; + if (this->binary_data().size() > 0) { + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesToArray( + 2, this->binary_data(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:pb.VectorRowRecord) + return target; +} + +size_t VectorRowRecord::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:pb.VectorRowRecord) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated float float_data = 1; + { + unsigned int count = static_cast(this->float_data_size()); + size_t data_size = 4UL * count; + if (data_size > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size)); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size); + _float_data_cached_byte_size_.store(cached_size, + std::memory_order_relaxed); + total_size += data_size; + } + + // bytes binary_data = 2; + if (this->binary_data().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->binary_data()); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void VectorRowRecord::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:pb.VectorRowRecord) + GOOGLE_DCHECK_NE(&from, this); + const VectorRowRecord* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.VectorRowRecord) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.VectorRowRecord) + MergeFrom(*source); + } +} + +void VectorRowRecord::MergeFrom(const VectorRowRecord& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:pb.VectorRowRecord) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + float_data_.MergeFrom(from.float_data_); + if (from.binary_data().size() > 0) { + + binary_data_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.binary_data_); + } +} + +void VectorRowRecord::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:pb.VectorRowRecord) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void VectorRowRecord::CopyFrom(const VectorRowRecord& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:pb.VectorRowRecord) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool VectorRowRecord::IsInitialized() const { + return true; +} + +void VectorRowRecord::InternalSwap(VectorRowRecord* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + float_data_.InternalSwap(&other->float_data_); + binary_data_.Swap(&other->binary_data_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} + +::PROTOBUF_NAMESPACE_ID::Metadata VectorRowRecord::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void AttrRecord::InitAsDefaultInstance() { +} +class AttrRecord::_Internal { + public: +}; + +AttrRecord::AttrRecord() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:pb.AttrRecord) +} +AttrRecord::AttrRecord(const AttrRecord& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + int32_value_(from.int32_value_), + int64_value_(from.int64_value_), + float_value_(from.float_value_), + double_value_(from.double_value_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:pb.AttrRecord) +} + +void AttrRecord::SharedCtor() { +} + +AttrRecord::~AttrRecord() { + // @@protoc_insertion_point(destructor:pb.AttrRecord) + SharedDtor(); +} + +void AttrRecord::SharedDtor() { +} + +void AttrRecord::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const AttrRecord& AttrRecord::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_AttrRecord_pulsar_2eproto.base); + return *internal_default_instance(); +} + + +void AttrRecord::Clear() { +// @@protoc_insertion_point(message_clear_start:pb.AttrRecord) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + int32_value_.Clear(); + int64_value_.Clear(); + float_value_.Clear(); + double_value_.Clear(); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* AttrRecord::_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 int32 int32_value = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt32Parser(mutable_int32_value(), ptr, ctx); + CHK_(ptr); + } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8) { + add_int32_value(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr)); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated int64 int64_value = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt64Parser(mutable_int64_value(), ptr, ctx); + CHK_(ptr); + } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16) { + add_int64_value(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr)); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated float float_value = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser(mutable_float_value(), ptr, ctx); + CHK_(ptr); + } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 29) { + add_float_value(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); + ptr += sizeof(float); + } else goto handle_unusual; + continue; + // repeated double double_value = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedDoubleParser(mutable_double_value(), ptr, ctx); + CHK_(ptr); + } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 33) { + add_double_value(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); + ptr += sizeof(double); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool AttrRecord::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:pb.AttrRecord) + 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 int32 int32_value = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPackedPrimitive< + ::PROTOBUF_NAMESPACE_ID::int32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32>( + input, this->mutable_int32_value()))); + } else if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) { + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< + ::PROTOBUF_NAMESPACE_ID::int32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32>( + 1, 10u, input, this->mutable_int32_value()))); + } else { + goto handle_unusual; + } + break; + } + + // repeated int64 int64_value = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPackedPrimitive< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + input, this->mutable_int64_value()))); + } else if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) { + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + 1, 18u, input, this->mutable_int64_value()))); + } else { + goto handle_unusual; + } + break; + } + + // repeated float float_value = 3; + case 3: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) { + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPackedPrimitive< + float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>( + input, this->mutable_float_value()))); + } else if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (29 & 0xFF)) { + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< + float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>( + 1, 26u, input, this->mutable_float_value()))); + } else { + goto handle_unusual; + } + break; + } + + // repeated double double_value = 4; + case 4: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (34 & 0xFF)) { + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPackedPrimitive< + double, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_DOUBLE>( + input, this->mutable_double_value()))); + } else if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (33 & 0xFF)) { + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< + double, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_DOUBLE>( + 1, 34u, input, this->mutable_double_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:pb.AttrRecord) + return true; +failure: + // @@protoc_insertion_point(parse_failure:pb.AttrRecord) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void AttrRecord::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:pb.AttrRecord) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated int32 int32_value = 1; + if (this->int32_value_size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTag(1, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(_int32_value_cached_byte_size_.load( + std::memory_order_relaxed)); + } + for (int i = 0, n = this->int32_value_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32NoTag( + this->int32_value(i), output); + } + + // repeated int64 int64_value = 2; + if (this->int64_value_size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTag(2, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(_int64_value_cached_byte_size_.load( + std::memory_order_relaxed)); + } + for (int i = 0, n = this->int64_value_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64NoTag( + this->int64_value(i), output); + } + + // repeated float float_value = 3; + if (this->float_value_size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTag(3, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(_float_value_cached_byte_size_.load( + std::memory_order_relaxed)); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatArray( + this->float_value().data(), this->float_value_size(), output); + } + + // repeated double double_value = 4; + if (this->double_value_size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTag(4, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(_double_value_cached_byte_size_.load( + std::memory_order_relaxed)); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleArray( + this->double_value().data(), this->double_value_size(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:pb.AttrRecord) +} + +::PROTOBUF_NAMESPACE_ID::uint8* AttrRecord::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:pb.AttrRecord) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated int32 int32_value = 1; + if (this->int32_value_size() > 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTagToArray( + 1, + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + target); + target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray( + _int32_value_cached_byte_size_.load(std::memory_order_relaxed), + target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + WriteInt32NoTagToArray(this->int32_value_, target); + } + + // repeated int64 int64_value = 2; + if (this->int64_value_size() > 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTagToArray( + 2, + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + target); + target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray( + _int64_value_cached_byte_size_.load(std::memory_order_relaxed), + target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + WriteInt64NoTagToArray(this->int64_value_, target); + } + + // repeated float float_value = 3; + if (this->float_value_size() > 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTagToArray( + 3, + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + target); + target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray( + _float_value_cached_byte_size_.load(std::memory_order_relaxed), + target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + WriteFloatNoTagToArray(this->float_value_, target); + } + + // repeated double double_value = 4; + if (this->double_value_size() > 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTagToArray( + 4, + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + target); + target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray( + _double_value_cached_byte_size_.load(std::memory_order_relaxed), + target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + WriteDoubleNoTagToArray(this->double_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:pb.AttrRecord) + return target; +} + +size_t AttrRecord::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:pb.AttrRecord) + 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 int32 int32_value = 1; + { + size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + Int32Size(this->int32_value_); + if (data_size > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size)); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size); + _int32_value_cached_byte_size_.store(cached_size, + std::memory_order_relaxed); + total_size += data_size; + } + + // repeated int64 int64_value = 2; + { + size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + Int64Size(this->int64_value_); + if (data_size > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size)); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size); + _int64_value_cached_byte_size_.store(cached_size, + std::memory_order_relaxed); + total_size += data_size; + } + + // repeated float float_value = 3; + { + unsigned int count = static_cast(this->float_value_size()); + size_t data_size = 4UL * count; + if (data_size > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size)); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size); + _float_value_cached_byte_size_.store(cached_size, + std::memory_order_relaxed); + total_size += data_size; + } + + // repeated double double_value = 4; + { + unsigned int count = static_cast(this->double_value_size()); + size_t data_size = 8UL * count; + if (data_size > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size)); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size); + _double_value_cached_byte_size_.store(cached_size, + std::memory_order_relaxed); + total_size += data_size; + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void AttrRecord::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:pb.AttrRecord) + GOOGLE_DCHECK_NE(&from, this); + const AttrRecord* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.AttrRecord) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.AttrRecord) + MergeFrom(*source); + } +} + +void AttrRecord::MergeFrom(const AttrRecord& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:pb.AttrRecord) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + int32_value_.MergeFrom(from.int32_value_); + int64_value_.MergeFrom(from.int64_value_); + float_value_.MergeFrom(from.float_value_); + double_value_.MergeFrom(from.double_value_); +} + +void AttrRecord::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:pb.AttrRecord) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void AttrRecord::CopyFrom(const AttrRecord& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:pb.AttrRecord) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool AttrRecord::IsInitialized() const { + return true; +} + +void AttrRecord::InternalSwap(AttrRecord* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + int32_value_.InternalSwap(&other->int32_value_); + int64_value_.InternalSwap(&other->int64_value_); + float_value_.InternalSwap(&other->float_value_); + double_value_.InternalSwap(&other->double_value_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata AttrRecord::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void VectorRecord::InitAsDefaultInstance() { +} +class VectorRecord::_Internal { + public: +}; + +VectorRecord::VectorRecord() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:pb.VectorRecord) +} +VectorRecord::VectorRecord(const VectorRecord& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + records_(from.records_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:pb.VectorRecord) +} + +void VectorRecord::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_VectorRecord_pulsar_2eproto.base); +} + +VectorRecord::~VectorRecord() { + // @@protoc_insertion_point(destructor:pb.VectorRecord) + SharedDtor(); +} + +void VectorRecord::SharedDtor() { +} + +void VectorRecord::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const VectorRecord& VectorRecord::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_VectorRecord_pulsar_2eproto.base); + return *internal_default_instance(); +} + + +void VectorRecord::Clear() { +// @@protoc_insertion_point(message_clear_start:pb.VectorRecord) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + records_.Clear(); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* VectorRecord::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // repeated .pb.VectorRowRecord records = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(add_records(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 10); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool VectorRecord::MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + // @@protoc_insertion_point(parse_start:pb.VectorRecord) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // repeated .pb.VectorRowRecord records = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, add_records())); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:pb.VectorRecord) + return true; +failure: + // @@protoc_insertion_point(parse_failure:pb.VectorRecord) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void VectorRecord::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:pb.VectorRecord) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated .pb.VectorRowRecord records = 1; + for (unsigned int i = 0, + n = static_cast(this->records_size()); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, + this->records(static_cast(i)), + output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:pb.VectorRecord) +} + +::PROTOBUF_NAMESPACE_ID::uint8* VectorRecord::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:pb.VectorRecord) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated .pb.VectorRowRecord records = 1; + for (unsigned int i = 0, + n = static_cast(this->records_size()); i < n; i++) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 1, this->records(static_cast(i)), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:pb.VectorRecord) + return target; +} + +size_t VectorRecord::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:pb.VectorRecord) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .pb.VectorRowRecord records = 1; + { + unsigned int count = static_cast(this->records_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + this->records(static_cast(i))); + } + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void VectorRecord::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:pb.VectorRecord) + GOOGLE_DCHECK_NE(&from, this); + const VectorRecord* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.VectorRecord) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.VectorRecord) + MergeFrom(*source); + } +} + +void VectorRecord::MergeFrom(const VectorRecord& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:pb.VectorRecord) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + records_.MergeFrom(from.records_); +} + +void VectorRecord::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:pb.VectorRecord) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void VectorRecord::CopyFrom(const VectorRecord& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:pb.VectorRecord) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool VectorRecord::IsInitialized() const { + return true; +} + +void VectorRecord::InternalSwap(VectorRecord* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + CastToBase(&records_)->InternalSwap(CastToBase(&other->records_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata VectorRecord::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void VectorParam::InitAsDefaultInstance() { + ::pb::_VectorParam_default_instance_._instance.get_mutable()->row_record_ = const_cast< ::pb::VectorRecord*>( + ::pb::VectorRecord::internal_default_instance()); +} +class VectorParam::_Internal { + public: + static const ::pb::VectorRecord& row_record(const VectorParam* msg); +}; + +const ::pb::VectorRecord& +VectorParam::_Internal::row_record(const VectorParam* msg) { + return *msg->row_record_; +} +VectorParam::VectorParam() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:pb.VectorParam) +} +VectorParam::VectorParam(const VectorParam& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + json_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.json().empty()) { + json_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.json_); + } + if (from.has_row_record()) { + row_record_ = new ::pb::VectorRecord(*from.row_record_); + } else { + row_record_ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:pb.VectorParam) +} + +void VectorParam::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_VectorParam_pulsar_2eproto.base); + json_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + row_record_ = nullptr; +} + +VectorParam::~VectorParam() { + // @@protoc_insertion_point(destructor:pb.VectorParam) + SharedDtor(); +} + +void VectorParam::SharedDtor() { + json_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (this != internal_default_instance()) delete row_record_; +} + +void VectorParam::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const VectorParam& VectorParam::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_VectorParam_pulsar_2eproto.base); + return *internal_default_instance(); +} + + +void VectorParam::Clear() { +// @@protoc_insertion_point(message_clear_start:pb.VectorParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + json_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (GetArenaNoVirtual() == nullptr && row_record_ != nullptr) { + delete row_record_; + } + row_record_ = nullptr; + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* VectorParam::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // string json = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_json(), ptr, ctx, "pb.VectorParam.json"); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .pb.VectorRecord row_record = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(mutable_row_record(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool VectorParam::MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + // @@protoc_insertion_point(parse_start:pb.VectorParam) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // string json = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_json())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->json().data(), static_cast(this->json().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "pb.VectorParam.json")); + } else { + goto handle_unusual; + } + break; + } + + // .pb.VectorRecord row_record = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, mutable_row_record())); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:pb.VectorParam) + return true; +failure: + // @@protoc_insertion_point(parse_failure:pb.VectorParam) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void VectorParam::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:pb.VectorParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string json = 1; + if (this->json().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->json().data(), static_cast(this->json().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "pb.VectorParam.json"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->json(), output); + } + + // .pb.VectorRecord row_record = 2; + if (this->has_row_record()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, _Internal::row_record(this), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:pb.VectorParam) +} + +::PROTOBUF_NAMESPACE_ID::uint8* VectorParam::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:pb.VectorParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string json = 1; + if (this->json().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->json().data(), static_cast(this->json().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "pb.VectorParam.json"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 1, this->json(), target); + } + + // .pb.VectorRecord row_record = 2; + if (this->has_row_record()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 2, _Internal::row_record(this), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:pb.VectorParam) + return target; +} + +size_t VectorParam::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:pb.VectorParam) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // string json = 1; + if (this->json().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->json()); + } + + // .pb.VectorRecord row_record = 2; + if (this->has_row_record()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *row_record_); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void VectorParam::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:pb.VectorParam) + GOOGLE_DCHECK_NE(&from, this); + const VectorParam* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.VectorParam) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.VectorParam) + MergeFrom(*source); + } +} + +void VectorParam::MergeFrom(const VectorParam& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:pb.VectorParam) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.json().size() > 0) { + + json_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.json_); + } + if (from.has_row_record()) { + mutable_row_record()->::pb::VectorRecord::MergeFrom(from.row_record()); + } +} + +void VectorParam::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:pb.VectorParam) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void VectorParam::CopyFrom(const VectorParam& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:pb.VectorParam) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool VectorParam::IsInitialized() const { + return true; +} + +void VectorParam::InternalSwap(VectorParam* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + json_.Swap(&other->json_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(row_record_, other->row_record_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata VectorParam::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void FieldValue::InitAsDefaultInstance() { + ::pb::_FieldValue_default_instance_._instance.get_mutable()->attr_record_ = const_cast< ::pb::AttrRecord*>( + ::pb::AttrRecord::internal_default_instance()); + ::pb::_FieldValue_default_instance_._instance.get_mutable()->vector_record_ = const_cast< ::pb::VectorRecord*>( + ::pb::VectorRecord::internal_default_instance()); +} +class FieldValue::_Internal { + public: + static const ::pb::AttrRecord& attr_record(const FieldValue* msg); + static const ::pb::VectorRecord& vector_record(const FieldValue* msg); +}; + +const ::pb::AttrRecord& +FieldValue::_Internal::attr_record(const FieldValue* msg) { + return *msg->attr_record_; +} +const ::pb::VectorRecord& +FieldValue::_Internal::vector_record(const FieldValue* msg) { + return *msg->vector_record_; +} +FieldValue::FieldValue() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:pb.FieldValue) +} +FieldValue::FieldValue(const FieldValue& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + field_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.field_name().empty()) { + field_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.field_name_); + } + if (from.has_attr_record()) { + attr_record_ = new ::pb::AttrRecord(*from.attr_record_); + } else { + attr_record_ = nullptr; + } + if (from.has_vector_record()) { + vector_record_ = new ::pb::VectorRecord(*from.vector_record_); + } else { + vector_record_ = nullptr; + } + type_ = from.type_; + // @@protoc_insertion_point(copy_constructor:pb.FieldValue) +} + +void FieldValue::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_FieldValue_pulsar_2eproto.base); + field_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + ::memset(&attr_record_, 0, static_cast( + reinterpret_cast(&type_) - + reinterpret_cast(&attr_record_)) + sizeof(type_)); +} + +FieldValue::~FieldValue() { + // @@protoc_insertion_point(destructor:pb.FieldValue) + SharedDtor(); +} + +void FieldValue::SharedDtor() { + field_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (this != internal_default_instance()) delete attr_record_; + if (this != internal_default_instance()) delete vector_record_; +} + +void FieldValue::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const FieldValue& FieldValue::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_FieldValue_pulsar_2eproto.base); + return *internal_default_instance(); +} + + +void FieldValue::Clear() { +// @@protoc_insertion_point(message_clear_start:pb.FieldValue) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + field_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (GetArenaNoVirtual() == nullptr && attr_record_ != nullptr) { + delete attr_record_; + } + attr_record_ = nullptr; + if (GetArenaNoVirtual() == nullptr && vector_record_ != nullptr) { + delete vector_record_; + } + vector_record_ = nullptr; + type_ = 0; + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* FieldValue::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // string field_name = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_field_name(), ptr, ctx, "pb.FieldValue.field_name"); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .pb.DataType type = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + set_type(static_cast<::pb::DataType>(val)); + } else goto handle_unusual; + continue; + // .pb.AttrRecord attr_record = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr = ctx->ParseMessage(mutable_attr_record(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .pb.VectorRecord vector_record = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + ptr = ctx->ParseMessage(mutable_vector_record(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool FieldValue::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:pb.FieldValue) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // string field_name = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_field_name())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->field_name().data(), static_cast(this->field_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "pb.FieldValue.field_name")); + } else { + goto handle_unusual; + } + break; + } + + // .pb.DataType type = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) { + int value = 0; + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + int, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + set_type(static_cast< ::pb::DataType >(value)); + } else { + goto handle_unusual; + } + break; + } + + // .pb.AttrRecord attr_record = 3; + case 3: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, mutable_attr_record())); + } else { + goto handle_unusual; + } + break; + } + + // .pb.VectorRecord vector_record = 4; + case 4: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (34 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, mutable_vector_record())); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:pb.FieldValue) + return true; +failure: + // @@protoc_insertion_point(parse_failure:pb.FieldValue) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void FieldValue::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:pb.FieldValue) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string field_name = 1; + if (this->field_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->field_name().data(), static_cast(this->field_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "pb.FieldValue.field_name"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->field_name(), output); + } + + // .pb.DataType type = 2; + if (this->type() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnum( + 2, this->type(), output); + } + + // .pb.AttrRecord attr_record = 3; + if (this->has_attr_record()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 3, _Internal::attr_record(this), output); + } + + // .pb.VectorRecord vector_record = 4; + if (this->has_vector_record()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 4, _Internal::vector_record(this), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:pb.FieldValue) +} + +::PROTOBUF_NAMESPACE_ID::uint8* FieldValue::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:pb.FieldValue) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string field_name = 1; + if (this->field_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->field_name().data(), static_cast(this->field_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "pb.FieldValue.field_name"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 1, this->field_name(), target); + } + + // .pb.DataType type = 2; + if (this->type() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 2, this->type(), target); + } + + // .pb.AttrRecord attr_record = 3; + if (this->has_attr_record()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 3, _Internal::attr_record(this), target); + } + + // .pb.VectorRecord vector_record = 4; + if (this->has_vector_record()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 4, _Internal::vector_record(this), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:pb.FieldValue) + return target; +} + +size_t FieldValue::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:pb.FieldValue) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // string field_name = 1; + if (this->field_name().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->field_name()); + } + + // .pb.AttrRecord attr_record = 3; + if (this->has_attr_record()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *attr_record_); + } + + // .pb.VectorRecord vector_record = 4; + if (this->has_vector_record()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *vector_record_); + } + + // .pb.DataType type = 2; + if (this->type() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->type()); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void FieldValue::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:pb.FieldValue) + GOOGLE_DCHECK_NE(&from, this); + const FieldValue* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.FieldValue) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.FieldValue) + MergeFrom(*source); + } +} + +void FieldValue::MergeFrom(const FieldValue& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:pb.FieldValue) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.field_name().size() > 0) { + + field_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.field_name_); + } + if (from.has_attr_record()) { + mutable_attr_record()->::pb::AttrRecord::MergeFrom(from.attr_record()); + } + if (from.has_vector_record()) { + mutable_vector_record()->::pb::VectorRecord::MergeFrom(from.vector_record()); + } + if (from.type() != 0) { + set_type(from.type()); + } +} + +void FieldValue::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:pb.FieldValue) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void FieldValue::CopyFrom(const FieldValue& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:pb.FieldValue) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool FieldValue::IsInitialized() const { + return true; +} + +void FieldValue::InternalSwap(FieldValue* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + field_name_.Swap(&other->field_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(attr_record_, other->attr_record_); + swap(vector_record_, other->vector_record_); + swap(type_, other->type_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata FieldValue::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void Cell::InitAsDefaultInstance() { + ::pb::_Cell_default_instance_.int32_value_ = 0; + ::pb::_Cell_default_instance_.int64_value_ = PROTOBUF_LONGLONG(0); + ::pb::_Cell_default_instance_.float_value_ = 0; + ::pb::_Cell_default_instance_.double_value_ = 0; +} +class Cell::_Internal { + public: +}; + +Cell::Cell() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:pb.Cell) +} +Cell::Cell(const Cell& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + clear_has_value(); + switch (from.value_case()) { + case kInt32Value: { + set_int32_value(from.int32_value()); + break; + } + case kInt64Value: { + set_int64_value(from.int64_value()); + break; + } + case kFloatValue: { + set_float_value(from.float_value()); + break; + } + case kDoubleValue: { + set_double_value(from.double_value()); + break; + } + case VALUE_NOT_SET: { + break; + } + } + // @@protoc_insertion_point(copy_constructor:pb.Cell) +} + +void Cell::SharedCtor() { + clear_has_value(); +} + +Cell::~Cell() { + // @@protoc_insertion_point(destructor:pb.Cell) + SharedDtor(); +} + +void Cell::SharedDtor() { + if (has_value()) { + clear_value(); + } +} + +void Cell::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const Cell& Cell::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_Cell_pulsar_2eproto.base); + return *internal_default_instance(); +} + + +void Cell::clear_value() { +// @@protoc_insertion_point(one_of_clear_start:pb.Cell) + switch (value_case()) { + case kInt32Value: { + // No need to clear + break; + } + case kInt64Value: { + // No need to clear + break; + } + case kFloatValue: { + // No need to clear + break; + } + case kDoubleValue: { + // No need to clear + break; + } + case VALUE_NOT_SET: { + break; + } + } + _oneof_case_[0] = VALUE_NOT_SET; +} + + +void Cell::Clear() { +// @@protoc_insertion_point(message_clear_start:pb.Cell) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + clear_value(); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* Cell::_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) { + // int32 int32_value = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + set_int32_value(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr)); + CHK_(ptr); + } else goto handle_unusual; + continue; + // int64 int64_value = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + set_int64_value(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr)); + CHK_(ptr); + } else goto handle_unusual; + continue; + // float float_value = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 29)) { + set_float_value(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); + ptr += sizeof(float); + } else goto handle_unusual; + continue; + // double double_value = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 33)) { + set_double_value(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); + ptr += sizeof(double); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool Cell::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:pb.Cell) + 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)) { + // int32 int32_value = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) { + clear_value(); + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + ::PROTOBUF_NAMESPACE_ID::int32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32>( + input, &value_.int32_value_))); + set_has_int32_value(); + } else { + goto handle_unusual; + } + break; + } + + // int64 int64_value = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) { + clear_value(); + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + input, &value_.int64_value_))); + set_has_int64_value(); + } else { + goto handle_unusual; + } + break; + } + + // float float_value = 3; + case 3: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (29 & 0xFF)) { + clear_value(); + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>( + input, &value_.float_value_))); + set_has_float_value(); + } else { + goto handle_unusual; + } + break; + } + + // double double_value = 4; + case 4: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (33 & 0xFF)) { + clear_value(); + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + double, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_DOUBLE>( + input, &value_.double_value_))); + set_has_double_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:pb.Cell) + return true; +failure: + // @@protoc_insertion_point(parse_failure:pb.Cell) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void Cell::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:pb.Cell) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // int32 int32_value = 1; + if (has_int32_value()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32(1, this->int32_value(), output); + } + + // int64 int64_value = 2; + if (has_int64_value()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(2, this->int64_value(), output); + } + + // float float_value = 3; + if (has_float_value()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloat(3, this->float_value(), output); + } + + // double double_value = 4; + if (has_double_value()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDouble(4, this->double_value(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:pb.Cell) +} + +::PROTOBUF_NAMESPACE_ID::uint8* Cell::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:pb.Cell) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // int32 int32_value = 1; + if (has_int32_value()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->int32_value(), target); + } + + // int64 int64_value = 2; + if (has_int64_value()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(2, this->int64_value(), target); + } + + // float float_value = 3; + if (has_float_value()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(3, this->float_value(), target); + } + + // double double_value = 4; + if (has_double_value()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(4, this->double_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:pb.Cell) + return target; +} + +size_t Cell::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:pb.Cell) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + switch (value_case()) { + // int32 int32_value = 1; + case kInt32Value: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + this->int32_value()); + break; + } + // int64 int64_value = 2; + case kInt64Value: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( + this->int64_value()); + break; + } + // float float_value = 3; + case kFloatValue: { + total_size += 1 + 4; + break; + } + // double double_value = 4; + case kDoubleValue: { + total_size += 1 + 8; + break; + } + case VALUE_NOT_SET: { + break; + } + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Cell::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:pb.Cell) + GOOGLE_DCHECK_NE(&from, this); + const Cell* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.Cell) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.Cell) + MergeFrom(*source); + } +} + +void Cell::MergeFrom(const Cell& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:pb.Cell) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + switch (from.value_case()) { + case kInt32Value: { + set_int32_value(from.int32_value()); + break; + } + case kInt64Value: { + set_int64_value(from.int64_value()); + break; + } + case kFloatValue: { + set_float_value(from.float_value()); + break; + } + case kDoubleValue: { + set_double_value(from.double_value()); + break; + } + case VALUE_NOT_SET: { + break; + } + } +} + +void Cell::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:pb.Cell) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Cell::CopyFrom(const Cell& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:pb.Cell) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Cell::IsInitialized() const { + return true; +} + +void Cell::InternalSwap(Cell* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(value_, other->value_); + swap(_oneof_case_[0], other->_oneof_case_[0]); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Cell::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void RowValue::InitAsDefaultInstance() { + ::pb::_RowValue_default_instance_._instance.get_mutable()->vec_ = const_cast< ::pb::VectorRowRecord*>( + ::pb::VectorRowRecord::internal_default_instance()); +} +class RowValue::_Internal { + public: + static const ::pb::VectorRowRecord& vec(const RowValue* msg); +}; + +const ::pb::VectorRowRecord& +RowValue::_Internal::vec(const RowValue* msg) { + return *msg->vec_; +} +RowValue::RowValue() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:pb.RowValue) +} +RowValue::RowValue(const RowValue& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + cell_(from.cell_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + if (from.has_vec()) { + vec_ = new ::pb::VectorRowRecord(*from.vec_); + } else { + vec_ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:pb.RowValue) +} + +void RowValue::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_RowValue_pulsar_2eproto.base); + vec_ = nullptr; +} + +RowValue::~RowValue() { + // @@protoc_insertion_point(destructor:pb.RowValue) + SharedDtor(); +} + +void RowValue::SharedDtor() { + if (this != internal_default_instance()) delete vec_; +} + +void RowValue::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const RowValue& RowValue::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_RowValue_pulsar_2eproto.base); + return *internal_default_instance(); +} + + +void RowValue::Clear() { +// @@protoc_insertion_point(message_clear_start:pb.RowValue) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cell_.Clear(); + if (GetArenaNoVirtual() == nullptr && vec_ != nullptr) { + delete vec_; + } + vec_ = nullptr; + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* RowValue::_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) { + // .pb.VectorRowRecord vec = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(mutable_vec(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated .pb.Cell cell = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(add_cell(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 18); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool RowValue::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:pb.RowValue) + 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)) { + // .pb.VectorRowRecord vec = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, mutable_vec())); + } else { + goto handle_unusual; + } + break; + } + + // repeated .pb.Cell cell = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, add_cell())); + } 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:pb.RowValue) + return true; +failure: + // @@protoc_insertion_point(parse_failure:pb.RowValue) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void RowValue::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:pb.RowValue) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .pb.VectorRowRecord vec = 1; + if (this->has_vec()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, _Internal::vec(this), output); + } + + // repeated .pb.Cell cell = 2; + for (unsigned int i = 0, + n = static_cast(this->cell_size()); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, + this->cell(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:pb.RowValue) +} + +::PROTOBUF_NAMESPACE_ID::uint8* RowValue::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:pb.RowValue) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .pb.VectorRowRecord vec = 1; + if (this->has_vec()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 1, _Internal::vec(this), target); + } + + // repeated .pb.Cell cell = 2; + for (unsigned int i = 0, + n = static_cast(this->cell_size()); i < n; i++) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 2, this->cell(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:pb.RowValue) + return target; +} + +size_t RowValue::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:pb.RowValue) + 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 .pb.Cell cell = 2; + { + unsigned int count = static_cast(this->cell_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + this->cell(static_cast(i))); + } + } + + // .pb.VectorRowRecord vec = 1; + if (this->has_vec()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *vec_); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void RowValue::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:pb.RowValue) + GOOGLE_DCHECK_NE(&from, this); + const RowValue* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.RowValue) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.RowValue) + MergeFrom(*source); + } +} + +void RowValue::MergeFrom(const RowValue& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:pb.RowValue) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cell_.MergeFrom(from.cell_); + if (from.has_vec()) { + mutable_vec()->::pb::VectorRowRecord::MergeFrom(from.vec()); + } +} + +void RowValue::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:pb.RowValue) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void RowValue::CopyFrom(const RowValue& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:pb.RowValue) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool RowValue::IsInitialized() const { + return true; +} + +void RowValue::InternalSwap(RowValue* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + CastToBase(&cell_)->InternalSwap(CastToBase(&other->cell_)); + swap(vec_, other->vec_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata RowValue::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void PulsarMessage::InitAsDefaultInstance() { + ::pb::_PulsarMessage_default_instance_._instance.get_mutable()->vector_param_ = const_cast< ::pb::VectorParam*>( + ::pb::VectorParam::internal_default_instance()); + ::pb::_PulsarMessage_default_instance_._instance.get_mutable()->segments_ = const_cast< ::pb::SegmentRecord*>( + ::pb::SegmentRecord::internal_default_instance()); +} +class PulsarMessage::_Internal { + public: + static const ::pb::VectorParam& vector_param(const PulsarMessage* msg); + static const ::pb::SegmentRecord& segments(const PulsarMessage* msg); +}; + +const ::pb::VectorParam& +PulsarMessage::_Internal::vector_param(const PulsarMessage* msg) { + return *msg->vector_param_; +} +const ::pb::SegmentRecord& +PulsarMessage::_Internal::segments(const PulsarMessage* msg) { + return *msg->segments_; +} +PulsarMessage::PulsarMessage() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:pb.PulsarMessage) +} +PulsarMessage::PulsarMessage(const PulsarMessage& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + fields_(from.fields_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.collection_name().empty()) { + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); + } + partition_tag_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.partition_tag().empty()) { + partition_tag_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.partition_tag_); + } + topic_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.topic_name().empty()) { + topic_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.topic_name_); + } + if (from.has_vector_param()) { + vector_param_ = new ::pb::VectorParam(*from.vector_param_); + } else { + vector_param_ = nullptr; + } + if (from.has_segments()) { + segments_ = new ::pb::SegmentRecord(*from.segments_); + } else { + segments_ = nullptr; + } + ::memcpy(&entity_id_, &from.entity_id_, + static_cast(reinterpret_cast(&msg_type_) - + reinterpret_cast(&entity_id_)) + sizeof(msg_type_)); + // @@protoc_insertion_point(copy_constructor:pb.PulsarMessage) +} + +void PulsarMessage::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_PulsarMessage_pulsar_2eproto.base); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + partition_tag_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + topic_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + ::memset(&vector_param_, 0, static_cast( + reinterpret_cast(&msg_type_) - + reinterpret_cast(&vector_param_)) + sizeof(msg_type_)); +} + +PulsarMessage::~PulsarMessage() { + // @@protoc_insertion_point(destructor:pb.PulsarMessage) + SharedDtor(); +} + +void PulsarMessage::SharedDtor() { + collection_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + partition_tag_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + topic_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (this != internal_default_instance()) delete vector_param_; + if (this != internal_default_instance()) delete segments_; +} + +void PulsarMessage::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const PulsarMessage& PulsarMessage::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_PulsarMessage_pulsar_2eproto.base); + return *internal_default_instance(); +} + + +void PulsarMessage::Clear() { +// @@protoc_insertion_point(message_clear_start:pb.PulsarMessage) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + fields_.Clear(); + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + partition_tag_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + topic_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (GetArenaNoVirtual() == nullptr && vector_param_ != nullptr) { + delete vector_param_; + } + vector_param_ = nullptr; + if (GetArenaNoVirtual() == nullptr && segments_ != nullptr) { + delete segments_; + } + segments_ = nullptr; + ::memset(&entity_id_, 0, static_cast( + reinterpret_cast(&msg_type_) - + reinterpret_cast(&entity_id_)) + sizeof(msg_type_)); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* PulsarMessage::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // string collection_name = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_collection_name(), ptr, ctx, "pb.PulsarMessage.collection_name"); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated .pb.FieldValue fields = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(add_fields(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 18); + } else goto handle_unusual; + continue; + // int64 entity_id = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + entity_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // string partition_tag = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_partition_tag(), ptr, ctx, "pb.PulsarMessage.partition_tag"); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .pb.VectorParam vector_param = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { + ptr = ctx->ParseMessage(mutable_vector_param(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .pb.SegmentRecord segments = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) { + ptr = ctx->ParseMessage(mutable_segments(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // int64 timestamp = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 56)) { + timestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // int64 client_id = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 64)) { + client_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .pb.OpType msg_type = 9; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 72)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + set_msg_type(static_cast<::pb::OpType>(val)); + } else goto handle_unusual; + continue; + // string topic_name = 10; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_topic_name(), ptr, ctx, "pb.PulsarMessage.topic_name"); + CHK_(ptr); + } else goto handle_unusual; + continue; + // int64 partition_id = 11; + case 11: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 88)) { + partition_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool PulsarMessage::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:pb.PulsarMessage) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // string collection_name = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_collection_name())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "pb.PulsarMessage.collection_name")); + } else { + goto handle_unusual; + } + break; + } + + // repeated .pb.FieldValue fields = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, add_fields())); + } else { + goto handle_unusual; + } + break; + } + + // int64 entity_id = 3; + case 3: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (24 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + input, &entity_id_))); + } else { + goto handle_unusual; + } + break; + } + + // string partition_tag = 4; + case 4: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (34 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_partition_tag())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->partition_tag().data(), static_cast(this->partition_tag().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "pb.PulsarMessage.partition_tag")); + } else { + goto handle_unusual; + } + break; + } + + // .pb.VectorParam vector_param = 5; + case 5: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (42 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, mutable_vector_param())); + } else { + goto handle_unusual; + } + break; + } + + // .pb.SegmentRecord segments = 6; + case 6: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (50 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, mutable_segments())); + } else { + goto handle_unusual; + } + break; + } + + // int64 timestamp = 7; + case 7: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (56 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + input, ×tamp_))); + } else { + goto handle_unusual; + } + break; + } + + // int64 client_id = 8; + case 8: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (64 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + input, &client_id_))); + } else { + goto handle_unusual; + } + break; + } + + // .pb.OpType msg_type = 9; + case 9: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (72 & 0xFF)) { + int value = 0; + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + int, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + set_msg_type(static_cast< ::pb::OpType >(value)); + } else { + goto handle_unusual; + } + break; + } + + // string topic_name = 10; + case 10: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (82 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_topic_name())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->topic_name().data(), static_cast(this->topic_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "pb.PulsarMessage.topic_name")); + } else { + goto handle_unusual; + } + break; + } + + // int64 partition_id = 11; + case 11: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (88 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + input, &partition_id_))); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:pb.PulsarMessage) + return true; +failure: + // @@protoc_insertion_point(parse_failure:pb.PulsarMessage) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void PulsarMessage::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:pb.PulsarMessage) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string collection_name = 1; + if (this->collection_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "pb.PulsarMessage.collection_name"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->collection_name(), output); + } + + // repeated .pb.FieldValue fields = 2; + for (unsigned int i = 0, + n = static_cast(this->fields_size()); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, + this->fields(static_cast(i)), + output); + } + + // int64 entity_id = 3; + if (this->entity_id() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(3, this->entity_id(), output); + } + + // string partition_tag = 4; + if (this->partition_tag().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->partition_tag().data(), static_cast(this->partition_tag().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "pb.PulsarMessage.partition_tag"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 4, this->partition_tag(), output); + } + + // .pb.VectorParam vector_param = 5; + if (this->has_vector_param()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 5, _Internal::vector_param(this), output); + } + + // .pb.SegmentRecord segments = 6; + if (this->has_segments()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 6, _Internal::segments(this), output); + } + + // int64 timestamp = 7; + if (this->timestamp() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(7, this->timestamp(), output); + } + + // int64 client_id = 8; + if (this->client_id() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(8, this->client_id(), output); + } + + // .pb.OpType msg_type = 9; + if (this->msg_type() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnum( + 9, this->msg_type(), output); + } + + // string topic_name = 10; + if (this->topic_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->topic_name().data(), static_cast(this->topic_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "pb.PulsarMessage.topic_name"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 10, this->topic_name(), output); + } + + // int64 partition_id = 11; + if (this->partition_id() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(11, this->partition_id(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:pb.PulsarMessage) +} + +::PROTOBUF_NAMESPACE_ID::uint8* PulsarMessage::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:pb.PulsarMessage) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string collection_name = 1; + if (this->collection_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "pb.PulsarMessage.collection_name"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 1, this->collection_name(), target); + } + + // repeated .pb.FieldValue fields = 2; + for (unsigned int i = 0, + n = static_cast(this->fields_size()); i < n; i++) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 2, this->fields(static_cast(i)), target); + } + + // int64 entity_id = 3; + if (this->entity_id() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(3, this->entity_id(), target); + } + + // string partition_tag = 4; + if (this->partition_tag().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->partition_tag().data(), static_cast(this->partition_tag().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "pb.PulsarMessage.partition_tag"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 4, this->partition_tag(), target); + } + + // .pb.VectorParam vector_param = 5; + if (this->has_vector_param()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 5, _Internal::vector_param(this), target); + } + + // .pb.SegmentRecord segments = 6; + if (this->has_segments()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 6, _Internal::segments(this), target); + } + + // int64 timestamp = 7; + if (this->timestamp() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(7, this->timestamp(), target); + } + + // int64 client_id = 8; + if (this->client_id() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(8, this->client_id(), target); + } + + // .pb.OpType msg_type = 9; + if (this->msg_type() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 9, this->msg_type(), target); + } + + // string topic_name = 10; + if (this->topic_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->topic_name().data(), static_cast(this->topic_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "pb.PulsarMessage.topic_name"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 10, this->topic_name(), target); + } + + // int64 partition_id = 11; + if (this->partition_id() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(11, this->partition_id(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:pb.PulsarMessage) + return target; +} + +size_t PulsarMessage::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:pb.PulsarMessage) + 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 .pb.FieldValue fields = 2; + { + unsigned int count = static_cast(this->fields_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + this->fields(static_cast(i))); + } + } + + // string collection_name = 1; + if (this->collection_name().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->collection_name()); + } + + // string partition_tag = 4; + if (this->partition_tag().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->partition_tag()); + } + + // string topic_name = 10; + if (this->topic_name().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->topic_name()); + } + + // .pb.VectorParam vector_param = 5; + if (this->has_vector_param()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *vector_param_); + } + + // .pb.SegmentRecord segments = 6; + if (this->has_segments()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *segments_); + } + + // int64 entity_id = 3; + if (this->entity_id() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( + this->entity_id()); + } + + // int64 timestamp = 7; + if (this->timestamp() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( + this->timestamp()); + } + + // int64 client_id = 8; + if (this->client_id() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( + this->client_id()); + } + + // int64 partition_id = 11; + if (this->partition_id() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( + this->partition_id()); + } + + // .pb.OpType msg_type = 9; + if (this->msg_type() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->msg_type()); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void PulsarMessage::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:pb.PulsarMessage) + GOOGLE_DCHECK_NE(&from, this); + const PulsarMessage* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.PulsarMessage) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.PulsarMessage) + MergeFrom(*source); + } +} + +void PulsarMessage::MergeFrom(const PulsarMessage& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:pb.PulsarMessage) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + fields_.MergeFrom(from.fields_); + if (from.collection_name().size() > 0) { + + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); + } + if (from.partition_tag().size() > 0) { + + partition_tag_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.partition_tag_); + } + if (from.topic_name().size() > 0) { + + topic_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.topic_name_); + } + if (from.has_vector_param()) { + mutable_vector_param()->::pb::VectorParam::MergeFrom(from.vector_param()); + } + if (from.has_segments()) { + mutable_segments()->::pb::SegmentRecord::MergeFrom(from.segments()); + } + if (from.entity_id() != 0) { + set_entity_id(from.entity_id()); + } + if (from.timestamp() != 0) { + set_timestamp(from.timestamp()); + } + if (from.client_id() != 0) { + set_client_id(from.client_id()); + } + if (from.partition_id() != 0) { + set_partition_id(from.partition_id()); + } + if (from.msg_type() != 0) { + set_msg_type(from.msg_type()); + } +} + +void PulsarMessage::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:pb.PulsarMessage) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void PulsarMessage::CopyFrom(const PulsarMessage& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:pb.PulsarMessage) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool PulsarMessage::IsInitialized() const { + return true; +} + +void PulsarMessage::InternalSwap(PulsarMessage* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + CastToBase(&fields_)->InternalSwap(CastToBase(&other->fields_)); + collection_name_.Swap(&other->collection_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + partition_tag_.Swap(&other->partition_tag_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + topic_name_.Swap(&other->topic_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(vector_param_, other->vector_param_); + swap(segments_, other->segments_); + swap(entity_id_, other->entity_id_); + swap(timestamp_, other->timestamp_); + swap(client_id_, other->client_id_); + swap(partition_id_, other->partition_id_); + swap(msg_type_, other->msg_type_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata PulsarMessage::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void TestData::InitAsDefaultInstance() { +} +class TestData::_Internal { + public: +}; + +TestData::TestData() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:pb.TestData) +} +TestData::TestData(const TestData& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.id().empty()) { + id_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.id_); + } + name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.name().empty()) { + name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.name_); + } + // @@protoc_insertion_point(copy_constructor:pb.TestData) +} + +void TestData::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_TestData_pulsar_2eproto.base); + id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +TestData::~TestData() { + // @@protoc_insertion_point(destructor:pb.TestData) + SharedDtor(); +} + +void TestData::SharedDtor() { + id_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void TestData::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const TestData& TestData::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_TestData_pulsar_2eproto.base); + return *internal_default_instance(); +} + + +void TestData::Clear() { +// @@protoc_insertion_point(message_clear_start:pb.TestData) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + id_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* TestData::_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 id = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_id(), ptr, ctx, "pb.TestData.id"); + CHK_(ptr); + } else goto handle_unusual; + continue; + // string name = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_name(), ptr, ctx, "pb.TestData.name"); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool TestData::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:pb.TestData) + 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 id = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_id())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->id().data(), static_cast(this->id().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "pb.TestData.id")); + } else { + goto handle_unusual; + } + break; + } + + // string name = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_name())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->name().data(), static_cast(this->name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "pb.TestData.name")); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:pb.TestData) + return true; +failure: + // @@protoc_insertion_point(parse_failure:pb.TestData) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void TestData::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:pb.TestData) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string id = 1; + if (this->id().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->id().data(), static_cast(this->id().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "pb.TestData.id"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->id(), output); + } + + // string name = 2; + if (this->name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->name().data(), static_cast(this->name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "pb.TestData.name"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 2, this->name(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:pb.TestData) +} + +::PROTOBUF_NAMESPACE_ID::uint8* TestData::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:pb.TestData) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string id = 1; + if (this->id().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->id().data(), static_cast(this->id().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "pb.TestData.id"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 1, this->id(), target); + } + + // string name = 2; + if (this->name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->name().data(), static_cast(this->name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "pb.TestData.name"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 2, this->name(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:pb.TestData) + return target; +} + +size_t TestData::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:pb.TestData) + 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 id = 1; + if (this->id().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->id()); + } + + // string name = 2; + if (this->name().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->name()); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void TestData::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:pb.TestData) + GOOGLE_DCHECK_NE(&from, this); + const TestData* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.TestData) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.TestData) + MergeFrom(*source); + } +} + +void TestData::MergeFrom(const TestData& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:pb.TestData) + 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.id().size() > 0) { + + id_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.id_); + } + if (from.name().size() > 0) { + + name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.name_); + } +} + +void TestData::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:pb.TestData) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void TestData::CopyFrom(const TestData& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:pb.TestData) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool TestData::IsInitialized() const { + return true; +} + +void TestData::InternalSwap(TestData* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + id_.Swap(&other->id_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} + +::PROTOBUF_NAMESPACE_ID::Metadata TestData::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void InsertMsg::InitAsDefaultInstance() { +} +class InsertMsg::_Internal { + public: +}; + +InsertMsg::InsertMsg() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:pb.InsertMsg) +} +InsertMsg::InsertMsg(const InsertMsg& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + client_id_ = from.client_id_; + // @@protoc_insertion_point(copy_constructor:pb.InsertMsg) +} + +void InsertMsg::SharedCtor() { + client_id_ = PROTOBUF_LONGLONG(0); +} + +InsertMsg::~InsertMsg() { + // @@protoc_insertion_point(destructor:pb.InsertMsg) + SharedDtor(); +} + +void InsertMsg::SharedDtor() { +} + +void InsertMsg::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const InsertMsg& InsertMsg::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_InsertMsg_pulsar_2eproto.base); + return *internal_default_instance(); +} + + +void InsertMsg::Clear() { +// @@protoc_insertion_point(message_clear_start:pb.InsertMsg) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + client_id_ = PROTOBUF_LONGLONG(0); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* InsertMsg::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // int64 client_id = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + client_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool InsertMsg::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:pb.InsertMsg) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // int64 client_id = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + input, &client_id_))); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:pb.InsertMsg) + return true; +failure: + // @@protoc_insertion_point(parse_failure:pb.InsertMsg) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void InsertMsg::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:pb.InsertMsg) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // int64 client_id = 1; + if (this->client_id() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(1, this->client_id(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:pb.InsertMsg) +} + +::PROTOBUF_NAMESPACE_ID::uint8* InsertMsg::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:pb.InsertMsg) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // int64 client_id = 1; + if (this->client_id() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(1, this->client_id(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:pb.InsertMsg) + return target; +} + +size_t InsertMsg::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:pb.InsertMsg) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // int64 client_id = 1; + if (this->client_id() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( + this->client_id()); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void InsertMsg::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:pb.InsertMsg) + GOOGLE_DCHECK_NE(&from, this); + const InsertMsg* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.InsertMsg) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.InsertMsg) + MergeFrom(*source); + } +} + +void InsertMsg::MergeFrom(const InsertMsg& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:pb.InsertMsg) + 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.client_id() != 0) { + set_client_id(from.client_id()); + } +} + +void InsertMsg::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:pb.InsertMsg) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void InsertMsg::CopyFrom(const InsertMsg& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:pb.InsertMsg) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool InsertMsg::IsInitialized() const { + return true; +} + +void InsertMsg::InternalSwap(InsertMsg* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(client_id_, other->client_id_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata InsertMsg::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void DeleteMsg::InitAsDefaultInstance() { +} +class DeleteMsg::_Internal { + public: +}; + +DeleteMsg::DeleteMsg() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:pb.DeleteMsg) +} +DeleteMsg::DeleteMsg(const DeleteMsg& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + client_id_ = from.client_id_; + // @@protoc_insertion_point(copy_constructor:pb.DeleteMsg) +} + +void DeleteMsg::SharedCtor() { + client_id_ = PROTOBUF_LONGLONG(0); +} + +DeleteMsg::~DeleteMsg() { + // @@protoc_insertion_point(destructor:pb.DeleteMsg) + SharedDtor(); +} + +void DeleteMsg::SharedDtor() { +} + +void DeleteMsg::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const DeleteMsg& DeleteMsg::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_DeleteMsg_pulsar_2eproto.base); + return *internal_default_instance(); +} + + +void DeleteMsg::Clear() { +// @@protoc_insertion_point(message_clear_start:pb.DeleteMsg) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + client_id_ = PROTOBUF_LONGLONG(0); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* DeleteMsg::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // int64 client_id = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + client_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool DeleteMsg::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:pb.DeleteMsg) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // int64 client_id = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + input, &client_id_))); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:pb.DeleteMsg) + return true; +failure: + // @@protoc_insertion_point(parse_failure:pb.DeleteMsg) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void DeleteMsg::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:pb.DeleteMsg) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // int64 client_id = 1; + if (this->client_id() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(1, this->client_id(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:pb.DeleteMsg) +} + +::PROTOBUF_NAMESPACE_ID::uint8* DeleteMsg::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:pb.DeleteMsg) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // int64 client_id = 1; + if (this->client_id() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(1, this->client_id(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:pb.DeleteMsg) + return target; +} + +size_t DeleteMsg::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:pb.DeleteMsg) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // int64 client_id = 1; + if (this->client_id() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( + this->client_id()); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void DeleteMsg::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:pb.DeleteMsg) + GOOGLE_DCHECK_NE(&from, this); + const DeleteMsg* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.DeleteMsg) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.DeleteMsg) + MergeFrom(*source); + } +} + +void DeleteMsg::MergeFrom(const DeleteMsg& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:pb.DeleteMsg) + 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.client_id() != 0) { + set_client_id(from.client_id()); + } +} + +void DeleteMsg::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:pb.DeleteMsg) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void DeleteMsg::CopyFrom(const DeleteMsg& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:pb.DeleteMsg) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool DeleteMsg::IsInitialized() const { + return true; +} + +void DeleteMsg::InternalSwap(DeleteMsg* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(client_id_, other->client_id_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata DeleteMsg::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void SearchMsg::InitAsDefaultInstance() { +} +class SearchMsg::_Internal { + public: +}; + +SearchMsg::SearchMsg() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:pb.SearchMsg) +} +SearchMsg::SearchMsg(const SearchMsg& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + client_id_ = from.client_id_; + // @@protoc_insertion_point(copy_constructor:pb.SearchMsg) +} + +void SearchMsg::SharedCtor() { + client_id_ = PROTOBUF_LONGLONG(0); +} + +SearchMsg::~SearchMsg() { + // @@protoc_insertion_point(destructor:pb.SearchMsg) + SharedDtor(); +} + +void SearchMsg::SharedDtor() { +} + +void SearchMsg::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const SearchMsg& SearchMsg::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_SearchMsg_pulsar_2eproto.base); + return *internal_default_instance(); +} + + +void SearchMsg::Clear() { +// @@protoc_insertion_point(message_clear_start:pb.SearchMsg) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + client_id_ = PROTOBUF_LONGLONG(0); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* SearchMsg::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // int64 client_id = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + client_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool SearchMsg::MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + // @@protoc_insertion_point(parse_start:pb.SearchMsg) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // int64 client_id = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + input, &client_id_))); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:pb.SearchMsg) + return true; +failure: + // @@protoc_insertion_point(parse_failure:pb.SearchMsg) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void SearchMsg::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:pb.SearchMsg) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // int64 client_id = 1; + if (this->client_id() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(1, this->client_id(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:pb.SearchMsg) +} + +::PROTOBUF_NAMESPACE_ID::uint8* SearchMsg::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:pb.SearchMsg) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // int64 client_id = 1; + if (this->client_id() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(1, this->client_id(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:pb.SearchMsg) + return target; +} + +size_t SearchMsg::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:pb.SearchMsg) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // int64 client_id = 1; + if (this->client_id() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( + this->client_id()); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void SearchMsg::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:pb.SearchMsg) + GOOGLE_DCHECK_NE(&from, this); + const SearchMsg* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.SearchMsg) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.SearchMsg) + MergeFrom(*source); + } +} + +void SearchMsg::MergeFrom(const SearchMsg& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:pb.SearchMsg) + 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.client_id() != 0) { + set_client_id(from.client_id()); + } +} + +void SearchMsg::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:pb.SearchMsg) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void SearchMsg::CopyFrom(const SearchMsg& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:pb.SearchMsg) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SearchMsg::IsInitialized() const { + return true; +} + +void SearchMsg::InternalSwap(SearchMsg* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(client_id_, other->client_id_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SearchMsg::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void SearchResultMsg::InitAsDefaultInstance() { +} +class SearchResultMsg::_Internal { + public: +}; + +SearchResultMsg::SearchResultMsg() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:pb.SearchResultMsg) +} +SearchResultMsg::SearchResultMsg(const SearchResultMsg& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + client_id_ = from.client_id_; + // @@protoc_insertion_point(copy_constructor:pb.SearchResultMsg) +} + +void SearchResultMsg::SharedCtor() { + client_id_ = PROTOBUF_LONGLONG(0); +} + +SearchResultMsg::~SearchResultMsg() { + // @@protoc_insertion_point(destructor:pb.SearchResultMsg) + SharedDtor(); +} + +void SearchResultMsg::SharedDtor() { +} + +void SearchResultMsg::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const SearchResultMsg& SearchResultMsg::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_SearchResultMsg_pulsar_2eproto.base); + return *internal_default_instance(); +} + + +void SearchResultMsg::Clear() { +// @@protoc_insertion_point(message_clear_start:pb.SearchResultMsg) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + client_id_ = PROTOBUF_LONGLONG(0); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* SearchResultMsg::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // int64 client_id = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + client_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool SearchResultMsg::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:pb.SearchResultMsg) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // int64 client_id = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + input, &client_id_))); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:pb.SearchResultMsg) + return true; +failure: + // @@protoc_insertion_point(parse_failure:pb.SearchResultMsg) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void SearchResultMsg::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:pb.SearchResultMsg) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // int64 client_id = 1; + if (this->client_id() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(1, this->client_id(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:pb.SearchResultMsg) +} + +::PROTOBUF_NAMESPACE_ID::uint8* SearchResultMsg::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:pb.SearchResultMsg) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // int64 client_id = 1; + if (this->client_id() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(1, this->client_id(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:pb.SearchResultMsg) + return target; +} + +size_t SearchResultMsg::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:pb.SearchResultMsg) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // int64 client_id = 1; + if (this->client_id() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( + this->client_id()); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void SearchResultMsg::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:pb.SearchResultMsg) + GOOGLE_DCHECK_NE(&from, this); + const SearchResultMsg* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.SearchResultMsg) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.SearchResultMsg) + MergeFrom(*source); + } +} + +void SearchResultMsg::MergeFrom(const SearchResultMsg& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:pb.SearchResultMsg) + 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.client_id() != 0) { + set_client_id(from.client_id()); + } +} + +void SearchResultMsg::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:pb.SearchResultMsg) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void SearchResultMsg::CopyFrom(const SearchResultMsg& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:pb.SearchResultMsg) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SearchResultMsg::IsInitialized() const { + return true; +} + +void SearchResultMsg::InternalSwap(SearchResultMsg* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(client_id_, other->client_id_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SearchResultMsg::GetMetadata() const { + return GetMetadataStatic(); +} + + +// @@protoc_insertion_point(namespace_scope) +} // namespace pb +PROTOBUF_NAMESPACE_OPEN +template<> PROTOBUF_NOINLINE ::pb::Status* Arena::CreateMaybeMessage< ::pb::Status >(Arena* arena) { + return Arena::CreateInternal< ::pb::Status >(arena); +} +template<> PROTOBUF_NOINLINE ::pb::SegmentRecord* Arena::CreateMaybeMessage< ::pb::SegmentRecord >(Arena* arena) { + return Arena::CreateInternal< ::pb::SegmentRecord >(arena); +} +template<> PROTOBUF_NOINLINE ::pb::VectorRowRecord* Arena::CreateMaybeMessage< ::pb::VectorRowRecord >(Arena* arena) { + return Arena::CreateInternal< ::pb::VectorRowRecord >(arena); +} +template<> PROTOBUF_NOINLINE ::pb::AttrRecord* Arena::CreateMaybeMessage< ::pb::AttrRecord >(Arena* arena) { + return Arena::CreateInternal< ::pb::AttrRecord >(arena); +} +template<> PROTOBUF_NOINLINE ::pb::VectorRecord* Arena::CreateMaybeMessage< ::pb::VectorRecord >(Arena* arena) { + return Arena::CreateInternal< ::pb::VectorRecord >(arena); +} +template<> PROTOBUF_NOINLINE ::pb::VectorParam* Arena::CreateMaybeMessage< ::pb::VectorParam >(Arena* arena) { + return Arena::CreateInternal< ::pb::VectorParam >(arena); +} +template<> PROTOBUF_NOINLINE ::pb::FieldValue* Arena::CreateMaybeMessage< ::pb::FieldValue >(Arena* arena) { + return Arena::CreateInternal< ::pb::FieldValue >(arena); +} +template<> PROTOBUF_NOINLINE ::pb::Cell* Arena::CreateMaybeMessage< ::pb::Cell >(Arena* arena) { + return Arena::CreateInternal< ::pb::Cell >(arena); +} +template<> PROTOBUF_NOINLINE ::pb::RowValue* Arena::CreateMaybeMessage< ::pb::RowValue >(Arena* arena) { + return Arena::CreateInternal< ::pb::RowValue >(arena); +} +template<> PROTOBUF_NOINLINE ::pb::PulsarMessage* Arena::CreateMaybeMessage< ::pb::PulsarMessage >(Arena* arena) { + return Arena::CreateInternal< ::pb::PulsarMessage >(arena); +} +template<> PROTOBUF_NOINLINE ::pb::TestData* Arena::CreateMaybeMessage< ::pb::TestData >(Arena* arena) { + return Arena::CreateInternal< ::pb::TestData >(arena); +} +template<> PROTOBUF_NOINLINE ::pb::InsertMsg* Arena::CreateMaybeMessage< ::pb::InsertMsg >(Arena* arena) { + return Arena::CreateInternal< ::pb::InsertMsg >(arena); +} +template<> PROTOBUF_NOINLINE ::pb::DeleteMsg* Arena::CreateMaybeMessage< ::pb::DeleteMsg >(Arena* arena) { + return Arena::CreateInternal< ::pb::DeleteMsg >(arena); +} +template<> PROTOBUF_NOINLINE ::pb::SearchMsg* Arena::CreateMaybeMessage< ::pb::SearchMsg >(Arena* arena) { + return Arena::CreateInternal< ::pb::SearchMsg >(arena); +} +template<> PROTOBUF_NOINLINE ::pb::SearchResultMsg* Arena::CreateMaybeMessage< ::pb::SearchResultMsg >(Arena* arena) { + return Arena::CreateInternal< ::pb::SearchResultMsg >(arena); +} +PROTOBUF_NAMESPACE_CLOSE + +// @@protoc_insertion_point(global_scope) +#include diff --git a/proxy/src/pulsar/message_client/pb/pulsar.pb.h b/proxy/src/pulsar/message_client/pb/pulsar.pb.h new file mode 100644 index 0000000000..e7e0429b83 --- /dev/null +++ b/proxy/src/pulsar/message_client/pb/pulsar.pb.h @@ -0,0 +1,4013 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: pulsar.proto + +#ifndef GOOGLE_PROTOBUF_INCLUDED_pulsar_2eproto +#define GOOGLE_PROTOBUF_INCLUDED_pulsar_2eproto + +#include +#include + +#include +#if PROTOBUF_VERSION < 3009000 +#error This file was generated by a newer version of protoc which is +#error incompatible with your Protocol Buffer headers. Please update +#error your headers. +#endif +#if 3009000 < PROTOBUF_MIN_PROTOC_VERSION +#error This file was generated by an older version of protoc which is +#error incompatible with your Protocol Buffer headers. Please +#error regenerate this file with a newer version of protoc. +#endif + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include // IWYU pragma: export +#include // IWYU pragma: export +#include +#include +// @@protoc_insertion_point(includes) +#include +#define PROTOBUF_INTERNAL_EXPORT_pulsar_2eproto +PROTOBUF_NAMESPACE_OPEN +namespace internal { +class AnyMetadata; +} // namespace internal +PROTOBUF_NAMESPACE_CLOSE + +// Internal implementation detail -- do not use these members. +struct TableStruct_pulsar_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[15] + 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_pulsar_2eproto; +namespace pb { +class AttrRecord; +class AttrRecordDefaultTypeInternal; +extern AttrRecordDefaultTypeInternal _AttrRecord_default_instance_; +class Cell; +class CellDefaultTypeInternal; +extern CellDefaultTypeInternal _Cell_default_instance_; +class DeleteMsg; +class DeleteMsgDefaultTypeInternal; +extern DeleteMsgDefaultTypeInternal _DeleteMsg_default_instance_; +class FieldValue; +class FieldValueDefaultTypeInternal; +extern FieldValueDefaultTypeInternal _FieldValue_default_instance_; +class InsertMsg; +class InsertMsgDefaultTypeInternal; +extern InsertMsgDefaultTypeInternal _InsertMsg_default_instance_; +class PulsarMessage; +class PulsarMessageDefaultTypeInternal; +extern PulsarMessageDefaultTypeInternal _PulsarMessage_default_instance_; +class RowValue; +class RowValueDefaultTypeInternal; +extern RowValueDefaultTypeInternal _RowValue_default_instance_; +class SearchMsg; +class SearchMsgDefaultTypeInternal; +extern SearchMsgDefaultTypeInternal _SearchMsg_default_instance_; +class SearchResultMsg; +class SearchResultMsgDefaultTypeInternal; +extern SearchResultMsgDefaultTypeInternal _SearchResultMsg_default_instance_; +class SegmentRecord; +class SegmentRecordDefaultTypeInternal; +extern SegmentRecordDefaultTypeInternal _SegmentRecord_default_instance_; +class Status; +class StatusDefaultTypeInternal; +extern StatusDefaultTypeInternal _Status_default_instance_; +class TestData; +class TestDataDefaultTypeInternal; +extern TestDataDefaultTypeInternal _TestData_default_instance_; +class VectorParam; +class VectorParamDefaultTypeInternal; +extern VectorParamDefaultTypeInternal _VectorParam_default_instance_; +class VectorRecord; +class VectorRecordDefaultTypeInternal; +extern VectorRecordDefaultTypeInternal _VectorRecord_default_instance_; +class VectorRowRecord; +class VectorRowRecordDefaultTypeInternal; +extern VectorRowRecordDefaultTypeInternal _VectorRowRecord_default_instance_; +} // namespace pb +PROTOBUF_NAMESPACE_OPEN +template<> ::pb::AttrRecord* Arena::CreateMaybeMessage<::pb::AttrRecord>(Arena*); +template<> ::pb::Cell* Arena::CreateMaybeMessage<::pb::Cell>(Arena*); +template<> ::pb::DeleteMsg* Arena::CreateMaybeMessage<::pb::DeleteMsg>(Arena*); +template<> ::pb::FieldValue* Arena::CreateMaybeMessage<::pb::FieldValue>(Arena*); +template<> ::pb::InsertMsg* Arena::CreateMaybeMessage<::pb::InsertMsg>(Arena*); +template<> ::pb::PulsarMessage* Arena::CreateMaybeMessage<::pb::PulsarMessage>(Arena*); +template<> ::pb::RowValue* Arena::CreateMaybeMessage<::pb::RowValue>(Arena*); +template<> ::pb::SearchMsg* Arena::CreateMaybeMessage<::pb::SearchMsg>(Arena*); +template<> ::pb::SearchResultMsg* Arena::CreateMaybeMessage<::pb::SearchResultMsg>(Arena*); +template<> ::pb::SegmentRecord* Arena::CreateMaybeMessage<::pb::SegmentRecord>(Arena*); +template<> ::pb::Status* Arena::CreateMaybeMessage<::pb::Status>(Arena*); +template<> ::pb::TestData* Arena::CreateMaybeMessage<::pb::TestData>(Arena*); +template<> ::pb::VectorParam* Arena::CreateMaybeMessage<::pb::VectorParam>(Arena*); +template<> ::pb::VectorRecord* Arena::CreateMaybeMessage<::pb::VectorRecord>(Arena*); +template<> ::pb::VectorRowRecord* Arena::CreateMaybeMessage<::pb::VectorRowRecord>(Arena*); +PROTOBUF_NAMESPACE_CLOSE +namespace pb { + +enum ErrorCode : int { + SUCCESS = 0, + UNEXPECTED_ERROR = 1, + CONNECT_FAILED = 2, + PERMISSION_DENIED = 3, + COLLECTION_NOT_EXISTS = 4, + ILLEGAL_ARGUMENT = 5, + ILLEGAL_DIMENSION = 7, + ILLEGAL_INDEX_TYPE = 8, + ILLEGAL_COLLECTION_NAME = 9, + ILLEGAL_TOPK = 10, + ILLEGAL_ROWRECORD = 11, + ILLEGAL_VECTOR_ID = 12, + ILLEGAL_SEARCH_RESULT = 13, + FILE_NOT_FOUND = 14, + META_FAILED = 15, + CACHE_FAILED = 16, + CANNOT_CREATE_FOLDER = 17, + CANNOT_CREATE_FILE = 18, + CANNOT_DELETE_FOLDER = 19, + CANNOT_DELETE_FILE = 20, + BUILD_INDEX_ERROR = 21, + ILLEGAL_NLIST = 22, + ILLEGAL_METRIC_TYPE = 23, + OUT_OF_MEMORY = 24, + ErrorCode_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(), + ErrorCode_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max() +}; +bool ErrorCode_IsValid(int value); +constexpr ErrorCode ErrorCode_MIN = SUCCESS; +constexpr ErrorCode ErrorCode_MAX = OUT_OF_MEMORY; +constexpr int ErrorCode_ARRAYSIZE = ErrorCode_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ErrorCode_descriptor(); +template +inline const std::string& ErrorCode_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function ErrorCode_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + ErrorCode_descriptor(), enum_t_value); +} +inline bool ErrorCode_Parse( + const std::string& name, ErrorCode* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + ErrorCode_descriptor(), name, value); +} +enum DataType : int { + NONE = 0, + BOOL = 1, + INT8 = 2, + INT16 = 3, + INT32 = 4, + INT64 = 5, + FLOAT = 10, + DOUBLE = 11, + STRING = 20, + VECTOR_BINARY = 100, + VECTOR_FLOAT = 101, + DataType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(), + DataType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max() +}; +bool DataType_IsValid(int value); +constexpr DataType DataType_MIN = NONE; +constexpr DataType DataType_MAX = VECTOR_FLOAT; +constexpr int DataType_ARRAYSIZE = DataType_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DataType_descriptor(); +template +inline const std::string& DataType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function DataType_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + DataType_descriptor(), enum_t_value); +} +inline bool DataType_Parse( + const std::string& name, DataType* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + DataType_descriptor(), name, value); +} +enum OpType : int { + Insert = 0, + Delete = 1, + Search = 2, + TimeSync = 3, + Key2Seg = 4, + Statistics = 5, + OpType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(), + OpType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max() +}; +bool OpType_IsValid(int value); +constexpr OpType OpType_MIN = Insert; +constexpr OpType OpType_MAX = Statistics; +constexpr int OpType_ARRAYSIZE = OpType_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* OpType_descriptor(); +template +inline const std::string& OpType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function OpType_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + OpType_descriptor(), enum_t_value); +} +inline bool OpType_Parse( + const std::string& name, OpType* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + OpType_descriptor(), name, value); +} +// =================================================================== + +class Status : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.Status) */ { + public: + Status(); + virtual ~Status(); + + Status(const Status& from); + Status(Status&& from) noexcept + : Status() { + *this = ::std::move(from); + } + + inline Status& operator=(const Status& from) { + CopyFrom(from); + return *this; + } + inline Status& operator=(Status&& from) noexcept { + if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const Status& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const Status* internal_default_instance() { + return reinterpret_cast( + &_Status_default_instance_); + } + static constexpr int kIndexInFileMessages = + 0; + + friend void swap(Status& a, Status& b) { + a.Swap(&b); + } + inline void Swap(Status* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Status* New() const final { + return CreateMaybeMessage(nullptr); + } + + Status* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Status& from); + void MergeFrom(const Status& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + #else + bool MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final; + #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + void SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final; + ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Status* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "pb.Status"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_pulsar_2eproto); + return ::descriptor_table_pulsar_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kReasonFieldNumber = 2, + kErrorCodeFieldNumber = 1, + }; + // string reason = 2; + void clear_reason(); + const std::string& reason() const; + void set_reason(const std::string& value); + void set_reason(std::string&& value); + void set_reason(const char* value); + void set_reason(const char* value, size_t size); + std::string* mutable_reason(); + std::string* release_reason(); + void set_allocated_reason(std::string* reason); + + // .pb.ErrorCode error_code = 1; + void clear_error_code(); + ::pb::ErrorCode error_code() const; + void set_error_code(::pb::ErrorCode value); + + // @@protoc_insertion_point(class_scope:pb.Status) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr reason_; + int error_code_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_pulsar_2eproto; +}; +// ------------------------------------------------------------------- + +class SegmentRecord : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.SegmentRecord) */ { + public: + SegmentRecord(); + virtual ~SegmentRecord(); + + SegmentRecord(const SegmentRecord& from); + SegmentRecord(SegmentRecord&& from) noexcept + : SegmentRecord() { + *this = ::std::move(from); + } + + inline SegmentRecord& operator=(const SegmentRecord& from) { + CopyFrom(from); + return *this; + } + inline SegmentRecord& operator=(SegmentRecord&& 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 SegmentRecord& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const SegmentRecord* internal_default_instance() { + return reinterpret_cast( + &_SegmentRecord_default_instance_); + } + static constexpr int kIndexInFileMessages = + 1; + + friend void swap(SegmentRecord& a, SegmentRecord& b) { + a.Swap(&b); + } + inline void Swap(SegmentRecord* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline SegmentRecord* New() const final { + return CreateMaybeMessage(nullptr); + } + + SegmentRecord* 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 SegmentRecord& from); + void MergeFrom(const SegmentRecord& 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(SegmentRecord* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "pb.SegmentRecord"; + } + 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_pulsar_2eproto); + return ::descriptor_table_pulsar_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kSegInfoFieldNumber = 1, + }; + // repeated string seg_info = 1; + int seg_info_size() const; + void clear_seg_info(); + const std::string& seg_info(int index) const; + std::string* mutable_seg_info(int index); + void set_seg_info(int index, const std::string& value); + void set_seg_info(int index, std::string&& value); + void set_seg_info(int index, const char* value); + void set_seg_info(int index, const char* value, size_t size); + std::string* add_seg_info(); + void add_seg_info(const std::string& value); + void add_seg_info(std::string&& value); + void add_seg_info(const char* value); + void add_seg_info(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& seg_info() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_seg_info(); + + // @@protoc_insertion_point(class_scope:pb.SegmentRecord) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField seg_info_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_pulsar_2eproto; +}; +// ------------------------------------------------------------------- + +class VectorRowRecord : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.VectorRowRecord) */ { + public: + VectorRowRecord(); + virtual ~VectorRowRecord(); + + VectorRowRecord(const VectorRowRecord& from); + VectorRowRecord(VectorRowRecord&& from) noexcept + : VectorRowRecord() { + *this = ::std::move(from); + } + + inline VectorRowRecord& operator=(const VectorRowRecord& from) { + CopyFrom(from); + return *this; + } + inline VectorRowRecord& operator=(VectorRowRecord&& from) noexcept { + if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const VectorRowRecord& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const VectorRowRecord* internal_default_instance() { + return reinterpret_cast( + &_VectorRowRecord_default_instance_); + } + static constexpr int kIndexInFileMessages = + 2; + + friend void swap(VectorRowRecord& a, VectorRowRecord& b) { + a.Swap(&b); + } + inline void Swap(VectorRowRecord* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline VectorRowRecord* New() const final { + return CreateMaybeMessage(nullptr); + } + + VectorRowRecord* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const VectorRowRecord& from); + void MergeFrom(const VectorRowRecord& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + #else + bool MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final; + #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + void SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final; + ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(VectorRowRecord* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "pb.VectorRowRecord"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_pulsar_2eproto); + return ::descriptor_table_pulsar_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kFloatDataFieldNumber = 1, + kBinaryDataFieldNumber = 2, + }; + // repeated float float_data = 1; + int float_data_size() const; + void clear_float_data(); + float float_data(int index) const; + void set_float_data(int index, float value); + void add_float_data(float value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& + float_data() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* + mutable_float_data(); + + // bytes binary_data = 2; + void clear_binary_data(); + const std::string& binary_data() const; + void set_binary_data(const std::string& value); + void set_binary_data(std::string&& value); + void set_binary_data(const char* value); + void set_binary_data(const void* value, size_t size); + std::string* mutable_binary_data(); + std::string* release_binary_data(); + void set_allocated_binary_data(std::string* binary_data); + + // @@protoc_insertion_point(class_scope:pb.VectorRowRecord) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > float_data_; + mutable std::atomic _float_data_cached_byte_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr binary_data_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_pulsar_2eproto; +}; +// ------------------------------------------------------------------- + +class AttrRecord : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.AttrRecord) */ { + public: + AttrRecord(); + virtual ~AttrRecord(); + + AttrRecord(const AttrRecord& from); + AttrRecord(AttrRecord&& from) noexcept + : AttrRecord() { + *this = ::std::move(from); + } + + inline AttrRecord& operator=(const AttrRecord& from) { + CopyFrom(from); + return *this; + } + inline AttrRecord& operator=(AttrRecord&& 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 AttrRecord& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const AttrRecord* internal_default_instance() { + return reinterpret_cast( + &_AttrRecord_default_instance_); + } + static constexpr int kIndexInFileMessages = + 3; + + friend void swap(AttrRecord& a, AttrRecord& b) { + a.Swap(&b); + } + inline void Swap(AttrRecord* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline AttrRecord* New() const final { + return CreateMaybeMessage(nullptr); + } + + AttrRecord* 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 AttrRecord& from); + void MergeFrom(const AttrRecord& 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(AttrRecord* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "pb.AttrRecord"; + } + 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_pulsar_2eproto); + return ::descriptor_table_pulsar_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kInt32ValueFieldNumber = 1, + kInt64ValueFieldNumber = 2, + kFloatValueFieldNumber = 3, + kDoubleValueFieldNumber = 4, + }; + // repeated int32 int32_value = 1; + int int32_value_size() const; + void clear_int32_value(); + ::PROTOBUF_NAMESPACE_ID::int32 int32_value(int index) const; + void set_int32_value(int index, ::PROTOBUF_NAMESPACE_ID::int32 value); + void add_int32_value(::PROTOBUF_NAMESPACE_ID::int32 value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >& + int32_value() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >* + mutable_int32_value(); + + // repeated int64 int64_value = 2; + int int64_value_size() const; + void clear_int64_value(); + ::PROTOBUF_NAMESPACE_ID::int64 int64_value(int index) const; + void set_int64_value(int index, ::PROTOBUF_NAMESPACE_ID::int64 value); + void add_int64_value(::PROTOBUF_NAMESPACE_ID::int64 value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >& + int64_value() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >* + mutable_int64_value(); + + // repeated float float_value = 3; + int float_value_size() const; + void clear_float_value(); + float float_value(int index) const; + void set_float_value(int index, float value); + void add_float_value(float value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& + float_value() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* + mutable_float_value(); + + // repeated double double_value = 4; + int double_value_size() const; + void clear_double_value(); + double double_value(int index) const; + void set_double_value(int index, double value); + void add_double_value(double value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >& + double_value() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >* + mutable_double_value(); + + // @@protoc_insertion_point(class_scope:pb.AttrRecord) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 > int32_value_; + mutable std::atomic _int32_value_cached_byte_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > int64_value_; + mutable std::atomic _int64_value_cached_byte_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > float_value_; + mutable std::atomic _float_value_cached_byte_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< double > double_value_; + mutable std::atomic _double_value_cached_byte_size_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_pulsar_2eproto; +}; +// ------------------------------------------------------------------- + +class VectorRecord : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.VectorRecord) */ { + public: + VectorRecord(); + virtual ~VectorRecord(); + + VectorRecord(const VectorRecord& from); + VectorRecord(VectorRecord&& from) noexcept + : VectorRecord() { + *this = ::std::move(from); + } + + inline VectorRecord& operator=(const VectorRecord& from) { + CopyFrom(from); + return *this; + } + inline VectorRecord& operator=(VectorRecord&& from) noexcept { + if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const VectorRecord& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const VectorRecord* internal_default_instance() { + return reinterpret_cast( + &_VectorRecord_default_instance_); + } + static constexpr int kIndexInFileMessages = + 4; + + friend void swap(VectorRecord& a, VectorRecord& b) { + a.Swap(&b); + } + inline void Swap(VectorRecord* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline VectorRecord* New() const final { + return CreateMaybeMessage(nullptr); + } + + VectorRecord* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const VectorRecord& from); + void MergeFrom(const VectorRecord& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + #else + bool MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final; + #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + void SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final; + ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(VectorRecord* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "pb.VectorRecord"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_pulsar_2eproto); + return ::descriptor_table_pulsar_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kRecordsFieldNumber = 1, + }; + // repeated .pb.VectorRowRecord records = 1; + int records_size() const; + void clear_records(); + ::pb::VectorRowRecord* mutable_records(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::VectorRowRecord >* + mutable_records(); + const ::pb::VectorRowRecord& records(int index) const; + ::pb::VectorRowRecord* add_records(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::VectorRowRecord >& + records() const; + + // @@protoc_insertion_point(class_scope:pb.VectorRecord) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::VectorRowRecord > records_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_pulsar_2eproto; +}; +// ------------------------------------------------------------------- + +class VectorParam : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.VectorParam) */ { + public: + VectorParam(); + virtual ~VectorParam(); + + VectorParam(const VectorParam& from); + VectorParam(VectorParam&& from) noexcept + : VectorParam() { + *this = ::std::move(from); + } + + inline VectorParam& operator=(const VectorParam& from) { + CopyFrom(from); + return *this; + } + inline VectorParam& operator=(VectorParam&& from) noexcept { + if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const VectorParam& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const VectorParam* internal_default_instance() { + return reinterpret_cast( + &_VectorParam_default_instance_); + } + static constexpr int kIndexInFileMessages = + 5; + + friend void swap(VectorParam& a, VectorParam& b) { + a.Swap(&b); + } + inline void Swap(VectorParam* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline VectorParam* New() const final { + return CreateMaybeMessage(nullptr); + } + + VectorParam* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const VectorParam& from); + void MergeFrom(const VectorParam& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + #else + bool MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final; + #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + void SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final; + ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(VectorParam* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "pb.VectorParam"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_pulsar_2eproto); + return ::descriptor_table_pulsar_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kJsonFieldNumber = 1, + kRowRecordFieldNumber = 2, + }; + // string json = 1; + void clear_json(); + const std::string& json() const; + void set_json(const std::string& value); + void set_json(std::string&& value); + void set_json(const char* value); + void set_json(const char* value, size_t size); + std::string* mutable_json(); + std::string* release_json(); + void set_allocated_json(std::string* json); + + // .pb.VectorRecord row_record = 2; + bool has_row_record() const; + void clear_row_record(); + const ::pb::VectorRecord& row_record() const; + ::pb::VectorRecord* release_row_record(); + ::pb::VectorRecord* mutable_row_record(); + void set_allocated_row_record(::pb::VectorRecord* row_record); + + // @@protoc_insertion_point(class_scope:pb.VectorParam) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr json_; + ::pb::VectorRecord* row_record_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_pulsar_2eproto; +}; +// ------------------------------------------------------------------- + +class FieldValue : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.FieldValue) */ { + public: + FieldValue(); + virtual ~FieldValue(); + + FieldValue(const FieldValue& from); + FieldValue(FieldValue&& from) noexcept + : FieldValue() { + *this = ::std::move(from); + } + + inline FieldValue& operator=(const FieldValue& from) { + CopyFrom(from); + return *this; + } + inline FieldValue& operator=(FieldValue&& 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 FieldValue& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const FieldValue* internal_default_instance() { + return reinterpret_cast( + &_FieldValue_default_instance_); + } + static constexpr int kIndexInFileMessages = + 6; + + friend void swap(FieldValue& a, FieldValue& b) { + a.Swap(&b); + } + inline void Swap(FieldValue* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline FieldValue* New() const final { + return CreateMaybeMessage(nullptr); + } + + FieldValue* 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 FieldValue& from); + void MergeFrom(const FieldValue& 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(FieldValue* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "pb.FieldValue"; + } + 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_pulsar_2eproto); + return ::descriptor_table_pulsar_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kFieldNameFieldNumber = 1, + kAttrRecordFieldNumber = 3, + kVectorRecordFieldNumber = 4, + kTypeFieldNumber = 2, + }; + // string field_name = 1; + void clear_field_name(); + const std::string& field_name() const; + void set_field_name(const std::string& value); + void set_field_name(std::string&& value); + void set_field_name(const char* value); + void set_field_name(const char* value, size_t size); + std::string* mutable_field_name(); + std::string* release_field_name(); + void set_allocated_field_name(std::string* field_name); + + // .pb.AttrRecord attr_record = 3; + bool has_attr_record() const; + void clear_attr_record(); + const ::pb::AttrRecord& attr_record() const; + ::pb::AttrRecord* release_attr_record(); + ::pb::AttrRecord* mutable_attr_record(); + void set_allocated_attr_record(::pb::AttrRecord* attr_record); + + // .pb.VectorRecord vector_record = 4; + bool has_vector_record() const; + void clear_vector_record(); + const ::pb::VectorRecord& vector_record() const; + ::pb::VectorRecord* release_vector_record(); + ::pb::VectorRecord* mutable_vector_record(); + void set_allocated_vector_record(::pb::VectorRecord* vector_record); + + // .pb.DataType type = 2; + void clear_type(); + ::pb::DataType type() const; + void set_type(::pb::DataType value); + + // @@protoc_insertion_point(class_scope:pb.FieldValue) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr field_name_; + ::pb::AttrRecord* attr_record_; + ::pb::VectorRecord* vector_record_; + int type_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_pulsar_2eproto; +}; +// ------------------------------------------------------------------- + +class Cell : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.Cell) */ { + public: + Cell(); + virtual ~Cell(); + + Cell(const Cell& from); + Cell(Cell&& from) noexcept + : Cell() { + *this = ::std::move(from); + } + + inline Cell& operator=(const Cell& from) { + CopyFrom(from); + return *this; + } + inline Cell& operator=(Cell&& 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 Cell& default_instance(); + + enum ValueCase { + kInt32Value = 1, + kInt64Value = 2, + kFloatValue = 3, + kDoubleValue = 4, + VALUE_NOT_SET = 0, + }; + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const Cell* internal_default_instance() { + return reinterpret_cast( + &_Cell_default_instance_); + } + static constexpr int kIndexInFileMessages = + 7; + + friend void swap(Cell& a, Cell& b) { + a.Swap(&b); + } + inline void Swap(Cell* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Cell* New() const final { + return CreateMaybeMessage(nullptr); + } + + Cell* 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 Cell& from); + void MergeFrom(const Cell& 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(Cell* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "pb.Cell"; + } + 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_pulsar_2eproto); + return ::descriptor_table_pulsar_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kInt32ValueFieldNumber = 1, + kInt64ValueFieldNumber = 2, + kFloatValueFieldNumber = 3, + kDoubleValueFieldNumber = 4, + }; + // int32 int32_value = 1; + private: + bool has_int32_value() const; + public: + void clear_int32_value(); + ::PROTOBUF_NAMESPACE_ID::int32 int32_value() const; + void set_int32_value(::PROTOBUF_NAMESPACE_ID::int32 value); + + // int64 int64_value = 2; + private: + bool has_int64_value() const; + public: + void clear_int64_value(); + ::PROTOBUF_NAMESPACE_ID::int64 int64_value() const; + void set_int64_value(::PROTOBUF_NAMESPACE_ID::int64 value); + + // float float_value = 3; + private: + bool has_float_value() const; + public: + void clear_float_value(); + float float_value() const; + void set_float_value(float value); + + // double double_value = 4; + private: + bool has_double_value() const; + public: + void clear_double_value(); + double double_value() const; + void set_double_value(double value); + + void clear_value(); + ValueCase value_case() const; + // @@protoc_insertion_point(class_scope:pb.Cell) + private: + class _Internal; + void set_has_int32_value(); + void set_has_int64_value(); + void set_has_float_value(); + void set_has_double_value(); + + inline bool has_value() const; + inline void clear_has_value(); + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + union ValueUnion { + ValueUnion() {} + ::PROTOBUF_NAMESPACE_ID::int32 int32_value_; + ::PROTOBUF_NAMESPACE_ID::int64 int64_value_; + float float_value_; + double double_value_; + } value_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + + friend struct ::TableStruct_pulsar_2eproto; +}; +// ------------------------------------------------------------------- + +class RowValue : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.RowValue) */ { + public: + RowValue(); + virtual ~RowValue(); + + RowValue(const RowValue& from); + RowValue(RowValue&& from) noexcept + : RowValue() { + *this = ::std::move(from); + } + + inline RowValue& operator=(const RowValue& from) { + CopyFrom(from); + return *this; + } + inline RowValue& operator=(RowValue&& 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 RowValue& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const RowValue* internal_default_instance() { + return reinterpret_cast( + &_RowValue_default_instance_); + } + static constexpr int kIndexInFileMessages = + 8; + + friend void swap(RowValue& a, RowValue& b) { + a.Swap(&b); + } + inline void Swap(RowValue* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline RowValue* New() const final { + return CreateMaybeMessage(nullptr); + } + + RowValue* 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 RowValue& from); + void MergeFrom(const RowValue& 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(RowValue* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "pb.RowValue"; + } + 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_pulsar_2eproto); + return ::descriptor_table_pulsar_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kCellFieldNumber = 2, + kVecFieldNumber = 1, + }; + // repeated .pb.Cell cell = 2; + int cell_size() const; + void clear_cell(); + ::pb::Cell* mutable_cell(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::Cell >* + mutable_cell(); + const ::pb::Cell& cell(int index) const; + ::pb::Cell* add_cell(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::Cell >& + cell() const; + + // .pb.VectorRowRecord vec = 1; + bool has_vec() const; + void clear_vec(); + const ::pb::VectorRowRecord& vec() const; + ::pb::VectorRowRecord* release_vec(); + ::pb::VectorRowRecord* mutable_vec(); + void set_allocated_vec(::pb::VectorRowRecord* vec); + + // @@protoc_insertion_point(class_scope:pb.RowValue) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::Cell > cell_; + ::pb::VectorRowRecord* vec_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_pulsar_2eproto; +}; +// ------------------------------------------------------------------- + +class PulsarMessage : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.PulsarMessage) */ { + public: + PulsarMessage(); + virtual ~PulsarMessage(); + + PulsarMessage(const PulsarMessage& from); + PulsarMessage(PulsarMessage&& from) noexcept + : PulsarMessage() { + *this = ::std::move(from); + } + + inline PulsarMessage& operator=(const PulsarMessage& from) { + CopyFrom(from); + return *this; + } + inline PulsarMessage& operator=(PulsarMessage&& 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 PulsarMessage& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const PulsarMessage* internal_default_instance() { + return reinterpret_cast( + &_PulsarMessage_default_instance_); + } + static constexpr int kIndexInFileMessages = + 9; + + friend void swap(PulsarMessage& a, PulsarMessage& b) { + a.Swap(&b); + } + inline void Swap(PulsarMessage* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline PulsarMessage* New() const final { + return CreateMaybeMessage(nullptr); + } + + PulsarMessage* 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 PulsarMessage& from); + void MergeFrom(const PulsarMessage& 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(PulsarMessage* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "pb.PulsarMessage"; + } + 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_pulsar_2eproto); + return ::descriptor_table_pulsar_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kFieldsFieldNumber = 2, + kCollectionNameFieldNumber = 1, + kPartitionTagFieldNumber = 4, + kTopicNameFieldNumber = 10, + kVectorParamFieldNumber = 5, + kSegmentsFieldNumber = 6, + kEntityIdFieldNumber = 3, + kTimestampFieldNumber = 7, + kClientIdFieldNumber = 8, + kPartitionIdFieldNumber = 11, + kMsgTypeFieldNumber = 9, + }; + // repeated .pb.FieldValue fields = 2; + int fields_size() const; + void clear_fields(); + ::pb::FieldValue* mutable_fields(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::FieldValue >* + mutable_fields(); + const ::pb::FieldValue& fields(int index) const; + ::pb::FieldValue* add_fields(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::FieldValue >& + fields() const; + + // string collection_name = 1; + void clear_collection_name(); + const std::string& collection_name() const; + void set_collection_name(const std::string& value); + void set_collection_name(std::string&& value); + void set_collection_name(const char* value); + void set_collection_name(const char* value, size_t size); + std::string* mutable_collection_name(); + std::string* release_collection_name(); + void set_allocated_collection_name(std::string* collection_name); + + // string partition_tag = 4; + void clear_partition_tag(); + const std::string& partition_tag() const; + void set_partition_tag(const std::string& value); + void set_partition_tag(std::string&& value); + void set_partition_tag(const char* value); + void set_partition_tag(const char* value, size_t size); + std::string* mutable_partition_tag(); + std::string* release_partition_tag(); + void set_allocated_partition_tag(std::string* partition_tag); + + // string topic_name = 10; + void clear_topic_name(); + const std::string& topic_name() const; + void set_topic_name(const std::string& value); + void set_topic_name(std::string&& value); + void set_topic_name(const char* value); + void set_topic_name(const char* value, size_t size); + std::string* mutable_topic_name(); + std::string* release_topic_name(); + void set_allocated_topic_name(std::string* topic_name); + + // .pb.VectorParam vector_param = 5; + bool has_vector_param() const; + void clear_vector_param(); + const ::pb::VectorParam& vector_param() const; + ::pb::VectorParam* release_vector_param(); + ::pb::VectorParam* mutable_vector_param(); + void set_allocated_vector_param(::pb::VectorParam* vector_param); + + // .pb.SegmentRecord segments = 6; + bool has_segments() const; + void clear_segments(); + const ::pb::SegmentRecord& segments() const; + ::pb::SegmentRecord* release_segments(); + ::pb::SegmentRecord* mutable_segments(); + void set_allocated_segments(::pb::SegmentRecord* segments); + + // int64 entity_id = 3; + void clear_entity_id(); + ::PROTOBUF_NAMESPACE_ID::int64 entity_id() const; + void set_entity_id(::PROTOBUF_NAMESPACE_ID::int64 value); + + // int64 timestamp = 7; + void clear_timestamp(); + ::PROTOBUF_NAMESPACE_ID::int64 timestamp() const; + void set_timestamp(::PROTOBUF_NAMESPACE_ID::int64 value); + + // int64 client_id = 8; + void clear_client_id(); + ::PROTOBUF_NAMESPACE_ID::int64 client_id() const; + void set_client_id(::PROTOBUF_NAMESPACE_ID::int64 value); + + // int64 partition_id = 11; + void clear_partition_id(); + ::PROTOBUF_NAMESPACE_ID::int64 partition_id() const; + void set_partition_id(::PROTOBUF_NAMESPACE_ID::int64 value); + + // .pb.OpType msg_type = 9; + void clear_msg_type(); + ::pb::OpType msg_type() const; + void set_msg_type(::pb::OpType value); + + // @@protoc_insertion_point(class_scope:pb.PulsarMessage) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::FieldValue > fields_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collection_name_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr partition_tag_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr topic_name_; + ::pb::VectorParam* vector_param_; + ::pb::SegmentRecord* segments_; + ::PROTOBUF_NAMESPACE_ID::int64 entity_id_; + ::PROTOBUF_NAMESPACE_ID::int64 timestamp_; + ::PROTOBUF_NAMESPACE_ID::int64 client_id_; + ::PROTOBUF_NAMESPACE_ID::int64 partition_id_; + int msg_type_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_pulsar_2eproto; +}; +// ------------------------------------------------------------------- + +class TestData : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.TestData) */ { + public: + TestData(); + virtual ~TestData(); + + TestData(const TestData& from); + TestData(TestData&& from) noexcept + : TestData() { + *this = ::std::move(from); + } + + inline TestData& operator=(const TestData& from) { + CopyFrom(from); + return *this; + } + inline TestData& operator=(TestData&& 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 TestData& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const TestData* internal_default_instance() { + return reinterpret_cast( + &_TestData_default_instance_); + } + static constexpr int kIndexInFileMessages = + 10; + + friend void swap(TestData& a, TestData& b) { + a.Swap(&b); + } + inline void Swap(TestData* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline TestData* New() const final { + return CreateMaybeMessage(nullptr); + } + + TestData* 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 TestData& from); + void MergeFrom(const TestData& 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(TestData* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "pb.TestData"; + } + 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_pulsar_2eproto); + return ::descriptor_table_pulsar_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kIdFieldNumber = 1, + kNameFieldNumber = 2, + }; + // string id = 1; + void clear_id(); + const std::string& id() const; + void set_id(const std::string& value); + void set_id(std::string&& value); + void set_id(const char* value); + void set_id(const char* value, size_t size); + std::string* mutable_id(); + std::string* release_id(); + void set_allocated_id(std::string* id); + + // string name = 2; + void clear_name(); + const std::string& name() const; + void set_name(const std::string& value); + void set_name(std::string&& value); + void set_name(const char* value); + void set_name(const char* value, size_t size); + std::string* mutable_name(); + std::string* release_name(); + void set_allocated_name(std::string* name); + + // @@protoc_insertion_point(class_scope:pb.TestData) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr id_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_pulsar_2eproto; +}; +// ------------------------------------------------------------------- + +class InsertMsg : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.InsertMsg) */ { + public: + InsertMsg(); + virtual ~InsertMsg(); + + InsertMsg(const InsertMsg& from); + InsertMsg(InsertMsg&& from) noexcept + : InsertMsg() { + *this = ::std::move(from); + } + + inline InsertMsg& operator=(const InsertMsg& from) { + CopyFrom(from); + return *this; + } + inline InsertMsg& operator=(InsertMsg&& 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 InsertMsg& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const InsertMsg* internal_default_instance() { + return reinterpret_cast( + &_InsertMsg_default_instance_); + } + static constexpr int kIndexInFileMessages = + 11; + + friend void swap(InsertMsg& a, InsertMsg& b) { + a.Swap(&b); + } + inline void Swap(InsertMsg* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline InsertMsg* New() const final { + return CreateMaybeMessage(nullptr); + } + + InsertMsg* 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 InsertMsg& from); + void MergeFrom(const InsertMsg& 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(InsertMsg* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "pb.InsertMsg"; + } + 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_pulsar_2eproto); + return ::descriptor_table_pulsar_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kClientIdFieldNumber = 1, + }; + // int64 client_id = 1; + void clear_client_id(); + ::PROTOBUF_NAMESPACE_ID::int64 client_id() const; + void set_client_id(::PROTOBUF_NAMESPACE_ID::int64 value); + + // @@protoc_insertion_point(class_scope:pb.InsertMsg) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::int64 client_id_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_pulsar_2eproto; +}; +// ------------------------------------------------------------------- + +class DeleteMsg : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.DeleteMsg) */ { + public: + DeleteMsg(); + virtual ~DeleteMsg(); + + DeleteMsg(const DeleteMsg& from); + DeleteMsg(DeleteMsg&& from) noexcept + : DeleteMsg() { + *this = ::std::move(from); + } + + inline DeleteMsg& operator=(const DeleteMsg& from) { + CopyFrom(from); + return *this; + } + inline DeleteMsg& operator=(DeleteMsg&& 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 DeleteMsg& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const DeleteMsg* internal_default_instance() { + return reinterpret_cast( + &_DeleteMsg_default_instance_); + } + static constexpr int kIndexInFileMessages = + 12; + + friend void swap(DeleteMsg& a, DeleteMsg& b) { + a.Swap(&b); + } + inline void Swap(DeleteMsg* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline DeleteMsg* New() const final { + return CreateMaybeMessage(nullptr); + } + + DeleteMsg* 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 DeleteMsg& from); + void MergeFrom(const DeleteMsg& 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(DeleteMsg* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "pb.DeleteMsg"; + } + 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_pulsar_2eproto); + return ::descriptor_table_pulsar_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kClientIdFieldNumber = 1, + }; + // int64 client_id = 1; + void clear_client_id(); + ::PROTOBUF_NAMESPACE_ID::int64 client_id() const; + void set_client_id(::PROTOBUF_NAMESPACE_ID::int64 value); + + // @@protoc_insertion_point(class_scope:pb.DeleteMsg) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::int64 client_id_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_pulsar_2eproto; +}; +// ------------------------------------------------------------------- + +class SearchMsg : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.SearchMsg) */ { + public: + SearchMsg(); + virtual ~SearchMsg(); + + SearchMsg(const SearchMsg& from); + SearchMsg(SearchMsg&& from) noexcept + : SearchMsg() { + *this = ::std::move(from); + } + + inline SearchMsg& operator=(const SearchMsg& from) { + CopyFrom(from); + return *this; + } + inline SearchMsg& operator=(SearchMsg&& from) noexcept { + if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const SearchMsg& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const SearchMsg* internal_default_instance() { + return reinterpret_cast( + &_SearchMsg_default_instance_); + } + static constexpr int kIndexInFileMessages = + 13; + + friend void swap(SearchMsg& a, SearchMsg& b) { + a.Swap(&b); + } + inline void Swap(SearchMsg* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline SearchMsg* New() const final { + return CreateMaybeMessage(nullptr); + } + + SearchMsg* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const SearchMsg& from); + void MergeFrom(const SearchMsg& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + #else + bool MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final; + #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + void SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final; + ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(SearchMsg* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "pb.SearchMsg"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_pulsar_2eproto); + return ::descriptor_table_pulsar_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kClientIdFieldNumber = 1, + }; + // int64 client_id = 1; + void clear_client_id(); + ::PROTOBUF_NAMESPACE_ID::int64 client_id() const; + void set_client_id(::PROTOBUF_NAMESPACE_ID::int64 value); + + // @@protoc_insertion_point(class_scope:pb.SearchMsg) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::int64 client_id_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_pulsar_2eproto; +}; +// ------------------------------------------------------------------- + +class SearchResultMsg : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.SearchResultMsg) */ { + public: + SearchResultMsg(); + virtual ~SearchResultMsg(); + + SearchResultMsg(const SearchResultMsg& from); + SearchResultMsg(SearchResultMsg&& from) noexcept + : SearchResultMsg() { + *this = ::std::move(from); + } + + inline SearchResultMsg& operator=(const SearchResultMsg& from) { + CopyFrom(from); + return *this; + } + inline SearchResultMsg& operator=(SearchResultMsg&& 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 SearchResultMsg& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const SearchResultMsg* internal_default_instance() { + return reinterpret_cast( + &_SearchResultMsg_default_instance_); + } + static constexpr int kIndexInFileMessages = + 14; + + friend void swap(SearchResultMsg& a, SearchResultMsg& b) { + a.Swap(&b); + } + inline void Swap(SearchResultMsg* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline SearchResultMsg* New() const final { + return CreateMaybeMessage(nullptr); + } + + SearchResultMsg* 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 SearchResultMsg& from); + void MergeFrom(const SearchResultMsg& 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(SearchResultMsg* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "pb.SearchResultMsg"; + } + 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_pulsar_2eproto); + return ::descriptor_table_pulsar_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kClientIdFieldNumber = 1, + }; + // int64 client_id = 1; + void clear_client_id(); + ::PROTOBUF_NAMESPACE_ID::int64 client_id() const; + void set_client_id(::PROTOBUF_NAMESPACE_ID::int64 value); + + // @@protoc_insertion_point(class_scope:pb.SearchResultMsg) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::int64 client_id_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_pulsar_2eproto; +}; +// =================================================================== + + +// =================================================================== + +#ifdef __GNUC__ + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wstrict-aliasing" +#endif // __GNUC__ +// Status + +// .pb.ErrorCode error_code = 1; +inline void Status::clear_error_code() { + error_code_ = 0; +} +inline ::pb::ErrorCode Status::error_code() const { + // @@protoc_insertion_point(field_get:pb.Status.error_code) + return static_cast< ::pb::ErrorCode >(error_code_); +} +inline void Status::set_error_code(::pb::ErrorCode value) { + + error_code_ = value; + // @@protoc_insertion_point(field_set:pb.Status.error_code) +} + +// string reason = 2; +inline void Status::clear_reason() { + reason_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& Status::reason() const { + // @@protoc_insertion_point(field_get:pb.Status.reason) + return reason_.GetNoArena(); +} +inline void Status::set_reason(const std::string& value) { + + reason_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:pb.Status.reason) +} +inline void Status::set_reason(std::string&& value) { + + reason_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:pb.Status.reason) +} +inline void Status::set_reason(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + reason_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:pb.Status.reason) +} +inline void Status::set_reason(const char* value, size_t size) { + + reason_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:pb.Status.reason) +} +inline std::string* Status::mutable_reason() { + + // @@protoc_insertion_point(field_mutable:pb.Status.reason) + return reason_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* Status::release_reason() { + // @@protoc_insertion_point(field_release:pb.Status.reason) + + return reason_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void Status::set_allocated_reason(std::string* reason) { + if (reason != nullptr) { + + } else { + + } + reason_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), reason); + // @@protoc_insertion_point(field_set_allocated:pb.Status.reason) +} + +// ------------------------------------------------------------------- + +// SegmentRecord + +// repeated string seg_info = 1; +inline int SegmentRecord::seg_info_size() const { + return seg_info_.size(); +} +inline void SegmentRecord::clear_seg_info() { + seg_info_.Clear(); +} +inline const std::string& SegmentRecord::seg_info(int index) const { + // @@protoc_insertion_point(field_get:pb.SegmentRecord.seg_info) + return seg_info_.Get(index); +} +inline std::string* SegmentRecord::mutable_seg_info(int index) { + // @@protoc_insertion_point(field_mutable:pb.SegmentRecord.seg_info) + return seg_info_.Mutable(index); +} +inline void SegmentRecord::set_seg_info(int index, const std::string& value) { + // @@protoc_insertion_point(field_set:pb.SegmentRecord.seg_info) + seg_info_.Mutable(index)->assign(value); +} +inline void SegmentRecord::set_seg_info(int index, std::string&& value) { + // @@protoc_insertion_point(field_set:pb.SegmentRecord.seg_info) + seg_info_.Mutable(index)->assign(std::move(value)); +} +inline void SegmentRecord::set_seg_info(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + seg_info_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:pb.SegmentRecord.seg_info) +} +inline void SegmentRecord::set_seg_info(int index, const char* value, size_t size) { + seg_info_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:pb.SegmentRecord.seg_info) +} +inline std::string* SegmentRecord::add_seg_info() { + // @@protoc_insertion_point(field_add_mutable:pb.SegmentRecord.seg_info) + return seg_info_.Add(); +} +inline void SegmentRecord::add_seg_info(const std::string& value) { + seg_info_.Add()->assign(value); + // @@protoc_insertion_point(field_add:pb.SegmentRecord.seg_info) +} +inline void SegmentRecord::add_seg_info(std::string&& value) { + seg_info_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:pb.SegmentRecord.seg_info) +} +inline void SegmentRecord::add_seg_info(const char* value) { + GOOGLE_DCHECK(value != nullptr); + seg_info_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:pb.SegmentRecord.seg_info) +} +inline void SegmentRecord::add_seg_info(const char* value, size_t size) { + seg_info_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:pb.SegmentRecord.seg_info) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +SegmentRecord::seg_info() const { + // @@protoc_insertion_point(field_list:pb.SegmentRecord.seg_info) + return seg_info_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +SegmentRecord::mutable_seg_info() { + // @@protoc_insertion_point(field_mutable_list:pb.SegmentRecord.seg_info) + return &seg_info_; +} + +// ------------------------------------------------------------------- + +// VectorRowRecord + +// repeated float float_data = 1; +inline int VectorRowRecord::float_data_size() const { + return float_data_.size(); +} +inline void VectorRowRecord::clear_float_data() { + float_data_.Clear(); +} +inline float VectorRowRecord::float_data(int index) const { + // @@protoc_insertion_point(field_get:pb.VectorRowRecord.float_data) + return float_data_.Get(index); +} +inline void VectorRowRecord::set_float_data(int index, float value) { + float_data_.Set(index, value); + // @@protoc_insertion_point(field_set:pb.VectorRowRecord.float_data) +} +inline void VectorRowRecord::add_float_data(float value) { + float_data_.Add(value); + // @@protoc_insertion_point(field_add:pb.VectorRowRecord.float_data) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& +VectorRowRecord::float_data() const { + // @@protoc_insertion_point(field_list:pb.VectorRowRecord.float_data) + return float_data_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* +VectorRowRecord::mutable_float_data() { + // @@protoc_insertion_point(field_mutable_list:pb.VectorRowRecord.float_data) + return &float_data_; +} + +// bytes binary_data = 2; +inline void VectorRowRecord::clear_binary_data() { + binary_data_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& VectorRowRecord::binary_data() const { + // @@protoc_insertion_point(field_get:pb.VectorRowRecord.binary_data) + return binary_data_.GetNoArena(); +} +inline void VectorRowRecord::set_binary_data(const std::string& value) { + + binary_data_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:pb.VectorRowRecord.binary_data) +} +inline void VectorRowRecord::set_binary_data(std::string&& value) { + + binary_data_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:pb.VectorRowRecord.binary_data) +} +inline void VectorRowRecord::set_binary_data(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + binary_data_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:pb.VectorRowRecord.binary_data) +} +inline void VectorRowRecord::set_binary_data(const void* value, size_t size) { + + binary_data_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:pb.VectorRowRecord.binary_data) +} +inline std::string* VectorRowRecord::mutable_binary_data() { + + // @@protoc_insertion_point(field_mutable:pb.VectorRowRecord.binary_data) + return binary_data_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* VectorRowRecord::release_binary_data() { + // @@protoc_insertion_point(field_release:pb.VectorRowRecord.binary_data) + + return binary_data_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void VectorRowRecord::set_allocated_binary_data(std::string* binary_data) { + if (binary_data != nullptr) { + + } else { + + } + binary_data_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), binary_data); + // @@protoc_insertion_point(field_set_allocated:pb.VectorRowRecord.binary_data) +} + +// ------------------------------------------------------------------- + +// AttrRecord + +// repeated int32 int32_value = 1; +inline int AttrRecord::int32_value_size() const { + return int32_value_.size(); +} +inline void AttrRecord::clear_int32_value() { + int32_value_.Clear(); +} +inline ::PROTOBUF_NAMESPACE_ID::int32 AttrRecord::int32_value(int index) const { + // @@protoc_insertion_point(field_get:pb.AttrRecord.int32_value) + return int32_value_.Get(index); +} +inline void AttrRecord::set_int32_value(int index, ::PROTOBUF_NAMESPACE_ID::int32 value) { + int32_value_.Set(index, value); + // @@protoc_insertion_point(field_set:pb.AttrRecord.int32_value) +} +inline void AttrRecord::add_int32_value(::PROTOBUF_NAMESPACE_ID::int32 value) { + int32_value_.Add(value); + // @@protoc_insertion_point(field_add:pb.AttrRecord.int32_value) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >& +AttrRecord::int32_value() const { + // @@protoc_insertion_point(field_list:pb.AttrRecord.int32_value) + return int32_value_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >* +AttrRecord::mutable_int32_value() { + // @@protoc_insertion_point(field_mutable_list:pb.AttrRecord.int32_value) + return &int32_value_; +} + +// repeated int64 int64_value = 2; +inline int AttrRecord::int64_value_size() const { + return int64_value_.size(); +} +inline void AttrRecord::clear_int64_value() { + int64_value_.Clear(); +} +inline ::PROTOBUF_NAMESPACE_ID::int64 AttrRecord::int64_value(int index) const { + // @@protoc_insertion_point(field_get:pb.AttrRecord.int64_value) + return int64_value_.Get(index); +} +inline void AttrRecord::set_int64_value(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) { + int64_value_.Set(index, value); + // @@protoc_insertion_point(field_set:pb.AttrRecord.int64_value) +} +inline void AttrRecord::add_int64_value(::PROTOBUF_NAMESPACE_ID::int64 value) { + int64_value_.Add(value); + // @@protoc_insertion_point(field_add:pb.AttrRecord.int64_value) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >& +AttrRecord::int64_value() const { + // @@protoc_insertion_point(field_list:pb.AttrRecord.int64_value) + return int64_value_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >* +AttrRecord::mutable_int64_value() { + // @@protoc_insertion_point(field_mutable_list:pb.AttrRecord.int64_value) + return &int64_value_; +} + +// repeated float float_value = 3; +inline int AttrRecord::float_value_size() const { + return float_value_.size(); +} +inline void AttrRecord::clear_float_value() { + float_value_.Clear(); +} +inline float AttrRecord::float_value(int index) const { + // @@protoc_insertion_point(field_get:pb.AttrRecord.float_value) + return float_value_.Get(index); +} +inline void AttrRecord::set_float_value(int index, float value) { + float_value_.Set(index, value); + // @@protoc_insertion_point(field_set:pb.AttrRecord.float_value) +} +inline void AttrRecord::add_float_value(float value) { + float_value_.Add(value); + // @@protoc_insertion_point(field_add:pb.AttrRecord.float_value) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& +AttrRecord::float_value() const { + // @@protoc_insertion_point(field_list:pb.AttrRecord.float_value) + return float_value_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* +AttrRecord::mutable_float_value() { + // @@protoc_insertion_point(field_mutable_list:pb.AttrRecord.float_value) + return &float_value_; +} + +// repeated double double_value = 4; +inline int AttrRecord::double_value_size() const { + return double_value_.size(); +} +inline void AttrRecord::clear_double_value() { + double_value_.Clear(); +} +inline double AttrRecord::double_value(int index) const { + // @@protoc_insertion_point(field_get:pb.AttrRecord.double_value) + return double_value_.Get(index); +} +inline void AttrRecord::set_double_value(int index, double value) { + double_value_.Set(index, value); + // @@protoc_insertion_point(field_set:pb.AttrRecord.double_value) +} +inline void AttrRecord::add_double_value(double value) { + double_value_.Add(value); + // @@protoc_insertion_point(field_add:pb.AttrRecord.double_value) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >& +AttrRecord::double_value() const { + // @@protoc_insertion_point(field_list:pb.AttrRecord.double_value) + return double_value_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >* +AttrRecord::mutable_double_value() { + // @@protoc_insertion_point(field_mutable_list:pb.AttrRecord.double_value) + return &double_value_; +} + +// ------------------------------------------------------------------- + +// VectorRecord + +// repeated .pb.VectorRowRecord records = 1; +inline int VectorRecord::records_size() const { + return records_.size(); +} +inline void VectorRecord::clear_records() { + records_.Clear(); +} +inline ::pb::VectorRowRecord* VectorRecord::mutable_records(int index) { + // @@protoc_insertion_point(field_mutable:pb.VectorRecord.records) + return records_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::VectorRowRecord >* +VectorRecord::mutable_records() { + // @@protoc_insertion_point(field_mutable_list:pb.VectorRecord.records) + return &records_; +} +inline const ::pb::VectorRowRecord& VectorRecord::records(int index) const { + // @@protoc_insertion_point(field_get:pb.VectorRecord.records) + return records_.Get(index); +} +inline ::pb::VectorRowRecord* VectorRecord::add_records() { + // @@protoc_insertion_point(field_add:pb.VectorRecord.records) + return records_.Add(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::VectorRowRecord >& +VectorRecord::records() const { + // @@protoc_insertion_point(field_list:pb.VectorRecord.records) + return records_; +} + +// ------------------------------------------------------------------- + +// VectorParam + +// string json = 1; +inline void VectorParam::clear_json() { + json_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& VectorParam::json() const { + // @@protoc_insertion_point(field_get:pb.VectorParam.json) + return json_.GetNoArena(); +} +inline void VectorParam::set_json(const std::string& value) { + + json_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:pb.VectorParam.json) +} +inline void VectorParam::set_json(std::string&& value) { + + json_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:pb.VectorParam.json) +} +inline void VectorParam::set_json(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + json_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:pb.VectorParam.json) +} +inline void VectorParam::set_json(const char* value, size_t size) { + + json_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:pb.VectorParam.json) +} +inline std::string* VectorParam::mutable_json() { + + // @@protoc_insertion_point(field_mutable:pb.VectorParam.json) + return json_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* VectorParam::release_json() { + // @@protoc_insertion_point(field_release:pb.VectorParam.json) + + return json_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void VectorParam::set_allocated_json(std::string* json) { + if (json != nullptr) { + + } else { + + } + json_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), json); + // @@protoc_insertion_point(field_set_allocated:pb.VectorParam.json) +} + +// .pb.VectorRecord row_record = 2; +inline bool VectorParam::has_row_record() const { + return this != internal_default_instance() && row_record_ != nullptr; +} +inline void VectorParam::clear_row_record() { + if (GetArenaNoVirtual() == nullptr && row_record_ != nullptr) { + delete row_record_; + } + row_record_ = nullptr; +} +inline const ::pb::VectorRecord& VectorParam::row_record() const { + const ::pb::VectorRecord* p = row_record_; + // @@protoc_insertion_point(field_get:pb.VectorParam.row_record) + return p != nullptr ? *p : *reinterpret_cast( + &::pb::_VectorRecord_default_instance_); +} +inline ::pb::VectorRecord* VectorParam::release_row_record() { + // @@protoc_insertion_point(field_release:pb.VectorParam.row_record) + + ::pb::VectorRecord* temp = row_record_; + row_record_ = nullptr; + return temp; +} +inline ::pb::VectorRecord* VectorParam::mutable_row_record() { + + if (row_record_ == nullptr) { + auto* p = CreateMaybeMessage<::pb::VectorRecord>(GetArenaNoVirtual()); + row_record_ = p; + } + // @@protoc_insertion_point(field_mutable:pb.VectorParam.row_record) + return row_record_; +} +inline void VectorParam::set_allocated_row_record(::pb::VectorRecord* row_record) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete row_record_; + } + if (row_record) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + row_record = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, row_record, submessage_arena); + } + + } else { + + } + row_record_ = row_record; + // @@protoc_insertion_point(field_set_allocated:pb.VectorParam.row_record) +} + +// ------------------------------------------------------------------- + +// FieldValue + +// string field_name = 1; +inline void FieldValue::clear_field_name() { + field_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& FieldValue::field_name() const { + // @@protoc_insertion_point(field_get:pb.FieldValue.field_name) + return field_name_.GetNoArena(); +} +inline void FieldValue::set_field_name(const std::string& value) { + + field_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:pb.FieldValue.field_name) +} +inline void FieldValue::set_field_name(std::string&& value) { + + field_name_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:pb.FieldValue.field_name) +} +inline void FieldValue::set_field_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + field_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:pb.FieldValue.field_name) +} +inline void FieldValue::set_field_name(const char* value, size_t size) { + + field_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:pb.FieldValue.field_name) +} +inline std::string* FieldValue::mutable_field_name() { + + // @@protoc_insertion_point(field_mutable:pb.FieldValue.field_name) + return field_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* FieldValue::release_field_name() { + // @@protoc_insertion_point(field_release:pb.FieldValue.field_name) + + return field_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void FieldValue::set_allocated_field_name(std::string* field_name) { + if (field_name != nullptr) { + + } else { + + } + field_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), field_name); + // @@protoc_insertion_point(field_set_allocated:pb.FieldValue.field_name) +} + +// .pb.DataType type = 2; +inline void FieldValue::clear_type() { + type_ = 0; +} +inline ::pb::DataType FieldValue::type() const { + // @@protoc_insertion_point(field_get:pb.FieldValue.type) + return static_cast< ::pb::DataType >(type_); +} +inline void FieldValue::set_type(::pb::DataType value) { + + type_ = value; + // @@protoc_insertion_point(field_set:pb.FieldValue.type) +} + +// .pb.AttrRecord attr_record = 3; +inline bool FieldValue::has_attr_record() const { + return this != internal_default_instance() && attr_record_ != nullptr; +} +inline void FieldValue::clear_attr_record() { + if (GetArenaNoVirtual() == nullptr && attr_record_ != nullptr) { + delete attr_record_; + } + attr_record_ = nullptr; +} +inline const ::pb::AttrRecord& FieldValue::attr_record() const { + const ::pb::AttrRecord* p = attr_record_; + // @@protoc_insertion_point(field_get:pb.FieldValue.attr_record) + return p != nullptr ? *p : *reinterpret_cast( + &::pb::_AttrRecord_default_instance_); +} +inline ::pb::AttrRecord* FieldValue::release_attr_record() { + // @@protoc_insertion_point(field_release:pb.FieldValue.attr_record) + + ::pb::AttrRecord* temp = attr_record_; + attr_record_ = nullptr; + return temp; +} +inline ::pb::AttrRecord* FieldValue::mutable_attr_record() { + + if (attr_record_ == nullptr) { + auto* p = CreateMaybeMessage<::pb::AttrRecord>(GetArenaNoVirtual()); + attr_record_ = p; + } + // @@protoc_insertion_point(field_mutable:pb.FieldValue.attr_record) + return attr_record_; +} +inline void FieldValue::set_allocated_attr_record(::pb::AttrRecord* attr_record) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete attr_record_; + } + if (attr_record) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + attr_record = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, attr_record, submessage_arena); + } + + } else { + + } + attr_record_ = attr_record; + // @@protoc_insertion_point(field_set_allocated:pb.FieldValue.attr_record) +} + +// .pb.VectorRecord vector_record = 4; +inline bool FieldValue::has_vector_record() const { + return this != internal_default_instance() && vector_record_ != nullptr; +} +inline void FieldValue::clear_vector_record() { + if (GetArenaNoVirtual() == nullptr && vector_record_ != nullptr) { + delete vector_record_; + } + vector_record_ = nullptr; +} +inline const ::pb::VectorRecord& FieldValue::vector_record() const { + const ::pb::VectorRecord* p = vector_record_; + // @@protoc_insertion_point(field_get:pb.FieldValue.vector_record) + return p != nullptr ? *p : *reinterpret_cast( + &::pb::_VectorRecord_default_instance_); +} +inline ::pb::VectorRecord* FieldValue::release_vector_record() { + // @@protoc_insertion_point(field_release:pb.FieldValue.vector_record) + + ::pb::VectorRecord* temp = vector_record_; + vector_record_ = nullptr; + return temp; +} +inline ::pb::VectorRecord* FieldValue::mutable_vector_record() { + + if (vector_record_ == nullptr) { + auto* p = CreateMaybeMessage<::pb::VectorRecord>(GetArenaNoVirtual()); + vector_record_ = p; + } + // @@protoc_insertion_point(field_mutable:pb.FieldValue.vector_record) + return vector_record_; +} +inline void FieldValue::set_allocated_vector_record(::pb::VectorRecord* vector_record) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete vector_record_; + } + if (vector_record) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + vector_record = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, vector_record, submessage_arena); + } + + } else { + + } + vector_record_ = vector_record; + // @@protoc_insertion_point(field_set_allocated:pb.FieldValue.vector_record) +} + +// ------------------------------------------------------------------- + +// Cell + +// int32 int32_value = 1; +inline bool Cell::has_int32_value() const { + return value_case() == kInt32Value; +} +inline void Cell::set_has_int32_value() { + _oneof_case_[0] = kInt32Value; +} +inline void Cell::clear_int32_value() { + if (has_int32_value()) { + value_.int32_value_ = 0; + clear_has_value(); + } +} +inline ::PROTOBUF_NAMESPACE_ID::int32 Cell::int32_value() const { + // @@protoc_insertion_point(field_get:pb.Cell.int32_value) + if (has_int32_value()) { + return value_.int32_value_; + } + return 0; +} +inline void Cell::set_int32_value(::PROTOBUF_NAMESPACE_ID::int32 value) { + if (!has_int32_value()) { + clear_value(); + set_has_int32_value(); + } + value_.int32_value_ = value; + // @@protoc_insertion_point(field_set:pb.Cell.int32_value) +} + +// int64 int64_value = 2; +inline bool Cell::has_int64_value() const { + return value_case() == kInt64Value; +} +inline void Cell::set_has_int64_value() { + _oneof_case_[0] = kInt64Value; +} +inline void Cell::clear_int64_value() { + if (has_int64_value()) { + value_.int64_value_ = PROTOBUF_LONGLONG(0); + clear_has_value(); + } +} +inline ::PROTOBUF_NAMESPACE_ID::int64 Cell::int64_value() const { + // @@protoc_insertion_point(field_get:pb.Cell.int64_value) + if (has_int64_value()) { + return value_.int64_value_; + } + return PROTOBUF_LONGLONG(0); +} +inline void Cell::set_int64_value(::PROTOBUF_NAMESPACE_ID::int64 value) { + if (!has_int64_value()) { + clear_value(); + set_has_int64_value(); + } + value_.int64_value_ = value; + // @@protoc_insertion_point(field_set:pb.Cell.int64_value) +} + +// float float_value = 3; +inline bool Cell::has_float_value() const { + return value_case() == kFloatValue; +} +inline void Cell::set_has_float_value() { + _oneof_case_[0] = kFloatValue; +} +inline void Cell::clear_float_value() { + if (has_float_value()) { + value_.float_value_ = 0; + clear_has_value(); + } +} +inline float Cell::float_value() const { + // @@protoc_insertion_point(field_get:pb.Cell.float_value) + if (has_float_value()) { + return value_.float_value_; + } + return 0; +} +inline void Cell::set_float_value(float value) { + if (!has_float_value()) { + clear_value(); + set_has_float_value(); + } + value_.float_value_ = value; + // @@protoc_insertion_point(field_set:pb.Cell.float_value) +} + +// double double_value = 4; +inline bool Cell::has_double_value() const { + return value_case() == kDoubleValue; +} +inline void Cell::set_has_double_value() { + _oneof_case_[0] = kDoubleValue; +} +inline void Cell::clear_double_value() { + if (has_double_value()) { + value_.double_value_ = 0; + clear_has_value(); + } +} +inline double Cell::double_value() const { + // @@protoc_insertion_point(field_get:pb.Cell.double_value) + if (has_double_value()) { + return value_.double_value_; + } + return 0; +} +inline void Cell::set_double_value(double value) { + if (!has_double_value()) { + clear_value(); + set_has_double_value(); + } + value_.double_value_ = value; + // @@protoc_insertion_point(field_set:pb.Cell.double_value) +} + +inline bool Cell::has_value() const { + return value_case() != VALUE_NOT_SET; +} +inline void Cell::clear_has_value() { + _oneof_case_[0] = VALUE_NOT_SET; +} +inline Cell::ValueCase Cell::value_case() const { + return Cell::ValueCase(_oneof_case_[0]); +} +// ------------------------------------------------------------------- + +// RowValue + +// .pb.VectorRowRecord vec = 1; +inline bool RowValue::has_vec() const { + return this != internal_default_instance() && vec_ != nullptr; +} +inline void RowValue::clear_vec() { + if (GetArenaNoVirtual() == nullptr && vec_ != nullptr) { + delete vec_; + } + vec_ = nullptr; +} +inline const ::pb::VectorRowRecord& RowValue::vec() const { + const ::pb::VectorRowRecord* p = vec_; + // @@protoc_insertion_point(field_get:pb.RowValue.vec) + return p != nullptr ? *p : *reinterpret_cast( + &::pb::_VectorRowRecord_default_instance_); +} +inline ::pb::VectorRowRecord* RowValue::release_vec() { + // @@protoc_insertion_point(field_release:pb.RowValue.vec) + + ::pb::VectorRowRecord* temp = vec_; + vec_ = nullptr; + return temp; +} +inline ::pb::VectorRowRecord* RowValue::mutable_vec() { + + if (vec_ == nullptr) { + auto* p = CreateMaybeMessage<::pb::VectorRowRecord>(GetArenaNoVirtual()); + vec_ = p; + } + // @@protoc_insertion_point(field_mutable:pb.RowValue.vec) + return vec_; +} +inline void RowValue::set_allocated_vec(::pb::VectorRowRecord* vec) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete vec_; + } + if (vec) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + vec = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, vec, submessage_arena); + } + + } else { + + } + vec_ = vec; + // @@protoc_insertion_point(field_set_allocated:pb.RowValue.vec) +} + +// repeated .pb.Cell cell = 2; +inline int RowValue::cell_size() const { + return cell_.size(); +} +inline void RowValue::clear_cell() { + cell_.Clear(); +} +inline ::pb::Cell* RowValue::mutable_cell(int index) { + // @@protoc_insertion_point(field_mutable:pb.RowValue.cell) + return cell_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::Cell >* +RowValue::mutable_cell() { + // @@protoc_insertion_point(field_mutable_list:pb.RowValue.cell) + return &cell_; +} +inline const ::pb::Cell& RowValue::cell(int index) const { + // @@protoc_insertion_point(field_get:pb.RowValue.cell) + return cell_.Get(index); +} +inline ::pb::Cell* RowValue::add_cell() { + // @@protoc_insertion_point(field_add:pb.RowValue.cell) + return cell_.Add(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::Cell >& +RowValue::cell() const { + // @@protoc_insertion_point(field_list:pb.RowValue.cell) + return cell_; +} + +// ------------------------------------------------------------------- + +// PulsarMessage + +// string collection_name = 1; +inline void PulsarMessage::clear_collection_name() { + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& PulsarMessage::collection_name() const { + // @@protoc_insertion_point(field_get:pb.PulsarMessage.collection_name) + return collection_name_.GetNoArena(); +} +inline void PulsarMessage::set_collection_name(const std::string& value) { + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:pb.PulsarMessage.collection_name) +} +inline void PulsarMessage::set_collection_name(std::string&& value) { + + collection_name_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:pb.PulsarMessage.collection_name) +} +inline void PulsarMessage::set_collection_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:pb.PulsarMessage.collection_name) +} +inline void PulsarMessage::set_collection_name(const char* value, size_t size) { + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:pb.PulsarMessage.collection_name) +} +inline std::string* PulsarMessage::mutable_collection_name() { + + // @@protoc_insertion_point(field_mutable:pb.PulsarMessage.collection_name) + return collection_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* PulsarMessage::release_collection_name() { + // @@protoc_insertion_point(field_release:pb.PulsarMessage.collection_name) + + return collection_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void PulsarMessage::set_allocated_collection_name(std::string* collection_name) { + if (collection_name != nullptr) { + + } else { + + } + collection_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), collection_name); + // @@protoc_insertion_point(field_set_allocated:pb.PulsarMessage.collection_name) +} + +// repeated .pb.FieldValue fields = 2; +inline int PulsarMessage::fields_size() const { + return fields_.size(); +} +inline void PulsarMessage::clear_fields() { + fields_.Clear(); +} +inline ::pb::FieldValue* PulsarMessage::mutable_fields(int index) { + // @@protoc_insertion_point(field_mutable:pb.PulsarMessage.fields) + return fields_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::FieldValue >* +PulsarMessage::mutable_fields() { + // @@protoc_insertion_point(field_mutable_list:pb.PulsarMessage.fields) + return &fields_; +} +inline const ::pb::FieldValue& PulsarMessage::fields(int index) const { + // @@protoc_insertion_point(field_get:pb.PulsarMessage.fields) + return fields_.Get(index); +} +inline ::pb::FieldValue* PulsarMessage::add_fields() { + // @@protoc_insertion_point(field_add:pb.PulsarMessage.fields) + return fields_.Add(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::FieldValue >& +PulsarMessage::fields() const { + // @@protoc_insertion_point(field_list:pb.PulsarMessage.fields) + return fields_; +} + +// int64 entity_id = 3; +inline void PulsarMessage::clear_entity_id() { + entity_id_ = PROTOBUF_LONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::int64 PulsarMessage::entity_id() const { + // @@protoc_insertion_point(field_get:pb.PulsarMessage.entity_id) + return entity_id_; +} +inline void PulsarMessage::set_entity_id(::PROTOBUF_NAMESPACE_ID::int64 value) { + + entity_id_ = value; + // @@protoc_insertion_point(field_set:pb.PulsarMessage.entity_id) +} + +// string partition_tag = 4; +inline void PulsarMessage::clear_partition_tag() { + partition_tag_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& PulsarMessage::partition_tag() const { + // @@protoc_insertion_point(field_get:pb.PulsarMessage.partition_tag) + return partition_tag_.GetNoArena(); +} +inline void PulsarMessage::set_partition_tag(const std::string& value) { + + partition_tag_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:pb.PulsarMessage.partition_tag) +} +inline void PulsarMessage::set_partition_tag(std::string&& value) { + + partition_tag_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:pb.PulsarMessage.partition_tag) +} +inline void PulsarMessage::set_partition_tag(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + partition_tag_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:pb.PulsarMessage.partition_tag) +} +inline void PulsarMessage::set_partition_tag(const char* value, size_t size) { + + partition_tag_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:pb.PulsarMessage.partition_tag) +} +inline std::string* PulsarMessage::mutable_partition_tag() { + + // @@protoc_insertion_point(field_mutable:pb.PulsarMessage.partition_tag) + return partition_tag_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* PulsarMessage::release_partition_tag() { + // @@protoc_insertion_point(field_release:pb.PulsarMessage.partition_tag) + + return partition_tag_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void PulsarMessage::set_allocated_partition_tag(std::string* partition_tag) { + if (partition_tag != nullptr) { + + } else { + + } + partition_tag_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), partition_tag); + // @@protoc_insertion_point(field_set_allocated:pb.PulsarMessage.partition_tag) +} + +// .pb.VectorParam vector_param = 5; +inline bool PulsarMessage::has_vector_param() const { + return this != internal_default_instance() && vector_param_ != nullptr; +} +inline void PulsarMessage::clear_vector_param() { + if (GetArenaNoVirtual() == nullptr && vector_param_ != nullptr) { + delete vector_param_; + } + vector_param_ = nullptr; +} +inline const ::pb::VectorParam& PulsarMessage::vector_param() const { + const ::pb::VectorParam* p = vector_param_; + // @@protoc_insertion_point(field_get:pb.PulsarMessage.vector_param) + return p != nullptr ? *p : *reinterpret_cast( + &::pb::_VectorParam_default_instance_); +} +inline ::pb::VectorParam* PulsarMessage::release_vector_param() { + // @@protoc_insertion_point(field_release:pb.PulsarMessage.vector_param) + + ::pb::VectorParam* temp = vector_param_; + vector_param_ = nullptr; + return temp; +} +inline ::pb::VectorParam* PulsarMessage::mutable_vector_param() { + + if (vector_param_ == nullptr) { + auto* p = CreateMaybeMessage<::pb::VectorParam>(GetArenaNoVirtual()); + vector_param_ = p; + } + // @@protoc_insertion_point(field_mutable:pb.PulsarMessage.vector_param) + return vector_param_; +} +inline void PulsarMessage::set_allocated_vector_param(::pb::VectorParam* vector_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete vector_param_; + } + if (vector_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + vector_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, vector_param, submessage_arena); + } + + } else { + + } + vector_param_ = vector_param; + // @@protoc_insertion_point(field_set_allocated:pb.PulsarMessage.vector_param) +} + +// .pb.SegmentRecord segments = 6; +inline bool PulsarMessage::has_segments() const { + return this != internal_default_instance() && segments_ != nullptr; +} +inline void PulsarMessage::clear_segments() { + if (GetArenaNoVirtual() == nullptr && segments_ != nullptr) { + delete segments_; + } + segments_ = nullptr; +} +inline const ::pb::SegmentRecord& PulsarMessage::segments() const { + const ::pb::SegmentRecord* p = segments_; + // @@protoc_insertion_point(field_get:pb.PulsarMessage.segments) + return p != nullptr ? *p : *reinterpret_cast( + &::pb::_SegmentRecord_default_instance_); +} +inline ::pb::SegmentRecord* PulsarMessage::release_segments() { + // @@protoc_insertion_point(field_release:pb.PulsarMessage.segments) + + ::pb::SegmentRecord* temp = segments_; + segments_ = nullptr; + return temp; +} +inline ::pb::SegmentRecord* PulsarMessage::mutable_segments() { + + if (segments_ == nullptr) { + auto* p = CreateMaybeMessage<::pb::SegmentRecord>(GetArenaNoVirtual()); + segments_ = p; + } + // @@protoc_insertion_point(field_mutable:pb.PulsarMessage.segments) + return segments_; +} +inline void PulsarMessage::set_allocated_segments(::pb::SegmentRecord* segments) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete segments_; + } + if (segments) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + segments = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, segments, submessage_arena); + } + + } else { + + } + segments_ = segments; + // @@protoc_insertion_point(field_set_allocated:pb.PulsarMessage.segments) +} + +// int64 timestamp = 7; +inline void PulsarMessage::clear_timestamp() { + timestamp_ = PROTOBUF_LONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::int64 PulsarMessage::timestamp() const { + // @@protoc_insertion_point(field_get:pb.PulsarMessage.timestamp) + return timestamp_; +} +inline void PulsarMessage::set_timestamp(::PROTOBUF_NAMESPACE_ID::int64 value) { + + timestamp_ = value; + // @@protoc_insertion_point(field_set:pb.PulsarMessage.timestamp) +} + +// int64 client_id = 8; +inline void PulsarMessage::clear_client_id() { + client_id_ = PROTOBUF_LONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::int64 PulsarMessage::client_id() const { + // @@protoc_insertion_point(field_get:pb.PulsarMessage.client_id) + return client_id_; +} +inline void PulsarMessage::set_client_id(::PROTOBUF_NAMESPACE_ID::int64 value) { + + client_id_ = value; + // @@protoc_insertion_point(field_set:pb.PulsarMessage.client_id) +} + +// .pb.OpType msg_type = 9; +inline void PulsarMessage::clear_msg_type() { + msg_type_ = 0; +} +inline ::pb::OpType PulsarMessage::msg_type() const { + // @@protoc_insertion_point(field_get:pb.PulsarMessage.msg_type) + return static_cast< ::pb::OpType >(msg_type_); +} +inline void PulsarMessage::set_msg_type(::pb::OpType value) { + + msg_type_ = value; + // @@protoc_insertion_point(field_set:pb.PulsarMessage.msg_type) +} + +// string topic_name = 10; +inline void PulsarMessage::clear_topic_name() { + topic_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& PulsarMessage::topic_name() const { + // @@protoc_insertion_point(field_get:pb.PulsarMessage.topic_name) + return topic_name_.GetNoArena(); +} +inline void PulsarMessage::set_topic_name(const std::string& value) { + + topic_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:pb.PulsarMessage.topic_name) +} +inline void PulsarMessage::set_topic_name(std::string&& value) { + + topic_name_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:pb.PulsarMessage.topic_name) +} +inline void PulsarMessage::set_topic_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + topic_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:pb.PulsarMessage.topic_name) +} +inline void PulsarMessage::set_topic_name(const char* value, size_t size) { + + topic_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:pb.PulsarMessage.topic_name) +} +inline std::string* PulsarMessage::mutable_topic_name() { + + // @@protoc_insertion_point(field_mutable:pb.PulsarMessage.topic_name) + return topic_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* PulsarMessage::release_topic_name() { + // @@protoc_insertion_point(field_release:pb.PulsarMessage.topic_name) + + return topic_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void PulsarMessage::set_allocated_topic_name(std::string* topic_name) { + if (topic_name != nullptr) { + + } else { + + } + topic_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), topic_name); + // @@protoc_insertion_point(field_set_allocated:pb.PulsarMessage.topic_name) +} + +// int64 partition_id = 11; +inline void PulsarMessage::clear_partition_id() { + partition_id_ = PROTOBUF_LONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::int64 PulsarMessage::partition_id() const { + // @@protoc_insertion_point(field_get:pb.PulsarMessage.partition_id) + return partition_id_; +} +inline void PulsarMessage::set_partition_id(::PROTOBUF_NAMESPACE_ID::int64 value) { + + partition_id_ = value; + // @@protoc_insertion_point(field_set:pb.PulsarMessage.partition_id) +} + +// ------------------------------------------------------------------- + +// TestData + +// string id = 1; +inline void TestData::clear_id() { + id_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& TestData::id() const { + // @@protoc_insertion_point(field_get:pb.TestData.id) + return id_.GetNoArena(); +} +inline void TestData::set_id(const std::string& value) { + + id_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:pb.TestData.id) +} +inline void TestData::set_id(std::string&& value) { + + id_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:pb.TestData.id) +} +inline void TestData::set_id(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + id_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:pb.TestData.id) +} +inline void TestData::set_id(const char* value, size_t size) { + + id_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:pb.TestData.id) +} +inline std::string* TestData::mutable_id() { + + // @@protoc_insertion_point(field_mutable:pb.TestData.id) + return id_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* TestData::release_id() { + // @@protoc_insertion_point(field_release:pb.TestData.id) + + return id_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void TestData::set_allocated_id(std::string* id) { + if (id != nullptr) { + + } else { + + } + id_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), id); + // @@protoc_insertion_point(field_set_allocated:pb.TestData.id) +} + +// string name = 2; +inline void TestData::clear_name() { + name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& TestData::name() const { + // @@protoc_insertion_point(field_get:pb.TestData.name) + return name_.GetNoArena(); +} +inline void TestData::set_name(const std::string& value) { + + name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:pb.TestData.name) +} +inline void TestData::set_name(std::string&& value) { + + name_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:pb.TestData.name) +} +inline void TestData::set_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:pb.TestData.name) +} +inline void TestData::set_name(const char* value, size_t size) { + + name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:pb.TestData.name) +} +inline std::string* TestData::mutable_name() { + + // @@protoc_insertion_point(field_mutable:pb.TestData.name) + return name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* TestData::release_name() { + // @@protoc_insertion_point(field_release:pb.TestData.name) + + return name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void TestData::set_allocated_name(std::string* name) { + if (name != nullptr) { + + } else { + + } + name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name); + // @@protoc_insertion_point(field_set_allocated:pb.TestData.name) +} + +// ------------------------------------------------------------------- + +// InsertMsg + +// int64 client_id = 1; +inline void InsertMsg::clear_client_id() { + client_id_ = PROTOBUF_LONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::int64 InsertMsg::client_id() const { + // @@protoc_insertion_point(field_get:pb.InsertMsg.client_id) + return client_id_; +} +inline void InsertMsg::set_client_id(::PROTOBUF_NAMESPACE_ID::int64 value) { + + client_id_ = value; + // @@protoc_insertion_point(field_set:pb.InsertMsg.client_id) +} + +// ------------------------------------------------------------------- + +// DeleteMsg + +// int64 client_id = 1; +inline void DeleteMsg::clear_client_id() { + client_id_ = PROTOBUF_LONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::int64 DeleteMsg::client_id() const { + // @@protoc_insertion_point(field_get:pb.DeleteMsg.client_id) + return client_id_; +} +inline void DeleteMsg::set_client_id(::PROTOBUF_NAMESPACE_ID::int64 value) { + + client_id_ = value; + // @@protoc_insertion_point(field_set:pb.DeleteMsg.client_id) +} + +// ------------------------------------------------------------------- + +// SearchMsg + +// int64 client_id = 1; +inline void SearchMsg::clear_client_id() { + client_id_ = PROTOBUF_LONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::int64 SearchMsg::client_id() const { + // @@protoc_insertion_point(field_get:pb.SearchMsg.client_id) + return client_id_; +} +inline void SearchMsg::set_client_id(::PROTOBUF_NAMESPACE_ID::int64 value) { + + client_id_ = value; + // @@protoc_insertion_point(field_set:pb.SearchMsg.client_id) +} + +// ------------------------------------------------------------------- + +// SearchResultMsg + +// int64 client_id = 1; +inline void SearchResultMsg::clear_client_id() { + client_id_ = PROTOBUF_LONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::int64 SearchResultMsg::client_id() const { + // @@protoc_insertion_point(field_get:pb.SearchResultMsg.client_id) + return client_id_; +} +inline void SearchResultMsg::set_client_id(::PROTOBUF_NAMESPACE_ID::int64 value) { + + client_id_ = value; + // @@protoc_insertion_point(field_set:pb.SearchResultMsg.client_id) +} + +#ifdef __GNUC__ + #pragma GCC diagnostic pop +#endif // __GNUC__ +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace pb + +PROTOBUF_NAMESPACE_OPEN + +template <> struct is_proto_enum< ::pb::ErrorCode> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::pb::ErrorCode>() { + return ::pb::ErrorCode_descriptor(); +} +template <> struct is_proto_enum< ::pb::DataType> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::pb::DataType>() { + return ::pb::DataType_descriptor(); +} +template <> struct is_proto_enum< ::pb::OpType> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::pb::OpType>() { + return ::pb::OpType_descriptor(); +} + +PROTOBUF_NAMESPACE_CLOSE + +// @@protoc_insertion_point(global_scope) + +#include +#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_pulsar_2eproto diff --git a/proxy/src/pulsar/message_client/pb/pulsar.proto b/proxy/src/pulsar/message_client/pb/pulsar.proto new file mode 100644 index 0000000000..17dfff0b9c --- /dev/null +++ b/proxy/src/pulsar/message_client/pb/pulsar.proto @@ -0,0 +1,157 @@ + +syntax = "proto3"; + +package pb; + +enum ErrorCode { + SUCCESS = 0; + UNEXPECTED_ERROR = 1; + CONNECT_FAILED = 2; + PERMISSION_DENIED = 3; + COLLECTION_NOT_EXISTS = 4; + ILLEGAL_ARGUMENT = 5; + ILLEGAL_DIMENSION = 7; + ILLEGAL_INDEX_TYPE = 8; + ILLEGAL_COLLECTION_NAME = 9; + ILLEGAL_TOPK = 10; + ILLEGAL_ROWRECORD = 11; + ILLEGAL_VECTOR_ID = 12; + ILLEGAL_SEARCH_RESULT = 13; + FILE_NOT_FOUND = 14; + META_FAILED = 15; + CACHE_FAILED = 16; + CANNOT_CREATE_FOLDER = 17; + CANNOT_CREATE_FILE = 18; + CANNOT_DELETE_FOLDER = 19; + CANNOT_DELETE_FILE = 20; + BUILD_INDEX_ERROR = 21; + ILLEGAL_NLIST = 22; + ILLEGAL_METRIC_TYPE = 23; + OUT_OF_MEMORY = 24; +} + +message Status { + ErrorCode error_code = 1; + string reason = 2; +} + +enum DataType { + NONE = 0; + BOOL = 1; + INT8 = 2; + INT16 = 3; + INT32 = 4; + INT64 = 5; + + FLOAT = 10; + DOUBLE = 11; + + STRING = 20; + + VECTOR_BINARY = 100; + VECTOR_FLOAT = 101; +} + +enum OpType { + Insert = 0; + Delete = 1; + Search = 2; + TimeSync = 3; + Key2Seg = 4; + Statistics = 5; +} + +message SegmentRecord { + repeated string seg_info = 1; +} + +message VectorRowRecord { + repeated float float_data = 1; //float vector data + bytes binary_data = 2; //binary vector data +} + +message AttrRecord { + repeated int32 int32_value = 1; + repeated int64 int64_value = 2; + repeated float float_value = 3; + repeated double double_value = 4; +} + +message VectorRecord { + repeated VectorRowRecord records = 1; +} + +message VectorParam { + string json = 1; + VectorRecord row_record = 2; +} + +message FieldValue { + string field_name = 1; + DataType type = 2; + AttrRecord attr_record = 3; + VectorRecord vector_record = 4; +} + +message Cell { + oneof value{ + int32 int32_value = 1; + int64 int64_value = 2; + float float_value = 3; + double double_value = 4; + VectorRowRecord vec = 5; + } +} + +message RowValue{ + repeated Cell cell = 2; +} + +message PulsarMessage { + string collection_name = 1; + repeated FieldValue fields = 2; + int64 entity_id = 3; + string partition_tag = 4; + VectorParam vector_param =5; + SegmentRecord segments = 6; + int64 timestamp = 7; + int64 client_id = 8; + OpType msg_type = 9; + string topic_name = 10; + int64 partition_id = 11; +} + +//message PulsarMessages { +// string collection_name = 1; +// repeated FieldValue fields = 2; +// repeated int64 entity_id = 3; +// string partition_tag = 4; +// repeated VectorParam vector_param =5; +// repeated SegmentRecord segments = 6; +// repeated int64 timestamp = 7; +// repeated int64 client_id = 8; +// OpType msg_type = 9; +// repeated string topic_name = 10; +// repeated int64 partition_id = 11; +//} +message TestData { + string id = 1; + string name = 2; +} + +message InsertMsg { + int64 client_id = 1; +} + +message DeleteMsg { + int64 client_id = 1; +} + +message SearchMsg { + int64 client_id = 1; +} + +message SearchResultMsg { + int64 client_id = 1; +} + diff --git a/proxy/src/pulsar/unittest/CMakeLists.txt b/proxy/src/pulsar/unittest/CMakeLists.txt new file mode 100644 index 0000000000..5bf43b79fd --- /dev/null +++ b/proxy/src/pulsar/unittest/CMakeLists.txt @@ -0,0 +1,14 @@ +enable_testing() +set(unittest_srcs + unittest_entry.cpp + consumer_test.cpp producer_test.cpp) + +add_executable(test ${unittest_srcs}) + +target_link_libraries(test + message_client_cpp + pulsar + gtest + gtest_main) + +install(TARGETS test DESTINATION unittest) \ No newline at end of file diff --git a/proxy/src/pulsar/unittest/consumer_test.cpp b/proxy/src/pulsar/unittest/consumer_test.cpp new file mode 100644 index 0000000000..f925706aca --- /dev/null +++ b/proxy/src/pulsar/unittest/consumer_test.cpp @@ -0,0 +1,14 @@ +#include +#include "pulsar/message_client/Consumer.h" +#include "pulsar/message_client/pb/pulsar.pb.h" + +TEST(CLIENT_CPP, CONSUMER) { + auto client= std::make_shared("pulsar://localhost:6650"); + message_client::MsgConsumer consumer(client, "my_consumer"); + consumer.subscribe("test"); + auto msg = consumer.receive_proto(message_client::TEST); + pb::TestData* data = (pb::TestData*)(msg.get()); + std::cout << "Received: " << msg << " with payload '" << data->name()<< ";" << data->id(); + consumer.close(); + client->close(); +} diff --git a/proxy/src/pulsar/unittest/producer_test.cpp b/proxy/src/pulsar/unittest/producer_test.cpp new file mode 100644 index 0000000000..02e295e5bb --- /dev/null +++ b/proxy/src/pulsar/unittest/producer_test.cpp @@ -0,0 +1,15 @@ +#include +#include "pulsar/message_client/Producer.h" +#include "pulsar/message_client/pb/pulsar.pb.h" + +TEST(CLIENT_CPP, Producer) { + auto client= std::make_shared("pulsar://localhost:6650"); + message_client::MsgProducer producer(client,"test"); + pb::TestData data; + data.set_id("test"); + data.set_name("hahah"); + std::string to_string = data.SerializeAsString(); + producer.send(to_string); + producer.close(); + client->close(); +} diff --git a/proxy/src/pulsar/unittest/unittest_entry.cpp b/proxy/src/pulsar/unittest/unittest_entry.cpp new file mode 100644 index 0000000000..697a9d70c0 --- /dev/null +++ b/proxy/src/pulsar/unittest/unittest_entry.cpp @@ -0,0 +1,6 @@ +#include + +int main(int argc, char** argv) { + ::testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); +} diff --git a/proxy/src/test/CMakeLists.txt b/proxy/src/test/CMakeLists.txt new file mode 100644 index 0000000000..c5c8edb60e --- /dev/null +++ b/proxy/src/test/CMakeLists.txt @@ -0,0 +1,26 @@ +AUX_SOURCE_DIRECTORY(. TEST) + +set( GRPC_SERVICE_FILES ${MILVUS_ENGINE_SRC}/grpc/gen-milvus/milvus.grpc.pb.cc + ${MILVUS_ENGINE_SRC}/grpc/gen-milvus/milvus.pb.cc + ${MILVUS_ENGINE_SRC}/grpc/gen-status/status.grpc.pb.cc + ${MILVUS_ENGINE_SRC}/grpc/gen-status/status.pb.cc + ${MILVUS_ENGINE_SRC}/grpc/gen-milvus/hello.grpc.pb.cc + ${MILVUS_ENGINE_SRC}/grpc/gen-milvus/hello.pb.cc + ${MILVUS_ENGINE_SRC}/grpc/gen-milvus/master.grpc.pb.cc + ${MILVUS_ENGINE_SRC}/grpc/gen-milvus/master.pb.cc + ) +add_executable(test_pulsar ${TEST} ${GRPC_SERVICE_FILES}) + +target_include_directories(test_pulsar PUBLIC ${PROJECT_BINARY_DIR}/thirdparty/pulsar/pulsar-src/pulsar-client-cpp/include) +target_include_directories(test_pulsar PUBLIC ${PROJECT_BINARY_DIR}/thirdparty/avro/avro-build/include) + + +target_link_libraries(test_pulsar + pulsarStatic + libprotobuf + grpc++_reflection + grpc++ + libboost_system.a + libboost_filesystem.a + libboost_serialization.a + ) \ No newline at end of file diff --git a/proxy/src/test/test_pulsar.cpp b/proxy/src/test/test_pulsar.cpp new file mode 100644 index 0000000000..3aa1989475 --- /dev/null +++ b/proxy/src/test/test_pulsar.cpp @@ -0,0 +1,71 @@ +#include "thread" +#include "pulsar/Client.h" +#include +#include + +using namespace pulsar; +using MyData = milvus::grpc::PMessage; + +static const std::string exampleSchema = + "{\"type\":\"record\",\"name\":\"Example\",\"namespace\":\"test\"," + "\"fields\":[{\"name\":\"id\",\"type\":\"string\"}, {\"name\":\"reason\",\"type\":\"string\"}]}"; + +int consumer() { + + Client client("pulsar://localhost:6650"); + + ConsumerConfiguration consumerConf; + Consumer consumer; + consumerConf.setSchema(SchemaInfo(PROTOBUF, "Protobuf", exampleSchema)); + Result result = client.subscribe("topic-proto", "sub-2", consumerConf, consumer); + + if (result != ResultOk) { + std::cout << "Failed to subscribe: " << result << std::endl; + return -1; + } + + Message msg; + for (int i = 0; i < 10; i++) { + consumer.receive(msg); + MyData data; + data.ParseFromString(msg.getDataAsString()); + std::cout << " Received: " << msg + << " with payload '" << data.id() << " " << data.reason() << "'" + << std::endl; + + consumer.acknowledge(msg); + } + + client.close(); + return 0; +} + +int main() { + Client client("pulsar://localhost:6650"); + + Producer producer; + ProducerConfiguration producerConf; + producerConf.setSchema(SchemaInfo(PROTOBUF, "Protobuf", exampleSchema)); + Result result = client.createProducer("pro", producerConf, producer); + + if (result != ResultOk) { + std::cout << "Error creating producer: " << result << std::endl; + return -1; + } + +// std::thread t(consumer); + // Publish 10 messages to the topic + for (int i = 0; i < 1; i++) { + auto data = MyData(); + auto a = new milvus::grpc::A(); + a->set_a(9999); + data.set_allocated_a(a); + data.set_id("999"); + data.set_reason("*****test****"); + Message msg = MessageBuilder().setContent(data.SerializeAsString()).build(); + Result res = producer.send(msg); + std::cout << " Message sent: " << res << std::endl; + } + client.close(); +// t.join(); +} \ No newline at end of file diff --git a/proxy/thirdparty/avro/CMakeLists.txt b/proxy/thirdparty/avro/CMakeLists.txt new file mode 100644 index 0000000000..16b235fd70 --- /dev/null +++ b/proxy/thirdparty/avro/CMakeLists.txt @@ -0,0 +1,56 @@ +#------------------------------------------------------------------------------- +# Copyright (C) 2019-2020 Zilliz. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance +# with the License. You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software distributed under the License +# is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express +# or implied. See the License for the specific language governing permissions and limitations under the License. +#------------------------------------------------------------------------------- + +if (DEFINED ENV{MILVUS_AVRO_URL}) + set(AVRO_URL "$ENV{MILVUS_AVRO_URL}") +else () + set(AVRO_URL + "https://github.com/apache/avro/archive/${AVRO_VERSION}.zip") +endif () + + +message(STATUS "Building avro-${AVRO_VERSION} from source") + + +FetchContent_Declare( + avro + URL ${AVRO_URL} + # URL_MD5 "f9137c5bc18b7d74027936f0f1bfa5c8" + DOWNLOAD_DIR ${MILVUS_BINARY_DIR}/3rdparty_download/download + SOURCE_DIR ${CMAKE_CURRENT_BINARY_DIR}/avro-src + BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR}/avro-build +) + +include(FetchContent) +FetchContent_GetProperties( avro ) +if (NOT avro_POPULATED) + FetchContent_Populate(avro) + +# file(REMOVE ${avro_SOURCE_DIR}/pulsar-client-cpp/CMakeLists.txt) +# message("${pulsar_SOURCE_DIR}/pulsar-client-cpp/CMakeLists.txt") +# EXECUTE_PROCESS(COMMAND cp ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists ${pulsar_SOURCE_DIR}/pulsar-client-cpp/CMakeLists.txt) + + # Adding the following targets: + # pulsar-client-cpp + add_subdirectory(${avro_SOURCE_DIR}/lang/c++ + ${avro_BINARY_DIR} + EXCLUDE_FROM_ALL) + + file (INSTALL DIRECTORY ${avro_SOURCE_DIR}/lang/c++/api/ DESTINATION ${avro_BINARY_DIR}/include/avro + FILES_MATCHING PATTERN *.hh) + +# target_include_directories(avrocpp PUBLIC ${pulsar_SOURCE_DIR}/pulsar-client-cpp/include) +endif () + +get_property(var DIRECTORY "${avro_SOURCE_DIR}/lang/c++" PROPERTY COMPILE_OPTIONS) +message(STATUS "avro compile options: ${var}") diff --git a/proxy/thirdparty/pulsar/CMakeLists.txt b/proxy/thirdparty/pulsar/CMakeLists.txt index 1beb217c6d..9904cc1e9f 100644 --- a/proxy/thirdparty/pulsar/CMakeLists.txt +++ b/proxy/thirdparty/pulsar/CMakeLists.txt @@ -45,7 +45,7 @@ FetchContent_Declare( include(FetchContent) FetchContent_GetProperties( pulsar ) -SET(BUILD_TESTS CACHE BOOL OFF FORCE) + if (NOT pulsar_POPULATED) FetchContent_Populate(pulsar) @@ -53,6 +53,11 @@ if (NOT pulsar_POPULATED) message("${pulsar_SOURCE_DIR}/pulsar-client-cpp/CMakeLists.txt") EXECUTE_PROCESS(COMMAND cp ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists ${pulsar_SOURCE_DIR}/pulsar-client-cpp/CMakeLists.txt) + SET(BUILD_TESTS CACHE BOOL OFF FORCE) + # pulsar-cpp-client CMakeLists.txt need variables below, set them for build without install libprotobuf_dev + SET(Protobuf_INCLUDE_DIRS CACHE PATH ${CMAKE_BINARY_DIR}/thirdparty/grpc/grpc-src/third_party/protobuf/src FORCE) + SET(Protobuf_LITE_LIBRARIES CACHE PATH ${CMAKE_BINARY_DIR}/thirdparty/grpc/grpc-build/third_party/protobuf FORCE) + # Adding the following targets: # pulsar-client-cpp add_subdirectory(${pulsar_SOURCE_DIR}/pulsar-client-cpp