From 3863f2d3b3ec412b96aca6220ced2f30176ab0fb Mon Sep 17 00:00:00 2001
From: Xu Peng <xupeng3112@163.com>
Date: Mon, 15 Apr 2019 13:32:03 +0800
Subject: [PATCH] fix(db): fix status compile error

Former-commit-id: 1d896ef1c7970c9c418683560e760762d828be84
---
 cpp/src/db/status.cpp | 40 ++++++++++++++++++++++--------------
 cpp/src/db/status.h   | 47 ++++++++++++++++++++++---------------------
 2 files changed, 49 insertions(+), 38 deletions(-)

diff --git a/cpp/src/db/status.cpp b/cpp/src/db/status.cpp
index 8c547d5abe..457565d10c 100644
--- a/cpp/src/db/status.cpp
+++ b/cpp/src/db/status.cpp
@@ -1,40 +1,48 @@
+#include <stdio.h>
+#include <cstring>
+#include <assert.h>
 #include "status.h"
 
-namespace vecengine {
+namespace zilliz {
+namespace vecwise {
+namespace engine {
 
-const char* Status::CopyState(const char* state_) {
+const char* Status::CopyState(const char* state) {
     uint32_t size;
-    memcpy(&size, state_, sizeof(size));
-    char result = new char[size+5];
-    memcpy(result, state_, size+5);
+    std::memcpy(&size, state, sizeof(size));
+    char* result = new char[size+5];
+    memcpy(result, state, size+5);
     return result;
 }
 
-Status::Status(Code code_, const std::string& msg_, const std::string& msg2_) {
-    assert(code_ != kOK);
-    const uint32_t len1 = msg_.size();
-    const uint32_t len2 = msg2_.size();
+Status::Status(Code code, const std::string& msg, const std::string& msg2) {
+    assert(code != kOK);
+    const uint32_t len1 = msg.size();
+    const uint32_t len2 = msg2.size();
     const uint32_t size = len1 + (len2 ? (2+len2) : 0);
     char* result = new char[size+5];
-    memcpy(result, &size, sizeof(size));
+    std::memcpy(result, &size, sizeof(size));
     result[4] = static_cast<char>(code);
-    memcpy(result+5, msg_.data(), len1);
+    memcpy(result+5, msg.data(), len1);
     if (len2) {
         result[5 + len1] = ':';
         result[6 + len1] = ' ';
-        memcpy(result + 7 + len1, msg2_.data(), len2);
+        memcpy(result + 7 + len1, msg2.data(), len2);
     }
-    _state = result;
+    state_ = result;
 }
 
 std::string Status::ToString() const {
-    if (_state == nullptr) return "OK";
+    if (state_ == nullptr) return "OK";
     char tmp[30];
     const char* type;
     switch (code()) {
         case kOK:
             type = "OK";
             break;
+        case kNotFound:
+            type = "NotFound: ";
+            break;
         default:
             snprintf(tmp, sizeof(tmp), "Unkown code(%d): ",
                     static_cast<int>(code()));
@@ -49,4 +57,6 @@ std::string Status::ToString() const {
     return result;
 }
 
-} // namespace vecengine
+} // namespace engine
+} // namespace vecwise
+} // namespace zilliz
diff --git a/cpp/src/db/status.h b/cpp/src/db/status.h
index 85ac57c1c8..80be027c9b 100644
--- a/cpp/src/db/status.h
+++ b/cpp/src/db/status.h
@@ -1,5 +1,6 @@
-#ifndef VECENGINE_STATUS_H_
-#define VECENGINE_STATUS_H_
+#pragma once
+
+#include <string>
 
 namespace zilliz {
 namespace vecwise {
@@ -7,26 +8,28 @@ namespace engine {
 
 class Status {
 public:
-    Status() noexcept : _state(nullptr) {}
-    ~Status() { delete[] _state; }
+    Status() noexcept : state_(nullptr) {}
+    ~Status() { delete[] state_; }
 
-    Status(const Status& rhs_);
-    Status& operator=(const Status& rhs_);
+    Status(const Status& rhs);
+    Status& operator=(const Status& rhs);
 
-    Status(const Status&& rhs_) noexcept : _state(rhs_._state) { rhs_._state = nullptr; }
-    Status& operator=(const Status& rhs_) noexcept;
+    Status(Status&& rhs) noexcept : state_(rhs.state_) { rhs.state_ = nullptr; }
+    Status& operator=(Status&& rhs_) noexcept;
 
     static Status OK() { return Status(); }
-    static Status NotFound(const std::string& msg_, const std::string& msg2_="") {
-        return Status(kNotFound, msg_, msg2_);
+    static Status NotFound(const std::string& msg, const std::string& msg2="") {
+        return Status(kNotFound, msg, msg2);
     }
 
-    bool ok() const { return _state == nullptr; }
+    bool ok() const { return state_ == nullptr; }
 
     bool IsNotFound() const { return code() == kNotFound; }
 
+    std::string ToString() const;
+
 private:
-    const char* _state;
+    const char* state_;
 
     enum Code {
         kOK = 0,
@@ -34,32 +37,30 @@ private:
     };
 
     Code code() const {
-        return (_state == nullptr) ? kOK : static_cast<Code>(_state[4])
+        return (state_ == nullptr) ? kOK : static_cast<Code>(state_[4]);
     }
-
+    Status(Code code, const std::string& msg, const std::string& msg2);
     static const char* CopyState(const char* s);
 
 }; // Status
 
-inline Status::Status(const Status* rhs_) {
-    _state = (rhs_._state == nullptr) ? nullptr : CopyState(rhs_._state);
+inline Status::Status(const Status& rhs) {
+    state_ = (rhs.state_ == nullptr) ? nullptr : CopyState(rhs.state_);
 }
 
-inline Status& Status::operator=(const Status& rhs_) {
-    if (_state != rhs_._state) {
+inline Status& Status::operator=(const Status& rhs) {
+    if (state_ != rhs.state_) {
         delete[] state_;
-        _state = (rhs_._state == nullptr) ? nullptr : CopyState(rhs_._state);
+        state_ = (rhs.state_ == nullptr) ? nullptr : CopyState(rhs.state_);
     }
     return *this;
 }
 
-inline Status& Status::operator=(Status&& rhs_) noexcept {
-    std::swap(_state, rhs_._state);
+inline Status& Status::operator=(Status&& rhs) noexcept {
+    std::swap(state_, rhs.state_);
     return *this;
 }
 
 } // namespace engine
 } // namespace vecwise
 } // namespace zilliz
-
-#endif // VECENGINE_STATUS_H_