potok/opencv
1
0
Fork 0
mirror of https://github.com/opencv/opencv.git synced 2026-07-31 00:03:03 +04:00
Code Packages Releases Wiki Activity
Files
5.x
opencv/modules/dnn/misc/onnx/opencv-onnx.pb.h
T
nklskyoy 7a2f2a985f Merge pull request #27449 from nklskyoy:onnx-multifile 
Onnx multifile import #27449

Merge with https://github.com/opencv/opencv_extra/pull/1259

LLMs are larger than 2GB and don't fit into single file onnx. this patch adds support for importing large onnx models with external data

updated `opencv-onnx.proto` to version 1.18.0 [(https://github.com/onnx/onnx/releases/tag/v1.18.0](https://github.com/onnx/onnx/blob/v1.18.0/onnx/onnx.proto)

### Pull Request Readiness Checklist

See details at https://github.com/opencv/opencv/wiki/How_to_contribute#making-a-good-pull-request

- [x] I agree to contribute to the project under Apache 2 License.
- [x] To the best of my knowledge, the proposed patch is not based on a code under GPL or another license that is incompatible with OpenCV
- [x] The PR is proposed to the proper branch
- [ ] There is a reference to the original bug report and related work
- [x] There is accuracy test, performance test and test data in opencv_extra repository, if applicable
      Patch to opencv_extra has the same branch name.
- [ ] The feature is well documented and sample code can be built with the project CMake
2025-07-16 16:50:32 +03:00

14178 lines
546 KiB
C++
Raw Permalink Blame History

// Generated by the protocol buffer compiler. DO NOT EDIT!
// source: opencv-onnx.proto
#ifndef GOOGLE_PROTOBUF_INCLUDED_opencv_2donnx_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_opencv_2donnx_2eproto
#include <limits>
#include <string>
#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3019000
#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 3019004 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif
#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/message_lite.h>
#include <google/protobuf/repeated_field.h> // IWYU pragma: export
#include <google/protobuf/extension_set.h> // IWYU pragma: export
#include <google/protobuf/generated_enum_util.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_opencv_2donnx_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
} // namespace internal
PROTOBUF_NAMESPACE_CLOSE
// Internal implementation detail -- do not use these members.
struct TableStruct_opencv_2donnx_2eproto {
static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
PROTOBUF_SECTION_VARIABLE(protodesc_cold);
static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
PROTOBUF_SECTION_VARIABLE(protodesc_cold);
static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[27]
PROTOBUF_SECTION_VARIABLE(protodesc_cold);
static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
static const uint32_t offsets[];
};
namespace opencv_onnx {
class AttributeProto;
struct AttributeProtoDefaultTypeInternal;
extern AttributeProtoDefaultTypeInternal _AttributeProto_default_instance_;
class DeviceConfigurationProto;
struct DeviceConfigurationProtoDefaultTypeInternal;
extern DeviceConfigurationProtoDefaultTypeInternal _DeviceConfigurationProto_default_instance_;
class FunctionProto;
struct FunctionProtoDefaultTypeInternal;
extern FunctionProtoDefaultTypeInternal _FunctionProto_default_instance_;
class GraphProto;
struct GraphProtoDefaultTypeInternal;
extern GraphProtoDefaultTypeInternal _GraphProto_default_instance_;
class IntIntListEntryProto;
struct IntIntListEntryProtoDefaultTypeInternal;
extern IntIntListEntryProtoDefaultTypeInternal _IntIntListEntryProto_default_instance_;
class ModelProto;
struct ModelProtoDefaultTypeInternal;
extern ModelProtoDefaultTypeInternal _ModelProto_default_instance_;
class NodeDeviceConfigurationProto;
struct NodeDeviceConfigurationProtoDefaultTypeInternal;
extern NodeDeviceConfigurationProtoDefaultTypeInternal _NodeDeviceConfigurationProto_default_instance_;
class NodeProto;
struct NodeProtoDefaultTypeInternal;
extern NodeProtoDefaultTypeInternal _NodeProto_default_instance_;
class OperatorSetIdProto;
struct OperatorSetIdProtoDefaultTypeInternal;
extern OperatorSetIdProtoDefaultTypeInternal _OperatorSetIdProto_default_instance_;
class ShardedDimProto;
struct ShardedDimProtoDefaultTypeInternal;
extern ShardedDimProtoDefaultTypeInternal _ShardedDimProto_default_instance_;
class ShardingSpecProto;
struct ShardingSpecProtoDefaultTypeInternal;
extern ShardingSpecProtoDefaultTypeInternal _ShardingSpecProto_default_instance_;
class SimpleShardedDimProto;
struct SimpleShardedDimProtoDefaultTypeInternal;
extern SimpleShardedDimProtoDefaultTypeInternal _SimpleShardedDimProto_default_instance_;
class SparseTensorProto;
struct SparseTensorProtoDefaultTypeInternal;
extern SparseTensorProtoDefaultTypeInternal _SparseTensorProto_default_instance_;
class StringStringEntryProto;
struct StringStringEntryProtoDefaultTypeInternal;
extern StringStringEntryProtoDefaultTypeInternal _StringStringEntryProto_default_instance_;
class TensorAnnotation;
struct TensorAnnotationDefaultTypeInternal;
extern TensorAnnotationDefaultTypeInternal _TensorAnnotation_default_instance_;
class TensorProto;
struct TensorProtoDefaultTypeInternal;
extern TensorProtoDefaultTypeInternal _TensorProto_default_instance_;
class TensorProto_Segment;
struct TensorProto_SegmentDefaultTypeInternal;
extern TensorProto_SegmentDefaultTypeInternal _TensorProto_Segment_default_instance_;
class TensorShapeProto;
struct TensorShapeProtoDefaultTypeInternal;
extern TensorShapeProtoDefaultTypeInternal _TensorShapeProto_default_instance_;
class TensorShapeProto_Dimension;
struct TensorShapeProto_DimensionDefaultTypeInternal;
extern TensorShapeProto_DimensionDefaultTypeInternal _TensorShapeProto_Dimension_default_instance_;
class TrainingInfoProto;
struct TrainingInfoProtoDefaultTypeInternal;
extern TrainingInfoProtoDefaultTypeInternal _TrainingInfoProto_default_instance_;
class TypeProto;
struct TypeProtoDefaultTypeInternal;
extern TypeProtoDefaultTypeInternal _TypeProto_default_instance_;
class TypeProto_Map;
struct TypeProto_MapDefaultTypeInternal;
extern TypeProto_MapDefaultTypeInternal _TypeProto_Map_default_instance_;
class TypeProto_Optional;
struct TypeProto_OptionalDefaultTypeInternal;
extern TypeProto_OptionalDefaultTypeInternal _TypeProto_Optional_default_instance_;
class TypeProto_Sequence;
struct TypeProto_SequenceDefaultTypeInternal;
extern TypeProto_SequenceDefaultTypeInternal _TypeProto_Sequence_default_instance_;
class TypeProto_SparseTensor;
struct TypeProto_SparseTensorDefaultTypeInternal;
extern TypeProto_SparseTensorDefaultTypeInternal _TypeProto_SparseTensor_default_instance_;
class TypeProto_Tensor;
struct TypeProto_TensorDefaultTypeInternal;
extern TypeProto_TensorDefaultTypeInternal _TypeProto_Tensor_default_instance_;
class ValueInfoProto;
struct ValueInfoProtoDefaultTypeInternal;
extern ValueInfoProtoDefaultTypeInternal _ValueInfoProto_default_instance_;
} // namespace opencv_onnx
PROTOBUF_NAMESPACE_OPEN
template<> ::opencv_onnx::AttributeProto* Arena::CreateMaybeMessage<::opencv_onnx::AttributeProto>(Arena*);
template<> ::opencv_onnx::DeviceConfigurationProto* Arena::CreateMaybeMessage<::opencv_onnx::DeviceConfigurationProto>(Arena*);
template<> ::opencv_onnx::FunctionProto* Arena::CreateMaybeMessage<::opencv_onnx::FunctionProto>(Arena*);
template<> ::opencv_onnx::GraphProto* Arena::CreateMaybeMessage<::opencv_onnx::GraphProto>(Arena*);
template<> ::opencv_onnx::IntIntListEntryProto* Arena::CreateMaybeMessage<::opencv_onnx::IntIntListEntryProto>(Arena*);
template<> ::opencv_onnx::ModelProto* Arena::CreateMaybeMessage<::opencv_onnx::ModelProto>(Arena*);
template<> ::opencv_onnx::NodeDeviceConfigurationProto* Arena::CreateMaybeMessage<::opencv_onnx::NodeDeviceConfigurationProto>(Arena*);
template<> ::opencv_onnx::NodeProto* Arena::CreateMaybeMessage<::opencv_onnx::NodeProto>(Arena*);
template<> ::opencv_onnx::OperatorSetIdProto* Arena::CreateMaybeMessage<::opencv_onnx::OperatorSetIdProto>(Arena*);
template<> ::opencv_onnx::ShardedDimProto* Arena::CreateMaybeMessage<::opencv_onnx::ShardedDimProto>(Arena*);
template<> ::opencv_onnx::ShardingSpecProto* Arena::CreateMaybeMessage<::opencv_onnx::ShardingSpecProto>(Arena*);
template<> ::opencv_onnx::SimpleShardedDimProto* Arena::CreateMaybeMessage<::opencv_onnx::SimpleShardedDimProto>(Arena*);
template<> ::opencv_onnx::SparseTensorProto* Arena::CreateMaybeMessage<::opencv_onnx::SparseTensorProto>(Arena*);
template<> ::opencv_onnx::StringStringEntryProto* Arena::CreateMaybeMessage<::opencv_onnx::StringStringEntryProto>(Arena*);
template<> ::opencv_onnx::TensorAnnotation* Arena::CreateMaybeMessage<::opencv_onnx::TensorAnnotation>(Arena*);
template<> ::opencv_onnx::TensorProto* Arena::CreateMaybeMessage<::opencv_onnx::TensorProto>(Arena*);
template<> ::opencv_onnx::TensorProto_Segment* Arena::CreateMaybeMessage<::opencv_onnx::TensorProto_Segment>(Arena*);
template<> ::opencv_onnx::TensorShapeProto* Arena::CreateMaybeMessage<::opencv_onnx::TensorShapeProto>(Arena*);
template<> ::opencv_onnx::TensorShapeProto_Dimension* Arena::CreateMaybeMessage<::opencv_onnx::TensorShapeProto_Dimension>(Arena*);
template<> ::opencv_onnx::TrainingInfoProto* Arena::CreateMaybeMessage<::opencv_onnx::TrainingInfoProto>(Arena*);
template<> ::opencv_onnx::TypeProto* Arena::CreateMaybeMessage<::opencv_onnx::TypeProto>(Arena*);
template<> ::opencv_onnx::TypeProto_Map* Arena::CreateMaybeMessage<::opencv_onnx::TypeProto_Map>(Arena*);
template<> ::opencv_onnx::TypeProto_Optional* Arena::CreateMaybeMessage<::opencv_onnx::TypeProto_Optional>(Arena*);
template<> ::opencv_onnx::TypeProto_Sequence* Arena::CreateMaybeMessage<::opencv_onnx::TypeProto_Sequence>(Arena*);
template<> ::opencv_onnx::TypeProto_SparseTensor* Arena::CreateMaybeMessage<::opencv_onnx::TypeProto_SparseTensor>(Arena*);
template<> ::opencv_onnx::TypeProto_Tensor* Arena::CreateMaybeMessage<::opencv_onnx::TypeProto_Tensor>(Arena*);
template<> ::opencv_onnx::ValueInfoProto* Arena::CreateMaybeMessage<::opencv_onnx::ValueInfoProto>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace opencv_onnx {
enum AttributeProto_AttributeType : int {
AttributeProto_AttributeType_UNDEFINED = 0,
AttributeProto_AttributeType_FLOAT = 1,
AttributeProto_AttributeType_INT = 2,
AttributeProto_AttributeType_STRING = 3,
AttributeProto_AttributeType_TENSOR = 4,
AttributeProto_AttributeType_GRAPH = 5,
AttributeProto_AttributeType_SPARSE_TENSOR = 11,
AttributeProto_AttributeType_TYPE_PROTO = 13,
AttributeProto_AttributeType_FLOATS = 6,
AttributeProto_AttributeType_INTS = 7,
AttributeProto_AttributeType_STRINGS = 8,
AttributeProto_AttributeType_TENSORS = 9,
AttributeProto_AttributeType_GRAPHS = 10,
AttributeProto_AttributeType_SPARSE_TENSORS = 12,
AttributeProto_AttributeType_TYPE_PROTOS = 14
};
bool AttributeProto_AttributeType_IsValid(int value);
constexpr AttributeProto_AttributeType AttributeProto_AttributeType_AttributeType_MIN = AttributeProto_AttributeType_UNDEFINED;
constexpr AttributeProto_AttributeType AttributeProto_AttributeType_AttributeType_MAX = AttributeProto_AttributeType_TYPE_PROTOS;
constexpr int AttributeProto_AttributeType_AttributeType_ARRAYSIZE = AttributeProto_AttributeType_AttributeType_MAX + 1;
const std::string& AttributeProto_AttributeType_Name(AttributeProto_AttributeType value);
template<typename T>
inline const std::string& AttributeProto_AttributeType_Name(T enum_t_value) {
static_assert(::std::is_same<T, AttributeProto_AttributeType>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function AttributeProto_AttributeType_Name.");
return AttributeProto_AttributeType_Name(static_cast<AttributeProto_AttributeType>(enum_t_value));
}
bool AttributeProto_AttributeType_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, AttributeProto_AttributeType* value);
enum TensorProto_DataType : int {
TensorProto_DataType_UNDEFINED = 0,
TensorProto_DataType_FLOAT = 1,
TensorProto_DataType_UINT8 = 2,
TensorProto_DataType_INT8 = 3,
TensorProto_DataType_UINT16 = 4,
TensorProto_DataType_INT16 = 5,
TensorProto_DataType_INT32 = 6,
TensorProto_DataType_INT64 = 7,
TensorProto_DataType_STRING = 8,
TensorProto_DataType_BOOL = 9,
TensorProto_DataType_FLOAT16 = 10,
TensorProto_DataType_DOUBLE = 11,
TensorProto_DataType_UINT32 = 12,
TensorProto_DataType_UINT64 = 13,
TensorProto_DataType_COMPLEX64 = 14,
TensorProto_DataType_COMPLEX128 = 15,
TensorProto_DataType_BFLOAT16 = 16,
TensorProto_DataType_FLOAT8E4M3FN = 17,
TensorProto_DataType_FLOAT8E4M3FNUZ = 18,
TensorProto_DataType_FLOAT8E5M2 = 19,
TensorProto_DataType_FLOAT8E5M2FNUZ = 20,
TensorProto_DataType_UINT4 = 21,
TensorProto_DataType_INT4 = 22,
TensorProto_DataType_FLOAT4E2M1 = 23
};
bool TensorProto_DataType_IsValid(int value);
constexpr TensorProto_DataType TensorProto_DataType_DataType_MIN = TensorProto_DataType_UNDEFINED;
constexpr TensorProto_DataType TensorProto_DataType_DataType_MAX = TensorProto_DataType_FLOAT4E2M1;
constexpr int TensorProto_DataType_DataType_ARRAYSIZE = TensorProto_DataType_DataType_MAX + 1;
const std::string& TensorProto_DataType_Name(TensorProto_DataType value);
template<typename T>
inline const std::string& TensorProto_DataType_Name(T enum_t_value) {
static_assert(::std::is_same<T, TensorProto_DataType>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function TensorProto_DataType_Name.");
return TensorProto_DataType_Name(static_cast<TensorProto_DataType>(enum_t_value));
}
bool TensorProto_DataType_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, TensorProto_DataType* value);
enum TensorProto_DataLocation : int {
TensorProto_DataLocation_DEFAULT = 0,
TensorProto_DataLocation_EXTERNAL = 1
};
bool TensorProto_DataLocation_IsValid(int value);
constexpr TensorProto_DataLocation TensorProto_DataLocation_DataLocation_MIN = TensorProto_DataLocation_DEFAULT;
constexpr TensorProto_DataLocation TensorProto_DataLocation_DataLocation_MAX = TensorProto_DataLocation_EXTERNAL;
constexpr int TensorProto_DataLocation_DataLocation_ARRAYSIZE = TensorProto_DataLocation_DataLocation_MAX + 1;
const std::string& TensorProto_DataLocation_Name(TensorProto_DataLocation value);
template<typename T>
inline const std::string& TensorProto_DataLocation_Name(T enum_t_value) {
static_assert(::std::is_same<T, TensorProto_DataLocation>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function TensorProto_DataLocation_Name.");
return TensorProto_DataLocation_Name(static_cast<TensorProto_DataLocation>(enum_t_value));
}
bool TensorProto_DataLocation_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, TensorProto_DataLocation* value);
enum Version : int {
_START_VERSION = 0,
IR_VERSION_2017_10_10 = 1,
IR_VERSION_2017_10_30 = 2,
IR_VERSION_2017_11_3 = 3,
IR_VERSION_2019_1_22 = 4,
IR_VERSION_2019_3_18 = 5,
IR_VERSION_2019_9_19 = 6,
IR_VERSION_2020_5_8 = 7,
IR_VERSION_2021_7_30 = 8,
IR_VERSION_2023_5_5 = 9,
IR_VERSION_2024_3_25 = 10,
IR_VERSION = 11
};
bool Version_IsValid(int value);
constexpr Version Version_MIN = _START_VERSION;
constexpr Version Version_MAX = IR_VERSION;
constexpr int Version_ARRAYSIZE = Version_MAX + 1;
const std::string& Version_Name(Version value);
template<typename T>
inline const std::string& Version_Name(T enum_t_value) {
static_assert(::std::is_same<T, Version>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function Version_Name.");
return Version_Name(static_cast<Version>(enum_t_value));
}
bool Version_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Version* value);
enum OperatorStatus : int {
EXPERIMENTAL = 0,
STABLE = 1
};
bool OperatorStatus_IsValid(int value);
constexpr OperatorStatus OperatorStatus_MIN = EXPERIMENTAL;
constexpr OperatorStatus OperatorStatus_MAX = STABLE;
constexpr int OperatorStatus_ARRAYSIZE = OperatorStatus_MAX + 1;
const std::string& OperatorStatus_Name(OperatorStatus value);
template<typename T>
inline const std::string& OperatorStatus_Name(T enum_t_value) {
static_assert(::std::is_same<T, OperatorStatus>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function OperatorStatus_Name.");
return OperatorStatus_Name(static_cast<OperatorStatus>(enum_t_value));
}
bool OperatorStatus_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, OperatorStatus* value);
// ===================================================================
class AttributeProto final :
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:opencv_onnx.AttributeProto) */ {
public:
inline AttributeProto() : AttributeProto(nullptr) {}
~AttributeProto() override;
explicit constexpr AttributeProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
AttributeProto(const AttributeProto& from);
AttributeProto(AttributeProto&& from) noexcept
: AttributeProto() {
*this = ::std::move(from);
}
inline AttributeProto& operator=(const AttributeProto& from) {
CopyFrom(from);
return *this;
}
inline AttributeProto& operator=(AttributeProto&& 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;
}
inline const std::string& unknown_fields() const {
return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
}
inline std::string* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<std::string>();
}
static const AttributeProto& default_instance() {
return *internal_default_instance();
}
static inline const AttributeProto* internal_default_instance() {
return reinterpret_cast<const AttributeProto*>(
&_AttributeProto_default_instance_);
}
static constexpr int kIndexInFileMessages =
0;
friend void swap(AttributeProto& a, AttributeProto& b) {
a.Swap(&b);
}
inline void Swap(AttributeProto* 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(AttributeProto* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
AttributeProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<AttributeProto>(arena);
}
void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
void CopyFrom(const AttributeProto& from);
void MergeFrom(const AttributeProto& from);
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 _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const;
void InternalSwap(AttributeProto* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "opencv_onnx.AttributeProto";
}
protected:
explicit AttributeProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
std::string GetTypeName() const final;
// nested types ----------------------------------------------------
typedef AttributeProto_AttributeType AttributeType;
static constexpr AttributeType UNDEFINED =
AttributeProto_AttributeType_UNDEFINED;
static constexpr AttributeType FLOAT =
AttributeProto_AttributeType_FLOAT;
static constexpr AttributeType INT =
AttributeProto_AttributeType_INT;
static constexpr AttributeType STRING =
AttributeProto_AttributeType_STRING;
static constexpr AttributeType TENSOR =
AttributeProto_AttributeType_TENSOR;
static constexpr AttributeType GRAPH =
AttributeProto_AttributeType_GRAPH;
static constexpr AttributeType SPARSE_TENSOR =
AttributeProto_AttributeType_SPARSE_TENSOR;
static constexpr AttributeType TYPE_PROTO =
AttributeProto_AttributeType_TYPE_PROTO;
static constexpr AttributeType FLOATS =
AttributeProto_AttributeType_FLOATS;
static constexpr AttributeType INTS =
AttributeProto_AttributeType_INTS;
static constexpr AttributeType STRINGS =
AttributeProto_AttributeType_STRINGS;
static constexpr AttributeType TENSORS =
AttributeProto_AttributeType_TENSORS;
static constexpr AttributeType GRAPHS =
AttributeProto_AttributeType_GRAPHS;
static constexpr AttributeType SPARSE_TENSORS =
AttributeProto_AttributeType_SPARSE_TENSORS;
static constexpr AttributeType TYPE_PROTOS =
AttributeProto_AttributeType_TYPE_PROTOS;
static inline bool AttributeType_IsValid(int value) {
return AttributeProto_AttributeType_IsValid(value);
}
static constexpr AttributeType AttributeType_MIN =
AttributeProto_AttributeType_AttributeType_MIN;
static constexpr AttributeType AttributeType_MAX =
AttributeProto_AttributeType_AttributeType_MAX;
static constexpr int AttributeType_ARRAYSIZE =
AttributeProto_AttributeType_AttributeType_ARRAYSIZE;
template<typename T>
static inline const std::string& AttributeType_Name(T enum_t_value) {
static_assert(::std::is_same<T, AttributeType>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function AttributeType_Name.");
return AttributeProto_AttributeType_Name(enum_t_value);
}
static inline bool AttributeType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
AttributeType* value) {
return AttributeProto_AttributeType_Parse(name, value);
}
// accessors -------------------------------------------------------
enum : int {
kFloatsFieldNumber = 7,
kIntsFieldNumber = 8,
kStringsFieldNumber = 9,
kTensorsFieldNumber = 10,
kGraphsFieldNumber = 11,
kTypeProtosFieldNumber = 15,
kSparseTensorsFieldNumber = 23,
kNameFieldNumber = 1,
kSFieldNumber = 4,
kDocStringFieldNumber = 13,
kRefAttrNameFieldNumber = 21,
kTFieldNumber = 5,
kGFieldNumber = 6,
kTpFieldNumber = 14,
kSparseTensorFieldNumber = 22,
kIFieldNumber = 3,
kFFieldNumber = 2,
kTypeFieldNumber = 20,
};
// repeated float floats = 7;
int floats_size() const;
private:
int _internal_floats_size() const;
public:
void clear_floats();
private:
float _internal_floats(int index) const;
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
_internal_floats() const;
void _internal_add_floats(float value);
::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
_internal_mutable_floats();
public:
float floats(int index) const;
void set_floats(int index, float value);
void add_floats(float value);
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
floats() const;
::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
mutable_floats();
// repeated int64 ints = 8;
int ints_size() const;
private:
int _internal_ints_size() const;
public:
void clear_ints();
private:
int64_t _internal_ints(int index) const;
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
_internal_ints() const;
void _internal_add_ints(int64_t value);
::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
_internal_mutable_ints();
public:
int64_t ints(int index) const;
void set_ints(int index, int64_t value);
void add_ints(int64_t value);
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
ints() const;
::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
mutable_ints();
// repeated bytes strings = 9;
int strings_size() const;
private:
int _internal_strings_size() const;
public:
void clear_strings();
const std::string& strings(int index) const;
std::string* mutable_strings(int index);
void set_strings(int index, const std::string& value);
void set_strings(int index, std::string&& value);
void set_strings(int index, const char* value);
void set_strings(int index, const void* value, size_t size);
std::string* add_strings();
void add_strings(const std::string& value);
void add_strings(std::string&& value);
void add_strings(const char* value);
void add_strings(const void* value, size_t size);
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& strings() const;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_strings();
private:
const std::string& _internal_strings(int index) const;
std::string* _internal_add_strings();
public:
// repeated .opencv_onnx.TensorProto tensors = 10;
int tensors_size() const;
private:
int _internal_tensors_size() const;
public:
void clear_tensors();
::opencv_onnx::TensorProto* mutable_tensors(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::TensorProto >*
mutable_tensors();
private:
const ::opencv_onnx::TensorProto& _internal_tensors(int index) const;
::opencv_onnx::TensorProto* _internal_add_tensors();
public:
const ::opencv_onnx::TensorProto& tensors(int index) const;
::opencv_onnx::TensorProto* add_tensors();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::TensorProto >&
tensors() const;
// repeated .opencv_onnx.GraphProto graphs = 11;
int graphs_size() const;
private:
int _internal_graphs_size() const;
public:
void clear_graphs();
::opencv_onnx::GraphProto* mutable_graphs(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::GraphProto >*
mutable_graphs();
private:
const ::opencv_onnx::GraphProto& _internal_graphs(int index) const;
::opencv_onnx::GraphProto* _internal_add_graphs();
public:
const ::opencv_onnx::GraphProto& graphs(int index) const;
::opencv_onnx::GraphProto* add_graphs();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::GraphProto >&
graphs() const;
// repeated .opencv_onnx.TypeProto type_protos = 15;
int type_protos_size() const;
private:
int _internal_type_protos_size() const;
public:
void clear_type_protos();
::opencv_onnx::TypeProto* mutable_type_protos(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::TypeProto >*
mutable_type_protos();
private:
const ::opencv_onnx::TypeProto& _internal_type_protos(int index) const;
::opencv_onnx::TypeProto* _internal_add_type_protos();
public:
const ::opencv_onnx::TypeProto& type_protos(int index) const;
::opencv_onnx::TypeProto* add_type_protos();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::TypeProto >&
type_protos() const;
// repeated .opencv_onnx.SparseTensorProto sparse_tensors = 23;
int sparse_tensors_size() const;
private:
int _internal_sparse_tensors_size() const;
public:
void clear_sparse_tensors();
::opencv_onnx::SparseTensorProto* mutable_sparse_tensors(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::SparseTensorProto >*
mutable_sparse_tensors();
private:
const ::opencv_onnx::SparseTensorProto& _internal_sparse_tensors(int index) const;
::opencv_onnx::SparseTensorProto* _internal_add_sparse_tensors();
public:
const ::opencv_onnx::SparseTensorProto& sparse_tensors(int index) const;
::opencv_onnx::SparseTensorProto* add_sparse_tensors();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::SparseTensorProto >&
sparse_tensors() const;
// optional string name = 1;
bool has_name() const;
private:
bool _internal_has_name() const;
public:
void clear_name();
const std::string& name() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_name(ArgT0&& arg0, ArgT... args);
std::string* mutable_name();
PROTOBUF_NODISCARD std::string* release_name();
void set_allocated_name(std::string* name);
private:
const std::string& _internal_name() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
std::string* _internal_mutable_name();
public:
// optional bytes s = 4;
bool has_s() const;
private:
bool _internal_has_s() const;
public:
void clear_s();
const std::string& s() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_s(ArgT0&& arg0, ArgT... args);
std::string* mutable_s();
PROTOBUF_NODISCARD std::string* release_s();
void set_allocated_s(std::string* s);
private:
const std::string& _internal_s() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_s(const std::string& value);
std::string* _internal_mutable_s();
public:
// optional string doc_string = 13;
bool has_doc_string() const;
private:
bool _internal_has_doc_string() const;
public:
void clear_doc_string();
const std::string& doc_string() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_doc_string(ArgT0&& arg0, ArgT... args);
std::string* mutable_doc_string();
PROTOBUF_NODISCARD std::string* release_doc_string();
void set_allocated_doc_string(std::string* doc_string);
private:
const std::string& _internal_doc_string() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_doc_string(const std::string& value);
std::string* _internal_mutable_doc_string();
public:
// optional string ref_attr_name = 21;
bool has_ref_attr_name() const;
private:
bool _internal_has_ref_attr_name() const;
public:
void clear_ref_attr_name();
const std::string& ref_attr_name() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_ref_attr_name(ArgT0&& arg0, ArgT... args);
std::string* mutable_ref_attr_name();
PROTOBUF_NODISCARD std::string* release_ref_attr_name();
void set_allocated_ref_attr_name(std::string* ref_attr_name);
private:
const std::string& _internal_ref_attr_name() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_ref_attr_name(const std::string& value);
std::string* _internal_mutable_ref_attr_name();
public:
// optional .opencv_onnx.TensorProto t = 5;
bool has_t() const;
private:
bool _internal_has_t() const;
public:
void clear_t();
const ::opencv_onnx::TensorProto& t() const;
PROTOBUF_NODISCARD ::opencv_onnx::TensorProto* release_t();
::opencv_onnx::TensorProto* mutable_t();
void set_allocated_t(::opencv_onnx::TensorProto* t);
private:
const ::opencv_onnx::TensorProto& _internal_t() const;
::opencv_onnx::TensorProto* _internal_mutable_t();
public:
void unsafe_arena_set_allocated_t(
::opencv_onnx::TensorProto* t);
::opencv_onnx::TensorProto* unsafe_arena_release_t();
// optional .opencv_onnx.GraphProto g = 6;
bool has_g() const;
private:
bool _internal_has_g() const;
public:
void clear_g();
const ::opencv_onnx::GraphProto& g() const;
PROTOBUF_NODISCARD ::opencv_onnx::GraphProto* release_g();
::opencv_onnx::GraphProto* mutable_g();
void set_allocated_g(::opencv_onnx::GraphProto* g);
private:
const ::opencv_onnx::GraphProto& _internal_g() const;
::opencv_onnx::GraphProto* _internal_mutable_g();
public:
void unsafe_arena_set_allocated_g(
::opencv_onnx::GraphProto* g);
::opencv_onnx::GraphProto* unsafe_arena_release_g();
// optional .opencv_onnx.TypeProto tp = 14;
bool has_tp() const;
private:
bool _internal_has_tp() const;
public:
void clear_tp();
const ::opencv_onnx::TypeProto& tp() const;
PROTOBUF_NODISCARD ::opencv_onnx::TypeProto* release_tp();
::opencv_onnx::TypeProto* mutable_tp();
void set_allocated_tp(::opencv_onnx::TypeProto* tp);
private:
const ::opencv_onnx::TypeProto& _internal_tp() const;
::opencv_onnx::TypeProto* _internal_mutable_tp();
public:
void unsafe_arena_set_allocated_tp(
::opencv_onnx::TypeProto* tp);
::opencv_onnx::TypeProto* unsafe_arena_release_tp();
// optional .opencv_onnx.SparseTensorProto sparse_tensor = 22;
bool has_sparse_tensor() const;
private:
bool _internal_has_sparse_tensor() const;
public:
void clear_sparse_tensor();
const ::opencv_onnx::SparseTensorProto& sparse_tensor() const;
PROTOBUF_NODISCARD ::opencv_onnx::SparseTensorProto* release_sparse_tensor();
::opencv_onnx::SparseTensorProto* mutable_sparse_tensor();
void set_allocated_sparse_tensor(::opencv_onnx::SparseTensorProto* sparse_tensor);
private:
const ::opencv_onnx::SparseTensorProto& _internal_sparse_tensor() const;
::opencv_onnx::SparseTensorProto* _internal_mutable_sparse_tensor();
public:
void unsafe_arena_set_allocated_sparse_tensor(
::opencv_onnx::SparseTensorProto* sparse_tensor);
::opencv_onnx::SparseTensorProto* unsafe_arena_release_sparse_tensor();
// optional int64 i = 3;
bool has_i() const;
private:
bool _internal_has_i() const;
public:
void clear_i();
int64_t i() const;
void set_i(int64_t value);
private:
int64_t _internal_i() const;
void _internal_set_i(int64_t value);
public:
// optional float f = 2;
bool has_f() const;
private:
bool _internal_has_f() const;
public:
void clear_f();
float f() const;
void set_f(float value);
private:
float _internal_f() const;
void _internal_set_f(float value);
public:
// optional .opencv_onnx.AttributeProto.AttributeType type = 20;
bool has_type() const;
private:
bool _internal_has_type() const;
public:
void clear_type();
::opencv_onnx::AttributeProto_AttributeType type() const;
void set_type(::opencv_onnx::AttributeProto_AttributeType value);
private:
::opencv_onnx::AttributeProto_AttributeType _internal_type() const;
void _internal_set_type(::opencv_onnx::AttributeProto_AttributeType value);
public:
// @@protoc_insertion_point(class_scope:opencv_onnx.AttributeProto)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::RepeatedField< float > floats_;
::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > ints_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> strings_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::TensorProto > tensors_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::GraphProto > graphs_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::TypeProto > type_protos_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::SparseTensorProto > sparse_tensors_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr s_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr doc_string_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr ref_attr_name_;
::opencv_onnx::TensorProto* t_;
::opencv_onnx::GraphProto* g_;
::opencv_onnx::TypeProto* tp_;
::opencv_onnx::SparseTensorProto* sparse_tensor_;
int64_t i_;
float f_;
int type_;
friend struct ::TableStruct_opencv_2donnx_2eproto;
};
// -------------------------------------------------------------------
class ValueInfoProto final :
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:opencv_onnx.ValueInfoProto) */ {
public:
inline ValueInfoProto() : ValueInfoProto(nullptr) {}
~ValueInfoProto() override;
explicit constexpr ValueInfoProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
ValueInfoProto(const ValueInfoProto& from);
ValueInfoProto(ValueInfoProto&& from) noexcept
: ValueInfoProto() {
*this = ::std::move(from);
}
inline ValueInfoProto& operator=(const ValueInfoProto& from) {
CopyFrom(from);
return *this;
}
inline ValueInfoProto& operator=(ValueInfoProto&& 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;
}
inline const std::string& unknown_fields() const {
return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
}
inline std::string* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<std::string>();
}
static const ValueInfoProto& default_instance() {
return *internal_default_instance();
}
static inline const ValueInfoProto* internal_default_instance() {
return reinterpret_cast<const ValueInfoProto*>(
&_ValueInfoProto_default_instance_);
}
static constexpr int kIndexInFileMessages =
1;
friend void swap(ValueInfoProto& a, ValueInfoProto& b) {
a.Swap(&b);
}
inline void Swap(ValueInfoProto* 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(ValueInfoProto* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
ValueInfoProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<ValueInfoProto>(arena);
}
void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
void CopyFrom(const ValueInfoProto& from);
void MergeFrom(const ValueInfoProto& from);
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 _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const;
void InternalSwap(ValueInfoProto* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "opencv_onnx.ValueInfoProto";
}
protected:
explicit ValueInfoProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
std::string GetTypeName() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kMetadataPropsFieldNumber = 4,
kNameFieldNumber = 1,
kDocStringFieldNumber = 3,
kTypeFieldNumber = 2,
};
// repeated .opencv_onnx.StringStringEntryProto metadata_props = 4;
int metadata_props_size() const;
private:
int _internal_metadata_props_size() const;
public:
void clear_metadata_props();
::opencv_onnx::StringStringEntryProto* mutable_metadata_props(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::StringStringEntryProto >*
mutable_metadata_props();
private:
const ::opencv_onnx::StringStringEntryProto& _internal_metadata_props(int index) const;
::opencv_onnx::StringStringEntryProto* _internal_add_metadata_props();
public:
const ::opencv_onnx::StringStringEntryProto& metadata_props(int index) const;
::opencv_onnx::StringStringEntryProto* add_metadata_props();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::StringStringEntryProto >&
metadata_props() const;
// optional string name = 1;
bool has_name() const;
private:
bool _internal_has_name() const;
public:
void clear_name();
const std::string& name() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_name(ArgT0&& arg0, ArgT... args);
std::string* mutable_name();
PROTOBUF_NODISCARD std::string* release_name();
void set_allocated_name(std::string* name);
private:
const std::string& _internal_name() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
std::string* _internal_mutable_name();
public:
// optional string doc_string = 3;
bool has_doc_string() const;
private:
bool _internal_has_doc_string() const;
public:
void clear_doc_string();
const std::string& doc_string() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_doc_string(ArgT0&& arg0, ArgT... args);
std::string* mutable_doc_string();
PROTOBUF_NODISCARD std::string* release_doc_string();
void set_allocated_doc_string(std::string* doc_string);
private:
const std::string& _internal_doc_string() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_doc_string(const std::string& value);
std::string* _internal_mutable_doc_string();
public:
// optional .opencv_onnx.TypeProto type = 2;
bool has_type() const;
private:
bool _internal_has_type() const;
public:
void clear_type();
const ::opencv_onnx::TypeProto& type() const;
PROTOBUF_NODISCARD ::opencv_onnx::TypeProto* release_type();
::opencv_onnx::TypeProto* mutable_type();
void set_allocated_type(::opencv_onnx::TypeProto* type);
private:
const ::opencv_onnx::TypeProto& _internal_type() const;
::opencv_onnx::TypeProto* _internal_mutable_type();
public:
void unsafe_arena_set_allocated_type(
::opencv_onnx::TypeProto* type);
::opencv_onnx::TypeProto* unsafe_arena_release_type();
// @@protoc_insertion_point(class_scope:opencv_onnx.ValueInfoProto)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::StringStringEntryProto > metadata_props_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr doc_string_;
::opencv_onnx::TypeProto* type_;
friend struct ::TableStruct_opencv_2donnx_2eproto;
};
// -------------------------------------------------------------------
class NodeProto final :
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:opencv_onnx.NodeProto) */ {
public:
inline NodeProto() : NodeProto(nullptr) {}
~NodeProto() override;
explicit constexpr NodeProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
NodeProto(const NodeProto& from);
NodeProto(NodeProto&& from) noexcept
: NodeProto() {
*this = ::std::move(from);
}
inline NodeProto& operator=(const NodeProto& from) {
CopyFrom(from);
return *this;
}
inline NodeProto& operator=(NodeProto&& 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;
}
inline const std::string& unknown_fields() const {
return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
}
inline std::string* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<std::string>();
}
static const NodeProto& default_instance() {
return *internal_default_instance();
}
static inline const NodeProto* internal_default_instance() {
return reinterpret_cast<const NodeProto*>(
&_NodeProto_default_instance_);
}
static constexpr int kIndexInFileMessages =
2;
friend void swap(NodeProto& a, NodeProto& b) {
a.Swap(&b);
}
inline void Swap(NodeProto* 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(NodeProto* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
NodeProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<NodeProto>(arena);
}
void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
void CopyFrom(const NodeProto& from);
void MergeFrom(const NodeProto& from);
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 _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const;
void InternalSwap(NodeProto* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "opencv_onnx.NodeProto";
}
protected:
explicit NodeProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
std::string GetTypeName() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kInputFieldNumber = 1,
kOutputFieldNumber = 2,
kAttributeFieldNumber = 5,
kMetadataPropsFieldNumber = 9,
kDeviceConfigurationsFieldNumber = 10,
kNameFieldNumber = 3,
kOpTypeFieldNumber = 4,
kDocStringFieldNumber = 6,
kDomainFieldNumber = 7,
kOverloadFieldNumber = 8,
};
// repeated string input = 1;
int input_size() const;
private:
int _internal_input_size() const;
public:
void clear_input();
const std::string& input(int index) const;
std::string* mutable_input(int index);
void set_input(int index, const std::string& value);
void set_input(int index, std::string&& value);
void set_input(int index, const char* value);
void set_input(int index, const char* value, size_t size);
std::string* add_input();
void add_input(const std::string& value);
void add_input(std::string&& value);
void add_input(const char* value);
void add_input(const char* value, size_t size);
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& input() const;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_input();
private:
const std::string& _internal_input(int index) const;
std::string* _internal_add_input();
public:
// repeated string output = 2;
int output_size() const;
private:
int _internal_output_size() const;
public:
void clear_output();
const std::string& output(int index) const;
std::string* mutable_output(int index);
void set_output(int index, const std::string& value);
void set_output(int index, std::string&& value);
void set_output(int index, const char* value);
void set_output(int index, const char* value, size_t size);
std::string* add_output();
void add_output(const std::string& value);
void add_output(std::string&& value);
void add_output(const char* value);
void add_output(const char* value, size_t size);
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& output() const;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_output();
private:
const std::string& _internal_output(int index) const;
std::string* _internal_add_output();
public:
// repeated .opencv_onnx.AttributeProto attribute = 5;
int attribute_size() const;
private:
int _internal_attribute_size() const;
public:
void clear_attribute();
::opencv_onnx::AttributeProto* mutable_attribute(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::AttributeProto >*
mutable_attribute();
private:
const ::opencv_onnx::AttributeProto& _internal_attribute(int index) const;
::opencv_onnx::AttributeProto* _internal_add_attribute();
public:
const ::opencv_onnx::AttributeProto& attribute(int index) const;
::opencv_onnx::AttributeProto* add_attribute();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::AttributeProto >&
attribute() const;
// repeated .opencv_onnx.StringStringEntryProto metadata_props = 9;
int metadata_props_size() const;
private:
int _internal_metadata_props_size() const;
public:
void clear_metadata_props();
::opencv_onnx::StringStringEntryProto* mutable_metadata_props(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::StringStringEntryProto >*
mutable_metadata_props();
private:
const ::opencv_onnx::StringStringEntryProto& _internal_metadata_props(int index) const;
::opencv_onnx::StringStringEntryProto* _internal_add_metadata_props();
public:
const ::opencv_onnx::StringStringEntryProto& metadata_props(int index) const;
::opencv_onnx::StringStringEntryProto* add_metadata_props();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::StringStringEntryProto >&
metadata_props() const;
// repeated .opencv_onnx.NodeDeviceConfigurationProto device_configurations = 10;
int device_configurations_size() const;
private:
int _internal_device_configurations_size() const;
public:
void clear_device_configurations();
::opencv_onnx::NodeDeviceConfigurationProto* mutable_device_configurations(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::NodeDeviceConfigurationProto >*
mutable_device_configurations();
private:
const ::opencv_onnx::NodeDeviceConfigurationProto& _internal_device_configurations(int index) const;
::opencv_onnx::NodeDeviceConfigurationProto* _internal_add_device_configurations();
public:
const ::opencv_onnx::NodeDeviceConfigurationProto& device_configurations(int index) const;
::opencv_onnx::NodeDeviceConfigurationProto* add_device_configurations();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::NodeDeviceConfigurationProto >&
device_configurations() const;
// optional string name = 3;
bool has_name() const;
private:
bool _internal_has_name() const;
public:
void clear_name();
const std::string& name() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_name(ArgT0&& arg0, ArgT... args);
std::string* mutable_name();
PROTOBUF_NODISCARD std::string* release_name();
void set_allocated_name(std::string* name);
private:
const std::string& _internal_name() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
std::string* _internal_mutable_name();
public:
// optional string op_type = 4;
bool has_op_type() const;
private:
bool _internal_has_op_type() const;
public:
void clear_op_type();
const std::string& op_type() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_op_type(ArgT0&& arg0, ArgT... args);
std::string* mutable_op_type();
PROTOBUF_NODISCARD std::string* release_op_type();
void set_allocated_op_type(std::string* op_type);
private:
const std::string& _internal_op_type() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_op_type(const std::string& value);
std::string* _internal_mutable_op_type();
public:
// optional string doc_string = 6;
bool has_doc_string() const;
private:
bool _internal_has_doc_string() const;
public:
void clear_doc_string();
const std::string& doc_string() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_doc_string(ArgT0&& arg0, ArgT... args);
std::string* mutable_doc_string();
PROTOBUF_NODISCARD std::string* release_doc_string();
void set_allocated_doc_string(std::string* doc_string);
private:
const std::string& _internal_doc_string() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_doc_string(const std::string& value);
std::string* _internal_mutable_doc_string();
public:
// optional string domain = 7;
bool has_domain() const;
private:
bool _internal_has_domain() const;
public:
void clear_domain();
const std::string& domain() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_domain(ArgT0&& arg0, ArgT... args);
std::string* mutable_domain();
PROTOBUF_NODISCARD std::string* release_domain();
void set_allocated_domain(std::string* domain);
private:
const std::string& _internal_domain() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_domain(const std::string& value);
std::string* _internal_mutable_domain();
public:
// optional string overload = 8;
bool has_overload() const;
private:
bool _internal_has_overload() const;
public:
void clear_overload();
const std::string& overload() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_overload(ArgT0&& arg0, ArgT... args);
std::string* mutable_overload();
PROTOBUF_NODISCARD std::string* release_overload();
void set_allocated_overload(std::string* overload);
private:
const std::string& _internal_overload() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_overload(const std::string& value);
std::string* _internal_mutable_overload();
public:
// @@protoc_insertion_point(class_scope:opencv_onnx.NodeProto)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> input_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> output_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::AttributeProto > attribute_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::StringStringEntryProto > metadata_props_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::NodeDeviceConfigurationProto > device_configurations_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr op_type_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr doc_string_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr domain_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr overload_;
friend struct ::TableStruct_opencv_2donnx_2eproto;
};
// -------------------------------------------------------------------
class IntIntListEntryProto final :
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:opencv_onnx.IntIntListEntryProto) */ {
public:
inline IntIntListEntryProto() : IntIntListEntryProto(nullptr) {}
~IntIntListEntryProto() override;
explicit constexpr IntIntListEntryProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
IntIntListEntryProto(const IntIntListEntryProto& from);
IntIntListEntryProto(IntIntListEntryProto&& from) noexcept
: IntIntListEntryProto() {
*this = ::std::move(from);
}
inline IntIntListEntryProto& operator=(const IntIntListEntryProto& from) {
CopyFrom(from);
return *this;
}
inline IntIntListEntryProto& operator=(IntIntListEntryProto&& 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;
}
inline const std::string& unknown_fields() const {
return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
}
inline std::string* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<std::string>();
}
static const IntIntListEntryProto& default_instance() {
return *internal_default_instance();
}
static inline const IntIntListEntryProto* internal_default_instance() {
return reinterpret_cast<const IntIntListEntryProto*>(
&_IntIntListEntryProto_default_instance_);
}
static constexpr int kIndexInFileMessages =
3;
friend void swap(IntIntListEntryProto& a, IntIntListEntryProto& b) {
a.Swap(&b);
}
inline void Swap(IntIntListEntryProto* 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(IntIntListEntryProto* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
IntIntListEntryProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<IntIntListEntryProto>(arena);
}
void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
void CopyFrom(const IntIntListEntryProto& from);
void MergeFrom(const IntIntListEntryProto& from);
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 _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const;
void InternalSwap(IntIntListEntryProto* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "opencv_onnx.IntIntListEntryProto";
}
protected:
explicit IntIntListEntryProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
std::string GetTypeName() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kValueFieldNumber = 2,
kKeyFieldNumber = 1,
};
// repeated int64 value = 2;
int value_size() const;
private:
int _internal_value_size() const;
public:
void clear_value();
private:
int64_t _internal_value(int index) const;
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
_internal_value() const;
void _internal_add_value(int64_t value);
::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
_internal_mutable_value();
public:
int64_t value(int index) const;
void set_value(int index, int64_t value);
void add_value(int64_t value);
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
value() const;
::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
mutable_value();
// optional int64 key = 1;
bool has_key() const;
private:
bool _internal_has_key() const;
public:
void clear_key();
int64_t key() const;
void set_key(int64_t value);
private:
int64_t _internal_key() const;
void _internal_set_key(int64_t value);
public:
// @@protoc_insertion_point(class_scope:opencv_onnx.IntIntListEntryProto)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > value_;
int64_t key_;
friend struct ::TableStruct_opencv_2donnx_2eproto;
};
// -------------------------------------------------------------------
class NodeDeviceConfigurationProto final :
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:opencv_onnx.NodeDeviceConfigurationProto) */ {
public:
inline NodeDeviceConfigurationProto() : NodeDeviceConfigurationProto(nullptr) {}
~NodeDeviceConfigurationProto() override;
explicit constexpr NodeDeviceConfigurationProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
NodeDeviceConfigurationProto(const NodeDeviceConfigurationProto& from);
NodeDeviceConfigurationProto(NodeDeviceConfigurationProto&& from) noexcept
: NodeDeviceConfigurationProto() {
*this = ::std::move(from);
}
inline NodeDeviceConfigurationProto& operator=(const NodeDeviceConfigurationProto& from) {
CopyFrom(from);
return *this;
}
inline NodeDeviceConfigurationProto& operator=(NodeDeviceConfigurationProto&& 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;
}
inline const std::string& unknown_fields() const {
return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
}
inline std::string* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<std::string>();
}
static const NodeDeviceConfigurationProto& default_instance() {
return *internal_default_instance();
}
static inline const NodeDeviceConfigurationProto* internal_default_instance() {
return reinterpret_cast<const NodeDeviceConfigurationProto*>(
&_NodeDeviceConfigurationProto_default_instance_);
}
static constexpr int kIndexInFileMessages =
4;
friend void swap(NodeDeviceConfigurationProto& a, NodeDeviceConfigurationProto& b) {
a.Swap(&b);
}
inline void Swap(NodeDeviceConfigurationProto* 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(NodeDeviceConfigurationProto* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
NodeDeviceConfigurationProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<NodeDeviceConfigurationProto>(arena);
}
void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
void CopyFrom(const NodeDeviceConfigurationProto& from);
void MergeFrom(const NodeDeviceConfigurationProto& from);
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 _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const;
void InternalSwap(NodeDeviceConfigurationProto* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "opencv_onnx.NodeDeviceConfigurationProto";
}
protected:
explicit NodeDeviceConfigurationProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
std::string GetTypeName() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kShardingSpecFieldNumber = 2,
kConfigurationIdFieldNumber = 1,
kPipelineStageFieldNumber = 3,
};
// repeated .opencv_onnx.ShardingSpecProto sharding_spec = 2;
int sharding_spec_size() const;
private:
int _internal_sharding_spec_size() const;
public:
void clear_sharding_spec();
::opencv_onnx::ShardingSpecProto* mutable_sharding_spec(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::ShardingSpecProto >*
mutable_sharding_spec();
private:
const ::opencv_onnx::ShardingSpecProto& _internal_sharding_spec(int index) const;
::opencv_onnx::ShardingSpecProto* _internal_add_sharding_spec();
public:
const ::opencv_onnx::ShardingSpecProto& sharding_spec(int index) const;
::opencv_onnx::ShardingSpecProto* add_sharding_spec();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::ShardingSpecProto >&
sharding_spec() const;
// optional string configuration_id = 1;
bool has_configuration_id() const;
private:
bool _internal_has_configuration_id() const;
public:
void clear_configuration_id();
const std::string& configuration_id() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_configuration_id(ArgT0&& arg0, ArgT... args);
std::string* mutable_configuration_id();
PROTOBUF_NODISCARD std::string* release_configuration_id();
void set_allocated_configuration_id(std::string* configuration_id);
private:
const std::string& _internal_configuration_id() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_configuration_id(const std::string& value);
std::string* _internal_mutable_configuration_id();
public:
// optional int32 pipeline_stage = 3;
bool has_pipeline_stage() const;
private:
bool _internal_has_pipeline_stage() const;
public:
void clear_pipeline_stage();
int32_t pipeline_stage() const;
void set_pipeline_stage(int32_t value);
private:
int32_t _internal_pipeline_stage() const;
void _internal_set_pipeline_stage(int32_t value);
public:
// @@protoc_insertion_point(class_scope:opencv_onnx.NodeDeviceConfigurationProto)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::ShardingSpecProto > sharding_spec_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr configuration_id_;
int32_t pipeline_stage_;
friend struct ::TableStruct_opencv_2donnx_2eproto;
};
// -------------------------------------------------------------------
class ShardingSpecProto final :
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:opencv_onnx.ShardingSpecProto) */ {
public:
inline ShardingSpecProto() : ShardingSpecProto(nullptr) {}
~ShardingSpecProto() override;
explicit constexpr ShardingSpecProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
ShardingSpecProto(const ShardingSpecProto& from);
ShardingSpecProto(ShardingSpecProto&& from) noexcept
: ShardingSpecProto() {
*this = ::std::move(from);
}
inline ShardingSpecProto& operator=(const ShardingSpecProto& from) {
CopyFrom(from);
return *this;
}
inline ShardingSpecProto& operator=(ShardingSpecProto&& 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;
}
inline const std::string& unknown_fields() const {
return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
}
inline std::string* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<std::string>();
}
static const ShardingSpecProto& default_instance() {
return *internal_default_instance();
}
static inline const ShardingSpecProto* internal_default_instance() {
return reinterpret_cast<const ShardingSpecProto*>(
&_ShardingSpecProto_default_instance_);
}
static constexpr int kIndexInFileMessages =
5;
friend void swap(ShardingSpecProto& a, ShardingSpecProto& b) {
a.Swap(&b);
}
inline void Swap(ShardingSpecProto* 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(ShardingSpecProto* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
ShardingSpecProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<ShardingSpecProto>(arena);
}
void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
void CopyFrom(const ShardingSpecProto& from);
void MergeFrom(const ShardingSpecProto& from);
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 _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const;
void InternalSwap(ShardingSpecProto* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "opencv_onnx.ShardingSpecProto";
}
protected:
explicit ShardingSpecProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
std::string GetTypeName() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kDeviceFieldNumber = 2,
kIndexToDeviceGroupMapFieldNumber = 3,
kShardedDimFieldNumber = 4,
kTensorNameFieldNumber = 1,
};
// repeated int64 device = 2;
int device_size() const;
private:
int _internal_device_size() const;
public:
void clear_device();
private:
int64_t _internal_device(int index) const;
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
_internal_device() const;
void _internal_add_device(int64_t value);
::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
_internal_mutable_device();
public:
int64_t device(int index) const;
void set_device(int index, int64_t value);
void add_device(int64_t value);
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
device() const;
::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
mutable_device();
// repeated .opencv_onnx.IntIntListEntryProto index_to_device_group_map = 3;
int index_to_device_group_map_size() const;
private:
int _internal_index_to_device_group_map_size() const;
public:
void clear_index_to_device_group_map();
::opencv_onnx::IntIntListEntryProto* mutable_index_to_device_group_map(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::IntIntListEntryProto >*
mutable_index_to_device_group_map();
private:
const ::opencv_onnx::IntIntListEntryProto& _internal_index_to_device_group_map(int index) const;
::opencv_onnx::IntIntListEntryProto* _internal_add_index_to_device_group_map();
public:
const ::opencv_onnx::IntIntListEntryProto& index_to_device_group_map(int index) const;
::opencv_onnx::IntIntListEntryProto* add_index_to_device_group_map();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::IntIntListEntryProto >&
index_to_device_group_map() const;
// repeated .opencv_onnx.ShardedDimProto sharded_dim = 4;
int sharded_dim_size() const;
private:
int _internal_sharded_dim_size() const;
public:
void clear_sharded_dim();
::opencv_onnx::ShardedDimProto* mutable_sharded_dim(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::ShardedDimProto >*
mutable_sharded_dim();
private:
const ::opencv_onnx::ShardedDimProto& _internal_sharded_dim(int index) const;
::opencv_onnx::ShardedDimProto* _internal_add_sharded_dim();
public:
const ::opencv_onnx::ShardedDimProto& sharded_dim(int index) const;
::opencv_onnx::ShardedDimProto* add_sharded_dim();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::ShardedDimProto >&
sharded_dim() const;
// optional string tensor_name = 1;
bool has_tensor_name() const;
private:
bool _internal_has_tensor_name() const;
public:
void clear_tensor_name();
const std::string& tensor_name() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_tensor_name(ArgT0&& arg0, ArgT... args);
std::string* mutable_tensor_name();
PROTOBUF_NODISCARD std::string* release_tensor_name();
void set_allocated_tensor_name(std::string* tensor_name);
private:
const std::string& _internal_tensor_name() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_tensor_name(const std::string& value);
std::string* _internal_mutable_tensor_name();
public:
// @@protoc_insertion_point(class_scope:opencv_onnx.ShardingSpecProto)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > device_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::IntIntListEntryProto > index_to_device_group_map_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::ShardedDimProto > sharded_dim_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr tensor_name_;
friend struct ::TableStruct_opencv_2donnx_2eproto;
};
// -------------------------------------------------------------------
class ShardedDimProto final :
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:opencv_onnx.ShardedDimProto) */ {
public:
inline ShardedDimProto() : ShardedDimProto(nullptr) {}
~ShardedDimProto() override;
explicit constexpr ShardedDimProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
ShardedDimProto(const ShardedDimProto& from);
ShardedDimProto(ShardedDimProto&& from) noexcept
: ShardedDimProto() {
*this = ::std::move(from);
}
inline ShardedDimProto& operator=(const ShardedDimProto& from) {
CopyFrom(from);
return *this;
}
inline ShardedDimProto& operator=(ShardedDimProto&& 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;
}
inline const std::string& unknown_fields() const {
return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
}
inline std::string* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<std::string>();
}
static const ShardedDimProto& default_instance() {
return *internal_default_instance();
}
static inline const ShardedDimProto* internal_default_instance() {
return reinterpret_cast<const ShardedDimProto*>(
&_ShardedDimProto_default_instance_);
}
static constexpr int kIndexInFileMessages =
6;
friend void swap(ShardedDimProto& a, ShardedDimProto& b) {
a.Swap(&b);
}
inline void Swap(ShardedDimProto* 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(ShardedDimProto* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
ShardedDimProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<ShardedDimProto>(arena);
}
void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
void CopyFrom(const ShardedDimProto& from);
void MergeFrom(const ShardedDimProto& from);
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 _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const;
void InternalSwap(ShardedDimProto* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "opencv_onnx.ShardedDimProto";
}
protected:
explicit ShardedDimProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
std::string GetTypeName() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kSimpleShardingFieldNumber = 2,
kAxisFieldNumber = 1,
};
// repeated .opencv_onnx.SimpleShardedDimProto simple_sharding = 2;
int simple_sharding_size() const;
private:
int _internal_simple_sharding_size() const;
public:
void clear_simple_sharding();
::opencv_onnx::SimpleShardedDimProto* mutable_simple_sharding(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::SimpleShardedDimProto >*
mutable_simple_sharding();
private:
const ::opencv_onnx::SimpleShardedDimProto& _internal_simple_sharding(int index) const;
::opencv_onnx::SimpleShardedDimProto* _internal_add_simple_sharding();
public:
const ::opencv_onnx::SimpleShardedDimProto& simple_sharding(int index) const;
::opencv_onnx::SimpleShardedDimProto* add_simple_sharding();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::SimpleShardedDimProto >&
simple_sharding() const;
// optional int64 axis = 1;
bool has_axis() const;
private:
bool _internal_has_axis() const;
public:
void clear_axis();
int64_t axis() const;
void set_axis(int64_t value);
private:
int64_t _internal_axis() const;
void _internal_set_axis(int64_t value);
public:
// @@protoc_insertion_point(class_scope:opencv_onnx.ShardedDimProto)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::SimpleShardedDimProto > simple_sharding_;
int64_t axis_;
friend struct ::TableStruct_opencv_2donnx_2eproto;
};
// -------------------------------------------------------------------
class SimpleShardedDimProto final :
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:opencv_onnx.SimpleShardedDimProto) */ {
public:
inline SimpleShardedDimProto() : SimpleShardedDimProto(nullptr) {}
~SimpleShardedDimProto() override;
explicit constexpr SimpleShardedDimProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
SimpleShardedDimProto(const SimpleShardedDimProto& from);
SimpleShardedDimProto(SimpleShardedDimProto&& from) noexcept
: SimpleShardedDimProto() {
*this = ::std::move(from);
}
inline SimpleShardedDimProto& operator=(const SimpleShardedDimProto& from) {
CopyFrom(from);
return *this;
}
inline SimpleShardedDimProto& operator=(SimpleShardedDimProto&& 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;
}
inline const std::string& unknown_fields() const {
return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
}
inline std::string* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<std::string>();
}
static const SimpleShardedDimProto& default_instance() {
return *internal_default_instance();
}
enum DimCase {
kDimValue = 1,
kDimParam = 2,
DIM_NOT_SET = 0,
};
static inline const SimpleShardedDimProto* internal_default_instance() {
return reinterpret_cast<const SimpleShardedDimProto*>(
&_SimpleShardedDimProto_default_instance_);
}
static constexpr int kIndexInFileMessages =
7;
friend void swap(SimpleShardedDimProto& a, SimpleShardedDimProto& b) {
a.Swap(&b);
}
inline void Swap(SimpleShardedDimProto* 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(SimpleShardedDimProto* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
SimpleShardedDimProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<SimpleShardedDimProto>(arena);
}
void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
void CopyFrom(const SimpleShardedDimProto& from);
void MergeFrom(const SimpleShardedDimProto& from);
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 _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const;
void InternalSwap(SimpleShardedDimProto* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "opencv_onnx.SimpleShardedDimProto";
}
protected:
explicit SimpleShardedDimProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
std::string GetTypeName() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kNumShardsFieldNumber = 3,
kDimValueFieldNumber = 1,
kDimParamFieldNumber = 2,
};
// optional int64 num_shards = 3;
bool has_num_shards() const;
private:
bool _internal_has_num_shards() const;
public:
void clear_num_shards();
int64_t num_shards() const;
void set_num_shards(int64_t value);
private:
int64_t _internal_num_shards() const;
void _internal_set_num_shards(int64_t value);
public:
// int64 dim_value = 1;
bool has_dim_value() const;
private:
bool _internal_has_dim_value() const;
public:
void clear_dim_value();
int64_t dim_value() const;
void set_dim_value(int64_t value);
private:
int64_t _internal_dim_value() const;
void _internal_set_dim_value(int64_t value);
public:
// string dim_param = 2;
bool has_dim_param() const;
private:
bool _internal_has_dim_param() const;
public:
void clear_dim_param();
const std::string& dim_param() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_dim_param(ArgT0&& arg0, ArgT... args);
std::string* mutable_dim_param();
PROTOBUF_NODISCARD std::string* release_dim_param();
void set_allocated_dim_param(std::string* dim_param);
private:
const std::string& _internal_dim_param() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_dim_param(const std::string& value);
std::string* _internal_mutable_dim_param();
public:
void clear_dim();
DimCase dim_case() const;
// @@protoc_insertion_point(class_scope:opencv_onnx.SimpleShardedDimProto)
private:
class _Internal;
void set_has_dim_value();
void set_has_dim_param();
inline bool has_dim() const;
inline void clear_has_dim();
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
int64_t num_shards_;
union DimUnion {
constexpr DimUnion() : _constinit_{} {}
::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
int64_t dim_value_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr dim_param_;
} dim_;
uint32_t _oneof_case_[1];
friend struct ::TableStruct_opencv_2donnx_2eproto;
};
// -------------------------------------------------------------------
class TrainingInfoProto final :
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:opencv_onnx.TrainingInfoProto) */ {
public:
inline TrainingInfoProto() : TrainingInfoProto(nullptr) {}
~TrainingInfoProto() override;
explicit constexpr TrainingInfoProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
TrainingInfoProto(const TrainingInfoProto& from);
TrainingInfoProto(TrainingInfoProto&& from) noexcept
: TrainingInfoProto() {
*this = ::std::move(from);
}
inline TrainingInfoProto& operator=(const TrainingInfoProto& from) {
CopyFrom(from);
return *this;
}
inline TrainingInfoProto& operator=(TrainingInfoProto&& 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;
}
inline const std::string& unknown_fields() const {
return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
}
inline std::string* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<std::string>();
}
static const TrainingInfoProto& default_instance() {
return *internal_default_instance();
}
static inline const TrainingInfoProto* internal_default_instance() {
return reinterpret_cast<const TrainingInfoProto*>(
&_TrainingInfoProto_default_instance_);
}
static constexpr int kIndexInFileMessages =
8;
friend void swap(TrainingInfoProto& a, TrainingInfoProto& b) {
a.Swap(&b);
}
inline void Swap(TrainingInfoProto* 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(TrainingInfoProto* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
TrainingInfoProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<TrainingInfoProto>(arena);
}
void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
void CopyFrom(const TrainingInfoProto& from);
void MergeFrom(const TrainingInfoProto& from);
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 _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const;
void InternalSwap(TrainingInfoProto* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "opencv_onnx.TrainingInfoProto";
}
protected:
explicit TrainingInfoProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
std::string GetTypeName() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kInitializationBindingFieldNumber = 3,
kUpdateBindingFieldNumber = 4,
kInitializationFieldNumber = 1,
kAlgorithmFieldNumber = 2,
};
// repeated .opencv_onnx.StringStringEntryProto initialization_binding = 3;
int initialization_binding_size() const;
private:
int _internal_initialization_binding_size() const;
public:
void clear_initialization_binding();
::opencv_onnx::StringStringEntryProto* mutable_initialization_binding(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::StringStringEntryProto >*
mutable_initialization_binding();
private:
const ::opencv_onnx::StringStringEntryProto& _internal_initialization_binding(int index) const;
::opencv_onnx::StringStringEntryProto* _internal_add_initialization_binding();
public:
const ::opencv_onnx::StringStringEntryProto& initialization_binding(int index) const;
::opencv_onnx::StringStringEntryProto* add_initialization_binding();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::StringStringEntryProto >&
initialization_binding() const;
// repeated .opencv_onnx.StringStringEntryProto update_binding = 4;
int update_binding_size() const;
private:
int _internal_update_binding_size() const;
public:
void clear_update_binding();
::opencv_onnx::StringStringEntryProto* mutable_update_binding(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::StringStringEntryProto >*
mutable_update_binding();
private:
const ::opencv_onnx::StringStringEntryProto& _internal_update_binding(int index) const;
::opencv_onnx::StringStringEntryProto* _internal_add_update_binding();
public:
const ::opencv_onnx::StringStringEntryProto& update_binding(int index) const;
::opencv_onnx::StringStringEntryProto* add_update_binding();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::StringStringEntryProto >&
update_binding() const;
// optional .opencv_onnx.GraphProto initialization = 1;
bool has_initialization() const;
private:
bool _internal_has_initialization() const;
public:
void clear_initialization();
const ::opencv_onnx::GraphProto& initialization() const;
PROTOBUF_NODISCARD ::opencv_onnx::GraphProto* release_initialization();
::opencv_onnx::GraphProto* mutable_initialization();
void set_allocated_initialization(::opencv_onnx::GraphProto* initialization);
private:
const ::opencv_onnx::GraphProto& _internal_initialization() const;
::opencv_onnx::GraphProto* _internal_mutable_initialization();
public:
void unsafe_arena_set_allocated_initialization(
::opencv_onnx::GraphProto* initialization);
::opencv_onnx::GraphProto* unsafe_arena_release_initialization();
// optional .opencv_onnx.GraphProto algorithm = 2;
bool has_algorithm() const;
private:
bool _internal_has_algorithm() const;
public:
void clear_algorithm();
const ::opencv_onnx::GraphProto& algorithm() const;
PROTOBUF_NODISCARD ::opencv_onnx::GraphProto* release_algorithm();
::opencv_onnx::GraphProto* mutable_algorithm();
void set_allocated_algorithm(::opencv_onnx::GraphProto* algorithm);
private:
const ::opencv_onnx::GraphProto& _internal_algorithm() const;
::opencv_onnx::GraphProto* _internal_mutable_algorithm();
public:
void unsafe_arena_set_allocated_algorithm(
::opencv_onnx::GraphProto* algorithm);
::opencv_onnx::GraphProto* unsafe_arena_release_algorithm();
// @@protoc_insertion_point(class_scope:opencv_onnx.TrainingInfoProto)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::StringStringEntryProto > initialization_binding_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::StringStringEntryProto > update_binding_;
::opencv_onnx::GraphProto* initialization_;
::opencv_onnx::GraphProto* algorithm_;
friend struct ::TableStruct_opencv_2donnx_2eproto;
};
// -------------------------------------------------------------------
class ModelProto final :
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:opencv_onnx.ModelProto) */ {
public:
inline ModelProto() : ModelProto(nullptr) {}
~ModelProto() override;
explicit constexpr ModelProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
ModelProto(const ModelProto& from);
ModelProto(ModelProto&& from) noexcept
: ModelProto() {
*this = ::std::move(from);
}
inline ModelProto& operator=(const ModelProto& from) {
CopyFrom(from);
return *this;
}
inline ModelProto& operator=(ModelProto&& 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;
}
inline const std::string& unknown_fields() const {
return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
}
inline std::string* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<std::string>();
}
static const ModelProto& default_instance() {
return *internal_default_instance();
}
static inline const ModelProto* internal_default_instance() {
return reinterpret_cast<const ModelProto*>(
&_ModelProto_default_instance_);
}
static constexpr int kIndexInFileMessages =
9;
friend void swap(ModelProto& a, ModelProto& b) {
a.Swap(&b);
}
inline void Swap(ModelProto* 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(ModelProto* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
ModelProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<ModelProto>(arena);
}
void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
void CopyFrom(const ModelProto& from);
void MergeFrom(const ModelProto& from);
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 _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const;
void InternalSwap(ModelProto* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "opencv_onnx.ModelProto";
}
protected:
explicit ModelProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
std::string GetTypeName() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kOpsetImportFieldNumber = 8,
kMetadataPropsFieldNumber = 14,
kTrainingInfoFieldNumber = 20,
kFunctionsFieldNumber = 25,
kConfigurationFieldNumber = 26,
kProducerNameFieldNumber = 2,
kProducerVersionFieldNumber = 3,
kDomainFieldNumber = 4,
kDocStringFieldNumber = 6,
kGraphFieldNumber = 7,
kIrVersionFieldNumber = 1,
kModelVersionFieldNumber = 5,
};
// repeated .opencv_onnx.OperatorSetIdProto opset_import = 8;
int opset_import_size() const;
private:
int _internal_opset_import_size() const;
public:
void clear_opset_import();
::opencv_onnx::OperatorSetIdProto* mutable_opset_import(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::OperatorSetIdProto >*
mutable_opset_import();
private:
const ::opencv_onnx::OperatorSetIdProto& _internal_opset_import(int index) const;
::opencv_onnx::OperatorSetIdProto* _internal_add_opset_import();
public:
const ::opencv_onnx::OperatorSetIdProto& opset_import(int index) const;
::opencv_onnx::OperatorSetIdProto* add_opset_import();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::OperatorSetIdProto >&
opset_import() const;
// repeated .opencv_onnx.StringStringEntryProto metadata_props = 14;
int metadata_props_size() const;
private:
int _internal_metadata_props_size() const;
public:
void clear_metadata_props();
::opencv_onnx::StringStringEntryProto* mutable_metadata_props(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::StringStringEntryProto >*
mutable_metadata_props();
private:
const ::opencv_onnx::StringStringEntryProto& _internal_metadata_props(int index) const;
::opencv_onnx::StringStringEntryProto* _internal_add_metadata_props();
public:
const ::opencv_onnx::StringStringEntryProto& metadata_props(int index) const;
::opencv_onnx::StringStringEntryProto* add_metadata_props();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::StringStringEntryProto >&
metadata_props() const;
// repeated .opencv_onnx.TrainingInfoProto training_info = 20;
int training_info_size() const;
private:
int _internal_training_info_size() const;
public:
void clear_training_info();
::opencv_onnx::TrainingInfoProto* mutable_training_info(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::TrainingInfoProto >*
mutable_training_info();
private:
const ::opencv_onnx::TrainingInfoProto& _internal_training_info(int index) const;
::opencv_onnx::TrainingInfoProto* _internal_add_training_info();
public:
const ::opencv_onnx::TrainingInfoProto& training_info(int index) const;
::opencv_onnx::TrainingInfoProto* add_training_info();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::TrainingInfoProto >&
training_info() const;
// repeated .opencv_onnx.FunctionProto functions = 25;
int functions_size() const;
private:
int _internal_functions_size() const;
public:
void clear_functions();
::opencv_onnx::FunctionProto* mutable_functions(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::FunctionProto >*
mutable_functions();
private:
const ::opencv_onnx::FunctionProto& _internal_functions(int index) const;
::opencv_onnx::FunctionProto* _internal_add_functions();
public:
const ::opencv_onnx::FunctionProto& functions(int index) const;
::opencv_onnx::FunctionProto* add_functions();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::FunctionProto >&
functions() const;
// repeated .opencv_onnx.DeviceConfigurationProto configuration = 26;
int configuration_size() const;
private:
int _internal_configuration_size() const;
public:
void clear_configuration();
::opencv_onnx::DeviceConfigurationProto* mutable_configuration(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::DeviceConfigurationProto >*
mutable_configuration();
private:
const ::opencv_onnx::DeviceConfigurationProto& _internal_configuration(int index) const;
::opencv_onnx::DeviceConfigurationProto* _internal_add_configuration();
public:
const ::opencv_onnx::DeviceConfigurationProto& configuration(int index) const;
::opencv_onnx::DeviceConfigurationProto* add_configuration();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::DeviceConfigurationProto >&
configuration() const;
// optional string producer_name = 2;
bool has_producer_name() const;
private:
bool _internal_has_producer_name() const;
public:
void clear_producer_name();
const std::string& producer_name() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_producer_name(ArgT0&& arg0, ArgT... args);
std::string* mutable_producer_name();
PROTOBUF_NODISCARD std::string* release_producer_name();
void set_allocated_producer_name(std::string* producer_name);
private:
const std::string& _internal_producer_name() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_producer_name(const std::string& value);
std::string* _internal_mutable_producer_name();
public:
// optional string producer_version = 3;
bool has_producer_version() const;
private:
bool _internal_has_producer_version() const;
public:
void clear_producer_version();
const std::string& producer_version() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_producer_version(ArgT0&& arg0, ArgT... args);
std::string* mutable_producer_version();
PROTOBUF_NODISCARD std::string* release_producer_version();
void set_allocated_producer_version(std::string* producer_version);
private:
const std::string& _internal_producer_version() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_producer_version(const std::string& value);
std::string* _internal_mutable_producer_version();
public:
// optional string domain = 4;
bool has_domain() const;
private:
bool _internal_has_domain() const;
public:
void clear_domain();
const std::string& domain() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_domain(ArgT0&& arg0, ArgT... args);
std::string* mutable_domain();
PROTOBUF_NODISCARD std::string* release_domain();
void set_allocated_domain(std::string* domain);
private:
const std::string& _internal_domain() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_domain(const std::string& value);
std::string* _internal_mutable_domain();
public:
// optional string doc_string = 6;
bool has_doc_string() const;
private:
bool _internal_has_doc_string() const;
public:
void clear_doc_string();
const std::string& doc_string() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_doc_string(ArgT0&& arg0, ArgT... args);
std::string* mutable_doc_string();
PROTOBUF_NODISCARD std::string* release_doc_string();
void set_allocated_doc_string(std::string* doc_string);
private:
const std::string& _internal_doc_string() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_doc_string(const std::string& value);
std::string* _internal_mutable_doc_string();
public:
// optional .opencv_onnx.GraphProto graph = 7;
bool has_graph() const;
private:
bool _internal_has_graph() const;
public:
void clear_graph();
const ::opencv_onnx::GraphProto& graph() const;
PROTOBUF_NODISCARD ::opencv_onnx::GraphProto* release_graph();
::opencv_onnx::GraphProto* mutable_graph();
void set_allocated_graph(::opencv_onnx::GraphProto* graph);
private:
const ::opencv_onnx::GraphProto& _internal_graph() const;
::opencv_onnx::GraphProto* _internal_mutable_graph();
public:
void unsafe_arena_set_allocated_graph(
::opencv_onnx::GraphProto* graph);
::opencv_onnx::GraphProto* unsafe_arena_release_graph();
// optional int64 ir_version = 1;
bool has_ir_version() const;
private:
bool _internal_has_ir_version() const;
public:
void clear_ir_version();
int64_t ir_version() const;
void set_ir_version(int64_t value);
private:
int64_t _internal_ir_version() const;
void _internal_set_ir_version(int64_t value);
public:
// optional int64 model_version = 5;
bool has_model_version() const;
private:
bool _internal_has_model_version() const;
public:
void clear_model_version();
int64_t model_version() const;
void set_model_version(int64_t value);
private:
int64_t _internal_model_version() const;
void _internal_set_model_version(int64_t value);
public:
// @@protoc_insertion_point(class_scope:opencv_onnx.ModelProto)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::OperatorSetIdProto > opset_import_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::StringStringEntryProto > metadata_props_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::TrainingInfoProto > training_info_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::FunctionProto > functions_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::DeviceConfigurationProto > configuration_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr producer_name_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr producer_version_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr domain_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr doc_string_;
::opencv_onnx::GraphProto* graph_;
int64_t ir_version_;
int64_t model_version_;
friend struct ::TableStruct_opencv_2donnx_2eproto;
};
// -------------------------------------------------------------------
class DeviceConfigurationProto final :
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:opencv_onnx.DeviceConfigurationProto) */ {
public:
inline DeviceConfigurationProto() : DeviceConfigurationProto(nullptr) {}
~DeviceConfigurationProto() override;
explicit constexpr DeviceConfigurationProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
DeviceConfigurationProto(const DeviceConfigurationProto& from);
DeviceConfigurationProto(DeviceConfigurationProto&& from) noexcept
: DeviceConfigurationProto() {
*this = ::std::move(from);
}
inline DeviceConfigurationProto& operator=(const DeviceConfigurationProto& from) {
CopyFrom(from);
return *this;
}
inline DeviceConfigurationProto& operator=(DeviceConfigurationProto&& 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;
}
inline const std::string& unknown_fields() const {
return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
}
inline std::string* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<std::string>();
}
static const DeviceConfigurationProto& default_instance() {
return *internal_default_instance();
}
static inline const DeviceConfigurationProto* internal_default_instance() {
return reinterpret_cast<const DeviceConfigurationProto*>(
&_DeviceConfigurationProto_default_instance_);
}
static constexpr int kIndexInFileMessages =
10;
friend void swap(DeviceConfigurationProto& a, DeviceConfigurationProto& b) {
a.Swap(&b);
}
inline void Swap(DeviceConfigurationProto* 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(DeviceConfigurationProto* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
DeviceConfigurationProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<DeviceConfigurationProto>(arena);
}
void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
void CopyFrom(const DeviceConfigurationProto& from);
void MergeFrom(const DeviceConfigurationProto& from);
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 _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const;
void InternalSwap(DeviceConfigurationProto* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "opencv_onnx.DeviceConfigurationProto";
}
protected:
explicit DeviceConfigurationProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
std::string GetTypeName() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kDeviceFieldNumber = 3,
kNameFieldNumber = 1,
kNumDevicesFieldNumber = 2,
};
// repeated string device = 3;
int device_size() const;
private:
int _internal_device_size() const;
public:
void clear_device();
const std::string& device(int index) const;
std::string* mutable_device(int index);
void set_device(int index, const std::string& value);
void set_device(int index, std::string&& value);
void set_device(int index, const char* value);
void set_device(int index, const char* value, size_t size);
std::string* add_device();
void add_device(const std::string& value);
void add_device(std::string&& value);
void add_device(const char* value);
void add_device(const char* value, size_t size);
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& device() const;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_device();
private:
const std::string& _internal_device(int index) const;
std::string* _internal_add_device();
public:
// optional string name = 1;
bool has_name() const;
private:
bool _internal_has_name() const;
public:
void clear_name();
const std::string& name() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_name(ArgT0&& arg0, ArgT... args);
std::string* mutable_name();
PROTOBUF_NODISCARD std::string* release_name();
void set_allocated_name(std::string* name);
private:
const std::string& _internal_name() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
std::string* _internal_mutable_name();
public:
// optional int32 num_devices = 2;
bool has_num_devices() const;
private:
bool _internal_has_num_devices() const;
public:
void clear_num_devices();
int32_t num_devices() const;
void set_num_devices(int32_t value);
private:
int32_t _internal_num_devices() const;
void _internal_set_num_devices(int32_t value);
public:
// @@protoc_insertion_point(class_scope:opencv_onnx.DeviceConfigurationProto)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> device_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
int32_t num_devices_;
friend struct ::TableStruct_opencv_2donnx_2eproto;
};
// -------------------------------------------------------------------
class StringStringEntryProto final :
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:opencv_onnx.StringStringEntryProto) */ {
public:
inline StringStringEntryProto() : StringStringEntryProto(nullptr) {}
~StringStringEntryProto() override;
explicit constexpr StringStringEntryProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
StringStringEntryProto(const StringStringEntryProto& from);
StringStringEntryProto(StringStringEntryProto&& from) noexcept
: StringStringEntryProto() {
*this = ::std::move(from);
}
inline StringStringEntryProto& operator=(const StringStringEntryProto& from) {
CopyFrom(from);
return *this;
}
inline StringStringEntryProto& operator=(StringStringEntryProto&& 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;
}
inline const std::string& unknown_fields() const {
return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
}
inline std::string* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<std::string>();
}
static const StringStringEntryProto& default_instance() {
return *internal_default_instance();
}
static inline const StringStringEntryProto* internal_default_instance() {
return reinterpret_cast<const StringStringEntryProto*>(
&_StringStringEntryProto_default_instance_);
}
static constexpr int kIndexInFileMessages =
11;
friend void swap(StringStringEntryProto& a, StringStringEntryProto& b) {
a.Swap(&b);
}
inline void Swap(StringStringEntryProto* 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(StringStringEntryProto* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
StringStringEntryProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<StringStringEntryProto>(arena);
}
void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
void CopyFrom(const StringStringEntryProto& from);
void MergeFrom(const StringStringEntryProto& from);
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 _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const;
void InternalSwap(StringStringEntryProto* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "opencv_onnx.StringStringEntryProto";
}
protected:
explicit StringStringEntryProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
std::string GetTypeName() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kKeyFieldNumber = 1,
kValueFieldNumber = 2,
};
// optional string key = 1;
bool has_key() const;
private:
bool _internal_has_key() const;
public:
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:
// optional string value = 2;
bool has_value() const;
private:
bool _internal_has_value() const;
public:
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:opencv_onnx.StringStringEntryProto)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_;
friend struct ::TableStruct_opencv_2donnx_2eproto;
};
// -------------------------------------------------------------------
class TensorAnnotation final :
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:opencv_onnx.TensorAnnotation) */ {
public:
inline TensorAnnotation() : TensorAnnotation(nullptr) {}
~TensorAnnotation() override;
explicit constexpr TensorAnnotation(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
TensorAnnotation(const TensorAnnotation& from);
TensorAnnotation(TensorAnnotation&& from) noexcept
: TensorAnnotation() {
*this = ::std::move(from);
}
inline TensorAnnotation& operator=(const TensorAnnotation& from) {
CopyFrom(from);
return *this;
}
inline TensorAnnotation& operator=(TensorAnnotation&& 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;
}
inline const std::string& unknown_fields() const {
return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
}
inline std::string* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<std::string>();
}
static const TensorAnnotation& default_instance() {
return *internal_default_instance();
}
static inline const TensorAnnotation* internal_default_instance() {
return reinterpret_cast<const TensorAnnotation*>(
&_TensorAnnotation_default_instance_);
}
static constexpr int kIndexInFileMessages =
12;
friend void swap(TensorAnnotation& a, TensorAnnotation& b) {
a.Swap(&b);
}
inline void Swap(TensorAnnotation* 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(TensorAnnotation* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
TensorAnnotation* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<TensorAnnotation>(arena);
}
void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
void CopyFrom(const TensorAnnotation& from);
void MergeFrom(const TensorAnnotation& from);
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 _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const;
void InternalSwap(TensorAnnotation* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "opencv_onnx.TensorAnnotation";
}
protected:
explicit TensorAnnotation(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
std::string GetTypeName() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kQuantParameterTensorNamesFieldNumber = 2,
kTensorNameFieldNumber = 1,
};
// repeated .opencv_onnx.StringStringEntryProto quant_parameter_tensor_names = 2;
int quant_parameter_tensor_names_size() const;
private:
int _internal_quant_parameter_tensor_names_size() const;
public:
void clear_quant_parameter_tensor_names();
::opencv_onnx::StringStringEntryProto* mutable_quant_parameter_tensor_names(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::StringStringEntryProto >*
mutable_quant_parameter_tensor_names();
private:
const ::opencv_onnx::StringStringEntryProto& _internal_quant_parameter_tensor_names(int index) const;
::opencv_onnx::StringStringEntryProto* _internal_add_quant_parameter_tensor_names();
public:
const ::opencv_onnx::StringStringEntryProto& quant_parameter_tensor_names(int index) const;
::opencv_onnx::StringStringEntryProto* add_quant_parameter_tensor_names();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::StringStringEntryProto >&
quant_parameter_tensor_names() const;
// optional string tensor_name = 1;
bool has_tensor_name() const;
private:
bool _internal_has_tensor_name() const;
public:
void clear_tensor_name();
const std::string& tensor_name() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_tensor_name(ArgT0&& arg0, ArgT... args);
std::string* mutable_tensor_name();
PROTOBUF_NODISCARD std::string* release_tensor_name();
void set_allocated_tensor_name(std::string* tensor_name);
private:
const std::string& _internal_tensor_name() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_tensor_name(const std::string& value);
std::string* _internal_mutable_tensor_name();
public:
// @@protoc_insertion_point(class_scope:opencv_onnx.TensorAnnotation)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::StringStringEntryProto > quant_parameter_tensor_names_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr tensor_name_;
friend struct ::TableStruct_opencv_2donnx_2eproto;
};
// -------------------------------------------------------------------
class GraphProto final :
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:opencv_onnx.GraphProto) */ {
public:
inline GraphProto() : GraphProto(nullptr) {}
~GraphProto() override;
explicit constexpr GraphProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
GraphProto(const GraphProto& from);
GraphProto(GraphProto&& from) noexcept
: GraphProto() {
*this = ::std::move(from);
}
inline GraphProto& operator=(const GraphProto& from) {
CopyFrom(from);
return *this;
}
inline GraphProto& operator=(GraphProto&& 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;
}
inline const std::string& unknown_fields() const {
return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
}
inline std::string* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<std::string>();
}
static const GraphProto& default_instance() {
return *internal_default_instance();
}
static inline const GraphProto* internal_default_instance() {
return reinterpret_cast<const GraphProto*>(
&_GraphProto_default_instance_);
}
static constexpr int kIndexInFileMessages =
13;
friend void swap(GraphProto& a, GraphProto& b) {
a.Swap(&b);
}
inline void Swap(GraphProto* 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(GraphProto* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
GraphProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<GraphProto>(arena);
}
void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
void CopyFrom(const GraphProto& from);
void MergeFrom(const GraphProto& from);
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 _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const;
void InternalSwap(GraphProto* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "opencv_onnx.GraphProto";
}
protected:
explicit GraphProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
std::string GetTypeName() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kNodeFieldNumber = 1,
kInitializerFieldNumber = 5,
kInputFieldNumber = 11,
kOutputFieldNumber = 12,
kValueInfoFieldNumber = 13,
kQuantizationAnnotationFieldNumber = 14,
kSparseInitializerFieldNumber = 15,
kMetadataPropsFieldNumber = 16,
kNameFieldNumber = 2,
kDocStringFieldNumber = 10,
};
// repeated .opencv_onnx.NodeProto node = 1;
int node_size() const;
private:
int _internal_node_size() const;
public:
void clear_node();
::opencv_onnx::NodeProto* mutable_node(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::NodeProto >*
mutable_node();
private:
const ::opencv_onnx::NodeProto& _internal_node(int index) const;
::opencv_onnx::NodeProto* _internal_add_node();
public:
const ::opencv_onnx::NodeProto& node(int index) const;
::opencv_onnx::NodeProto* add_node();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::NodeProto >&
node() const;
// repeated .opencv_onnx.TensorProto initializer = 5;
int initializer_size() const;
private:
int _internal_initializer_size() const;
public:
void clear_initializer();
::opencv_onnx::TensorProto* mutable_initializer(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::TensorProto >*
mutable_initializer();
private:
const ::opencv_onnx::TensorProto& _internal_initializer(int index) const;
::opencv_onnx::TensorProto* _internal_add_initializer();
public:
const ::opencv_onnx::TensorProto& initializer(int index) const;
::opencv_onnx::TensorProto* add_initializer();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::TensorProto >&
initializer() const;
// repeated .opencv_onnx.ValueInfoProto input = 11;
int input_size() const;
private:
int _internal_input_size() const;
public:
void clear_input();
::opencv_onnx::ValueInfoProto* mutable_input(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::ValueInfoProto >*
mutable_input();
private:
const ::opencv_onnx::ValueInfoProto& _internal_input(int index) const;
::opencv_onnx::ValueInfoProto* _internal_add_input();
public:
const ::opencv_onnx::ValueInfoProto& input(int index) const;
::opencv_onnx::ValueInfoProto* add_input();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::ValueInfoProto >&
input() const;
// repeated .opencv_onnx.ValueInfoProto output = 12;
int output_size() const;
private:
int _internal_output_size() const;
public:
void clear_output();
::opencv_onnx::ValueInfoProto* mutable_output(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::ValueInfoProto >*
mutable_output();
private:
const ::opencv_onnx::ValueInfoProto& _internal_output(int index) const;
::opencv_onnx::ValueInfoProto* _internal_add_output();
public:
const ::opencv_onnx::ValueInfoProto& output(int index) const;
::opencv_onnx::ValueInfoProto* add_output();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::ValueInfoProto >&
output() const;
// repeated .opencv_onnx.ValueInfoProto value_info = 13;
int value_info_size() const;
private:
int _internal_value_info_size() const;
public:
void clear_value_info();
::opencv_onnx::ValueInfoProto* mutable_value_info(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::ValueInfoProto >*
mutable_value_info();
private:
const ::opencv_onnx::ValueInfoProto& _internal_value_info(int index) const;
::opencv_onnx::ValueInfoProto* _internal_add_value_info();
public:
const ::opencv_onnx::ValueInfoProto& value_info(int index) const;
::opencv_onnx::ValueInfoProto* add_value_info();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::ValueInfoProto >&
value_info() const;
// repeated .opencv_onnx.TensorAnnotation quantization_annotation = 14;
int quantization_annotation_size() const;
private:
int _internal_quantization_annotation_size() const;
public:
void clear_quantization_annotation();
::opencv_onnx::TensorAnnotation* mutable_quantization_annotation(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::TensorAnnotation >*
mutable_quantization_annotation();
private:
const ::opencv_onnx::TensorAnnotation& _internal_quantization_annotation(int index) const;
::opencv_onnx::TensorAnnotation* _internal_add_quantization_annotation();
public:
const ::opencv_onnx::TensorAnnotation& quantization_annotation(int index) const;
::opencv_onnx::TensorAnnotation* add_quantization_annotation();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::TensorAnnotation >&
quantization_annotation() const;
// repeated .opencv_onnx.SparseTensorProto sparse_initializer = 15;
int sparse_initializer_size() const;
private:
int _internal_sparse_initializer_size() const;
public:
void clear_sparse_initializer();
::opencv_onnx::SparseTensorProto* mutable_sparse_initializer(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::SparseTensorProto >*
mutable_sparse_initializer();
private:
const ::opencv_onnx::SparseTensorProto& _internal_sparse_initializer(int index) const;
::opencv_onnx::SparseTensorProto* _internal_add_sparse_initializer();
public:
const ::opencv_onnx::SparseTensorProto& sparse_initializer(int index) const;
::opencv_onnx::SparseTensorProto* add_sparse_initializer();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::SparseTensorProto >&
sparse_initializer() const;
// repeated .opencv_onnx.StringStringEntryProto metadata_props = 16;
int metadata_props_size() const;
private:
int _internal_metadata_props_size() const;
public:
void clear_metadata_props();
::opencv_onnx::StringStringEntryProto* mutable_metadata_props(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::StringStringEntryProto >*
mutable_metadata_props();
private:
const ::opencv_onnx::StringStringEntryProto& _internal_metadata_props(int index) const;
::opencv_onnx::StringStringEntryProto* _internal_add_metadata_props();
public:
const ::opencv_onnx::StringStringEntryProto& metadata_props(int index) const;
::opencv_onnx::StringStringEntryProto* add_metadata_props();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::StringStringEntryProto >&
metadata_props() const;
// optional string name = 2;
bool has_name() const;
private:
bool _internal_has_name() const;
public:
void clear_name();
const std::string& name() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_name(ArgT0&& arg0, ArgT... args);
std::string* mutable_name();
PROTOBUF_NODISCARD std::string* release_name();
void set_allocated_name(std::string* name);
private:
const std::string& _internal_name() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
std::string* _internal_mutable_name();
public:
// optional string doc_string = 10;
bool has_doc_string() const;
private:
bool _internal_has_doc_string() const;
public:
void clear_doc_string();
const std::string& doc_string() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_doc_string(ArgT0&& arg0, ArgT... args);
std::string* mutable_doc_string();
PROTOBUF_NODISCARD std::string* release_doc_string();
void set_allocated_doc_string(std::string* doc_string);
private:
const std::string& _internal_doc_string() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_doc_string(const std::string& value);
std::string* _internal_mutable_doc_string();
public:
// @@protoc_insertion_point(class_scope:opencv_onnx.GraphProto)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::NodeProto > node_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::TensorProto > initializer_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::ValueInfoProto > input_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::ValueInfoProto > output_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::ValueInfoProto > value_info_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::TensorAnnotation > quantization_annotation_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::SparseTensorProto > sparse_initializer_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::StringStringEntryProto > metadata_props_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr doc_string_;
friend struct ::TableStruct_opencv_2donnx_2eproto;
};
// -------------------------------------------------------------------
class TensorProto_Segment final :
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:opencv_onnx.TensorProto.Segment) */ {
public:
inline TensorProto_Segment() : TensorProto_Segment(nullptr) {}
~TensorProto_Segment() override;
explicit constexpr TensorProto_Segment(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
TensorProto_Segment(const TensorProto_Segment& from);
TensorProto_Segment(TensorProto_Segment&& from) noexcept
: TensorProto_Segment() {
*this = ::std::move(from);
}
inline TensorProto_Segment& operator=(const TensorProto_Segment& from) {
CopyFrom(from);
return *this;
}
inline TensorProto_Segment& operator=(TensorProto_Segment&& 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;
}
inline const std::string& unknown_fields() const {
return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
}
inline std::string* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<std::string>();
}
static const TensorProto_Segment& default_instance() {
return *internal_default_instance();
}
static inline const TensorProto_Segment* internal_default_instance() {
return reinterpret_cast<const TensorProto_Segment*>(
&_TensorProto_Segment_default_instance_);
}
static constexpr int kIndexInFileMessages =
14;
friend void swap(TensorProto_Segment& a, TensorProto_Segment& b) {
a.Swap(&b);
}
inline void Swap(TensorProto_Segment* 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(TensorProto_Segment* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
TensorProto_Segment* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<TensorProto_Segment>(arena);
}
void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
void CopyFrom(const TensorProto_Segment& from);
void MergeFrom(const TensorProto_Segment& from);
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 _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const;
void InternalSwap(TensorProto_Segment* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "opencv_onnx.TensorProto.Segment";
}
protected:
explicit TensorProto_Segment(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
std::string GetTypeName() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kBeginFieldNumber = 1,
kEndFieldNumber = 2,
};
// optional int64 begin = 1;
bool has_begin() const;
private:
bool _internal_has_begin() const;
public:
void clear_begin();
int64_t begin() const;
void set_begin(int64_t value);
private:
int64_t _internal_begin() const;
void _internal_set_begin(int64_t value);
public:
// optional int64 end = 2;
bool has_end() const;
private:
bool _internal_has_end() const;
public:
void clear_end();
int64_t end() const;
void set_end(int64_t value);
private:
int64_t _internal_end() const;
void _internal_set_end(int64_t value);
public:
// @@protoc_insertion_point(class_scope:opencv_onnx.TensorProto.Segment)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
int64_t begin_;
int64_t end_;
friend struct ::TableStruct_opencv_2donnx_2eproto;
};
// -------------------------------------------------------------------
class TensorProto final :
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:opencv_onnx.TensorProto) */ {
public:
inline TensorProto() : TensorProto(nullptr) {}
~TensorProto() override;
explicit constexpr TensorProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
TensorProto(const TensorProto& from);
TensorProto(TensorProto&& from) noexcept
: TensorProto() {
*this = ::std::move(from);
}
inline TensorProto& operator=(const TensorProto& from) {
CopyFrom(from);
return *this;
}
inline TensorProto& operator=(TensorProto&& 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;
}
inline const std::string& unknown_fields() const {
return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
}
inline std::string* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<std::string>();
}
static const TensorProto& default_instance() {
return *internal_default_instance();
}
static inline const TensorProto* internal_default_instance() {
return reinterpret_cast<const TensorProto*>(
&_TensorProto_default_instance_);
}
static constexpr int kIndexInFileMessages =
15;
friend void swap(TensorProto& a, TensorProto& b) {
a.Swap(&b);
}
inline void Swap(TensorProto* 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(TensorProto* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
TensorProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<TensorProto>(arena);
}
void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
void CopyFrom(const TensorProto& from);
void MergeFrom(const TensorProto& from);
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 _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const;
void InternalSwap(TensorProto* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "opencv_onnx.TensorProto";
}
protected:
explicit TensorProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
std::string GetTypeName() const final;
// nested types ----------------------------------------------------
typedef TensorProto_Segment Segment;
typedef TensorProto_DataType DataType;
static constexpr DataType UNDEFINED =
TensorProto_DataType_UNDEFINED;
static constexpr DataType FLOAT =
TensorProto_DataType_FLOAT;
static constexpr DataType UINT8 =
TensorProto_DataType_UINT8;
static constexpr DataType INT8 =
TensorProto_DataType_INT8;
static constexpr DataType UINT16 =
TensorProto_DataType_UINT16;
static constexpr DataType INT16 =
TensorProto_DataType_INT16;
static constexpr DataType INT32 =
TensorProto_DataType_INT32;
static constexpr DataType INT64 =
TensorProto_DataType_INT64;
static constexpr DataType STRING =
TensorProto_DataType_STRING;
static constexpr DataType BOOL =
TensorProto_DataType_BOOL;
static constexpr DataType FLOAT16 =
TensorProto_DataType_FLOAT16;
static constexpr DataType DOUBLE =
TensorProto_DataType_DOUBLE;
static constexpr DataType UINT32 =
TensorProto_DataType_UINT32;
static constexpr DataType UINT64 =
TensorProto_DataType_UINT64;
static constexpr DataType COMPLEX64 =
TensorProto_DataType_COMPLEX64;
static constexpr DataType COMPLEX128 =
TensorProto_DataType_COMPLEX128;
static constexpr DataType BFLOAT16 =
TensorProto_DataType_BFLOAT16;
static constexpr DataType FLOAT8E4M3FN =
TensorProto_DataType_FLOAT8E4M3FN;
static constexpr DataType FLOAT8E4M3FNUZ =
TensorProto_DataType_FLOAT8E4M3FNUZ;
static constexpr DataType FLOAT8E5M2 =
TensorProto_DataType_FLOAT8E5M2;
static constexpr DataType FLOAT8E5M2FNUZ =
TensorProto_DataType_FLOAT8E5M2FNUZ;
static constexpr DataType UINT4 =
TensorProto_DataType_UINT4;
static constexpr DataType INT4 =
TensorProto_DataType_INT4;
static constexpr DataType FLOAT4E2M1 =
TensorProto_DataType_FLOAT4E2M1;
static inline bool DataType_IsValid(int value) {
return TensorProto_DataType_IsValid(value);
}
static constexpr DataType DataType_MIN =
TensorProto_DataType_DataType_MIN;
static constexpr DataType DataType_MAX =
TensorProto_DataType_DataType_MAX;
static constexpr int DataType_ARRAYSIZE =
TensorProto_DataType_DataType_ARRAYSIZE;
template<typename T>
static inline const std::string& DataType_Name(T enum_t_value) {
static_assert(::std::is_same<T, DataType>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function DataType_Name.");
return TensorProto_DataType_Name(enum_t_value);
}
static inline bool DataType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
DataType* value) {
return TensorProto_DataType_Parse(name, value);
}
typedef TensorProto_DataLocation DataLocation;
static constexpr DataLocation DEFAULT =
TensorProto_DataLocation_DEFAULT;
static constexpr DataLocation EXTERNAL =
TensorProto_DataLocation_EXTERNAL;
static inline bool DataLocation_IsValid(int value) {
return TensorProto_DataLocation_IsValid(value);
}
static constexpr DataLocation DataLocation_MIN =
TensorProto_DataLocation_DataLocation_MIN;
static constexpr DataLocation DataLocation_MAX =
TensorProto_DataLocation_DataLocation_MAX;
static constexpr int DataLocation_ARRAYSIZE =
TensorProto_DataLocation_DataLocation_ARRAYSIZE;
template<typename T>
static inline const std::string& DataLocation_Name(T enum_t_value) {
static_assert(::std::is_same<T, DataLocation>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function DataLocation_Name.");
return TensorProto_DataLocation_Name(enum_t_value);
}
static inline bool DataLocation_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
DataLocation* value) {
return TensorProto_DataLocation_Parse(name, value);
}
// accessors -------------------------------------------------------
enum : int {
kDimsFieldNumber = 1,
kFloatDataFieldNumber = 4,
kInt32DataFieldNumber = 5,
kStringDataFieldNumber = 6,
kInt64DataFieldNumber = 7,
kDoubleDataFieldNumber = 10,
kUint64DataFieldNumber = 11,
kExternalDataFieldNumber = 13,
kMetadataPropsFieldNumber = 16,
kNameFieldNumber = 8,
kRawDataFieldNumber = 9,
kDocStringFieldNumber = 12,
kSegmentFieldNumber = 3,
kDataTypeFieldNumber = 2,
kDataLocationFieldNumber = 14,
};
// repeated int64 dims = 1;
int dims_size() const;
private:
int _internal_dims_size() const;
public:
void clear_dims();
private:
int64_t _internal_dims(int index) const;
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
_internal_dims() const;
void _internal_add_dims(int64_t value);
::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
_internal_mutable_dims();
public:
int64_t dims(int index) const;
void set_dims(int index, int64_t value);
void add_dims(int64_t value);
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
dims() const;
::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
mutable_dims();
// repeated float float_data = 4 [packed = true];
int float_data_size() const;
private:
int _internal_float_data_size() const;
public:
void clear_float_data();
private:
float _internal_float_data(int index) const;
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
_internal_float_data() const;
void _internal_add_float_data(float value);
::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
_internal_mutable_float_data();
public:
float float_data(int index) const;
void set_float_data(int index, float value);
void add_float_data(float value);
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
float_data() const;
::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
mutable_float_data();
// repeated int32 int32_data = 5 [packed = true];
int int32_data_size() const;
private:
int _internal_int32_data_size() const;
public:
void clear_int32_data();
private:
int32_t _internal_int32_data(int index) const;
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
_internal_int32_data() const;
void _internal_add_int32_data(int32_t value);
::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
_internal_mutable_int32_data();
public:
int32_t int32_data(int index) const;
void set_int32_data(int index, int32_t value);
void add_int32_data(int32_t value);
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
int32_data() const;
::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
mutable_int32_data();
// repeated bytes string_data = 6;
int string_data_size() const;
private:
int _internal_string_data_size() const;
public:
void clear_string_data();
const std::string& string_data(int index) const;
std::string* mutable_string_data(int index);
void set_string_data(int index, const std::string& value);
void set_string_data(int index, std::string&& value);
void set_string_data(int index, const char* value);
void set_string_data(int index, const void* value, size_t size);
std::string* add_string_data();
void add_string_data(const std::string& value);
void add_string_data(std::string&& value);
void add_string_data(const char* value);
void add_string_data(const void* value, size_t size);
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& string_data() const;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_string_data();
private:
const std::string& _internal_string_data(int index) const;
std::string* _internal_add_string_data();
public:
// repeated int64 int64_data = 7 [packed = true];
int int64_data_size() const;
private:
int _internal_int64_data_size() const;
public:
void clear_int64_data();
private:
int64_t _internal_int64_data(int index) const;
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
_internal_int64_data() const;
void _internal_add_int64_data(int64_t value);
::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
_internal_mutable_int64_data();
public:
int64_t int64_data(int index) const;
void set_int64_data(int index, int64_t value);
void add_int64_data(int64_t value);
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
int64_data() const;
::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
mutable_int64_data();
// repeated double double_data = 10 [packed = true];
int double_data_size() const;
private:
int _internal_double_data_size() const;
public:
void clear_double_data();
private:
double _internal_double_data(int index) const;
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
_internal_double_data() const;
void _internal_add_double_data(double value);
::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
_internal_mutable_double_data();
public:
double double_data(int index) const;
void set_double_data(int index, double value);
void add_double_data(double value);
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
double_data() const;
::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
mutable_double_data();
// repeated uint64 uint64_data = 11 [packed = true];
int uint64_data_size() const;
private:
int _internal_uint64_data_size() const;
public:
void clear_uint64_data();
private:
uint64_t _internal_uint64_data(int index) const;
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
_internal_uint64_data() const;
void _internal_add_uint64_data(uint64_t value);
::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
_internal_mutable_uint64_data();
public:
uint64_t uint64_data(int index) const;
void set_uint64_data(int index, uint64_t value);
void add_uint64_data(uint64_t value);
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
uint64_data() const;
::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
mutable_uint64_data();
// repeated .opencv_onnx.StringStringEntryProto external_data = 13;
int external_data_size() const;
private:
int _internal_external_data_size() const;
public:
void clear_external_data();
::opencv_onnx::StringStringEntryProto* mutable_external_data(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::StringStringEntryProto >*
mutable_external_data();
private:
const ::opencv_onnx::StringStringEntryProto& _internal_external_data(int index) const;
::opencv_onnx::StringStringEntryProto* _internal_add_external_data();
public:
const ::opencv_onnx::StringStringEntryProto& external_data(int index) const;
::opencv_onnx::StringStringEntryProto* add_external_data();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::StringStringEntryProto >&
external_data() const;
// repeated .opencv_onnx.StringStringEntryProto metadata_props = 16;
int metadata_props_size() const;
private:
int _internal_metadata_props_size() const;
public:
void clear_metadata_props();
::opencv_onnx::StringStringEntryProto* mutable_metadata_props(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::StringStringEntryProto >*
mutable_metadata_props();
private:
const ::opencv_onnx::StringStringEntryProto& _internal_metadata_props(int index) const;
::opencv_onnx::StringStringEntryProto* _internal_add_metadata_props();
public:
const ::opencv_onnx::StringStringEntryProto& metadata_props(int index) const;
::opencv_onnx::StringStringEntryProto* add_metadata_props();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::StringStringEntryProto >&
metadata_props() const;
// optional string name = 8;
bool has_name() const;
private:
bool _internal_has_name() const;
public:
void clear_name();
const std::string& name() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_name(ArgT0&& arg0, ArgT... args);
std::string* mutable_name();
PROTOBUF_NODISCARD std::string* release_name();
void set_allocated_name(std::string* name);
private:
const std::string& _internal_name() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
std::string* _internal_mutable_name();
public:
// optional bytes raw_data = 9;
bool has_raw_data() const;
private:
bool _internal_has_raw_data() const;
public:
void clear_raw_data();
const std::string& raw_data() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_raw_data(ArgT0&& arg0, ArgT... args);
std::string* mutable_raw_data();
PROTOBUF_NODISCARD std::string* release_raw_data();
void set_allocated_raw_data(std::string* raw_data);
private:
const std::string& _internal_raw_data() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_raw_data(const std::string& value);
std::string* _internal_mutable_raw_data();
public:
// optional string doc_string = 12;
bool has_doc_string() const;
private:
bool _internal_has_doc_string() const;
public:
void clear_doc_string();
const std::string& doc_string() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_doc_string(ArgT0&& arg0, ArgT... args);
std::string* mutable_doc_string();
PROTOBUF_NODISCARD std::string* release_doc_string();
void set_allocated_doc_string(std::string* doc_string);
private:
const std::string& _internal_doc_string() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_doc_string(const std::string& value);
std::string* _internal_mutable_doc_string();
public:
// optional .opencv_onnx.TensorProto.Segment segment = 3;
bool has_segment() const;
private:
bool _internal_has_segment() const;
public:
void clear_segment();
const ::opencv_onnx::TensorProto_Segment& segment() const;
PROTOBUF_NODISCARD ::opencv_onnx::TensorProto_Segment* release_segment();
::opencv_onnx::TensorProto_Segment* mutable_segment();
void set_allocated_segment(::opencv_onnx::TensorProto_Segment* segment);
private:
const ::opencv_onnx::TensorProto_Segment& _internal_segment() const;
::opencv_onnx::TensorProto_Segment* _internal_mutable_segment();
public:
void unsafe_arena_set_allocated_segment(
::opencv_onnx::TensorProto_Segment* segment);
::opencv_onnx::TensorProto_Segment* unsafe_arena_release_segment();
// optional int32 data_type = 2;
bool has_data_type() const;
private:
bool _internal_has_data_type() const;
public:
void clear_data_type();
int32_t data_type() const;
void set_data_type(int32_t value);
private:
int32_t _internal_data_type() const;
void _internal_set_data_type(int32_t value);
public:
// optional .opencv_onnx.TensorProto.DataLocation data_location = 14;
bool has_data_location() const;
private:
bool _internal_has_data_location() const;
public:
void clear_data_location();
::opencv_onnx::TensorProto_DataLocation data_location() const;
void set_data_location(::opencv_onnx::TensorProto_DataLocation value);
private:
::opencv_onnx::TensorProto_DataLocation _internal_data_location() const;
void _internal_set_data_location(::opencv_onnx::TensorProto_DataLocation value);
public:
// @@protoc_insertion_point(class_scope:opencv_onnx.TensorProto)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > dims_;
::PROTOBUF_NAMESPACE_ID::RepeatedField< float > float_data_;
::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > int32_data_;
mutable std::atomic<int> _int32_data_cached_byte_size_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> string_data_;
::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > int64_data_;
mutable std::atomic<int> _int64_data_cached_byte_size_;
::PROTOBUF_NAMESPACE_ID::RepeatedField< double > double_data_;
::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t > uint64_data_;
mutable std::atomic<int> _uint64_data_cached_byte_size_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::StringStringEntryProto > external_data_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::StringStringEntryProto > metadata_props_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr raw_data_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr doc_string_;
::opencv_onnx::TensorProto_Segment* segment_;
int32_t data_type_;
int data_location_;
friend struct ::TableStruct_opencv_2donnx_2eproto;
};
// -------------------------------------------------------------------
class SparseTensorProto final :
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:opencv_onnx.SparseTensorProto) */ {
public:
inline SparseTensorProto() : SparseTensorProto(nullptr) {}
~SparseTensorProto() override;
explicit constexpr SparseTensorProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
SparseTensorProto(const SparseTensorProto& from);
SparseTensorProto(SparseTensorProto&& from) noexcept
: SparseTensorProto() {
*this = ::std::move(from);
}
inline SparseTensorProto& operator=(const SparseTensorProto& from) {
CopyFrom(from);
return *this;
}
inline SparseTensorProto& operator=(SparseTensorProto&& 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;
}
inline const std::string& unknown_fields() const {
return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
}
inline std::string* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<std::string>();
}
static const SparseTensorProto& default_instance() {
return *internal_default_instance();
}
static inline const SparseTensorProto* internal_default_instance() {
return reinterpret_cast<const SparseTensorProto*>(
&_SparseTensorProto_default_instance_);
}
static constexpr int kIndexInFileMessages =
16;
friend void swap(SparseTensorProto& a, SparseTensorProto& b) {
a.Swap(&b);
}
inline void Swap(SparseTensorProto* 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(SparseTensorProto* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
SparseTensorProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<SparseTensorProto>(arena);
}
void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
void CopyFrom(const SparseTensorProto& from);
void MergeFrom(const SparseTensorProto& from);
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 _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const;
void InternalSwap(SparseTensorProto* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "opencv_onnx.SparseTensorProto";
}
protected:
explicit SparseTensorProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
std::string GetTypeName() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kDimsFieldNumber = 3,
kValuesFieldNumber = 1,
kIndicesFieldNumber = 2,
};
// repeated int64 dims = 3;
int dims_size() const;
private:
int _internal_dims_size() const;
public:
void clear_dims();
private:
int64_t _internal_dims(int index) const;
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
_internal_dims() const;
void _internal_add_dims(int64_t value);
::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
_internal_mutable_dims();
public:
int64_t dims(int index) const;
void set_dims(int index, int64_t value);
void add_dims(int64_t value);
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
dims() const;
::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
mutable_dims();
// optional .opencv_onnx.TensorProto values = 1;
bool has_values() const;
private:
bool _internal_has_values() const;
public:
void clear_values();
const ::opencv_onnx::TensorProto& values() const;
PROTOBUF_NODISCARD ::opencv_onnx::TensorProto* release_values();
::opencv_onnx::TensorProto* mutable_values();
void set_allocated_values(::opencv_onnx::TensorProto* values);
private:
const ::opencv_onnx::TensorProto& _internal_values() const;
::opencv_onnx::TensorProto* _internal_mutable_values();
public:
void unsafe_arena_set_allocated_values(
::opencv_onnx::TensorProto* values);
::opencv_onnx::TensorProto* unsafe_arena_release_values();
// optional .opencv_onnx.TensorProto indices = 2;
bool has_indices() const;
private:
bool _internal_has_indices() const;
public:
void clear_indices();
const ::opencv_onnx::TensorProto& indices() const;
PROTOBUF_NODISCARD ::opencv_onnx::TensorProto* release_indices();
::opencv_onnx::TensorProto* mutable_indices();
void set_allocated_indices(::opencv_onnx::TensorProto* indices);
private:
const ::opencv_onnx::TensorProto& _internal_indices() const;
::opencv_onnx::TensorProto* _internal_mutable_indices();
public:
void unsafe_arena_set_allocated_indices(
::opencv_onnx::TensorProto* indices);
::opencv_onnx::TensorProto* unsafe_arena_release_indices();
// @@protoc_insertion_point(class_scope:opencv_onnx.SparseTensorProto)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > dims_;
::opencv_onnx::TensorProto* values_;
::opencv_onnx::TensorProto* indices_;
friend struct ::TableStruct_opencv_2donnx_2eproto;
};
// -------------------------------------------------------------------
class TensorShapeProto_Dimension final :
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:opencv_onnx.TensorShapeProto.Dimension) */ {
public:
inline TensorShapeProto_Dimension() : TensorShapeProto_Dimension(nullptr) {}
~TensorShapeProto_Dimension() override;
explicit constexpr TensorShapeProto_Dimension(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
TensorShapeProto_Dimension(const TensorShapeProto_Dimension& from);
TensorShapeProto_Dimension(TensorShapeProto_Dimension&& from) noexcept
: TensorShapeProto_Dimension() {
*this = ::std::move(from);
}
inline TensorShapeProto_Dimension& operator=(const TensorShapeProto_Dimension& from) {
CopyFrom(from);
return *this;
}
inline TensorShapeProto_Dimension& operator=(TensorShapeProto_Dimension&& 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;
}
inline const std::string& unknown_fields() const {
return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
}
inline std::string* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<std::string>();
}
static const TensorShapeProto_Dimension& default_instance() {
return *internal_default_instance();
}
enum ValueCase {
kDimValue = 1,
kDimParam = 2,
VALUE_NOT_SET = 0,
};
static inline const TensorShapeProto_Dimension* internal_default_instance() {
return reinterpret_cast<const TensorShapeProto_Dimension*>(
&_TensorShapeProto_Dimension_default_instance_);
}
static constexpr int kIndexInFileMessages =
17;
friend void swap(TensorShapeProto_Dimension& a, TensorShapeProto_Dimension& b) {
a.Swap(&b);
}
inline void Swap(TensorShapeProto_Dimension* 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(TensorShapeProto_Dimension* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
TensorShapeProto_Dimension* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<TensorShapeProto_Dimension>(arena);
}
void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
void CopyFrom(const TensorShapeProto_Dimension& from);
void MergeFrom(const TensorShapeProto_Dimension& from);
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 _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const;
void InternalSwap(TensorShapeProto_Dimension* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "opencv_onnx.TensorShapeProto.Dimension";
}
protected:
explicit TensorShapeProto_Dimension(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
std::string GetTypeName() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kDenotationFieldNumber = 3,
kDimValueFieldNumber = 1,
kDimParamFieldNumber = 2,
};
// optional string denotation = 3;
bool has_denotation() const;
private:
bool _internal_has_denotation() const;
public:
void clear_denotation();
const std::string& denotation() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_denotation(ArgT0&& arg0, ArgT... args);
std::string* mutable_denotation();
PROTOBUF_NODISCARD std::string* release_denotation();
void set_allocated_denotation(std::string* denotation);
private:
const std::string& _internal_denotation() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_denotation(const std::string& value);
std::string* _internal_mutable_denotation();
public:
// int64 dim_value = 1;
bool has_dim_value() const;
private:
bool _internal_has_dim_value() const;
public:
void clear_dim_value();
int64_t dim_value() const;
void set_dim_value(int64_t value);
private:
int64_t _internal_dim_value() const;
void _internal_set_dim_value(int64_t value);
public:
// string dim_param = 2;
bool has_dim_param() const;
private:
bool _internal_has_dim_param() const;
public:
void clear_dim_param();
const std::string& dim_param() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_dim_param(ArgT0&& arg0, ArgT... args);
std::string* mutable_dim_param();
PROTOBUF_NODISCARD std::string* release_dim_param();
void set_allocated_dim_param(std::string* dim_param);
private:
const std::string& _internal_dim_param() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_dim_param(const std::string& value);
std::string* _internal_mutable_dim_param();
public:
void clear_value();
ValueCase value_case() const;
// @@protoc_insertion_point(class_scope:opencv_onnx.TensorShapeProto.Dimension)
private:
class _Internal;
void set_has_dim_value();
void set_has_dim_param();
inline bool has_value() const;
inline void clear_has_value();
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr denotation_;
union ValueUnion {
constexpr ValueUnion() : _constinit_{} {}
::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
int64_t dim_value_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr dim_param_;
} value_;
uint32_t _oneof_case_[1];
friend struct ::TableStruct_opencv_2donnx_2eproto;
};
// -------------------------------------------------------------------
class TensorShapeProto final :
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:opencv_onnx.TensorShapeProto) */ {
public:
inline TensorShapeProto() : TensorShapeProto(nullptr) {}
~TensorShapeProto() override;
explicit constexpr TensorShapeProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
TensorShapeProto(const TensorShapeProto& from);
TensorShapeProto(TensorShapeProto&& from) noexcept
: TensorShapeProto() {
*this = ::std::move(from);
}
inline TensorShapeProto& operator=(const TensorShapeProto& from) {
CopyFrom(from);
return *this;
}
inline TensorShapeProto& operator=(TensorShapeProto&& 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;
}
inline const std::string& unknown_fields() const {
return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
}
inline std::string* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<std::string>();
}
static const TensorShapeProto& default_instance() {
return *internal_default_instance();
}
static inline const TensorShapeProto* internal_default_instance() {
return reinterpret_cast<const TensorShapeProto*>(
&_TensorShapeProto_default_instance_);
}
static constexpr int kIndexInFileMessages =
18;
friend void swap(TensorShapeProto& a, TensorShapeProto& b) {
a.Swap(&b);
}
inline void Swap(TensorShapeProto* 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(TensorShapeProto* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
TensorShapeProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<TensorShapeProto>(arena);
}
void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
void CopyFrom(const TensorShapeProto& from);
void MergeFrom(const TensorShapeProto& from);
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 _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const;
void InternalSwap(TensorShapeProto* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "opencv_onnx.TensorShapeProto";
}
protected:
explicit TensorShapeProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
std::string GetTypeName() const final;
// nested types ----------------------------------------------------
typedef TensorShapeProto_Dimension Dimension;
// accessors -------------------------------------------------------
enum : int {
kDimFieldNumber = 1,
};
// repeated .opencv_onnx.TensorShapeProto.Dimension dim = 1;
int dim_size() const;
private:
int _internal_dim_size() const;
public:
void clear_dim();
::opencv_onnx::TensorShapeProto_Dimension* mutable_dim(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::TensorShapeProto_Dimension >*
mutable_dim();
private:
const ::opencv_onnx::TensorShapeProto_Dimension& _internal_dim(int index) const;
::opencv_onnx::TensorShapeProto_Dimension* _internal_add_dim();
public:
const ::opencv_onnx::TensorShapeProto_Dimension& dim(int index) const;
::opencv_onnx::TensorShapeProto_Dimension* add_dim();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::TensorShapeProto_Dimension >&
dim() const;
// @@protoc_insertion_point(class_scope:opencv_onnx.TensorShapeProto)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::TensorShapeProto_Dimension > dim_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
friend struct ::TableStruct_opencv_2donnx_2eproto;
};
// -------------------------------------------------------------------
class TypeProto_Tensor final :
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:opencv_onnx.TypeProto.Tensor) */ {
public:
inline TypeProto_Tensor() : TypeProto_Tensor(nullptr) {}
~TypeProto_Tensor() override;
explicit constexpr TypeProto_Tensor(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
TypeProto_Tensor(const TypeProto_Tensor& from);
TypeProto_Tensor(TypeProto_Tensor&& from) noexcept
: TypeProto_Tensor() {
*this = ::std::move(from);
}
inline TypeProto_Tensor& operator=(const TypeProto_Tensor& from) {
CopyFrom(from);
return *this;
}
inline TypeProto_Tensor& operator=(TypeProto_Tensor&& 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;
}
inline const std::string& unknown_fields() const {
return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
}
inline std::string* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<std::string>();
}
static const TypeProto_Tensor& default_instance() {
return *internal_default_instance();
}
static inline const TypeProto_Tensor* internal_default_instance() {
return reinterpret_cast<const TypeProto_Tensor*>(
&_TypeProto_Tensor_default_instance_);
}
static constexpr int kIndexInFileMessages =
19;
friend void swap(TypeProto_Tensor& a, TypeProto_Tensor& b) {
a.Swap(&b);
}
inline void Swap(TypeProto_Tensor* 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(TypeProto_Tensor* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
TypeProto_Tensor* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<TypeProto_Tensor>(arena);
}
void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
void CopyFrom(const TypeProto_Tensor& from);
void MergeFrom(const TypeProto_Tensor& from);
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 _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const;
void InternalSwap(TypeProto_Tensor* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "opencv_onnx.TypeProto.Tensor";
}
protected:
explicit TypeProto_Tensor(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
std::string GetTypeName() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kShapeFieldNumber = 2,
kElemTypeFieldNumber = 1,
};
// optional .opencv_onnx.TensorShapeProto shape = 2;
bool has_shape() const;
private:
bool _internal_has_shape() const;
public:
void clear_shape();
const ::opencv_onnx::TensorShapeProto& shape() const;
PROTOBUF_NODISCARD ::opencv_onnx::TensorShapeProto* release_shape();
::opencv_onnx::TensorShapeProto* mutable_shape();
void set_allocated_shape(::opencv_onnx::TensorShapeProto* shape);
private:
const ::opencv_onnx::TensorShapeProto& _internal_shape() const;
::opencv_onnx::TensorShapeProto* _internal_mutable_shape();
public:
void unsafe_arena_set_allocated_shape(
::opencv_onnx::TensorShapeProto* shape);
::opencv_onnx::TensorShapeProto* unsafe_arena_release_shape();
// optional int32 elem_type = 1;
bool has_elem_type() const;
private:
bool _internal_has_elem_type() const;
public:
void clear_elem_type();
int32_t elem_type() const;
void set_elem_type(int32_t value);
private:
int32_t _internal_elem_type() const;
void _internal_set_elem_type(int32_t value);
public:
// @@protoc_insertion_point(class_scope:opencv_onnx.TypeProto.Tensor)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::opencv_onnx::TensorShapeProto* shape_;
int32_t elem_type_;
friend struct ::TableStruct_opencv_2donnx_2eproto;
};
// -------------------------------------------------------------------
class TypeProto_Sequence final :
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:opencv_onnx.TypeProto.Sequence) */ {
public:
inline TypeProto_Sequence() : TypeProto_Sequence(nullptr) {}
~TypeProto_Sequence() override;
explicit constexpr TypeProto_Sequence(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
TypeProto_Sequence(const TypeProto_Sequence& from);
TypeProto_Sequence(TypeProto_Sequence&& from) noexcept
: TypeProto_Sequence() {
*this = ::std::move(from);
}
inline TypeProto_Sequence& operator=(const TypeProto_Sequence& from) {
CopyFrom(from);
return *this;
}
inline TypeProto_Sequence& operator=(TypeProto_Sequence&& 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;
}
inline const std::string& unknown_fields() const {
return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
}
inline std::string* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<std::string>();
}
static const TypeProto_Sequence& default_instance() {
return *internal_default_instance();
}
static inline const TypeProto_Sequence* internal_default_instance() {
return reinterpret_cast<const TypeProto_Sequence*>(
&_TypeProto_Sequence_default_instance_);
}
static constexpr int kIndexInFileMessages =
20;
friend void swap(TypeProto_Sequence& a, TypeProto_Sequence& b) {
a.Swap(&b);
}
inline void Swap(TypeProto_Sequence* 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(TypeProto_Sequence* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
TypeProto_Sequence* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<TypeProto_Sequence>(arena);
}
void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
void CopyFrom(const TypeProto_Sequence& from);
void MergeFrom(const TypeProto_Sequence& from);
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 _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const;
void InternalSwap(TypeProto_Sequence* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "opencv_onnx.TypeProto.Sequence";
}
protected:
explicit TypeProto_Sequence(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
std::string GetTypeName() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kElemTypeFieldNumber = 1,
};
// optional .opencv_onnx.TypeProto elem_type = 1;
bool has_elem_type() const;
private:
bool _internal_has_elem_type() const;
public:
void clear_elem_type();
const ::opencv_onnx::TypeProto& elem_type() const;
PROTOBUF_NODISCARD ::opencv_onnx::TypeProto* release_elem_type();
::opencv_onnx::TypeProto* mutable_elem_type();
void set_allocated_elem_type(::opencv_onnx::TypeProto* elem_type);
private:
const ::opencv_onnx::TypeProto& _internal_elem_type() const;
::opencv_onnx::TypeProto* _internal_mutable_elem_type();
public:
void unsafe_arena_set_allocated_elem_type(
::opencv_onnx::TypeProto* elem_type);
::opencv_onnx::TypeProto* unsafe_arena_release_elem_type();
// @@protoc_insertion_point(class_scope:opencv_onnx.TypeProto.Sequence)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::opencv_onnx::TypeProto* elem_type_;
friend struct ::TableStruct_opencv_2donnx_2eproto;
};
// -------------------------------------------------------------------
class TypeProto_Map final :
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:opencv_onnx.TypeProto.Map) */ {
public:
inline TypeProto_Map() : TypeProto_Map(nullptr) {}
~TypeProto_Map() override;
explicit constexpr TypeProto_Map(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
TypeProto_Map(const TypeProto_Map& from);
TypeProto_Map(TypeProto_Map&& from) noexcept
: TypeProto_Map() {
*this = ::std::move(from);
}
inline TypeProto_Map& operator=(const TypeProto_Map& from) {
CopyFrom(from);
return *this;
}
inline TypeProto_Map& operator=(TypeProto_Map&& 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;
}
inline const std::string& unknown_fields() const {
return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
}
inline std::string* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<std::string>();
}
static const TypeProto_Map& default_instance() {
return *internal_default_instance();
}
static inline const TypeProto_Map* internal_default_instance() {
return reinterpret_cast<const TypeProto_Map*>(
&_TypeProto_Map_default_instance_);
}
static constexpr int kIndexInFileMessages =
21;
friend void swap(TypeProto_Map& a, TypeProto_Map& b) {
a.Swap(&b);
}
inline void Swap(TypeProto_Map* 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(TypeProto_Map* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
TypeProto_Map* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<TypeProto_Map>(arena);
}
void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
void CopyFrom(const TypeProto_Map& from);
void MergeFrom(const TypeProto_Map& from);
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 _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const;
void InternalSwap(TypeProto_Map* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "opencv_onnx.TypeProto.Map";
}
protected:
explicit TypeProto_Map(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
std::string GetTypeName() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kValueTypeFieldNumber = 2,
kKeyTypeFieldNumber = 1,
};
// optional .opencv_onnx.TypeProto value_type = 2;
bool has_value_type() const;
private:
bool _internal_has_value_type() const;
public:
void clear_value_type();
const ::opencv_onnx::TypeProto& value_type() const;
PROTOBUF_NODISCARD ::opencv_onnx::TypeProto* release_value_type();
::opencv_onnx::TypeProto* mutable_value_type();
void set_allocated_value_type(::opencv_onnx::TypeProto* value_type);
private:
const ::opencv_onnx::TypeProto& _internal_value_type() const;
::opencv_onnx::TypeProto* _internal_mutable_value_type();
public:
void unsafe_arena_set_allocated_value_type(
::opencv_onnx::TypeProto* value_type);
::opencv_onnx::TypeProto* unsafe_arena_release_value_type();
// optional int32 key_type = 1;
bool has_key_type() const;
private:
bool _internal_has_key_type() const;
public:
void clear_key_type();
int32_t key_type() const;
void set_key_type(int32_t value);
private:
int32_t _internal_key_type() const;
void _internal_set_key_type(int32_t value);
public:
// @@protoc_insertion_point(class_scope:opencv_onnx.TypeProto.Map)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::opencv_onnx::TypeProto* value_type_;
int32_t key_type_;
friend struct ::TableStruct_opencv_2donnx_2eproto;
};
// -------------------------------------------------------------------
class TypeProto_Optional final :
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:opencv_onnx.TypeProto.Optional) */ {
public:
inline TypeProto_Optional() : TypeProto_Optional(nullptr) {}
~TypeProto_Optional() override;
explicit constexpr TypeProto_Optional(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
TypeProto_Optional(const TypeProto_Optional& from);
TypeProto_Optional(TypeProto_Optional&& from) noexcept
: TypeProto_Optional() {
*this = ::std::move(from);
}
inline TypeProto_Optional& operator=(const TypeProto_Optional& from) {
CopyFrom(from);
return *this;
}
inline TypeProto_Optional& operator=(TypeProto_Optional&& 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;
}
inline const std::string& unknown_fields() const {
return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
}
inline std::string* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<std::string>();
}
static const TypeProto_Optional& default_instance() {
return *internal_default_instance();
}
static inline const TypeProto_Optional* internal_default_instance() {
return reinterpret_cast<const TypeProto_Optional*>(
&_TypeProto_Optional_default_instance_);
}
static constexpr int kIndexInFileMessages =
22;
friend void swap(TypeProto_Optional& a, TypeProto_Optional& b) {
a.Swap(&b);
}
inline void Swap(TypeProto_Optional* 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(TypeProto_Optional* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
TypeProto_Optional* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<TypeProto_Optional>(arena);
}
void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
void CopyFrom(const TypeProto_Optional& from);
void MergeFrom(const TypeProto_Optional& from);
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 _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const;
void InternalSwap(TypeProto_Optional* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "opencv_onnx.TypeProto.Optional";
}
protected:
explicit TypeProto_Optional(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
std::string GetTypeName() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kElemTypeFieldNumber = 1,
};
// optional .opencv_onnx.TypeProto elem_type = 1;
bool has_elem_type() const;
private:
bool _internal_has_elem_type() const;
public:
void clear_elem_type();
const ::opencv_onnx::TypeProto& elem_type() const;
PROTOBUF_NODISCARD ::opencv_onnx::TypeProto* release_elem_type();
::opencv_onnx::TypeProto* mutable_elem_type();
void set_allocated_elem_type(::opencv_onnx::TypeProto* elem_type);
private:
const ::opencv_onnx::TypeProto& _internal_elem_type() const;
::opencv_onnx::TypeProto* _internal_mutable_elem_type();
public:
void unsafe_arena_set_allocated_elem_type(
::opencv_onnx::TypeProto* elem_type);
::opencv_onnx::TypeProto* unsafe_arena_release_elem_type();
// @@protoc_insertion_point(class_scope:opencv_onnx.TypeProto.Optional)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::opencv_onnx::TypeProto* elem_type_;
friend struct ::TableStruct_opencv_2donnx_2eproto;
};
// -------------------------------------------------------------------
class TypeProto_SparseTensor final :
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:opencv_onnx.TypeProto.SparseTensor) */ {
public:
inline TypeProto_SparseTensor() : TypeProto_SparseTensor(nullptr) {}
~TypeProto_SparseTensor() override;
explicit constexpr TypeProto_SparseTensor(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
TypeProto_SparseTensor(const TypeProto_SparseTensor& from);
TypeProto_SparseTensor(TypeProto_SparseTensor&& from) noexcept
: TypeProto_SparseTensor() {
*this = ::std::move(from);
}
inline TypeProto_SparseTensor& operator=(const TypeProto_SparseTensor& from) {
CopyFrom(from);
return *this;
}
inline TypeProto_SparseTensor& operator=(TypeProto_SparseTensor&& 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;
}
inline const std::string& unknown_fields() const {
return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
}
inline std::string* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<std::string>();
}
static const TypeProto_SparseTensor& default_instance() {
return *internal_default_instance();
}
static inline const TypeProto_SparseTensor* internal_default_instance() {
return reinterpret_cast<const TypeProto_SparseTensor*>(
&_TypeProto_SparseTensor_default_instance_);
}
static constexpr int kIndexInFileMessages =
23;
friend void swap(TypeProto_SparseTensor& a, TypeProto_SparseTensor& b) {
a.Swap(&b);
}
inline void Swap(TypeProto_SparseTensor* 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(TypeProto_SparseTensor* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
TypeProto_SparseTensor* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<TypeProto_SparseTensor>(arena);
}
void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
void CopyFrom(const TypeProto_SparseTensor& from);
void MergeFrom(const TypeProto_SparseTensor& from);
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 _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const;
void InternalSwap(TypeProto_SparseTensor* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "opencv_onnx.TypeProto.SparseTensor";
}
protected:
explicit TypeProto_SparseTensor(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
std::string GetTypeName() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kShapeFieldNumber = 2,
kElemTypeFieldNumber = 1,
};
// optional .opencv_onnx.TensorShapeProto shape = 2;
bool has_shape() const;
private:
bool _internal_has_shape() const;
public:
void clear_shape();
const ::opencv_onnx::TensorShapeProto& shape() const;
PROTOBUF_NODISCARD ::opencv_onnx::TensorShapeProto* release_shape();
::opencv_onnx::TensorShapeProto* mutable_shape();
void set_allocated_shape(::opencv_onnx::TensorShapeProto* shape);
private:
const ::opencv_onnx::TensorShapeProto& _internal_shape() const;
::opencv_onnx::TensorShapeProto* _internal_mutable_shape();
public:
void unsafe_arena_set_allocated_shape(
::opencv_onnx::TensorShapeProto* shape);
::opencv_onnx::TensorShapeProto* unsafe_arena_release_shape();
// optional int32 elem_type = 1;
bool has_elem_type() const;
private:
bool _internal_has_elem_type() const;
public:
void clear_elem_type();
int32_t elem_type() const;
void set_elem_type(int32_t value);
private:
int32_t _internal_elem_type() const;
void _internal_set_elem_type(int32_t value);
public:
// @@protoc_insertion_point(class_scope:opencv_onnx.TypeProto.SparseTensor)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::opencv_onnx::TensorShapeProto* shape_;
int32_t elem_type_;
friend struct ::TableStruct_opencv_2donnx_2eproto;
};
// -------------------------------------------------------------------
class TypeProto final :
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:opencv_onnx.TypeProto) */ {
public:
inline TypeProto() : TypeProto(nullptr) {}
~TypeProto() override;
explicit constexpr TypeProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
TypeProto(const TypeProto& from);
TypeProto(TypeProto&& from) noexcept
: TypeProto() {
*this = ::std::move(from);
}
inline TypeProto& operator=(const TypeProto& from) {
CopyFrom(from);
return *this;
}
inline TypeProto& operator=(TypeProto&& 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;
}
inline const std::string& unknown_fields() const {
return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
}
inline std::string* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<std::string>();
}
static const TypeProto& default_instance() {
return *internal_default_instance();
}
enum ValueCase {
kTensorType = 1,
kSequenceType = 4,
kMapType = 5,
kOptionalType = 9,
kSparseTensorType = 8,
VALUE_NOT_SET = 0,
};
static inline const TypeProto* internal_default_instance() {
return reinterpret_cast<const TypeProto*>(
&_TypeProto_default_instance_);
}
static constexpr int kIndexInFileMessages =
24;
friend void swap(TypeProto& a, TypeProto& b) {
a.Swap(&b);
}
inline void Swap(TypeProto* 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(TypeProto* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
TypeProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<TypeProto>(arena);
}
void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
void CopyFrom(const TypeProto& from);
void MergeFrom(const TypeProto& from);
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 _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const;
void InternalSwap(TypeProto* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "opencv_onnx.TypeProto";
}
protected:
explicit TypeProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
std::string GetTypeName() const final;
// nested types ----------------------------------------------------
typedef TypeProto_Tensor Tensor;
typedef TypeProto_Sequence Sequence;
typedef TypeProto_Map Map;
typedef TypeProto_Optional Optional;
typedef TypeProto_SparseTensor SparseTensor;
// accessors -------------------------------------------------------
enum : int {
kDenotationFieldNumber = 6,
kTensorTypeFieldNumber = 1,
kSequenceTypeFieldNumber = 4,
kMapTypeFieldNumber = 5,
kOptionalTypeFieldNumber = 9,
kSparseTensorTypeFieldNumber = 8,
};
// optional string denotation = 6;
bool has_denotation() const;
private:
bool _internal_has_denotation() const;
public:
void clear_denotation();
const std::string& denotation() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_denotation(ArgT0&& arg0, ArgT... args);
std::string* mutable_denotation();
PROTOBUF_NODISCARD std::string* release_denotation();
void set_allocated_denotation(std::string* denotation);
private:
const std::string& _internal_denotation() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_denotation(const std::string& value);
std::string* _internal_mutable_denotation();
public:
// .opencv_onnx.TypeProto.Tensor tensor_type = 1;
bool has_tensor_type() const;
private:
bool _internal_has_tensor_type() const;
public:
void clear_tensor_type();
const ::opencv_onnx::TypeProto_Tensor& tensor_type() const;
PROTOBUF_NODISCARD ::opencv_onnx::TypeProto_Tensor* release_tensor_type();
::opencv_onnx::TypeProto_Tensor* mutable_tensor_type();
void set_allocated_tensor_type(::opencv_onnx::TypeProto_Tensor* tensor_type);
private:
const ::opencv_onnx::TypeProto_Tensor& _internal_tensor_type() const;
::opencv_onnx::TypeProto_Tensor* _internal_mutable_tensor_type();
public:
void unsafe_arena_set_allocated_tensor_type(
::opencv_onnx::TypeProto_Tensor* tensor_type);
::opencv_onnx::TypeProto_Tensor* unsafe_arena_release_tensor_type();
// .opencv_onnx.TypeProto.Sequence sequence_type = 4;
bool has_sequence_type() const;
private:
bool _internal_has_sequence_type() const;
public:
void clear_sequence_type();
const ::opencv_onnx::TypeProto_Sequence& sequence_type() const;
PROTOBUF_NODISCARD ::opencv_onnx::TypeProto_Sequence* release_sequence_type();
::opencv_onnx::TypeProto_Sequence* mutable_sequence_type();
void set_allocated_sequence_type(::opencv_onnx::TypeProto_Sequence* sequence_type);
private:
const ::opencv_onnx::TypeProto_Sequence& _internal_sequence_type() const;
::opencv_onnx::TypeProto_Sequence* _internal_mutable_sequence_type();
public:
void unsafe_arena_set_allocated_sequence_type(
::opencv_onnx::TypeProto_Sequence* sequence_type);
::opencv_onnx::TypeProto_Sequence* unsafe_arena_release_sequence_type();
// .opencv_onnx.TypeProto.Map map_type = 5;
bool has_map_type() const;
private:
bool _internal_has_map_type() const;
public:
void clear_map_type();
const ::opencv_onnx::TypeProto_Map& map_type() const;
PROTOBUF_NODISCARD ::opencv_onnx::TypeProto_Map* release_map_type();
::opencv_onnx::TypeProto_Map* mutable_map_type();
void set_allocated_map_type(::opencv_onnx::TypeProto_Map* map_type);
private:
const ::opencv_onnx::TypeProto_Map& _internal_map_type() const;
::opencv_onnx::TypeProto_Map* _internal_mutable_map_type();
public:
void unsafe_arena_set_allocated_map_type(
::opencv_onnx::TypeProto_Map* map_type);
::opencv_onnx::TypeProto_Map* unsafe_arena_release_map_type();
// .opencv_onnx.TypeProto.Optional optional_type = 9;
bool has_optional_type() const;
private:
bool _internal_has_optional_type() const;
public:
void clear_optional_type();
const ::opencv_onnx::TypeProto_Optional& optional_type() const;
PROTOBUF_NODISCARD ::opencv_onnx::TypeProto_Optional* release_optional_type();
::opencv_onnx::TypeProto_Optional* mutable_optional_type();
void set_allocated_optional_type(::opencv_onnx::TypeProto_Optional* optional_type);
private:
const ::opencv_onnx::TypeProto_Optional& _internal_optional_type() const;
::opencv_onnx::TypeProto_Optional* _internal_mutable_optional_type();
public:
void unsafe_arena_set_allocated_optional_type(
::opencv_onnx::TypeProto_Optional* optional_type);
::opencv_onnx::TypeProto_Optional* unsafe_arena_release_optional_type();
// .opencv_onnx.TypeProto.SparseTensor sparse_tensor_type = 8;
bool has_sparse_tensor_type() const;
private:
bool _internal_has_sparse_tensor_type() const;
public:
void clear_sparse_tensor_type();
const ::opencv_onnx::TypeProto_SparseTensor& sparse_tensor_type() const;
PROTOBUF_NODISCARD ::opencv_onnx::TypeProto_SparseTensor* release_sparse_tensor_type();
::opencv_onnx::TypeProto_SparseTensor* mutable_sparse_tensor_type();
void set_allocated_sparse_tensor_type(::opencv_onnx::TypeProto_SparseTensor* sparse_tensor_type);
private:
const ::opencv_onnx::TypeProto_SparseTensor& _internal_sparse_tensor_type() const;
::opencv_onnx::TypeProto_SparseTensor* _internal_mutable_sparse_tensor_type();
public:
void unsafe_arena_set_allocated_sparse_tensor_type(
::opencv_onnx::TypeProto_SparseTensor* sparse_tensor_type);
::opencv_onnx::TypeProto_SparseTensor* unsafe_arena_release_sparse_tensor_type();
void clear_value();
ValueCase value_case() const;
// @@protoc_insertion_point(class_scope:opencv_onnx.TypeProto)
private:
class _Internal;
void set_has_tensor_type();
void set_has_sequence_type();
void set_has_map_type();
void set_has_optional_type();
void set_has_sparse_tensor_type();
inline bool has_value() const;
inline void clear_has_value();
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr denotation_;
union ValueUnion {
constexpr ValueUnion() : _constinit_{} {}
::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
::opencv_onnx::TypeProto_Tensor* tensor_type_;
::opencv_onnx::TypeProto_Sequence* sequence_type_;
::opencv_onnx::TypeProto_Map* map_type_;
::opencv_onnx::TypeProto_Optional* optional_type_;
::opencv_onnx::TypeProto_SparseTensor* sparse_tensor_type_;
} value_;
uint32_t _oneof_case_[1];
friend struct ::TableStruct_opencv_2donnx_2eproto;
};
// -------------------------------------------------------------------
class OperatorSetIdProto final :
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:opencv_onnx.OperatorSetIdProto) */ {
public:
inline OperatorSetIdProto() : OperatorSetIdProto(nullptr) {}
~OperatorSetIdProto() override;
explicit constexpr OperatorSetIdProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
OperatorSetIdProto(const OperatorSetIdProto& from);
OperatorSetIdProto(OperatorSetIdProto&& from) noexcept
: OperatorSetIdProto() {
*this = ::std::move(from);
}
inline OperatorSetIdProto& operator=(const OperatorSetIdProto& from) {
CopyFrom(from);
return *this;
}
inline OperatorSetIdProto& operator=(OperatorSetIdProto&& 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;
}
inline const std::string& unknown_fields() const {
return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
}
inline std::string* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<std::string>();
}
static const OperatorSetIdProto& default_instance() {
return *internal_default_instance();
}
static inline const OperatorSetIdProto* internal_default_instance() {
return reinterpret_cast<const OperatorSetIdProto*>(
&_OperatorSetIdProto_default_instance_);
}
static constexpr int kIndexInFileMessages =
25;
friend void swap(OperatorSetIdProto& a, OperatorSetIdProto& b) {
a.Swap(&b);
}
inline void Swap(OperatorSetIdProto* 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(OperatorSetIdProto* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
OperatorSetIdProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<OperatorSetIdProto>(arena);
}
void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
void CopyFrom(const OperatorSetIdProto& from);
void MergeFrom(const OperatorSetIdProto& from);
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 _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const;
void InternalSwap(OperatorSetIdProto* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "opencv_onnx.OperatorSetIdProto";
}
protected:
explicit OperatorSetIdProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
std::string GetTypeName() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kDomainFieldNumber = 1,
kVersionFieldNumber = 2,
};
// optional string domain = 1;
bool has_domain() const;
private:
bool _internal_has_domain() const;
public:
void clear_domain();
const std::string& domain() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_domain(ArgT0&& arg0, ArgT... args);
std::string* mutable_domain();
PROTOBUF_NODISCARD std::string* release_domain();
void set_allocated_domain(std::string* domain);
private:
const std::string& _internal_domain() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_domain(const std::string& value);
std::string* _internal_mutable_domain();
public:
// optional int64 version = 2;
bool has_version() const;
private:
bool _internal_has_version() const;
public:
void clear_version();
int64_t version() const;
void set_version(int64_t value);
private:
int64_t _internal_version() const;
void _internal_set_version(int64_t value);
public:
// @@protoc_insertion_point(class_scope:opencv_onnx.OperatorSetIdProto)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr domain_;
int64_t version_;
friend struct ::TableStruct_opencv_2donnx_2eproto;
};
// -------------------------------------------------------------------
class FunctionProto final :
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:opencv_onnx.FunctionProto) */ {
public:
inline FunctionProto() : FunctionProto(nullptr) {}
~FunctionProto() override;
explicit constexpr FunctionProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
FunctionProto(const FunctionProto& from);
FunctionProto(FunctionProto&& from) noexcept
: FunctionProto() {
*this = ::std::move(from);
}
inline FunctionProto& operator=(const FunctionProto& from) {
CopyFrom(from);
return *this;
}
inline FunctionProto& operator=(FunctionProto&& 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;
}
inline const std::string& unknown_fields() const {
return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
}
inline std::string* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<std::string>();
}
static const FunctionProto& default_instance() {
return *internal_default_instance();
}
static inline const FunctionProto* internal_default_instance() {
return reinterpret_cast<const FunctionProto*>(
&_FunctionProto_default_instance_);
}
static constexpr int kIndexInFileMessages =
26;
friend void swap(FunctionProto& a, FunctionProto& b) {
a.Swap(&b);
}
inline void Swap(FunctionProto* 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(FunctionProto* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
FunctionProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<FunctionProto>(arena);
}
void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
void CopyFrom(const FunctionProto& from);
void MergeFrom(const FunctionProto& from);
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 _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const;
void InternalSwap(FunctionProto* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "opencv_onnx.FunctionProto";
}
protected:
explicit FunctionProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
std::string GetTypeName() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kInputFieldNumber = 4,
kOutputFieldNumber = 5,
kAttributeFieldNumber = 6,
kNodeFieldNumber = 7,
kOpsetImportFieldNumber = 9,
kAttributeProtoFieldNumber = 11,
kValueInfoFieldNumber = 12,
kMetadataPropsFieldNumber = 14,
kNameFieldNumber = 1,
kDocStringFieldNumber = 8,
kDomainFieldNumber = 10,
kOverloadFieldNumber = 13,
};
// repeated string input = 4;
int input_size() const;
private:
int _internal_input_size() const;
public:
void clear_input();
const std::string& input(int index) const;
std::string* mutable_input(int index);
void set_input(int index, const std::string& value);
void set_input(int index, std::string&& value);
void set_input(int index, const char* value);
void set_input(int index, const char* value, size_t size);
std::string* add_input();
void add_input(const std::string& value);
void add_input(std::string&& value);
void add_input(const char* value);
void add_input(const char* value, size_t size);
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& input() const;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_input();
private:
const std::string& _internal_input(int index) const;
std::string* _internal_add_input();
public:
// repeated string output = 5;
int output_size() const;
private:
int _internal_output_size() const;
public:
void clear_output();
const std::string& output(int index) const;
std::string* mutable_output(int index);
void set_output(int index, const std::string& value);
void set_output(int index, std::string&& value);
void set_output(int index, const char* value);
void set_output(int index, const char* value, size_t size);
std::string* add_output();
void add_output(const std::string& value);
void add_output(std::string&& value);
void add_output(const char* value);
void add_output(const char* value, size_t size);
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& output() const;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_output();
private:
const std::string& _internal_output(int index) const;
std::string* _internal_add_output();
public:
// repeated string attribute = 6;
int attribute_size() const;
private:
int _internal_attribute_size() const;
public:
void clear_attribute();
const std::string& attribute(int index) const;
std::string* mutable_attribute(int index);
void set_attribute(int index, const std::string& value);
void set_attribute(int index, std::string&& value);
void set_attribute(int index, const char* value);
void set_attribute(int index, const char* value, size_t size);
std::string* add_attribute();
void add_attribute(const std::string& value);
void add_attribute(std::string&& value);
void add_attribute(const char* value);
void add_attribute(const char* value, size_t size);
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& attribute() const;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_attribute();
private:
const std::string& _internal_attribute(int index) const;
std::string* _internal_add_attribute();
public:
// repeated .opencv_onnx.NodeProto node = 7;
int node_size() const;
private:
int _internal_node_size() const;
public:
void clear_node();
::opencv_onnx::NodeProto* mutable_node(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::NodeProto >*
mutable_node();
private:
const ::opencv_onnx::NodeProto& _internal_node(int index) const;
::opencv_onnx::NodeProto* _internal_add_node();
public:
const ::opencv_onnx::NodeProto& node(int index) const;
::opencv_onnx::NodeProto* add_node();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::NodeProto >&
node() const;
// repeated .opencv_onnx.OperatorSetIdProto opset_import = 9;
int opset_import_size() const;
private:
int _internal_opset_import_size() const;
public:
void clear_opset_import();
::opencv_onnx::OperatorSetIdProto* mutable_opset_import(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::OperatorSetIdProto >*
mutable_opset_import();
private:
const ::opencv_onnx::OperatorSetIdProto& _internal_opset_import(int index) const;
::opencv_onnx::OperatorSetIdProto* _internal_add_opset_import();
public:
const ::opencv_onnx::OperatorSetIdProto& opset_import(int index) const;
::opencv_onnx::OperatorSetIdProto* add_opset_import();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::OperatorSetIdProto >&
opset_import() const;
// repeated .opencv_onnx.AttributeProto attribute_proto = 11;
int attribute_proto_size() const;
private:
int _internal_attribute_proto_size() const;
public:
void clear_attribute_proto();
::opencv_onnx::AttributeProto* mutable_attribute_proto(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::AttributeProto >*
mutable_attribute_proto();
private:
const ::opencv_onnx::AttributeProto& _internal_attribute_proto(int index) const;
::opencv_onnx::AttributeProto* _internal_add_attribute_proto();
public:
const ::opencv_onnx::AttributeProto& attribute_proto(int index) const;
::opencv_onnx::AttributeProto* add_attribute_proto();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::AttributeProto >&
attribute_proto() const;
// repeated .opencv_onnx.ValueInfoProto value_info = 12;
int value_info_size() const;
private:
int _internal_value_info_size() const;
public:
void clear_value_info();
::opencv_onnx::ValueInfoProto* mutable_value_info(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::ValueInfoProto >*
mutable_value_info();
private:
const ::opencv_onnx::ValueInfoProto& _internal_value_info(int index) const;
::opencv_onnx::ValueInfoProto* _internal_add_value_info();
public:
const ::opencv_onnx::ValueInfoProto& value_info(int index) const;
::opencv_onnx::ValueInfoProto* add_value_info();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::ValueInfoProto >&
value_info() const;
// repeated .opencv_onnx.StringStringEntryProto metadata_props = 14;
int metadata_props_size() const;
private:
int _internal_metadata_props_size() const;
public:
void clear_metadata_props();
::opencv_onnx::StringStringEntryProto* mutable_metadata_props(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::StringStringEntryProto >*
mutable_metadata_props();
private:
const ::opencv_onnx::StringStringEntryProto& _internal_metadata_props(int index) const;
::opencv_onnx::StringStringEntryProto* _internal_add_metadata_props();
public:
const ::opencv_onnx::StringStringEntryProto& metadata_props(int index) const;
::opencv_onnx::StringStringEntryProto* add_metadata_props();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::StringStringEntryProto >&
metadata_props() const;
// optional string name = 1;
bool has_name() const;
private:
bool _internal_has_name() const;
public:
void clear_name();
const std::string& name() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_name(ArgT0&& arg0, ArgT... args);
std::string* mutable_name();
PROTOBUF_NODISCARD std::string* release_name();
void set_allocated_name(std::string* name);
private:
const std::string& _internal_name() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
std::string* _internal_mutable_name();
public:
// optional string doc_string = 8;
bool has_doc_string() const;
private:
bool _internal_has_doc_string() const;
public:
void clear_doc_string();
const std::string& doc_string() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_doc_string(ArgT0&& arg0, ArgT... args);
std::string* mutable_doc_string();
PROTOBUF_NODISCARD std::string* release_doc_string();
void set_allocated_doc_string(std::string* doc_string);
private:
const std::string& _internal_doc_string() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_doc_string(const std::string& value);
std::string* _internal_mutable_doc_string();
public:
// optional string domain = 10;
bool has_domain() const;
private:
bool _internal_has_domain() const;
public:
void clear_domain();
const std::string& domain() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_domain(ArgT0&& arg0, ArgT... args);
std::string* mutable_domain();
PROTOBUF_NODISCARD std::string* release_domain();
void set_allocated_domain(std::string* domain);
private:
const std::string& _internal_domain() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_domain(const std::string& value);
std::string* _internal_mutable_domain();
public:
// optional string overload = 13;
bool has_overload() const;
private:
bool _internal_has_overload() const;
public:
void clear_overload();
const std::string& overload() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_overload(ArgT0&& arg0, ArgT... args);
std::string* mutable_overload();
PROTOBUF_NODISCARD std::string* release_overload();
void set_allocated_overload(std::string* overload);
private:
const std::string& _internal_overload() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_overload(const std::string& value);
std::string* _internal_mutable_overload();
public:
// @@protoc_insertion_point(class_scope:opencv_onnx.FunctionProto)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> input_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> output_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> attribute_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::NodeProto > node_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::OperatorSetIdProto > opset_import_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::AttributeProto > attribute_proto_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::ValueInfoProto > value_info_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::StringStringEntryProto > metadata_props_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr doc_string_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr domain_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr overload_;
friend struct ::TableStruct_opencv_2donnx_2eproto;
};
// ===================================================================
// ===================================================================
#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif // __GNUC__
// AttributeProto
// optional string name = 1;
inline bool AttributeProto::_internal_has_name() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool AttributeProto::has_name() const {
return _internal_has_name();
}
inline void AttributeProto::clear_name() {
name_.ClearToEmpty();
_has_bits_[0] &= ~0x00000001u;
}
inline const std::string& AttributeProto::name() const {
// @@protoc_insertion_point(field_get:opencv_onnx.AttributeProto.name)
return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void AttributeProto::set_name(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000001u;
name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:opencv_onnx.AttributeProto.name)
}
inline std::string* AttributeProto::mutable_name() {
std::string* _s = _internal_mutable_name();
// @@protoc_insertion_point(field_mutable:opencv_onnx.AttributeProto.name)
return _s;
}
inline const std::string& AttributeProto::_internal_name() const {
return name_.Get();
}
inline void AttributeProto::_internal_set_name(const std::string& value) {
_has_bits_[0] |= 0x00000001u;
name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* AttributeProto::_internal_mutable_name() {
_has_bits_[0] |= 0x00000001u;
return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* AttributeProto::release_name() {
// @@protoc_insertion_point(field_release:opencv_onnx.AttributeProto.name)
if (!_internal_has_name()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000001u;
auto* p = name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void AttributeProto::set_allocated_name(std::string* name) {
if (name != nullptr) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.AttributeProto.name)
}
// optional string ref_attr_name = 21;
inline bool AttributeProto::_internal_has_ref_attr_name() const {
bool value = (_has_bits_[0] & 0x00000008u) != 0;
return value;
}
inline bool AttributeProto::has_ref_attr_name() const {
return _internal_has_ref_attr_name();
}
inline void AttributeProto::clear_ref_attr_name() {
ref_attr_name_.ClearToEmpty();
_has_bits_[0] &= ~0x00000008u;
}
inline const std::string& AttributeProto::ref_attr_name() const {
// @@protoc_insertion_point(field_get:opencv_onnx.AttributeProto.ref_attr_name)
return _internal_ref_attr_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void AttributeProto::set_ref_attr_name(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000008u;
ref_attr_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:opencv_onnx.AttributeProto.ref_attr_name)
}
inline std::string* AttributeProto::mutable_ref_attr_name() {
std::string* _s = _internal_mutable_ref_attr_name();
// @@protoc_insertion_point(field_mutable:opencv_onnx.AttributeProto.ref_attr_name)
return _s;
}
inline const std::string& AttributeProto::_internal_ref_attr_name() const {
return ref_attr_name_.Get();
}
inline void AttributeProto::_internal_set_ref_attr_name(const std::string& value) {
_has_bits_[0] |= 0x00000008u;
ref_attr_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* AttributeProto::_internal_mutable_ref_attr_name() {
_has_bits_[0] |= 0x00000008u;
return ref_attr_name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* AttributeProto::release_ref_attr_name() {
// @@protoc_insertion_point(field_release:opencv_onnx.AttributeProto.ref_attr_name)
if (!_internal_has_ref_attr_name()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000008u;
auto* p = ref_attr_name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (ref_attr_name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
ref_attr_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void AttributeProto::set_allocated_ref_attr_name(std::string* ref_attr_name) {
if (ref_attr_name != nullptr) {
_has_bits_[0] |= 0x00000008u;
} else {
_has_bits_[0] &= ~0x00000008u;
}
ref_attr_name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ref_attr_name,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (ref_attr_name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
ref_attr_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.AttributeProto.ref_attr_name)
}
// optional string doc_string = 13;
inline bool AttributeProto::_internal_has_doc_string() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool AttributeProto::has_doc_string() const {
return _internal_has_doc_string();
}
inline void AttributeProto::clear_doc_string() {
doc_string_.ClearToEmpty();
_has_bits_[0] &= ~0x00000004u;
}
inline const std::string& AttributeProto::doc_string() const {
// @@protoc_insertion_point(field_get:opencv_onnx.AttributeProto.doc_string)
return _internal_doc_string();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void AttributeProto::set_doc_string(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000004u;
doc_string_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:opencv_onnx.AttributeProto.doc_string)
}
inline std::string* AttributeProto::mutable_doc_string() {
std::string* _s = _internal_mutable_doc_string();
// @@protoc_insertion_point(field_mutable:opencv_onnx.AttributeProto.doc_string)
return _s;
}
inline const std::string& AttributeProto::_internal_doc_string() const {
return doc_string_.Get();
}
inline void AttributeProto::_internal_set_doc_string(const std::string& value) {
_has_bits_[0] |= 0x00000004u;
doc_string_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* AttributeProto::_internal_mutable_doc_string() {
_has_bits_[0] |= 0x00000004u;
return doc_string_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* AttributeProto::release_doc_string() {
// @@protoc_insertion_point(field_release:opencv_onnx.AttributeProto.doc_string)
if (!_internal_has_doc_string()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000004u;
auto* p = doc_string_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (doc_string_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
doc_string_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void AttributeProto::set_allocated_doc_string(std::string* doc_string) {
if (doc_string != nullptr) {
_has_bits_[0] |= 0x00000004u;
} else {
_has_bits_[0] &= ~0x00000004u;
}
doc_string_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), doc_string,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (doc_string_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
doc_string_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.AttributeProto.doc_string)
}
// optional .opencv_onnx.AttributeProto.AttributeType type = 20;
inline bool AttributeProto::_internal_has_type() const {
bool value = (_has_bits_[0] & 0x00000400u) != 0;
return value;
}
inline bool AttributeProto::has_type() const {
return _internal_has_type();
}
inline void AttributeProto::clear_type() {
type_ = 0;
_has_bits_[0] &= ~0x00000400u;
}
inline ::opencv_onnx::AttributeProto_AttributeType AttributeProto::_internal_type() const {
return static_cast< ::opencv_onnx::AttributeProto_AttributeType >(type_);
}
inline ::opencv_onnx::AttributeProto_AttributeType AttributeProto::type() const {
// @@protoc_insertion_point(field_get:opencv_onnx.AttributeProto.type)
return _internal_type();
}
inline void AttributeProto::_internal_set_type(::opencv_onnx::AttributeProto_AttributeType value) {
assert(::opencv_onnx::AttributeProto_AttributeType_IsValid(value));
_has_bits_[0] |= 0x00000400u;
type_ = value;
}
inline void AttributeProto::set_type(::opencv_onnx::AttributeProto_AttributeType value) {
_internal_set_type(value);
// @@protoc_insertion_point(field_set:opencv_onnx.AttributeProto.type)
}
// optional float f = 2;
inline bool AttributeProto::_internal_has_f() const {
bool value = (_has_bits_[0] & 0x00000200u) != 0;
return value;
}
inline bool AttributeProto::has_f() const {
return _internal_has_f();
}
inline void AttributeProto::clear_f() {
f_ = 0;
_has_bits_[0] &= ~0x00000200u;
}
inline float AttributeProto::_internal_f() const {
return f_;
}
inline float AttributeProto::f() const {
// @@protoc_insertion_point(field_get:opencv_onnx.AttributeProto.f)
return _internal_f();
}
inline void AttributeProto::_internal_set_f(float value) {
_has_bits_[0] |= 0x00000200u;
f_ = value;
}
inline void AttributeProto::set_f(float value) {
_internal_set_f(value);
// @@protoc_insertion_point(field_set:opencv_onnx.AttributeProto.f)
}
// optional int64 i = 3;
inline bool AttributeProto::_internal_has_i() const {
bool value = (_has_bits_[0] & 0x00000100u) != 0;
return value;
}
inline bool AttributeProto::has_i() const {
return _internal_has_i();
}
inline void AttributeProto::clear_i() {
i_ = int64_t{0};
_has_bits_[0] &= ~0x00000100u;
}
inline int64_t AttributeProto::_internal_i() const {
return i_;
}
inline int64_t AttributeProto::i() const {
// @@protoc_insertion_point(field_get:opencv_onnx.AttributeProto.i)
return _internal_i();
}
inline void AttributeProto::_internal_set_i(int64_t value) {
_has_bits_[0] |= 0x00000100u;
i_ = value;
}
inline void AttributeProto::set_i(int64_t value) {
_internal_set_i(value);
// @@protoc_insertion_point(field_set:opencv_onnx.AttributeProto.i)
}
// optional bytes s = 4;
inline bool AttributeProto::_internal_has_s() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool AttributeProto::has_s() const {
return _internal_has_s();
}
inline void AttributeProto::clear_s() {
s_.ClearToEmpty();
_has_bits_[0] &= ~0x00000002u;
}
inline const std::string& AttributeProto::s() const {
// @@protoc_insertion_point(field_get:opencv_onnx.AttributeProto.s)
return _internal_s();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void AttributeProto::set_s(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000002u;
s_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:opencv_onnx.AttributeProto.s)
}
inline std::string* AttributeProto::mutable_s() {
std::string* _s = _internal_mutable_s();
// @@protoc_insertion_point(field_mutable:opencv_onnx.AttributeProto.s)
return _s;
}
inline const std::string& AttributeProto::_internal_s() const {
return s_.Get();
}
inline void AttributeProto::_internal_set_s(const std::string& value) {
_has_bits_[0] |= 0x00000002u;
s_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* AttributeProto::_internal_mutable_s() {
_has_bits_[0] |= 0x00000002u;
return s_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* AttributeProto::release_s() {
// @@protoc_insertion_point(field_release:opencv_onnx.AttributeProto.s)
if (!_internal_has_s()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000002u;
auto* p = s_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (s_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
s_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void AttributeProto::set_allocated_s(std::string* s) {
if (s != nullptr) {
_has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
}
s_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), s,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (s_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
s_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.AttributeProto.s)
}
// optional .opencv_onnx.TensorProto t = 5;
inline bool AttributeProto::_internal_has_t() const {
bool value = (_has_bits_[0] & 0x00000010u) != 0;
PROTOBUF_ASSUME(!value || t_ != nullptr);
return value;
}
inline bool AttributeProto::has_t() const {
return _internal_has_t();
}
inline void AttributeProto::clear_t() {
if (t_ != nullptr) t_->Clear();
_has_bits_[0] &= ~0x00000010u;
}
inline const ::opencv_onnx::TensorProto& AttributeProto::_internal_t() const {
const ::opencv_onnx::TensorProto* p = t_;
return p != nullptr ? *p : reinterpret_cast<const ::opencv_onnx::TensorProto&>(
::opencv_onnx::_TensorProto_default_instance_);
}
inline const ::opencv_onnx::TensorProto& AttributeProto::t() const {
// @@protoc_insertion_point(field_get:opencv_onnx.AttributeProto.t)
return _internal_t();
}
inline void AttributeProto::unsafe_arena_set_allocated_t(
::opencv_onnx::TensorProto* t) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(t_);
}
t_ = t;
if (t) {
_has_bits_[0] |= 0x00000010u;
} else {
_has_bits_[0] &= ~0x00000010u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_onnx.AttributeProto.t)
}
inline ::opencv_onnx::TensorProto* AttributeProto::release_t() {
_has_bits_[0] &= ~0x00000010u;
::opencv_onnx::TensorProto* temp = t_;
t_ = 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 ::opencv_onnx::TensorProto* AttributeProto::unsafe_arena_release_t() {
// @@protoc_insertion_point(field_release:opencv_onnx.AttributeProto.t)
_has_bits_[0] &= ~0x00000010u;
::opencv_onnx::TensorProto* temp = t_;
t_ = nullptr;
return temp;
}
inline ::opencv_onnx::TensorProto* AttributeProto::_internal_mutable_t() {
_has_bits_[0] |= 0x00000010u;
if (t_ == nullptr) {
auto* p = CreateMaybeMessage<::opencv_onnx::TensorProto>(GetArenaForAllocation());
t_ = p;
}
return t_;
}
inline ::opencv_onnx::TensorProto* AttributeProto::mutable_t() {
::opencv_onnx::TensorProto* _msg = _internal_mutable_t();
// @@protoc_insertion_point(field_mutable:opencv_onnx.AttributeProto.t)
return _msg;
}
inline void AttributeProto::set_allocated_t(::opencv_onnx::TensorProto* t) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete t_;
}
if (t) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_onnx::TensorProto>::GetOwningArena(t);
if (message_arena != submessage_arena) {
t = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, t, submessage_arena);
}
_has_bits_[0] |= 0x00000010u;
} else {
_has_bits_[0] &= ~0x00000010u;
}
t_ = t;
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.AttributeProto.t)
}
// optional .opencv_onnx.GraphProto g = 6;
inline bool AttributeProto::_internal_has_g() const {
bool value = (_has_bits_[0] & 0x00000020u) != 0;
PROTOBUF_ASSUME(!value || g_ != nullptr);
return value;
}
inline bool AttributeProto::has_g() const {
return _internal_has_g();
}
inline void AttributeProto::clear_g() {
if (g_ != nullptr) g_->Clear();
_has_bits_[0] &= ~0x00000020u;
}
inline const ::opencv_onnx::GraphProto& AttributeProto::_internal_g() const {
const ::opencv_onnx::GraphProto* p = g_;
return p != nullptr ? *p : reinterpret_cast<const ::opencv_onnx::GraphProto&>(
::opencv_onnx::_GraphProto_default_instance_);
}
inline const ::opencv_onnx::GraphProto& AttributeProto::g() const {
// @@protoc_insertion_point(field_get:opencv_onnx.AttributeProto.g)
return _internal_g();
}
inline void AttributeProto::unsafe_arena_set_allocated_g(
::opencv_onnx::GraphProto* g) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(g_);
}
g_ = g;
if (g) {
_has_bits_[0] |= 0x00000020u;
} else {
_has_bits_[0] &= ~0x00000020u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_onnx.AttributeProto.g)
}
inline ::opencv_onnx::GraphProto* AttributeProto::release_g() {
_has_bits_[0] &= ~0x00000020u;
::opencv_onnx::GraphProto* temp = g_;
g_ = 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 ::opencv_onnx::GraphProto* AttributeProto::unsafe_arena_release_g() {
// @@protoc_insertion_point(field_release:opencv_onnx.AttributeProto.g)
_has_bits_[0] &= ~0x00000020u;
::opencv_onnx::GraphProto* temp = g_;
g_ = nullptr;
return temp;
}
inline ::opencv_onnx::GraphProto* AttributeProto::_internal_mutable_g() {
_has_bits_[0] |= 0x00000020u;
if (g_ == nullptr) {
auto* p = CreateMaybeMessage<::opencv_onnx::GraphProto>(GetArenaForAllocation());
g_ = p;
}
return g_;
}
inline ::opencv_onnx::GraphProto* AttributeProto::mutable_g() {
::opencv_onnx::GraphProto* _msg = _internal_mutable_g();
// @@protoc_insertion_point(field_mutable:opencv_onnx.AttributeProto.g)
return _msg;
}
inline void AttributeProto::set_allocated_g(::opencv_onnx::GraphProto* g) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete g_;
}
if (g) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_onnx::GraphProto>::GetOwningArena(g);
if (message_arena != submessage_arena) {
g = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, g, submessage_arena);
}
_has_bits_[0] |= 0x00000020u;
} else {
_has_bits_[0] &= ~0x00000020u;
}
g_ = g;
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.AttributeProto.g)
}
// optional .opencv_onnx.SparseTensorProto sparse_tensor = 22;
inline bool AttributeProto::_internal_has_sparse_tensor() const {
bool value = (_has_bits_[0] & 0x00000080u) != 0;
PROTOBUF_ASSUME(!value || sparse_tensor_ != nullptr);
return value;
}
inline bool AttributeProto::has_sparse_tensor() const {
return _internal_has_sparse_tensor();
}
inline void AttributeProto::clear_sparse_tensor() {
if (sparse_tensor_ != nullptr) sparse_tensor_->Clear();
_has_bits_[0] &= ~0x00000080u;
}
inline const ::opencv_onnx::SparseTensorProto& AttributeProto::_internal_sparse_tensor() const {
const ::opencv_onnx::SparseTensorProto* p = sparse_tensor_;
return p != nullptr ? *p : reinterpret_cast<const ::opencv_onnx::SparseTensorProto&>(
::opencv_onnx::_SparseTensorProto_default_instance_);
}
inline const ::opencv_onnx::SparseTensorProto& AttributeProto::sparse_tensor() const {
// @@protoc_insertion_point(field_get:opencv_onnx.AttributeProto.sparse_tensor)
return _internal_sparse_tensor();
}
inline void AttributeProto::unsafe_arena_set_allocated_sparse_tensor(
::opencv_onnx::SparseTensorProto* sparse_tensor) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(sparse_tensor_);
}
sparse_tensor_ = sparse_tensor;
if (sparse_tensor) {
_has_bits_[0] |= 0x00000080u;
} else {
_has_bits_[0] &= ~0x00000080u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_onnx.AttributeProto.sparse_tensor)
}
inline ::opencv_onnx::SparseTensorProto* AttributeProto::release_sparse_tensor() {
_has_bits_[0] &= ~0x00000080u;
::opencv_onnx::SparseTensorProto* temp = sparse_tensor_;
sparse_tensor_ = 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 ::opencv_onnx::SparseTensorProto* AttributeProto::unsafe_arena_release_sparse_tensor() {
// @@protoc_insertion_point(field_release:opencv_onnx.AttributeProto.sparse_tensor)
_has_bits_[0] &= ~0x00000080u;
::opencv_onnx::SparseTensorProto* temp = sparse_tensor_;
sparse_tensor_ = nullptr;
return temp;
}
inline ::opencv_onnx::SparseTensorProto* AttributeProto::_internal_mutable_sparse_tensor() {
_has_bits_[0] |= 0x00000080u;
if (sparse_tensor_ == nullptr) {
auto* p = CreateMaybeMessage<::opencv_onnx::SparseTensorProto>(GetArenaForAllocation());
sparse_tensor_ = p;
}
return sparse_tensor_;
}
inline ::opencv_onnx::SparseTensorProto* AttributeProto::mutable_sparse_tensor() {
::opencv_onnx::SparseTensorProto* _msg = _internal_mutable_sparse_tensor();
// @@protoc_insertion_point(field_mutable:opencv_onnx.AttributeProto.sparse_tensor)
return _msg;
}
inline void AttributeProto::set_allocated_sparse_tensor(::opencv_onnx::SparseTensorProto* sparse_tensor) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete sparse_tensor_;
}
if (sparse_tensor) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_onnx::SparseTensorProto>::GetOwningArena(sparse_tensor);
if (message_arena != submessage_arena) {
sparse_tensor = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, sparse_tensor, submessage_arena);
}
_has_bits_[0] |= 0x00000080u;
} else {
_has_bits_[0] &= ~0x00000080u;
}
sparse_tensor_ = sparse_tensor;
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.AttributeProto.sparse_tensor)
}
// optional .opencv_onnx.TypeProto tp = 14;
inline bool AttributeProto::_internal_has_tp() const {
bool value = (_has_bits_[0] & 0x00000040u) != 0;
PROTOBUF_ASSUME(!value || tp_ != nullptr);
return value;
}
inline bool AttributeProto::has_tp() const {
return _internal_has_tp();
}
inline void AttributeProto::clear_tp() {
if (tp_ != nullptr) tp_->Clear();
_has_bits_[0] &= ~0x00000040u;
}
inline const ::opencv_onnx::TypeProto& AttributeProto::_internal_tp() const {
const ::opencv_onnx::TypeProto* p = tp_;
return p != nullptr ? *p : reinterpret_cast<const ::opencv_onnx::TypeProto&>(
::opencv_onnx::_TypeProto_default_instance_);
}
inline const ::opencv_onnx::TypeProto& AttributeProto::tp() const {
// @@protoc_insertion_point(field_get:opencv_onnx.AttributeProto.tp)
return _internal_tp();
}
inline void AttributeProto::unsafe_arena_set_allocated_tp(
::opencv_onnx::TypeProto* tp) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(tp_);
}
tp_ = tp;
if (tp) {
_has_bits_[0] |= 0x00000040u;
} else {
_has_bits_[0] &= ~0x00000040u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_onnx.AttributeProto.tp)
}
inline ::opencv_onnx::TypeProto* AttributeProto::release_tp() {
_has_bits_[0] &= ~0x00000040u;
::opencv_onnx::TypeProto* temp = tp_;
tp_ = 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 ::opencv_onnx::TypeProto* AttributeProto::unsafe_arena_release_tp() {
// @@protoc_insertion_point(field_release:opencv_onnx.AttributeProto.tp)
_has_bits_[0] &= ~0x00000040u;
::opencv_onnx::TypeProto* temp = tp_;
tp_ = nullptr;
return temp;
}
inline ::opencv_onnx::TypeProto* AttributeProto::_internal_mutable_tp() {
_has_bits_[0] |= 0x00000040u;
if (tp_ == nullptr) {
auto* p = CreateMaybeMessage<::opencv_onnx::TypeProto>(GetArenaForAllocation());
tp_ = p;
}
return tp_;
}
inline ::opencv_onnx::TypeProto* AttributeProto::mutable_tp() {
::opencv_onnx::TypeProto* _msg = _internal_mutable_tp();
// @@protoc_insertion_point(field_mutable:opencv_onnx.AttributeProto.tp)
return _msg;
}
inline void AttributeProto::set_allocated_tp(::opencv_onnx::TypeProto* tp) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete tp_;
}
if (tp) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_onnx::TypeProto>::GetOwningArena(tp);
if (message_arena != submessage_arena) {
tp = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, tp, submessage_arena);
}
_has_bits_[0] |= 0x00000040u;
} else {
_has_bits_[0] &= ~0x00000040u;
}
tp_ = tp;
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.AttributeProto.tp)
}
// repeated float floats = 7;
inline int AttributeProto::_internal_floats_size() const {
return floats_.size();
}
inline int AttributeProto::floats_size() const {
return _internal_floats_size();
}
inline void AttributeProto::clear_floats() {
floats_.Clear();
}
inline float AttributeProto::_internal_floats(int index) const {
return floats_.Get(index);
}
inline float AttributeProto::floats(int index) const {
// @@protoc_insertion_point(field_get:opencv_onnx.AttributeProto.floats)
return _internal_floats(index);
}
inline void AttributeProto::set_floats(int index, float value) {
floats_.Set(index, value);
// @@protoc_insertion_point(field_set:opencv_onnx.AttributeProto.floats)
}
inline void AttributeProto::_internal_add_floats(float value) {
floats_.Add(value);
}
inline void AttributeProto::add_floats(float value) {
_internal_add_floats(value);
// @@protoc_insertion_point(field_add:opencv_onnx.AttributeProto.floats)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
AttributeProto::_internal_floats() const {
return floats_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
AttributeProto::floats() const {
// @@protoc_insertion_point(field_list:opencv_onnx.AttributeProto.floats)
return _internal_floats();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
AttributeProto::_internal_mutable_floats() {
return &floats_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
AttributeProto::mutable_floats() {
// @@protoc_insertion_point(field_mutable_list:opencv_onnx.AttributeProto.floats)
return _internal_mutable_floats();
}
// repeated int64 ints = 8;
inline int AttributeProto::_internal_ints_size() const {
return ints_.size();
}
inline int AttributeProto::ints_size() const {
return _internal_ints_size();
}
inline void AttributeProto::clear_ints() {
ints_.Clear();
}
inline int64_t AttributeProto::_internal_ints(int index) const {
return ints_.Get(index);
}
inline int64_t AttributeProto::ints(int index) const {
// @@protoc_insertion_point(field_get:opencv_onnx.AttributeProto.ints)
return _internal_ints(index);
}
inline void AttributeProto::set_ints(int index, int64_t value) {
ints_.Set(index, value);
// @@protoc_insertion_point(field_set:opencv_onnx.AttributeProto.ints)
}
inline void AttributeProto::_internal_add_ints(int64_t value) {
ints_.Add(value);
}
inline void AttributeProto::add_ints(int64_t value) {
_internal_add_ints(value);
// @@protoc_insertion_point(field_add:opencv_onnx.AttributeProto.ints)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
AttributeProto::_internal_ints() const {
return ints_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
AttributeProto::ints() const {
// @@protoc_insertion_point(field_list:opencv_onnx.AttributeProto.ints)
return _internal_ints();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
AttributeProto::_internal_mutable_ints() {
return &ints_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
AttributeProto::mutable_ints() {
// @@protoc_insertion_point(field_mutable_list:opencv_onnx.AttributeProto.ints)
return _internal_mutable_ints();
}
// repeated bytes strings = 9;
inline int AttributeProto::_internal_strings_size() const {
return strings_.size();
}
inline int AttributeProto::strings_size() const {
return _internal_strings_size();
}
inline void AttributeProto::clear_strings() {
strings_.Clear();
}
inline std::string* AttributeProto::add_strings() {
std::string* _s = _internal_add_strings();
// @@protoc_insertion_point(field_add_mutable:opencv_onnx.AttributeProto.strings)
return _s;
}
inline const std::string& AttributeProto::_internal_strings(int index) const {
return strings_.Get(index);
}
inline const std::string& AttributeProto::strings(int index) const {
// @@protoc_insertion_point(field_get:opencv_onnx.AttributeProto.strings)
return _internal_strings(index);
}
inline std::string* AttributeProto::mutable_strings(int index) {
// @@protoc_insertion_point(field_mutable:opencv_onnx.AttributeProto.strings)
return strings_.Mutable(index);
}
inline void AttributeProto::set_strings(int index, const std::string& value) {
strings_.Mutable(index)->assign(value);
// @@protoc_insertion_point(field_set:opencv_onnx.AttributeProto.strings)
}
inline void AttributeProto::set_strings(int index, std::string&& value) {
strings_.Mutable(index)->assign(std::move(value));
// @@protoc_insertion_point(field_set:opencv_onnx.AttributeProto.strings)
}
inline void AttributeProto::set_strings(int index, const char* value) {
GOOGLE_DCHECK(value != nullptr);
strings_.Mutable(index)->assign(value);
// @@protoc_insertion_point(field_set_char:opencv_onnx.AttributeProto.strings)
}
inline void AttributeProto::set_strings(int index, const void* value, size_t size) {
strings_.Mutable(index)->assign(
reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_set_pointer:opencv_onnx.AttributeProto.strings)
}
inline std::string* AttributeProto::_internal_add_strings() {
return strings_.Add();
}
inline void AttributeProto::add_strings(const std::string& value) {
strings_.Add()->assign(value);
// @@protoc_insertion_point(field_add:opencv_onnx.AttributeProto.strings)
}
inline void AttributeProto::add_strings(std::string&& value) {
strings_.Add(std::move(value));
// @@protoc_insertion_point(field_add:opencv_onnx.AttributeProto.strings)
}
inline void AttributeProto::add_strings(const char* value) {
GOOGLE_DCHECK(value != nullptr);
strings_.Add()->assign(value);
// @@protoc_insertion_point(field_add_char:opencv_onnx.AttributeProto.strings)
}
inline void AttributeProto::add_strings(const void* value, size_t size) {
strings_.Add()->assign(reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_add_pointer:opencv_onnx.AttributeProto.strings)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
AttributeProto::strings() const {
// @@protoc_insertion_point(field_list:opencv_onnx.AttributeProto.strings)
return strings_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
AttributeProto::mutable_strings() {
// @@protoc_insertion_point(field_mutable_list:opencv_onnx.AttributeProto.strings)
return &strings_;
}
// repeated .opencv_onnx.TensorProto tensors = 10;
inline int AttributeProto::_internal_tensors_size() const {
return tensors_.size();
}
inline int AttributeProto::tensors_size() const {
return _internal_tensors_size();
}
inline void AttributeProto::clear_tensors() {
tensors_.Clear();
}
inline ::opencv_onnx::TensorProto* AttributeProto::mutable_tensors(int index) {
// @@protoc_insertion_point(field_mutable:opencv_onnx.AttributeProto.tensors)
return tensors_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::TensorProto >*
AttributeProto::mutable_tensors() {
// @@protoc_insertion_point(field_mutable_list:opencv_onnx.AttributeProto.tensors)
return &tensors_;
}
inline const ::opencv_onnx::TensorProto& AttributeProto::_internal_tensors(int index) const {
return tensors_.Get(index);
}
inline const ::opencv_onnx::TensorProto& AttributeProto::tensors(int index) const {
// @@protoc_insertion_point(field_get:opencv_onnx.AttributeProto.tensors)
return _internal_tensors(index);
}
inline ::opencv_onnx::TensorProto* AttributeProto::_internal_add_tensors() {
return tensors_.Add();
}
inline ::opencv_onnx::TensorProto* AttributeProto::add_tensors() {
::opencv_onnx::TensorProto* _add = _internal_add_tensors();
// @@protoc_insertion_point(field_add:opencv_onnx.AttributeProto.tensors)
return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::TensorProto >&
AttributeProto::tensors() const {
// @@protoc_insertion_point(field_list:opencv_onnx.AttributeProto.tensors)
return tensors_;
}
// repeated .opencv_onnx.GraphProto graphs = 11;
inline int AttributeProto::_internal_graphs_size() const {
return graphs_.size();
}
inline int AttributeProto::graphs_size() const {
return _internal_graphs_size();
}
inline void AttributeProto::clear_graphs() {
graphs_.Clear();
}
inline ::opencv_onnx::GraphProto* AttributeProto::mutable_graphs(int index) {
// @@protoc_insertion_point(field_mutable:opencv_onnx.AttributeProto.graphs)
return graphs_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::GraphProto >*
AttributeProto::mutable_graphs() {
// @@protoc_insertion_point(field_mutable_list:opencv_onnx.AttributeProto.graphs)
return &graphs_;
}
inline const ::opencv_onnx::GraphProto& AttributeProto::_internal_graphs(int index) const {
return graphs_.Get(index);
}
inline const ::opencv_onnx::GraphProto& AttributeProto::graphs(int index) const {
// @@protoc_insertion_point(field_get:opencv_onnx.AttributeProto.graphs)
return _internal_graphs(index);
}
inline ::opencv_onnx::GraphProto* AttributeProto::_internal_add_graphs() {
return graphs_.Add();
}
inline ::opencv_onnx::GraphProto* AttributeProto::add_graphs() {
::opencv_onnx::GraphProto* _add = _internal_add_graphs();
// @@protoc_insertion_point(field_add:opencv_onnx.AttributeProto.graphs)
return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::GraphProto >&
AttributeProto::graphs() const {
// @@protoc_insertion_point(field_list:opencv_onnx.AttributeProto.graphs)
return graphs_;
}
// repeated .opencv_onnx.SparseTensorProto sparse_tensors = 23;
inline int AttributeProto::_internal_sparse_tensors_size() const {
return sparse_tensors_.size();
}
inline int AttributeProto::sparse_tensors_size() const {
return _internal_sparse_tensors_size();
}
inline void AttributeProto::clear_sparse_tensors() {
sparse_tensors_.Clear();
}
inline ::opencv_onnx::SparseTensorProto* AttributeProto::mutable_sparse_tensors(int index) {
// @@protoc_insertion_point(field_mutable:opencv_onnx.AttributeProto.sparse_tensors)
return sparse_tensors_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::SparseTensorProto >*
AttributeProto::mutable_sparse_tensors() {
// @@protoc_insertion_point(field_mutable_list:opencv_onnx.AttributeProto.sparse_tensors)
return &sparse_tensors_;
}
inline const ::opencv_onnx::SparseTensorProto& AttributeProto::_internal_sparse_tensors(int index) const {
return sparse_tensors_.Get(index);
}
inline const ::opencv_onnx::SparseTensorProto& AttributeProto::sparse_tensors(int index) const {
// @@protoc_insertion_point(field_get:opencv_onnx.AttributeProto.sparse_tensors)
return _internal_sparse_tensors(index);
}
inline ::opencv_onnx::SparseTensorProto* AttributeProto::_internal_add_sparse_tensors() {
return sparse_tensors_.Add();
}
inline ::opencv_onnx::SparseTensorProto* AttributeProto::add_sparse_tensors() {
::opencv_onnx::SparseTensorProto* _add = _internal_add_sparse_tensors();
// @@protoc_insertion_point(field_add:opencv_onnx.AttributeProto.sparse_tensors)
return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::SparseTensorProto >&
AttributeProto::sparse_tensors() const {
// @@protoc_insertion_point(field_list:opencv_onnx.AttributeProto.sparse_tensors)
return sparse_tensors_;
}
// repeated .opencv_onnx.TypeProto type_protos = 15;
inline int AttributeProto::_internal_type_protos_size() const {
return type_protos_.size();
}
inline int AttributeProto::type_protos_size() const {
return _internal_type_protos_size();
}
inline void AttributeProto::clear_type_protos() {
type_protos_.Clear();
}
inline ::opencv_onnx::TypeProto* AttributeProto::mutable_type_protos(int index) {
// @@protoc_insertion_point(field_mutable:opencv_onnx.AttributeProto.type_protos)
return type_protos_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::TypeProto >*
AttributeProto::mutable_type_protos() {
// @@protoc_insertion_point(field_mutable_list:opencv_onnx.AttributeProto.type_protos)
return &type_protos_;
}
inline const ::opencv_onnx::TypeProto& AttributeProto::_internal_type_protos(int index) const {
return type_protos_.Get(index);
}
inline const ::opencv_onnx::TypeProto& AttributeProto::type_protos(int index) const {
// @@protoc_insertion_point(field_get:opencv_onnx.AttributeProto.type_protos)
return _internal_type_protos(index);
}
inline ::opencv_onnx::TypeProto* AttributeProto::_internal_add_type_protos() {
return type_protos_.Add();
}
inline ::opencv_onnx::TypeProto* AttributeProto::add_type_protos() {
::opencv_onnx::TypeProto* _add = _internal_add_type_protos();
// @@protoc_insertion_point(field_add:opencv_onnx.AttributeProto.type_protos)
return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::TypeProto >&
AttributeProto::type_protos() const {
// @@protoc_insertion_point(field_list:opencv_onnx.AttributeProto.type_protos)
return type_protos_;
}
// -------------------------------------------------------------------
// ValueInfoProto
// optional string name = 1;
inline bool ValueInfoProto::_internal_has_name() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool ValueInfoProto::has_name() const {
return _internal_has_name();
}
inline void ValueInfoProto::clear_name() {
name_.ClearToEmpty();
_has_bits_[0] &= ~0x00000001u;
}
inline const std::string& ValueInfoProto::name() const {
// @@protoc_insertion_point(field_get:opencv_onnx.ValueInfoProto.name)
return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ValueInfoProto::set_name(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000001u;
name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:opencv_onnx.ValueInfoProto.name)
}
inline std::string* ValueInfoProto::mutable_name() {
std::string* _s = _internal_mutable_name();
// @@protoc_insertion_point(field_mutable:opencv_onnx.ValueInfoProto.name)
return _s;
}
inline const std::string& ValueInfoProto::_internal_name() const {
return name_.Get();
}
inline void ValueInfoProto::_internal_set_name(const std::string& value) {
_has_bits_[0] |= 0x00000001u;
name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* ValueInfoProto::_internal_mutable_name() {
_has_bits_[0] |= 0x00000001u;
return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* ValueInfoProto::release_name() {
// @@protoc_insertion_point(field_release:opencv_onnx.ValueInfoProto.name)
if (!_internal_has_name()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000001u;
auto* p = name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void ValueInfoProto::set_allocated_name(std::string* name) {
if (name != nullptr) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.ValueInfoProto.name)
}
// optional .opencv_onnx.TypeProto type = 2;
inline bool ValueInfoProto::_internal_has_type() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
PROTOBUF_ASSUME(!value || type_ != nullptr);
return value;
}
inline bool ValueInfoProto::has_type() const {
return _internal_has_type();
}
inline void ValueInfoProto::clear_type() {
if (type_ != nullptr) type_->Clear();
_has_bits_[0] &= ~0x00000004u;
}
inline const ::opencv_onnx::TypeProto& ValueInfoProto::_internal_type() const {
const ::opencv_onnx::TypeProto* p = type_;
return p != nullptr ? *p : reinterpret_cast<const ::opencv_onnx::TypeProto&>(
::opencv_onnx::_TypeProto_default_instance_);
}
inline const ::opencv_onnx::TypeProto& ValueInfoProto::type() const {
// @@protoc_insertion_point(field_get:opencv_onnx.ValueInfoProto.type)
return _internal_type();
}
inline void ValueInfoProto::unsafe_arena_set_allocated_type(
::opencv_onnx::TypeProto* type) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(type_);
}
type_ = type;
if (type) {
_has_bits_[0] |= 0x00000004u;
} else {
_has_bits_[0] &= ~0x00000004u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_onnx.ValueInfoProto.type)
}
inline ::opencv_onnx::TypeProto* ValueInfoProto::release_type() {
_has_bits_[0] &= ~0x00000004u;
::opencv_onnx::TypeProto* temp = type_;
type_ = 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 ::opencv_onnx::TypeProto* ValueInfoProto::unsafe_arena_release_type() {
// @@protoc_insertion_point(field_release:opencv_onnx.ValueInfoProto.type)
_has_bits_[0] &= ~0x00000004u;
::opencv_onnx::TypeProto* temp = type_;
type_ = nullptr;
return temp;
}
inline ::opencv_onnx::TypeProto* ValueInfoProto::_internal_mutable_type() {
_has_bits_[0] |= 0x00000004u;
if (type_ == nullptr) {
auto* p = CreateMaybeMessage<::opencv_onnx::TypeProto>(GetArenaForAllocation());
type_ = p;
}
return type_;
}
inline ::opencv_onnx::TypeProto* ValueInfoProto::mutable_type() {
::opencv_onnx::TypeProto* _msg = _internal_mutable_type();
// @@protoc_insertion_point(field_mutable:opencv_onnx.ValueInfoProto.type)
return _msg;
}
inline void ValueInfoProto::set_allocated_type(::opencv_onnx::TypeProto* type) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete type_;
}
if (type) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_onnx::TypeProto>::GetOwningArena(type);
if (message_arena != submessage_arena) {
type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, type, submessage_arena);
}
_has_bits_[0] |= 0x00000004u;
} else {
_has_bits_[0] &= ~0x00000004u;
}
type_ = type;
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.ValueInfoProto.type)
}
// optional string doc_string = 3;
inline bool ValueInfoProto::_internal_has_doc_string() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool ValueInfoProto::has_doc_string() const {
return _internal_has_doc_string();
}
inline void ValueInfoProto::clear_doc_string() {
doc_string_.ClearToEmpty();
_has_bits_[0] &= ~0x00000002u;
}
inline const std::string& ValueInfoProto::doc_string() const {
// @@protoc_insertion_point(field_get:opencv_onnx.ValueInfoProto.doc_string)
return _internal_doc_string();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ValueInfoProto::set_doc_string(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000002u;
doc_string_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:opencv_onnx.ValueInfoProto.doc_string)
}
inline std::string* ValueInfoProto::mutable_doc_string() {
std::string* _s = _internal_mutable_doc_string();
// @@protoc_insertion_point(field_mutable:opencv_onnx.ValueInfoProto.doc_string)
return _s;
}
inline const std::string& ValueInfoProto::_internal_doc_string() const {
return doc_string_.Get();
}
inline void ValueInfoProto::_internal_set_doc_string(const std::string& value) {
_has_bits_[0] |= 0x00000002u;
doc_string_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* ValueInfoProto::_internal_mutable_doc_string() {
_has_bits_[0] |= 0x00000002u;
return doc_string_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* ValueInfoProto::release_doc_string() {
// @@protoc_insertion_point(field_release:opencv_onnx.ValueInfoProto.doc_string)
if (!_internal_has_doc_string()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000002u;
auto* p = doc_string_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (doc_string_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
doc_string_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void ValueInfoProto::set_allocated_doc_string(std::string* doc_string) {
if (doc_string != nullptr) {
_has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
}
doc_string_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), doc_string,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (doc_string_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
doc_string_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.ValueInfoProto.doc_string)
}
// repeated .opencv_onnx.StringStringEntryProto metadata_props = 4;
inline int ValueInfoProto::_internal_metadata_props_size() const {
return metadata_props_.size();
}
inline int ValueInfoProto::metadata_props_size() const {
return _internal_metadata_props_size();
}
inline void ValueInfoProto::clear_metadata_props() {
metadata_props_.Clear();
}
inline ::opencv_onnx::StringStringEntryProto* ValueInfoProto::mutable_metadata_props(int index) {
// @@protoc_insertion_point(field_mutable:opencv_onnx.ValueInfoProto.metadata_props)
return metadata_props_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::StringStringEntryProto >*
ValueInfoProto::mutable_metadata_props() {
// @@protoc_insertion_point(field_mutable_list:opencv_onnx.ValueInfoProto.metadata_props)
return &metadata_props_;
}
inline const ::opencv_onnx::StringStringEntryProto& ValueInfoProto::_internal_metadata_props(int index) const {
return metadata_props_.Get(index);
}
inline const ::opencv_onnx::StringStringEntryProto& ValueInfoProto::metadata_props(int index) const {
// @@protoc_insertion_point(field_get:opencv_onnx.ValueInfoProto.metadata_props)
return _internal_metadata_props(index);
}
inline ::opencv_onnx::StringStringEntryProto* ValueInfoProto::_internal_add_metadata_props() {
return metadata_props_.Add();
}
inline ::opencv_onnx::StringStringEntryProto* ValueInfoProto::add_metadata_props() {
::opencv_onnx::StringStringEntryProto* _add = _internal_add_metadata_props();
// @@protoc_insertion_point(field_add:opencv_onnx.ValueInfoProto.metadata_props)
return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::StringStringEntryProto >&
ValueInfoProto::metadata_props() const {
// @@protoc_insertion_point(field_list:opencv_onnx.ValueInfoProto.metadata_props)
return metadata_props_;
}
// -------------------------------------------------------------------
// NodeProto
// repeated string input = 1;
inline int NodeProto::_internal_input_size() const {
return input_.size();
}
inline int NodeProto::input_size() const {
return _internal_input_size();
}
inline void NodeProto::clear_input() {
input_.Clear();
}
inline std::string* NodeProto::add_input() {
std::string* _s = _internal_add_input();
// @@protoc_insertion_point(field_add_mutable:opencv_onnx.NodeProto.input)
return _s;
}
inline const std::string& NodeProto::_internal_input(int index) const {
return input_.Get(index);
}
inline const std::string& NodeProto::input(int index) const {
// @@protoc_insertion_point(field_get:opencv_onnx.NodeProto.input)
return _internal_input(index);
}
inline std::string* NodeProto::mutable_input(int index) {
// @@protoc_insertion_point(field_mutable:opencv_onnx.NodeProto.input)
return input_.Mutable(index);
}
inline void NodeProto::set_input(int index, const std::string& value) {
input_.Mutable(index)->assign(value);
// @@protoc_insertion_point(field_set:opencv_onnx.NodeProto.input)
}
inline void NodeProto::set_input(int index, std::string&& value) {
input_.Mutable(index)->assign(std::move(value));
// @@protoc_insertion_point(field_set:opencv_onnx.NodeProto.input)
}
inline void NodeProto::set_input(int index, const char* value) {
GOOGLE_DCHECK(value != nullptr);
input_.Mutable(index)->assign(value);
// @@protoc_insertion_point(field_set_char:opencv_onnx.NodeProto.input)
}
inline void NodeProto::set_input(int index, const char* value, size_t size) {
input_.Mutable(index)->assign(
reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_set_pointer:opencv_onnx.NodeProto.input)
}
inline std::string* NodeProto::_internal_add_input() {
return input_.Add();
}
inline void NodeProto::add_input(const std::string& value) {
input_.Add()->assign(value);
// @@protoc_insertion_point(field_add:opencv_onnx.NodeProto.input)
}
inline void NodeProto::add_input(std::string&& value) {
input_.Add(std::move(value));
// @@protoc_insertion_point(field_add:opencv_onnx.NodeProto.input)
}
inline void NodeProto::add_input(const char* value) {
GOOGLE_DCHECK(value != nullptr);
input_.Add()->assign(value);
// @@protoc_insertion_point(field_add_char:opencv_onnx.NodeProto.input)
}
inline void NodeProto::add_input(const char* value, size_t size) {
input_.Add()->assign(reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_add_pointer:opencv_onnx.NodeProto.input)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
NodeProto::input() const {
// @@protoc_insertion_point(field_list:opencv_onnx.NodeProto.input)
return input_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
NodeProto::mutable_input() {
// @@protoc_insertion_point(field_mutable_list:opencv_onnx.NodeProto.input)
return &input_;
}
// repeated string output = 2;
inline int NodeProto::_internal_output_size() const {
return output_.size();
}
inline int NodeProto::output_size() const {
return _internal_output_size();
}
inline void NodeProto::clear_output() {
output_.Clear();
}
inline std::string* NodeProto::add_output() {
std::string* _s = _internal_add_output();
// @@protoc_insertion_point(field_add_mutable:opencv_onnx.NodeProto.output)
return _s;
}
inline const std::string& NodeProto::_internal_output(int index) const {
return output_.Get(index);
}
inline const std::string& NodeProto::output(int index) const {
// @@protoc_insertion_point(field_get:opencv_onnx.NodeProto.output)
return _internal_output(index);
}
inline std::string* NodeProto::mutable_output(int index) {
// @@protoc_insertion_point(field_mutable:opencv_onnx.NodeProto.output)
return output_.Mutable(index);
}
inline void NodeProto::set_output(int index, const std::string& value) {
output_.Mutable(index)->assign(value);
// @@protoc_insertion_point(field_set:opencv_onnx.NodeProto.output)
}
inline void NodeProto::set_output(int index, std::string&& value) {
output_.Mutable(index)->assign(std::move(value));
// @@protoc_insertion_point(field_set:opencv_onnx.NodeProto.output)
}
inline void NodeProto::set_output(int index, const char* value) {
GOOGLE_DCHECK(value != nullptr);
output_.Mutable(index)->assign(value);
// @@protoc_insertion_point(field_set_char:opencv_onnx.NodeProto.output)
}
inline void NodeProto::set_output(int index, const char* value, size_t size) {
output_.Mutable(index)->assign(
reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_set_pointer:opencv_onnx.NodeProto.output)
}
inline std::string* NodeProto::_internal_add_output() {
return output_.Add();
}
inline void NodeProto::add_output(const std::string& value) {
output_.Add()->assign(value);
// @@protoc_insertion_point(field_add:opencv_onnx.NodeProto.output)
}
inline void NodeProto::add_output(std::string&& value) {
output_.Add(std::move(value));
// @@protoc_insertion_point(field_add:opencv_onnx.NodeProto.output)
}
inline void NodeProto::add_output(const char* value) {
GOOGLE_DCHECK(value != nullptr);
output_.Add()->assign(value);
// @@protoc_insertion_point(field_add_char:opencv_onnx.NodeProto.output)
}
inline void NodeProto::add_output(const char* value, size_t size) {
output_.Add()->assign(reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_add_pointer:opencv_onnx.NodeProto.output)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
NodeProto::output() const {
// @@protoc_insertion_point(field_list:opencv_onnx.NodeProto.output)
return output_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
NodeProto::mutable_output() {
// @@protoc_insertion_point(field_mutable_list:opencv_onnx.NodeProto.output)
return &output_;
}
// optional string name = 3;
inline bool NodeProto::_internal_has_name() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool NodeProto::has_name() const {
return _internal_has_name();
}
inline void NodeProto::clear_name() {
name_.ClearToEmpty();
_has_bits_[0] &= ~0x00000001u;
}
inline const std::string& NodeProto::name() const {
// @@protoc_insertion_point(field_get:opencv_onnx.NodeProto.name)
return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void NodeProto::set_name(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000001u;
name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:opencv_onnx.NodeProto.name)
}
inline std::string* NodeProto::mutable_name() {
std::string* _s = _internal_mutable_name();
// @@protoc_insertion_point(field_mutable:opencv_onnx.NodeProto.name)
return _s;
}
inline const std::string& NodeProto::_internal_name() const {
return name_.Get();
}
inline void NodeProto::_internal_set_name(const std::string& value) {
_has_bits_[0] |= 0x00000001u;
name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* NodeProto::_internal_mutable_name() {
_has_bits_[0] |= 0x00000001u;
return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* NodeProto::release_name() {
// @@protoc_insertion_point(field_release:opencv_onnx.NodeProto.name)
if (!_internal_has_name()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000001u;
auto* p = name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void NodeProto::set_allocated_name(std::string* name) {
if (name != nullptr) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.NodeProto.name)
}
// optional string op_type = 4;
inline bool NodeProto::_internal_has_op_type() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool NodeProto::has_op_type() const {
return _internal_has_op_type();
}
inline void NodeProto::clear_op_type() {
op_type_.ClearToEmpty();
_has_bits_[0] &= ~0x00000002u;
}
inline const std::string& NodeProto::op_type() const {
// @@protoc_insertion_point(field_get:opencv_onnx.NodeProto.op_type)
return _internal_op_type();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void NodeProto::set_op_type(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000002u;
op_type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:opencv_onnx.NodeProto.op_type)
}
inline std::string* NodeProto::mutable_op_type() {
std::string* _s = _internal_mutable_op_type();
// @@protoc_insertion_point(field_mutable:opencv_onnx.NodeProto.op_type)
return _s;
}
inline const std::string& NodeProto::_internal_op_type() const {
return op_type_.Get();
}
inline void NodeProto::_internal_set_op_type(const std::string& value) {
_has_bits_[0] |= 0x00000002u;
op_type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* NodeProto::_internal_mutable_op_type() {
_has_bits_[0] |= 0x00000002u;
return op_type_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* NodeProto::release_op_type() {
// @@protoc_insertion_point(field_release:opencv_onnx.NodeProto.op_type)
if (!_internal_has_op_type()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000002u;
auto* p = op_type_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (op_type_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
op_type_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void NodeProto::set_allocated_op_type(std::string* op_type) {
if (op_type != nullptr) {
_has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
}
op_type_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), op_type,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (op_type_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
op_type_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.NodeProto.op_type)
}
// optional string domain = 7;
inline bool NodeProto::_internal_has_domain() const {
bool value = (_has_bits_[0] & 0x00000008u) != 0;
return value;
}
inline bool NodeProto::has_domain() const {
return _internal_has_domain();
}
inline void NodeProto::clear_domain() {
domain_.ClearToEmpty();
_has_bits_[0] &= ~0x00000008u;
}
inline const std::string& NodeProto::domain() const {
// @@protoc_insertion_point(field_get:opencv_onnx.NodeProto.domain)
return _internal_domain();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void NodeProto::set_domain(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000008u;
domain_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:opencv_onnx.NodeProto.domain)
}
inline std::string* NodeProto::mutable_domain() {
std::string* _s = _internal_mutable_domain();
// @@protoc_insertion_point(field_mutable:opencv_onnx.NodeProto.domain)
return _s;
}
inline const std::string& NodeProto::_internal_domain() const {
return domain_.Get();
}
inline void NodeProto::_internal_set_domain(const std::string& value) {
_has_bits_[0] |= 0x00000008u;
domain_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* NodeProto::_internal_mutable_domain() {
_has_bits_[0] |= 0x00000008u;
return domain_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* NodeProto::release_domain() {
// @@protoc_insertion_point(field_release:opencv_onnx.NodeProto.domain)
if (!_internal_has_domain()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000008u;
auto* p = domain_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (domain_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
domain_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void NodeProto::set_allocated_domain(std::string* domain) {
if (domain != nullptr) {
_has_bits_[0] |= 0x00000008u;
} else {
_has_bits_[0] &= ~0x00000008u;
}
domain_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), domain,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (domain_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
domain_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.NodeProto.domain)
}
// optional string overload = 8;
inline bool NodeProto::_internal_has_overload() const {
bool value = (_has_bits_[0] & 0x00000010u) != 0;
return value;
}
inline bool NodeProto::has_overload() const {
return _internal_has_overload();
}
inline void NodeProto::clear_overload() {
overload_.ClearToEmpty();
_has_bits_[0] &= ~0x00000010u;
}
inline const std::string& NodeProto::overload() const {
// @@protoc_insertion_point(field_get:opencv_onnx.NodeProto.overload)
return _internal_overload();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void NodeProto::set_overload(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000010u;
overload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:opencv_onnx.NodeProto.overload)
}
inline std::string* NodeProto::mutable_overload() {
std::string* _s = _internal_mutable_overload();
// @@protoc_insertion_point(field_mutable:opencv_onnx.NodeProto.overload)
return _s;
}
inline const std::string& NodeProto::_internal_overload() const {
return overload_.Get();
}
inline void NodeProto::_internal_set_overload(const std::string& value) {
_has_bits_[0] |= 0x00000010u;
overload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* NodeProto::_internal_mutable_overload() {
_has_bits_[0] |= 0x00000010u;
return overload_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* NodeProto::release_overload() {
// @@protoc_insertion_point(field_release:opencv_onnx.NodeProto.overload)
if (!_internal_has_overload()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000010u;
auto* p = overload_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (overload_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
overload_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void NodeProto::set_allocated_overload(std::string* overload) {
if (overload != nullptr) {
_has_bits_[0] |= 0x00000010u;
} else {
_has_bits_[0] &= ~0x00000010u;
}
overload_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), overload,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (overload_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
overload_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.NodeProto.overload)
}
// repeated .opencv_onnx.AttributeProto attribute = 5;
inline int NodeProto::_internal_attribute_size() const {
return attribute_.size();
}
inline int NodeProto::attribute_size() const {
return _internal_attribute_size();
}
inline void NodeProto::clear_attribute() {
attribute_.Clear();
}
inline ::opencv_onnx::AttributeProto* NodeProto::mutable_attribute(int index) {
// @@protoc_insertion_point(field_mutable:opencv_onnx.NodeProto.attribute)
return attribute_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::AttributeProto >*
NodeProto::mutable_attribute() {
// @@protoc_insertion_point(field_mutable_list:opencv_onnx.NodeProto.attribute)
return &attribute_;
}
inline const ::opencv_onnx::AttributeProto& NodeProto::_internal_attribute(int index) const {
return attribute_.Get(index);
}
inline const ::opencv_onnx::AttributeProto& NodeProto::attribute(int index) const {
// @@protoc_insertion_point(field_get:opencv_onnx.NodeProto.attribute)
return _internal_attribute(index);
}
inline ::opencv_onnx::AttributeProto* NodeProto::_internal_add_attribute() {
return attribute_.Add();
}
inline ::opencv_onnx::AttributeProto* NodeProto::add_attribute() {
::opencv_onnx::AttributeProto* _add = _internal_add_attribute();
// @@protoc_insertion_point(field_add:opencv_onnx.NodeProto.attribute)
return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::AttributeProto >&
NodeProto::attribute() const {
// @@protoc_insertion_point(field_list:opencv_onnx.NodeProto.attribute)
return attribute_;
}
// optional string doc_string = 6;
inline bool NodeProto::_internal_has_doc_string() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool NodeProto::has_doc_string() const {
return _internal_has_doc_string();
}
inline void NodeProto::clear_doc_string() {
doc_string_.ClearToEmpty();
_has_bits_[0] &= ~0x00000004u;
}
inline const std::string& NodeProto::doc_string() const {
// @@protoc_insertion_point(field_get:opencv_onnx.NodeProto.doc_string)
return _internal_doc_string();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void NodeProto::set_doc_string(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000004u;
doc_string_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:opencv_onnx.NodeProto.doc_string)
}
inline std::string* NodeProto::mutable_doc_string() {
std::string* _s = _internal_mutable_doc_string();
// @@protoc_insertion_point(field_mutable:opencv_onnx.NodeProto.doc_string)
return _s;
}
inline const std::string& NodeProto::_internal_doc_string() const {
return doc_string_.Get();
}
inline void NodeProto::_internal_set_doc_string(const std::string& value) {
_has_bits_[0] |= 0x00000004u;
doc_string_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* NodeProto::_internal_mutable_doc_string() {
_has_bits_[0] |= 0x00000004u;
return doc_string_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* NodeProto::release_doc_string() {
// @@protoc_insertion_point(field_release:opencv_onnx.NodeProto.doc_string)
if (!_internal_has_doc_string()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000004u;
auto* p = doc_string_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (doc_string_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
doc_string_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void NodeProto::set_allocated_doc_string(std::string* doc_string) {
if (doc_string != nullptr) {
_has_bits_[0] |= 0x00000004u;
} else {
_has_bits_[0] &= ~0x00000004u;
}
doc_string_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), doc_string,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (doc_string_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
doc_string_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.NodeProto.doc_string)
}
// repeated .opencv_onnx.StringStringEntryProto metadata_props = 9;
inline int NodeProto::_internal_metadata_props_size() const {
return metadata_props_.size();
}
inline int NodeProto::metadata_props_size() const {
return _internal_metadata_props_size();
}
inline void NodeProto::clear_metadata_props() {
metadata_props_.Clear();
}
inline ::opencv_onnx::StringStringEntryProto* NodeProto::mutable_metadata_props(int index) {
// @@protoc_insertion_point(field_mutable:opencv_onnx.NodeProto.metadata_props)
return metadata_props_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::StringStringEntryProto >*
NodeProto::mutable_metadata_props() {
// @@protoc_insertion_point(field_mutable_list:opencv_onnx.NodeProto.metadata_props)
return &metadata_props_;
}
inline const ::opencv_onnx::StringStringEntryProto& NodeProto::_internal_metadata_props(int index) const {
return metadata_props_.Get(index);
}
inline const ::opencv_onnx::StringStringEntryProto& NodeProto::metadata_props(int index) const {
// @@protoc_insertion_point(field_get:opencv_onnx.NodeProto.metadata_props)
return _internal_metadata_props(index);
}
inline ::opencv_onnx::StringStringEntryProto* NodeProto::_internal_add_metadata_props() {
return metadata_props_.Add();
}
inline ::opencv_onnx::StringStringEntryProto* NodeProto::add_metadata_props() {
::opencv_onnx::StringStringEntryProto* _add = _internal_add_metadata_props();
// @@protoc_insertion_point(field_add:opencv_onnx.NodeProto.metadata_props)
return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::StringStringEntryProto >&
NodeProto::metadata_props() const {
// @@protoc_insertion_point(field_list:opencv_onnx.NodeProto.metadata_props)
return metadata_props_;
}
// repeated .opencv_onnx.NodeDeviceConfigurationProto device_configurations = 10;
inline int NodeProto::_internal_device_configurations_size() const {
return device_configurations_.size();
}
inline int NodeProto::device_configurations_size() const {
return _internal_device_configurations_size();
}
inline void NodeProto::clear_device_configurations() {
device_configurations_.Clear();
}
inline ::opencv_onnx::NodeDeviceConfigurationProto* NodeProto::mutable_device_configurations(int index) {
// @@protoc_insertion_point(field_mutable:opencv_onnx.NodeProto.device_configurations)
return device_configurations_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::NodeDeviceConfigurationProto >*
NodeProto::mutable_device_configurations() {
// @@protoc_insertion_point(field_mutable_list:opencv_onnx.NodeProto.device_configurations)
return &device_configurations_;
}
inline const ::opencv_onnx::NodeDeviceConfigurationProto& NodeProto::_internal_device_configurations(int index) const {
return device_configurations_.Get(index);
}
inline const ::opencv_onnx::NodeDeviceConfigurationProto& NodeProto::device_configurations(int index) const {
// @@protoc_insertion_point(field_get:opencv_onnx.NodeProto.device_configurations)
return _internal_device_configurations(index);
}
inline ::opencv_onnx::NodeDeviceConfigurationProto* NodeProto::_internal_add_device_configurations() {
return device_configurations_.Add();
}
inline ::opencv_onnx::NodeDeviceConfigurationProto* NodeProto::add_device_configurations() {
::opencv_onnx::NodeDeviceConfigurationProto* _add = _internal_add_device_configurations();
// @@protoc_insertion_point(field_add:opencv_onnx.NodeProto.device_configurations)
return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::NodeDeviceConfigurationProto >&
NodeProto::device_configurations() const {
// @@protoc_insertion_point(field_list:opencv_onnx.NodeProto.device_configurations)
return device_configurations_;
}
// -------------------------------------------------------------------
// IntIntListEntryProto
// optional int64 key = 1;
inline bool IntIntListEntryProto::_internal_has_key() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool IntIntListEntryProto::has_key() const {
return _internal_has_key();
}
inline void IntIntListEntryProto::clear_key() {
key_ = int64_t{0};
_has_bits_[0] &= ~0x00000001u;
}
inline int64_t IntIntListEntryProto::_internal_key() const {
return key_;
}
inline int64_t IntIntListEntryProto::key() const {
// @@protoc_insertion_point(field_get:opencv_onnx.IntIntListEntryProto.key)
return _internal_key();
}
inline void IntIntListEntryProto::_internal_set_key(int64_t value) {
_has_bits_[0] |= 0x00000001u;
key_ = value;
}
inline void IntIntListEntryProto::set_key(int64_t value) {
_internal_set_key(value);
// @@protoc_insertion_point(field_set:opencv_onnx.IntIntListEntryProto.key)
}
// repeated int64 value = 2;
inline int IntIntListEntryProto::_internal_value_size() const {
return value_.size();
}
inline int IntIntListEntryProto::value_size() const {
return _internal_value_size();
}
inline void IntIntListEntryProto::clear_value() {
value_.Clear();
}
inline int64_t IntIntListEntryProto::_internal_value(int index) const {
return value_.Get(index);
}
inline int64_t IntIntListEntryProto::value(int index) const {
// @@protoc_insertion_point(field_get:opencv_onnx.IntIntListEntryProto.value)
return _internal_value(index);
}
inline void IntIntListEntryProto::set_value(int index, int64_t value) {
value_.Set(index, value);
// @@protoc_insertion_point(field_set:opencv_onnx.IntIntListEntryProto.value)
}
inline void IntIntListEntryProto::_internal_add_value(int64_t value) {
value_.Add(value);
}
inline void IntIntListEntryProto::add_value(int64_t value) {
_internal_add_value(value);
// @@protoc_insertion_point(field_add:opencv_onnx.IntIntListEntryProto.value)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
IntIntListEntryProto::_internal_value() const {
return value_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
IntIntListEntryProto::value() const {
// @@protoc_insertion_point(field_list:opencv_onnx.IntIntListEntryProto.value)
return _internal_value();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
IntIntListEntryProto::_internal_mutable_value() {
return &value_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
IntIntListEntryProto::mutable_value() {
// @@protoc_insertion_point(field_mutable_list:opencv_onnx.IntIntListEntryProto.value)
return _internal_mutable_value();
}
// -------------------------------------------------------------------
// NodeDeviceConfigurationProto
// optional string configuration_id = 1;
inline bool NodeDeviceConfigurationProto::_internal_has_configuration_id() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool NodeDeviceConfigurationProto::has_configuration_id() const {
return _internal_has_configuration_id();
}
inline void NodeDeviceConfigurationProto::clear_configuration_id() {
configuration_id_.ClearToEmpty();
_has_bits_[0] &= ~0x00000001u;
}
inline const std::string& NodeDeviceConfigurationProto::configuration_id() const {
// @@protoc_insertion_point(field_get:opencv_onnx.NodeDeviceConfigurationProto.configuration_id)
return _internal_configuration_id();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void NodeDeviceConfigurationProto::set_configuration_id(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000001u;
configuration_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:opencv_onnx.NodeDeviceConfigurationProto.configuration_id)
}
inline std::string* NodeDeviceConfigurationProto::mutable_configuration_id() {
std::string* _s = _internal_mutable_configuration_id();
// @@protoc_insertion_point(field_mutable:opencv_onnx.NodeDeviceConfigurationProto.configuration_id)
return _s;
}
inline const std::string& NodeDeviceConfigurationProto::_internal_configuration_id() const {
return configuration_id_.Get();
}
inline void NodeDeviceConfigurationProto::_internal_set_configuration_id(const std::string& value) {
_has_bits_[0] |= 0x00000001u;
configuration_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* NodeDeviceConfigurationProto::_internal_mutable_configuration_id() {
_has_bits_[0] |= 0x00000001u;
return configuration_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* NodeDeviceConfigurationProto::release_configuration_id() {
// @@protoc_insertion_point(field_release:opencv_onnx.NodeDeviceConfigurationProto.configuration_id)
if (!_internal_has_configuration_id()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000001u;
auto* p = configuration_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (configuration_id_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
configuration_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void NodeDeviceConfigurationProto::set_allocated_configuration_id(std::string* configuration_id) {
if (configuration_id != nullptr) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
configuration_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), configuration_id,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (configuration_id_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
configuration_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.NodeDeviceConfigurationProto.configuration_id)
}
// repeated .opencv_onnx.ShardingSpecProto sharding_spec = 2;
inline int NodeDeviceConfigurationProto::_internal_sharding_spec_size() const {
return sharding_spec_.size();
}
inline int NodeDeviceConfigurationProto::sharding_spec_size() const {
return _internal_sharding_spec_size();
}
inline void NodeDeviceConfigurationProto::clear_sharding_spec() {
sharding_spec_.Clear();
}
inline ::opencv_onnx::ShardingSpecProto* NodeDeviceConfigurationProto::mutable_sharding_spec(int index) {
// @@protoc_insertion_point(field_mutable:opencv_onnx.NodeDeviceConfigurationProto.sharding_spec)
return sharding_spec_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::ShardingSpecProto >*
NodeDeviceConfigurationProto::mutable_sharding_spec() {
// @@protoc_insertion_point(field_mutable_list:opencv_onnx.NodeDeviceConfigurationProto.sharding_spec)
return &sharding_spec_;
}
inline const ::opencv_onnx::ShardingSpecProto& NodeDeviceConfigurationProto::_internal_sharding_spec(int index) const {
return sharding_spec_.Get(index);
}
inline const ::opencv_onnx::ShardingSpecProto& NodeDeviceConfigurationProto::sharding_spec(int index) const {
// @@protoc_insertion_point(field_get:opencv_onnx.NodeDeviceConfigurationProto.sharding_spec)
return _internal_sharding_spec(index);
}
inline ::opencv_onnx::ShardingSpecProto* NodeDeviceConfigurationProto::_internal_add_sharding_spec() {
return sharding_spec_.Add();
}
inline ::opencv_onnx::ShardingSpecProto* NodeDeviceConfigurationProto::add_sharding_spec() {
::opencv_onnx::ShardingSpecProto* _add = _internal_add_sharding_spec();
// @@protoc_insertion_point(field_add:opencv_onnx.NodeDeviceConfigurationProto.sharding_spec)
return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::ShardingSpecProto >&
NodeDeviceConfigurationProto::sharding_spec() const {
// @@protoc_insertion_point(field_list:opencv_onnx.NodeDeviceConfigurationProto.sharding_spec)
return sharding_spec_;
}
// optional int32 pipeline_stage = 3;
inline bool NodeDeviceConfigurationProto::_internal_has_pipeline_stage() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool NodeDeviceConfigurationProto::has_pipeline_stage() const {
return _internal_has_pipeline_stage();
}
inline void NodeDeviceConfigurationProto::clear_pipeline_stage() {
pipeline_stage_ = 0;
_has_bits_[0] &= ~0x00000002u;
}
inline int32_t NodeDeviceConfigurationProto::_internal_pipeline_stage() const {
return pipeline_stage_;
}
inline int32_t NodeDeviceConfigurationProto::pipeline_stage() const {
// @@protoc_insertion_point(field_get:opencv_onnx.NodeDeviceConfigurationProto.pipeline_stage)
return _internal_pipeline_stage();
}
inline void NodeDeviceConfigurationProto::_internal_set_pipeline_stage(int32_t value) {
_has_bits_[0] |= 0x00000002u;
pipeline_stage_ = value;
}
inline void NodeDeviceConfigurationProto::set_pipeline_stage(int32_t value) {
_internal_set_pipeline_stage(value);
// @@protoc_insertion_point(field_set:opencv_onnx.NodeDeviceConfigurationProto.pipeline_stage)
}
// -------------------------------------------------------------------
// ShardingSpecProto
// optional string tensor_name = 1;
inline bool ShardingSpecProto::_internal_has_tensor_name() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool ShardingSpecProto::has_tensor_name() const {
return _internal_has_tensor_name();
}
inline void ShardingSpecProto::clear_tensor_name() {
tensor_name_.ClearToEmpty();
_has_bits_[0] &= ~0x00000001u;
}
inline const std::string& ShardingSpecProto::tensor_name() const {
// @@protoc_insertion_point(field_get:opencv_onnx.ShardingSpecProto.tensor_name)
return _internal_tensor_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ShardingSpecProto::set_tensor_name(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000001u;
tensor_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:opencv_onnx.ShardingSpecProto.tensor_name)
}
inline std::string* ShardingSpecProto::mutable_tensor_name() {
std::string* _s = _internal_mutable_tensor_name();
// @@protoc_insertion_point(field_mutable:opencv_onnx.ShardingSpecProto.tensor_name)
return _s;
}
inline const std::string& ShardingSpecProto::_internal_tensor_name() const {
return tensor_name_.Get();
}
inline void ShardingSpecProto::_internal_set_tensor_name(const std::string& value) {
_has_bits_[0] |= 0x00000001u;
tensor_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* ShardingSpecProto::_internal_mutable_tensor_name() {
_has_bits_[0] |= 0x00000001u;
return tensor_name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* ShardingSpecProto::release_tensor_name() {
// @@protoc_insertion_point(field_release:opencv_onnx.ShardingSpecProto.tensor_name)
if (!_internal_has_tensor_name()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000001u;
auto* p = tensor_name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (tensor_name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
tensor_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void ShardingSpecProto::set_allocated_tensor_name(std::string* tensor_name) {
if (tensor_name != nullptr) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
tensor_name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), tensor_name,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (tensor_name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
tensor_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.ShardingSpecProto.tensor_name)
}
// repeated int64 device = 2;
inline int ShardingSpecProto::_internal_device_size() const {
return device_.size();
}
inline int ShardingSpecProto::device_size() const {
return _internal_device_size();
}
inline void ShardingSpecProto::clear_device() {
device_.Clear();
}
inline int64_t ShardingSpecProto::_internal_device(int index) const {
return device_.Get(index);
}
inline int64_t ShardingSpecProto::device(int index) const {
// @@protoc_insertion_point(field_get:opencv_onnx.ShardingSpecProto.device)
return _internal_device(index);
}
inline void ShardingSpecProto::set_device(int index, int64_t value) {
device_.Set(index, value);
// @@protoc_insertion_point(field_set:opencv_onnx.ShardingSpecProto.device)
}
inline void ShardingSpecProto::_internal_add_device(int64_t value) {
device_.Add(value);
}
inline void ShardingSpecProto::add_device(int64_t value) {
_internal_add_device(value);
// @@protoc_insertion_point(field_add:opencv_onnx.ShardingSpecProto.device)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
ShardingSpecProto::_internal_device() const {
return device_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
ShardingSpecProto::device() const {
// @@protoc_insertion_point(field_list:opencv_onnx.ShardingSpecProto.device)
return _internal_device();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
ShardingSpecProto::_internal_mutable_device() {
return &device_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
ShardingSpecProto::mutable_device() {
// @@protoc_insertion_point(field_mutable_list:opencv_onnx.ShardingSpecProto.device)
return _internal_mutable_device();
}
// repeated .opencv_onnx.IntIntListEntryProto index_to_device_group_map = 3;
inline int ShardingSpecProto::_internal_index_to_device_group_map_size() const {
return index_to_device_group_map_.size();
}
inline int ShardingSpecProto::index_to_device_group_map_size() const {
return _internal_index_to_device_group_map_size();
}
inline void ShardingSpecProto::clear_index_to_device_group_map() {
index_to_device_group_map_.Clear();
}
inline ::opencv_onnx::IntIntListEntryProto* ShardingSpecProto::mutable_index_to_device_group_map(int index) {
// @@protoc_insertion_point(field_mutable:opencv_onnx.ShardingSpecProto.index_to_device_group_map)
return index_to_device_group_map_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::IntIntListEntryProto >*
ShardingSpecProto::mutable_index_to_device_group_map() {
// @@protoc_insertion_point(field_mutable_list:opencv_onnx.ShardingSpecProto.index_to_device_group_map)
return &index_to_device_group_map_;
}
inline const ::opencv_onnx::IntIntListEntryProto& ShardingSpecProto::_internal_index_to_device_group_map(int index) const {
return index_to_device_group_map_.Get(index);
}
inline const ::opencv_onnx::IntIntListEntryProto& ShardingSpecProto::index_to_device_group_map(int index) const {
// @@protoc_insertion_point(field_get:opencv_onnx.ShardingSpecProto.index_to_device_group_map)
return _internal_index_to_device_group_map(index);
}
inline ::opencv_onnx::IntIntListEntryProto* ShardingSpecProto::_internal_add_index_to_device_group_map() {
return index_to_device_group_map_.Add();
}
inline ::opencv_onnx::IntIntListEntryProto* ShardingSpecProto::add_index_to_device_group_map() {
::opencv_onnx::IntIntListEntryProto* _add = _internal_add_index_to_device_group_map();
// @@protoc_insertion_point(field_add:opencv_onnx.ShardingSpecProto.index_to_device_group_map)
return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::IntIntListEntryProto >&
ShardingSpecProto::index_to_device_group_map() const {
// @@protoc_insertion_point(field_list:opencv_onnx.ShardingSpecProto.index_to_device_group_map)
return index_to_device_group_map_;
}
// repeated .opencv_onnx.ShardedDimProto sharded_dim = 4;
inline int ShardingSpecProto::_internal_sharded_dim_size() const {
return sharded_dim_.size();
}
inline int ShardingSpecProto::sharded_dim_size() const {
return _internal_sharded_dim_size();
}
inline void ShardingSpecProto::clear_sharded_dim() {
sharded_dim_.Clear();
}
inline ::opencv_onnx::ShardedDimProto* ShardingSpecProto::mutable_sharded_dim(int index) {
// @@protoc_insertion_point(field_mutable:opencv_onnx.ShardingSpecProto.sharded_dim)
return sharded_dim_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::ShardedDimProto >*
ShardingSpecProto::mutable_sharded_dim() {
// @@protoc_insertion_point(field_mutable_list:opencv_onnx.ShardingSpecProto.sharded_dim)
return &sharded_dim_;
}
inline const ::opencv_onnx::ShardedDimProto& ShardingSpecProto::_internal_sharded_dim(int index) const {
return sharded_dim_.Get(index);
}
inline const ::opencv_onnx::ShardedDimProto& ShardingSpecProto::sharded_dim(int index) const {
// @@protoc_insertion_point(field_get:opencv_onnx.ShardingSpecProto.sharded_dim)
return _internal_sharded_dim(index);
}
inline ::opencv_onnx::ShardedDimProto* ShardingSpecProto::_internal_add_sharded_dim() {
return sharded_dim_.Add();
}
inline ::opencv_onnx::ShardedDimProto* ShardingSpecProto::add_sharded_dim() {
::opencv_onnx::ShardedDimProto* _add = _internal_add_sharded_dim();
// @@protoc_insertion_point(field_add:opencv_onnx.ShardingSpecProto.sharded_dim)
return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::ShardedDimProto >&
ShardingSpecProto::sharded_dim() const {
// @@protoc_insertion_point(field_list:opencv_onnx.ShardingSpecProto.sharded_dim)
return sharded_dim_;
}
// -------------------------------------------------------------------
// ShardedDimProto
// optional int64 axis = 1;
inline bool ShardedDimProto::_internal_has_axis() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool ShardedDimProto::has_axis() const {
return _internal_has_axis();
}
inline void ShardedDimProto::clear_axis() {
axis_ = int64_t{0};
_has_bits_[0] &= ~0x00000001u;
}
inline int64_t ShardedDimProto::_internal_axis() const {
return axis_;
}
inline int64_t ShardedDimProto::axis() const {
// @@protoc_insertion_point(field_get:opencv_onnx.ShardedDimProto.axis)
return _internal_axis();
}
inline void ShardedDimProto::_internal_set_axis(int64_t value) {
_has_bits_[0] |= 0x00000001u;
axis_ = value;
}
inline void ShardedDimProto::set_axis(int64_t value) {
_internal_set_axis(value);
// @@protoc_insertion_point(field_set:opencv_onnx.ShardedDimProto.axis)
}
// repeated .opencv_onnx.SimpleShardedDimProto simple_sharding = 2;
inline int ShardedDimProto::_internal_simple_sharding_size() const {
return simple_sharding_.size();
}
inline int ShardedDimProto::simple_sharding_size() const {
return _internal_simple_sharding_size();
}
inline void ShardedDimProto::clear_simple_sharding() {
simple_sharding_.Clear();
}
inline ::opencv_onnx::SimpleShardedDimProto* ShardedDimProto::mutable_simple_sharding(int index) {
// @@protoc_insertion_point(field_mutable:opencv_onnx.ShardedDimProto.simple_sharding)
return simple_sharding_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::SimpleShardedDimProto >*
ShardedDimProto::mutable_simple_sharding() {
// @@protoc_insertion_point(field_mutable_list:opencv_onnx.ShardedDimProto.simple_sharding)
return &simple_sharding_;
}
inline const ::opencv_onnx::SimpleShardedDimProto& ShardedDimProto::_internal_simple_sharding(int index) const {
return simple_sharding_.Get(index);
}
inline const ::opencv_onnx::SimpleShardedDimProto& ShardedDimProto::simple_sharding(int index) const {
// @@protoc_insertion_point(field_get:opencv_onnx.ShardedDimProto.simple_sharding)
return _internal_simple_sharding(index);
}
inline ::opencv_onnx::SimpleShardedDimProto* ShardedDimProto::_internal_add_simple_sharding() {
return simple_sharding_.Add();
}
inline ::opencv_onnx::SimpleShardedDimProto* ShardedDimProto::add_simple_sharding() {
::opencv_onnx::SimpleShardedDimProto* _add = _internal_add_simple_sharding();
// @@protoc_insertion_point(field_add:opencv_onnx.ShardedDimProto.simple_sharding)
return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::SimpleShardedDimProto >&
ShardedDimProto::simple_sharding() const {
// @@protoc_insertion_point(field_list:opencv_onnx.ShardedDimProto.simple_sharding)
return simple_sharding_;
}
// -------------------------------------------------------------------
// SimpleShardedDimProto
// int64 dim_value = 1;
inline bool SimpleShardedDimProto::_internal_has_dim_value() const {
return dim_case() == kDimValue;
}
inline bool SimpleShardedDimProto::has_dim_value() const {
return _internal_has_dim_value();
}
inline void SimpleShardedDimProto::set_has_dim_value() {
_oneof_case_[0] = kDimValue;
}
inline void SimpleShardedDimProto::clear_dim_value() {
if (_internal_has_dim_value()) {
dim_.dim_value_ = int64_t{0};
clear_has_dim();
}
}
inline int64_t SimpleShardedDimProto::_internal_dim_value() const {
if (_internal_has_dim_value()) {
return dim_.dim_value_;
}
return int64_t{0};
}
inline void SimpleShardedDimProto::_internal_set_dim_value(int64_t value) {
if (!_internal_has_dim_value()) {
clear_dim();
set_has_dim_value();
}
dim_.dim_value_ = value;
}
inline int64_t SimpleShardedDimProto::dim_value() const {
// @@protoc_insertion_point(field_get:opencv_onnx.SimpleShardedDimProto.dim_value)
return _internal_dim_value();
}
inline void SimpleShardedDimProto::set_dim_value(int64_t value) {
_internal_set_dim_value(value);
// @@protoc_insertion_point(field_set:opencv_onnx.SimpleShardedDimProto.dim_value)
}
// string dim_param = 2;
inline bool SimpleShardedDimProto::_internal_has_dim_param() const {
return dim_case() == kDimParam;
}
inline bool SimpleShardedDimProto::has_dim_param() const {
return _internal_has_dim_param();
}
inline void SimpleShardedDimProto::set_has_dim_param() {
_oneof_case_[0] = kDimParam;
}
inline void SimpleShardedDimProto::clear_dim_param() {
if (_internal_has_dim_param()) {
dim_.dim_param_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
clear_has_dim();
}
}
inline const std::string& SimpleShardedDimProto::dim_param() const {
// @@protoc_insertion_point(field_get:opencv_onnx.SimpleShardedDimProto.dim_param)
return _internal_dim_param();
}
template <typename ArgT0, typename... ArgT>
inline void SimpleShardedDimProto::set_dim_param(ArgT0&& arg0, ArgT... args) {
if (!_internal_has_dim_param()) {
clear_dim();
set_has_dim_param();
dim_.dim_param_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
dim_.dim_param_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:opencv_onnx.SimpleShardedDimProto.dim_param)
}
inline std::string* SimpleShardedDimProto::mutable_dim_param() {
std::string* _s = _internal_mutable_dim_param();
// @@protoc_insertion_point(field_mutable:opencv_onnx.SimpleShardedDimProto.dim_param)
return _s;
}
inline const std::string& SimpleShardedDimProto::_internal_dim_param() const {
if (_internal_has_dim_param()) {
return dim_.dim_param_.Get();
}
return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
}
inline void SimpleShardedDimProto::_internal_set_dim_param(const std::string& value) {
if (!_internal_has_dim_param()) {
clear_dim();
set_has_dim_param();
dim_.dim_param_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
dim_.dim_param_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* SimpleShardedDimProto::_internal_mutable_dim_param() {
if (!_internal_has_dim_param()) {
clear_dim();
set_has_dim_param();
dim_.dim_param_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
return dim_.dim_param_.Mutable(
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* SimpleShardedDimProto::release_dim_param() {
// @@protoc_insertion_point(field_release:opencv_onnx.SimpleShardedDimProto.dim_param)
if (_internal_has_dim_param()) {
clear_has_dim();
return dim_.dim_param_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
} else {
return nullptr;
}
}
inline void SimpleShardedDimProto::set_allocated_dim_param(std::string* dim_param) {
if (has_dim()) {
clear_dim();
}
if (dim_param != nullptr) {
set_has_dim_param();
dim_.dim_param_.UnsafeSetDefault(dim_param);
::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaForAllocation();
if (arena != nullptr) {
arena->Own(dim_param);
}
}
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.SimpleShardedDimProto.dim_param)
}
// optional int64 num_shards = 3;
inline bool SimpleShardedDimProto::_internal_has_num_shards() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool SimpleShardedDimProto::has_num_shards() const {
return _internal_has_num_shards();
}
inline void SimpleShardedDimProto::clear_num_shards() {
num_shards_ = int64_t{0};
_has_bits_[0] &= ~0x00000001u;
}
inline int64_t SimpleShardedDimProto::_internal_num_shards() const {
return num_shards_;
}
inline int64_t SimpleShardedDimProto::num_shards() const {
// @@protoc_insertion_point(field_get:opencv_onnx.SimpleShardedDimProto.num_shards)
return _internal_num_shards();
}
inline void SimpleShardedDimProto::_internal_set_num_shards(int64_t value) {
_has_bits_[0] |= 0x00000001u;
num_shards_ = value;
}
inline void SimpleShardedDimProto::set_num_shards(int64_t value) {
_internal_set_num_shards(value);
// @@protoc_insertion_point(field_set:opencv_onnx.SimpleShardedDimProto.num_shards)
}
inline bool SimpleShardedDimProto::has_dim() const {
return dim_case() != DIM_NOT_SET;
}
inline void SimpleShardedDimProto::clear_has_dim() {
_oneof_case_[0] = DIM_NOT_SET;
}
inline SimpleShardedDimProto::DimCase SimpleShardedDimProto::dim_case() const {
return SimpleShardedDimProto::DimCase(_oneof_case_[0]);
}
// -------------------------------------------------------------------
// TrainingInfoProto
// optional .opencv_onnx.GraphProto initialization = 1;
inline bool TrainingInfoProto::_internal_has_initialization() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
PROTOBUF_ASSUME(!value || initialization_ != nullptr);
return value;
}
inline bool TrainingInfoProto::has_initialization() const {
return _internal_has_initialization();
}
inline void TrainingInfoProto::clear_initialization() {
if (initialization_ != nullptr) initialization_->Clear();
_has_bits_[0] &= ~0x00000001u;
}
inline const ::opencv_onnx::GraphProto& TrainingInfoProto::_internal_initialization() const {
const ::opencv_onnx::GraphProto* p = initialization_;
return p != nullptr ? *p : reinterpret_cast<const ::opencv_onnx::GraphProto&>(
::opencv_onnx::_GraphProto_default_instance_);
}
inline const ::opencv_onnx::GraphProto& TrainingInfoProto::initialization() const {
// @@protoc_insertion_point(field_get:opencv_onnx.TrainingInfoProto.initialization)
return _internal_initialization();
}
inline void TrainingInfoProto::unsafe_arena_set_allocated_initialization(
::opencv_onnx::GraphProto* initialization) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(initialization_);
}
initialization_ = initialization;
if (initialization) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_onnx.TrainingInfoProto.initialization)
}
inline ::opencv_onnx::GraphProto* TrainingInfoProto::release_initialization() {
_has_bits_[0] &= ~0x00000001u;
::opencv_onnx::GraphProto* temp = initialization_;
initialization_ = 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 ::opencv_onnx::GraphProto* TrainingInfoProto::unsafe_arena_release_initialization() {
// @@protoc_insertion_point(field_release:opencv_onnx.TrainingInfoProto.initialization)
_has_bits_[0] &= ~0x00000001u;
::opencv_onnx::GraphProto* temp = initialization_;
initialization_ = nullptr;
return temp;
}
inline ::opencv_onnx::GraphProto* TrainingInfoProto::_internal_mutable_initialization() {
_has_bits_[0] |= 0x00000001u;
if (initialization_ == nullptr) {
auto* p = CreateMaybeMessage<::opencv_onnx::GraphProto>(GetArenaForAllocation());
initialization_ = p;
}
return initialization_;
}
inline ::opencv_onnx::GraphProto* TrainingInfoProto::mutable_initialization() {
::opencv_onnx::GraphProto* _msg = _internal_mutable_initialization();
// @@protoc_insertion_point(field_mutable:opencv_onnx.TrainingInfoProto.initialization)
return _msg;
}
inline void TrainingInfoProto::set_allocated_initialization(::opencv_onnx::GraphProto* initialization) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete initialization_;
}
if (initialization) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_onnx::GraphProto>::GetOwningArena(initialization);
if (message_arena != submessage_arena) {
initialization = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, initialization, submessage_arena);
}
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
initialization_ = initialization;
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.TrainingInfoProto.initialization)
}
// optional .opencv_onnx.GraphProto algorithm = 2;
inline bool TrainingInfoProto::_internal_has_algorithm() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
PROTOBUF_ASSUME(!value || algorithm_ != nullptr);
return value;
}
inline bool TrainingInfoProto::has_algorithm() const {
return _internal_has_algorithm();
}
inline void TrainingInfoProto::clear_algorithm() {
if (algorithm_ != nullptr) algorithm_->Clear();
_has_bits_[0] &= ~0x00000002u;
}
inline const ::opencv_onnx::GraphProto& TrainingInfoProto::_internal_algorithm() const {
const ::opencv_onnx::GraphProto* p = algorithm_;
return p != nullptr ? *p : reinterpret_cast<const ::opencv_onnx::GraphProto&>(
::opencv_onnx::_GraphProto_default_instance_);
}
inline const ::opencv_onnx::GraphProto& TrainingInfoProto::algorithm() const {
// @@protoc_insertion_point(field_get:opencv_onnx.TrainingInfoProto.algorithm)
return _internal_algorithm();
}
inline void TrainingInfoProto::unsafe_arena_set_allocated_algorithm(
::opencv_onnx::GraphProto* algorithm) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(algorithm_);
}
algorithm_ = algorithm;
if (algorithm) {
_has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_onnx.TrainingInfoProto.algorithm)
}
inline ::opencv_onnx::GraphProto* TrainingInfoProto::release_algorithm() {
_has_bits_[0] &= ~0x00000002u;
::opencv_onnx::GraphProto* temp = algorithm_;
algorithm_ = 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 ::opencv_onnx::GraphProto* TrainingInfoProto::unsafe_arena_release_algorithm() {
// @@protoc_insertion_point(field_release:opencv_onnx.TrainingInfoProto.algorithm)
_has_bits_[0] &= ~0x00000002u;
::opencv_onnx::GraphProto* temp = algorithm_;
algorithm_ = nullptr;
return temp;
}
inline ::opencv_onnx::GraphProto* TrainingInfoProto::_internal_mutable_algorithm() {
_has_bits_[0] |= 0x00000002u;
if (algorithm_ == nullptr) {
auto* p = CreateMaybeMessage<::opencv_onnx::GraphProto>(GetArenaForAllocation());
algorithm_ = p;
}
return algorithm_;
}
inline ::opencv_onnx::GraphProto* TrainingInfoProto::mutable_algorithm() {
::opencv_onnx::GraphProto* _msg = _internal_mutable_algorithm();
// @@protoc_insertion_point(field_mutable:opencv_onnx.TrainingInfoProto.algorithm)
return _msg;
}
inline void TrainingInfoProto::set_allocated_algorithm(::opencv_onnx::GraphProto* algorithm) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete algorithm_;
}
if (algorithm) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_onnx::GraphProto>::GetOwningArena(algorithm);
if (message_arena != submessage_arena) {
algorithm = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, algorithm, submessage_arena);
}
_has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
}
algorithm_ = algorithm;
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.TrainingInfoProto.algorithm)
}
// repeated .opencv_onnx.StringStringEntryProto initialization_binding = 3;
inline int TrainingInfoProto::_internal_initialization_binding_size() const {
return initialization_binding_.size();
}
inline int TrainingInfoProto::initialization_binding_size() const {
return _internal_initialization_binding_size();
}
inline void TrainingInfoProto::clear_initialization_binding() {
initialization_binding_.Clear();
}
inline ::opencv_onnx::StringStringEntryProto* TrainingInfoProto::mutable_initialization_binding(int index) {
// @@protoc_insertion_point(field_mutable:opencv_onnx.TrainingInfoProto.initialization_binding)
return initialization_binding_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::StringStringEntryProto >*
TrainingInfoProto::mutable_initialization_binding() {
// @@protoc_insertion_point(field_mutable_list:opencv_onnx.TrainingInfoProto.initialization_binding)
return &initialization_binding_;
}
inline const ::opencv_onnx::StringStringEntryProto& TrainingInfoProto::_internal_initialization_binding(int index) const {
return initialization_binding_.Get(index);
}
inline const ::opencv_onnx::StringStringEntryProto& TrainingInfoProto::initialization_binding(int index) const {
// @@protoc_insertion_point(field_get:opencv_onnx.TrainingInfoProto.initialization_binding)
return _internal_initialization_binding(index);
}
inline ::opencv_onnx::StringStringEntryProto* TrainingInfoProto::_internal_add_initialization_binding() {
return initialization_binding_.Add();
}
inline ::opencv_onnx::StringStringEntryProto* TrainingInfoProto::add_initialization_binding() {
::opencv_onnx::StringStringEntryProto* _add = _internal_add_initialization_binding();
// @@protoc_insertion_point(field_add:opencv_onnx.TrainingInfoProto.initialization_binding)
return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::StringStringEntryProto >&
TrainingInfoProto::initialization_binding() const {
// @@protoc_insertion_point(field_list:opencv_onnx.TrainingInfoProto.initialization_binding)
return initialization_binding_;
}
// repeated .opencv_onnx.StringStringEntryProto update_binding = 4;
inline int TrainingInfoProto::_internal_update_binding_size() const {
return update_binding_.size();
}
inline int TrainingInfoProto::update_binding_size() const {
return _internal_update_binding_size();
}
inline void TrainingInfoProto::clear_update_binding() {
update_binding_.Clear();
}
inline ::opencv_onnx::StringStringEntryProto* TrainingInfoProto::mutable_update_binding(int index) {
// @@protoc_insertion_point(field_mutable:opencv_onnx.TrainingInfoProto.update_binding)
return update_binding_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::StringStringEntryProto >*
TrainingInfoProto::mutable_update_binding() {
// @@protoc_insertion_point(field_mutable_list:opencv_onnx.TrainingInfoProto.update_binding)
return &update_binding_;
}
inline const ::opencv_onnx::StringStringEntryProto& TrainingInfoProto::_internal_update_binding(int index) const {
return update_binding_.Get(index);
}
inline const ::opencv_onnx::StringStringEntryProto& TrainingInfoProto::update_binding(int index) const {
// @@protoc_insertion_point(field_get:opencv_onnx.TrainingInfoProto.update_binding)
return _internal_update_binding(index);
}
inline ::opencv_onnx::StringStringEntryProto* TrainingInfoProto::_internal_add_update_binding() {
return update_binding_.Add();
}
inline ::opencv_onnx::StringStringEntryProto* TrainingInfoProto::add_update_binding() {
::opencv_onnx::StringStringEntryProto* _add = _internal_add_update_binding();
// @@protoc_insertion_point(field_add:opencv_onnx.TrainingInfoProto.update_binding)
return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::StringStringEntryProto >&
TrainingInfoProto::update_binding() const {
// @@protoc_insertion_point(field_list:opencv_onnx.TrainingInfoProto.update_binding)
return update_binding_;
}
// -------------------------------------------------------------------
// ModelProto
// optional int64 ir_version = 1;
inline bool ModelProto::_internal_has_ir_version() const {
bool value = (_has_bits_[0] & 0x00000020u) != 0;
return value;
}
inline bool ModelProto::has_ir_version() const {
return _internal_has_ir_version();
}
inline void ModelProto::clear_ir_version() {
ir_version_ = int64_t{0};
_has_bits_[0] &= ~0x00000020u;
}
inline int64_t ModelProto::_internal_ir_version() const {
return ir_version_;
}
inline int64_t ModelProto::ir_version() const {
// @@protoc_insertion_point(field_get:opencv_onnx.ModelProto.ir_version)
return _internal_ir_version();
}
inline void ModelProto::_internal_set_ir_version(int64_t value) {
_has_bits_[0] |= 0x00000020u;
ir_version_ = value;
}
inline void ModelProto::set_ir_version(int64_t value) {
_internal_set_ir_version(value);
// @@protoc_insertion_point(field_set:opencv_onnx.ModelProto.ir_version)
}
// repeated .opencv_onnx.OperatorSetIdProto opset_import = 8;
inline int ModelProto::_internal_opset_import_size() const {
return opset_import_.size();
}
inline int ModelProto::opset_import_size() const {
return _internal_opset_import_size();
}
inline void ModelProto::clear_opset_import() {
opset_import_.Clear();
}
inline ::opencv_onnx::OperatorSetIdProto* ModelProto::mutable_opset_import(int index) {
// @@protoc_insertion_point(field_mutable:opencv_onnx.ModelProto.opset_import)
return opset_import_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::OperatorSetIdProto >*
ModelProto::mutable_opset_import() {
// @@protoc_insertion_point(field_mutable_list:opencv_onnx.ModelProto.opset_import)
return &opset_import_;
}
inline const ::opencv_onnx::OperatorSetIdProto& ModelProto::_internal_opset_import(int index) const {
return opset_import_.Get(index);
}
inline const ::opencv_onnx::OperatorSetIdProto& ModelProto::opset_import(int index) const {
// @@protoc_insertion_point(field_get:opencv_onnx.ModelProto.opset_import)
return _internal_opset_import(index);
}
inline ::opencv_onnx::OperatorSetIdProto* ModelProto::_internal_add_opset_import() {
return opset_import_.Add();
}
inline ::opencv_onnx::OperatorSetIdProto* ModelProto::add_opset_import() {
::opencv_onnx::OperatorSetIdProto* _add = _internal_add_opset_import();
// @@protoc_insertion_point(field_add:opencv_onnx.ModelProto.opset_import)
return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::OperatorSetIdProto >&
ModelProto::opset_import() const {
// @@protoc_insertion_point(field_list:opencv_onnx.ModelProto.opset_import)
return opset_import_;
}
// optional string producer_name = 2;
inline bool ModelProto::_internal_has_producer_name() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool ModelProto::has_producer_name() const {
return _internal_has_producer_name();
}
inline void ModelProto::clear_producer_name() {
producer_name_.ClearToEmpty();
_has_bits_[0] &= ~0x00000001u;
}
inline const std::string& ModelProto::producer_name() const {
// @@protoc_insertion_point(field_get:opencv_onnx.ModelProto.producer_name)
return _internal_producer_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ModelProto::set_producer_name(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000001u;
producer_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:opencv_onnx.ModelProto.producer_name)
}
inline std::string* ModelProto::mutable_producer_name() {
std::string* _s = _internal_mutable_producer_name();
// @@protoc_insertion_point(field_mutable:opencv_onnx.ModelProto.producer_name)
return _s;
}
inline const std::string& ModelProto::_internal_producer_name() const {
return producer_name_.Get();
}
inline void ModelProto::_internal_set_producer_name(const std::string& value) {
_has_bits_[0] |= 0x00000001u;
producer_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* ModelProto::_internal_mutable_producer_name() {
_has_bits_[0] |= 0x00000001u;
return producer_name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* ModelProto::release_producer_name() {
// @@protoc_insertion_point(field_release:opencv_onnx.ModelProto.producer_name)
if (!_internal_has_producer_name()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000001u;
auto* p = producer_name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (producer_name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
producer_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void ModelProto::set_allocated_producer_name(std::string* producer_name) {
if (producer_name != nullptr) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
producer_name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), producer_name,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (producer_name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
producer_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.ModelProto.producer_name)
}
// optional string producer_version = 3;
inline bool ModelProto::_internal_has_producer_version() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool ModelProto::has_producer_version() const {
return _internal_has_producer_version();
}
inline void ModelProto::clear_producer_version() {
producer_version_.ClearToEmpty();
_has_bits_[0] &= ~0x00000002u;
}
inline const std::string& ModelProto::producer_version() const {
// @@protoc_insertion_point(field_get:opencv_onnx.ModelProto.producer_version)
return _internal_producer_version();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ModelProto::set_producer_version(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000002u;
producer_version_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:opencv_onnx.ModelProto.producer_version)
}
inline std::string* ModelProto::mutable_producer_version() {
std::string* _s = _internal_mutable_producer_version();
// @@protoc_insertion_point(field_mutable:opencv_onnx.ModelProto.producer_version)
return _s;
}
inline const std::string& ModelProto::_internal_producer_version() const {
return producer_version_.Get();
}
inline void ModelProto::_internal_set_producer_version(const std::string& value) {
_has_bits_[0] |= 0x00000002u;
producer_version_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* ModelProto::_internal_mutable_producer_version() {
_has_bits_[0] |= 0x00000002u;
return producer_version_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* ModelProto::release_producer_version() {
// @@protoc_insertion_point(field_release:opencv_onnx.ModelProto.producer_version)
if (!_internal_has_producer_version()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000002u;
auto* p = producer_version_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (producer_version_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
producer_version_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void ModelProto::set_allocated_producer_version(std::string* producer_version) {
if (producer_version != nullptr) {
_has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
}
producer_version_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), producer_version,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (producer_version_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
producer_version_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.ModelProto.producer_version)
}
// optional string domain = 4;
inline bool ModelProto::_internal_has_domain() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool ModelProto::has_domain() const {
return _internal_has_domain();
}
inline void ModelProto::clear_domain() {
domain_.ClearToEmpty();
_has_bits_[0] &= ~0x00000004u;
}
inline const std::string& ModelProto::domain() const {
// @@protoc_insertion_point(field_get:opencv_onnx.ModelProto.domain)
return _internal_domain();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ModelProto::set_domain(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000004u;
domain_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:opencv_onnx.ModelProto.domain)
}
inline std::string* ModelProto::mutable_domain() {
std::string* _s = _internal_mutable_domain();
// @@protoc_insertion_point(field_mutable:opencv_onnx.ModelProto.domain)
return _s;
}
inline const std::string& ModelProto::_internal_domain() const {
return domain_.Get();
}
inline void ModelProto::_internal_set_domain(const std::string& value) {
_has_bits_[0] |= 0x00000004u;
domain_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* ModelProto::_internal_mutable_domain() {
_has_bits_[0] |= 0x00000004u;
return domain_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* ModelProto::release_domain() {
// @@protoc_insertion_point(field_release:opencv_onnx.ModelProto.domain)
if (!_internal_has_domain()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000004u;
auto* p = domain_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (domain_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
domain_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void ModelProto::set_allocated_domain(std::string* domain) {
if (domain != nullptr) {
_has_bits_[0] |= 0x00000004u;
} else {
_has_bits_[0] &= ~0x00000004u;
}
domain_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), domain,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (domain_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
domain_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.ModelProto.domain)
}
// optional int64 model_version = 5;
inline bool ModelProto::_internal_has_model_version() const {
bool value = (_has_bits_[0] & 0x00000040u) != 0;
return value;
}
inline bool ModelProto::has_model_version() const {
return _internal_has_model_version();
}
inline void ModelProto::clear_model_version() {
model_version_ = int64_t{0};
_has_bits_[0] &= ~0x00000040u;
}
inline int64_t ModelProto::_internal_model_version() const {
return model_version_;
}
inline int64_t ModelProto::model_version() const {
// @@protoc_insertion_point(field_get:opencv_onnx.ModelProto.model_version)
return _internal_model_version();
}
inline void ModelProto::_internal_set_model_version(int64_t value) {
_has_bits_[0] |= 0x00000040u;
model_version_ = value;
}
inline void ModelProto::set_model_version(int64_t value) {
_internal_set_model_version(value);
// @@protoc_insertion_point(field_set:opencv_onnx.ModelProto.model_version)
}
// optional string doc_string = 6;
inline bool ModelProto::_internal_has_doc_string() const {
bool value = (_has_bits_[0] & 0x00000008u) != 0;
return value;
}
inline bool ModelProto::has_doc_string() const {
return _internal_has_doc_string();
}
inline void ModelProto::clear_doc_string() {
doc_string_.ClearToEmpty();
_has_bits_[0] &= ~0x00000008u;
}
inline const std::string& ModelProto::doc_string() const {
// @@protoc_insertion_point(field_get:opencv_onnx.ModelProto.doc_string)
return _internal_doc_string();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ModelProto::set_doc_string(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000008u;
doc_string_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:opencv_onnx.ModelProto.doc_string)
}
inline std::string* ModelProto::mutable_doc_string() {
std::string* _s = _internal_mutable_doc_string();
// @@protoc_insertion_point(field_mutable:opencv_onnx.ModelProto.doc_string)
return _s;
}
inline const std::string& ModelProto::_internal_doc_string() const {
return doc_string_.Get();
}
inline void ModelProto::_internal_set_doc_string(const std::string& value) {
_has_bits_[0] |= 0x00000008u;
doc_string_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* ModelProto::_internal_mutable_doc_string() {
_has_bits_[0] |= 0x00000008u;
return doc_string_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* ModelProto::release_doc_string() {
// @@protoc_insertion_point(field_release:opencv_onnx.ModelProto.doc_string)
if (!_internal_has_doc_string()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000008u;
auto* p = doc_string_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (doc_string_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
doc_string_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void ModelProto::set_allocated_doc_string(std::string* doc_string) {
if (doc_string != nullptr) {
_has_bits_[0] |= 0x00000008u;
} else {
_has_bits_[0] &= ~0x00000008u;
}
doc_string_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), doc_string,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (doc_string_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
doc_string_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.ModelProto.doc_string)
}
// optional .opencv_onnx.GraphProto graph = 7;
inline bool ModelProto::_internal_has_graph() const {
bool value = (_has_bits_[0] & 0x00000010u) != 0;
PROTOBUF_ASSUME(!value || graph_ != nullptr);
return value;
}
inline bool ModelProto::has_graph() const {
return _internal_has_graph();
}
inline void ModelProto::clear_graph() {
if (graph_ != nullptr) graph_->Clear();
_has_bits_[0] &= ~0x00000010u;
}
inline const ::opencv_onnx::GraphProto& ModelProto::_internal_graph() const {
const ::opencv_onnx::GraphProto* p = graph_;
return p != nullptr ? *p : reinterpret_cast<const ::opencv_onnx::GraphProto&>(
::opencv_onnx::_GraphProto_default_instance_);
}
inline const ::opencv_onnx::GraphProto& ModelProto::graph() const {
// @@protoc_insertion_point(field_get:opencv_onnx.ModelProto.graph)
return _internal_graph();
}
inline void ModelProto::unsafe_arena_set_allocated_graph(
::opencv_onnx::GraphProto* graph) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(graph_);
}
graph_ = graph;
if (graph) {
_has_bits_[0] |= 0x00000010u;
} else {
_has_bits_[0] &= ~0x00000010u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_onnx.ModelProto.graph)
}
inline ::opencv_onnx::GraphProto* ModelProto::release_graph() {
_has_bits_[0] &= ~0x00000010u;
::opencv_onnx::GraphProto* temp = graph_;
graph_ = 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 ::opencv_onnx::GraphProto* ModelProto::unsafe_arena_release_graph() {
// @@protoc_insertion_point(field_release:opencv_onnx.ModelProto.graph)
_has_bits_[0] &= ~0x00000010u;
::opencv_onnx::GraphProto* temp = graph_;
graph_ = nullptr;
return temp;
}
inline ::opencv_onnx::GraphProto* ModelProto::_internal_mutable_graph() {
_has_bits_[0] |= 0x00000010u;
if (graph_ == nullptr) {
auto* p = CreateMaybeMessage<::opencv_onnx::GraphProto>(GetArenaForAllocation());
graph_ = p;
}
return graph_;
}
inline ::opencv_onnx::GraphProto* ModelProto::mutable_graph() {
::opencv_onnx::GraphProto* _msg = _internal_mutable_graph();
// @@protoc_insertion_point(field_mutable:opencv_onnx.ModelProto.graph)
return _msg;
}
inline void ModelProto::set_allocated_graph(::opencv_onnx::GraphProto* graph) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete graph_;
}
if (graph) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_onnx::GraphProto>::GetOwningArena(graph);
if (message_arena != submessage_arena) {
graph = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, graph, submessage_arena);
}
_has_bits_[0] |= 0x00000010u;
} else {
_has_bits_[0] &= ~0x00000010u;
}
graph_ = graph;
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.ModelProto.graph)
}
// repeated .opencv_onnx.StringStringEntryProto metadata_props = 14;
inline int ModelProto::_internal_metadata_props_size() const {
return metadata_props_.size();
}
inline int ModelProto::metadata_props_size() const {
return _internal_metadata_props_size();
}
inline void ModelProto::clear_metadata_props() {
metadata_props_.Clear();
}
inline ::opencv_onnx::StringStringEntryProto* ModelProto::mutable_metadata_props(int index) {
// @@protoc_insertion_point(field_mutable:opencv_onnx.ModelProto.metadata_props)
return metadata_props_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::StringStringEntryProto >*
ModelProto::mutable_metadata_props() {
// @@protoc_insertion_point(field_mutable_list:opencv_onnx.ModelProto.metadata_props)
return &metadata_props_;
}
inline const ::opencv_onnx::StringStringEntryProto& ModelProto::_internal_metadata_props(int index) const {
return metadata_props_.Get(index);
}
inline const ::opencv_onnx::StringStringEntryProto& ModelProto::metadata_props(int index) const {
// @@protoc_insertion_point(field_get:opencv_onnx.ModelProto.metadata_props)
return _internal_metadata_props(index);
}
inline ::opencv_onnx::StringStringEntryProto* ModelProto::_internal_add_metadata_props() {
return metadata_props_.Add();
}
inline ::opencv_onnx::StringStringEntryProto* ModelProto::add_metadata_props() {
::opencv_onnx::StringStringEntryProto* _add = _internal_add_metadata_props();
// @@protoc_insertion_point(field_add:opencv_onnx.ModelProto.metadata_props)
return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::StringStringEntryProto >&
ModelProto::metadata_props() const {
// @@protoc_insertion_point(field_list:opencv_onnx.ModelProto.metadata_props)
return metadata_props_;
}
// repeated .opencv_onnx.TrainingInfoProto training_info = 20;
inline int ModelProto::_internal_training_info_size() const {
return training_info_.size();
}
inline int ModelProto::training_info_size() const {
return _internal_training_info_size();
}
inline void ModelProto::clear_training_info() {
training_info_.Clear();
}
inline ::opencv_onnx::TrainingInfoProto* ModelProto::mutable_training_info(int index) {
// @@protoc_insertion_point(field_mutable:opencv_onnx.ModelProto.training_info)
return training_info_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::TrainingInfoProto >*
ModelProto::mutable_training_info() {
// @@protoc_insertion_point(field_mutable_list:opencv_onnx.ModelProto.training_info)
return &training_info_;
}
inline const ::opencv_onnx::TrainingInfoProto& ModelProto::_internal_training_info(int index) const {
return training_info_.Get(index);
}
inline const ::opencv_onnx::TrainingInfoProto& ModelProto::training_info(int index) const {
// @@protoc_insertion_point(field_get:opencv_onnx.ModelProto.training_info)
return _internal_training_info(index);
}
inline ::opencv_onnx::TrainingInfoProto* ModelProto::_internal_add_training_info() {
return training_info_.Add();
}
inline ::opencv_onnx::TrainingInfoProto* ModelProto::add_training_info() {
::opencv_onnx::TrainingInfoProto* _add = _internal_add_training_info();
// @@protoc_insertion_point(field_add:opencv_onnx.ModelProto.training_info)
return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::TrainingInfoProto >&
ModelProto::training_info() const {
// @@protoc_insertion_point(field_list:opencv_onnx.ModelProto.training_info)
return training_info_;
}
// repeated .opencv_onnx.FunctionProto functions = 25;
inline int ModelProto::_internal_functions_size() const {
return functions_.size();
}
inline int ModelProto::functions_size() const {
return _internal_functions_size();
}
inline void ModelProto::clear_functions() {
functions_.Clear();
}
inline ::opencv_onnx::FunctionProto* ModelProto::mutable_functions(int index) {
// @@protoc_insertion_point(field_mutable:opencv_onnx.ModelProto.functions)
return functions_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::FunctionProto >*
ModelProto::mutable_functions() {
// @@protoc_insertion_point(field_mutable_list:opencv_onnx.ModelProto.functions)
return &functions_;
}
inline const ::opencv_onnx::FunctionProto& ModelProto::_internal_functions(int index) const {
return functions_.Get(index);
}
inline const ::opencv_onnx::FunctionProto& ModelProto::functions(int index) const {
// @@protoc_insertion_point(field_get:opencv_onnx.ModelProto.functions)
return _internal_functions(index);
}
inline ::opencv_onnx::FunctionProto* ModelProto::_internal_add_functions() {
return functions_.Add();
}
inline ::opencv_onnx::FunctionProto* ModelProto::add_functions() {
::opencv_onnx::FunctionProto* _add = _internal_add_functions();
// @@protoc_insertion_point(field_add:opencv_onnx.ModelProto.functions)
return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::FunctionProto >&
ModelProto::functions() const {
// @@protoc_insertion_point(field_list:opencv_onnx.ModelProto.functions)
return functions_;
}
// repeated .opencv_onnx.DeviceConfigurationProto configuration = 26;
inline int ModelProto::_internal_configuration_size() const {
return configuration_.size();
}
inline int ModelProto::configuration_size() const {
return _internal_configuration_size();
}
inline void ModelProto::clear_configuration() {
configuration_.Clear();
}
inline ::opencv_onnx::DeviceConfigurationProto* ModelProto::mutable_configuration(int index) {
// @@protoc_insertion_point(field_mutable:opencv_onnx.ModelProto.configuration)
return configuration_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::DeviceConfigurationProto >*
ModelProto::mutable_configuration() {
// @@protoc_insertion_point(field_mutable_list:opencv_onnx.ModelProto.configuration)
return &configuration_;
}
inline const ::opencv_onnx::DeviceConfigurationProto& ModelProto::_internal_configuration(int index) const {
return configuration_.Get(index);
}
inline const ::opencv_onnx::DeviceConfigurationProto& ModelProto::configuration(int index) const {
// @@protoc_insertion_point(field_get:opencv_onnx.ModelProto.configuration)
return _internal_configuration(index);
}
inline ::opencv_onnx::DeviceConfigurationProto* ModelProto::_internal_add_configuration() {
return configuration_.Add();
}
inline ::opencv_onnx::DeviceConfigurationProto* ModelProto::add_configuration() {
::opencv_onnx::DeviceConfigurationProto* _add = _internal_add_configuration();
// @@protoc_insertion_point(field_add:opencv_onnx.ModelProto.configuration)
return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::DeviceConfigurationProto >&
ModelProto::configuration() const {
// @@protoc_insertion_point(field_list:opencv_onnx.ModelProto.configuration)
return configuration_;
}
// -------------------------------------------------------------------
// DeviceConfigurationProto
// optional string name = 1;
inline bool DeviceConfigurationProto::_internal_has_name() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool DeviceConfigurationProto::has_name() const {
return _internal_has_name();
}
inline void DeviceConfigurationProto::clear_name() {
name_.ClearToEmpty();
_has_bits_[0] &= ~0x00000001u;
}
inline const std::string& DeviceConfigurationProto::name() const {
// @@protoc_insertion_point(field_get:opencv_onnx.DeviceConfigurationProto.name)
return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void DeviceConfigurationProto::set_name(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000001u;
name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:opencv_onnx.DeviceConfigurationProto.name)
}
inline std::string* DeviceConfigurationProto::mutable_name() {
std::string* _s = _internal_mutable_name();
// @@protoc_insertion_point(field_mutable:opencv_onnx.DeviceConfigurationProto.name)
return _s;
}
inline const std::string& DeviceConfigurationProto::_internal_name() const {
return name_.Get();
}
inline void DeviceConfigurationProto::_internal_set_name(const std::string& value) {
_has_bits_[0] |= 0x00000001u;
name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* DeviceConfigurationProto::_internal_mutable_name() {
_has_bits_[0] |= 0x00000001u;
return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* DeviceConfigurationProto::release_name() {
// @@protoc_insertion_point(field_release:opencv_onnx.DeviceConfigurationProto.name)
if (!_internal_has_name()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000001u;
auto* p = name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void DeviceConfigurationProto::set_allocated_name(std::string* name) {
if (name != nullptr) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.DeviceConfigurationProto.name)
}
// optional int32 num_devices = 2;
inline bool DeviceConfigurationProto::_internal_has_num_devices() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool DeviceConfigurationProto::has_num_devices() const {
return _internal_has_num_devices();
}
inline void DeviceConfigurationProto::clear_num_devices() {
num_devices_ = 0;
_has_bits_[0] &= ~0x00000002u;
}
inline int32_t DeviceConfigurationProto::_internal_num_devices() const {
return num_devices_;
}
inline int32_t DeviceConfigurationProto::num_devices() const {
// @@protoc_insertion_point(field_get:opencv_onnx.DeviceConfigurationProto.num_devices)
return _internal_num_devices();
}
inline void DeviceConfigurationProto::_internal_set_num_devices(int32_t value) {
_has_bits_[0] |= 0x00000002u;
num_devices_ = value;
}
inline void DeviceConfigurationProto::set_num_devices(int32_t value) {
_internal_set_num_devices(value);
// @@protoc_insertion_point(field_set:opencv_onnx.DeviceConfigurationProto.num_devices)
}
// repeated string device = 3;
inline int DeviceConfigurationProto::_internal_device_size() const {
return device_.size();
}
inline int DeviceConfigurationProto::device_size() const {
return _internal_device_size();
}
inline void DeviceConfigurationProto::clear_device() {
device_.Clear();
}
inline std::string* DeviceConfigurationProto::add_device() {
std::string* _s = _internal_add_device();
// @@protoc_insertion_point(field_add_mutable:opencv_onnx.DeviceConfigurationProto.device)
return _s;
}
inline const std::string& DeviceConfigurationProto::_internal_device(int index) const {
return device_.Get(index);
}
inline const std::string& DeviceConfigurationProto::device(int index) const {
// @@protoc_insertion_point(field_get:opencv_onnx.DeviceConfigurationProto.device)
return _internal_device(index);
}
inline std::string* DeviceConfigurationProto::mutable_device(int index) {
// @@protoc_insertion_point(field_mutable:opencv_onnx.DeviceConfigurationProto.device)
return device_.Mutable(index);
}
inline void DeviceConfigurationProto::set_device(int index, const std::string& value) {
device_.Mutable(index)->assign(value);
// @@protoc_insertion_point(field_set:opencv_onnx.DeviceConfigurationProto.device)
}
inline void DeviceConfigurationProto::set_device(int index, std::string&& value) {
device_.Mutable(index)->assign(std::move(value));
// @@protoc_insertion_point(field_set:opencv_onnx.DeviceConfigurationProto.device)
}
inline void DeviceConfigurationProto::set_device(int index, const char* value) {
GOOGLE_DCHECK(value != nullptr);
device_.Mutable(index)->assign(value);
// @@protoc_insertion_point(field_set_char:opencv_onnx.DeviceConfigurationProto.device)
}
inline void DeviceConfigurationProto::set_device(int index, const char* value, size_t size) {
device_.Mutable(index)->assign(
reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_set_pointer:opencv_onnx.DeviceConfigurationProto.device)
}
inline std::string* DeviceConfigurationProto::_internal_add_device() {
return device_.Add();
}
inline void DeviceConfigurationProto::add_device(const std::string& value) {
device_.Add()->assign(value);
// @@protoc_insertion_point(field_add:opencv_onnx.DeviceConfigurationProto.device)
}
inline void DeviceConfigurationProto::add_device(std::string&& value) {
device_.Add(std::move(value));
// @@protoc_insertion_point(field_add:opencv_onnx.DeviceConfigurationProto.device)
}
inline void DeviceConfigurationProto::add_device(const char* value) {
GOOGLE_DCHECK(value != nullptr);
device_.Add()->assign(value);
// @@protoc_insertion_point(field_add_char:opencv_onnx.DeviceConfigurationProto.device)
}
inline void DeviceConfigurationProto::add_device(const char* value, size_t size) {
device_.Add()->assign(reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_add_pointer:opencv_onnx.DeviceConfigurationProto.device)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
DeviceConfigurationProto::device() const {
// @@protoc_insertion_point(field_list:opencv_onnx.DeviceConfigurationProto.device)
return device_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
DeviceConfigurationProto::mutable_device() {
// @@protoc_insertion_point(field_mutable_list:opencv_onnx.DeviceConfigurationProto.device)
return &device_;
}
// -------------------------------------------------------------------
// StringStringEntryProto
// optional string key = 1;
inline bool StringStringEntryProto::_internal_has_key() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool StringStringEntryProto::has_key() const {
return _internal_has_key();
}
inline void StringStringEntryProto::clear_key() {
key_.ClearToEmpty();
_has_bits_[0] &= ~0x00000001u;
}
inline const std::string& StringStringEntryProto::key() const {
// @@protoc_insertion_point(field_get:opencv_onnx.StringStringEntryProto.key)
return _internal_key();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void StringStringEntryProto::set_key(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000001u;
key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:opencv_onnx.StringStringEntryProto.key)
}
inline std::string* StringStringEntryProto::mutable_key() {
std::string* _s = _internal_mutable_key();
// @@protoc_insertion_point(field_mutable:opencv_onnx.StringStringEntryProto.key)
return _s;
}
inline const std::string& StringStringEntryProto::_internal_key() const {
return key_.Get();
}
inline void StringStringEntryProto::_internal_set_key(const std::string& value) {
_has_bits_[0] |= 0x00000001u;
key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* StringStringEntryProto::_internal_mutable_key() {
_has_bits_[0] |= 0x00000001u;
return key_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* StringStringEntryProto::release_key() {
// @@protoc_insertion_point(field_release:opencv_onnx.StringStringEntryProto.key)
if (!_internal_has_key()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000001u;
auto* p = key_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (key_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
key_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void StringStringEntryProto::set_allocated_key(std::string* key) {
if (key != nullptr) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), key,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (key_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
key_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.StringStringEntryProto.key)
}
// optional string value = 2;
inline bool StringStringEntryProto::_internal_has_value() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool StringStringEntryProto::has_value() const {
return _internal_has_value();
}
inline void StringStringEntryProto::clear_value() {
value_.ClearToEmpty();
_has_bits_[0] &= ~0x00000002u;
}
inline const std::string& StringStringEntryProto::value() const {
// @@protoc_insertion_point(field_get:opencv_onnx.StringStringEntryProto.value)
return _internal_value();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void StringStringEntryProto::set_value(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000002u;
value_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:opencv_onnx.StringStringEntryProto.value)
}
inline std::string* StringStringEntryProto::mutable_value() {
std::string* _s = _internal_mutable_value();
// @@protoc_insertion_point(field_mutable:opencv_onnx.StringStringEntryProto.value)
return _s;
}
inline const std::string& StringStringEntryProto::_internal_value() const {
return value_.Get();
}
inline void StringStringEntryProto::_internal_set_value(const std::string& value) {
_has_bits_[0] |= 0x00000002u;
value_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* StringStringEntryProto::_internal_mutable_value() {
_has_bits_[0] |= 0x00000002u;
return value_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* StringStringEntryProto::release_value() {
// @@protoc_insertion_point(field_release:opencv_onnx.StringStringEntryProto.value)
if (!_internal_has_value()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000002u;
auto* p = value_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (value_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
value_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void StringStringEntryProto::set_allocated_value(std::string* value) {
if (value != nullptr) {
_has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
}
value_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (value_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
value_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.StringStringEntryProto.value)
}
// -------------------------------------------------------------------
// TensorAnnotation
// optional string tensor_name = 1;
inline bool TensorAnnotation::_internal_has_tensor_name() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool TensorAnnotation::has_tensor_name() const {
return _internal_has_tensor_name();
}
inline void TensorAnnotation::clear_tensor_name() {
tensor_name_.ClearToEmpty();
_has_bits_[0] &= ~0x00000001u;
}
inline const std::string& TensorAnnotation::tensor_name() const {
// @@protoc_insertion_point(field_get:opencv_onnx.TensorAnnotation.tensor_name)
return _internal_tensor_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void TensorAnnotation::set_tensor_name(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000001u;
tensor_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:opencv_onnx.TensorAnnotation.tensor_name)
}
inline std::string* TensorAnnotation::mutable_tensor_name() {
std::string* _s = _internal_mutable_tensor_name();
// @@protoc_insertion_point(field_mutable:opencv_onnx.TensorAnnotation.tensor_name)
return _s;
}
inline const std::string& TensorAnnotation::_internal_tensor_name() const {
return tensor_name_.Get();
}
inline void TensorAnnotation::_internal_set_tensor_name(const std::string& value) {
_has_bits_[0] |= 0x00000001u;
tensor_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* TensorAnnotation::_internal_mutable_tensor_name() {
_has_bits_[0] |= 0x00000001u;
return tensor_name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* TensorAnnotation::release_tensor_name() {
// @@protoc_insertion_point(field_release:opencv_onnx.TensorAnnotation.tensor_name)
if (!_internal_has_tensor_name()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000001u;
auto* p = tensor_name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (tensor_name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
tensor_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void TensorAnnotation::set_allocated_tensor_name(std::string* tensor_name) {
if (tensor_name != nullptr) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
tensor_name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), tensor_name,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (tensor_name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
tensor_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.TensorAnnotation.tensor_name)
}
// repeated .opencv_onnx.StringStringEntryProto quant_parameter_tensor_names = 2;
inline int TensorAnnotation::_internal_quant_parameter_tensor_names_size() const {
return quant_parameter_tensor_names_.size();
}
inline int TensorAnnotation::quant_parameter_tensor_names_size() const {
return _internal_quant_parameter_tensor_names_size();
}
inline void TensorAnnotation::clear_quant_parameter_tensor_names() {
quant_parameter_tensor_names_.Clear();
}
inline ::opencv_onnx::StringStringEntryProto* TensorAnnotation::mutable_quant_parameter_tensor_names(int index) {
// @@protoc_insertion_point(field_mutable:opencv_onnx.TensorAnnotation.quant_parameter_tensor_names)
return quant_parameter_tensor_names_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::StringStringEntryProto >*
TensorAnnotation::mutable_quant_parameter_tensor_names() {
// @@protoc_insertion_point(field_mutable_list:opencv_onnx.TensorAnnotation.quant_parameter_tensor_names)
return &quant_parameter_tensor_names_;
}
inline const ::opencv_onnx::StringStringEntryProto& TensorAnnotation::_internal_quant_parameter_tensor_names(int index) const {
return quant_parameter_tensor_names_.Get(index);
}
inline const ::opencv_onnx::StringStringEntryProto& TensorAnnotation::quant_parameter_tensor_names(int index) const {
// @@protoc_insertion_point(field_get:opencv_onnx.TensorAnnotation.quant_parameter_tensor_names)
return _internal_quant_parameter_tensor_names(index);
}
inline ::opencv_onnx::StringStringEntryProto* TensorAnnotation::_internal_add_quant_parameter_tensor_names() {
return quant_parameter_tensor_names_.Add();
}
inline ::opencv_onnx::StringStringEntryProto* TensorAnnotation::add_quant_parameter_tensor_names() {
::opencv_onnx::StringStringEntryProto* _add = _internal_add_quant_parameter_tensor_names();
// @@protoc_insertion_point(field_add:opencv_onnx.TensorAnnotation.quant_parameter_tensor_names)
return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::StringStringEntryProto >&
TensorAnnotation::quant_parameter_tensor_names() const {
// @@protoc_insertion_point(field_list:opencv_onnx.TensorAnnotation.quant_parameter_tensor_names)
return quant_parameter_tensor_names_;
}
// -------------------------------------------------------------------
// GraphProto
// repeated .opencv_onnx.NodeProto node = 1;
inline int GraphProto::_internal_node_size() const {
return node_.size();
}
inline int GraphProto::node_size() const {
return _internal_node_size();
}
inline void GraphProto::clear_node() {
node_.Clear();
}
inline ::opencv_onnx::NodeProto* GraphProto::mutable_node(int index) {
// @@protoc_insertion_point(field_mutable:opencv_onnx.GraphProto.node)
return node_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::NodeProto >*
GraphProto::mutable_node() {
// @@protoc_insertion_point(field_mutable_list:opencv_onnx.GraphProto.node)
return &node_;
}
inline const ::opencv_onnx::NodeProto& GraphProto::_internal_node(int index) const {
return node_.Get(index);
}
inline const ::opencv_onnx::NodeProto& GraphProto::node(int index) const {
// @@protoc_insertion_point(field_get:opencv_onnx.GraphProto.node)
return _internal_node(index);
}
inline ::opencv_onnx::NodeProto* GraphProto::_internal_add_node() {
return node_.Add();
}
inline ::opencv_onnx::NodeProto* GraphProto::add_node() {
::opencv_onnx::NodeProto* _add = _internal_add_node();
// @@protoc_insertion_point(field_add:opencv_onnx.GraphProto.node)
return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::NodeProto >&
GraphProto::node() const {
// @@protoc_insertion_point(field_list:opencv_onnx.GraphProto.node)
return node_;
}
// optional string name = 2;
inline bool GraphProto::_internal_has_name() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool GraphProto::has_name() const {
return _internal_has_name();
}
inline void GraphProto::clear_name() {
name_.ClearToEmpty();
_has_bits_[0] &= ~0x00000001u;
}
inline const std::string& GraphProto::name() const {
// @@protoc_insertion_point(field_get:opencv_onnx.GraphProto.name)
return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void GraphProto::set_name(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000001u;
name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:opencv_onnx.GraphProto.name)
}
inline std::string* GraphProto::mutable_name() {
std::string* _s = _internal_mutable_name();
// @@protoc_insertion_point(field_mutable:opencv_onnx.GraphProto.name)
return _s;
}
inline const std::string& GraphProto::_internal_name() const {
return name_.Get();
}
inline void GraphProto::_internal_set_name(const std::string& value) {
_has_bits_[0] |= 0x00000001u;
name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* GraphProto::_internal_mutable_name() {
_has_bits_[0] |= 0x00000001u;
return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* GraphProto::release_name() {
// @@protoc_insertion_point(field_release:opencv_onnx.GraphProto.name)
if (!_internal_has_name()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000001u;
auto* p = name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void GraphProto::set_allocated_name(std::string* name) {
if (name != nullptr) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.GraphProto.name)
}
// repeated .opencv_onnx.TensorProto initializer = 5;
inline int GraphProto::_internal_initializer_size() const {
return initializer_.size();
}
inline int GraphProto::initializer_size() const {
return _internal_initializer_size();
}
inline void GraphProto::clear_initializer() {
initializer_.Clear();
}
inline ::opencv_onnx::TensorProto* GraphProto::mutable_initializer(int index) {
// @@protoc_insertion_point(field_mutable:opencv_onnx.GraphProto.initializer)
return initializer_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::TensorProto >*
GraphProto::mutable_initializer() {
// @@protoc_insertion_point(field_mutable_list:opencv_onnx.GraphProto.initializer)
return &initializer_;
}
inline const ::opencv_onnx::TensorProto& GraphProto::_internal_initializer(int index) const {
return initializer_.Get(index);
}
inline const ::opencv_onnx::TensorProto& GraphProto::initializer(int index) const {
// @@protoc_insertion_point(field_get:opencv_onnx.GraphProto.initializer)
return _internal_initializer(index);
}
inline ::opencv_onnx::TensorProto* GraphProto::_internal_add_initializer() {
return initializer_.Add();
}
inline ::opencv_onnx::TensorProto* GraphProto::add_initializer() {
::opencv_onnx::TensorProto* _add = _internal_add_initializer();
// @@protoc_insertion_point(field_add:opencv_onnx.GraphProto.initializer)
return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::TensorProto >&
GraphProto::initializer() const {
// @@protoc_insertion_point(field_list:opencv_onnx.GraphProto.initializer)
return initializer_;
}
// repeated .opencv_onnx.SparseTensorProto sparse_initializer = 15;
inline int GraphProto::_internal_sparse_initializer_size() const {
return sparse_initializer_.size();
}
inline int GraphProto::sparse_initializer_size() const {
return _internal_sparse_initializer_size();
}
inline void GraphProto::clear_sparse_initializer() {
sparse_initializer_.Clear();
}
inline ::opencv_onnx::SparseTensorProto* GraphProto::mutable_sparse_initializer(int index) {
// @@protoc_insertion_point(field_mutable:opencv_onnx.GraphProto.sparse_initializer)
return sparse_initializer_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::SparseTensorProto >*
GraphProto::mutable_sparse_initializer() {
// @@protoc_insertion_point(field_mutable_list:opencv_onnx.GraphProto.sparse_initializer)
return &sparse_initializer_;
}
inline const ::opencv_onnx::SparseTensorProto& GraphProto::_internal_sparse_initializer(int index) const {
return sparse_initializer_.Get(index);
}
inline const ::opencv_onnx::SparseTensorProto& GraphProto::sparse_initializer(int index) const {
// @@protoc_insertion_point(field_get:opencv_onnx.GraphProto.sparse_initializer)
return _internal_sparse_initializer(index);
}
inline ::opencv_onnx::SparseTensorProto* GraphProto::_internal_add_sparse_initializer() {
return sparse_initializer_.Add();
}
inline ::opencv_onnx::SparseTensorProto* GraphProto::add_sparse_initializer() {
::opencv_onnx::SparseTensorProto* _add = _internal_add_sparse_initializer();
// @@protoc_insertion_point(field_add:opencv_onnx.GraphProto.sparse_initializer)
return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::SparseTensorProto >&
GraphProto::sparse_initializer() const {
// @@protoc_insertion_point(field_list:opencv_onnx.GraphProto.sparse_initializer)
return sparse_initializer_;
}
// optional string doc_string = 10;
inline bool GraphProto::_internal_has_doc_string() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool GraphProto::has_doc_string() const {
return _internal_has_doc_string();
}
inline void GraphProto::clear_doc_string() {
doc_string_.ClearToEmpty();
_has_bits_[0] &= ~0x00000002u;
}
inline const std::string& GraphProto::doc_string() const {
// @@protoc_insertion_point(field_get:opencv_onnx.GraphProto.doc_string)
return _internal_doc_string();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void GraphProto::set_doc_string(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000002u;
doc_string_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:opencv_onnx.GraphProto.doc_string)
}
inline std::string* GraphProto::mutable_doc_string() {
std::string* _s = _internal_mutable_doc_string();
// @@protoc_insertion_point(field_mutable:opencv_onnx.GraphProto.doc_string)
return _s;
}
inline const std::string& GraphProto::_internal_doc_string() const {
return doc_string_.Get();
}
inline void GraphProto::_internal_set_doc_string(const std::string& value) {
_has_bits_[0] |= 0x00000002u;
doc_string_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* GraphProto::_internal_mutable_doc_string() {
_has_bits_[0] |= 0x00000002u;
return doc_string_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* GraphProto::release_doc_string() {
// @@protoc_insertion_point(field_release:opencv_onnx.GraphProto.doc_string)
if (!_internal_has_doc_string()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000002u;
auto* p = doc_string_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (doc_string_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
doc_string_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void GraphProto::set_allocated_doc_string(std::string* doc_string) {
if (doc_string != nullptr) {
_has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
}
doc_string_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), doc_string,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (doc_string_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
doc_string_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.GraphProto.doc_string)
}
// repeated .opencv_onnx.ValueInfoProto input = 11;
inline int GraphProto::_internal_input_size() const {
return input_.size();
}
inline int GraphProto::input_size() const {
return _internal_input_size();
}
inline void GraphProto::clear_input() {
input_.Clear();
}
inline ::opencv_onnx::ValueInfoProto* GraphProto::mutable_input(int index) {
// @@protoc_insertion_point(field_mutable:opencv_onnx.GraphProto.input)
return input_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::ValueInfoProto >*
GraphProto::mutable_input() {
// @@protoc_insertion_point(field_mutable_list:opencv_onnx.GraphProto.input)
return &input_;
}
inline const ::opencv_onnx::ValueInfoProto& GraphProto::_internal_input(int index) const {
return input_.Get(index);
}
inline const ::opencv_onnx::ValueInfoProto& GraphProto::input(int index) const {
// @@protoc_insertion_point(field_get:opencv_onnx.GraphProto.input)
return _internal_input(index);
}
inline ::opencv_onnx::ValueInfoProto* GraphProto::_internal_add_input() {
return input_.Add();
}
inline ::opencv_onnx::ValueInfoProto* GraphProto::add_input() {
::opencv_onnx::ValueInfoProto* _add = _internal_add_input();
// @@protoc_insertion_point(field_add:opencv_onnx.GraphProto.input)
return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::ValueInfoProto >&
GraphProto::input() const {
// @@protoc_insertion_point(field_list:opencv_onnx.GraphProto.input)
return input_;
}
// repeated .opencv_onnx.ValueInfoProto output = 12;
inline int GraphProto::_internal_output_size() const {
return output_.size();
}
inline int GraphProto::output_size() const {
return _internal_output_size();
}
inline void GraphProto::clear_output() {
output_.Clear();
}
inline ::opencv_onnx::ValueInfoProto* GraphProto::mutable_output(int index) {
// @@protoc_insertion_point(field_mutable:opencv_onnx.GraphProto.output)
return output_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::ValueInfoProto >*
GraphProto::mutable_output() {
// @@protoc_insertion_point(field_mutable_list:opencv_onnx.GraphProto.output)
return &output_;
}
inline const ::opencv_onnx::ValueInfoProto& GraphProto::_internal_output(int index) const {
return output_.Get(index);
}
inline const ::opencv_onnx::ValueInfoProto& GraphProto::output(int index) const {
// @@protoc_insertion_point(field_get:opencv_onnx.GraphProto.output)
return _internal_output(index);
}
inline ::opencv_onnx::ValueInfoProto* GraphProto::_internal_add_output() {
return output_.Add();
}
inline ::opencv_onnx::ValueInfoProto* GraphProto::add_output() {
::opencv_onnx::ValueInfoProto* _add = _internal_add_output();
// @@protoc_insertion_point(field_add:opencv_onnx.GraphProto.output)
return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::ValueInfoProto >&
GraphProto::output() const {
// @@protoc_insertion_point(field_list:opencv_onnx.GraphProto.output)
return output_;
}
// repeated .opencv_onnx.ValueInfoProto value_info = 13;
inline int GraphProto::_internal_value_info_size() const {
return value_info_.size();
}
inline int GraphProto::value_info_size() const {
return _internal_value_info_size();
}
inline void GraphProto::clear_value_info() {
value_info_.Clear();
}
inline ::opencv_onnx::ValueInfoProto* GraphProto::mutable_value_info(int index) {
// @@protoc_insertion_point(field_mutable:opencv_onnx.GraphProto.value_info)
return value_info_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::ValueInfoProto >*
GraphProto::mutable_value_info() {
// @@protoc_insertion_point(field_mutable_list:opencv_onnx.GraphProto.value_info)
return &value_info_;
}
inline const ::opencv_onnx::ValueInfoProto& GraphProto::_internal_value_info(int index) const {
return value_info_.Get(index);
}
inline const ::opencv_onnx::ValueInfoProto& GraphProto::value_info(int index) const {
// @@protoc_insertion_point(field_get:opencv_onnx.GraphProto.value_info)
return _internal_value_info(index);
}
inline ::opencv_onnx::ValueInfoProto* GraphProto::_internal_add_value_info() {
return value_info_.Add();
}
inline ::opencv_onnx::ValueInfoProto* GraphProto::add_value_info() {
::opencv_onnx::ValueInfoProto* _add = _internal_add_value_info();
// @@protoc_insertion_point(field_add:opencv_onnx.GraphProto.value_info)
return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::ValueInfoProto >&
GraphProto::value_info() const {
// @@protoc_insertion_point(field_list:opencv_onnx.GraphProto.value_info)
return value_info_;
}
// repeated .opencv_onnx.TensorAnnotation quantization_annotation = 14;
inline int GraphProto::_internal_quantization_annotation_size() const {
return quantization_annotation_.size();
}
inline int GraphProto::quantization_annotation_size() const {
return _internal_quantization_annotation_size();
}
inline void GraphProto::clear_quantization_annotation() {
quantization_annotation_.Clear();
}
inline ::opencv_onnx::TensorAnnotation* GraphProto::mutable_quantization_annotation(int index) {
// @@protoc_insertion_point(field_mutable:opencv_onnx.GraphProto.quantization_annotation)
return quantization_annotation_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::TensorAnnotation >*
GraphProto::mutable_quantization_annotation() {
// @@protoc_insertion_point(field_mutable_list:opencv_onnx.GraphProto.quantization_annotation)
return &quantization_annotation_;
}
inline const ::opencv_onnx::TensorAnnotation& GraphProto::_internal_quantization_annotation(int index) const {
return quantization_annotation_.Get(index);
}
inline const ::opencv_onnx::TensorAnnotation& GraphProto::quantization_annotation(int index) const {
// @@protoc_insertion_point(field_get:opencv_onnx.GraphProto.quantization_annotation)
return _internal_quantization_annotation(index);
}
inline ::opencv_onnx::TensorAnnotation* GraphProto::_internal_add_quantization_annotation() {
return quantization_annotation_.Add();
}
inline ::opencv_onnx::TensorAnnotation* GraphProto::add_quantization_annotation() {
::opencv_onnx::TensorAnnotation* _add = _internal_add_quantization_annotation();
// @@protoc_insertion_point(field_add:opencv_onnx.GraphProto.quantization_annotation)
return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::TensorAnnotation >&
GraphProto::quantization_annotation() const {
// @@protoc_insertion_point(field_list:opencv_onnx.GraphProto.quantization_annotation)
return quantization_annotation_;
}
// repeated .opencv_onnx.StringStringEntryProto metadata_props = 16;
inline int GraphProto::_internal_metadata_props_size() const {
return metadata_props_.size();
}
inline int GraphProto::metadata_props_size() const {
return _internal_metadata_props_size();
}
inline void GraphProto::clear_metadata_props() {
metadata_props_.Clear();
}
inline ::opencv_onnx::StringStringEntryProto* GraphProto::mutable_metadata_props(int index) {
// @@protoc_insertion_point(field_mutable:opencv_onnx.GraphProto.metadata_props)
return metadata_props_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::StringStringEntryProto >*
GraphProto::mutable_metadata_props() {
// @@protoc_insertion_point(field_mutable_list:opencv_onnx.GraphProto.metadata_props)
return &metadata_props_;
}
inline const ::opencv_onnx::StringStringEntryProto& GraphProto::_internal_metadata_props(int index) const {
return metadata_props_.Get(index);
}
inline const ::opencv_onnx::StringStringEntryProto& GraphProto::metadata_props(int index) const {
// @@protoc_insertion_point(field_get:opencv_onnx.GraphProto.metadata_props)
return _internal_metadata_props(index);
}
inline ::opencv_onnx::StringStringEntryProto* GraphProto::_internal_add_metadata_props() {
return metadata_props_.Add();
}
inline ::opencv_onnx::StringStringEntryProto* GraphProto::add_metadata_props() {
::opencv_onnx::StringStringEntryProto* _add = _internal_add_metadata_props();
// @@protoc_insertion_point(field_add:opencv_onnx.GraphProto.metadata_props)
return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::StringStringEntryProto >&
GraphProto::metadata_props() const {
// @@protoc_insertion_point(field_list:opencv_onnx.GraphProto.metadata_props)
return metadata_props_;
}
// -------------------------------------------------------------------
// TensorProto_Segment
// optional int64 begin = 1;
inline bool TensorProto_Segment::_internal_has_begin() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool TensorProto_Segment::has_begin() const {
return _internal_has_begin();
}
inline void TensorProto_Segment::clear_begin() {
begin_ = int64_t{0};
_has_bits_[0] &= ~0x00000001u;
}
inline int64_t TensorProto_Segment::_internal_begin() const {
return begin_;
}
inline int64_t TensorProto_Segment::begin() const {
// @@protoc_insertion_point(field_get:opencv_onnx.TensorProto.Segment.begin)
return _internal_begin();
}
inline void TensorProto_Segment::_internal_set_begin(int64_t value) {
_has_bits_[0] |= 0x00000001u;
begin_ = value;
}
inline void TensorProto_Segment::set_begin(int64_t value) {
_internal_set_begin(value);
// @@protoc_insertion_point(field_set:opencv_onnx.TensorProto.Segment.begin)
}
// optional int64 end = 2;
inline bool TensorProto_Segment::_internal_has_end() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool TensorProto_Segment::has_end() const {
return _internal_has_end();
}
inline void TensorProto_Segment::clear_end() {
end_ = int64_t{0};
_has_bits_[0] &= ~0x00000002u;
}
inline int64_t TensorProto_Segment::_internal_end() const {
return end_;
}
inline int64_t TensorProto_Segment::end() const {
// @@protoc_insertion_point(field_get:opencv_onnx.TensorProto.Segment.end)
return _internal_end();
}
inline void TensorProto_Segment::_internal_set_end(int64_t value) {
_has_bits_[0] |= 0x00000002u;
end_ = value;
}
inline void TensorProto_Segment::set_end(int64_t value) {
_internal_set_end(value);
// @@protoc_insertion_point(field_set:opencv_onnx.TensorProto.Segment.end)
}
// -------------------------------------------------------------------
// TensorProto
// repeated int64 dims = 1;
inline int TensorProto::_internal_dims_size() const {
return dims_.size();
}
inline int TensorProto::dims_size() const {
return _internal_dims_size();
}
inline void TensorProto::clear_dims() {
dims_.Clear();
}
inline int64_t TensorProto::_internal_dims(int index) const {
return dims_.Get(index);
}
inline int64_t TensorProto::dims(int index) const {
// @@protoc_insertion_point(field_get:opencv_onnx.TensorProto.dims)
return _internal_dims(index);
}
inline void TensorProto::set_dims(int index, int64_t value) {
dims_.Set(index, value);
// @@protoc_insertion_point(field_set:opencv_onnx.TensorProto.dims)
}
inline void TensorProto::_internal_add_dims(int64_t value) {
dims_.Add(value);
}
inline void TensorProto::add_dims(int64_t value) {
_internal_add_dims(value);
// @@protoc_insertion_point(field_add:opencv_onnx.TensorProto.dims)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
TensorProto::_internal_dims() const {
return dims_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
TensorProto::dims() const {
// @@protoc_insertion_point(field_list:opencv_onnx.TensorProto.dims)
return _internal_dims();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
TensorProto::_internal_mutable_dims() {
return &dims_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
TensorProto::mutable_dims() {
// @@protoc_insertion_point(field_mutable_list:opencv_onnx.TensorProto.dims)
return _internal_mutable_dims();
}
// optional int32 data_type = 2;
inline bool TensorProto::_internal_has_data_type() const {
bool value = (_has_bits_[0] & 0x00000010u) != 0;
return value;
}
inline bool TensorProto::has_data_type() const {
return _internal_has_data_type();
}
inline void TensorProto::clear_data_type() {
data_type_ = 0;
_has_bits_[0] &= ~0x00000010u;
}
inline int32_t TensorProto::_internal_data_type() const {
return data_type_;
}
inline int32_t TensorProto::data_type() const {
// @@protoc_insertion_point(field_get:opencv_onnx.TensorProto.data_type)
return _internal_data_type();
}
inline void TensorProto::_internal_set_data_type(int32_t value) {
_has_bits_[0] |= 0x00000010u;
data_type_ = value;
}
inline void TensorProto::set_data_type(int32_t value) {
_internal_set_data_type(value);
// @@protoc_insertion_point(field_set:opencv_onnx.TensorProto.data_type)
}
// optional .opencv_onnx.TensorProto.Segment segment = 3;
inline bool TensorProto::_internal_has_segment() const {
bool value = (_has_bits_[0] & 0x00000008u) != 0;
PROTOBUF_ASSUME(!value || segment_ != nullptr);
return value;
}
inline bool TensorProto::has_segment() const {
return _internal_has_segment();
}
inline void TensorProto::clear_segment() {
if (segment_ != nullptr) segment_->Clear();
_has_bits_[0] &= ~0x00000008u;
}
inline const ::opencv_onnx::TensorProto_Segment& TensorProto::_internal_segment() const {
const ::opencv_onnx::TensorProto_Segment* p = segment_;
return p != nullptr ? *p : reinterpret_cast<const ::opencv_onnx::TensorProto_Segment&>(
::opencv_onnx::_TensorProto_Segment_default_instance_);
}
inline const ::opencv_onnx::TensorProto_Segment& TensorProto::segment() const {
// @@protoc_insertion_point(field_get:opencv_onnx.TensorProto.segment)
return _internal_segment();
}
inline void TensorProto::unsafe_arena_set_allocated_segment(
::opencv_onnx::TensorProto_Segment* segment) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(segment_);
}
segment_ = segment;
if (segment) {
_has_bits_[0] |= 0x00000008u;
} else {
_has_bits_[0] &= ~0x00000008u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_onnx.TensorProto.segment)
}
inline ::opencv_onnx::TensorProto_Segment* TensorProto::release_segment() {
_has_bits_[0] &= ~0x00000008u;
::opencv_onnx::TensorProto_Segment* temp = segment_;
segment_ = 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 ::opencv_onnx::TensorProto_Segment* TensorProto::unsafe_arena_release_segment() {
// @@protoc_insertion_point(field_release:opencv_onnx.TensorProto.segment)
_has_bits_[0] &= ~0x00000008u;
::opencv_onnx::TensorProto_Segment* temp = segment_;
segment_ = nullptr;
return temp;
}
inline ::opencv_onnx::TensorProto_Segment* TensorProto::_internal_mutable_segment() {
_has_bits_[0] |= 0x00000008u;
if (segment_ == nullptr) {
auto* p = CreateMaybeMessage<::opencv_onnx::TensorProto_Segment>(GetArenaForAllocation());
segment_ = p;
}
return segment_;
}
inline ::opencv_onnx::TensorProto_Segment* TensorProto::mutable_segment() {
::opencv_onnx::TensorProto_Segment* _msg = _internal_mutable_segment();
// @@protoc_insertion_point(field_mutable:opencv_onnx.TensorProto.segment)
return _msg;
}
inline void TensorProto::set_allocated_segment(::opencv_onnx::TensorProto_Segment* segment) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete segment_;
}
if (segment) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_onnx::TensorProto_Segment>::GetOwningArena(segment);
if (message_arena != submessage_arena) {
segment = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, segment, submessage_arena);
}
_has_bits_[0] |= 0x00000008u;
} else {
_has_bits_[0] &= ~0x00000008u;
}
segment_ = segment;
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.TensorProto.segment)
}
// repeated float float_data = 4 [packed = true];
inline int TensorProto::_internal_float_data_size() const {
return float_data_.size();
}
inline int TensorProto::float_data_size() const {
return _internal_float_data_size();
}
inline void TensorProto::clear_float_data() {
float_data_.Clear();
}
inline float TensorProto::_internal_float_data(int index) const {
return float_data_.Get(index);
}
inline float TensorProto::float_data(int index) const {
// @@protoc_insertion_point(field_get:opencv_onnx.TensorProto.float_data)
return _internal_float_data(index);
}
inline void TensorProto::set_float_data(int index, float value) {
float_data_.Set(index, value);
// @@protoc_insertion_point(field_set:opencv_onnx.TensorProto.float_data)
}
inline void TensorProto::_internal_add_float_data(float value) {
float_data_.Add(value);
}
inline void TensorProto::add_float_data(float value) {
_internal_add_float_data(value);
// @@protoc_insertion_point(field_add:opencv_onnx.TensorProto.float_data)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
TensorProto::_internal_float_data() const {
return float_data_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
TensorProto::float_data() const {
// @@protoc_insertion_point(field_list:opencv_onnx.TensorProto.float_data)
return _internal_float_data();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
TensorProto::_internal_mutable_float_data() {
return &float_data_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
TensorProto::mutable_float_data() {
// @@protoc_insertion_point(field_mutable_list:opencv_onnx.TensorProto.float_data)
return _internal_mutable_float_data();
}
// repeated int32 int32_data = 5 [packed = true];
inline int TensorProto::_internal_int32_data_size() const {
return int32_data_.size();
}
inline int TensorProto::int32_data_size() const {
return _internal_int32_data_size();
}
inline void TensorProto::clear_int32_data() {
int32_data_.Clear();
}
inline int32_t TensorProto::_internal_int32_data(int index) const {
return int32_data_.Get(index);
}
inline int32_t TensorProto::int32_data(int index) const {
// @@protoc_insertion_point(field_get:opencv_onnx.TensorProto.int32_data)
return _internal_int32_data(index);
}
inline void TensorProto::set_int32_data(int index, int32_t value) {
int32_data_.Set(index, value);
// @@protoc_insertion_point(field_set:opencv_onnx.TensorProto.int32_data)
}
inline void TensorProto::_internal_add_int32_data(int32_t value) {
int32_data_.Add(value);
}
inline void TensorProto::add_int32_data(int32_t value) {
_internal_add_int32_data(value);
// @@protoc_insertion_point(field_add:opencv_onnx.TensorProto.int32_data)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
TensorProto::_internal_int32_data() const {
return int32_data_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
TensorProto::int32_data() const {
// @@protoc_insertion_point(field_list:opencv_onnx.TensorProto.int32_data)
return _internal_int32_data();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
TensorProto::_internal_mutable_int32_data() {
return &int32_data_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
TensorProto::mutable_int32_data() {
// @@protoc_insertion_point(field_mutable_list:opencv_onnx.TensorProto.int32_data)
return _internal_mutable_int32_data();
}
// repeated bytes string_data = 6;
inline int TensorProto::_internal_string_data_size() const {
return string_data_.size();
}
inline int TensorProto::string_data_size() const {
return _internal_string_data_size();
}
inline void TensorProto::clear_string_data() {
string_data_.Clear();
}
inline std::string* TensorProto::add_string_data() {
std::string* _s = _internal_add_string_data();
// @@protoc_insertion_point(field_add_mutable:opencv_onnx.TensorProto.string_data)
return _s;
}
inline const std::string& TensorProto::_internal_string_data(int index) const {
return string_data_.Get(index);
}
inline const std::string& TensorProto::string_data(int index) const {
// @@protoc_insertion_point(field_get:opencv_onnx.TensorProto.string_data)
return _internal_string_data(index);
}
inline std::string* TensorProto::mutable_string_data(int index) {
// @@protoc_insertion_point(field_mutable:opencv_onnx.TensorProto.string_data)
return string_data_.Mutable(index);
}
inline void TensorProto::set_string_data(int index, const std::string& value) {
string_data_.Mutable(index)->assign(value);
// @@protoc_insertion_point(field_set:opencv_onnx.TensorProto.string_data)
}
inline void TensorProto::set_string_data(int index, std::string&& value) {
string_data_.Mutable(index)->assign(std::move(value));
// @@protoc_insertion_point(field_set:opencv_onnx.TensorProto.string_data)
}
inline void TensorProto::set_string_data(int index, const char* value) {
GOOGLE_DCHECK(value != nullptr);
string_data_.Mutable(index)->assign(value);
// @@protoc_insertion_point(field_set_char:opencv_onnx.TensorProto.string_data)
}
inline void TensorProto::set_string_data(int index, const void* value, size_t size) {
string_data_.Mutable(index)->assign(
reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_set_pointer:opencv_onnx.TensorProto.string_data)
}
inline std::string* TensorProto::_internal_add_string_data() {
return string_data_.Add();
}
inline void TensorProto::add_string_data(const std::string& value) {
string_data_.Add()->assign(value);
// @@protoc_insertion_point(field_add:opencv_onnx.TensorProto.string_data)
}
inline void TensorProto::add_string_data(std::string&& value) {
string_data_.Add(std::move(value));
// @@protoc_insertion_point(field_add:opencv_onnx.TensorProto.string_data)
}
inline void TensorProto::add_string_data(const char* value) {
GOOGLE_DCHECK(value != nullptr);
string_data_.Add()->assign(value);
// @@protoc_insertion_point(field_add_char:opencv_onnx.TensorProto.string_data)
}
inline void TensorProto::add_string_data(const void* value, size_t size) {
string_data_.Add()->assign(reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_add_pointer:opencv_onnx.TensorProto.string_data)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
TensorProto::string_data() const {
// @@protoc_insertion_point(field_list:opencv_onnx.TensorProto.string_data)
return string_data_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
TensorProto::mutable_string_data() {
// @@protoc_insertion_point(field_mutable_list:opencv_onnx.TensorProto.string_data)
return &string_data_;
}
// repeated int64 int64_data = 7 [packed = true];
inline int TensorProto::_internal_int64_data_size() const {
return int64_data_.size();
}
inline int TensorProto::int64_data_size() const {
return _internal_int64_data_size();
}
inline void TensorProto::clear_int64_data() {
int64_data_.Clear();
}
inline int64_t TensorProto::_internal_int64_data(int index) const {
return int64_data_.Get(index);
}
inline int64_t TensorProto::int64_data(int index) const {
// @@protoc_insertion_point(field_get:opencv_onnx.TensorProto.int64_data)
return _internal_int64_data(index);
}
inline void TensorProto::set_int64_data(int index, int64_t value) {
int64_data_.Set(index, value);
// @@protoc_insertion_point(field_set:opencv_onnx.TensorProto.int64_data)
}
inline void TensorProto::_internal_add_int64_data(int64_t value) {
int64_data_.Add(value);
}
inline void TensorProto::add_int64_data(int64_t value) {
_internal_add_int64_data(value);
// @@protoc_insertion_point(field_add:opencv_onnx.TensorProto.int64_data)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
TensorProto::_internal_int64_data() const {
return int64_data_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
TensorProto::int64_data() const {
// @@protoc_insertion_point(field_list:opencv_onnx.TensorProto.int64_data)
return _internal_int64_data();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
TensorProto::_internal_mutable_int64_data() {
return &int64_data_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
TensorProto::mutable_int64_data() {
// @@protoc_insertion_point(field_mutable_list:opencv_onnx.TensorProto.int64_data)
return _internal_mutable_int64_data();
}
// optional string name = 8;
inline bool TensorProto::_internal_has_name() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool TensorProto::has_name() const {
return _internal_has_name();
}
inline void TensorProto::clear_name() {
name_.ClearToEmpty();
_has_bits_[0] &= ~0x00000001u;
}
inline const std::string& TensorProto::name() const {
// @@protoc_insertion_point(field_get:opencv_onnx.TensorProto.name)
return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void TensorProto::set_name(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000001u;
name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:opencv_onnx.TensorProto.name)
}
inline std::string* TensorProto::mutable_name() {
std::string* _s = _internal_mutable_name();
// @@protoc_insertion_point(field_mutable:opencv_onnx.TensorProto.name)
return _s;
}
inline const std::string& TensorProto::_internal_name() const {
return name_.Get();
}
inline void TensorProto::_internal_set_name(const std::string& value) {
_has_bits_[0] |= 0x00000001u;
name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* TensorProto::_internal_mutable_name() {
_has_bits_[0] |= 0x00000001u;
return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* TensorProto::release_name() {
// @@protoc_insertion_point(field_release:opencv_onnx.TensorProto.name)
if (!_internal_has_name()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000001u;
auto* p = name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void TensorProto::set_allocated_name(std::string* name) {
if (name != nullptr) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.TensorProto.name)
}
// optional string doc_string = 12;
inline bool TensorProto::_internal_has_doc_string() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool TensorProto::has_doc_string() const {
return _internal_has_doc_string();
}
inline void TensorProto::clear_doc_string() {
doc_string_.ClearToEmpty();
_has_bits_[0] &= ~0x00000004u;
}
inline const std::string& TensorProto::doc_string() const {
// @@protoc_insertion_point(field_get:opencv_onnx.TensorProto.doc_string)
return _internal_doc_string();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void TensorProto::set_doc_string(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000004u;
doc_string_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:opencv_onnx.TensorProto.doc_string)
}
inline std::string* TensorProto::mutable_doc_string() {
std::string* _s = _internal_mutable_doc_string();
// @@protoc_insertion_point(field_mutable:opencv_onnx.TensorProto.doc_string)
return _s;
}
inline const std::string& TensorProto::_internal_doc_string() const {
return doc_string_.Get();
}
inline void TensorProto::_internal_set_doc_string(const std::string& value) {
_has_bits_[0] |= 0x00000004u;
doc_string_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* TensorProto::_internal_mutable_doc_string() {
_has_bits_[0] |= 0x00000004u;
return doc_string_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* TensorProto::release_doc_string() {
// @@protoc_insertion_point(field_release:opencv_onnx.TensorProto.doc_string)
if (!_internal_has_doc_string()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000004u;
auto* p = doc_string_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (doc_string_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
doc_string_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void TensorProto::set_allocated_doc_string(std::string* doc_string) {
if (doc_string != nullptr) {
_has_bits_[0] |= 0x00000004u;
} else {
_has_bits_[0] &= ~0x00000004u;
}
doc_string_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), doc_string,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (doc_string_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
doc_string_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.TensorProto.doc_string)
}
// optional bytes raw_data = 9;
inline bool TensorProto::_internal_has_raw_data() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool TensorProto::has_raw_data() const {
return _internal_has_raw_data();
}
inline void TensorProto::clear_raw_data() {
raw_data_.ClearToEmpty();
_has_bits_[0] &= ~0x00000002u;
}
inline const std::string& TensorProto::raw_data() const {
// @@protoc_insertion_point(field_get:opencv_onnx.TensorProto.raw_data)
return _internal_raw_data();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void TensorProto::set_raw_data(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000002u;
raw_data_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:opencv_onnx.TensorProto.raw_data)
}
inline std::string* TensorProto::mutable_raw_data() {
std::string* _s = _internal_mutable_raw_data();
// @@protoc_insertion_point(field_mutable:opencv_onnx.TensorProto.raw_data)
return _s;
}
inline const std::string& TensorProto::_internal_raw_data() const {
return raw_data_.Get();
}
inline void TensorProto::_internal_set_raw_data(const std::string& value) {
_has_bits_[0] |= 0x00000002u;
raw_data_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* TensorProto::_internal_mutable_raw_data() {
_has_bits_[0] |= 0x00000002u;
return raw_data_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* TensorProto::release_raw_data() {
// @@protoc_insertion_point(field_release:opencv_onnx.TensorProto.raw_data)
if (!_internal_has_raw_data()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000002u;
auto* p = raw_data_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (raw_data_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
raw_data_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void TensorProto::set_allocated_raw_data(std::string* raw_data) {
if (raw_data != nullptr) {
_has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
}
raw_data_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), raw_data,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (raw_data_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
raw_data_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.TensorProto.raw_data)
}
// repeated .opencv_onnx.StringStringEntryProto external_data = 13;
inline int TensorProto::_internal_external_data_size() const {
return external_data_.size();
}
inline int TensorProto::external_data_size() const {
return _internal_external_data_size();
}
inline void TensorProto::clear_external_data() {
external_data_.Clear();
}
inline ::opencv_onnx::StringStringEntryProto* TensorProto::mutable_external_data(int index) {
// @@protoc_insertion_point(field_mutable:opencv_onnx.TensorProto.external_data)
return external_data_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::StringStringEntryProto >*
TensorProto::mutable_external_data() {
// @@protoc_insertion_point(field_mutable_list:opencv_onnx.TensorProto.external_data)
return &external_data_;
}
inline const ::opencv_onnx::StringStringEntryProto& TensorProto::_internal_external_data(int index) const {
return external_data_.Get(index);
}
inline const ::opencv_onnx::StringStringEntryProto& TensorProto::external_data(int index) const {
// @@protoc_insertion_point(field_get:opencv_onnx.TensorProto.external_data)
return _internal_external_data(index);
}
inline ::opencv_onnx::StringStringEntryProto* TensorProto::_internal_add_external_data() {
return external_data_.Add();
}
inline ::opencv_onnx::StringStringEntryProto* TensorProto::add_external_data() {
::opencv_onnx::StringStringEntryProto* _add = _internal_add_external_data();
// @@protoc_insertion_point(field_add:opencv_onnx.TensorProto.external_data)
return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::StringStringEntryProto >&
TensorProto::external_data() const {
// @@protoc_insertion_point(field_list:opencv_onnx.TensorProto.external_data)
return external_data_;
}
// optional .opencv_onnx.TensorProto.DataLocation data_location = 14;
inline bool TensorProto::_internal_has_data_location() const {
bool value = (_has_bits_[0] & 0x00000020u) != 0;
return value;
}
inline bool TensorProto::has_data_location() const {
return _internal_has_data_location();
}
inline void TensorProto::clear_data_location() {
data_location_ = 0;
_has_bits_[0] &= ~0x00000020u;
}
inline ::opencv_onnx::TensorProto_DataLocation TensorProto::_internal_data_location() const {
return static_cast< ::opencv_onnx::TensorProto_DataLocation >(data_location_);
}
inline ::opencv_onnx::TensorProto_DataLocation TensorProto::data_location() const {
// @@protoc_insertion_point(field_get:opencv_onnx.TensorProto.data_location)
return _internal_data_location();
}
inline void TensorProto::_internal_set_data_location(::opencv_onnx::TensorProto_DataLocation value) {
assert(::opencv_onnx::TensorProto_DataLocation_IsValid(value));
_has_bits_[0] |= 0x00000020u;
data_location_ = value;
}
inline void TensorProto::set_data_location(::opencv_onnx::TensorProto_DataLocation value) {
_internal_set_data_location(value);
// @@protoc_insertion_point(field_set:opencv_onnx.TensorProto.data_location)
}
// repeated double double_data = 10 [packed = true];
inline int TensorProto::_internal_double_data_size() const {
return double_data_.size();
}
inline int TensorProto::double_data_size() const {
return _internal_double_data_size();
}
inline void TensorProto::clear_double_data() {
double_data_.Clear();
}
inline double TensorProto::_internal_double_data(int index) const {
return double_data_.Get(index);
}
inline double TensorProto::double_data(int index) const {
// @@protoc_insertion_point(field_get:opencv_onnx.TensorProto.double_data)
return _internal_double_data(index);
}
inline void TensorProto::set_double_data(int index, double value) {
double_data_.Set(index, value);
// @@protoc_insertion_point(field_set:opencv_onnx.TensorProto.double_data)
}
inline void TensorProto::_internal_add_double_data(double value) {
double_data_.Add(value);
}
inline void TensorProto::add_double_data(double value) {
_internal_add_double_data(value);
// @@protoc_insertion_point(field_add:opencv_onnx.TensorProto.double_data)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
TensorProto::_internal_double_data() const {
return double_data_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
TensorProto::double_data() const {
// @@protoc_insertion_point(field_list:opencv_onnx.TensorProto.double_data)
return _internal_double_data();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
TensorProto::_internal_mutable_double_data() {
return &double_data_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
TensorProto::mutable_double_data() {
// @@protoc_insertion_point(field_mutable_list:opencv_onnx.TensorProto.double_data)
return _internal_mutable_double_data();
}
// repeated uint64 uint64_data = 11 [packed = true];
inline int TensorProto::_internal_uint64_data_size() const {
return uint64_data_.size();
}
inline int TensorProto::uint64_data_size() const {
return _internal_uint64_data_size();
}
inline void TensorProto::clear_uint64_data() {
uint64_data_.Clear();
}
inline uint64_t TensorProto::_internal_uint64_data(int index) const {
return uint64_data_.Get(index);
}
inline uint64_t TensorProto::uint64_data(int index) const {
// @@protoc_insertion_point(field_get:opencv_onnx.TensorProto.uint64_data)
return _internal_uint64_data(index);
}
inline void TensorProto::set_uint64_data(int index, uint64_t value) {
uint64_data_.Set(index, value);
// @@protoc_insertion_point(field_set:opencv_onnx.TensorProto.uint64_data)
}
inline void TensorProto::_internal_add_uint64_data(uint64_t value) {
uint64_data_.Add(value);
}
inline void TensorProto::add_uint64_data(uint64_t value) {
_internal_add_uint64_data(value);
// @@protoc_insertion_point(field_add:opencv_onnx.TensorProto.uint64_data)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
TensorProto::_internal_uint64_data() const {
return uint64_data_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
TensorProto::uint64_data() const {
// @@protoc_insertion_point(field_list:opencv_onnx.TensorProto.uint64_data)
return _internal_uint64_data();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
TensorProto::_internal_mutable_uint64_data() {
return &uint64_data_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
TensorProto::mutable_uint64_data() {
// @@protoc_insertion_point(field_mutable_list:opencv_onnx.TensorProto.uint64_data)
return _internal_mutable_uint64_data();
}
// repeated .opencv_onnx.StringStringEntryProto metadata_props = 16;
inline int TensorProto::_internal_metadata_props_size() const {
return metadata_props_.size();
}
inline int TensorProto::metadata_props_size() const {
return _internal_metadata_props_size();
}
inline void TensorProto::clear_metadata_props() {
metadata_props_.Clear();
}
inline ::opencv_onnx::StringStringEntryProto* TensorProto::mutable_metadata_props(int index) {
// @@protoc_insertion_point(field_mutable:opencv_onnx.TensorProto.metadata_props)
return metadata_props_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::StringStringEntryProto >*
TensorProto::mutable_metadata_props() {
// @@protoc_insertion_point(field_mutable_list:opencv_onnx.TensorProto.metadata_props)
return &metadata_props_;
}
inline const ::opencv_onnx::StringStringEntryProto& TensorProto::_internal_metadata_props(int index) const {
return metadata_props_.Get(index);
}
inline const ::opencv_onnx::StringStringEntryProto& TensorProto::metadata_props(int index) const {
// @@protoc_insertion_point(field_get:opencv_onnx.TensorProto.metadata_props)
return _internal_metadata_props(index);
}
inline ::opencv_onnx::StringStringEntryProto* TensorProto::_internal_add_metadata_props() {
return metadata_props_.Add();
}
inline ::opencv_onnx::StringStringEntryProto* TensorProto::add_metadata_props() {
::opencv_onnx::StringStringEntryProto* _add = _internal_add_metadata_props();
// @@protoc_insertion_point(field_add:opencv_onnx.TensorProto.metadata_props)
return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::StringStringEntryProto >&
TensorProto::metadata_props() const {
// @@protoc_insertion_point(field_list:opencv_onnx.TensorProto.metadata_props)
return metadata_props_;
}
// -------------------------------------------------------------------
// SparseTensorProto
// optional .opencv_onnx.TensorProto values = 1;
inline bool SparseTensorProto::_internal_has_values() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
PROTOBUF_ASSUME(!value || values_ != nullptr);
return value;
}
inline bool SparseTensorProto::has_values() const {
return _internal_has_values();
}
inline void SparseTensorProto::clear_values() {
if (values_ != nullptr) values_->Clear();
_has_bits_[0] &= ~0x00000001u;
}
inline const ::opencv_onnx::TensorProto& SparseTensorProto::_internal_values() const {
const ::opencv_onnx::TensorProto* p = values_;
return p != nullptr ? *p : reinterpret_cast<const ::opencv_onnx::TensorProto&>(
::opencv_onnx::_TensorProto_default_instance_);
}
inline const ::opencv_onnx::TensorProto& SparseTensorProto::values() const {
// @@protoc_insertion_point(field_get:opencv_onnx.SparseTensorProto.values)
return _internal_values();
}
inline void SparseTensorProto::unsafe_arena_set_allocated_values(
::opencv_onnx::TensorProto* values) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(values_);
}
values_ = values;
if (values) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_onnx.SparseTensorProto.values)
}
inline ::opencv_onnx::TensorProto* SparseTensorProto::release_values() {
_has_bits_[0] &= ~0x00000001u;
::opencv_onnx::TensorProto* temp = values_;
values_ = 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 ::opencv_onnx::TensorProto* SparseTensorProto::unsafe_arena_release_values() {
// @@protoc_insertion_point(field_release:opencv_onnx.SparseTensorProto.values)
_has_bits_[0] &= ~0x00000001u;
::opencv_onnx::TensorProto* temp = values_;
values_ = nullptr;
return temp;
}
inline ::opencv_onnx::TensorProto* SparseTensorProto::_internal_mutable_values() {
_has_bits_[0] |= 0x00000001u;
if (values_ == nullptr) {
auto* p = CreateMaybeMessage<::opencv_onnx::TensorProto>(GetArenaForAllocation());
values_ = p;
}
return values_;
}
inline ::opencv_onnx::TensorProto* SparseTensorProto::mutable_values() {
::opencv_onnx::TensorProto* _msg = _internal_mutable_values();
// @@protoc_insertion_point(field_mutable:opencv_onnx.SparseTensorProto.values)
return _msg;
}
inline void SparseTensorProto::set_allocated_values(::opencv_onnx::TensorProto* values) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete values_;
}
if (values) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_onnx::TensorProto>::GetOwningArena(values);
if (message_arena != submessage_arena) {
values = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, values, submessage_arena);
}
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
values_ = values;
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.SparseTensorProto.values)
}
// optional .opencv_onnx.TensorProto indices = 2;
inline bool SparseTensorProto::_internal_has_indices() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
PROTOBUF_ASSUME(!value || indices_ != nullptr);
return value;
}
inline bool SparseTensorProto::has_indices() const {
return _internal_has_indices();
}
inline void SparseTensorProto::clear_indices() {
if (indices_ != nullptr) indices_->Clear();
_has_bits_[0] &= ~0x00000002u;
}
inline const ::opencv_onnx::TensorProto& SparseTensorProto::_internal_indices() const {
const ::opencv_onnx::TensorProto* p = indices_;
return p != nullptr ? *p : reinterpret_cast<const ::opencv_onnx::TensorProto&>(
::opencv_onnx::_TensorProto_default_instance_);
}
inline const ::opencv_onnx::TensorProto& SparseTensorProto::indices() const {
// @@protoc_insertion_point(field_get:opencv_onnx.SparseTensorProto.indices)
return _internal_indices();
}
inline void SparseTensorProto::unsafe_arena_set_allocated_indices(
::opencv_onnx::TensorProto* indices) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(indices_);
}
indices_ = indices;
if (indices) {
_has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_onnx.SparseTensorProto.indices)
}
inline ::opencv_onnx::TensorProto* SparseTensorProto::release_indices() {
_has_bits_[0] &= ~0x00000002u;
::opencv_onnx::TensorProto* temp = indices_;
indices_ = 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 ::opencv_onnx::TensorProto* SparseTensorProto::unsafe_arena_release_indices() {
// @@protoc_insertion_point(field_release:opencv_onnx.SparseTensorProto.indices)
_has_bits_[0] &= ~0x00000002u;
::opencv_onnx::TensorProto* temp = indices_;
indices_ = nullptr;
return temp;
}
inline ::opencv_onnx::TensorProto* SparseTensorProto::_internal_mutable_indices() {
_has_bits_[0] |= 0x00000002u;
if (indices_ == nullptr) {
auto* p = CreateMaybeMessage<::opencv_onnx::TensorProto>(GetArenaForAllocation());
indices_ = p;
}
return indices_;
}
inline ::opencv_onnx::TensorProto* SparseTensorProto::mutable_indices() {
::opencv_onnx::TensorProto* _msg = _internal_mutable_indices();
// @@protoc_insertion_point(field_mutable:opencv_onnx.SparseTensorProto.indices)
return _msg;
}
inline void SparseTensorProto::set_allocated_indices(::opencv_onnx::TensorProto* indices) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete indices_;
}
if (indices) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_onnx::TensorProto>::GetOwningArena(indices);
if (message_arena != submessage_arena) {
indices = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, indices, submessage_arena);
}
_has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
}
indices_ = indices;
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.SparseTensorProto.indices)
}
// repeated int64 dims = 3;
inline int SparseTensorProto::_internal_dims_size() const {
return dims_.size();
}
inline int SparseTensorProto::dims_size() const {
return _internal_dims_size();
}
inline void SparseTensorProto::clear_dims() {
dims_.Clear();
}
inline int64_t SparseTensorProto::_internal_dims(int index) const {
return dims_.Get(index);
}
inline int64_t SparseTensorProto::dims(int index) const {
// @@protoc_insertion_point(field_get:opencv_onnx.SparseTensorProto.dims)
return _internal_dims(index);
}
inline void SparseTensorProto::set_dims(int index, int64_t value) {
dims_.Set(index, value);
// @@protoc_insertion_point(field_set:opencv_onnx.SparseTensorProto.dims)
}
inline void SparseTensorProto::_internal_add_dims(int64_t value) {
dims_.Add(value);
}
inline void SparseTensorProto::add_dims(int64_t value) {
_internal_add_dims(value);
// @@protoc_insertion_point(field_add:opencv_onnx.SparseTensorProto.dims)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
SparseTensorProto::_internal_dims() const {
return dims_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
SparseTensorProto::dims() const {
// @@protoc_insertion_point(field_list:opencv_onnx.SparseTensorProto.dims)
return _internal_dims();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
SparseTensorProto::_internal_mutable_dims() {
return &dims_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
SparseTensorProto::mutable_dims() {
// @@protoc_insertion_point(field_mutable_list:opencv_onnx.SparseTensorProto.dims)
return _internal_mutable_dims();
}
// -------------------------------------------------------------------
// TensorShapeProto_Dimension
// int64 dim_value = 1;
inline bool TensorShapeProto_Dimension::_internal_has_dim_value() const {
return value_case() == kDimValue;
}
inline bool TensorShapeProto_Dimension::has_dim_value() const {
return _internal_has_dim_value();
}
inline void TensorShapeProto_Dimension::set_has_dim_value() {
_oneof_case_[0] = kDimValue;
}
inline void TensorShapeProto_Dimension::clear_dim_value() {
if (_internal_has_dim_value()) {
value_.dim_value_ = int64_t{0};
clear_has_value();
}
}
inline int64_t TensorShapeProto_Dimension::_internal_dim_value() const {
if (_internal_has_dim_value()) {
return value_.dim_value_;
}
return int64_t{0};
}
inline void TensorShapeProto_Dimension::_internal_set_dim_value(int64_t value) {
if (!_internal_has_dim_value()) {
clear_value();
set_has_dim_value();
}
value_.dim_value_ = value;
}
inline int64_t TensorShapeProto_Dimension::dim_value() const {
// @@protoc_insertion_point(field_get:opencv_onnx.TensorShapeProto.Dimension.dim_value)
return _internal_dim_value();
}
inline void TensorShapeProto_Dimension::set_dim_value(int64_t value) {
_internal_set_dim_value(value);
// @@protoc_insertion_point(field_set:opencv_onnx.TensorShapeProto.Dimension.dim_value)
}
// string dim_param = 2;
inline bool TensorShapeProto_Dimension::_internal_has_dim_param() const {
return value_case() == kDimParam;
}
inline bool TensorShapeProto_Dimension::has_dim_param() const {
return _internal_has_dim_param();
}
inline void TensorShapeProto_Dimension::set_has_dim_param() {
_oneof_case_[0] = kDimParam;
}
inline void TensorShapeProto_Dimension::clear_dim_param() {
if (_internal_has_dim_param()) {
value_.dim_param_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
clear_has_value();
}
}
inline const std::string& TensorShapeProto_Dimension::dim_param() const {
// @@protoc_insertion_point(field_get:opencv_onnx.TensorShapeProto.Dimension.dim_param)
return _internal_dim_param();
}
template <typename ArgT0, typename... ArgT>
inline void TensorShapeProto_Dimension::set_dim_param(ArgT0&& arg0, ArgT... args) {
if (!_internal_has_dim_param()) {
clear_value();
set_has_dim_param();
value_.dim_param_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
value_.dim_param_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:opencv_onnx.TensorShapeProto.Dimension.dim_param)
}
inline std::string* TensorShapeProto_Dimension::mutable_dim_param() {
std::string* _s = _internal_mutable_dim_param();
// @@protoc_insertion_point(field_mutable:opencv_onnx.TensorShapeProto.Dimension.dim_param)
return _s;
}
inline const std::string& TensorShapeProto_Dimension::_internal_dim_param() const {
if (_internal_has_dim_param()) {
return value_.dim_param_.Get();
}
return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
}
inline void TensorShapeProto_Dimension::_internal_set_dim_param(const std::string& value) {
if (!_internal_has_dim_param()) {
clear_value();
set_has_dim_param();
value_.dim_param_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
value_.dim_param_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* TensorShapeProto_Dimension::_internal_mutable_dim_param() {
if (!_internal_has_dim_param()) {
clear_value();
set_has_dim_param();
value_.dim_param_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
return value_.dim_param_.Mutable(
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* TensorShapeProto_Dimension::release_dim_param() {
// @@protoc_insertion_point(field_release:opencv_onnx.TensorShapeProto.Dimension.dim_param)
if (_internal_has_dim_param()) {
clear_has_value();
return value_.dim_param_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
} else {
return nullptr;
}
}
inline void TensorShapeProto_Dimension::set_allocated_dim_param(std::string* dim_param) {
if (has_value()) {
clear_value();
}
if (dim_param != nullptr) {
set_has_dim_param();
value_.dim_param_.UnsafeSetDefault(dim_param);
::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaForAllocation();
if (arena != nullptr) {
arena->Own(dim_param);
}
}
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.TensorShapeProto.Dimension.dim_param)
}
// optional string denotation = 3;
inline bool TensorShapeProto_Dimension::_internal_has_denotation() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool TensorShapeProto_Dimension::has_denotation() const {
return _internal_has_denotation();
}
inline void TensorShapeProto_Dimension::clear_denotation() {
denotation_.ClearToEmpty();
_has_bits_[0] &= ~0x00000001u;
}
inline const std::string& TensorShapeProto_Dimension::denotation() const {
// @@protoc_insertion_point(field_get:opencv_onnx.TensorShapeProto.Dimension.denotation)
return _internal_denotation();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void TensorShapeProto_Dimension::set_denotation(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000001u;
denotation_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:opencv_onnx.TensorShapeProto.Dimension.denotation)
}
inline std::string* TensorShapeProto_Dimension::mutable_denotation() {
std::string* _s = _internal_mutable_denotation();
// @@protoc_insertion_point(field_mutable:opencv_onnx.TensorShapeProto.Dimension.denotation)
return _s;
}
inline const std::string& TensorShapeProto_Dimension::_internal_denotation() const {
return denotation_.Get();
}
inline void TensorShapeProto_Dimension::_internal_set_denotation(const std::string& value) {
_has_bits_[0] |= 0x00000001u;
denotation_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* TensorShapeProto_Dimension::_internal_mutable_denotation() {
_has_bits_[0] |= 0x00000001u;
return denotation_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* TensorShapeProto_Dimension::release_denotation() {
// @@protoc_insertion_point(field_release:opencv_onnx.TensorShapeProto.Dimension.denotation)
if (!_internal_has_denotation()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000001u;
auto* p = denotation_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (denotation_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
denotation_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void TensorShapeProto_Dimension::set_allocated_denotation(std::string* denotation) {
if (denotation != nullptr) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
denotation_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), denotation,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (denotation_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
denotation_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.TensorShapeProto.Dimension.denotation)
}
inline bool TensorShapeProto_Dimension::has_value() const {
return value_case() != VALUE_NOT_SET;
}
inline void TensorShapeProto_Dimension::clear_has_value() {
_oneof_case_[0] = VALUE_NOT_SET;
}
inline TensorShapeProto_Dimension::ValueCase TensorShapeProto_Dimension::value_case() const {
return TensorShapeProto_Dimension::ValueCase(_oneof_case_[0]);
}
// -------------------------------------------------------------------
// TensorShapeProto
// repeated .opencv_onnx.TensorShapeProto.Dimension dim = 1;
inline int TensorShapeProto::_internal_dim_size() const {
return dim_.size();
}
inline int TensorShapeProto::dim_size() const {
return _internal_dim_size();
}
inline void TensorShapeProto::clear_dim() {
dim_.Clear();
}
inline ::opencv_onnx::TensorShapeProto_Dimension* TensorShapeProto::mutable_dim(int index) {
// @@protoc_insertion_point(field_mutable:opencv_onnx.TensorShapeProto.dim)
return dim_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::TensorShapeProto_Dimension >*
TensorShapeProto::mutable_dim() {
// @@protoc_insertion_point(field_mutable_list:opencv_onnx.TensorShapeProto.dim)
return &dim_;
}
inline const ::opencv_onnx::TensorShapeProto_Dimension& TensorShapeProto::_internal_dim(int index) const {
return dim_.Get(index);
}
inline const ::opencv_onnx::TensorShapeProto_Dimension& TensorShapeProto::dim(int index) const {
// @@protoc_insertion_point(field_get:opencv_onnx.TensorShapeProto.dim)
return _internal_dim(index);
}
inline ::opencv_onnx::TensorShapeProto_Dimension* TensorShapeProto::_internal_add_dim() {
return dim_.Add();
}
inline ::opencv_onnx::TensorShapeProto_Dimension* TensorShapeProto::add_dim() {
::opencv_onnx::TensorShapeProto_Dimension* _add = _internal_add_dim();
// @@protoc_insertion_point(field_add:opencv_onnx.TensorShapeProto.dim)
return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::TensorShapeProto_Dimension >&
TensorShapeProto::dim() const {
// @@protoc_insertion_point(field_list:opencv_onnx.TensorShapeProto.dim)
return dim_;
}
// -------------------------------------------------------------------
// TypeProto_Tensor
// optional int32 elem_type = 1;
inline bool TypeProto_Tensor::_internal_has_elem_type() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool TypeProto_Tensor::has_elem_type() const {
return _internal_has_elem_type();
}
inline void TypeProto_Tensor::clear_elem_type() {
elem_type_ = 0;
_has_bits_[0] &= ~0x00000002u;
}
inline int32_t TypeProto_Tensor::_internal_elem_type() const {
return elem_type_;
}
inline int32_t TypeProto_Tensor::elem_type() const {
// @@protoc_insertion_point(field_get:opencv_onnx.TypeProto.Tensor.elem_type)
return _internal_elem_type();
}
inline void TypeProto_Tensor::_internal_set_elem_type(int32_t value) {
_has_bits_[0] |= 0x00000002u;
elem_type_ = value;
}
inline void TypeProto_Tensor::set_elem_type(int32_t value) {
_internal_set_elem_type(value);
// @@protoc_insertion_point(field_set:opencv_onnx.TypeProto.Tensor.elem_type)
}
// optional .opencv_onnx.TensorShapeProto shape = 2;
inline bool TypeProto_Tensor::_internal_has_shape() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
PROTOBUF_ASSUME(!value || shape_ != nullptr);
return value;
}
inline bool TypeProto_Tensor::has_shape() const {
return _internal_has_shape();
}
inline void TypeProto_Tensor::clear_shape() {
if (shape_ != nullptr) shape_->Clear();
_has_bits_[0] &= ~0x00000001u;
}
inline const ::opencv_onnx::TensorShapeProto& TypeProto_Tensor::_internal_shape() const {
const ::opencv_onnx::TensorShapeProto* p = shape_;
return p != nullptr ? *p : reinterpret_cast<const ::opencv_onnx::TensorShapeProto&>(
::opencv_onnx::_TensorShapeProto_default_instance_);
}
inline const ::opencv_onnx::TensorShapeProto& TypeProto_Tensor::shape() const {
// @@protoc_insertion_point(field_get:opencv_onnx.TypeProto.Tensor.shape)
return _internal_shape();
}
inline void TypeProto_Tensor::unsafe_arena_set_allocated_shape(
::opencv_onnx::TensorShapeProto* shape) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(shape_);
}
shape_ = shape;
if (shape) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_onnx.TypeProto.Tensor.shape)
}
inline ::opencv_onnx::TensorShapeProto* TypeProto_Tensor::release_shape() {
_has_bits_[0] &= ~0x00000001u;
::opencv_onnx::TensorShapeProto* temp = shape_;
shape_ = 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 ::opencv_onnx::TensorShapeProto* TypeProto_Tensor::unsafe_arena_release_shape() {
// @@protoc_insertion_point(field_release:opencv_onnx.TypeProto.Tensor.shape)
_has_bits_[0] &= ~0x00000001u;
::opencv_onnx::TensorShapeProto* temp = shape_;
shape_ = nullptr;
return temp;
}
inline ::opencv_onnx::TensorShapeProto* TypeProto_Tensor::_internal_mutable_shape() {
_has_bits_[0] |= 0x00000001u;
if (shape_ == nullptr) {
auto* p = CreateMaybeMessage<::opencv_onnx::TensorShapeProto>(GetArenaForAllocation());
shape_ = p;
}
return shape_;
}
inline ::opencv_onnx::TensorShapeProto* TypeProto_Tensor::mutable_shape() {
::opencv_onnx::TensorShapeProto* _msg = _internal_mutable_shape();
// @@protoc_insertion_point(field_mutable:opencv_onnx.TypeProto.Tensor.shape)
return _msg;
}
inline void TypeProto_Tensor::set_allocated_shape(::opencv_onnx::TensorShapeProto* shape) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete shape_;
}
if (shape) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_onnx::TensorShapeProto>::GetOwningArena(shape);
if (message_arena != submessage_arena) {
shape = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, shape, submessage_arena);
}
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
shape_ = shape;
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.TypeProto.Tensor.shape)
}
// -------------------------------------------------------------------
// TypeProto_Sequence
// optional .opencv_onnx.TypeProto elem_type = 1;
inline bool TypeProto_Sequence::_internal_has_elem_type() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
PROTOBUF_ASSUME(!value || elem_type_ != nullptr);
return value;
}
inline bool TypeProto_Sequence::has_elem_type() const {
return _internal_has_elem_type();
}
inline void TypeProto_Sequence::clear_elem_type() {
if (elem_type_ != nullptr) elem_type_->Clear();
_has_bits_[0] &= ~0x00000001u;
}
inline const ::opencv_onnx::TypeProto& TypeProto_Sequence::_internal_elem_type() const {
const ::opencv_onnx::TypeProto* p = elem_type_;
return p != nullptr ? *p : reinterpret_cast<const ::opencv_onnx::TypeProto&>(
::opencv_onnx::_TypeProto_default_instance_);
}
inline const ::opencv_onnx::TypeProto& TypeProto_Sequence::elem_type() const {
// @@protoc_insertion_point(field_get:opencv_onnx.TypeProto.Sequence.elem_type)
return _internal_elem_type();
}
inline void TypeProto_Sequence::unsafe_arena_set_allocated_elem_type(
::opencv_onnx::TypeProto* elem_type) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(elem_type_);
}
elem_type_ = elem_type;
if (elem_type) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_onnx.TypeProto.Sequence.elem_type)
}
inline ::opencv_onnx::TypeProto* TypeProto_Sequence::release_elem_type() {
_has_bits_[0] &= ~0x00000001u;
::opencv_onnx::TypeProto* temp = elem_type_;
elem_type_ = 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 ::opencv_onnx::TypeProto* TypeProto_Sequence::unsafe_arena_release_elem_type() {
// @@protoc_insertion_point(field_release:opencv_onnx.TypeProto.Sequence.elem_type)
_has_bits_[0] &= ~0x00000001u;
::opencv_onnx::TypeProto* temp = elem_type_;
elem_type_ = nullptr;
return temp;
}
inline ::opencv_onnx::TypeProto* TypeProto_Sequence::_internal_mutable_elem_type() {
_has_bits_[0] |= 0x00000001u;
if (elem_type_ == nullptr) {
auto* p = CreateMaybeMessage<::opencv_onnx::TypeProto>(GetArenaForAllocation());
elem_type_ = p;
}
return elem_type_;
}
inline ::opencv_onnx::TypeProto* TypeProto_Sequence::mutable_elem_type() {
::opencv_onnx::TypeProto* _msg = _internal_mutable_elem_type();
// @@protoc_insertion_point(field_mutable:opencv_onnx.TypeProto.Sequence.elem_type)
return _msg;
}
inline void TypeProto_Sequence::set_allocated_elem_type(::opencv_onnx::TypeProto* elem_type) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete elem_type_;
}
if (elem_type) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_onnx::TypeProto>::GetOwningArena(elem_type);
if (message_arena != submessage_arena) {
elem_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, elem_type, submessage_arena);
}
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
elem_type_ = elem_type;
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.TypeProto.Sequence.elem_type)
}
// -------------------------------------------------------------------
// TypeProto_Map
// optional int32 key_type = 1;
inline bool TypeProto_Map::_internal_has_key_type() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool TypeProto_Map::has_key_type() const {
return _internal_has_key_type();
}
inline void TypeProto_Map::clear_key_type() {
key_type_ = 0;
_has_bits_[0] &= ~0x00000002u;
}
inline int32_t TypeProto_Map::_internal_key_type() const {
return key_type_;
}
inline int32_t TypeProto_Map::key_type() const {
// @@protoc_insertion_point(field_get:opencv_onnx.TypeProto.Map.key_type)
return _internal_key_type();
}
inline void TypeProto_Map::_internal_set_key_type(int32_t value) {
_has_bits_[0] |= 0x00000002u;
key_type_ = value;
}
inline void TypeProto_Map::set_key_type(int32_t value) {
_internal_set_key_type(value);
// @@protoc_insertion_point(field_set:opencv_onnx.TypeProto.Map.key_type)
}
// optional .opencv_onnx.TypeProto value_type = 2;
inline bool TypeProto_Map::_internal_has_value_type() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
PROTOBUF_ASSUME(!value || value_type_ != nullptr);
return value;
}
inline bool TypeProto_Map::has_value_type() const {
return _internal_has_value_type();
}
inline void TypeProto_Map::clear_value_type() {
if (value_type_ != nullptr) value_type_->Clear();
_has_bits_[0] &= ~0x00000001u;
}
inline const ::opencv_onnx::TypeProto& TypeProto_Map::_internal_value_type() const {
const ::opencv_onnx::TypeProto* p = value_type_;
return p != nullptr ? *p : reinterpret_cast<const ::opencv_onnx::TypeProto&>(
::opencv_onnx::_TypeProto_default_instance_);
}
inline const ::opencv_onnx::TypeProto& TypeProto_Map::value_type() const {
// @@protoc_insertion_point(field_get:opencv_onnx.TypeProto.Map.value_type)
return _internal_value_type();
}
inline void TypeProto_Map::unsafe_arena_set_allocated_value_type(
::opencv_onnx::TypeProto* value_type) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(value_type_);
}
value_type_ = value_type;
if (value_type) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_onnx.TypeProto.Map.value_type)
}
inline ::opencv_onnx::TypeProto* TypeProto_Map::release_value_type() {
_has_bits_[0] &= ~0x00000001u;
::opencv_onnx::TypeProto* temp = value_type_;
value_type_ = 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 ::opencv_onnx::TypeProto* TypeProto_Map::unsafe_arena_release_value_type() {
// @@protoc_insertion_point(field_release:opencv_onnx.TypeProto.Map.value_type)
_has_bits_[0] &= ~0x00000001u;
::opencv_onnx::TypeProto* temp = value_type_;
value_type_ = nullptr;
return temp;
}
inline ::opencv_onnx::TypeProto* TypeProto_Map::_internal_mutable_value_type() {
_has_bits_[0] |= 0x00000001u;
if (value_type_ == nullptr) {
auto* p = CreateMaybeMessage<::opencv_onnx::TypeProto>(GetArenaForAllocation());
value_type_ = p;
}
return value_type_;
}
inline ::opencv_onnx::TypeProto* TypeProto_Map::mutable_value_type() {
::opencv_onnx::TypeProto* _msg = _internal_mutable_value_type();
// @@protoc_insertion_point(field_mutable:opencv_onnx.TypeProto.Map.value_type)
return _msg;
}
inline void TypeProto_Map::set_allocated_value_type(::opencv_onnx::TypeProto* value_type) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete value_type_;
}
if (value_type) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_onnx::TypeProto>::GetOwningArena(value_type);
if (message_arena != submessage_arena) {
value_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, value_type, submessage_arena);
}
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
value_type_ = value_type;
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.TypeProto.Map.value_type)
}
// -------------------------------------------------------------------
// TypeProto_Optional
// optional .opencv_onnx.TypeProto elem_type = 1;
inline bool TypeProto_Optional::_internal_has_elem_type() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
PROTOBUF_ASSUME(!value || elem_type_ != nullptr);
return value;
}
inline bool TypeProto_Optional::has_elem_type() const {
return _internal_has_elem_type();
}
inline void TypeProto_Optional::clear_elem_type() {
if (elem_type_ != nullptr) elem_type_->Clear();
_has_bits_[0] &= ~0x00000001u;
}
inline const ::opencv_onnx::TypeProto& TypeProto_Optional::_internal_elem_type() const {
const ::opencv_onnx::TypeProto* p = elem_type_;
return p != nullptr ? *p : reinterpret_cast<const ::opencv_onnx::TypeProto&>(
::opencv_onnx::_TypeProto_default_instance_);
}
inline const ::opencv_onnx::TypeProto& TypeProto_Optional::elem_type() const {
// @@protoc_insertion_point(field_get:opencv_onnx.TypeProto.Optional.elem_type)
return _internal_elem_type();
}
inline void TypeProto_Optional::unsafe_arena_set_allocated_elem_type(
::opencv_onnx::TypeProto* elem_type) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(elem_type_);
}
elem_type_ = elem_type;
if (elem_type) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_onnx.TypeProto.Optional.elem_type)
}
inline ::opencv_onnx::TypeProto* TypeProto_Optional::release_elem_type() {
_has_bits_[0] &= ~0x00000001u;
::opencv_onnx::TypeProto* temp = elem_type_;
elem_type_ = 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 ::opencv_onnx::TypeProto* TypeProto_Optional::unsafe_arena_release_elem_type() {
// @@protoc_insertion_point(field_release:opencv_onnx.TypeProto.Optional.elem_type)
_has_bits_[0] &= ~0x00000001u;
::opencv_onnx::TypeProto* temp = elem_type_;
elem_type_ = nullptr;
return temp;
}
inline ::opencv_onnx::TypeProto* TypeProto_Optional::_internal_mutable_elem_type() {
_has_bits_[0] |= 0x00000001u;
if (elem_type_ == nullptr) {
auto* p = CreateMaybeMessage<::opencv_onnx::TypeProto>(GetArenaForAllocation());
elem_type_ = p;
}
return elem_type_;
}
inline ::opencv_onnx::TypeProto* TypeProto_Optional::mutable_elem_type() {
::opencv_onnx::TypeProto* _msg = _internal_mutable_elem_type();
// @@protoc_insertion_point(field_mutable:opencv_onnx.TypeProto.Optional.elem_type)
return _msg;
}
inline void TypeProto_Optional::set_allocated_elem_type(::opencv_onnx::TypeProto* elem_type) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete elem_type_;
}
if (elem_type) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_onnx::TypeProto>::GetOwningArena(elem_type);
if (message_arena != submessage_arena) {
elem_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, elem_type, submessage_arena);
}
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
elem_type_ = elem_type;
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.TypeProto.Optional.elem_type)
}
// -------------------------------------------------------------------
// TypeProto_SparseTensor
// optional int32 elem_type = 1;
inline bool TypeProto_SparseTensor::_internal_has_elem_type() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool TypeProto_SparseTensor::has_elem_type() const {
return _internal_has_elem_type();
}
inline void TypeProto_SparseTensor::clear_elem_type() {
elem_type_ = 0;
_has_bits_[0] &= ~0x00000002u;
}
inline int32_t TypeProto_SparseTensor::_internal_elem_type() const {
return elem_type_;
}
inline int32_t TypeProto_SparseTensor::elem_type() const {
// @@protoc_insertion_point(field_get:opencv_onnx.TypeProto.SparseTensor.elem_type)
return _internal_elem_type();
}
inline void TypeProto_SparseTensor::_internal_set_elem_type(int32_t value) {
_has_bits_[0] |= 0x00000002u;
elem_type_ = value;
}
inline void TypeProto_SparseTensor::set_elem_type(int32_t value) {
_internal_set_elem_type(value);
// @@protoc_insertion_point(field_set:opencv_onnx.TypeProto.SparseTensor.elem_type)
}
// optional .opencv_onnx.TensorShapeProto shape = 2;
inline bool TypeProto_SparseTensor::_internal_has_shape() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
PROTOBUF_ASSUME(!value || shape_ != nullptr);
return value;
}
inline bool TypeProto_SparseTensor::has_shape() const {
return _internal_has_shape();
}
inline void TypeProto_SparseTensor::clear_shape() {
if (shape_ != nullptr) shape_->Clear();
_has_bits_[0] &= ~0x00000001u;
}
inline const ::opencv_onnx::TensorShapeProto& TypeProto_SparseTensor::_internal_shape() const {
const ::opencv_onnx::TensorShapeProto* p = shape_;
return p != nullptr ? *p : reinterpret_cast<const ::opencv_onnx::TensorShapeProto&>(
::opencv_onnx::_TensorShapeProto_default_instance_);
}
inline const ::opencv_onnx::TensorShapeProto& TypeProto_SparseTensor::shape() const {
// @@protoc_insertion_point(field_get:opencv_onnx.TypeProto.SparseTensor.shape)
return _internal_shape();
}
inline void TypeProto_SparseTensor::unsafe_arena_set_allocated_shape(
::opencv_onnx::TensorShapeProto* shape) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(shape_);
}
shape_ = shape;
if (shape) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_onnx.TypeProto.SparseTensor.shape)
}
inline ::opencv_onnx::TensorShapeProto* TypeProto_SparseTensor::release_shape() {
_has_bits_[0] &= ~0x00000001u;
::opencv_onnx::TensorShapeProto* temp = shape_;
shape_ = 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 ::opencv_onnx::TensorShapeProto* TypeProto_SparseTensor::unsafe_arena_release_shape() {
// @@protoc_insertion_point(field_release:opencv_onnx.TypeProto.SparseTensor.shape)
_has_bits_[0] &= ~0x00000001u;
::opencv_onnx::TensorShapeProto* temp = shape_;
shape_ = nullptr;
return temp;
}
inline ::opencv_onnx::TensorShapeProto* TypeProto_SparseTensor::_internal_mutable_shape() {
_has_bits_[0] |= 0x00000001u;
if (shape_ == nullptr) {
auto* p = CreateMaybeMessage<::opencv_onnx::TensorShapeProto>(GetArenaForAllocation());
shape_ = p;
}
return shape_;
}
inline ::opencv_onnx::TensorShapeProto* TypeProto_SparseTensor::mutable_shape() {
::opencv_onnx::TensorShapeProto* _msg = _internal_mutable_shape();
// @@protoc_insertion_point(field_mutable:opencv_onnx.TypeProto.SparseTensor.shape)
return _msg;
}
inline void TypeProto_SparseTensor::set_allocated_shape(::opencv_onnx::TensorShapeProto* shape) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete shape_;
}
if (shape) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_onnx::TensorShapeProto>::GetOwningArena(shape);
if (message_arena != submessage_arena) {
shape = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, shape, submessage_arena);
}
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
shape_ = shape;
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.TypeProto.SparseTensor.shape)
}
// -------------------------------------------------------------------
// TypeProto
// .opencv_onnx.TypeProto.Tensor tensor_type = 1;
inline bool TypeProto::_internal_has_tensor_type() const {
return value_case() == kTensorType;
}
inline bool TypeProto::has_tensor_type() const {
return _internal_has_tensor_type();
}
inline void TypeProto::set_has_tensor_type() {
_oneof_case_[0] = kTensorType;
}
inline void TypeProto::clear_tensor_type() {
if (_internal_has_tensor_type()) {
if (GetArenaForAllocation() == nullptr) {
delete value_.tensor_type_;
}
clear_has_value();
}
}
inline ::opencv_onnx::TypeProto_Tensor* TypeProto::release_tensor_type() {
// @@protoc_insertion_point(field_release:opencv_onnx.TypeProto.tensor_type)
if (_internal_has_tensor_type()) {
clear_has_value();
::opencv_onnx::TypeProto_Tensor* temp = value_.tensor_type_;
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
value_.tensor_type_ = nullptr;
return temp;
} else {
return nullptr;
}
}
inline const ::opencv_onnx::TypeProto_Tensor& TypeProto::_internal_tensor_type() const {
return _internal_has_tensor_type()
? *value_.tensor_type_
: reinterpret_cast< ::opencv_onnx::TypeProto_Tensor&>(::opencv_onnx::_TypeProto_Tensor_default_instance_);
}
inline const ::opencv_onnx::TypeProto_Tensor& TypeProto::tensor_type() const {
// @@protoc_insertion_point(field_get:opencv_onnx.TypeProto.tensor_type)
return _internal_tensor_type();
}
inline ::opencv_onnx::TypeProto_Tensor* TypeProto::unsafe_arena_release_tensor_type() {
// @@protoc_insertion_point(field_unsafe_arena_release:opencv_onnx.TypeProto.tensor_type)
if (_internal_has_tensor_type()) {
clear_has_value();
::opencv_onnx::TypeProto_Tensor* temp = value_.tensor_type_;
value_.tensor_type_ = nullptr;
return temp;
} else {
return nullptr;
}
}
inline void TypeProto::unsafe_arena_set_allocated_tensor_type(::opencv_onnx::TypeProto_Tensor* tensor_type) {
clear_value();
if (tensor_type) {
set_has_tensor_type();
value_.tensor_type_ = tensor_type;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_onnx.TypeProto.tensor_type)
}
inline ::opencv_onnx::TypeProto_Tensor* TypeProto::_internal_mutable_tensor_type() {
if (!_internal_has_tensor_type()) {
clear_value();
set_has_tensor_type();
value_.tensor_type_ = CreateMaybeMessage< ::opencv_onnx::TypeProto_Tensor >(GetArenaForAllocation());
}
return value_.tensor_type_;
}
inline ::opencv_onnx::TypeProto_Tensor* TypeProto::mutable_tensor_type() {
::opencv_onnx::TypeProto_Tensor* _msg = _internal_mutable_tensor_type();
// @@protoc_insertion_point(field_mutable:opencv_onnx.TypeProto.tensor_type)
return _msg;
}
// .opencv_onnx.TypeProto.Sequence sequence_type = 4;
inline bool TypeProto::_internal_has_sequence_type() const {
return value_case() == kSequenceType;
}
inline bool TypeProto::has_sequence_type() const {
return _internal_has_sequence_type();
}
inline void TypeProto::set_has_sequence_type() {
_oneof_case_[0] = kSequenceType;
}
inline void TypeProto::clear_sequence_type() {
if (_internal_has_sequence_type()) {
if (GetArenaForAllocation() == nullptr) {
delete value_.sequence_type_;
}
clear_has_value();
}
}
inline ::opencv_onnx::TypeProto_Sequence* TypeProto::release_sequence_type() {
// @@protoc_insertion_point(field_release:opencv_onnx.TypeProto.sequence_type)
if (_internal_has_sequence_type()) {
clear_has_value();
::opencv_onnx::TypeProto_Sequence* temp = value_.sequence_type_;
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
value_.sequence_type_ = nullptr;
return temp;
} else {
return nullptr;
}
}
inline const ::opencv_onnx::TypeProto_Sequence& TypeProto::_internal_sequence_type() const {
return _internal_has_sequence_type()
? *value_.sequence_type_
: reinterpret_cast< ::opencv_onnx::TypeProto_Sequence&>(::opencv_onnx::_TypeProto_Sequence_default_instance_);
}
inline const ::opencv_onnx::TypeProto_Sequence& TypeProto::sequence_type() const {
// @@protoc_insertion_point(field_get:opencv_onnx.TypeProto.sequence_type)
return _internal_sequence_type();
}
inline ::opencv_onnx::TypeProto_Sequence* TypeProto::unsafe_arena_release_sequence_type() {
// @@protoc_insertion_point(field_unsafe_arena_release:opencv_onnx.TypeProto.sequence_type)
if (_internal_has_sequence_type()) {
clear_has_value();
::opencv_onnx::TypeProto_Sequence* temp = value_.sequence_type_;
value_.sequence_type_ = nullptr;
return temp;
} else {
return nullptr;
}
}
inline void TypeProto::unsafe_arena_set_allocated_sequence_type(::opencv_onnx::TypeProto_Sequence* sequence_type) {
clear_value();
if (sequence_type) {
set_has_sequence_type();
value_.sequence_type_ = sequence_type;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_onnx.TypeProto.sequence_type)
}
inline ::opencv_onnx::TypeProto_Sequence* TypeProto::_internal_mutable_sequence_type() {
if (!_internal_has_sequence_type()) {
clear_value();
set_has_sequence_type();
value_.sequence_type_ = CreateMaybeMessage< ::opencv_onnx::TypeProto_Sequence >(GetArenaForAllocation());
}
return value_.sequence_type_;
}
inline ::opencv_onnx::TypeProto_Sequence* TypeProto::mutable_sequence_type() {
::opencv_onnx::TypeProto_Sequence* _msg = _internal_mutable_sequence_type();
// @@protoc_insertion_point(field_mutable:opencv_onnx.TypeProto.sequence_type)
return _msg;
}
// .opencv_onnx.TypeProto.Map map_type = 5;
inline bool TypeProto::_internal_has_map_type() const {
return value_case() == kMapType;
}
inline bool TypeProto::has_map_type() const {
return _internal_has_map_type();
}
inline void TypeProto::set_has_map_type() {
_oneof_case_[0] = kMapType;
}
inline void TypeProto::clear_map_type() {
if (_internal_has_map_type()) {
if (GetArenaForAllocation() == nullptr) {
delete value_.map_type_;
}
clear_has_value();
}
}
inline ::opencv_onnx::TypeProto_Map* TypeProto::release_map_type() {
// @@protoc_insertion_point(field_release:opencv_onnx.TypeProto.map_type)
if (_internal_has_map_type()) {
clear_has_value();
::opencv_onnx::TypeProto_Map* temp = value_.map_type_;
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
value_.map_type_ = nullptr;
return temp;
} else {
return nullptr;
}
}
inline const ::opencv_onnx::TypeProto_Map& TypeProto::_internal_map_type() const {
return _internal_has_map_type()
? *value_.map_type_
: reinterpret_cast< ::opencv_onnx::TypeProto_Map&>(::opencv_onnx::_TypeProto_Map_default_instance_);
}
inline const ::opencv_onnx::TypeProto_Map& TypeProto::map_type() const {
// @@protoc_insertion_point(field_get:opencv_onnx.TypeProto.map_type)
return _internal_map_type();
}
inline ::opencv_onnx::TypeProto_Map* TypeProto::unsafe_arena_release_map_type() {
// @@protoc_insertion_point(field_unsafe_arena_release:opencv_onnx.TypeProto.map_type)
if (_internal_has_map_type()) {
clear_has_value();
::opencv_onnx::TypeProto_Map* temp = value_.map_type_;
value_.map_type_ = nullptr;
return temp;
} else {
return nullptr;
}
}
inline void TypeProto::unsafe_arena_set_allocated_map_type(::opencv_onnx::TypeProto_Map* map_type) {
clear_value();
if (map_type) {
set_has_map_type();
value_.map_type_ = map_type;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_onnx.TypeProto.map_type)
}
inline ::opencv_onnx::TypeProto_Map* TypeProto::_internal_mutable_map_type() {
if (!_internal_has_map_type()) {
clear_value();
set_has_map_type();
value_.map_type_ = CreateMaybeMessage< ::opencv_onnx::TypeProto_Map >(GetArenaForAllocation());
}
return value_.map_type_;
}
inline ::opencv_onnx::TypeProto_Map* TypeProto::mutable_map_type() {
::opencv_onnx::TypeProto_Map* _msg = _internal_mutable_map_type();
// @@protoc_insertion_point(field_mutable:opencv_onnx.TypeProto.map_type)
return _msg;
}
// .opencv_onnx.TypeProto.Optional optional_type = 9;
inline bool TypeProto::_internal_has_optional_type() const {
return value_case() == kOptionalType;
}
inline bool TypeProto::has_optional_type() const {
return _internal_has_optional_type();
}
inline void TypeProto::set_has_optional_type() {
_oneof_case_[0] = kOptionalType;
}
inline void TypeProto::clear_optional_type() {
if (_internal_has_optional_type()) {
if (GetArenaForAllocation() == nullptr) {
delete value_.optional_type_;
}
clear_has_value();
}
}
inline ::opencv_onnx::TypeProto_Optional* TypeProto::release_optional_type() {
// @@protoc_insertion_point(field_release:opencv_onnx.TypeProto.optional_type)
if (_internal_has_optional_type()) {
clear_has_value();
::opencv_onnx::TypeProto_Optional* temp = value_.optional_type_;
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
value_.optional_type_ = nullptr;
return temp;
} else {
return nullptr;
}
}
inline const ::opencv_onnx::TypeProto_Optional& TypeProto::_internal_optional_type() const {
return _internal_has_optional_type()
? *value_.optional_type_
: reinterpret_cast< ::opencv_onnx::TypeProto_Optional&>(::opencv_onnx::_TypeProto_Optional_default_instance_);
}
inline const ::opencv_onnx::TypeProto_Optional& TypeProto::optional_type() const {
// @@protoc_insertion_point(field_get:opencv_onnx.TypeProto.optional_type)
return _internal_optional_type();
}
inline ::opencv_onnx::TypeProto_Optional* TypeProto::unsafe_arena_release_optional_type() {
// @@protoc_insertion_point(field_unsafe_arena_release:opencv_onnx.TypeProto.optional_type)
if (_internal_has_optional_type()) {
clear_has_value();
::opencv_onnx::TypeProto_Optional* temp = value_.optional_type_;
value_.optional_type_ = nullptr;
return temp;
} else {
return nullptr;
}
}
inline void TypeProto::unsafe_arena_set_allocated_optional_type(::opencv_onnx::TypeProto_Optional* optional_type) {
clear_value();
if (optional_type) {
set_has_optional_type();
value_.optional_type_ = optional_type;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_onnx.TypeProto.optional_type)
}
inline ::opencv_onnx::TypeProto_Optional* TypeProto::_internal_mutable_optional_type() {
if (!_internal_has_optional_type()) {
clear_value();
set_has_optional_type();
value_.optional_type_ = CreateMaybeMessage< ::opencv_onnx::TypeProto_Optional >(GetArenaForAllocation());
}
return value_.optional_type_;
}
inline ::opencv_onnx::TypeProto_Optional* TypeProto::mutable_optional_type() {
::opencv_onnx::TypeProto_Optional* _msg = _internal_mutable_optional_type();
// @@protoc_insertion_point(field_mutable:opencv_onnx.TypeProto.optional_type)
return _msg;
}
// .opencv_onnx.TypeProto.SparseTensor sparse_tensor_type = 8;
inline bool TypeProto::_internal_has_sparse_tensor_type() const {
return value_case() == kSparseTensorType;
}
inline bool TypeProto::has_sparse_tensor_type() const {
return _internal_has_sparse_tensor_type();
}
inline void TypeProto::set_has_sparse_tensor_type() {
_oneof_case_[0] = kSparseTensorType;
}
inline void TypeProto::clear_sparse_tensor_type() {
if (_internal_has_sparse_tensor_type()) {
if (GetArenaForAllocation() == nullptr) {
delete value_.sparse_tensor_type_;
}
clear_has_value();
}
}
inline ::opencv_onnx::TypeProto_SparseTensor* TypeProto::release_sparse_tensor_type() {
// @@protoc_insertion_point(field_release:opencv_onnx.TypeProto.sparse_tensor_type)
if (_internal_has_sparse_tensor_type()) {
clear_has_value();
::opencv_onnx::TypeProto_SparseTensor* temp = value_.sparse_tensor_type_;
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
value_.sparse_tensor_type_ = nullptr;
return temp;
} else {
return nullptr;
}
}
inline const ::opencv_onnx::TypeProto_SparseTensor& TypeProto::_internal_sparse_tensor_type() const {
return _internal_has_sparse_tensor_type()
? *value_.sparse_tensor_type_
: reinterpret_cast< ::opencv_onnx::TypeProto_SparseTensor&>(::opencv_onnx::_TypeProto_SparseTensor_default_instance_);
}
inline const ::opencv_onnx::TypeProto_SparseTensor& TypeProto::sparse_tensor_type() const {
// @@protoc_insertion_point(field_get:opencv_onnx.TypeProto.sparse_tensor_type)
return _internal_sparse_tensor_type();
}
inline ::opencv_onnx::TypeProto_SparseTensor* TypeProto::unsafe_arena_release_sparse_tensor_type() {
// @@protoc_insertion_point(field_unsafe_arena_release:opencv_onnx.TypeProto.sparse_tensor_type)
if (_internal_has_sparse_tensor_type()) {
clear_has_value();
::opencv_onnx::TypeProto_SparseTensor* temp = value_.sparse_tensor_type_;
value_.sparse_tensor_type_ = nullptr;
return temp;
} else {
return nullptr;
}
}
inline void TypeProto::unsafe_arena_set_allocated_sparse_tensor_type(::opencv_onnx::TypeProto_SparseTensor* sparse_tensor_type) {
clear_value();
if (sparse_tensor_type) {
set_has_sparse_tensor_type();
value_.sparse_tensor_type_ = sparse_tensor_type;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_onnx.TypeProto.sparse_tensor_type)
}
inline ::opencv_onnx::TypeProto_SparseTensor* TypeProto::_internal_mutable_sparse_tensor_type() {
if (!_internal_has_sparse_tensor_type()) {
clear_value();
set_has_sparse_tensor_type();
value_.sparse_tensor_type_ = CreateMaybeMessage< ::opencv_onnx::TypeProto_SparseTensor >(GetArenaForAllocation());
}
return value_.sparse_tensor_type_;
}
inline ::opencv_onnx::TypeProto_SparseTensor* TypeProto::mutable_sparse_tensor_type() {
::opencv_onnx::TypeProto_SparseTensor* _msg = _internal_mutable_sparse_tensor_type();
// @@protoc_insertion_point(field_mutable:opencv_onnx.TypeProto.sparse_tensor_type)
return _msg;
}
// optional string denotation = 6;
inline bool TypeProto::_internal_has_denotation() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool TypeProto::has_denotation() const {
return _internal_has_denotation();
}
inline void TypeProto::clear_denotation() {
denotation_.ClearToEmpty();
_has_bits_[0] &= ~0x00000001u;
}
inline const std::string& TypeProto::denotation() const {
// @@protoc_insertion_point(field_get:opencv_onnx.TypeProto.denotation)
return _internal_denotation();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void TypeProto::set_denotation(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000001u;
denotation_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:opencv_onnx.TypeProto.denotation)
}
inline std::string* TypeProto::mutable_denotation() {
std::string* _s = _internal_mutable_denotation();
// @@protoc_insertion_point(field_mutable:opencv_onnx.TypeProto.denotation)
return _s;
}
inline const std::string& TypeProto::_internal_denotation() const {
return denotation_.Get();
}
inline void TypeProto::_internal_set_denotation(const std::string& value) {
_has_bits_[0] |= 0x00000001u;
denotation_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* TypeProto::_internal_mutable_denotation() {
_has_bits_[0] |= 0x00000001u;
return denotation_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* TypeProto::release_denotation() {
// @@protoc_insertion_point(field_release:opencv_onnx.TypeProto.denotation)
if (!_internal_has_denotation()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000001u;
auto* p = denotation_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (denotation_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
denotation_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void TypeProto::set_allocated_denotation(std::string* denotation) {
if (denotation != nullptr) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
denotation_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), denotation,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (denotation_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
denotation_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.TypeProto.denotation)
}
inline bool TypeProto::has_value() const {
return value_case() != VALUE_NOT_SET;
}
inline void TypeProto::clear_has_value() {
_oneof_case_[0] = VALUE_NOT_SET;
}
inline TypeProto::ValueCase TypeProto::value_case() const {
return TypeProto::ValueCase(_oneof_case_[0]);
}
// -------------------------------------------------------------------
// OperatorSetIdProto
// optional string domain = 1;
inline bool OperatorSetIdProto::_internal_has_domain() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool OperatorSetIdProto::has_domain() const {
return _internal_has_domain();
}
inline void OperatorSetIdProto::clear_domain() {
domain_.ClearToEmpty();
_has_bits_[0] &= ~0x00000001u;
}
inline const std::string& OperatorSetIdProto::domain() const {
// @@protoc_insertion_point(field_get:opencv_onnx.OperatorSetIdProto.domain)
return _internal_domain();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void OperatorSetIdProto::set_domain(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000001u;
domain_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:opencv_onnx.OperatorSetIdProto.domain)
}
inline std::string* OperatorSetIdProto::mutable_domain() {
std::string* _s = _internal_mutable_domain();
// @@protoc_insertion_point(field_mutable:opencv_onnx.OperatorSetIdProto.domain)
return _s;
}
inline const std::string& OperatorSetIdProto::_internal_domain() const {
return domain_.Get();
}
inline void OperatorSetIdProto::_internal_set_domain(const std::string& value) {
_has_bits_[0] |= 0x00000001u;
domain_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* OperatorSetIdProto::_internal_mutable_domain() {
_has_bits_[0] |= 0x00000001u;
return domain_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* OperatorSetIdProto::release_domain() {
// @@protoc_insertion_point(field_release:opencv_onnx.OperatorSetIdProto.domain)
if (!_internal_has_domain()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000001u;
auto* p = domain_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (domain_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
domain_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void OperatorSetIdProto::set_allocated_domain(std::string* domain) {
if (domain != nullptr) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
domain_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), domain,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (domain_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
domain_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.OperatorSetIdProto.domain)
}
// optional int64 version = 2;
inline bool OperatorSetIdProto::_internal_has_version() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool OperatorSetIdProto::has_version() const {
return _internal_has_version();
}
inline void OperatorSetIdProto::clear_version() {
version_ = int64_t{0};
_has_bits_[0] &= ~0x00000002u;
}
inline int64_t OperatorSetIdProto::_internal_version() const {
return version_;
}
inline int64_t OperatorSetIdProto::version() const {
// @@protoc_insertion_point(field_get:opencv_onnx.OperatorSetIdProto.version)
return _internal_version();
}
inline void OperatorSetIdProto::_internal_set_version(int64_t value) {
_has_bits_[0] |= 0x00000002u;
version_ = value;
}
inline void OperatorSetIdProto::set_version(int64_t value) {
_internal_set_version(value);
// @@protoc_insertion_point(field_set:opencv_onnx.OperatorSetIdProto.version)
}
// -------------------------------------------------------------------
// FunctionProto
// optional string name = 1;
inline bool FunctionProto::_internal_has_name() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool FunctionProto::has_name() const {
return _internal_has_name();
}
inline void FunctionProto::clear_name() {
name_.ClearToEmpty();
_has_bits_[0] &= ~0x00000001u;
}
inline const std::string& FunctionProto::name() const {
// @@protoc_insertion_point(field_get:opencv_onnx.FunctionProto.name)
return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void FunctionProto::set_name(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000001u;
name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:opencv_onnx.FunctionProto.name)
}
inline std::string* FunctionProto::mutable_name() {
std::string* _s = _internal_mutable_name();
// @@protoc_insertion_point(field_mutable:opencv_onnx.FunctionProto.name)
return _s;
}
inline const std::string& FunctionProto::_internal_name() const {
return name_.Get();
}
inline void FunctionProto::_internal_set_name(const std::string& value) {
_has_bits_[0] |= 0x00000001u;
name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* FunctionProto::_internal_mutable_name() {
_has_bits_[0] |= 0x00000001u;
return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* FunctionProto::release_name() {
// @@protoc_insertion_point(field_release:opencv_onnx.FunctionProto.name)
if (!_internal_has_name()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000001u;
auto* p = name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void FunctionProto::set_allocated_name(std::string* name) {
if (name != nullptr) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.FunctionProto.name)
}
// repeated string input = 4;
inline int FunctionProto::_internal_input_size() const {
return input_.size();
}
inline int FunctionProto::input_size() const {
return _internal_input_size();
}
inline void FunctionProto::clear_input() {
input_.Clear();
}
inline std::string* FunctionProto::add_input() {
std::string* _s = _internal_add_input();
// @@protoc_insertion_point(field_add_mutable:opencv_onnx.FunctionProto.input)
return _s;
}
inline const std::string& FunctionProto::_internal_input(int index) const {
return input_.Get(index);
}
inline const std::string& FunctionProto::input(int index) const {
// @@protoc_insertion_point(field_get:opencv_onnx.FunctionProto.input)
return _internal_input(index);
}
inline std::string* FunctionProto::mutable_input(int index) {
// @@protoc_insertion_point(field_mutable:opencv_onnx.FunctionProto.input)
return input_.Mutable(index);
}
inline void FunctionProto::set_input(int index, const std::string& value) {
input_.Mutable(index)->assign(value);
// @@protoc_insertion_point(field_set:opencv_onnx.FunctionProto.input)
}
inline void FunctionProto::set_input(int index, std::string&& value) {
input_.Mutable(index)->assign(std::move(value));
// @@protoc_insertion_point(field_set:opencv_onnx.FunctionProto.input)
}
inline void FunctionProto::set_input(int index, const char* value) {
GOOGLE_DCHECK(value != nullptr);
input_.Mutable(index)->assign(value);
// @@protoc_insertion_point(field_set_char:opencv_onnx.FunctionProto.input)
}
inline void FunctionProto::set_input(int index, const char* value, size_t size) {
input_.Mutable(index)->assign(
reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_set_pointer:opencv_onnx.FunctionProto.input)
}
inline std::string* FunctionProto::_internal_add_input() {
return input_.Add();
}
inline void FunctionProto::add_input(const std::string& value) {
input_.Add()->assign(value);
// @@protoc_insertion_point(field_add:opencv_onnx.FunctionProto.input)
}
inline void FunctionProto::add_input(std::string&& value) {
input_.Add(std::move(value));
// @@protoc_insertion_point(field_add:opencv_onnx.FunctionProto.input)
}
inline void FunctionProto::add_input(const char* value) {
GOOGLE_DCHECK(value != nullptr);
input_.Add()->assign(value);
// @@protoc_insertion_point(field_add_char:opencv_onnx.FunctionProto.input)
}
inline void FunctionProto::add_input(const char* value, size_t size) {
input_.Add()->assign(reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_add_pointer:opencv_onnx.FunctionProto.input)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
FunctionProto::input() const {
// @@protoc_insertion_point(field_list:opencv_onnx.FunctionProto.input)
return input_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
FunctionProto::mutable_input() {
// @@protoc_insertion_point(field_mutable_list:opencv_onnx.FunctionProto.input)
return &input_;
}
// repeated string output = 5;
inline int FunctionProto::_internal_output_size() const {
return output_.size();
}
inline int FunctionProto::output_size() const {
return _internal_output_size();
}
inline void FunctionProto::clear_output() {
output_.Clear();
}
inline std::string* FunctionProto::add_output() {
std::string* _s = _internal_add_output();
// @@protoc_insertion_point(field_add_mutable:opencv_onnx.FunctionProto.output)
return _s;
}
inline const std::string& FunctionProto::_internal_output(int index) const {
return output_.Get(index);
}
inline const std::string& FunctionProto::output(int index) const {
// @@protoc_insertion_point(field_get:opencv_onnx.FunctionProto.output)
return _internal_output(index);
}
inline std::string* FunctionProto::mutable_output(int index) {
// @@protoc_insertion_point(field_mutable:opencv_onnx.FunctionProto.output)
return output_.Mutable(index);
}
inline void FunctionProto::set_output(int index, const std::string& value) {
output_.Mutable(index)->assign(value);
// @@protoc_insertion_point(field_set:opencv_onnx.FunctionProto.output)
}
inline void FunctionProto::set_output(int index, std::string&& value) {
output_.Mutable(index)->assign(std::move(value));
// @@protoc_insertion_point(field_set:opencv_onnx.FunctionProto.output)
}
inline void FunctionProto::set_output(int index, const char* value) {
GOOGLE_DCHECK(value != nullptr);
output_.Mutable(index)->assign(value);
// @@protoc_insertion_point(field_set_char:opencv_onnx.FunctionProto.output)
}
inline void FunctionProto::set_output(int index, const char* value, size_t size) {
output_.Mutable(index)->assign(
reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_set_pointer:opencv_onnx.FunctionProto.output)
}
inline std::string* FunctionProto::_internal_add_output() {
return output_.Add();
}
inline void FunctionProto::add_output(const std::string& value) {
output_.Add()->assign(value);
// @@protoc_insertion_point(field_add:opencv_onnx.FunctionProto.output)
}
inline void FunctionProto::add_output(std::string&& value) {
output_.Add(std::move(value));
// @@protoc_insertion_point(field_add:opencv_onnx.FunctionProto.output)
}
inline void FunctionProto::add_output(const char* value) {
GOOGLE_DCHECK(value != nullptr);
output_.Add()->assign(value);
// @@protoc_insertion_point(field_add_char:opencv_onnx.FunctionProto.output)
}
inline void FunctionProto::add_output(const char* value, size_t size) {
output_.Add()->assign(reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_add_pointer:opencv_onnx.FunctionProto.output)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
FunctionProto::output() const {
// @@protoc_insertion_point(field_list:opencv_onnx.FunctionProto.output)
return output_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
FunctionProto::mutable_output() {
// @@protoc_insertion_point(field_mutable_list:opencv_onnx.FunctionProto.output)
return &output_;
}
// repeated string attribute = 6;
inline int FunctionProto::_internal_attribute_size() const {
return attribute_.size();
}
inline int FunctionProto::attribute_size() const {
return _internal_attribute_size();
}
inline void FunctionProto::clear_attribute() {
attribute_.Clear();
}
inline std::string* FunctionProto::add_attribute() {
std::string* _s = _internal_add_attribute();
// @@protoc_insertion_point(field_add_mutable:opencv_onnx.FunctionProto.attribute)
return _s;
}
inline const std::string& FunctionProto::_internal_attribute(int index) const {
return attribute_.Get(index);
}
inline const std::string& FunctionProto::attribute(int index) const {
// @@protoc_insertion_point(field_get:opencv_onnx.FunctionProto.attribute)
return _internal_attribute(index);
}
inline std::string* FunctionProto::mutable_attribute(int index) {
// @@protoc_insertion_point(field_mutable:opencv_onnx.FunctionProto.attribute)
return attribute_.Mutable(index);
}
inline void FunctionProto::set_attribute(int index, const std::string& value) {
attribute_.Mutable(index)->assign(value);
// @@protoc_insertion_point(field_set:opencv_onnx.FunctionProto.attribute)
}
inline void FunctionProto::set_attribute(int index, std::string&& value) {
attribute_.Mutable(index)->assign(std::move(value));
// @@protoc_insertion_point(field_set:opencv_onnx.FunctionProto.attribute)
}
inline void FunctionProto::set_attribute(int index, const char* value) {
GOOGLE_DCHECK(value != nullptr);
attribute_.Mutable(index)->assign(value);
// @@protoc_insertion_point(field_set_char:opencv_onnx.FunctionProto.attribute)
}
inline void FunctionProto::set_attribute(int index, const char* value, size_t size) {
attribute_.Mutable(index)->assign(
reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_set_pointer:opencv_onnx.FunctionProto.attribute)
}
inline std::string* FunctionProto::_internal_add_attribute() {
return attribute_.Add();
}
inline void FunctionProto::add_attribute(const std::string& value) {
attribute_.Add()->assign(value);
// @@protoc_insertion_point(field_add:opencv_onnx.FunctionProto.attribute)
}
inline void FunctionProto::add_attribute(std::string&& value) {
attribute_.Add(std::move(value));
// @@protoc_insertion_point(field_add:opencv_onnx.FunctionProto.attribute)
}
inline void FunctionProto::add_attribute(const char* value) {
GOOGLE_DCHECK(value != nullptr);
attribute_.Add()->assign(value);
// @@protoc_insertion_point(field_add_char:opencv_onnx.FunctionProto.attribute)
}
inline void FunctionProto::add_attribute(const char* value, size_t size) {
attribute_.Add()->assign(reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_add_pointer:opencv_onnx.FunctionProto.attribute)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
FunctionProto::attribute() const {
// @@protoc_insertion_point(field_list:opencv_onnx.FunctionProto.attribute)
return attribute_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
FunctionProto::mutable_attribute() {
// @@protoc_insertion_point(field_mutable_list:opencv_onnx.FunctionProto.attribute)
return &attribute_;
}
// repeated .opencv_onnx.AttributeProto attribute_proto = 11;
inline int FunctionProto::_internal_attribute_proto_size() const {
return attribute_proto_.size();
}
inline int FunctionProto::attribute_proto_size() const {
return _internal_attribute_proto_size();
}
inline void FunctionProto::clear_attribute_proto() {
attribute_proto_.Clear();
}
inline ::opencv_onnx::AttributeProto* FunctionProto::mutable_attribute_proto(int index) {
// @@protoc_insertion_point(field_mutable:opencv_onnx.FunctionProto.attribute_proto)
return attribute_proto_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::AttributeProto >*
FunctionProto::mutable_attribute_proto() {
// @@protoc_insertion_point(field_mutable_list:opencv_onnx.FunctionProto.attribute_proto)
return &attribute_proto_;
}
inline const ::opencv_onnx::AttributeProto& FunctionProto::_internal_attribute_proto(int index) const {
return attribute_proto_.Get(index);
}
inline const ::opencv_onnx::AttributeProto& FunctionProto::attribute_proto(int index) const {
// @@protoc_insertion_point(field_get:opencv_onnx.FunctionProto.attribute_proto)
return _internal_attribute_proto(index);
}
inline ::opencv_onnx::AttributeProto* FunctionProto::_internal_add_attribute_proto() {
return attribute_proto_.Add();
}
inline ::opencv_onnx::AttributeProto* FunctionProto::add_attribute_proto() {
::opencv_onnx::AttributeProto* _add = _internal_add_attribute_proto();
// @@protoc_insertion_point(field_add:opencv_onnx.FunctionProto.attribute_proto)
return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::AttributeProto >&
FunctionProto::attribute_proto() const {
// @@protoc_insertion_point(field_list:opencv_onnx.FunctionProto.attribute_proto)
return attribute_proto_;
}
// repeated .opencv_onnx.NodeProto node = 7;
inline int FunctionProto::_internal_node_size() const {
return node_.size();
}
inline int FunctionProto::node_size() const {
return _internal_node_size();
}
inline void FunctionProto::clear_node() {
node_.Clear();
}
inline ::opencv_onnx::NodeProto* FunctionProto::mutable_node(int index) {
// @@protoc_insertion_point(field_mutable:opencv_onnx.FunctionProto.node)
return node_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::NodeProto >*
FunctionProto::mutable_node() {
// @@protoc_insertion_point(field_mutable_list:opencv_onnx.FunctionProto.node)
return &node_;
}
inline const ::opencv_onnx::NodeProto& FunctionProto::_internal_node(int index) const {
return node_.Get(index);
}
inline const ::opencv_onnx::NodeProto& FunctionProto::node(int index) const {
// @@protoc_insertion_point(field_get:opencv_onnx.FunctionProto.node)
return _internal_node(index);
}
inline ::opencv_onnx::NodeProto* FunctionProto::_internal_add_node() {
return node_.Add();
}
inline ::opencv_onnx::NodeProto* FunctionProto::add_node() {
::opencv_onnx::NodeProto* _add = _internal_add_node();
// @@protoc_insertion_point(field_add:opencv_onnx.FunctionProto.node)
return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::NodeProto >&
FunctionProto::node() const {
// @@protoc_insertion_point(field_list:opencv_onnx.FunctionProto.node)
return node_;
}
// optional string doc_string = 8;
inline bool FunctionProto::_internal_has_doc_string() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool FunctionProto::has_doc_string() const {
return _internal_has_doc_string();
}
inline void FunctionProto::clear_doc_string() {
doc_string_.ClearToEmpty();
_has_bits_[0] &= ~0x00000002u;
}
inline const std::string& FunctionProto::doc_string() const {
// @@protoc_insertion_point(field_get:opencv_onnx.FunctionProto.doc_string)
return _internal_doc_string();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void FunctionProto::set_doc_string(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000002u;
doc_string_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:opencv_onnx.FunctionProto.doc_string)
}
inline std::string* FunctionProto::mutable_doc_string() {
std::string* _s = _internal_mutable_doc_string();
// @@protoc_insertion_point(field_mutable:opencv_onnx.FunctionProto.doc_string)
return _s;
}
inline const std::string& FunctionProto::_internal_doc_string() const {
return doc_string_.Get();
}
inline void FunctionProto::_internal_set_doc_string(const std::string& value) {
_has_bits_[0] |= 0x00000002u;
doc_string_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* FunctionProto::_internal_mutable_doc_string() {
_has_bits_[0] |= 0x00000002u;
return doc_string_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* FunctionProto::release_doc_string() {
// @@protoc_insertion_point(field_release:opencv_onnx.FunctionProto.doc_string)
if (!_internal_has_doc_string()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000002u;
auto* p = doc_string_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (doc_string_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
doc_string_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void FunctionProto::set_allocated_doc_string(std::string* doc_string) {
if (doc_string != nullptr) {
_has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
}
doc_string_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), doc_string,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (doc_string_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
doc_string_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.FunctionProto.doc_string)
}
// repeated .opencv_onnx.OperatorSetIdProto opset_import = 9;
inline int FunctionProto::_internal_opset_import_size() const {
return opset_import_.size();
}
inline int FunctionProto::opset_import_size() const {
return _internal_opset_import_size();
}
inline void FunctionProto::clear_opset_import() {
opset_import_.Clear();
}
inline ::opencv_onnx::OperatorSetIdProto* FunctionProto::mutable_opset_import(int index) {
// @@protoc_insertion_point(field_mutable:opencv_onnx.FunctionProto.opset_import)
return opset_import_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::OperatorSetIdProto >*
FunctionProto::mutable_opset_import() {
// @@protoc_insertion_point(field_mutable_list:opencv_onnx.FunctionProto.opset_import)
return &opset_import_;
}
inline const ::opencv_onnx::OperatorSetIdProto& FunctionProto::_internal_opset_import(int index) const {
return opset_import_.Get(index);
}
inline const ::opencv_onnx::OperatorSetIdProto& FunctionProto::opset_import(int index) const {
// @@protoc_insertion_point(field_get:opencv_onnx.FunctionProto.opset_import)
return _internal_opset_import(index);
}
inline ::opencv_onnx::OperatorSetIdProto* FunctionProto::_internal_add_opset_import() {
return opset_import_.Add();
}
inline ::opencv_onnx::OperatorSetIdProto* FunctionProto::add_opset_import() {
::opencv_onnx::OperatorSetIdProto* _add = _internal_add_opset_import();
// @@protoc_insertion_point(field_add:opencv_onnx.FunctionProto.opset_import)
return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::OperatorSetIdProto >&
FunctionProto::opset_import() const {
// @@protoc_insertion_point(field_list:opencv_onnx.FunctionProto.opset_import)
return opset_import_;
}
// optional string domain = 10;
inline bool FunctionProto::_internal_has_domain() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool FunctionProto::has_domain() const {
return _internal_has_domain();
}
inline void FunctionProto::clear_domain() {
domain_.ClearToEmpty();
_has_bits_[0] &= ~0x00000004u;
}
inline const std::string& FunctionProto::domain() const {
// @@protoc_insertion_point(field_get:opencv_onnx.FunctionProto.domain)
return _internal_domain();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void FunctionProto::set_domain(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000004u;
domain_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:opencv_onnx.FunctionProto.domain)
}
inline std::string* FunctionProto::mutable_domain() {
std::string* _s = _internal_mutable_domain();
// @@protoc_insertion_point(field_mutable:opencv_onnx.FunctionProto.domain)
return _s;
}
inline const std::string& FunctionProto::_internal_domain() const {
return domain_.Get();
}
inline void FunctionProto::_internal_set_domain(const std::string& value) {
_has_bits_[0] |= 0x00000004u;
domain_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* FunctionProto::_internal_mutable_domain() {
_has_bits_[0] |= 0x00000004u;
return domain_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* FunctionProto::release_domain() {
// @@protoc_insertion_point(field_release:opencv_onnx.FunctionProto.domain)
if (!_internal_has_domain()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000004u;
auto* p = domain_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (domain_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
domain_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void FunctionProto::set_allocated_domain(std::string* domain) {
if (domain != nullptr) {
_has_bits_[0] |= 0x00000004u;
} else {
_has_bits_[0] &= ~0x00000004u;
}
domain_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), domain,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (domain_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
domain_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.FunctionProto.domain)
}
// optional string overload = 13;
inline bool FunctionProto::_internal_has_overload() const {
bool value = (_has_bits_[0] & 0x00000008u) != 0;
return value;
}
inline bool FunctionProto::has_overload() const {
return _internal_has_overload();
}
inline void FunctionProto::clear_overload() {
overload_.ClearToEmpty();
_has_bits_[0] &= ~0x00000008u;
}
inline const std::string& FunctionProto::overload() const {
// @@protoc_insertion_point(field_get:opencv_onnx.FunctionProto.overload)
return _internal_overload();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void FunctionProto::set_overload(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000008u;
overload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:opencv_onnx.FunctionProto.overload)
}
inline std::string* FunctionProto::mutable_overload() {
std::string* _s = _internal_mutable_overload();
// @@protoc_insertion_point(field_mutable:opencv_onnx.FunctionProto.overload)
return _s;
}
inline const std::string& FunctionProto::_internal_overload() const {
return overload_.Get();
}
inline void FunctionProto::_internal_set_overload(const std::string& value) {
_has_bits_[0] |= 0x00000008u;
overload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* FunctionProto::_internal_mutable_overload() {
_has_bits_[0] |= 0x00000008u;
return overload_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* FunctionProto::release_overload() {
// @@protoc_insertion_point(field_release:opencv_onnx.FunctionProto.overload)
if (!_internal_has_overload()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000008u;
auto* p = overload_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (overload_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
overload_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void FunctionProto::set_allocated_overload(std::string* overload) {
if (overload != nullptr) {
_has_bits_[0] |= 0x00000008u;
} else {
_has_bits_[0] &= ~0x00000008u;
}
overload_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), overload,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (overload_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
overload_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.FunctionProto.overload)
}
// repeated .opencv_onnx.ValueInfoProto value_info = 12;
inline int FunctionProto::_internal_value_info_size() const {
return value_info_.size();
}
inline int FunctionProto::value_info_size() const {
return _internal_value_info_size();
}
inline void FunctionProto::clear_value_info() {
value_info_.Clear();
}
inline ::opencv_onnx::ValueInfoProto* FunctionProto::mutable_value_info(int index) {
// @@protoc_insertion_point(field_mutable:opencv_onnx.FunctionProto.value_info)
return value_info_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::ValueInfoProto >*
FunctionProto::mutable_value_info() {
// @@protoc_insertion_point(field_mutable_list:opencv_onnx.FunctionProto.value_info)
return &value_info_;
}
inline const ::opencv_onnx::ValueInfoProto& FunctionProto::_internal_value_info(int index) const {
return value_info_.Get(index);
}
inline const ::opencv_onnx::ValueInfoProto& FunctionProto::value_info(int index) const {
// @@protoc_insertion_point(field_get:opencv_onnx.FunctionProto.value_info)
return _internal_value_info(index);
}
inline ::opencv_onnx::ValueInfoProto* FunctionProto::_internal_add_value_info() {
return value_info_.Add();
}
inline ::opencv_onnx::ValueInfoProto* FunctionProto::add_value_info() {
::opencv_onnx::ValueInfoProto* _add = _internal_add_value_info();
// @@protoc_insertion_point(field_add:opencv_onnx.FunctionProto.value_info)
return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::ValueInfoProto >&
FunctionProto::value_info() const {
// @@protoc_insertion_point(field_list:opencv_onnx.FunctionProto.value_info)
return value_info_;
}
// repeated .opencv_onnx.StringStringEntryProto metadata_props = 14;
inline int FunctionProto::_internal_metadata_props_size() const {
return metadata_props_.size();
}
inline int FunctionProto::metadata_props_size() const {
return _internal_metadata_props_size();
}
inline void FunctionProto::clear_metadata_props() {
metadata_props_.Clear();
}
inline ::opencv_onnx::StringStringEntryProto* FunctionProto::mutable_metadata_props(int index) {
// @@protoc_insertion_point(field_mutable:opencv_onnx.FunctionProto.metadata_props)
return metadata_props_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::StringStringEntryProto >*
FunctionProto::mutable_metadata_props() {
// @@protoc_insertion_point(field_mutable_list:opencv_onnx.FunctionProto.metadata_props)
return &metadata_props_;
}
inline const ::opencv_onnx::StringStringEntryProto& FunctionProto::_internal_metadata_props(int index) const {
return metadata_props_.Get(index);
}
inline const ::opencv_onnx::StringStringEntryProto& FunctionProto::metadata_props(int index) const {
// @@protoc_insertion_point(field_get:opencv_onnx.FunctionProto.metadata_props)
return _internal_metadata_props(index);
}
inline ::opencv_onnx::StringStringEntryProto* FunctionProto::_internal_add_metadata_props() {
return metadata_props_.Add();
}
inline ::opencv_onnx::StringStringEntryProto* FunctionProto::add_metadata_props() {
::opencv_onnx::StringStringEntryProto* _add = _internal_add_metadata_props();
// @@protoc_insertion_point(field_add:opencv_onnx.FunctionProto.metadata_props)
return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::StringStringEntryProto >&
FunctionProto::metadata_props() const {
// @@protoc_insertion_point(field_list:opencv_onnx.FunctionProto.metadata_props)
return metadata_props_;
}
#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif // __GNUC__
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// @@protoc_insertion_point(namespace_scope)
} // namespace opencv_onnx
PROTOBUF_NAMESPACE_OPEN
template <> struct is_proto_enum< ::opencv_onnx::AttributeProto_AttributeType> : ::std::true_type {};
template <> struct is_proto_enum< ::opencv_onnx::TensorProto_DataType> : ::std::true_type {};
template <> struct is_proto_enum< ::opencv_onnx::TensorProto_DataLocation> : ::std::true_type {};
template <> struct is_proto_enum< ::opencv_onnx::Version> : ::std::true_type {};
template <> struct is_proto_enum< ::opencv_onnx::OperatorStatus> : ::std::true_type {};
PROTOBUF_NAMESPACE_CLOSE
// @@protoc_insertion_point(global_scope)
#include <google/protobuf/port_undef.inc>
#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_opencv_2donnx_2eproto
View Git Blame Copy Permalink