refactory: improvments of typo and some hotfix

Signed-off-by: Ji Bin <[email protected]>

Author: matrixji

src/impl/MilvusClientImpl.cpp

@@ -141,7 +141,7 @@ MilvusClientImpl::LoadCollection(const std::string& collection_name, int replica
     };
 
     auto wait_for_status = [this, &collection_name, &progress_monitor](const proto::common::Status&) {
-        return waitForStatus(
+        return WaitForStatus(
             [&collection_name, this](Progress& progress) -> Status {
                 CollectionsInfo collections_info;
                 auto collection_names = std::vector<std::string>{collection_name};
@@ -259,7 +259,7 @@ MilvusClientImpl::ShowCollections(const std::vector<std::string>& collection_nam
     };
 
     auto post = [&collections_info](const proto::milvus::ShowCollectionsResponse& response) {
-        for (size_t i = 0; i < response.collection_ids_size(); i++) {
+        for (int i = 0; i < response.collection_ids_size(); i++) {
             auto inmemory_percentage = 0;
             if (response.inmemory_percentages_size() > i) {
                 inmemory_percentage = response.inmemory_percentages(i);
@@ -331,7 +331,7 @@ MilvusClientImpl::LoadPartitions(const std::string& collection_name, const std::
     };
 
     auto wait_for_status = [this, &collection_name, &partition_names, &progress_monitor](const proto::common::Status&) {
-        return waitForStatus(
+        return WaitForStatus(
             [&collection_name, &partition_names, this](Progress& progress) -> Status {
                 PartitionsInfo partitions_info;
                 auto status = ShowPartitions(collection_name, partition_names, partitions_info);
@@ -422,7 +422,7 @@ MilvusClientImpl::ShowPartitions(const std::string& collection_name, const std::
         if (count > 0) {
             partitions_info.reserve(count);
         }
-        for (size_t i = 0; i < count; ++i) {
+        for (int i = 0; i < count; ++i) {
             partitions_info.emplace_back(response.partition_names(i), response.partitionids(i),
                                          response.created_timestamps(i), response.inmemory_percentages(i));
         }
@@ -499,7 +499,7 @@ MilvusClientImpl::CreateIndex(const std::string& collection_name, const IndexDes
     };
 
     auto wait_for_status = [&collection_name, &index_desc, &progress_monitor, this](const proto::common::Status&) {
-        return waitForStatus(
+        return WaitForStatus(
             [&collection_name, &index_desc, this](Progress& progress) -> Status {
                 IndexState index_state;
                 auto status = GetIndexState(collection_name, index_desc.FieldName(), index_state);
@@ -539,13 +539,13 @@ MilvusClientImpl::DescribeIndex(const std::string& collection_name, const std::s
 
     auto post = [&index_desc](const proto::milvus::DescribeIndexResponse& response) {
         auto count = response.index_descriptions_size();
-        for (size_t i = 0; i < count; ++i) {
+        for (int i = 0; i < count; ++i) {
             auto& field_name = response.index_descriptions(i).field_name();
             auto& index_name = response.index_descriptions(i).index_name();
             index_desc.SetFieldName(field_name);
             index_desc.SetIndexName(index_name);
             auto index_params_size = response.index_descriptions(i).params_size();
-            for (size_t j = 0; j < index_params_size; ++j) {
+            for (int j = 0; j < index_params_size; ++j) {
                 const auto& key = response.index_descriptions(i).params(j).key();
                 const auto& value = response.index_descriptions(i).params(j).value();
                 if (key == milvus::KeyIndexType()) {
@@ -759,19 +759,20 @@ MilvusClientImpl::Search(const SearchArguments& arguments, SearchResults& result
         const auto& scores = result_data.scores();
         const auto& fields_data = result_data.fields_data();
         auto num_of_queries = result_data.num_queries();
-        std::vector<int64_t> topks(num_of_queries, result_data.top_k());
+        std::vector<int> topks{};
+        topks.reserve(result_data.topks_size());
         for (int i = 0; i < result_data.topks_size(); ++i) {
-            topks[i] = result_data.topks(i);
+            topks.emplace_back(result_data.topks(i));
         }
         std::vector<SingleResult> single_results;
         single_results.reserve(num_of_queries);
-        size_t offset{0};
-        for (int64_t i = 0; i < num_of_queries; ++i) {
+        int offset{0};
+        for (int i = 0; i < num_of_queries; ++i) {
             std::vector<float> item_scores;
             std::vector<FieldDataPtr> item_field_data;
             auto item_topk = topks[i];
             item_scores.reserve(item_topk);
-            for (int64_t j = 0; j < item_topk; ++j) {
+            for (int j = 0; j < item_topk; ++j) {
                 item_scores.emplace_back(scores.at(offset + j));
             }
             item_field_data.reserve(fields_data.size());
@@ -842,7 +843,7 @@ MilvusClientImpl::CalcDistance(const CalcDistanceArguments& arguments, DistanceA
                     }
 
                     // suppose vectors is not empty, already checked by Validate()
-                    data_array->set_dim(vectors[0].size());
+                    data_array->set_dim(static_cast<int>(vectors[0].size()));
                 } else {
                     auto data_ptr = std::static_pointer_cast<BinaryVecFieldData>(arg_vectors);
                     auto& str = *data_array->mutable_binary_vector();
@@ -853,7 +854,7 @@ MilvusClientImpl::CalcDistance(const CalcDistanceArguments& arguments, DistanceA
                     for (auto& vector : vectors) {
                         str.append(vector);
                     }
-                    data_array->set_dim(dimensions);
+                    data_array->set_dim(static_cast<int>(dimensions));
                 }
 
             } else if (arg_vectors->Type() == DataType::INT64) {
@@ -960,7 +961,7 @@ MilvusClientImpl::Flush(const std::vector<std::string>& collection_names, const
             return Status::OK();
         }
 
-        return waitForStatus(
+        return WaitForStatus(
             [&segment_count, &flush_segments, &finished_count, this](Progress& p) -> Status {
                 p.total_ = segment_count;
 
@@ -1117,7 +1118,7 @@ MilvusClientImpl::ManualCompaction(const std::string& collection_name, uint64_t
         return status;
     }
 
-    auto pre = [&collection_name, &travel_timestamp, &collection_desc]() {
+    auto pre = [&travel_timestamp, &collection_desc]() {
         proto::milvus::ManualCompactionRequest rpc_request;
         rpc_request.set_collectionid(collection_desc.ID());
         rpc_request.set_timetravel(travel_timestamp);
@@ -1223,7 +1224,7 @@ MilvusClientImpl::ListCredUsers(std::vector<std::string>& users) {
 }
 
 Status
-MilvusClientImpl::waitForStatus(std::function<Status(Progress&)> query_function,
+MilvusClientImpl::WaitForStatus(const std::function<Status(Progress&)>& query_function,
                                 const ProgressMonitor& progress_monitor) {
     // no need to check
     if (progress_monitor.CheckTimeout() == 0) {

src/impl/MilvusClientImpl.h

@@ -186,16 +186,16 @@ class MilvusClientImpl : public MilvusClient {
      * @param [in] progress_monitor timeout setting for waiting progress
      * @return Status, the final status
      */
-    Status
-    waitForStatus(std::function<Status(Progress&)> query_function, const ProgressMonitor& progress_monitor);
+    static Status
+    WaitForStatus(const std::function<Status(Progress&)>& query_function, const ProgressMonitor& progress_monitor);
 
     /**
      * @brief template for public api call
      *        validate -> pre -> rpc -> wait_for_status -> post
      */
     template <typename Request, typename Response>
     Status
-    apiHandler(std::function<Status(void)> validate, std::function<Request(void)> pre,
+    apiHandler(const std::function<Status(void)>& validate, std::function<Request(void)> pre,
                Status (MilvusConnection::*rpc)(const Request&, Response&, const GrpcOpts&),
                std::function<Status(const Response&)> wait_for_status, std::function<void(const Response&)> post,
                const GrpcOpts& options = GrpcOpts{}) {
@@ -215,7 +215,7 @@ class MilvusClientImpl : public MilvusClient {
         auto status = std::bind(rpc, connection_.get(), std::placeholders::_1, std::placeholders::_2,
                                 std::placeholders::_3)(rpc_request, rpc_response, options);
         if (!status.IsOk()) {
-            // resp's status already checked in connection class
+            // response's status already checked in connection class
             return status;
         }
 

src/impl/MilvusConnection.cpp

@@ -20,7 +20,6 @@
 #include <memory>
 
 #include "grpcpp/security/credentials.h"
-#include "milvus/types/ConnectParam.h"
 
 using grpc::Channel;
 using grpc::ClientContext;
@@ -63,8 +62,8 @@ MilvusConnection::~MilvusConnection() {
 Status
 MilvusConnection::Connect(const ConnectParam& param) {
     authorization_value_ = param.Authorizations();
-    std::shared_ptr<grpc::ChannelCredentials> creds{nullptr};
-    auto& uri = param.Uri();
+    std::shared_ptr<grpc::ChannelCredentials> credentials{nullptr};
+    auto uri = param.Uri();
 
     ::grpc::ChannelArguments args;
     args.SetMaxSendMessageSize(-1);     // max send message size: 2GB
@@ -74,12 +73,12 @@ MilvusConnection::Connect(const ConnectParam& param) {
         if (!param.ServerName().empty()) {
             args.SetSslTargetNameOverride(param.ServerName());
         }
-        creds = createTlsCredentials(param.Cert(), param.Key(), param.CaCert());
+        credentials = createTlsCredentials(param.Cert(), param.Key(), param.CaCert());
     } else {
-        creds = ::grpc::InsecureChannelCredentials();
+        credentials = ::grpc::InsecureChannelCredentials();
     }
 
-    channel_ = ::grpc::CreateCustomChannel(uri, creds, args);
+    channel_ = ::grpc::CreateCustomChannel(uri, credentials, args);
     auto connected = channel_->WaitForConnected(std::chrono::system_clock::now() +
                                                 std::chrono::milliseconds{param.ConnectTimeout()});
     if (connected) {
@@ -175,7 +174,7 @@ MilvusConnection::DropPartition(const proto::milvus::DropPartitionRequest& reque
 Status
 MilvusConnection::HasPartition(const proto::milvus::HasPartitionRequest& request, proto::milvus::BoolResponse& response,
                                const GrpcContextOptions& options) {
-    return grpcCall("HasParition", &Stub::HasPartition, request, response, options);
+    return grpcCall("HasPartition", &Stub::HasPartition, request, response, options);
 }
 
 Status

src/impl/MilvusConnection.h

@@ -238,23 +238,23 @@ class MilvusConnection {
     std::shared_ptr<grpc::Channel> channel_;
     std::string authorization_value_{};
 
-    Status
-    statusByProtoResponse(const proto::common::Status& status) {
-        if (status.error_code() != proto::common::ErrorCode::Success) {
+    static Status
+    StatusByProtoResponse(const proto::common::Status& status) {
+        if (status.code() != proto::common::ErrorCode::Success) {
             return Status{StatusCode::SERVER_FAILED, status.reason()};
         }
         return Status::OK();
     }
 
     template <typename Response>
-    Status
-    statusByProtoResponse(const Response& response) {
+    static Status
+    StatusByProtoResponse(const Response& response) {
         const auto& status = response.status();
-        return statusByProtoResponse(status);
+        return StatusByProtoResponse(status);
     }
 
-    StatusCode
-    statusCodeFromGrpcStatus(const ::grpc::Status& grpc_status) {
+    static StatusCode
+    StatusCodeFromGrpcStatus(const ::grpc::Status& grpc_status) {
         if (grpc_status.error_code() == ::grpc::StatusCode::DEADLINE_EXCEEDED) {
             return StatusCode::TIMEOUT;
         }
@@ -284,10 +284,10 @@ class MilvusConnection {
         ::grpc::Status grpc_status = (stub_.get()->*func)(&context, request, &response);
 
         if (!grpc_status.ok()) {
-            return {statusCodeFromGrpcStatus(grpc_status), grpc_status.error_message()};
+            return {StatusCodeFromGrpcStatus(grpc_status), grpc_status.error_message()};
         }
 
-        return statusByProtoResponse(response);
+        return StatusByProtoResponse(response);
     }
 };
 

src/impl/Status.cpp

@@ -16,8 +16,6 @@
 
 #include "milvus/Status.h"
 
-#include <cstring>
-
 namespace milvus {
 
 Status::Status(StatusCode code, std::string msg) : code_(code), msg_(std::move(msg)) {

src/impl/TypeUtils.cpp

@@ -406,7 +406,7 @@ CreateProtoFieldData(const BinaryVecFieldData& field) {
     for (const auto& item : data) {
         std::copy(item.begin(), item.end(), std::back_inserter(vectors_data));
     }
-    ret->set_dim(dim);
+    ret->set_dim(static_cast<int>(dim));
     return ret;
 }
 
@@ -416,11 +416,11 @@ CreateProtoFieldData(const FloatVecFieldData& field) {
     auto& data = field.Data();
     auto dim = data.front().size();
     auto& vectors_data = *(ret->mutable_float_vector()->mutable_data());
-    vectors_data.Reserve(data.size() * dim);
+    vectors_data.Reserve(static_cast<int>(data.size() * dim));
     for (const auto& item : data) {
         vectors_data.Add(item.begin(), item.end());
     }
-    ret->set_dim(dim);
+    ret->set_dim(static_cast<int>(dim));
     return ret;
 }
 

src/impl/types/CalcDistanceArguments.cpp

@@ -16,8 +16,6 @@
 
 #include "milvus/types/CalcDistanceArguments.h"
 
-#include <algorithm>
-#include <functional>
 #include <set>
 #include <unordered_map>
 

src/impl/types/CollectionStat.cpp

@@ -29,7 +29,7 @@ CollectionStat::RowCount() const {
         // TODO: throw exception or log
         return 0;
     }
-    return std::atoll(iter->second.c_str());
+    return std::strtoll(iter->second.c_str(), nullptr, 10);
 }
 
 void

src/impl/types/CompactionState.cpp

@@ -16,8 +16,6 @@
 
 #include "milvus/types/CompactionState.h"
 
-#include <string>
-
 namespace milvus {
 
 CompactionState::CompactionState() = default;

src/impl/types/ConnectParam.cpp

@@ -40,7 +40,7 @@ ConnectParam::Port() const {
     return port_;
 }
 
-const std::string
+std::string
 ConnectParam::Uri() const {
     return host_ + ":" + std::to_string(port_);
 }