admin/milvus
1
0
Fork 0
mirror of https://gitee.com/milvus-io/milvus.git synced 2025-12-08 01:58:34 +08:00
Code Issues Packages Projects Releases Wiki Activity
milvus/internal/core/src/pb/common.pb.h
Enwei Jiao 967a97b9bd
Support json & array types (#23408) 
Signed-off-by: yah01 <yang.cen@zilliz.com>
Co-authored-by: yah01 <yang.cen@zilliz.com>
2023-04-20 11:32:31 +08:00

3889 lines
135 KiB
C++
Executable File
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 < 3021000
#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 3021004 < 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_util.h>
#include <google/protobuf/metadata_lite.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 uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_common_2eproto;
namespace milvus {
namespace proto {
namespace common {
class Address;
struct AddressDefaultTypeInternal;
extern AddressDefaultTypeInternal _Address_default_instance_;
class Blob;
struct BlobDefaultTypeInternal;
extern BlobDefaultTypeInternal _Blob_default_instance_;
class DMLMsgHeader;
struct DMLMsgHeaderDefaultTypeInternal;
extern DMLMsgHeaderDefaultTypeInternal _DMLMsgHeader_default_instance_;
class KeyDataPair;
struct KeyDataPairDefaultTypeInternal;
extern KeyDataPairDefaultTypeInternal _KeyDataPair_default_instance_;
class KeyValuePair;
struct KeyValuePairDefaultTypeInternal;
extern KeyValuePairDefaultTypeInternal _KeyValuePair_default_instance_;
class MsgBase;
struct MsgBaseDefaultTypeInternal;
extern MsgBaseDefaultTypeInternal _MsgBase_default_instance_;
class MsgHeader;
struct MsgHeaderDefaultTypeInternal;
extern MsgHeaderDefaultTypeInternal _MsgHeader_default_instance_;
class PlaceholderGroup;
struct PlaceholderGroupDefaultTypeInternal;
extern PlaceholderGroupDefaultTypeInternal _PlaceholderGroup_default_instance_;
class PlaceholderValue;
struct PlaceholderValueDefaultTypeInternal;
extern PlaceholderValueDefaultTypeInternal _PlaceholderValue_default_instance_;
class PrivilegeExt;
struct PrivilegeExtDefaultTypeInternal;
extern PrivilegeExtDefaultTypeInternal _PrivilegeExt_default_instance_;
class SegmentStats;
struct SegmentStatsDefaultTypeInternal;
extern SegmentStatsDefaultTypeInternal _SegmentStats_default_instance_;
class Status;
struct 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::SegmentStats* Arena::CreateMaybeMessage<::milvus::proto::common::SegmentStats>(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,
ForceDeny = 48,
RateLimit = 49,
NodeIDNotMatch = 50,
UpsertAutoIDTrue = 51,
InsufficientMemoryToLoad = 52,
MemoryQuotaExhausted = 53,
DiskQuotaExhausted = 54,
TimeTickLongDelay = 55,
NotReadyServe = 56,
NotReadyCoordActivating = 57,
DataCoordNA = 100,
DDRequestRace = 1000,
ErrorCode_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
ErrorCode_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::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(
::PROTOBUF_NAMESPACE_ID::ConstStringParam 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,
Retry = 5,
IndexState_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
IndexState_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
};
bool IndexState_IsValid(int value);
constexpr IndexState IndexState_MIN = IndexStateNone;
constexpr IndexState IndexState_MAX = Retry;
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(
::PROTOBUF_NAMESPACE_ID::ConstStringParam 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<int32_t>::min(),
SegmentState_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::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(
::PROTOBUF_NAMESPACE_ID::ConstStringParam 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<int32_t>::min(),
PlaceholderType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::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(
::PROTOBUF_NAMESPACE_ID::ConstStringParam 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,
AlterCollection = 111,
RenameCollection = 112,
DescribeAlias = 113,
ListAliases = 114,
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,
FederListIndexedSegment = 257,
FederDescribeSegmentIndexData = 258,
CreateIndex = 300,
DescribeIndex = 301,
DropIndex = 302,
Insert = 400,
Delete = 401,
Flush = 402,
ResendSegmentStats = 403,
Upsert = 404,
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,
UnsubDmChannel = 516,
GetDistribution = 517,
SyncDistribution = 518,
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,
CreateResourceGroup = 1700,
DropResourceGroup = 1701,
ListResourceGroups = 1702,
DescribeResourceGroup = 1703,
TransferNode = 1704,
TransferReplica = 1705,
MsgType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
MsgType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
};
bool MsgType_IsValid(int value);
constexpr MsgType MsgType_MIN = Undefined;
constexpr MsgType MsgType_MAX = TransferReplica;
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(
::PROTOBUF_NAMESPACE_ID::ConstStringParam 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<int32_t>::min(),
DslType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::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(
::PROTOBUF_NAMESPACE_ID::ConstStringParam 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<int32_t>::min(),
CompactionState_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::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(
::PROTOBUF_NAMESPACE_ID::ConstStringParam 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<int32_t>::min(),
ConsistencyLevel_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::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(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ConsistencyLevel* value) {
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ConsistencyLevel>(
ConsistencyLevel_descriptor(), name, value);
}
enum ImportState : int {
ImportPending = 0,
ImportFailed = 1,
ImportStarted = 2,
ImportPersisted = 5,
ImportFlushed = 8,
ImportCompleted = 6,
ImportFailedAndCleaned = 7,
ImportState_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
ImportState_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
};
bool ImportState_IsValid(int value);
constexpr ImportState ImportState_MIN = ImportPending;
constexpr ImportState ImportState_MAX = ImportFlushed;
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(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ImportState* value) {
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ImportState>(
ImportState_descriptor(), name, value);
}
enum ObjectType : int {
Collection = 0,
Global = 1,
User = 2,
ObjectType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
ObjectType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
};
bool ObjectType_IsValid(int value);
constexpr ObjectType ObjectType_MIN = Collection;
constexpr ObjectType ObjectType_MAX = User;
constexpr int ObjectType_ARRAYSIZE = ObjectType_MAX + 1;
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ObjectType_descriptor();
template<typename T>
inline const std::string& ObjectType_Name(T enum_t_value) {
static_assert(::std::is_same<T, ObjectType>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function ObjectType_Name.");
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
ObjectType_descriptor(), enum_t_value);
}
inline bool ObjectType_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ObjectType* value) {
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ObjectType>(
ObjectType_descriptor(), name, value);
}
enum ObjectPrivilege : int {
PrivilegeAll = 0,
PrivilegeCreateCollection = 1,
PrivilegeDropCollection = 2,
PrivilegeDescribeCollection = 3,
PrivilegeShowCollections = 4,
PrivilegeLoad = 5,
PrivilegeRelease = 6,
PrivilegeCompaction = 7,
PrivilegeInsert = 8,
PrivilegeDelete = 9,
PrivilegeGetStatistics = 10,
PrivilegeCreateIndex = 11,
PrivilegeIndexDetail = 12,
PrivilegeDropIndex = 13,
PrivilegeSearch = 14,
PrivilegeFlush = 15,
PrivilegeQuery = 16,
PrivilegeLoadBalance = 17,
PrivilegeImport = 18,
PrivilegeCreateOwnership = 19,
PrivilegeUpdateUser = 20,
PrivilegeDropOwnership = 21,
PrivilegeSelectOwnership = 22,
PrivilegeManageOwnership = 23,
PrivilegeSelectUser = 24,
PrivilegeUpsert = 25,
PrivilegeCreateResourceGroup = 26,
PrivilegeDropResourceGroup = 27,
PrivilegeDescribeResourceGroup = 28,
PrivilegeListResourceGroups = 29,
PrivilegeTransferNode = 30,
PrivilegeTransferReplica = 31,
PrivilegeGetLoadingProgress = 32,
PrivilegeGetLoadState = 33,
ObjectPrivilege_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
ObjectPrivilege_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
};
bool ObjectPrivilege_IsValid(int value);
constexpr ObjectPrivilege ObjectPrivilege_MIN = PrivilegeAll;
constexpr ObjectPrivilege ObjectPrivilege_MAX = PrivilegeGetLoadState;
constexpr int ObjectPrivilege_ARRAYSIZE = ObjectPrivilege_MAX + 1;
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ObjectPrivilege_descriptor();
template<typename T>
inline const std::string& ObjectPrivilege_Name(T enum_t_value) {
static_assert(::std::is_same<T, ObjectPrivilege>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function ObjectPrivilege_Name.");
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
ObjectPrivilege_descriptor(), enum_t_value);
}
inline bool ObjectPrivilege_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ObjectPrivilege* value) {
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ObjectPrivilege>(
ObjectPrivilege_descriptor(), name, value);
}
enum StateCode : int {
Initializing = 0,
Healthy = 1,
Abnormal = 2,
StandBy = 3,
Stopping = 4,
StateCode_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
StateCode_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
};
bool StateCode_IsValid(int value);
constexpr StateCode StateCode_MIN = Initializing;
constexpr StateCode StateCode_MAX = Stopping;
constexpr int StateCode_ARRAYSIZE = StateCode_MAX + 1;
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* StateCode_descriptor();
template<typename T>
inline const std::string& StateCode_Name(T enum_t_value) {
static_assert(::std::is_same<T, StateCode>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function StateCode_Name.");
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
StateCode_descriptor(), enum_t_value);
}
inline bool StateCode_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, StateCode* value) {
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<StateCode>(
StateCode_descriptor(), name, value);
}
enum LoadState : int {
LoadStateNotExist = 0,
LoadStateNotLoad = 1,
LoadStateLoading = 2,
LoadStateLoaded = 3,
LoadState_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
LoadState_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
};
bool LoadState_IsValid(int value);
constexpr LoadState LoadState_MIN = LoadStateNotExist;
constexpr LoadState LoadState_MAX = LoadStateLoaded;
constexpr int LoadState_ARRAYSIZE = LoadState_MAX + 1;
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* LoadState_descriptor();
template<typename T>
inline const std::string& LoadState_Name(T enum_t_value) {
static_assert(::std::is_same<T, LoadState>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function LoadState_Name.");
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
LoadState_descriptor(), enum_t_value);
}
inline bool LoadState_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, LoadState* value) {
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<LoadState>(
LoadState_descriptor(), name, value);
}
// ===================================================================
class Status final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.common.Status) */ {
public:
inline Status() : Status(nullptr) {}
~Status() override;
explicit PROTOBUF_CONSTEXPR Status(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
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 (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const Status& default_instance() {
return *internal_default_instance();
}
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;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(Status* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
Status* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<Status>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const Status& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom( const Status& from) {
Status::MergeImpl(*this, from);
}
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
private:
void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(Status* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "milvus.proto.common.Status";
}
protected:
explicit Status(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kReasonFieldNumber = 2,
kErrorCodeFieldNumber = 1,
kCodeFieldNumber = 3,
};
// string reason = 2;
void clear_reason();
const std::string& reason() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_reason(ArgT0&& arg0, ArgT... args);
std::string* mutable_reason();
PROTOBUF_NODISCARD std::string* release_reason();
void set_allocated_reason(std::string* reason);
private:
const std::string& _internal_reason() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_reason(const std::string& value);
std::string* _internal_mutable_reason();
public:
// .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);
private:
::milvus::proto::common::ErrorCode _internal_error_code() const;
void _internal_set_error_code(::milvus::proto::common::ErrorCode value);
public:
// int32 code = 3;
void clear_code();
int32_t code() const;
void set_code(int32_t value);
private:
int32_t _internal_code() const;
void _internal_set_code(int32_t value);
public:
// @@protoc_insertion_point(class_scope:milvus.proto.common.Status)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
struct Impl_ {
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr reason_;
int error_code_;
int32_t code_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
};
union { Impl_ _impl_; };
friend struct ::TableStruct_common_2eproto;
};
// -------------------------------------------------------------------
class KeyValuePair final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.common.KeyValuePair) */ {
public:
inline KeyValuePair() : KeyValuePair(nullptr) {}
~KeyValuePair() override;
explicit PROTOBUF_CONSTEXPR KeyValuePair(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
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 (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const KeyValuePair& default_instance() {
return *internal_default_instance();
}
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;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(KeyValuePair* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
KeyValuePair* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<KeyValuePair>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const KeyValuePair& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom( const KeyValuePair& from) {
KeyValuePair::MergeImpl(*this, from);
}
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
private:
void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(KeyValuePair* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "milvus.proto.common.KeyValuePair";
}
protected:
explicit KeyValuePair(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kKeyFieldNumber = 1,
kValueFieldNumber = 2,
};
// string key = 1;
void clear_key();
const std::string& key() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_key(ArgT0&& arg0, ArgT... args);
std::string* mutable_key();
PROTOBUF_NODISCARD std::string* release_key();
void set_allocated_key(std::string* key);
private:
const std::string& _internal_key() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_key(const std::string& value);
std::string* _internal_mutable_key();
public:
// string value = 2;
void clear_value();
const std::string& value() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_value(ArgT0&& arg0, ArgT... args);
std::string* mutable_value();
PROTOBUF_NODISCARD std::string* release_value();
void set_allocated_value(std::string* value);
private:
const std::string& _internal_value() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_value(const std::string& value);
std::string* _internal_mutable_value();
public:
// @@protoc_insertion_point(class_scope:milvus.proto.common.KeyValuePair)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
struct Impl_ {
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
};
union { Impl_ _impl_; };
friend struct ::TableStruct_common_2eproto;
};
// -------------------------------------------------------------------
class KeyDataPair final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.common.KeyDataPair) */ {
public:
inline KeyDataPair() : KeyDataPair(nullptr) {}
~KeyDataPair() override;
explicit PROTOBUF_CONSTEXPR KeyDataPair(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
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 (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const KeyDataPair& default_instance() {
return *internal_default_instance();
}
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;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(KeyDataPair* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
KeyDataPair* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<KeyDataPair>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const KeyDataPair& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom( const KeyDataPair& from) {
KeyDataPair::MergeImpl(*this, from);
}
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
private:
void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(KeyDataPair* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "milvus.proto.common.KeyDataPair";
}
protected:
explicit KeyDataPair(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kKeyFieldNumber = 1,
kDataFieldNumber = 2,
};
// string key = 1;
void clear_key();
const std::string& key() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_key(ArgT0&& arg0, ArgT... args);
std::string* mutable_key();
PROTOBUF_NODISCARD std::string* release_key();
void set_allocated_key(std::string* key);
private:
const std::string& _internal_key() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_key(const std::string& value);
std::string* _internal_mutable_key();
public:
// bytes data = 2;
void clear_data();
const std::string& data() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_data(ArgT0&& arg0, ArgT... args);
std::string* mutable_data();
PROTOBUF_NODISCARD std::string* release_data();
void set_allocated_data(std::string* data);
private:
const std::string& _internal_data() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_data(const std::string& value);
std::string* _internal_mutable_data();
public:
// @@protoc_insertion_point(class_scope:milvus.proto.common.KeyDataPair)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
struct Impl_ {
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr data_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
};
union { Impl_ _impl_; };
friend struct ::TableStruct_common_2eproto;
};
// -------------------------------------------------------------------
class Blob final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.common.Blob) */ {
public:
inline Blob() : Blob(nullptr) {}
~Blob() override;
explicit PROTOBUF_CONSTEXPR Blob(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
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 (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const Blob& default_instance() {
return *internal_default_instance();
}
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;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(Blob* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
Blob* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<Blob>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const Blob& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom( const Blob& from) {
Blob::MergeImpl(*this, from);
}
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
private:
void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(Blob* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "milvus.proto.common.Blob";
}
protected:
explicit Blob(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kValueFieldNumber = 1,
};
// bytes value = 1;
void clear_value();
const std::string& value() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_value(ArgT0&& arg0, ArgT... args);
std::string* mutable_value();
PROTOBUF_NODISCARD std::string* release_value();
void set_allocated_value(std::string* value);
private:
const std::string& _internal_value() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_value(const std::string& value);
std::string* _internal_mutable_value();
public:
// @@protoc_insertion_point(class_scope:milvus.proto.common.Blob)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
struct Impl_ {
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
};
union { Impl_ _impl_; };
friend struct ::TableStruct_common_2eproto;
};
// -------------------------------------------------------------------
class PlaceholderValue final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.common.PlaceholderValue) */ {
public:
inline PlaceholderValue() : PlaceholderValue(nullptr) {}
~PlaceholderValue() override;
explicit PROTOBUF_CONSTEXPR PlaceholderValue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
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 (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const PlaceholderValue& default_instance() {
return *internal_default_instance();
}
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;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(PlaceholderValue* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
PlaceholderValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<PlaceholderValue>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const PlaceholderValue& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom( const PlaceholderValue& from) {
PlaceholderValue::MergeImpl(*this, from);
}
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
private:
void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(PlaceholderValue* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "milvus.proto.common.PlaceholderValue";
}
protected:
explicit PlaceholderValue(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kValuesFieldNumber = 3,
kTagFieldNumber = 1,
kTypeFieldNumber = 2,
};
// repeated bytes values = 3;
int values_size() const;
private:
int _internal_values_size() const;
public:
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();
private:
const std::string& _internal_values(int index) const;
std::string* _internal_add_values();
public:
// string tag = 1;
void clear_tag();
const std::string& tag() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_tag(ArgT0&& arg0, ArgT... args);
std::string* mutable_tag();
PROTOBUF_NODISCARD std::string* release_tag();
void set_allocated_tag(std::string* tag);
private:
const std::string& _internal_tag() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_tag(const std::string& value);
std::string* _internal_mutable_tag();
public:
// .milvus.proto.common.PlaceholderType type = 2;
void clear_type();
::milvus::proto::common::PlaceholderType type() const;
void set_type(::milvus::proto::common::PlaceholderType value);
private:
::milvus::proto::common::PlaceholderType _internal_type() const;
void _internal_set_type(::milvus::proto::common::PlaceholderType value);
public:
// @@protoc_insertion_point(class_scope:milvus.proto.common.PlaceholderValue)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
struct Impl_ {
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> values_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr tag_;
int type_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
};
union { Impl_ _impl_; };
friend struct ::TableStruct_common_2eproto;
};
// -------------------------------------------------------------------
class PlaceholderGroup final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.common.PlaceholderGroup) */ {
public:
inline PlaceholderGroup() : PlaceholderGroup(nullptr) {}
~PlaceholderGroup() override;
explicit PROTOBUF_CONSTEXPR PlaceholderGroup(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
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 (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const PlaceholderGroup& default_instance() {
return *internal_default_instance();
}
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;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(PlaceholderGroup* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
PlaceholderGroup* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<PlaceholderGroup>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const PlaceholderGroup& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom( const PlaceholderGroup& from) {
PlaceholderGroup::MergeImpl(*this, from);
}
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
private:
void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(PlaceholderGroup* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "milvus.proto.common.PlaceholderGroup";
}
protected:
explicit PlaceholderGroup(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kPlaceholdersFieldNumber = 1,
};
// repeated .milvus.proto.common.PlaceholderValue placeholders = 1;
int placeholders_size() const;
private:
int _internal_placeholders_size() const;
public:
void clear_placeholders();
::milvus::proto::common::PlaceholderValue* mutable_placeholders(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::common::PlaceholderValue >*
mutable_placeholders();
private:
const ::milvus::proto::common::PlaceholderValue& _internal_placeholders(int index) const;
::milvus::proto::common::PlaceholderValue* _internal_add_placeholders();
public:
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;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
struct Impl_ {
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::common::PlaceholderValue > placeholders_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
};
union { Impl_ _impl_; };
friend struct ::TableStruct_common_2eproto;
};
// -------------------------------------------------------------------
class Address final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.common.Address) */ {
public:
inline Address() : Address(nullptr) {}
~Address() override;
explicit PROTOBUF_CONSTEXPR Address(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
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 (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const Address& default_instance() {
return *internal_default_instance();
}
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;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(Address* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
Address* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<Address>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const Address& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom( const Address& from) {
Address::MergeImpl(*this, from);
}
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
private:
void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(Address* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "milvus.proto.common.Address";
}
protected:
explicit Address(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kIpFieldNumber = 1,
kPortFieldNumber = 2,
};
// string ip = 1;
void clear_ip();
const std::string& ip() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_ip(ArgT0&& arg0, ArgT... args);
std::string* mutable_ip();
PROTOBUF_NODISCARD std::string* release_ip();
void set_allocated_ip(std::string* ip);
private:
const std::string& _internal_ip() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_ip(const std::string& value);
std::string* _internal_mutable_ip();
public:
// int64 port = 2;
void clear_port();
int64_t port() const;
void set_port(int64_t value);
private:
int64_t _internal_port() const;
void _internal_set_port(int64_t value);
public:
// @@protoc_insertion_point(class_scope:milvus.proto.common.Address)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
struct Impl_ {
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr ip_;
int64_t port_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
};
union { Impl_ _impl_; };
friend struct ::TableStruct_common_2eproto;
};
// -------------------------------------------------------------------
class MsgBase final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.common.MsgBase) */ {
public:
inline MsgBase() : MsgBase(nullptr) {}
~MsgBase() override;
explicit PROTOBUF_CONSTEXPR MsgBase(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
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 (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const MsgBase& default_instance() {
return *internal_default_instance();
}
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;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(MsgBase* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
MsgBase* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<MsgBase>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const MsgBase& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom( const MsgBase& from) {
MsgBase::MergeImpl(*this, from);
}
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
private:
void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(MsgBase* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "milvus.proto.common.MsgBase";
}
protected:
explicit MsgBase(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kMsgIDFieldNumber = 2,
kTimestampFieldNumber = 3,
kSourceIDFieldNumber = 4,
kTargetIDFieldNumber = 5,
kMsgTypeFieldNumber = 1,
};
// int64 msgID = 2;
void clear_msgid();
int64_t msgid() const;
void set_msgid(int64_t value);
private:
int64_t _internal_msgid() const;
void _internal_set_msgid(int64_t value);
public:
// uint64 timestamp = 3;
void clear_timestamp();
uint64_t timestamp() const;
void set_timestamp(uint64_t value);
private:
uint64_t _internal_timestamp() const;
void _internal_set_timestamp(uint64_t value);
public:
// int64 sourceID = 4;
void clear_sourceid();
int64_t sourceid() const;
void set_sourceid(int64_t value);
private:
int64_t _internal_sourceid() const;
void _internal_set_sourceid(int64_t value);
public:
// int64 targetID = 5;
void clear_targetid();
int64_t targetid() const;
void set_targetid(int64_t value);
private:
int64_t _internal_targetid() const;
void _internal_set_targetid(int64_t value);
public:
// .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);
private:
::milvus::proto::common::MsgType _internal_msg_type() const;
void _internal_set_msg_type(::milvus::proto::common::MsgType value);
public:
// @@protoc_insertion_point(class_scope:milvus.proto.common.MsgBase)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
struct Impl_ {
int64_t msgid_;
uint64_t timestamp_;
int64_t sourceid_;
int64_t targetid_;
int msg_type_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
};
union { Impl_ _impl_; };
friend struct ::TableStruct_common_2eproto;
};
// -------------------------------------------------------------------
class MsgHeader final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.common.MsgHeader) */ {
public:
inline MsgHeader() : MsgHeader(nullptr) {}
~MsgHeader() override;
explicit PROTOBUF_CONSTEXPR MsgHeader(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
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 (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const MsgHeader& default_instance() {
return *internal_default_instance();
}
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;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(MsgHeader* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
MsgHeader* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<MsgHeader>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const MsgHeader& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom( const MsgHeader& from) {
MsgHeader::MergeImpl(*this, from);
}
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
private:
void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(MsgHeader* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "milvus.proto.common.MsgHeader";
}
protected:
explicit MsgHeader(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kBaseFieldNumber = 1,
};
// .milvus.proto.common.MsgBase base = 1;
bool has_base() const;
private:
bool _internal_has_base() const;
public:
void clear_base();
const ::milvus::proto::common::MsgBase& base() const;
PROTOBUF_NODISCARD ::milvus::proto::common::MsgBase* release_base();
::milvus::proto::common::MsgBase* mutable_base();
void set_allocated_base(::milvus::proto::common::MsgBase* base);
private:
const ::milvus::proto::common::MsgBase& _internal_base() const;
::milvus::proto::common::MsgBase* _internal_mutable_base();
public:
void unsafe_arena_set_allocated_base(
::milvus::proto::common::MsgBase* base);
::milvus::proto::common::MsgBase* unsafe_arena_release_base();
// @@protoc_insertion_point(class_scope:milvus.proto.common.MsgHeader)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
struct Impl_ {
::milvus::proto::common::MsgBase* base_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
};
union { Impl_ _impl_; };
friend struct ::TableStruct_common_2eproto;
};
// -------------------------------------------------------------------
class DMLMsgHeader final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.common.DMLMsgHeader) */ {
public:
inline DMLMsgHeader() : DMLMsgHeader(nullptr) {}
~DMLMsgHeader() override;
explicit PROTOBUF_CONSTEXPR DMLMsgHeader(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
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 (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const DMLMsgHeader& default_instance() {
return *internal_default_instance();
}
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;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(DMLMsgHeader* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
DMLMsgHeader* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<DMLMsgHeader>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const DMLMsgHeader& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom( const DMLMsgHeader& from) {
DMLMsgHeader::MergeImpl(*this, from);
}
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
private:
void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(DMLMsgHeader* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "milvus.proto.common.DMLMsgHeader";
}
protected:
explicit DMLMsgHeader(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kShardNameFieldNumber = 2,
kBaseFieldNumber = 1,
};
// string shardName = 2;
void clear_shardname();
const std::string& shardname() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_shardname(ArgT0&& arg0, ArgT... args);
std::string* mutable_shardname();
PROTOBUF_NODISCARD std::string* release_shardname();
void set_allocated_shardname(std::string* shardname);
private:
const std::string& _internal_shardname() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_shardname(const std::string& value);
std::string* _internal_mutable_shardname();
public:
// .milvus.proto.common.MsgBase base = 1;
bool has_base() const;
private:
bool _internal_has_base() const;
public:
void clear_base();
const ::milvus::proto::common::MsgBase& base() const;
PROTOBUF_NODISCARD ::milvus::proto::common::MsgBase* release_base();
::milvus::proto::common::MsgBase* mutable_base();
void set_allocated_base(::milvus::proto::common::MsgBase* base);
private:
const ::milvus::proto::common::MsgBase& _internal_base() const;
::milvus::proto::common::MsgBase* _internal_mutable_base();
public:
void unsafe_arena_set_allocated_base(
::milvus::proto::common::MsgBase* base);
::milvus::proto::common::MsgBase* unsafe_arena_release_base();
// @@protoc_insertion_point(class_scope:milvus.proto.common.DMLMsgHeader)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
struct Impl_ {
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr shardname_;
::milvus::proto::common::MsgBase* base_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
};
union { Impl_ _impl_; };
friend struct ::TableStruct_common_2eproto;
};
// -------------------------------------------------------------------
class PrivilegeExt final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.common.PrivilegeExt) */ {
public:
inline PrivilegeExt() : PrivilegeExt(nullptr) {}
~PrivilegeExt() override;
explicit PROTOBUF_CONSTEXPR PrivilegeExt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
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 (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const PrivilegeExt& default_instance() {
return *internal_default_instance();
}
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;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(PrivilegeExt* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
PrivilegeExt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<PrivilegeExt>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const PrivilegeExt& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom( const PrivilegeExt& from) {
PrivilegeExt::MergeImpl(*this, from);
}
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
private:
void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(PrivilegeExt* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "milvus.proto.common.PrivilegeExt";
}
protected:
explicit PrivilegeExt(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kObjectTypeFieldNumber = 1,
kObjectPrivilegeFieldNumber = 2,
kObjectNameIndexFieldNumber = 3,
kObjectNameIndexsFieldNumber = 4,
};
// .milvus.proto.common.ObjectType object_type = 1;
void clear_object_type();
::milvus::proto::common::ObjectType object_type() const;
void set_object_type(::milvus::proto::common::ObjectType value);
private:
::milvus::proto::common::ObjectType _internal_object_type() const;
void _internal_set_object_type(::milvus::proto::common::ObjectType value);
public:
// .milvus.proto.common.ObjectPrivilege object_privilege = 2;
void clear_object_privilege();
::milvus::proto::common::ObjectPrivilege object_privilege() const;
void set_object_privilege(::milvus::proto::common::ObjectPrivilege value);
private:
::milvus::proto::common::ObjectPrivilege _internal_object_privilege() const;
void _internal_set_object_privilege(::milvus::proto::common::ObjectPrivilege value);
public:
// int32 object_name_index = 3;
void clear_object_name_index();
int32_t object_name_index() const;
void set_object_name_index(int32_t value);
private:
int32_t _internal_object_name_index() const;
void _internal_set_object_name_index(int32_t value);
public:
// int32 object_name_indexs = 4;
void clear_object_name_indexs();
int32_t object_name_indexs() const;
void set_object_name_indexs(int32_t value);
private:
int32_t _internal_object_name_indexs() const;
void _internal_set_object_name_indexs(int32_t value);
public:
// @@protoc_insertion_point(class_scope:milvus.proto.common.PrivilegeExt)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
struct Impl_ {
int object_type_;
int object_privilege_;
int32_t object_name_index_;
int32_t object_name_indexs_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
};
union { Impl_ _impl_; };
friend struct ::TableStruct_common_2eproto;
};
// -------------------------------------------------------------------
class SegmentStats final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.common.SegmentStats) */ {
public:
inline SegmentStats() : SegmentStats(nullptr) {}
~SegmentStats() override;
explicit PROTOBUF_CONSTEXPR SegmentStats(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
SegmentStats(const SegmentStats& from);
SegmentStats(SegmentStats&& from) noexcept
: SegmentStats() {
*this = ::std::move(from);
}
inline SegmentStats& operator=(const SegmentStats& from) {
CopyFrom(from);
return *this;
}
inline SegmentStats& operator=(SegmentStats&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const SegmentStats& default_instance() {
return *internal_default_instance();
}
static inline const SegmentStats* internal_default_instance() {
return reinterpret_cast<const SegmentStats*>(
&_SegmentStats_default_instance_);
}
static constexpr int kIndexInFileMessages =
11;
friend void swap(SegmentStats& a, SegmentStats& b) {
a.Swap(&b);
}
inline void Swap(SegmentStats* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(SegmentStats* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
SegmentStats* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<SegmentStats>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const SegmentStats& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom( const SegmentStats& from) {
SegmentStats::MergeImpl(*this, from);
}
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
private:
void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(SegmentStats* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "milvus.proto.common.SegmentStats";
}
protected:
explicit SegmentStats(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kSegmentIDFieldNumber = 1,
kNumRowsFieldNumber = 2,
};
// int64 SegmentID = 1;
void clear_segmentid();
int64_t segmentid() const;
void set_segmentid(int64_t value);
private:
int64_t _internal_segmentid() const;
void _internal_set_segmentid(int64_t value);
public:
// int64 NumRows = 2;
void clear_numrows();
int64_t numrows() const;
void set_numrows(int64_t value);
private:
int64_t _internal_numrows() const;
void _internal_set_numrows(int64_t value);
public:
// @@protoc_insertion_point(class_scope:milvus.proto.common.SegmentStats)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
struct Impl_ {
int64_t segmentid_;
int64_t numrows_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
};
union { Impl_ _impl_; };
friend struct ::TableStruct_common_2eproto;
};
// ===================================================================
static const int kPrivilegeExtObjFieldNumber = 1001;
extern ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier< ::PROTOBUF_NAMESPACE_ID::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() {
_impl_.error_code_ = 0;
}
inline ::milvus::proto::common::ErrorCode Status::_internal_error_code() const {
return static_cast< ::milvus::proto::common::ErrorCode >(_impl_.error_code_);
}
inline ::milvus::proto::common::ErrorCode Status::error_code() const {
// @@protoc_insertion_point(field_get:milvus.proto.common.Status.error_code)
return _internal_error_code();
}
inline void Status::_internal_set_error_code(::milvus::proto::common::ErrorCode value) {
_impl_.error_code_ = value;
}
inline void Status::set_error_code(::milvus::proto::common::ErrorCode value) {
_internal_set_error_code(value);
// @@protoc_insertion_point(field_set:milvus.proto.common.Status.error_code)
}
// string reason = 2;
inline void Status::clear_reason() {
_impl_.reason_.ClearToEmpty();
}
inline const std::string& Status::reason() const {
// @@protoc_insertion_point(field_get:milvus.proto.common.Status.reason)
return _internal_reason();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Status::set_reason(ArgT0&& arg0, ArgT... args) {
_impl_.reason_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:milvus.proto.common.Status.reason)
}
inline std::string* Status::mutable_reason() {
std::string* _s = _internal_mutable_reason();
// @@protoc_insertion_point(field_mutable:milvus.proto.common.Status.reason)
return _s;
}
inline const std::string& Status::_internal_reason() const {
return _impl_.reason_.Get();
}
inline void Status::_internal_set_reason(const std::string& value) {
_impl_.reason_.Set(value, GetArenaForAllocation());
}
inline std::string* Status::_internal_mutable_reason() {
return _impl_.reason_.Mutable(GetArenaForAllocation());
}
inline std::string* Status::release_reason() {
// @@protoc_insertion_point(field_release:milvus.proto.common.Status.reason)
return _impl_.reason_.Release();
}
inline void Status::set_allocated_reason(std::string* reason) {
if (reason != nullptr) {
} else {
}
_impl_.reason_.SetAllocated(reason, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (_impl_.reason_.IsDefault()) {
_impl_.reason_.Set("", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:milvus.proto.common.Status.reason)
}
// int32 code = 3;
inline void Status::clear_code() {
_impl_.code_ = 0;
}
inline int32_t Status::_internal_code() const {
return _impl_.code_;
}
inline int32_t Status::code() const {
// @@protoc_insertion_point(field_get:milvus.proto.common.Status.code)
return _internal_code();
}
inline void Status::_internal_set_code(int32_t value) {
_impl_.code_ = value;
}
inline void Status::set_code(int32_t value) {
_internal_set_code(value);
// @@protoc_insertion_point(field_set:milvus.proto.common.Status.code)
}
// -------------------------------------------------------------------
// KeyValuePair
// string key = 1;
inline void KeyValuePair::clear_key() {
_impl_.key_.ClearToEmpty();
}
inline const std::string& KeyValuePair::key() const {
// @@protoc_insertion_point(field_get:milvus.proto.common.KeyValuePair.key)
return _internal_key();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void KeyValuePair::set_key(ArgT0&& arg0, ArgT... args) {
_impl_.key_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:milvus.proto.common.KeyValuePair.key)
}
inline std::string* KeyValuePair::mutable_key() {
std::string* _s = _internal_mutable_key();
// @@protoc_insertion_point(field_mutable:milvus.proto.common.KeyValuePair.key)
return _s;
}
inline const std::string& KeyValuePair::_internal_key() const {
return _impl_.key_.Get();
}
inline void KeyValuePair::_internal_set_key(const std::string& value) {
_impl_.key_.Set(value, GetArenaForAllocation());
}
inline std::string* KeyValuePair::_internal_mutable_key() {
return _impl_.key_.Mutable(GetArenaForAllocation());
}
inline std::string* KeyValuePair::release_key() {
// @@protoc_insertion_point(field_release:milvus.proto.common.KeyValuePair.key)
return _impl_.key_.Release();
}
inline void KeyValuePair::set_allocated_key(std::string* key) {
if (key != nullptr) {
} else {
}
_impl_.key_.SetAllocated(key, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (_impl_.key_.IsDefault()) {
_impl_.key_.Set("", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:milvus.proto.common.KeyValuePair.key)
}
// string value = 2;
inline void KeyValuePair::clear_value() {
_impl_.value_.ClearToEmpty();
}
inline const std::string& KeyValuePair::value() const {
// @@protoc_insertion_point(field_get:milvus.proto.common.KeyValuePair.value)
return _internal_value();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void KeyValuePair::set_value(ArgT0&& arg0, ArgT... args) {
_impl_.value_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:milvus.proto.common.KeyValuePair.value)
}
inline std::string* KeyValuePair::mutable_value() {
std::string* _s = _internal_mutable_value();
// @@protoc_insertion_point(field_mutable:milvus.proto.common.KeyValuePair.value)
return _s;
}
inline const std::string& KeyValuePair::_internal_value() const {
return _impl_.value_.Get();
}
inline void KeyValuePair::_internal_set_value(const std::string& value) {
_impl_.value_.Set(value, GetArenaForAllocation());
}
inline std::string* KeyValuePair::_internal_mutable_value() {
return _impl_.value_.Mutable(GetArenaForAllocation());
}
inline std::string* KeyValuePair::release_value() {
// @@protoc_insertion_point(field_release:milvus.proto.common.KeyValuePair.value)
return _impl_.value_.Release();
}
inline void KeyValuePair::set_allocated_value(std::string* value) {
if (value != nullptr) {
} else {
}
_impl_.value_.SetAllocated(value, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (_impl_.value_.IsDefault()) {
_impl_.value_.Set("", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:milvus.proto.common.KeyValuePair.value)
}
// -------------------------------------------------------------------
// KeyDataPair
// string key = 1;
inline void KeyDataPair::clear_key() {
_impl_.key_.ClearToEmpty();
}
inline const std::string& KeyDataPair::key() const {
// @@protoc_insertion_point(field_get:milvus.proto.common.KeyDataPair.key)
return _internal_key();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void KeyDataPair::set_key(ArgT0&& arg0, ArgT... args) {
_impl_.key_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:milvus.proto.common.KeyDataPair.key)
}
inline std::string* KeyDataPair::mutable_key() {
std::string* _s = _internal_mutable_key();
// @@protoc_insertion_point(field_mutable:milvus.proto.common.KeyDataPair.key)
return _s;
}
inline const std::string& KeyDataPair::_internal_key() const {
return _impl_.key_.Get();
}
inline void KeyDataPair::_internal_set_key(const std::string& value) {
_impl_.key_.Set(value, GetArenaForAllocation());
}
inline std::string* KeyDataPair::_internal_mutable_key() {
return _impl_.key_.Mutable(GetArenaForAllocation());
}
inline std::string* KeyDataPair::release_key() {
// @@protoc_insertion_point(field_release:milvus.proto.common.KeyDataPair.key)
return _impl_.key_.Release();
}
inline void KeyDataPair::set_allocated_key(std::string* key) {
if (key != nullptr) {
} else {
}
_impl_.key_.SetAllocated(key, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (_impl_.key_.IsDefault()) {
_impl_.key_.Set("", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:milvus.proto.common.KeyDataPair.key)
}
// bytes data = 2;
inline void KeyDataPair::clear_data() {
_impl_.data_.ClearToEmpty();
}
inline const std::string& KeyDataPair::data() const {
// @@protoc_insertion_point(field_get:milvus.proto.common.KeyDataPair.data)
return _internal_data();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void KeyDataPair::set_data(ArgT0&& arg0, ArgT... args) {
_impl_.data_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:milvus.proto.common.KeyDataPair.data)
}
inline std::string* KeyDataPair::mutable_data() {
std::string* _s = _internal_mutable_data();
// @@protoc_insertion_point(field_mutable:milvus.proto.common.KeyDataPair.data)
return _s;
}
inline const std::string& KeyDataPair::_internal_data() const {
return _impl_.data_.Get();
}
inline void KeyDataPair::_internal_set_data(const std::string& value) {
_impl_.data_.Set(value, GetArenaForAllocation());
}
inline std::string* KeyDataPair::_internal_mutable_data() {
return _impl_.data_.Mutable(GetArenaForAllocation());
}
inline std::string* KeyDataPair::release_data() {
// @@protoc_insertion_point(field_release:milvus.proto.common.KeyDataPair.data)
return _impl_.data_.Release();
}
inline void KeyDataPair::set_allocated_data(std::string* data) {
if (data != nullptr) {
} else {
}
_impl_.data_.SetAllocated(data, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (_impl_.data_.IsDefault()) {
_impl_.data_.Set("", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:milvus.proto.common.KeyDataPair.data)
}
// -------------------------------------------------------------------
// Blob
// bytes value = 1;
inline void Blob::clear_value() {
_impl_.value_.ClearToEmpty();
}
inline const std::string& Blob::value() const {
// @@protoc_insertion_point(field_get:milvus.proto.common.Blob.value)
return _internal_value();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Blob::set_value(ArgT0&& arg0, ArgT... args) {
_impl_.value_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:milvus.proto.common.Blob.value)
}
inline std::string* Blob::mutable_value() {
std::string* _s = _internal_mutable_value();
// @@protoc_insertion_point(field_mutable:milvus.proto.common.Blob.value)
return _s;
}
inline const std::string& Blob::_internal_value() const {
return _impl_.value_.Get();
}
inline void Blob::_internal_set_value(const std::string& value) {
_impl_.value_.Set(value, GetArenaForAllocation());
}
inline std::string* Blob::_internal_mutable_value() {
return _impl_.value_.Mutable(GetArenaForAllocation());
}
inline std::string* Blob::release_value() {
// @@protoc_insertion_point(field_release:milvus.proto.common.Blob.value)
return _impl_.value_.Release();
}
inline void Blob::set_allocated_value(std::string* value) {
if (value != nullptr) {
} else {
}
_impl_.value_.SetAllocated(value, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (_impl_.value_.IsDefault()) {
_impl_.value_.Set("", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:milvus.proto.common.Blob.value)
}
// -------------------------------------------------------------------
// PlaceholderValue
// string tag = 1;
inline void PlaceholderValue::clear_tag() {
_impl_.tag_.ClearToEmpty();
}
inline const std::string& PlaceholderValue::tag() const {
// @@protoc_insertion_point(field_get:milvus.proto.common.PlaceholderValue.tag)
return _internal_tag();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void PlaceholderValue::set_tag(ArgT0&& arg0, ArgT... args) {
_impl_.tag_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:milvus.proto.common.PlaceholderValue.tag)
}
inline std::string* PlaceholderValue::mutable_tag() {
std::string* _s = _internal_mutable_tag();
// @@protoc_insertion_point(field_mutable:milvus.proto.common.PlaceholderValue.tag)
return _s;
}
inline const std::string& PlaceholderValue::_internal_tag() const {
return _impl_.tag_.Get();
}
inline void PlaceholderValue::_internal_set_tag(const std::string& value) {
_impl_.tag_.Set(value, GetArenaForAllocation());
}
inline std::string* PlaceholderValue::_internal_mutable_tag() {
return _impl_.tag_.Mutable(GetArenaForAllocation());
}
inline std::string* PlaceholderValue::release_tag() {
// @@protoc_insertion_point(field_release:milvus.proto.common.PlaceholderValue.tag)
return _impl_.tag_.Release();
}
inline void PlaceholderValue::set_allocated_tag(std::string* tag) {
if (tag != nullptr) {
} else {
}
_impl_.tag_.SetAllocated(tag, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (_impl_.tag_.IsDefault()) {
_impl_.tag_.Set("", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:milvus.proto.common.PlaceholderValue.tag)
}
// .milvus.proto.common.PlaceholderType type = 2;
inline void PlaceholderValue::clear_type() {
_impl_.type_ = 0;
}
inline ::milvus::proto::common::PlaceholderType PlaceholderValue::_internal_type() const {
return static_cast< ::milvus::proto::common::PlaceholderType >(_impl_.type_);
}
inline ::milvus::proto::common::PlaceholderType PlaceholderValue::type() const {
// @@protoc_insertion_point(field_get:milvus.proto.common.PlaceholderValue.type)
return _internal_type();
}
inline void PlaceholderValue::_internal_set_type(::milvus::proto::common::PlaceholderType value) {
_impl_.type_ = value;
}
inline void PlaceholderValue::set_type(::milvus::proto::common::PlaceholderType value) {
_internal_set_type(value);
// @@protoc_insertion_point(field_set:milvus.proto.common.PlaceholderValue.type)
}
// repeated bytes values = 3;
inline int PlaceholderValue::_internal_values_size() const {
return _impl_.values_.size();
}
inline int PlaceholderValue::values_size() const {
return _internal_values_size();
}
inline void PlaceholderValue::clear_values() {
_impl_.values_.Clear();
}
inline std::string* PlaceholderValue::add_values() {
std::string* _s = _internal_add_values();
// @@protoc_insertion_point(field_add_mutable:milvus.proto.common.PlaceholderValue.values)
return _s;
}
inline const std::string& PlaceholderValue::_internal_values(int index) const {
return _impl_.values_.Get(index);
}
inline const std::string& PlaceholderValue::values(int index) const {
// @@protoc_insertion_point(field_get:milvus.proto.common.PlaceholderValue.values)
return _internal_values(index);
}
inline std::string* PlaceholderValue::mutable_values(int index) {
// @@protoc_insertion_point(field_mutable:milvus.proto.common.PlaceholderValue.values)
return _impl_.values_.Mutable(index);
}
inline void PlaceholderValue::set_values(int index, const std::string& value) {
_impl_.values_.Mutable(index)->assign(value);
// @@protoc_insertion_point(field_set:milvus.proto.common.PlaceholderValue.values)
}
inline void PlaceholderValue::set_values(int index, std::string&& value) {
_impl_.values_.Mutable(index)->assign(std::move(value));
// @@protoc_insertion_point(field_set:milvus.proto.common.PlaceholderValue.values)
}
inline void PlaceholderValue::set_values(int index, const char* value) {
GOOGLE_DCHECK(value != nullptr);
_impl_.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) {
_impl_.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::_internal_add_values() {
return _impl_.values_.Add();
}
inline void PlaceholderValue::add_values(const std::string& value) {
_impl_.values_.Add()->assign(value);
// @@protoc_insertion_point(field_add:milvus.proto.common.PlaceholderValue.values)
}
inline void PlaceholderValue::add_values(std::string&& value) {
_impl_.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);
_impl_.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) {
_impl_.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 _impl_.values_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
PlaceholderValue::mutable_values() {
// @@protoc_insertion_point(field_mutable_list:milvus.proto.common.PlaceholderValue.values)
return &_impl_.values_;
}
// -------------------------------------------------------------------
// PlaceholderGroup
// repeated .milvus.proto.common.PlaceholderValue placeholders = 1;
inline int PlaceholderGroup::_internal_placeholders_size() const {
return _impl_.placeholders_.size();
}
inline int PlaceholderGroup::placeholders_size() const {
return _internal_placeholders_size();
}
inline void PlaceholderGroup::clear_placeholders() {
_impl_.placeholders_.Clear();
}
inline ::milvus::proto::common::PlaceholderValue* PlaceholderGroup::mutable_placeholders(int index) {
// @@protoc_insertion_point(field_mutable:milvus.proto.common.PlaceholderGroup.placeholders)
return _impl_.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 &_impl_.placeholders_;
}
inline const ::milvus::proto::common::PlaceholderValue& PlaceholderGroup::_internal_placeholders(int index) const {
return _impl_.placeholders_.Get(index);
}
inline const ::milvus::proto::common::PlaceholderValue& PlaceholderGroup::placeholders(int index) const {
// @@protoc_insertion_point(field_get:milvus.proto.common.PlaceholderGroup.placeholders)
return _internal_placeholders(index);
}
inline ::milvus::proto::common::PlaceholderValue* PlaceholderGroup::_internal_add_placeholders() {
return _impl_.placeholders_.Add();
}
inline ::milvus::proto::common::PlaceholderValue* PlaceholderGroup::add_placeholders() {
::milvus::proto::common::PlaceholderValue* _add = _internal_add_placeholders();
// @@protoc_insertion_point(field_add:milvus.proto.common.PlaceholderGroup.placeholders)
return _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 _impl_.placeholders_;
}
// -------------------------------------------------------------------
// Address
// string ip = 1;
inline void Address::clear_ip() {
_impl_.ip_.ClearToEmpty();
}
inline const std::string& Address::ip() const {
// @@protoc_insertion_point(field_get:milvus.proto.common.Address.ip)
return _internal_ip();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Address::set_ip(ArgT0&& arg0, ArgT... args) {
_impl_.ip_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:milvus.proto.common.Address.ip)
}
inline std::string* Address::mutable_ip() {
std::string* _s = _internal_mutable_ip();
// @@protoc_insertion_point(field_mutable:milvus.proto.common.Address.ip)
return _s;
}
inline const std::string& Address::_internal_ip() const {
return _impl_.ip_.Get();
}
inline void Address::_internal_set_ip(const std::string& value) {
_impl_.ip_.Set(value, GetArenaForAllocation());
}
inline std::string* Address::_internal_mutable_ip() {
return _impl_.ip_.Mutable(GetArenaForAllocation());
}
inline std::string* Address::release_ip() {
// @@protoc_insertion_point(field_release:milvus.proto.common.Address.ip)
return _impl_.ip_.Release();
}
inline void Address::set_allocated_ip(std::string* ip) {
if (ip != nullptr) {
} else {
}
_impl_.ip_.SetAllocated(ip, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (_impl_.ip_.IsDefault()) {
_impl_.ip_.Set("", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:milvus.proto.common.Address.ip)
}
// int64 port = 2;
inline void Address::clear_port() {
_impl_.port_ = int64_t{0};
}
inline int64_t Address::_internal_port() const {
return _impl_.port_;
}
inline int64_t Address::port() const {
// @@protoc_insertion_point(field_get:milvus.proto.common.Address.port)
return _internal_port();
}
inline void Address::_internal_set_port(int64_t value) {
_impl_.port_ = value;
}
inline void Address::set_port(int64_t value) {
_internal_set_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() {
_impl_.msg_type_ = 0;
}
inline ::milvus::proto::common::MsgType MsgBase::_internal_msg_type() const {
return static_cast< ::milvus::proto::common::MsgType >(_impl_.msg_type_);
}
inline ::milvus::proto::common::MsgType MsgBase::msg_type() const {
// @@protoc_insertion_point(field_get:milvus.proto.common.MsgBase.msg_type)
return _internal_msg_type();
}
inline void MsgBase::_internal_set_msg_type(::milvus::proto::common::MsgType value) {
_impl_.msg_type_ = value;
}
inline void MsgBase::set_msg_type(::milvus::proto::common::MsgType value) {
_internal_set_msg_type(value);
// @@protoc_insertion_point(field_set:milvus.proto.common.MsgBase.msg_type)
}
// int64 msgID = 2;
inline void MsgBase::clear_msgid() {
_impl_.msgid_ = int64_t{0};
}
inline int64_t MsgBase::_internal_msgid() const {
return _impl_.msgid_;
}
inline int64_t MsgBase::msgid() const {
// @@protoc_insertion_point(field_get:milvus.proto.common.MsgBase.msgID)
return _internal_msgid();
}
inline void MsgBase::_internal_set_msgid(int64_t value) {
_impl_.msgid_ = value;
}
inline void MsgBase::set_msgid(int64_t value) {
_internal_set_msgid(value);
// @@protoc_insertion_point(field_set:milvus.proto.common.MsgBase.msgID)
}
// uint64 timestamp = 3;
inline void MsgBase::clear_timestamp() {
_impl_.timestamp_ = uint64_t{0u};
}
inline uint64_t MsgBase::_internal_timestamp() const {
return _impl_.timestamp_;
}
inline uint64_t MsgBase::timestamp() const {
// @@protoc_insertion_point(field_get:milvus.proto.common.MsgBase.timestamp)
return _internal_timestamp();
}
inline void MsgBase::_internal_set_timestamp(uint64_t value) {
_impl_.timestamp_ = value;
}
inline void MsgBase::set_timestamp(uint64_t value) {
_internal_set_timestamp(value);
// @@protoc_insertion_point(field_set:milvus.proto.common.MsgBase.timestamp)
}
// int64 sourceID = 4;
inline void MsgBase::clear_sourceid() {
_impl_.sourceid_ = int64_t{0};
}
inline int64_t MsgBase::_internal_sourceid() const {
return _impl_.sourceid_;
}
inline int64_t MsgBase::sourceid() const {
// @@protoc_insertion_point(field_get:milvus.proto.common.MsgBase.sourceID)
return _internal_sourceid();
}
inline void MsgBase::_internal_set_sourceid(int64_t value) {
_impl_.sourceid_ = value;
}
inline void MsgBase::set_sourceid(int64_t value) {
_internal_set_sourceid(value);
// @@protoc_insertion_point(field_set:milvus.proto.common.MsgBase.sourceID)
}
// int64 targetID = 5;
inline void MsgBase::clear_targetid() {
_impl_.targetid_ = int64_t{0};
}
inline int64_t MsgBase::_internal_targetid() const {
return _impl_.targetid_;
}
inline int64_t MsgBase::targetid() const {
// @@protoc_insertion_point(field_get:milvus.proto.common.MsgBase.targetID)
return _internal_targetid();
}
inline void MsgBase::_internal_set_targetid(int64_t value) {
_impl_.targetid_ = value;
}
inline void MsgBase::set_targetid(int64_t value) {
_internal_set_targetid(value);
// @@protoc_insertion_point(field_set:milvus.proto.common.MsgBase.targetID)
}
// -------------------------------------------------------------------
// MsgHeader
// .milvus.proto.common.MsgBase base = 1;
inline bool MsgHeader::_internal_has_base() const {
return this != internal_default_instance() && _impl_.base_ != nullptr;
}
inline bool MsgHeader::has_base() const {
return _internal_has_base();
}
inline void MsgHeader::clear_base() {
if (GetArenaForAllocation() == nullptr && _impl_.base_ != nullptr) {
delete _impl_.base_;
}
_impl_.base_ = nullptr;
}
inline const ::milvus::proto::common::MsgBase& MsgHeader::_internal_base() const {
const ::milvus::proto::common::MsgBase* p = _impl_.base_;
return p != nullptr ? *p : reinterpret_cast<const ::milvus::proto::common::MsgBase&>(
::milvus::proto::common::_MsgBase_default_instance_);
}
inline const ::milvus::proto::common::MsgBase& MsgHeader::base() const {
// @@protoc_insertion_point(field_get:milvus.proto.common.MsgHeader.base)
return _internal_base();
}
inline void MsgHeader::unsafe_arena_set_allocated_base(
::milvus::proto::common::MsgBase* base) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.base_);
}
_impl_.base_ = base;
if (base) {
} else {
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:milvus.proto.common.MsgHeader.base)
}
inline ::milvus::proto::common::MsgBase* MsgHeader::release_base() {
::milvus::proto::common::MsgBase* temp = _impl_.base_;
_impl_.base_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::milvus::proto::common::MsgBase* MsgHeader::unsafe_arena_release_base() {
// @@protoc_insertion_point(field_release:milvus.proto.common.MsgHeader.base)
::milvus::proto::common::MsgBase* temp = _impl_.base_;
_impl_.base_ = nullptr;
return temp;
}
inline ::milvus::proto::common::MsgBase* MsgHeader::_internal_mutable_base() {
if (_impl_.base_ == nullptr) {
auto* p = CreateMaybeMessage<::milvus::proto::common::MsgBase>(GetArenaForAllocation());
_impl_.base_ = p;
}
return _impl_.base_;
}
inline ::milvus::proto::common::MsgBase* MsgHeader::mutable_base() {
::milvus::proto::common::MsgBase* _msg = _internal_mutable_base();
// @@protoc_insertion_point(field_mutable:milvus.proto.common.MsgHeader.base)
return _msg;
}
inline void MsgHeader::set_allocated_base(::milvus::proto::common::MsgBase* base) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete _impl_.base_;
}
if (base) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(base);
if (message_arena != submessage_arena) {
base = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, base, submessage_arena);
}
} else {
}
_impl_.base_ = base;
// @@protoc_insertion_point(field_set_allocated:milvus.proto.common.MsgHeader.base)
}
// -------------------------------------------------------------------
// DMLMsgHeader
// .milvus.proto.common.MsgBase base = 1;
inline bool DMLMsgHeader::_internal_has_base() const {
return this != internal_default_instance() && _impl_.base_ != nullptr;
}
inline bool DMLMsgHeader::has_base() const {
return _internal_has_base();
}
inline void DMLMsgHeader::clear_base() {
if (GetArenaForAllocation() == nullptr && _impl_.base_ != nullptr) {
delete _impl_.base_;
}
_impl_.base_ = nullptr;
}
inline const ::milvus::proto::common::MsgBase& DMLMsgHeader::_internal_base() const {
const ::milvus::proto::common::MsgBase* p = _impl_.base_;
return p != nullptr ? *p : reinterpret_cast<const ::milvus::proto::common::MsgBase&>(
::milvus::proto::common::_MsgBase_default_instance_);
}
inline const ::milvus::proto::common::MsgBase& DMLMsgHeader::base() const {
// @@protoc_insertion_point(field_get:milvus.proto.common.DMLMsgHeader.base)
return _internal_base();
}
inline void DMLMsgHeader::unsafe_arena_set_allocated_base(
::milvus::proto::common::MsgBase* base) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.base_);
}
_impl_.base_ = base;
if (base) {
} else {
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:milvus.proto.common.DMLMsgHeader.base)
}
inline ::milvus::proto::common::MsgBase* DMLMsgHeader::release_base() {
::milvus::proto::common::MsgBase* temp = _impl_.base_;
_impl_.base_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::milvus::proto::common::MsgBase* DMLMsgHeader::unsafe_arena_release_base() {
// @@protoc_insertion_point(field_release:milvus.proto.common.DMLMsgHeader.base)
::milvus::proto::common::MsgBase* temp = _impl_.base_;
_impl_.base_ = nullptr;
return temp;
}
inline ::milvus::proto::common::MsgBase* DMLMsgHeader::_internal_mutable_base() {
if (_impl_.base_ == nullptr) {
auto* p = CreateMaybeMessage<::milvus::proto::common::MsgBase>(GetArenaForAllocation());
_impl_.base_ = p;
}
return _impl_.base_;
}
inline ::milvus::proto::common::MsgBase* DMLMsgHeader::mutable_base() {
::milvus::proto::common::MsgBase* _msg = _internal_mutable_base();
// @@protoc_insertion_point(field_mutable:milvus.proto.common.DMLMsgHeader.base)
return _msg;
}
inline void DMLMsgHeader::set_allocated_base(::milvus::proto::common::MsgBase* base) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete _impl_.base_;
}
if (base) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(base);
if (message_arena != submessage_arena) {
base = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, base, submessage_arena);
}
} else {
}
_impl_.base_ = base;
// @@protoc_insertion_point(field_set_allocated:milvus.proto.common.DMLMsgHeader.base)
}
// string shardName = 2;
inline void DMLMsgHeader::clear_shardname() {
_impl_.shardname_.ClearToEmpty();
}
inline const std::string& DMLMsgHeader::shardname() const {
// @@protoc_insertion_point(field_get:milvus.proto.common.DMLMsgHeader.shardName)
return _internal_shardname();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void DMLMsgHeader::set_shardname(ArgT0&& arg0, ArgT... args) {
_impl_.shardname_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:milvus.proto.common.DMLMsgHeader.shardName)
}
inline std::string* DMLMsgHeader::mutable_shardname() {
std::string* _s = _internal_mutable_shardname();
// @@protoc_insertion_point(field_mutable:milvus.proto.common.DMLMsgHeader.shardName)
return _s;
}
inline const std::string& DMLMsgHeader::_internal_shardname() const {
return _impl_.shardname_.Get();
}
inline void DMLMsgHeader::_internal_set_shardname(const std::string& value) {
_impl_.shardname_.Set(value, GetArenaForAllocation());
}
inline std::string* DMLMsgHeader::_internal_mutable_shardname() {
return _impl_.shardname_.Mutable(GetArenaForAllocation());
}
inline std::string* DMLMsgHeader::release_shardname() {
// @@protoc_insertion_point(field_release:milvus.proto.common.DMLMsgHeader.shardName)
return _impl_.shardname_.Release();
}
inline void DMLMsgHeader::set_allocated_shardname(std::string* shardname) {
if (shardname != nullptr) {
} else {
}
_impl_.shardname_.SetAllocated(shardname, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (_impl_.shardname_.IsDefault()) {
_impl_.shardname_.Set("", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:milvus.proto.common.DMLMsgHeader.shardName)
}
// -------------------------------------------------------------------
// PrivilegeExt
// .milvus.proto.common.ObjectType object_type = 1;
inline void PrivilegeExt::clear_object_type() {
_impl_.object_type_ = 0;
}
inline ::milvus::proto::common::ObjectType PrivilegeExt::_internal_object_type() const {
return static_cast< ::milvus::proto::common::ObjectType >(_impl_.object_type_);
}
inline ::milvus::proto::common::ObjectType PrivilegeExt::object_type() const {
// @@protoc_insertion_point(field_get:milvus.proto.common.PrivilegeExt.object_type)
return _internal_object_type();
}
inline void PrivilegeExt::_internal_set_object_type(::milvus::proto::common::ObjectType value) {
_impl_.object_type_ = value;
}
inline void PrivilegeExt::set_object_type(::milvus::proto::common::ObjectType value) {
_internal_set_object_type(value);
// @@protoc_insertion_point(field_set:milvus.proto.common.PrivilegeExt.object_type)
}
// .milvus.proto.common.ObjectPrivilege object_privilege = 2;
inline void PrivilegeExt::clear_object_privilege() {
_impl_.object_privilege_ = 0;
}
inline ::milvus::proto::common::ObjectPrivilege PrivilegeExt::_internal_object_privilege() const {
return static_cast< ::milvus::proto::common::ObjectPrivilege >(_impl_.object_privilege_);
}
inline ::milvus::proto::common::ObjectPrivilege PrivilegeExt::object_privilege() const {
// @@protoc_insertion_point(field_get:milvus.proto.common.PrivilegeExt.object_privilege)
return _internal_object_privilege();
}
inline void PrivilegeExt::_internal_set_object_privilege(::milvus::proto::common::ObjectPrivilege value) {
_impl_.object_privilege_ = value;
}
inline void PrivilegeExt::set_object_privilege(::milvus::proto::common::ObjectPrivilege value) {
_internal_set_object_privilege(value);
// @@protoc_insertion_point(field_set:milvus.proto.common.PrivilegeExt.object_privilege)
}
// int32 object_name_index = 3;
inline void PrivilegeExt::clear_object_name_index() {
_impl_.object_name_index_ = 0;
}
inline int32_t PrivilegeExt::_internal_object_name_index() const {
return _impl_.object_name_index_;
}
inline int32_t PrivilegeExt::object_name_index() const {
// @@protoc_insertion_point(field_get:milvus.proto.common.PrivilegeExt.object_name_index)
return _internal_object_name_index();
}
inline void PrivilegeExt::_internal_set_object_name_index(int32_t value) {
_impl_.object_name_index_ = value;
}
inline void PrivilegeExt::set_object_name_index(int32_t value) {
_internal_set_object_name_index(value);
// @@protoc_insertion_point(field_set:milvus.proto.common.PrivilegeExt.object_name_index)
}
// int32 object_name_indexs = 4;
inline void PrivilegeExt::clear_object_name_indexs() {
_impl_.object_name_indexs_ = 0;
}
inline int32_t PrivilegeExt::_internal_object_name_indexs() const {
return _impl_.object_name_indexs_;
}
inline int32_t PrivilegeExt::object_name_indexs() const {
// @@protoc_insertion_point(field_get:milvus.proto.common.PrivilegeExt.object_name_indexs)
return _internal_object_name_indexs();
}
inline void PrivilegeExt::_internal_set_object_name_indexs(int32_t value) {
_impl_.object_name_indexs_ = value;
}
inline void PrivilegeExt::set_object_name_indexs(int32_t value) {
_internal_set_object_name_indexs(value);
// @@protoc_insertion_point(field_set:milvus.proto.common.PrivilegeExt.object_name_indexs)
}
// -------------------------------------------------------------------
// SegmentStats
// int64 SegmentID = 1;
inline void SegmentStats::clear_segmentid() {
_impl_.segmentid_ = int64_t{0};
}
inline int64_t SegmentStats::_internal_segmentid() const {
return _impl_.segmentid_;
}
inline int64_t SegmentStats::segmentid() const {
// @@protoc_insertion_point(field_get:milvus.proto.common.SegmentStats.SegmentID)
return _internal_segmentid();
}
inline void SegmentStats::_internal_set_segmentid(int64_t value) {
_impl_.segmentid_ = value;
}
inline void SegmentStats::set_segmentid(int64_t value) {
_internal_set_segmentid(value);
// @@protoc_insertion_point(field_set:milvus.proto.common.SegmentStats.SegmentID)
}
// int64 NumRows = 2;
inline void SegmentStats::clear_numrows() {
_impl_.numrows_ = int64_t{0};
}
inline int64_t SegmentStats::_internal_numrows() const {
return _impl_.numrows_;
}
inline int64_t SegmentStats::numrows() const {
// @@protoc_insertion_point(field_get:milvus.proto.common.SegmentStats.NumRows)
return _internal_numrows();
}
inline void SegmentStats::_internal_set_numrows(int64_t value) {
_impl_.numrows_ = value;
}
inline void SegmentStats::set_numrows(int64_t value) {
_internal_set_numrows(value);
// @@protoc_insertion_point(field_set:milvus.proto.common.SegmentStats.NumRows)
}
#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::ObjectType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::milvus::proto::common::ObjectType>() {
return ::milvus::proto::common::ObjectType_descriptor();
}
template <> struct is_proto_enum< ::milvus::proto::common::ObjectPrivilege> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::milvus::proto::common::ObjectPrivilege>() {
return ::milvus::proto::common::ObjectPrivilege_descriptor();
}
template <> struct is_proto_enum< ::milvus::proto::common::StateCode> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::milvus::proto::common::StateCode>() {
return ::milvus::proto::common::StateCode_descriptor();
}
template <> struct is_proto_enum< ::milvus::proto::common::LoadState> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::milvus::proto::common::LoadState>() {
return ::milvus::proto::common::LoadState_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