admin/milvus
1
0
Fork 0
mirror of https://gitee.com/milvus-io/milvus.git synced 2026-01-07 19:31:51 +08:00
Code Issues Packages Projects Releases Wiki Activity

fix(db): fix status compile error

Browse Source 
Former-commit-id: 1d896ef1c7970c9c418683560e760762d828be84
This commit is contained in:
Xu Peng 2019-04-15 13:32:03 +08:00 committed by xj.lin
parent 1bc01da85f
commit 3863f2d3b3
2 changed files with 49 additions and 38 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
cpp/src/db/status.cpp
View File

@ -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

47
cpp/src/db/status.h
View File

@ -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_