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
milvus/internal/core/src/pb/common.pb.h
Zach d3c478f03c
refine index node (#18545) 
Signed-off-by: Zach41 <zongmei.zhang@zilliz.com>
2022-08-09 15:38:50 +08:00

3087 lines
111 KiB
C++
Raw Blame History

// Generated by the protocol buffer compiler. DO NOT EDIT!
// source: common.proto
#ifndef GOOGLE_PROTOBUF_INCLUDED_common_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_common_2eproto
#include <limits>
#include <string>
#include <google/protobuf/port_def.inc>
#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 <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/inlined_string_field.h>
#include <google/protobuf/metadata.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h> // IWYU pragma: export
#include <google/protobuf/extension_set.h> // IWYU pragma: export
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
#include <google/protobuf/descriptor.pb.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_common_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
} // namespace internal
PROTOBUF_NAMESPACE_CLOSE
// Internal implementation detail -- do not use these members.
struct TableStruct_common_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[11]
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_common_2eproto;
namespace milvus {
namespace proto {
namespace common {
class Address;
class AddressDefaultTypeInternal;
extern AddressDefaultTypeInternal _Address_default_instance_;
class Blob;
class BlobDefaultTypeInternal;
extern BlobDefaultTypeInternal _Blob_default_instance_;
class DMLMsgHeader;
class DMLMsgHeaderDefaultTypeInternal;
extern DMLMsgHeaderDefaultTypeInternal _DMLMsgHeader_default_instance_;
class KeyDataPair;
class KeyDataPairDefaultTypeInternal;
extern KeyDataPairDefaultTypeInternal _KeyDataPair_default_instance_;
class KeyValuePair;
class KeyValuePairDefaultTypeInternal;
extern KeyValuePairDefaultTypeInternal _KeyValuePair_default_instance_;
class MsgBase;
class MsgBaseDefaultTypeInternal;
extern MsgBaseDefaultTypeInternal _MsgBase_default_instance_;
class MsgHeader;
class MsgHeaderDefaultTypeInternal;
extern MsgHeaderDefaultTypeInternal _MsgHeader_default_instance_;
class PlaceholderGroup;
class PlaceholderGroupDefaultTypeInternal;
extern PlaceholderGroupDefaultTypeInternal _PlaceholderGroup_default_instance_;
class PlaceholderValue;
class PlaceholderValueDefaultTypeInternal;
extern PlaceholderValueDefaultTypeInternal _PlaceholderValue_default_instance_;
class PrivilegeExt;
class PrivilegeExtDefaultTypeInternal;
extern PrivilegeExtDefaultTypeInternal _PrivilegeExt_default_instance_;
class Status;
class StatusDefaultTypeInternal;
extern StatusDefaultTypeInternal _Status_default_instance_;
} // namespace common
} // namespace proto
} // namespace milvus
PROTOBUF_NAMESPACE_OPEN
template<> ::milvus::proto::common::Address* Arena::CreateMaybeMessage<::milvus::proto::common::Address>(Arena*);
template<> ::milvus::proto::common::Blob* Arena::CreateMaybeMessage<::milvus::proto::common::Blob>(Arena*);
template<> ::milvus::proto::common::DMLMsgHeader* Arena::CreateMaybeMessage<::milvus::proto::common::DMLMsgHeader>(Arena*);
template<> ::milvus::proto::common::KeyDataPair* Arena::CreateMaybeMessage<::milvus::proto::common::KeyDataPair>(Arena*);
template<> ::milvus::proto::common::KeyValuePair* Arena::CreateMaybeMessage<::milvus::proto::common::KeyValuePair>(Arena*);
template<> ::milvus::proto::common::MsgBase* Arena::CreateMaybeMessage<::milvus::proto::common::MsgBase>(Arena*);
template<> ::milvus::proto::common::MsgHeader* Arena::CreateMaybeMessage<::milvus::proto::common::MsgHeader>(Arena*);
template<> ::milvus::proto::common::PlaceholderGroup* Arena::CreateMaybeMessage<::milvus::proto::common::PlaceholderGroup>(Arena*);
template<> ::milvus::proto::common::PlaceholderValue* Arena::CreateMaybeMessage<::milvus::proto::common::PlaceholderValue>(Arena*);
template<> ::milvus::proto::common::PrivilegeExt* Arena::CreateMaybeMessage<::milvus::proto::common::PrivilegeExt>(Arena*);
template<> ::milvus::proto::common::Status* Arena::CreateMaybeMessage<::milvus::proto::common::Status>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace milvus {
namespace proto {
namespace common {
enum ErrorCode : int {
Success = 0,
UnexpectedError = 1,
ConnectFailed = 2,
PermissionDenied = 3,
CollectionNotExists = 4,
IllegalArgument = 5,
IllegalDimension = 7,
IllegalIndexType = 8,
IllegalCollectionName = 9,
IllegalTOPK = 10,
IllegalRowRecord = 11,
IllegalVectorID = 12,
IllegalSearchResult = 13,
FileNotFound = 14,
MetaFailed = 15,
CacheFailed = 16,
CannotCreateFolder = 17,
CannotCreateFile = 18,
CannotDeleteFolder = 19,
CannotDeleteFile = 20,
BuildIndexError = 21,
IllegalNLIST = 22,
IllegalMetricType = 23,
OutOfMemory = 24,
IndexNotExist = 25,
EmptyCollection = 26,
UpdateImportTaskFailure = 27,
CollectionNameNotFound = 28,
CreateCredentialFailure = 29,
UpdateCredentialFailure = 30,
DeleteCredentialFailure = 31,
GetCredentialFailure = 32,
ListCredUsersFailure = 33,
GetUserFailure = 34,
CreateRoleFailure = 35,
DropRoleFailure = 36,
OperateUserRoleFailure = 37,
SelectRoleFailure = 38,
SelectUserFailure = 39,
SelectResourceFailure = 40,
OperatePrivilegeFailure = 41,
SelectGrantFailure = 42,
RefreshPolicyInfoCacheFailure = 43,
ListPolicyFailure = 44,
NotShardLeader = 45,
NoReplicaAvailable = 46,
SegmentNotFound = 47,
DDRequestRace = 1000,
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 = DDRequestRace;
constexpr int ErrorCode_ARRAYSIZE = ErrorCode_MAX + 1;
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ErrorCode_descriptor();
template<typename T>
inline const std::string& ErrorCode_Name(T enum_t_value) {
static_assert(::std::is_same<T, ErrorCode>::value ||
::std::is_integral<T>::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>(
ErrorCode_descriptor(), name, value);
}
enum IndexState : int {
IndexStateNone = 0,
Unissued = 1,
InProgress = 2,
Finished = 3,
Failed = 4,
Abandoned = 5,
IndexState_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
IndexState_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool IndexState_IsValid(int value);
constexpr IndexState IndexState_MIN = IndexStateNone;
constexpr IndexState IndexState_MAX = Abandoned;
constexpr int IndexState_ARRAYSIZE = IndexState_MAX + 1;
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* IndexState_descriptor();
template<typename T>
inline const std::string& IndexState_Name(T enum_t_value) {
static_assert(::std::is_same<T, IndexState>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function IndexState_Name.");
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
IndexState_descriptor(), enum_t_value);
}
inline bool IndexState_Parse(
const std::string& name, IndexState* value) {
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<IndexState>(
IndexState_descriptor(), name, value);
}
enum SegmentState : int {
SegmentStateNone = 0,
NotExist = 1,
Growing = 2,
Sealed = 3,
Flushed = 4,
Flushing = 5,
Dropped = 6,
Importing = 7,
SegmentState_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
SegmentState_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool SegmentState_IsValid(int value);
constexpr SegmentState SegmentState_MIN = SegmentStateNone;
constexpr SegmentState SegmentState_MAX = Importing;
constexpr int SegmentState_ARRAYSIZE = SegmentState_MAX + 1;
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SegmentState_descriptor();
template<typename T>
inline const std::string& SegmentState_Name(T enum_t_value) {
static_assert(::std::is_same<T, SegmentState>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function SegmentState_Name.");
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
SegmentState_descriptor(), enum_t_value);
}
inline bool SegmentState_Parse(
const std::string& name, SegmentState* value) {
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SegmentState>(
SegmentState_descriptor(), name, value);
}
enum PlaceholderType : int {
None = 0,
BinaryVector = 100,
FloatVector = 101,
PlaceholderType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
PlaceholderType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool PlaceholderType_IsValid(int value);
constexpr PlaceholderType PlaceholderType_MIN = None;
constexpr PlaceholderType PlaceholderType_MAX = FloatVector;
constexpr int PlaceholderType_ARRAYSIZE = PlaceholderType_MAX + 1;
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PlaceholderType_descriptor();
template<typename T>
inline const std::string& PlaceholderType_Name(T enum_t_value) {
static_assert(::std::is_same<T, PlaceholderType>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function PlaceholderType_Name.");
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
PlaceholderType_descriptor(), enum_t_value);
}
inline bool PlaceholderType_Parse(
const std::string& name, PlaceholderType* value) {
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<PlaceholderType>(
PlaceholderType_descriptor(), name, value);
}
enum MsgType : int {
Undefined = 0,
CreateCollection = 100,
DropCollection = 101,
HasCollection = 102,
DescribeCollection = 103,
ShowCollections = 104,
GetSystemConfigs = 105,
LoadCollection = 106,
ReleaseCollection = 107,
CreateAlias = 108,
DropAlias = 109,
AlterAlias = 110,
CreatePartition = 200,
DropPartition = 201,
HasPartition = 202,
DescribePartition = 203,
ShowPartitions = 204,
LoadPartitions = 205,
ReleasePartitions = 206,
ShowSegments = 250,
DescribeSegment = 251,
LoadSegments = 252,
ReleaseSegments = 253,
HandoffSegments = 254,
LoadBalanceSegments = 255,
DescribeSegments = 256,
CreateIndex = 300,
DescribeIndex = 301,
DropIndex = 302,
Insert = 400,
Delete = 401,
Flush = 402,
ResendSegmentStats = 403,
Search = 500,
SearchResult = 501,
GetIndexState = 502,
GetIndexBuildProgress = 503,
GetCollectionStatistics = 504,
GetPartitionStatistics = 505,
Retrieve = 506,
RetrieveResult = 507,
WatchDmChannels = 508,
RemoveDmChannels = 509,
WatchQueryChannels = 510,
RemoveQueryChannels = 511,
SealedSegmentsChangeInfo = 512,
WatchDeltaChannels = 513,
GetShardLeaders = 514,
GetReplicas = 515,
SegmentInfo = 600,
SystemInfo = 601,
GetRecoveryInfo = 602,
GetSegmentState = 603,
TimeTick = 1200,
QueryNodeStats = 1201,
LoadIndex = 1202,
RequestID = 1203,
RequestTSO = 1204,
AllocateSegment = 1205,
SegmentStatistics = 1206,
SegmentFlushDone = 1207,
DataNodeTt = 1208,
CreateCredential = 1500,
GetCredential = 1501,
DeleteCredential = 1502,
UpdateCredential = 1503,
ListCredUsernames = 1504,
CreateRole = 1600,
DropRole = 1601,
OperateUserRole = 1602,
SelectRole = 1603,
SelectUser = 1604,
SelectResource = 1605,
OperatePrivilege = 1606,
SelectGrant = 1607,
RefreshPolicyInfoCache = 1608,
ListPolicy = 1609,
MsgType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
MsgType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool MsgType_IsValid(int value);
constexpr MsgType MsgType_MIN = Undefined;
constexpr MsgType MsgType_MAX = ListPolicy;
constexpr int MsgType_ARRAYSIZE = MsgType_MAX + 1;
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* MsgType_descriptor();
template<typename T>
inline const std::string& MsgType_Name(T enum_t_value) {
static_assert(::std::is_same<T, MsgType>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function MsgType_Name.");
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
MsgType_descriptor(), enum_t_value);
}
inline bool MsgType_Parse(
const std::string& name, MsgType* value) {
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<MsgType>(
MsgType_descriptor(), name, value);
}
enum DslType : int {
Dsl = 0,
BoolExprV1 = 1,
DslType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
DslType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool DslType_IsValid(int value);
constexpr DslType DslType_MIN = Dsl;
constexpr DslType DslType_MAX = BoolExprV1;
constexpr int DslType_ARRAYSIZE = DslType_MAX + 1;
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DslType_descriptor();
template<typename T>
inline const std::string& DslType_Name(T enum_t_value) {
static_assert(::std::is_same<T, DslType>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function DslType_Name.");
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
DslType_descriptor(), enum_t_value);
}
inline bool DslType_Parse(
const std::string& name, DslType* value) {
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DslType>(
DslType_descriptor(), name, value);
}
enum CompactionState : int {
UndefiedState = 0,
Executing = 1,
Completed = 2,
CompactionState_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
CompactionState_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool CompactionState_IsValid(int value);
constexpr CompactionState CompactionState_MIN = UndefiedState;
constexpr CompactionState CompactionState_MAX = Completed;
constexpr int CompactionState_ARRAYSIZE = CompactionState_MAX + 1;
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* CompactionState_descriptor();
template<typename T>
inline const std::string& CompactionState_Name(T enum_t_value) {
static_assert(::std::is_same<T, CompactionState>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function CompactionState_Name.");
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
CompactionState_descriptor(), enum_t_value);
}
inline bool CompactionState_Parse(
const std::string& name, CompactionState* value) {
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<CompactionState>(
CompactionState_descriptor(), name, value);
}
enum ConsistencyLevel : int {
Strong = 0,
Session = 1,
Bounded = 2,
Eventually = 3,
Customized = 4,
ConsistencyLevel_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
ConsistencyLevel_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool ConsistencyLevel_IsValid(int value);
constexpr ConsistencyLevel ConsistencyLevel_MIN = Strong;
constexpr ConsistencyLevel ConsistencyLevel_MAX = Customized;
constexpr int ConsistencyLevel_ARRAYSIZE = ConsistencyLevel_MAX + 1;
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ConsistencyLevel_descriptor();
template<typename T>
inline const std::string& ConsistencyLevel_Name(T enum_t_value) {
static_assert(::std::is_same<T, ConsistencyLevel>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function ConsistencyLevel_Name.");
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
ConsistencyLevel_descriptor(), enum_t_value);
}
inline bool ConsistencyLevel_Parse(
const std::string& name, ConsistencyLevel* value) {
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ConsistencyLevel>(
ConsistencyLevel_descriptor(), name, value);
}
enum ImportState : int {
ImportPending = 0,
ImportFailed = 1,
ImportStarted = 2,
ImportDownloaded = 3,
ImportParsed = 4,
ImportPersisted = 5,
ImportCompleted = 6,
ImportAllocSegment = 10,
ImportState_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
ImportState_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool ImportState_IsValid(int value);
constexpr ImportState ImportState_MIN = ImportPending;
constexpr ImportState ImportState_MAX = ImportAllocSegment;
constexpr int ImportState_ARRAYSIZE = ImportState_MAX + 1;
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ImportState_descriptor();
template<typename T>
inline const std::string& ImportState_Name(T enum_t_value) {
static_assert(::std::is_same<T, ImportState>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function ImportState_Name.");
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
ImportState_descriptor(), enum_t_value);
}
inline bool ImportState_Parse(
const std::string& name, ImportState* value) {
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ImportState>(
ImportState_descriptor(), name, value);
}
enum ResourceType : int {
Collection = 0,
ResourceType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
ResourceType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool ResourceType_IsValid(int value);
constexpr ResourceType ResourceType_MIN = Collection;
constexpr ResourceType ResourceType_MAX = Collection;
constexpr int ResourceType_ARRAYSIZE = ResourceType_MAX + 1;
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ResourceType_descriptor();
template<typename T>
inline const std::string& ResourceType_Name(T enum_t_value) {
static_assert(::std::is_same<T, ResourceType>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function ResourceType_Name.");
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
ResourceType_descriptor(), enum_t_value);
}
inline bool ResourceType_Parse(
const std::string& name, ResourceType* value) {
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ResourceType>(
ResourceType_descriptor(), name, value);
}
enum ResourcePrivilege : int {
PrivilegeAll = 0,
PrivilegeCreate = 1,
PrivilegeDrop = 2,
PrivilegeAlter = 3,
PrivilegeRead = 4,
PrivilegeLoad = 5,
PrivilegeRelease = 6,
PrivilegeCompact = 7,
PrivilegeInsert = 8,
PrivilegeDelete = 9,
ResourcePrivilege_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
ResourcePrivilege_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool ResourcePrivilege_IsValid(int value);
constexpr ResourcePrivilege ResourcePrivilege_MIN = PrivilegeAll;
constexpr ResourcePrivilege ResourcePrivilege_MAX = PrivilegeDelete;
constexpr int ResourcePrivilege_ARRAYSIZE = ResourcePrivilege_MAX + 1;
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ResourcePrivilege_descriptor();
template<typename T>
inline const std::string& ResourcePrivilege_Name(T enum_t_value) {
static_assert(::std::is_same<T, ResourcePrivilege>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function ResourcePrivilege_Name.");
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
ResourcePrivilege_descriptor(), enum_t_value);
}
inline bool ResourcePrivilege_Parse(
const std::string& name, ResourcePrivilege* value) {
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ResourcePrivilege>(
ResourcePrivilege_descriptor(), name, value);
}
// ===================================================================
class Status :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.common.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<const Status*>(
&_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<Status>(nullptr);
}
Status* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
return CreateMaybeMessage<Status>(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 "milvus.proto.common.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_common_2eproto);
return ::descriptor_table_common_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);
// .milvus.proto.common.ErrorCode error_code = 1;
void clear_error_code();
::milvus::proto::common::ErrorCode error_code() const;
void set_error_code(::milvus::proto::common::ErrorCode value);
// @@protoc_insertion_point(class_scope:milvus.proto.common.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_common_2eproto;
};
// -------------------------------------------------------------------
class KeyValuePair :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.common.KeyValuePair) */ {
public:
KeyValuePair();
virtual ~KeyValuePair();
KeyValuePair(const KeyValuePair& from);
KeyValuePair(KeyValuePair&& from) noexcept
: KeyValuePair() {
*this = ::std::move(from);
}
inline KeyValuePair& operator=(const KeyValuePair& from) {
CopyFrom(from);
return *this;
}
inline KeyValuePair& operator=(KeyValuePair&& 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 KeyValuePair& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const KeyValuePair* internal_default_instance() {
return reinterpret_cast<const KeyValuePair*>(
&_KeyValuePair_default_instance_);
}
static constexpr int kIndexInFileMessages =
1;
friend void swap(KeyValuePair& a, KeyValuePair& b) {
a.Swap(&b);
}
inline void Swap(KeyValuePair* other) {
if (other == this) return;
InternalSwap(other);
}
// implements Message ----------------------------------------------
inline KeyValuePair* New() const final {
return CreateMaybeMessage<KeyValuePair>(nullptr);
}
KeyValuePair* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
return CreateMaybeMessage<KeyValuePair>(arena);
}
void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void CopyFrom(const KeyValuePair& from);
void MergeFrom(const KeyValuePair& 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(KeyValuePair* other);
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "milvus.proto.common.KeyValuePair";
}
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_common_2eproto);
return ::descriptor_table_common_2eproto.file_level_metadata[kIndexInFileMessages];
}
public:
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kKeyFieldNumber = 1,
kValueFieldNumber = 2,
};
// string key = 1;
void clear_key();
const std::string& key() const;
void set_key(const std::string& value);
void set_key(std::string&& value);
void set_key(const char* value);
void set_key(const char* value, size_t size);
std::string* mutable_key();
std::string* release_key();
void set_allocated_key(std::string* key);
// string value = 2;
void clear_value();
const std::string& value() const;
void set_value(const std::string& value);
void set_value(std::string&& value);
void set_value(const char* value);
void set_value(const char* value, size_t size);
std::string* mutable_value();
std::string* release_value();
void set_allocated_value(std::string* value);
// @@protoc_insertion_point(class_scope:milvus.proto.common.KeyValuePair)
private:
class _Internal;
::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
friend struct ::TableStruct_common_2eproto;
};
// -------------------------------------------------------------------
class KeyDataPair :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.common.KeyDataPair) */ {
public:
KeyDataPair();
virtual ~KeyDataPair();
KeyDataPair(const KeyDataPair& from);
KeyDataPair(KeyDataPair&& from) noexcept
: KeyDataPair() {
*this = ::std::move(from);
}
inline KeyDataPair& operator=(const KeyDataPair& from) {
CopyFrom(from);
return *this;
}
inline KeyDataPair& operator=(KeyDataPair&& 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 KeyDataPair& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const KeyDataPair* internal_default_instance() {
return reinterpret_cast<const KeyDataPair*>(
&_KeyDataPair_default_instance_);
}
static constexpr int kIndexInFileMessages =
2;
friend void swap(KeyDataPair& a, KeyDataPair& b) {
a.Swap(&b);
}
inline void Swap(KeyDataPair* other) {
if (other == this) return;
InternalSwap(other);
}
// implements Message ----------------------------------------------
inline KeyDataPair* New() const final {
return CreateMaybeMessage<KeyDataPair>(nullptr);
}
KeyDataPair* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
return CreateMaybeMessage<KeyDataPair>(arena);
}
void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void CopyFrom(const KeyDataPair& from);
void MergeFrom(const KeyDataPair& 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(KeyDataPair* other);
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "milvus.proto.common.KeyDataPair";
}
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_common_2eproto);
return ::descriptor_table_common_2eproto.file_level_metadata[kIndexInFileMessages];
}
public:
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kKeyFieldNumber = 1,
kDataFieldNumber = 2,
};
// string key = 1;
void clear_key();
const std::string& key() const;
void set_key(const std::string& value);
void set_key(std::string&& value);
void set_key(const char* value);
void set_key(const char* value, size_t size);
std::string* mutable_key();
std::string* release_key();
void set_allocated_key(std::string* key);
// bytes data = 2;
void clear_data();
const std::string& data() const;
void set_data(const std::string& value);
void set_data(std::string&& value);
void set_data(const char* value);
void set_data(const void* value, size_t size);
std::string* mutable_data();
std::string* release_data();
void set_allocated_data(std::string* data);
// @@protoc_insertion_point(class_scope:milvus.proto.common.KeyDataPair)
private:
class _Internal;
::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr data_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
friend struct ::TableStruct_common_2eproto;
};
// -------------------------------------------------------------------
class Blob :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.common.Blob) */ {
public:
Blob();
virtual ~Blob();
Blob(const Blob& from);
Blob(Blob&& from) noexcept
: Blob() {
*this = ::std::move(from);
}
inline Blob& operator=(const Blob& from) {
CopyFrom(from);
return *this;
}
inline Blob& operator=(Blob&& 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 Blob& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const Blob* internal_default_instance() {
return reinterpret_cast<const Blob*>(
&_Blob_default_instance_);
}
static constexpr int kIndexInFileMessages =
3;
friend void swap(Blob& a, Blob& b) {
a.Swap(&b);
}
inline void Swap(Blob* other) {
if (other == this) return;
InternalSwap(other);
}
// implements Message ----------------------------------------------
inline Blob* New() const final {
return CreateMaybeMessage<Blob>(nullptr);
}
Blob* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
return CreateMaybeMessage<Blob>(arena);
}
void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void CopyFrom(const Blob& from);
void MergeFrom(const Blob& 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(Blob* other);
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "milvus.proto.common.Blob";
}
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_common_2eproto);
return ::descriptor_table_common_2eproto.file_level_metadata[kIndexInFileMessages];
}
public:
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kValueFieldNumber = 1,
};
// bytes value = 1;
void clear_value();
const std::string& value() const;
void set_value(const std::string& value);
void set_value(std::string&& value);
void set_value(const char* value);
void set_value(const void* value, size_t size);
std::string* mutable_value();
std::string* release_value();
void set_allocated_value(std::string* value);
// @@protoc_insertion_point(class_scope:milvus.proto.common.Blob)
private:
class _Internal;
::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
friend struct ::TableStruct_common_2eproto;
};
// -------------------------------------------------------------------
class PlaceholderValue :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.common.PlaceholderValue) */ {
public:
PlaceholderValue();
virtual ~PlaceholderValue();
PlaceholderValue(const PlaceholderValue& from);
PlaceholderValue(PlaceholderValue&& from) noexcept
: PlaceholderValue() {
*this = ::std::move(from);
}
inline PlaceholderValue& operator=(const PlaceholderValue& from) {
CopyFrom(from);
return *this;
}
inline PlaceholderValue& operator=(PlaceholderValue&& 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 PlaceholderValue& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const PlaceholderValue* internal_default_instance() {
return reinterpret_cast<const PlaceholderValue*>(
&_PlaceholderValue_default_instance_);
}
static constexpr int kIndexInFileMessages =
4;
friend void swap(PlaceholderValue& a, PlaceholderValue& b) {
a.Swap(&b);
}
inline void Swap(PlaceholderValue* other) {
if (other == this) return;
InternalSwap(other);
}
// implements Message ----------------------------------------------
inline PlaceholderValue* New() const final {
return CreateMaybeMessage<PlaceholderValue>(nullptr);
}
PlaceholderValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
return CreateMaybeMessage<PlaceholderValue>(arena);
}
void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void CopyFrom(const PlaceholderValue& from);
void MergeFrom(const PlaceholderValue& 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(PlaceholderValue* other);
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "milvus.proto.common.PlaceholderValue";
}
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_common_2eproto);
return ::descriptor_table_common_2eproto.file_level_metadata[kIndexInFileMessages];
}
public:
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kValuesFieldNumber = 3,
kTagFieldNumber = 1,
kTypeFieldNumber = 2,
};
// repeated bytes values = 3;
int values_size() const;
void clear_values();
const std::string& values(int index) const;
std::string* mutable_values(int index);
void set_values(int index, const std::string& value);
void set_values(int index, std::string&& value);
void set_values(int index, const char* value);
void set_values(int index, const void* value, size_t size);
std::string* add_values();
void add_values(const std::string& value);
void add_values(std::string&& value);
void add_values(const char* value);
void add_values(const void* value, size_t size);
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& values() const;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_values();
// string tag = 1;
void clear_tag();
const std::string& tag() const;
void set_tag(const std::string& value);
void set_tag(std::string&& value);
void set_tag(const char* value);
void set_tag(const char* value, size_t size);
std::string* mutable_tag();
std::string* release_tag();
void set_allocated_tag(std::string* tag);
// .milvus.proto.common.PlaceholderType type = 2;
void clear_type();
::milvus::proto::common::PlaceholderType type() const;
void set_type(::milvus::proto::common::PlaceholderType value);
// @@protoc_insertion_point(class_scope:milvus.proto.common.PlaceholderValue)
private:
class _Internal;
::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> values_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr tag_;
int type_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
friend struct ::TableStruct_common_2eproto;
};
// -------------------------------------------------------------------
class PlaceholderGroup :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.common.PlaceholderGroup) */ {
public:
PlaceholderGroup();
virtual ~PlaceholderGroup();
PlaceholderGroup(const PlaceholderGroup& from);
PlaceholderGroup(PlaceholderGroup&& from) noexcept
: PlaceholderGroup() {
*this = ::std::move(from);
}
inline PlaceholderGroup& operator=(const PlaceholderGroup& from) {
CopyFrom(from);
return *this;
}
inline PlaceholderGroup& operator=(PlaceholderGroup&& 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 PlaceholderGroup& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const PlaceholderGroup* internal_default_instance() {
return reinterpret_cast<const PlaceholderGroup*>(
&_PlaceholderGroup_default_instance_);
}
static constexpr int kIndexInFileMessages =
5;
friend void swap(PlaceholderGroup& a, PlaceholderGroup& b) {
a.Swap(&b);
}
inline void Swap(PlaceholderGroup* other) {
if (other == this) return;
InternalSwap(other);
}
// implements Message ----------------------------------------------
inline PlaceholderGroup* New() const final {
return CreateMaybeMessage<PlaceholderGroup>(nullptr);
}
PlaceholderGroup* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
return CreateMaybeMessage<PlaceholderGroup>(arena);
}
void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void CopyFrom(const PlaceholderGroup& from);
void MergeFrom(const PlaceholderGroup& 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(PlaceholderGroup* other);
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "milvus.proto.common.PlaceholderGroup";
}
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_common_2eproto);
return ::descriptor_table_common_2eproto.file_level_metadata[kIndexInFileMessages];
}
public:
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kPlaceholdersFieldNumber = 1,
};
// repeated .milvus.proto.common.PlaceholderValue placeholders = 1;
int placeholders_size() const;
void clear_placeholders();
::milvus::proto::common::PlaceholderValue* mutable_placeholders(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::common::PlaceholderValue >*
mutable_placeholders();
const ::milvus::proto::common::PlaceholderValue& placeholders(int index) const;
::milvus::proto::common::PlaceholderValue* add_placeholders();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::common::PlaceholderValue >&
placeholders() const;
// @@protoc_insertion_point(class_scope:milvus.proto.common.PlaceholderGroup)
private:
class _Internal;
::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::common::PlaceholderValue > placeholders_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
friend struct ::TableStruct_common_2eproto;
};
// -------------------------------------------------------------------
class Address :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.common.Address) */ {
public:
Address();
virtual ~Address();
Address(const Address& from);
Address(Address&& from) noexcept
: Address() {
*this = ::std::move(from);
}
inline Address& operator=(const Address& from) {
CopyFrom(from);
return *this;
}
inline Address& operator=(Address&& 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 Address& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const Address* internal_default_instance() {
return reinterpret_cast<const Address*>(
&_Address_default_instance_);
}
static constexpr int kIndexInFileMessages =
6;
friend void swap(Address& a, Address& b) {
a.Swap(&b);
}
inline void Swap(Address* other) {
if (other == this) return;
InternalSwap(other);
}
// implements Message ----------------------------------------------
inline Address* New() const final {
return CreateMaybeMessage<Address>(nullptr);
}
Address* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
return CreateMaybeMessage<Address>(arena);
}
void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void CopyFrom(const Address& from);
void MergeFrom(const Address& 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(Address* other);
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "milvus.proto.common.Address";
}
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_common_2eproto);
return ::descriptor_table_common_2eproto.file_level_metadata[kIndexInFileMessages];
}
public:
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kIpFieldNumber = 1,
kPortFieldNumber = 2,
};
// string ip = 1;
void clear_ip();
const std::string& ip() const;
void set_ip(const std::string& value);
void set_ip(std::string&& value);
void set_ip(const char* value);
void set_ip(const char* value, size_t size);
std::string* mutable_ip();
std::string* release_ip();
void set_allocated_ip(std::string* ip);
// int64 port = 2;
void clear_port();
::PROTOBUF_NAMESPACE_ID::int64 port() const;
void set_port(::PROTOBUF_NAMESPACE_ID::int64 value);
// @@protoc_insertion_point(class_scope:milvus.proto.common.Address)
private:
class _Internal;
::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr ip_;
::PROTOBUF_NAMESPACE_ID::int64 port_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
friend struct ::TableStruct_common_2eproto;
};
// -------------------------------------------------------------------
class MsgBase :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.common.MsgBase) */ {
public:
MsgBase();
virtual ~MsgBase();
MsgBase(const MsgBase& from);
MsgBase(MsgBase&& from) noexcept
: MsgBase() {
*this = ::std::move(from);
}
inline MsgBase& operator=(const MsgBase& from) {
CopyFrom(from);
return *this;
}
inline MsgBase& operator=(MsgBase&& 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 MsgBase& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const MsgBase* internal_default_instance() {
return reinterpret_cast<const MsgBase*>(
&_MsgBase_default_instance_);
}
static constexpr int kIndexInFileMessages =
7;
friend void swap(MsgBase& a, MsgBase& b) {
a.Swap(&b);
}
inline void Swap(MsgBase* other) {
if (other == this) return;
InternalSwap(other);
}
// implements Message ----------------------------------------------
inline MsgBase* New() const final {
return CreateMaybeMessage<MsgBase>(nullptr);
}
MsgBase* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
return CreateMaybeMessage<MsgBase>(arena);
}
void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void CopyFrom(const MsgBase& from);
void MergeFrom(const MsgBase& 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(MsgBase* other);
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "milvus.proto.common.MsgBase";
}
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_common_2eproto);
return ::descriptor_table_common_2eproto.file_level_metadata[kIndexInFileMessages];
}
public:
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kMsgIDFieldNumber = 2,
kTimestampFieldNumber = 3,
kSourceIDFieldNumber = 4,
kMsgTypeFieldNumber = 1,
};
// int64 msgID = 2;
void clear_msgid();
::PROTOBUF_NAMESPACE_ID::int64 msgid() const;
void set_msgid(::PROTOBUF_NAMESPACE_ID::int64 value);
// uint64 timestamp = 3;
void clear_timestamp();
::PROTOBUF_NAMESPACE_ID::uint64 timestamp() const;
void set_timestamp(::PROTOBUF_NAMESPACE_ID::uint64 value);
// int64 sourceID = 4;
void clear_sourceid();
::PROTOBUF_NAMESPACE_ID::int64 sourceid() const;
void set_sourceid(::PROTOBUF_NAMESPACE_ID::int64 value);
// .milvus.proto.common.MsgType msg_type = 1;
void clear_msg_type();
::milvus::proto::common::MsgType msg_type() const;
void set_msg_type(::milvus::proto::common::MsgType value);
// @@protoc_insertion_point(class_scope:milvus.proto.common.MsgBase)
private:
class _Internal;
::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
::PROTOBUF_NAMESPACE_ID::int64 msgid_;
::PROTOBUF_NAMESPACE_ID::uint64 timestamp_;
::PROTOBUF_NAMESPACE_ID::int64 sourceid_;
int msg_type_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
friend struct ::TableStruct_common_2eproto;
};
// -------------------------------------------------------------------
class MsgHeader :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.common.MsgHeader) */ {
public:
MsgHeader();
virtual ~MsgHeader();
MsgHeader(const MsgHeader& from);
MsgHeader(MsgHeader&& from) noexcept
: MsgHeader() {
*this = ::std::move(from);
}
inline MsgHeader& operator=(const MsgHeader& from) {
CopyFrom(from);
return *this;
}
inline MsgHeader& operator=(MsgHeader&& 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 MsgHeader& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const MsgHeader* internal_default_instance() {
return reinterpret_cast<const MsgHeader*>(
&_MsgHeader_default_instance_);
}
static constexpr int kIndexInFileMessages =
8;
friend void swap(MsgHeader& a, MsgHeader& b) {
a.Swap(&b);
}
inline void Swap(MsgHeader* other) {
if (other == this) return;
InternalSwap(other);
}
// implements Message ----------------------------------------------
inline MsgHeader* New() const final {
return CreateMaybeMessage<MsgHeader>(nullptr);
}
MsgHeader* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
return CreateMaybeMessage<MsgHeader>(arena);
}
void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void CopyFrom(const MsgHeader& from);
void MergeFrom(const MsgHeader& 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(MsgHeader* other);
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "milvus.proto.common.MsgHeader";
}
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_common_2eproto);
return ::descriptor_table_common_2eproto.file_level_metadata[kIndexInFileMessages];
}
public:
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kBaseFieldNumber = 1,
};
// .milvus.proto.common.MsgBase base = 1;
bool has_base() const;
void clear_base();
const ::milvus::proto::common::MsgBase& base() const;
::milvus::proto::common::MsgBase* release_base();
::milvus::proto::common::MsgBase* mutable_base();
void set_allocated_base(::milvus::proto::common::MsgBase* base);
// @@protoc_insertion_point(class_scope:milvus.proto.common.MsgHeader)
private:
class _Internal;
::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
::milvus::proto::common::MsgBase* base_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
friend struct ::TableStruct_common_2eproto;
};
// -------------------------------------------------------------------
class DMLMsgHeader :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.common.DMLMsgHeader) */ {
public:
DMLMsgHeader();
virtual ~DMLMsgHeader();
DMLMsgHeader(const DMLMsgHeader& from);
DMLMsgHeader(DMLMsgHeader&& from) noexcept
: DMLMsgHeader() {
*this = ::std::move(from);
}
inline DMLMsgHeader& operator=(const DMLMsgHeader& from) {
CopyFrom(from);
return *this;
}
inline DMLMsgHeader& operator=(DMLMsgHeader&& 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 DMLMsgHeader& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const DMLMsgHeader* internal_default_instance() {
return reinterpret_cast<const DMLMsgHeader*>(
&_DMLMsgHeader_default_instance_);
}
static constexpr int kIndexInFileMessages =
9;
friend void swap(DMLMsgHeader& a, DMLMsgHeader& b) {
a.Swap(&b);
}
inline void Swap(DMLMsgHeader* other) {
if (other == this) return;
InternalSwap(other);
}
// implements Message ----------------------------------------------
inline DMLMsgHeader* New() const final {
return CreateMaybeMessage<DMLMsgHeader>(nullptr);
}
DMLMsgHeader* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
return CreateMaybeMessage<DMLMsgHeader>(arena);
}
void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void CopyFrom(const DMLMsgHeader& from);
void MergeFrom(const DMLMsgHeader& 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(DMLMsgHeader* other);
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "milvus.proto.common.DMLMsgHeader";
}
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_common_2eproto);
return ::descriptor_table_common_2eproto.file_level_metadata[kIndexInFileMessages];
}
public:
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kShardNameFieldNumber = 2,
kBaseFieldNumber = 1,
};
// string shardName = 2;
void clear_shardname();
const std::string& shardname() const;
void set_shardname(const std::string& value);
void set_shardname(std::string&& value);
void set_shardname(const char* value);
void set_shardname(const char* value, size_t size);
std::string* mutable_shardname();
std::string* release_shardname();
void set_allocated_shardname(std::string* shardname);
// .milvus.proto.common.MsgBase base = 1;
bool has_base() const;
void clear_base();
const ::milvus::proto::common::MsgBase& base() const;
::milvus::proto::common::MsgBase* release_base();
::milvus::proto::common::MsgBase* mutable_base();
void set_allocated_base(::milvus::proto::common::MsgBase* base);
// @@protoc_insertion_point(class_scope:milvus.proto.common.DMLMsgHeader)
private:
class _Internal;
::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr shardname_;
::milvus::proto::common::MsgBase* base_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
friend struct ::TableStruct_common_2eproto;
};
// -------------------------------------------------------------------
class PrivilegeExt :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.common.PrivilegeExt) */ {
public:
PrivilegeExt();
virtual ~PrivilegeExt();
PrivilegeExt(const PrivilegeExt& from);
PrivilegeExt(PrivilegeExt&& from) noexcept
: PrivilegeExt() {
*this = ::std::move(from);
}
inline PrivilegeExt& operator=(const PrivilegeExt& from) {
CopyFrom(from);
return *this;
}
inline PrivilegeExt& operator=(PrivilegeExt&& 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 PrivilegeExt& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const PrivilegeExt* internal_default_instance() {
return reinterpret_cast<const PrivilegeExt*>(
&_PrivilegeExt_default_instance_);
}
static constexpr int kIndexInFileMessages =
10;
friend void swap(PrivilegeExt& a, PrivilegeExt& b) {
a.Swap(&b);
}
inline void Swap(PrivilegeExt* other) {
if (other == this) return;
InternalSwap(other);
}
// implements Message ----------------------------------------------
inline PrivilegeExt* New() const final {
return CreateMaybeMessage<PrivilegeExt>(nullptr);
}
PrivilegeExt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
return CreateMaybeMessage<PrivilegeExt>(arena);
}
void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void CopyFrom(const PrivilegeExt& from);
void MergeFrom(const PrivilegeExt& 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(PrivilegeExt* other);
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "milvus.proto.common.PrivilegeExt";
}
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_common_2eproto);
return ::descriptor_table_common_2eproto.file_level_metadata[kIndexInFileMessages];
}
public:
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kResourceTypeFieldNumber = 1,
kResourcePrivilegeFieldNumber = 2,
kResourceNameIndexFieldNumber = 3,
};
// .milvus.proto.common.ResourceType resource_type = 1;
void clear_resource_type();
::milvus::proto::common::ResourceType resource_type() const;
void set_resource_type(::milvus::proto::common::ResourceType value);
// .milvus.proto.common.ResourcePrivilege resource_privilege = 2;
void clear_resource_privilege();
::milvus::proto::common::ResourcePrivilege resource_privilege() const;
void set_resource_privilege(::milvus::proto::common::ResourcePrivilege value);
// int32 resource_name_index = 3;
void clear_resource_name_index();
::PROTOBUF_NAMESPACE_ID::int32 resource_name_index() const;
void set_resource_name_index(::PROTOBUF_NAMESPACE_ID::int32 value);
// @@protoc_insertion_point(class_scope:milvus.proto.common.PrivilegeExt)
private:
class _Internal;
::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
int resource_type_;
int resource_privilege_;
::PROTOBUF_NAMESPACE_ID::int32 resource_name_index_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
friend struct ::TableStruct_common_2eproto;
};
// ===================================================================
static const int kPrivilegeExtObjFieldNumber = 1001;
extern ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier< ::google::protobuf::MessageOptions,
::PROTOBUF_NAMESPACE_ID::internal::MessageTypeTraits< ::milvus::proto::common::PrivilegeExt >, 11, false >
privilege_ext_obj;
// ===================================================================
#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif // __GNUC__
// Status
// .milvus.proto.common.ErrorCode error_code = 1;
inline void Status::clear_error_code() {
error_code_ = 0;
}
inline ::milvus::proto::common::ErrorCode Status::error_code() const {
// @@protoc_insertion_point(field_get:milvus.proto.common.Status.error_code)
return static_cast< ::milvus::proto::common::ErrorCode >(error_code_);
}
inline void Status::set_error_code(::milvus::proto::common::ErrorCode value) {
error_code_ = value;
// @@protoc_insertion_point(field_set:milvus.proto.common.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:milvus.proto.common.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:milvus.proto.common.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:milvus.proto.common.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:milvus.proto.common.Status.reason)
}
inline void Status::set_reason(const char* value, size_t size) {
reason_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
::std::string(reinterpret_cast<const char*>(value), size));
// @@protoc_insertion_point(field_set_pointer:milvus.proto.common.Status.reason)
}
inline std::string* Status::mutable_reason() {
// @@protoc_insertion_point(field_mutable:milvus.proto.common.Status.reason)
return reason_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* Status::release_reason() {
// @@protoc_insertion_point(field_release:milvus.proto.common.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:milvus.proto.common.Status.reason)
}
// -------------------------------------------------------------------
// KeyValuePair
// string key = 1;
inline void KeyValuePair::clear_key() {
key_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& KeyValuePair::key() const {
// @@protoc_insertion_point(field_get:milvus.proto.common.KeyValuePair.key)
return key_.GetNoArena();
}
inline void KeyValuePair::set_key(const std::string& value) {
key_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
// @@protoc_insertion_point(field_set:milvus.proto.common.KeyValuePair.key)
}
inline void KeyValuePair::set_key(std::string&& value) {
key_.SetNoArena(
&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
// @@protoc_insertion_point(field_set_rvalue:milvus.proto.common.KeyValuePair.key)
}
inline void KeyValuePair::set_key(const char* value) {
GOOGLE_DCHECK(value != nullptr);
key_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
// @@protoc_insertion_point(field_set_char:milvus.proto.common.KeyValuePair.key)
}
inline void KeyValuePair::set_key(const char* value, size_t size) {
key_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
::std::string(reinterpret_cast<const char*>(value), size));
// @@protoc_insertion_point(field_set_pointer:milvus.proto.common.KeyValuePair.key)
}
inline std::string* KeyValuePair::mutable_key() {
// @@protoc_insertion_point(field_mutable:milvus.proto.common.KeyValuePair.key)
return key_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* KeyValuePair::release_key() {
// @@protoc_insertion_point(field_release:milvus.proto.common.KeyValuePair.key)
return key_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void KeyValuePair::set_allocated_key(std::string* key) {
if (key != nullptr) {
} else {
}
key_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), key);
// @@protoc_insertion_point(field_set_allocated:milvus.proto.common.KeyValuePair.key)
}
// string value = 2;
inline void KeyValuePair::clear_value() {
value_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& KeyValuePair::value() const {
// @@protoc_insertion_point(field_get:milvus.proto.common.KeyValuePair.value)
return value_.GetNoArena();
}
inline void KeyValuePair::set_value(const std::string& value) {
value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
// @@protoc_insertion_point(field_set:milvus.proto.common.KeyValuePair.value)
}
inline void KeyValuePair::set_value(std::string&& value) {
value_.SetNoArena(
&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
// @@protoc_insertion_point(field_set_rvalue:milvus.proto.common.KeyValuePair.value)
}
inline void KeyValuePair::set_value(const char* value) {
GOOGLE_DCHECK(value != nullptr);
value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
// @@protoc_insertion_point(field_set_char:milvus.proto.common.KeyValuePair.value)
}
inline void KeyValuePair::set_value(const char* value, size_t size) {
value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
::std::string(reinterpret_cast<const char*>(value), size));
// @@protoc_insertion_point(field_set_pointer:milvus.proto.common.KeyValuePair.value)
}
inline std::string* KeyValuePair::mutable_value() {
// @@protoc_insertion_point(field_mutable:milvus.proto.common.KeyValuePair.value)
return value_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* KeyValuePair::release_value() {
// @@protoc_insertion_point(field_release:milvus.proto.common.KeyValuePair.value)
return value_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void KeyValuePair::set_allocated_value(std::string* value) {
if (value != nullptr) {
} else {
}
value_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
// @@protoc_insertion_point(field_set_allocated:milvus.proto.common.KeyValuePair.value)
}
// -------------------------------------------------------------------
// KeyDataPair
// string key = 1;
inline void KeyDataPair::clear_key() {
key_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& KeyDataPair::key() const {
// @@protoc_insertion_point(field_get:milvus.proto.common.KeyDataPair.key)
return key_.GetNoArena();
}
inline void KeyDataPair::set_key(const std::string& value) {
key_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
// @@protoc_insertion_point(field_set:milvus.proto.common.KeyDataPair.key)
}
inline void KeyDataPair::set_key(std::string&& value) {
key_.SetNoArena(
&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
// @@protoc_insertion_point(field_set_rvalue:milvus.proto.common.KeyDataPair.key)
}
inline void KeyDataPair::set_key(const char* value) {
GOOGLE_DCHECK(value != nullptr);
key_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
// @@protoc_insertion_point(field_set_char:milvus.proto.common.KeyDataPair.key)
}
inline void KeyDataPair::set_key(const char* value, size_t size) {
key_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
::std::string(reinterpret_cast<const char*>(value), size));
// @@protoc_insertion_point(field_set_pointer:milvus.proto.common.KeyDataPair.key)
}
inline std::string* KeyDataPair::mutable_key() {
// @@protoc_insertion_point(field_mutable:milvus.proto.common.KeyDataPair.key)
return key_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* KeyDataPair::release_key() {
// @@protoc_insertion_point(field_release:milvus.proto.common.KeyDataPair.key)
return key_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void KeyDataPair::set_allocated_key(std::string* key) {
if (key != nullptr) {
} else {
}
key_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), key);
// @@protoc_insertion_point(field_set_allocated:milvus.proto.common.KeyDataPair.key)
}
// bytes data = 2;
inline void KeyDataPair::clear_data() {
data_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& KeyDataPair::data() const {
// @@protoc_insertion_point(field_get:milvus.proto.common.KeyDataPair.data)
return data_.GetNoArena();
}
inline void KeyDataPair::set_data(const std::string& value) {
data_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
// @@protoc_insertion_point(field_set:milvus.proto.common.KeyDataPair.data)
}
inline void KeyDataPair::set_data(std::string&& value) {
data_.SetNoArena(
&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
// @@protoc_insertion_point(field_set_rvalue:milvus.proto.common.KeyDataPair.data)
}
inline void KeyDataPair::set_data(const char* value) {
GOOGLE_DCHECK(value != nullptr);
data_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
// @@protoc_insertion_point(field_set_char:milvus.proto.common.KeyDataPair.data)
}
inline void KeyDataPair::set_data(const void* value, size_t size) {
data_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
::std::string(reinterpret_cast<const char*>(value), size));
// @@protoc_insertion_point(field_set_pointer:milvus.proto.common.KeyDataPair.data)
}
inline std::string* KeyDataPair::mutable_data() {
// @@protoc_insertion_point(field_mutable:milvus.proto.common.KeyDataPair.data)
return data_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* KeyDataPair::release_data() {
// @@protoc_insertion_point(field_release:milvus.proto.common.KeyDataPair.data)
return data_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void KeyDataPair::set_allocated_data(std::string* data) {
if (data != nullptr) {
} else {
}
data_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), data);
// @@protoc_insertion_point(field_set_allocated:milvus.proto.common.KeyDataPair.data)
}
// -------------------------------------------------------------------
// Blob
// bytes value = 1;
inline void Blob::clear_value() {
value_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& Blob::value() const {
// @@protoc_insertion_point(field_get:milvus.proto.common.Blob.value)
return value_.GetNoArena();
}
inline void Blob::set_value(const std::string& value) {
value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
// @@protoc_insertion_point(field_set:milvus.proto.common.Blob.value)
}
inline void Blob::set_value(std::string&& value) {
value_.SetNoArena(
&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
// @@protoc_insertion_point(field_set_rvalue:milvus.proto.common.Blob.value)
}
inline void Blob::set_value(const char* value) {
GOOGLE_DCHECK(value != nullptr);
value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
// @@protoc_insertion_point(field_set_char:milvus.proto.common.Blob.value)
}
inline void Blob::set_value(const void* value, size_t size) {
value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
::std::string(reinterpret_cast<const char*>(value), size));
// @@protoc_insertion_point(field_set_pointer:milvus.proto.common.Blob.value)
}
inline std::string* Blob::mutable_value() {
// @@protoc_insertion_point(field_mutable:milvus.proto.common.Blob.value)
return value_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* Blob::release_value() {
// @@protoc_insertion_point(field_release:milvus.proto.common.Blob.value)
return value_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void Blob::set_allocated_value(std::string* value) {
if (value != nullptr) {
} else {
}
value_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
// @@protoc_insertion_point(field_set_allocated:milvus.proto.common.Blob.value)
}
// -------------------------------------------------------------------
// PlaceholderValue
// string tag = 1;
inline void PlaceholderValue::clear_tag() {
tag_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& PlaceholderValue::tag() const {
// @@protoc_insertion_point(field_get:milvus.proto.common.PlaceholderValue.tag)
return tag_.GetNoArena();
}
inline void PlaceholderValue::set_tag(const std::string& value) {
tag_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
// @@protoc_insertion_point(field_set:milvus.proto.common.PlaceholderValue.tag)
}
inline void PlaceholderValue::set_tag(std::string&& value) {
tag_.SetNoArena(
&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
// @@protoc_insertion_point(field_set_rvalue:milvus.proto.common.PlaceholderValue.tag)
}
inline void PlaceholderValue::set_tag(const char* value) {
GOOGLE_DCHECK(value != nullptr);
tag_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
// @@protoc_insertion_point(field_set_char:milvus.proto.common.PlaceholderValue.tag)
}
inline void PlaceholderValue::set_tag(const char* value, size_t size) {
tag_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
::std::string(reinterpret_cast<const char*>(value), size));
// @@protoc_insertion_point(field_set_pointer:milvus.proto.common.PlaceholderValue.tag)
}
inline std::string* PlaceholderValue::mutable_tag() {
// @@protoc_insertion_point(field_mutable:milvus.proto.common.PlaceholderValue.tag)
return tag_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* PlaceholderValue::release_tag() {
// @@protoc_insertion_point(field_release:milvus.proto.common.PlaceholderValue.tag)
return tag_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void PlaceholderValue::set_allocated_tag(std::string* tag) {
if (tag != nullptr) {
} else {
}
tag_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), tag);
// @@protoc_insertion_point(field_set_allocated:milvus.proto.common.PlaceholderValue.tag)
}
// .milvus.proto.common.PlaceholderType type = 2;
inline void PlaceholderValue::clear_type() {
type_ = 0;
}
inline ::milvus::proto::common::PlaceholderType PlaceholderValue::type() const {
// @@protoc_insertion_point(field_get:milvus.proto.common.PlaceholderValue.type)
return static_cast< ::milvus::proto::common::PlaceholderType >(type_);
}
inline void PlaceholderValue::set_type(::milvus::proto::common::PlaceholderType value) {
type_ = value;
// @@protoc_insertion_point(field_set:milvus.proto.common.PlaceholderValue.type)
}
// repeated bytes values = 3;
inline int PlaceholderValue::values_size() const {
return values_.size();
}
inline void PlaceholderValue::clear_values() {
values_.Clear();
}
inline const std::string& PlaceholderValue::values(int index) const {
// @@protoc_insertion_point(field_get:milvus.proto.common.PlaceholderValue.values)
return values_.Get(index);
}
inline std::string* PlaceholderValue::mutable_values(int index) {
// @@protoc_insertion_point(field_mutable:milvus.proto.common.PlaceholderValue.values)
return values_.Mutable(index);
}
inline void PlaceholderValue::set_values(int index, const std::string& value) {
// @@protoc_insertion_point(field_set:milvus.proto.common.PlaceholderValue.values)
values_.Mutable(index)->assign(value);
}
inline void PlaceholderValue::set_values(int index, std::string&& value) {
// @@protoc_insertion_point(field_set:milvus.proto.common.PlaceholderValue.values)
values_.Mutable(index)->assign(std::move(value));
}
inline void PlaceholderValue::set_values(int index, const char* value) {
GOOGLE_DCHECK(value != nullptr);
values_.Mutable(index)->assign(value);
// @@protoc_insertion_point(field_set_char:milvus.proto.common.PlaceholderValue.values)
}
inline void PlaceholderValue::set_values(int index, const void* value, size_t size) {
values_.Mutable(index)->assign(
reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_set_pointer:milvus.proto.common.PlaceholderValue.values)
}
inline std::string* PlaceholderValue::add_values() {
// @@protoc_insertion_point(field_add_mutable:milvus.proto.common.PlaceholderValue.values)
return values_.Add();
}
inline void PlaceholderValue::add_values(const std::string& value) {
values_.Add()->assign(value);
// @@protoc_insertion_point(field_add:milvus.proto.common.PlaceholderValue.values)
}
inline void PlaceholderValue::add_values(std::string&& value) {
values_.Add(std::move(value));
// @@protoc_insertion_point(field_add:milvus.proto.common.PlaceholderValue.values)
}
inline void PlaceholderValue::add_values(const char* value) {
GOOGLE_DCHECK(value != nullptr);
values_.Add()->assign(value);
// @@protoc_insertion_point(field_add_char:milvus.proto.common.PlaceholderValue.values)
}
inline void PlaceholderValue::add_values(const void* value, size_t size) {
values_.Add()->assign(reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_add_pointer:milvus.proto.common.PlaceholderValue.values)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
PlaceholderValue::values() const {
// @@protoc_insertion_point(field_list:milvus.proto.common.PlaceholderValue.values)
return values_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
PlaceholderValue::mutable_values() {
// @@protoc_insertion_point(field_mutable_list:milvus.proto.common.PlaceholderValue.values)
return &values_;
}
// -------------------------------------------------------------------
// PlaceholderGroup
// repeated .milvus.proto.common.PlaceholderValue placeholders = 1;
inline int PlaceholderGroup::placeholders_size() const {
return placeholders_.size();
}
inline void PlaceholderGroup::clear_placeholders() {
placeholders_.Clear();
}
inline ::milvus::proto::common::PlaceholderValue* PlaceholderGroup::mutable_placeholders(int index) {
// @@protoc_insertion_point(field_mutable:milvus.proto.common.PlaceholderGroup.placeholders)
return placeholders_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::common::PlaceholderValue >*
PlaceholderGroup::mutable_placeholders() {
// @@protoc_insertion_point(field_mutable_list:milvus.proto.common.PlaceholderGroup.placeholders)
return &placeholders_;
}
inline const ::milvus::proto::common::PlaceholderValue& PlaceholderGroup::placeholders(int index) const {
// @@protoc_insertion_point(field_get:milvus.proto.common.PlaceholderGroup.placeholders)
return placeholders_.Get(index);
}
inline ::milvus::proto::common::PlaceholderValue* PlaceholderGroup::add_placeholders() {
// @@protoc_insertion_point(field_add:milvus.proto.common.PlaceholderGroup.placeholders)
return placeholders_.Add();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::common::PlaceholderValue >&
PlaceholderGroup::placeholders() const {
// @@protoc_insertion_point(field_list:milvus.proto.common.PlaceholderGroup.placeholders)
return placeholders_;
}
// -------------------------------------------------------------------
// Address
// string ip = 1;
inline void Address::clear_ip() {
ip_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& Address::ip() const {
// @@protoc_insertion_point(field_get:milvus.proto.common.Address.ip)
return ip_.GetNoArena();
}
inline void Address::set_ip(const std::string& value) {
ip_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
// @@protoc_insertion_point(field_set:milvus.proto.common.Address.ip)
}
inline void Address::set_ip(std::string&& value) {
ip_.SetNoArena(
&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
// @@protoc_insertion_point(field_set_rvalue:milvus.proto.common.Address.ip)
}
inline void Address::set_ip(const char* value) {
GOOGLE_DCHECK(value != nullptr);
ip_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
// @@protoc_insertion_point(field_set_char:milvus.proto.common.Address.ip)
}
inline void Address::set_ip(const char* value, size_t size) {
ip_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
::std::string(reinterpret_cast<const char*>(value), size));
// @@protoc_insertion_point(field_set_pointer:milvus.proto.common.Address.ip)
}
inline std::string* Address::mutable_ip() {
// @@protoc_insertion_point(field_mutable:milvus.proto.common.Address.ip)
return ip_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* Address::release_ip() {
// @@protoc_insertion_point(field_release:milvus.proto.common.Address.ip)
return ip_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void Address::set_allocated_ip(std::string* ip) {
if (ip != nullptr) {
} else {
}
ip_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ip);
// @@protoc_insertion_point(field_set_allocated:milvus.proto.common.Address.ip)
}
// int64 port = 2;
inline void Address::clear_port() {
port_ = PROTOBUF_LONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::int64 Address::port() const {
// @@protoc_insertion_point(field_get:milvus.proto.common.Address.port)
return port_;
}
inline void Address::set_port(::PROTOBUF_NAMESPACE_ID::int64 value) {
port_ = value;
// @@protoc_insertion_point(field_set:milvus.proto.common.Address.port)
}
// -------------------------------------------------------------------
// MsgBase
// .milvus.proto.common.MsgType msg_type = 1;
inline void MsgBase::clear_msg_type() {
msg_type_ = 0;
}
inline ::milvus::proto::common::MsgType MsgBase::msg_type() const {
// @@protoc_insertion_point(field_get:milvus.proto.common.MsgBase.msg_type)
return static_cast< ::milvus::proto::common::MsgType >(msg_type_);
}
inline void MsgBase::set_msg_type(::milvus::proto::common::MsgType value) {
msg_type_ = value;
// @@protoc_insertion_point(field_set:milvus.proto.common.MsgBase.msg_type)
}
// int64 msgID = 2;
inline void MsgBase::clear_msgid() {
msgid_ = PROTOBUF_LONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::int64 MsgBase::msgid() const {
// @@protoc_insertion_point(field_get:milvus.proto.common.MsgBase.msgID)
return msgid_;
}
inline void MsgBase::set_msgid(::PROTOBUF_NAMESPACE_ID::int64 value) {
msgid_ = value;
// @@protoc_insertion_point(field_set:milvus.proto.common.MsgBase.msgID)
}
// uint64 timestamp = 3;
inline void MsgBase::clear_timestamp() {
timestamp_ = PROTOBUF_ULONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 MsgBase::timestamp() const {
// @@protoc_insertion_point(field_get:milvus.proto.common.MsgBase.timestamp)
return timestamp_;
}
inline void MsgBase::set_timestamp(::PROTOBUF_NAMESPACE_ID::uint64 value) {
timestamp_ = value;
// @@protoc_insertion_point(field_set:milvus.proto.common.MsgBase.timestamp)
}
// int64 sourceID = 4;
inline void MsgBase::clear_sourceid() {
sourceid_ = PROTOBUF_LONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::int64 MsgBase::sourceid() const {
// @@protoc_insertion_point(field_get:milvus.proto.common.MsgBase.sourceID)
return sourceid_;
}
inline void MsgBase::set_sourceid(::PROTOBUF_NAMESPACE_ID::int64 value) {
sourceid_ = value;
// @@protoc_insertion_point(field_set:milvus.proto.common.MsgBase.sourceID)
}
// -------------------------------------------------------------------
// MsgHeader
// .milvus.proto.common.MsgBase base = 1;
inline bool MsgHeader::has_base() const {
return this != internal_default_instance() && base_ != nullptr;
}
inline void MsgHeader::clear_base() {
if (GetArenaNoVirtual() == nullptr && base_ != nullptr) {
delete base_;
}
base_ = nullptr;
}
inline const ::milvus::proto::common::MsgBase& MsgHeader::base() const {
const ::milvus::proto::common::MsgBase* p = base_;
// @@protoc_insertion_point(field_get:milvus.proto.common.MsgHeader.base)
return p != nullptr ? *p : *reinterpret_cast<const ::milvus::proto::common::MsgBase*>(
&::milvus::proto::common::_MsgBase_default_instance_);
}
inline ::milvus::proto::common::MsgBase* MsgHeader::release_base() {
// @@protoc_insertion_point(field_release:milvus.proto.common.MsgHeader.base)
::milvus::proto::common::MsgBase* temp = base_;
base_ = nullptr;
return temp;
}
inline ::milvus::proto::common::MsgBase* MsgHeader::mutable_base() {
if (base_ == nullptr) {
auto* p = CreateMaybeMessage<::milvus::proto::common::MsgBase>(GetArenaNoVirtual());
base_ = p;
}
// @@protoc_insertion_point(field_mutable:milvus.proto.common.MsgHeader.base)
return base_;
}
inline void MsgHeader::set_allocated_base(::milvus::proto::common::MsgBase* base) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == nullptr) {
delete base_;
}
if (base) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
if (message_arena != submessage_arena) {
base = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, base, submessage_arena);
}
} else {
}
base_ = base;
// @@protoc_insertion_point(field_set_allocated:milvus.proto.common.MsgHeader.base)
}
// -------------------------------------------------------------------
// DMLMsgHeader
// .milvus.proto.common.MsgBase base = 1;
inline bool DMLMsgHeader::has_base() const {
return this != internal_default_instance() && base_ != nullptr;
}
inline void DMLMsgHeader::clear_base() {
if (GetArenaNoVirtual() == nullptr && base_ != nullptr) {
delete base_;
}
base_ = nullptr;
}
inline const ::milvus::proto::common::MsgBase& DMLMsgHeader::base() const {
const ::milvus::proto::common::MsgBase* p = base_;
// @@protoc_insertion_point(field_get:milvus.proto.common.DMLMsgHeader.base)
return p != nullptr ? *p : *reinterpret_cast<const ::milvus::proto::common::MsgBase*>(
&::milvus::proto::common::_MsgBase_default_instance_);
}
inline ::milvus::proto::common::MsgBase* DMLMsgHeader::release_base() {
// @@protoc_insertion_point(field_release:milvus.proto.common.DMLMsgHeader.base)
::milvus::proto::common::MsgBase* temp = base_;
base_ = nullptr;
return temp;
}
inline ::milvus::proto::common::MsgBase* DMLMsgHeader::mutable_base() {
if (base_ == nullptr) {
auto* p = CreateMaybeMessage<::milvus::proto::common::MsgBase>(GetArenaNoVirtual());
base_ = p;
}
// @@protoc_insertion_point(field_mutable:milvus.proto.common.DMLMsgHeader.base)
return base_;
}
inline void DMLMsgHeader::set_allocated_base(::milvus::proto::common::MsgBase* base) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == nullptr) {
delete base_;
}
if (base) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
if (message_arena != submessage_arena) {
base = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, base, submessage_arena);
}
} else {
}
base_ = base;
// @@protoc_insertion_point(field_set_allocated:milvus.proto.common.DMLMsgHeader.base)
}
// string shardName = 2;
inline void DMLMsgHeader::clear_shardname() {
shardname_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& DMLMsgHeader::shardname() const {
// @@protoc_insertion_point(field_get:milvus.proto.common.DMLMsgHeader.shardName)
return shardname_.GetNoArena();
}
inline void DMLMsgHeader::set_shardname(const std::string& value) {
shardname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
// @@protoc_insertion_point(field_set:milvus.proto.common.DMLMsgHeader.shardName)
}
inline void DMLMsgHeader::set_shardname(std::string&& value) {
shardname_.SetNoArena(
&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
// @@protoc_insertion_point(field_set_rvalue:milvus.proto.common.DMLMsgHeader.shardName)
}
inline void DMLMsgHeader::set_shardname(const char* value) {
GOOGLE_DCHECK(value != nullptr);
shardname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
// @@protoc_insertion_point(field_set_char:milvus.proto.common.DMLMsgHeader.shardName)
}
inline void DMLMsgHeader::set_shardname(const char* value, size_t size) {
shardname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
::std::string(reinterpret_cast<const char*>(value), size));
// @@protoc_insertion_point(field_set_pointer:milvus.proto.common.DMLMsgHeader.shardName)
}
inline std::string* DMLMsgHeader::mutable_shardname() {
// @@protoc_insertion_point(field_mutable:milvus.proto.common.DMLMsgHeader.shardName)
return shardname_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* DMLMsgHeader::release_shardname() {
// @@protoc_insertion_point(field_release:milvus.proto.common.DMLMsgHeader.shardName)
return shardname_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void DMLMsgHeader::set_allocated_shardname(std::string* shardname) {
if (shardname != nullptr) {
} else {
}
shardname_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), shardname);
// @@protoc_insertion_point(field_set_allocated:milvus.proto.common.DMLMsgHeader.shardName)
}
// -------------------------------------------------------------------
// PrivilegeExt
// .milvus.proto.common.ResourceType resource_type = 1;
inline void PrivilegeExt::clear_resource_type() {
resource_type_ = 0;
}
inline ::milvus::proto::common::ResourceType PrivilegeExt::resource_type() const {
// @@protoc_insertion_point(field_get:milvus.proto.common.PrivilegeExt.resource_type)
return static_cast< ::milvus::proto::common::ResourceType >(resource_type_);
}
inline void PrivilegeExt::set_resource_type(::milvus::proto::common::ResourceType value) {
resource_type_ = value;
// @@protoc_insertion_point(field_set:milvus.proto.common.PrivilegeExt.resource_type)
}
// .milvus.proto.common.ResourcePrivilege resource_privilege = 2;
inline void PrivilegeExt::clear_resource_privilege() {
resource_privilege_ = 0;
}
inline ::milvus::proto::common::ResourcePrivilege PrivilegeExt::resource_privilege() const {
// @@protoc_insertion_point(field_get:milvus.proto.common.PrivilegeExt.resource_privilege)
return static_cast< ::milvus::proto::common::ResourcePrivilege >(resource_privilege_);
}
inline void PrivilegeExt::set_resource_privilege(::milvus::proto::common::ResourcePrivilege value) {
resource_privilege_ = value;
// @@protoc_insertion_point(field_set:milvus.proto.common.PrivilegeExt.resource_privilege)
}
// int32 resource_name_index = 3;
inline void PrivilegeExt::clear_resource_name_index() {
resource_name_index_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 PrivilegeExt::resource_name_index() const {
// @@protoc_insertion_point(field_get:milvus.proto.common.PrivilegeExt.resource_name_index)
return resource_name_index_;
}
inline void PrivilegeExt::set_resource_name_index(::PROTOBUF_NAMESPACE_ID::int32 value) {
resource_name_index_ = value;
// @@protoc_insertion_point(field_set:milvus.proto.common.PrivilegeExt.resource_name_index)
}
#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif // __GNUC__
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// @@protoc_insertion_point(namespace_scope)
} // namespace common
} // namespace proto
} // namespace milvus
PROTOBUF_NAMESPACE_OPEN
template <> struct is_proto_enum< ::milvus::proto::common::ErrorCode> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::milvus::proto::common::ErrorCode>() {
return ::milvus::proto::common::ErrorCode_descriptor();
}
template <> struct is_proto_enum< ::milvus::proto::common::IndexState> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::milvus::proto::common::IndexState>() {
return ::milvus::proto::common::IndexState_descriptor();
}
template <> struct is_proto_enum< ::milvus::proto::common::SegmentState> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::milvus::proto::common::SegmentState>() {
return ::milvus::proto::common::SegmentState_descriptor();
}
template <> struct is_proto_enum< ::milvus::proto::common::PlaceholderType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::milvus::proto::common::PlaceholderType>() {
return ::milvus::proto::common::PlaceholderType_descriptor();
}
template <> struct is_proto_enum< ::milvus::proto::common::MsgType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::milvus::proto::common::MsgType>() {
return ::milvus::proto::common::MsgType_descriptor();
}
template <> struct is_proto_enum< ::milvus::proto::common::DslType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::milvus::proto::common::DslType>() {
return ::milvus::proto::common::DslType_descriptor();
}
template <> struct is_proto_enum< ::milvus::proto::common::CompactionState> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::milvus::proto::common::CompactionState>() {
return ::milvus::proto::common::CompactionState_descriptor();
}
template <> struct is_proto_enum< ::milvus::proto::common::ConsistencyLevel> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::milvus::proto::common::ConsistencyLevel>() {
return ::milvus::proto::common::ConsistencyLevel_descriptor();
}
template <> struct is_proto_enum< ::milvus::proto::common::ImportState> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::milvus::proto::common::ImportState>() {
return ::milvus::proto::common::ImportState_descriptor();
}
template <> struct is_proto_enum< ::milvus::proto::common::ResourceType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::milvus::proto::common::ResourceType>() {
return ::milvus::proto::common::ResourceType_descriptor();
}
template <> struct is_proto_enum< ::milvus::proto::common::ResourcePrivilege> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::milvus::proto::common::ResourcePrivilege>() {
return ::milvus::proto::common::ResourcePrivilege_descriptor();
}
PROTOBUF_NAMESPACE_CLOSE
// @@protoc_insertion_point(global_scope)
#include <google/protobuf/port_undef.inc>
#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_common_2eproto
Reference in New Issue View Git Blame Copy Permalink